Python Notes

>>> 0.4 - 0.1
0.30000000000000004
>>> 0.4 - 0.1 == 0.3
False
>>> abs(0.4 - 0.1 - 0.3) < 1e-6  # or math.isclose(a, b)
True

>>> from fractions import Fraction
>>> from decimal import Decimal
>>> x = Fraction(3, 5)  # 分数
>>> x.numerator  # 查看分子
3
>>> x.denominator  # 查看分母
5
>>> y = Decimal(1/9)  # 高精度实数

>>> 'Hello World'.encode('utf-8')
b'Hello World'
>>> b'Hello World'.decode('utf-8')
'Hello World'

import keyword
print(keyword.kwlist)  # 查看关键字

>>> bin(10)
'0b1010'  # 0b开头表示二进制数，同理0o、0x开头表示八、十六进制数

with open('output.txt', 'w') as f:
	print("Hello, world!", file=f)  # 将内容写入到 output.txt 文件中

>>> for index, value in enumerate(range(10, 15)):
	print((index, value), end=' ')
(0, 10) (1, 11) (2, 12) (3, 13) (4, 14)

>>> list(zip('abcd', [1, 2, 3]))
[('a', 1), ('b', 2), ('c', 3)]

>>> list(map(str, range(5)))
['0', '1', '2', '3', '4']

>>> from functools import reduce
>>> from operator import add, sub, mul, truediv, floordiv, mod, pow
>>> seq = list(range(1, 10))
>>> reduce(add, seq)
45

>>> x = [1, 2, [3, 4]]
>>> y = x.copy()  # 浅复制
>>> y
[1, 2, [3, 4]]
>>> y[2].append(5)  # 对可变的数据进行修改
>>> y
[1, 2, [3, 4, 5]]
>>> x
[1, 2, [3, 4, 5]]  # 由于浅复制，原列表也会改变
>>> y.append(6)  # 对可变的数据进行修改
>>> y
[1, 2, [3, 4, 5], 6]
>>> x
[1, 2, [3, 4, 5]]  # 不可变的数据不受影响

>>> x = [1, 2, 3]
>>> y = [4, 5]
>>> id(x)
2832802183680
>>> id(y)
2832798807040
>>> x += y
>>> x
[1, 2, 3, 4, 5]
>>> id(x)  # 内存地址不变
2832802183680
>>> x *= 2
>>> x
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
>>> id(x)  # 内存地址不变
2832802183680
>>> 5 in x
True

[expression for variable1 in sequence1 if condition1
			for variable2 in sequence2 if condition2
			for variableN in sequenceN if conditionN]

aList = [x * x for x in range(10)]
# 等价于
aList = []
for x in range(10):
	aList.append(x * x)

>>> vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
# 也可以使用 itertools 库中的 chain() 函数
>>> from itertools import chain
>>> list(chain(*vec))  # *vec 使用序列解包，将 vec 中的所有子列表作为单独的参数传递给 chain()
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> import os
>>> [filename for filename in os.listdir('E:\\') if filename.endswith((.png', '.jpg', '.gif'))]
['logo.png']

>>> [(x, y) for x in [1, 2, 3] if x > 1 for y in [3, 4, 5] if x != y]
[(2, 3), (2, 4), (2, 5), (3, 4), (3, 5)]

>>> matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
# 也可以使用 zip() 和 list() 来实现
>>> list(map(list, zip(*matrix)))
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

>>> x = [1, 2, 3, 4, 5]
>>> x[::]  # 返回包含原列表中所有元素的新列表
[1, 2, 3, 4, 5]
>>> x[:]  # step 为 1 时，可以省略第二个冒号
[1, 2, 3, 4, 5]
>>> x[::-1]  # 返回包含原列表中所有元素的逆序列表
[5, 4, 3, 2, 1]
>>> x[::2]  # 改变步长，隔一个取一个
[1, 3, 5]
>>> x[1:3]  # 指定切片开始和结束的索引，左闭右开区间
[2, 3]
>>> x[3:1:-1]  # 步长为负整数时，从右侧（索引值大）向左侧（索引值小）挨个选取
[4, 3]
>>> x[0:100]  # 切片结束索引大于列表长度，直接从尾部截断，不抛出异常
[1, 2, 3, 4, 5]
>>> x[100:]  # 切片开始索引大于列表长度，返回空列表
[]

>>> x = [1, 2, 3, 4, 5]  # 延续上一节
>>> x[:0] = [6]  # 相当于 x[0:0]，start 默认为 0 可以省略
>>> x
[6, 1, 2, 3, 4, 5]
>>> x[1:1] = ['1']
>>> x
[6, '1', 1, 2, 3, 4, 5]
>>> x[len(x):] = ['last']  # 同理，stop 默认为列表长度可以省略
>>> x
[6, '1', 1, 2, 3, 4, 5, 'last']
>>> x[1:1] = ['dreamless', 'drugs']  # 也可以一次性添加多个元素
>>> x
[6, 'dreamless', 'drugs', '1', 1, 2, 3, 4, 5, 'last']

>>> x = [6, 'dreamless', 'drugs', '1', 1, 2, 3, 4, 5, 'last']  # 延续上一节
>>> x[3:6] = ['a', 'b', 'c']  # 替换列表元素，等号两边列表的长度相等
>>> x
[6, 'dreamless', 'drugs', 'a', 'b', 'c', 3, 4, 5, 'last']
>>> x[9:] = [6, 7, 8]  # 切片是连续的，等号两边列表的长度可以不相等
>>> x
[6, 'dreamless', 'drugs', 'a', 'b', 'c', 3, 4, 5, 6, 7, 8]
>>> x[::2] = [1]  # 切片不连续（step = 2），等号两边列表的长度必须相等
ValueError: attempt to assign sequence of size 1 to extended slice of size 6
>>> x[::2] = range(6)
>>> x
[0, 'dreamless', 1, 'a', 2, 'c', 3, 4, 4, 6, 5, 8]

>>> x = [0, 'dreamless', 1, 'a', 2, 'c', 3, 4, 4, 6, 5, 8]  # 延续上一节
>>> x[:3] = []  # 删除列表中前三个元素
>>> x
['a', 2, 'c', 3, 4, 4, 6, 5, 8]
>>> del x[5:]  # 切片连续时 del 生效
>>> x
['a', 2, 'c', 3, 4]
>>> x[::2] = []  # 切片不连续时赋值空列表的方法失效
ValueError: attempt to assign sequence of size 0 to extended slice of size 3
>>> del x[::2]  # 切片不连续时 del 生效
>>> x
[2, 3]

>>> x = [1, 3, 5]
>>> y = x[::]  # 切片，浅复制
>>> x == y  # 两个列表的值相等
True
>>> x is y  # 两个列表并不是同一个对象
False
>>> id(x) == id(y)  # 两个列表对象的内存地址（值的引用）不相等
False
>>> id(x[0]) == id(y[0])  # 但是相同的值在内存中只有一份
True

>>> g = ((i + 2) ** 2 for i in range(10))  # 创建生成器对象
>>> g
<generator object <genexpr> at 0x00000293920A5890>
>>> tuple(g)  # 将生成器对象转换为元组
(4, 9, 16, 25, 36, 49, 64, 81, 100, 121)
>>> list(g)  # 生成器对象已遍历结束，没有元素了
[]
>>> g = ((i + 2) ** 2 for i in range(10))  # 重新创建生成器对象
>>> g.__next__()  # 使用生成器对象的 __next__() 方法来获取元素
4
>>> g.__next__()
9
>>> next(g)  # 使用内置函数 next() 来获取元素
16
>>> x = map(str, range(10))
>>> x
<map object at 0x00000293925182B0>
>>> next(x)
'0'
>>> '0' in x  # 访问过的元素无法再次访问
False
>>> '1' in x  # 未访问的元素
True

>>> hash((1,))
-6644214454873602895
>>> hash([1])
TypeError: unhashable type: 'list'

>>> x = {'a': 0, 'b': 1, 'c': 2}
>>> x['a']
0
>>> x['d']
KeyError: 'd'
>>> x.get('a')
0
>>> x.get('d', 'Not Exists.')
'Not Exists.'
>>> x.setdefault('d', 3)
3
>>> x
{'a': 0, 'b': 1, 'c': 2, 'd': 3}

>>> x = {'a': 0, 'b': 1, 'c': 2}
>>> x['a'] = 'a'  # 指定的键存在
>>> x
{'a': 'a', 'b': 1, 'c': 2}
>>> x['d'] = 3  # 指定的键不存在
>>> x
{'a': 'a', 'b': 1, 'c': 2, 'd': 3}

>>> x = {'a': 0, 'b': 1, 'c': 2}
>>> x.update({'a': 123, 'd': 3})
>>> x
{'a': 123, 'b': 1, 'c': 2, 'd': 3}

>>> x = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4}
>>> x.popitem()
('e', 4)
>>> x
{'a': 0, 'b': 1, 'c': 2, 'd': 3}
>>> x.pop('a')
0
>>> x
{'b': 1, 'c': 2, 'd': 3}
>>> x.clear()
>>> x
{}

>>> x = {1, 2, 3, 4, 5}
>>> x.add(6)
>>> x
{1, 2, 3, 4, 5, 6}
>>> x.update({1, 2, 7})
>>> x
{1, 2, 3, 4, 5, 6, 7}
>>> x.pop()
1
>>> x.pop()
2
>>> x
{3, 4, 5, 6, 7}
>>> x.remove(1)
KeyError: 1
>>> x.discard(1)
>>> x
{3, 4, 5, 6, 7}
>>> x.clear()
>>> x
set()

>>> a_set = {1, 2, 3, 4, 5}
>>> b_set = {3, 4, 5, 6, 7}
>>> a_set | b_set  # 并集
{1, 2, 3, 4, 5, 6, 7}
>>> a_set.union(b_set)
{1, 2, 3, 4, 5, 6, 7}
>>> a_set & b_set  # 交集
{3, 4, 5}
>>> a_set.intersection(b_set)
{3, 4, 5}
>>> a_set - b_set  # 差集（A - B 返回包含在集合 A 中但不包含在集合 B 中的所有元素）
{1, 2}
>>> a_set.difference(b_set)
{1, 2}
>>> a_set ^ b_set  # 对称差集（A 的差集与 B 的差集的并集，即 (A - B) | (B - A)）
{1, 2, 6, 7}
>>> a_set.symmetric_difference(b_set)
{1, 2, 6, 7}
>>> x = {1, 2}
>>> y = {1, 2, 3}
>>> z = {4, 5, 6}
>>> x < y  # 子集
True
>>> x.issubset(y)
True
>>> y > x
True
>>> y.issuperset(x)
True
>>> y.isdisjoint(z)  # 测试交集是否为空
True

>>> x, y, z = 1, 2, 'a'  # 多个变量同时赋值
>>> x
1
>>> y
2
>>> z
'a'
>>> x, y = y, x  # 交换两个变量的值
>>> x
2
>>> y
1
>>> print(*[1, 2, 3], 4, *(5, 6))  # * 表示可迭代对象的序列解包
1 2 3 4 5 6
>>> print([1, 2, 3], 4, (5, 6))
[1, 2, 3] 4 (5, 6)

>>> path = 'C:\Windows\notepad.exe'
>>> print(path)
C:\Windows
otepad.exe
>>> path = r'C:\Windows\notepad.exe'
>>> print(path)
C:\Windows\notepad.exe

>>> a = 'Leon'
>>> b = 'Hello, %-10s' % a
>>> b
'Hello, Leon      '

>>> a = 1234
>>> b = '%+d' % a
>>> b
'+1234'

>>> a = 7
>>> b = '%03d' % a
>>> b
'007'

>>> a = 'Leon'
>>> b = 'Hello, %10s' % a
>>> b
'Hello,       Leon'

>>> a = 1234
>>> b = '%.2f' % a
>>> b
'1234.00'

# 使用数字表示索引
>>> print("0: {0:.4s}, 1: {1:.4s}".format('dreamless', 'drugs'))
0: drea, 1: drug

# 使用关键字参数和属性（ arg_name.attr_name ）
>>> class Person:
	def __init__(self, name, age):
		self.name = name
		self.age = age

>>> person = Person("Leon", 22)
>>> msg = "My name is {person.name}, and I am {person.age} years old.".format(person=person)
>>> print(msg)
My name is Leon, and I am 22 years old.

>>> print("{:*^20}".format("PYTHON"))  # 填充字符为 * 并居中对齐
*******PYTHON*******

>>> print("{:=+10}".format(22))  # 将填充字符（空格）放在正号与数字之间
+       22

>>> print("{:#b}".format(22))
0b10110

>>> print("{:_}".format(5000000))
5_000_000

>>> print("{:.2f}".format(3.1415926))
3.14
>>> print("{:.3s}".format('ecust'))
ecu

# 变量名 / 方法调用
>>> name = "Leon"
>>> f"{name}"
>>> f"{name.upper()}"

# 算术表达式
>>> x = 10
>>> y = 20
>>> f"{x + y}"

# 列表和字典访问
>>> numbers = [10, 20, 30]
>>> info = {'name': 'Leon', 'age': 22}
>>> f"{numbers[1]}, {info['name']}"

# 调用函数
>>> def greet(name):
	return f"Hello, {name}!"

>>> name = "Leon"
>>> f"{greet(name)}"

# 条件表达式（三元运算符）
>>> x = 5
>>> f"{x if x > 10 else 'x is less than or equal to 10'}"

# 访问对象属性
>>> class Person:
	def __init__(self, name, age):
		self.name = name
		self.age = age

>>> person = Person("Leon", 22)
>>> f"My name is {person.name}, and I am {person.age} years old."

>>> s = 'apple, peach, banana, peach, pear'
>>> s.find('p')
1
>>> s.find('p', 5, 10)
7

>>> s = 'apple, peach, banana, peach, pear'
>>> s.split(',')
['apple', ' peach', ' banana', ' peach', ' pear']
>>> s.split('e')
['appl', ', p', 'ach, banana, p', 'ach, p', 'ar']

>>> li = ['apple', 'peach', 'banana', 'pear']
>>> ' '.join(li)  # 以空格作为连接符
'apple peach banana pear'
>>> ','.join(li)
'apple,peach,banana,pear'  # 以逗号作为连接符

>>> s = 'aaa     bb   c d eee  '
>>> ' '.join(s.split())
'aaa bb c d eee'

>>> s = 'What is Your Name?'
>>> s.lower()
'what is your name?'
>>> s.upper()
'WHAT IS YOUR NAME?'
>>> s.capitalize()
'What is your name?'
>>> s.title()
'What Is Your Name?'
>>> s.swapcase()
'wHAT IS yOUR nAME?'

>>> s = 'a, b, c, a, a, d'
>>> s.replace('a', '123')
'123, b, c, 123, 123, d'
>>> s.replace('a', '123', 1)
'123, b, c, a, a, d'

>>> s = 'My favorite color is purple.'
>>> table = ''.maketrans('abcdefghij', '0123456789')  # 创建转换表，也可以用 str.maketrans()
>>> s.translate(table)
'My 50vor8t4 2olor 8s purpl4.'
>>> table = str.maketrans('abcdefghij', '0123456789', 'l')
>>> s.translate(table)
'My 50vor8t4 2oor 8s purp4.'

>>> s = '  12345 \n\n'
>>> s.strip()
'12345'
>>> s = 'aaahelloworlddddaa'
>>> s.strip('a')
'helloworldddd'
>>> s.strip('ad')  # 删除 'a' 和 'd'
'helloworl'

>>> import os
>>> [filename for filename in os.listdir('E:\\') if filename.endswith((.png', '.jpg', '.gif'))]
['logo.png']

>>> 'e' in 'Dreamless Drugs'
True

>>> "\t\n\r".isspace()
True

>>> s = 'Dreamless Drugs'
>>> s.center(20)
'  Dreamless Drugs   '  # 默认以空格填充
>>> s.center(20, '=')
'==Dreamless Drugs==='
>>> s.ljust(20, '=')
'Dreamless Drugs====='
>>> s.rjust(20, '=')
'=====Dreamless Drugs'
>>> s.zfill(20)
'00000Dreamless Drugs'

>>> s = 'Dreamless Drugs'
>>> s[:5]
'Dream'

>>> x = input()
[1, 3, 5, 7, 9]
>>> x
'[1, 3, 5, 7, 9]'
>>> eval(x)
[1, 3, 5, 7, 9]
>>> import ast
>>> ast.literal_eval(x)  # 更推荐
[1, 3, 5, 7, 9]

>>> import re
>>> text = re.search(r'hello', 'Say hello!')  # search() 在整个字符串中匹配
>>> text.group()
'hello'
>>> text = re.match(r'hello', 'Say hello!')  # match() 从字符串的开头匹配，匹配失败
>>> text.group()
AttributeError: 'NoneType' object has no attribute 'group'
>>> text = re.match(r'hello', 'hello Say hello!')  # match() 匹配成功
>>> text.group()
'hello'

>>> import re
>>> text = re.fullmatch(r'\d+', '12345')  # 确保整个字符串都由数字 [0-9] 构成
>>> if text:
	print('The string is made of digits.')
else:
	print('The string has non-digit characters.')
The string is made of digits.

>>> import re
>>> re.split(r'\W+', 'Words, words, ws.')  # 最后一个匹配项是 '.'，但是在 '.' 之后字符串没有内容，因此返回的最后一项为空字符串
['Words', 'words', 'ws', '']
>>> re.split(r'(\W+)', 'Words, words, ws.')  # 正则表达式使用了 ()，分隔符也被返回
['Words', ', ', 'words', ', ', 'ws', '.', '']
>>> re.split(r'\W+', 'Words, words, ws.', maxsplit=1)  # 指定最大分隔次数为 1，字符串的剩余部分以一个整体作为最后一项返回
['Words', 'words, ws.']

>>> import re
>>> text = 'Emails: example1@gmail.com, example2@163.com'
>>> re.findall(r'(\w+)@(\w+)\.(\w+)', text)  # 多个捕获组，返回元组列表
[('example1', 'gmail', 'com'), ('example2', '163', 'com')]

>>> import re
>>> text = 'The rain in Spain falls mainly in the plain.'
>>> matches = re.finditer(r'\b\w+ain\b', text)
>>> for match in matches:  # 获取每个匹配项的内容
	print(match.group(), end=' ')
rain Spain plain 

# 注意！迭代器 matches 的元素只能访问一次
>>> for match in matches:  # 获取每个匹配项的起始和结束位置
	print(f'Match: {match.group()}, Start: {match.start()}, End: {match.end()}')
Match: rain, Start: 4, End: 8
Match: Spain, Start: 12, End: 17
Match: plain, Start: 38, End: 43

>>> import re
>>> text = re.sub(r'drugs', 'clouds', 'Dreamless drugs are the best drugs ever.')
>>> text
'Dreamless clouds are the best clouds ever.'
>>> text = re.sub(r'drugs', 'clouds', 'Dreamless drugs are the best drugs ever.', count=1)  # 指定最大替换次数
>>> text
'Dreamless clouds are the best drugs ever.'
>>> def upper_func(match):  # 接收匹配的 Match 对象为参数
	return match.group(0).upper()

>>> text = re.sub(r'\b[a-z]+\b', upper_func, 'hello world')  # repl 为函数
>>> text
'HELLO WORLD'

>>> import re
>>> text = re.subn(r'drugs', 'clouds', 'Dreamless drugs are the best drugs ever.')
>>> text
('Dreamless clouds are the best clouds ever.', 2)

>>> import re
>>> re.escape('http://www.python.org')
'http://www\\.python\\.org'  # 双反斜杠 \\ 表示一个字面的反斜杠 \，然后 \. 表示字面的 .，因此 \\. 才能匹配 .

>>> import re
>>> text = 'Dreamless drugs are the best drugs ever.'
>>> p = re.compile(r'drugs')
>>> p.search(text)
<re.Match object; span=(10, 15), match='drugs'>
>>> p.search(text, 20)  # 设定搜索从 20 开始
<re.Match object; span=(29, 34), match='drugs'>

>>> import re
>>> text = 'Dreamless drugs are the best drugs ever.'
>>> p = re.compile(r'drugs')
>>> print(p.match(text))  # 无匹配返回 None
None
>>> p.match(text, 10)
<re.Match object; span=(10, 15), match='drugs'>

>>> import re
>>> m = re.match(r'(\w+) (\w+)', 'Dreamless Drugs, harmless')
>>> m.group()  # 返回整个模式内容
'Dreamless Drugs'
>>> m.group(1)  # 返回第一个子模式内容
'Dreamless'
>>> m.group(2)  # 返回第二个子模式内容
'Drugs'
>>> m.group(1, 2)  # 以元组形式返回指定的多个子模式内容
('Dreamless', 'Drugs')
>>> m.groups()  # 以元组形式返回所有匹配的子模式内容
('Dreamless', 'Drugs')

>>> m = re.match(r'(?P<first_name>\w+) (?P<last_name>\w+)', 'Melanie C')
>>> m.group('first_name')  # 使用命名的子模式
'Melanie'
>>> m.group('last_name')
'C'
>>> m.groupdict()
{'first_name': 'Melanie', 'last_name': 'C'}

>>> import re
>>> m = re.match(r'(\w+) (\w+)', 'Dreamless Drugs, harmless')
>>> m.start()
0
>>> m.end()
15
>>> m.span()  # 整个匹配的子字符串
(0, 15)
>>> m.span(1)  # 第一个捕获组匹配的子字符串
(0, 9)
>>> m.span(2)  # 第二个捕获组匹配的子字符串
(10, 15)

>>> import re
>>> m = re.match(r'(\w+) (\w+)', 'Dreamless Drugs, harmless')
>>> m.group()  # 查看匹配结果
'Dreamless Drugs'
>>> m.expand(r'\2 \1')  # 使用 \number 引用捕获组进行替换
'Drugs Dreamless'

>>> m = re.match(r'(?P<first_name>\w+) (?P<last_name>\w+)', 'Melanie C')
>>> m.group()  # 查看匹配结果
'Melanie C'
>>> m.expand(r'\g<last_name> \g<first_name>')  # 使用捕获组名来引用捕获组进行替换
'C Melanie'

if expression:
	# 语句块

if expression:
	# 语句块 1
else:
	# 语句块 2

if expression1:
	# 语句块 1
elif expression2:
	# 语句块 2
elif expression3:
	# 语句块 3
else:
	# 语句块 n

if expression1:
	# 语句块 1
	if expression2:
		# 语句块 2
	else:
		# 语句块 3
else:
	if expression4:
		# 语句块 4

# for 循环
for variable in sequence:
	# 循环体
[else:
	# 代码块]
	
# while 循环
while condition:
	# 循环体
[else:
	# 代码块]

import math  # 或者使用 from math import sin[ as loc_sin]，效果一样
for i in range(1000000):
	math.sin(i)
	
loc_sin = math.sin  # 将 math.sin 转换为局部变量
for i in range(1000000):
	loc_sin(i)

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- StopAsyncIteration
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- AssertionError
      +-- AttributeError
      +-- BufferError
      +-- EOFError
      +-- ImportError
      |    +-- ModuleNotFoundError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- MemoryError
      +-- NameError
      |    +-- UnboundLocalError
      +-- OSError
      |    +-- BlockingIOError
      |    +-- ChildProcessError
      |    +-- ConnectionError
      |    |    +-- BrokenPipeError
      |    |    +-- ConnectionAbortedError
      |    |    +-- ConnectionRefusedError
      |    |    +-- ConnectionResetError
      |    +-- FileExistsError
      |    +-- FileNotFoundError
      |    +-- InterruptedError
      |    +-- IsADirectoryError
      |    +-- NotADirectoryError
      |    +-- PermissionError
      |    +-- ProcessLookupError
      |    +-- TimeoutError
      +-- ReferenceError
      +-- RuntimeError
      |    +-- NotImplementedError
      |    +-- RecursionError
      +-- SyntaxError
      |    +-- IndentationError
      |         +-- TabError
      +-- SystemError
      +-- TypeError
      +-- ValueError
      |    +-- UnicodeError
      |         +-- UnicodeDecodeError
      |         +-- UnicodeEncodeError
      |         +-- UnicodeTranslateError
      +-- Warning
           +-- DeprecationWarning
           +-- PendingDeprecationWarning
           +-- RuntimeWarning
           +-- SyntaxWarning
           +-- UserWarning
           +-- FutureWarning
           +-- ImportWarning
           +-- UnicodeWarning
           +-- BytesWarning
           +-- ResourceWarning

try:
	# 可能会引发异常的代码
except ExceptionType[ as e]:
	# 如果 try 中的代码出现异常并被 except 捕获，执行此处的代码

try:
	# 可能会引发异常的代码
except ExceptionType[ as e]:
	# 如果 try 中的代码出现异常并被 except 捕获，执行此处的代码
else:
	# 如果 try 中的代码没有出现异常，就继续执行此处的代码

try:
	# 可能会引发异常的代码
except ExceptionType[ as e]:
	# 如果 try 中的代码出现异常并被 except 捕获，执行此处的代码
else:
	# 也可以结合 else 子句
finally:
	# 无论如何此处的代码都会被执行

try:
	# 可能会引发异常的代码
except ExceptionType1:
	# 处理异常类型 1 的代码
except ExceptionType2:
	# 处理异常类型 2 的代码
except ExceptionType3:
	# 处理异常类型 3 的代码

def 函数名([参数列表]):
	'''注释'''
	函数体

# 定义装饰器 before
def before(func):
def wrapper(*args, **kwargs):
	print('Before function called.')
	return func(*args, **kwargs)
return wrapper

# 使用 before 装饰器修饰函数
@before
def test():
	return 3

# 调用函数
test()

# 运行结果
Before function called.
3

# 定义一个计算阶乘的递归函数
def factorial(n):
	if n == 0:
		return 1  # 0 的阶乘为 1
	else:
		return n * factorial(n - 1)  # n 的阶乘为 n 乘 (n-1) 的阶乘

>>> def student(name, gender, age):
	return (name, gender, age)

>>> student('Leon', 'male', 22)
('Leon', 'male', 22)
>>> student()
TypeError: student() missing 3 required positional arguments: 'name', 'gender', and 'age'

>>> def student(name, gender, age, s_id='1901'):
	return (name, gender, age, s_id)

>>> student.__defaults__
('1901',)

>>> def demo(item, li=[]):  # 默认参数为可变类型
	li.append(item)
	return li

>>> demo(5, [1, 2, 3, 4])
[1, 2, 3, 4, 5]
>>> demo('d', ['a', 'b', 'c'])  # 为默认参数传递了值，所以每次调用函数都会初始化
['a', 'b', 'c', 'd']
>>> demo('a')
['a']
>>> demo('b')  # 没有为默认参数传递值，所以这一次调用函数时默认参数没有初始化，即返回的列表还是上一次的列表，因此结果不是想要的 ['b']，而是 ['a', 'b']
['a', 'b']

# 对上述 demo() 函数的改进，不使用可变序列作为函数参数的默认值
>>> def demo(item, li=None):
	if li is None:  # 如果 li 为 None，则 li 赋值为空列表；如果 li 不为 None，则 item 会添加到现有的列表 li 中
		li = []
	li.append(item)
	return li

>>> i = 3
>>> def demo(n=i):  # 默认参数 n 的值取决于变量 i 的当前值
	return n

>>> demo()
3
>>> i = 5
>>> demo()  # 函数定义后再改变 i 的值不影响参数 n 的默认值
3
>>> def demo(n=i):  # 重新定义函数
	return n

>>> demo()
5

>>> def student(name, gender, age, s_id='1901'):
	return (name, gender, age, s_id)

>>> student(name='Leon', gender='male', age=22)  # 按照关键字参数来传递参数的值
('Leon', 'male', 22, '1901')

>>> def demo(*args):
	return args

>>> demo(1, 2, 3)  # 接收多个位置参数并放在元组中
(1, 2, 3)

>>> def demo(**kwargs):  # 接收多个关键字参数并放在字典中
	return kwargs

>>> demo(x=1, y=2, z=3)
{'x': 1, 'y': 2, 'z': 3}

>>> def student(name, gender, age):
	return f'{name} is {age} years old, and {name} is {gender}.'

>>> leon = ['Leon', 'male', 22]
>>> student(*leon)  # 对列表进行解包
'Leon is 22 years old, and Leon is male.'

>>> leon = ('Leon', 'male', 22)
>>> student(*leon)  # 对元组进行解包
'Leon is 22 years old, and Leon is male.'

>>> leon = {'name': 'Leon', 'gender': 'male', 'age': 22}
>>> student(*leon)  # 一个星号默认对字典的键进行解包
'name is age years old, and name is gender.'
>>> student(*leon.values())  # 对字典的值进行解包
'Leon is 22 years old, and Leon is male.'
>>> student(**leon)  # 对字典的元素进行解包
'Leon is 22 years old, and Leon is male.'

>>> def demo(a, b, c):
	return (a, b, c)

>>> demo(*(1, 2, 3))  # 正常序列解包
(1, 2, 3)
>>> demo(a=1, *(2, 3))  # 优先处理使用一个星号的序列解包（2 -> a，3 -> b），再处理关键字参数（1 -> a），所以会报错
TypeError: demo() got multiple values for argument 'a'
>>> demo(c=1, *(2, 3))  # 正常序列解包
(2, 3, 1)

>>> def demo():
	global x  # 声明全局变量 x
	x = 3  # 全局变量
	y = 4  # 局部变量
	return (x, y)

>>> x = 5  # 在函数外定义全局变量 x
>>> x
5
>>> demo()  # 调用函数修改了全局变量 x 的值
(3, 4)
>>> x
3
>>> y  # 局部变量 y 在函数执行之后自动删除
NameError: name 'y' is not defined
>>> del x  # 删除全局变量 x
>>> x
NameError: name 'x' is not defined
>>> demo()  # 此次调用函数创建了全局变量 x
(3, 4)
>>> x
3

# 基本语法
lambda arguments: expression

# 等价于
def func(arguments):
	expression

# 也可以给 lambda 表达式起个名字
>>> f = lambda x, y, z: x + y + z
>>> f(3, 4, 5)
12

# 也支持默认参数
>>> g = lambda x, y=4, z=5: x + y + z
>>> g(1)
10
>>> g(1, z=3, y=2)  # 调用时使用关键字参数
6

# 定义函数生成斐波那契数列
>>> def f():
	a, b = 1, 1
	while True:
		yield a  # 暂停执行，需要时再产生一个新元素
		a, b = b, a+b

>>> x = f()  # 创建生成器对象
>>> x
<generator object f at 0x00000293920A5890>
>>> for i in range(10):
	print(next(x), end=' ')
	
1 1 2 3 5 8 13 21 34 55

>>> class Car(object):
	def infor(self):
		return 'infor'

>>> car = Car()
>>> car.infor()
'infor'

>>> isinstance(car, Car)
True
>>> type(car)
<class '__main__.Car'>  # __main__ 表示 Car 类的来源为主程序，即 car 对象是主程序中 Car 类的实例

# 如果是用 from test import Car 导入Car类
>>> type(car)
<class 'test.Car'>

>>> class Student:
	address = 'ECUST'  # 类的数据成员
	
	def __init__(self, name):
		self.name = name  # 对象的数据成员

>>> s = Student('Leon')
>>> s.address  # 类的数据成员通过对象名访问
'ECUST'
>>> s.name  # 对象的数据成员通过对象名访问
'Leon'
>>> Student.address  # 类的数据成员通过类名访问
'ECUST'
>>> Student.name  # 对象的数据成员无法通过类名访问
AttributeError: type object 'Student' has no attribute 'name'

class Student:
	address = 'ECUST'

	def __init__(self, name='Leon', age=22):  # __init__() 是私有方法，当然也属于特殊方法
		self.s_id = None  # 这里在 self 后的 s_id、name 和 __age 是数据成员，前两者是公有成员可以外部访问，后者是私有成员  
		self.name = name
		self.__age = age

	def set_id(self, s_id):  # set_id() 是公有方法
		self.s_id = s_id
		return s_id

	def show_age(self):
		return self.__age  # 在实例方法中可以访问私有成员
		
	@classmethod  # 使用装饰器声明类方法
	def class_show_address(cls):
		return cls.address  # 只能访问类的成员
		
	@staticmethod  # 使用装饰器声明静态方法
	def static_show_address():  # 可以没有参数
		return Student.address

from abc import ABCMeta, abstractmethod

class Foo(metaclass=ABCMeta):  # or ABC，定义抽象类
	def f1(self):  # 普通实例方法
		pass
		
	@abstractmethod  # 抽象方法
	def f2(self):
		raise Exception('You must reimplement this method.')
	
class Bar(Foo):
	def f2(self):  # 必须在子类中重新实现父类中的抽象方法
		pass