Python 3 备忘清单

Python 备忘单是 Python 3 编程语言的单页参考表

入门

介绍

Python 官方网站(python.org)
Python 文档(docs.python.org)
Y 分钟学会 Python(learnxinyminutes.com)
Python 中的正则表达式(jaywcjlove.github.io)

控制台打印

>>>print("Hello, World!")
Hello, World!

著名的“Hello World”程序在 Python 中的实现

变量

age=18# 年龄是 int 类型name="John"# 名字现在是 str 类型print(name)

Python 不能在没有赋值的情况下声明变量
变量可以存放不同类型的值

内置数据类型

序列指一批有序的元素，集合指一批无序且不重复的元素

:-	:-
`str`	文本／字符串（Text）
`int`, `float`, `complex`	数值（Numeric）
`dict`	映射／键值对（Mapping）
`list`, `tuple`, `range`	序列（Sequence）
`set`, `frozenset`	集合（Set）
`bool`	布尔值／逻辑值（Boolean）
`bytes`, `bytearray`, `memoryview`	二进制数据（Binary）

查看: 数据类型

字符串切片

>>>msg="Hello, World!">>>print(msg[2:5])
llo

查看: 字符串

列表

mylist= []
mylist.append(1)
mylist.append(2)
foriteminmylist:
print(item) # 打印输出 1,2

查看: 列表

判断

num=200ifnum>0:
print("num is greater than 0")
else:
print("num is not greater than 0")

查看: 判断

循环

foriteminrange(6):
ifitem==3: breakprint(item)
else:
print("Finally finished!")

查看: 循环

函数

>>>defmy_function():
... print("来自函数的你好")
...
>>>my_function()
来自函数的你好

查看: 函数

文件处理

withopen("myfile.txt", "r", encoding='utf8') asfile:
forlineinfile:
print(line)

查看: 文件处理

算术

result=10+30# => 40result=40-10# => 30result=50*5# => 250result=16/4# => 4.0 (Float Division)result=16//4# => 4 (Integer Division)result=25%2# => 1result=5**3# => 125

/ 表示 x 和 y 的商，// 表示 x 和 y 的底商，另见 StackOverflow

加等于

counter=0counter+=10# => 10counter=0counter=counter+10# => 10message="Part 1."# => Part 1.Part 2.message+="Part 2."

f-字符串 (Python 3.6+)

>>>website='Quick Reference'>>>f"Hello, {website}""Hello, Quick Reference">>>num=10>>>f'{num} + 10 = {num+10}''10 + 10 = 20'

查看: f-字符串

Python 数据类型

字符串

hello="Hello World"hello='Hello World'multi_string="""Multiline StringsLorem ipsum dolor sit amet,consectetur adipiscing elit """

查看: 字符串

数值

x=1# 整数y=2.8# 浮点小数z=1j# 复数>>>print(type(x))
<class'int'>

只要内存足够，可以容纳无限大(小)的数值

布尔值

my_bool=Truemy_bool=Falsebool(0) # => Falsebool(1) # => True

bool 是 int 的子类

列表

list1= ["apple", "banana", "cherry"]
list2= [True, False, False]
list3= [1, 5, 7, 9, 3]
list4=list((1, 5, 7, 9, 3))

查看: 列表

元组

my_tuple= (1, 2, 3)
my_tuple=tuple((1, 2, 3))

类似列表，但自身不可变

集合

set1= {"a", "b", "c"} set2=set(("a", "b", "c"))

类似列表，但里面的元素是无序而不重复的

字典

>>>empty_dict= {}
>>>a= {"one": 1, "two": 2, "three": 3}
>>>a["one"]
1>>>a.keys()
dict_keys(['one', 'two', 'three'])
>>>a.values()
dict_values([1, 2, 3])
>>>a.update({"four": 4})
>>>a.keys()
dict_keys(['one', 'two', 'three', 'four'])
>>>a['four']
4

键-值对，一种像 JSON 那样对象

类型转换

转换为整数

x=int(1) # 得到 1y=int(2.8) # 得到 2z=int("3") # 得到 3

转换为浮点数

x=float(1) # 得到 1.0y=float(2.8) # 得到 2.8z=float("3") # 得到 3.0w=float("4.2") # 得到 4.2

转换为字符串

x=str("s1") # 得到 "s1"y=str(2) # 得到 "2"z=str(3.0) # 得到 "3.0"

Python 字符串

下标访问

>>>hello="Hello, World">>>print(hello[1]) # 获取第二个字符e>>>print(hello[-1]) # 获取倒数第一个字符d>>>print(type(hello[-1])) # 得到的还是字符串<class'str'>

循环

>>>forcharin"foo":
... print(char)
foo

对字符串 for-in 可以得到每个字符（类型还是字符串）

切割字符串

 ┌───┬───┬───┬───┬───┬───┬───┐
| m | y | b | a | c | o | n |
└───┴───┴───┴───┴───┴───┴───┘
01234567
-7 -6 -5 -4 -3 -2 -1

>>>s='mybacon'>>>s[2:5]
'bac'>>>s[0:2]
'my'

>>>s='mybacon'>>>s[:2]
'my'>>>s[2:]
'bacon'>>>s[:2] +s[2:]
'mybacon'>>>s[:]
'mybacon'

>>>s='mybacon'>>>s[-5:-1]
'baco'>>>s[2:6]
'baco'

步长

>>>s='12345'*5>>>s'1234512345123451234512345'>>>s[::5]
'11111'>>>s[4::5]
'55555'>>>s[::-5]
'55555'>>>s[::-1]
'5432154321543215432154321'

获取长度

>>>hello="Hello, World!">>>print(len(hello))
13

len() 函数返回字符串的长度

重复多次

>>>s='===+'>>>n=8>>>s*n'===+===+===+===+===+===+===+===+'

存在性判断

>>>s='spam'>>>sin'I saw spamalot!'True>>>snotin'I saw The Holy Grail!'True

判断 "spam" 这个字符串是否在其它字符串里

字符串拼接

>>>s='spam'>>>t='egg'>>>s+t# 可以使用加号进行拼接'spamegg'>>>'spam''egg'# 两个字符串之间可以省略加号'spamegg'

格式化

name="John"print("Hello, %s!"%name)

name="John"age=23print("%s is %d years old."% (name, age))

format() 方法

txt1="My name is {fname}, I'm {age}".format(fname="John", age=36)
txt2="My name is {0}, I'm {1}".format("John", 36)
txt3="My name is {}, I'm {}".format("John", 36)

转义符号

转义符号	对应的操作
`\\`	输出反斜杠
`\'`	输出单引号
`\"`	输出双引号
`\n`	换行
`\t`	水平制表符
`\r`	光标回到首位
`\b`	退格

控制台输入

>>>name=input("Enter your name: ")
Enteryourname: Tom>>>name'Tom'

从控制台获取输入数据

头尾判断

>>># 是否以 H 开头>>>"Hello, world!".startswith("H")
True>>># 是否以 h 开头>>>"Hello, world!".startswith("h")
False>>># 是否以 ! 结尾>>>"Hello, world!".endswith("!")
True

插入分隔符拼接

>>>"、".join(["John", "Peter", "Vicky"])
'John、Peter、Vicky'

Python f-字符串 (Python 3.6+)

f-字符串用法

>>>website='Reference'>>>f"Hello, {website}""Hello, Reference">>>num=10>>>f'{num} + 10 = {num+10}''10 + 10 = 20'>>>f"""He said {"I'm John"}""""He said I'm John">>>f'5 {"{stars}"}''5 {stars}'>>>f'{{5}} {"stars"}''{5} stars'>>>name='Eric'>>>age=27>>>f"""Hello!... I'm {name}.... I'm {age}.""""Hello!\n I'm Eric.\n I'm 27."

它从 Python 3.6 开始可用，另见: 格式字符串字面值

填充对齐

>>>f'{"text":10}'# 使用空格填充到指定长度'text '>>>f'{"test":*>10}'# 向左填充'******test'>>>f'{"test":*<10}'# 向右填充'test******'>>>f'{"test":*^10}'# 居中填充'***test***'>>>f'{12345:0>10}'# 使用数字填充'0000012345'

按类型输出

>>>f'{10:b}'# 输出二进制数值'1010'>>>f'{10:o}'# 输出八进制数值'12'>>>f'{200:x}'# 输出十六进制数值'c8'>>>f'{200:X}''C8'>>>f'{345600000000:e}'# 科学计数法'3.456000e+11'>>>f'{65:c}'# 将整数转化为一个字符后输出'A'>>>f'{10:#b}'# [类型] 带符号（基础）'0b1010'>>>f'{10:#o}''0o12'>>>f'{10:#x}''0xa'

显示正负号

>>>f'{12345:+}'# 显示正数的正号'+12345'>>>f'{-12345:+}'# 显示负数的负号'-12345'>>>f'{-12345:+10}'# 显示负号，并使用空格填充，直到长度为 10' -12345'>>>f'{-12345:+010}'# 显示负号，并使用0填充，直到长度为 10'-000012345'

其它

>>>f'{-12345:0=10}'# 负数'-000012345'>>>f'{12345:010}'# [0] 快捷方式（不对齐）'0000012345'>>>f'{-12345:010}''-000012345'>>>importmath# [.precision]>>>math.pi3.141592653589793>>>f'{math.pi:.2f}''3.14'>>>f'{1000000:,.2f}'# [分组选项]'1,000,000.00'>>>f'{1000000:_.2f}''1_000_000.00'>>>f'{0.25:0%}'# 百分比'25.000000%'>>>f'{0.25:.0%}''25%'

Python 列表

定义

>>>li1= []
>>>li1
[]
>>>li2= [4, 5, 6]
>>>li2
[4, 5, 6]
>>>li3=list((1, 2, 3))
>>>li3
[1, 2, 3]
>>>li4=list(range(1, 11))
>>>li4
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

生成

>>>list(filter(lambdax : x%2==1, range(1, 20)))
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> [x**2forxinrange (1, 11) ifx%2==1]
[1, 9, 25, 49, 81]
>>> [xforxin [3, 4, 5, 6, 7] ifx>5]
[6, 7]
>>>list(filter(lambdax: x>5, [3, 4, 5, 6, 7]))
[6, 7]

添加元素

>>>li= []
>>>li.append(1)
>>>li
[1]
>>>li.append(2)
>>>li
[1, 2]
>>>li.append(4)
>>>li
[1, 2, 4]
>>>li.append(3)
>>>li
[1, 2, 4, 3]

切片

列表切片的语法：

a_list[start:end]
a_list[start:end:step]

切片

>>>a= ['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']
>>>a[2:5]
['bacon', 'tomato', 'ham']
>>>a[-5:-2]
['egg', 'bacon', 'tomato']
>>>a[1:4]
['egg', 'bacon', 'tomato']

省略索引

>>>a[:4]
['spam', 'egg', 'bacon', 'tomato']
>>>a[0:4]
['spam', 'egg', 'bacon', 'tomato']
>>>a[2:]
['bacon', 'tomato', 'ham', 'lobster']
>>>a[2:len(a)]
['bacon', 'tomato', 'ham', 'lobster']
>>>a
['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']
>>>a[:]
['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']

间隔索引

['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']
>>>a[0:6:2]
['spam', 'bacon', 'ham']
>>>a[1:6:2]
['egg', 'tomato', 'lobster']
>>>a[6:0:-2]
['lobster', 'tomato', 'egg']
>>>a
['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']
>>>a[::-1]
['lobster', 'ham', 'tomato', 'bacon', 'egg', 'spam']

删除

>>>li= ['bread', 'butter', 'milk']
>>>li.pop()
'milk'>>>li
['bread', 'butter']
>>>delli[0]
>>>li
['butter']
>>>li.remove('butter')
>>>li
[]

列表边界

>>>li= ['a', 'b', 'c', 'd']
>>>li[0]
'a'>>>li[-1]
'd'>>>li[4]
Traceback (mostrecentcalllast):
File"<stdin>", line1, in<module>IndexError: listindexoutofrange

连接

>>>odd= [1, 3, 5]
>>>odd.extend([9, 11, 13])
>>>odd
[1, 3, 5, 9, 11, 13]
>>>odd= [1, 3, 5]
>>>odd+ [9, 11, 13]
[1, 3, 5, 9, 11, 13]

排序和反转

>>>li= [3, 1, 3, 2, 5]
>>>li.sort()
>>>li
[1, 2, 3, 3, 5]
>>>li.reverse()
>>>li
[5, 3, 3, 2, 1]

计数

>>>li= [3, 1, 3, 2, 5]
>>>li.count(3)
2

重复

>>>li= ["re"] *3>>>li
['re', 're', 're']

搜索

>>>nums= [40, 36, 89, 2, 36, 100, 7, -20.5, -999]
>>>nums.index(2)
3>>>nums.index(100, 3, 7) # 搜索3-7之间的元素5>>>nums.index(7, 4) # 搜索4之后的元素6

当寻找一个不存在的值时，抛出ValueError。

Python 判断

if-else

number=int(input('输入一个整数：'))
ifnumber<0:
print("您输入了一个负数。")
else:
print("您输入了一个非负整数。")

if-elif-else

number=int(input('输入一个整数：'))
ifnumber<0:
print("您输入了一个负数。")
elifnumber==0:
print("您输入了一个 0 。")
else:
print("您输入了一个正数。")

三目运算

scope=int(input('输入百分制成绩：'))
line=60tip="及格"ifscope>=lineelse"不及格"# 相当于 scope >= line ? "及格" : "不及格"print(tip)

注意条件是放在中间的

Python 循环

一般形式

primes= [2, 3, 5, 7]
forprimeinprimes:
print(prime)

带索引

animals= ["dog", "cat", "mouse"]
fori, valueinenumerate(animals):
print(i, value)

while 循环

x=0whilex<4:
print(x)
x+=1# Shorthand for x = x + 1

跳出循环

x=0forindexinrange(10):
x=index*10ifindex==5:
breakprint(x)

跳过一轮循环

forindexinrange(3, 8): x=index*10ifindex==5:
continueprint(x)

范围循环

foriinrange(4):
print(i) # Prints: 0 1 2 3foriinrange(4, 8):
print(i) # Prints: 4 5 6 7foriinrange(4, 10, 2):
print(i) # Prints: 4 6 8

使用 zip()

name= ['Pete', 'John', 'Elizabeth']
age= [6, 23, 44]
forn, ainzip(name, age):
print('%s is %d years old'%(n, a))

列表生成式

result= [x**2forxinrange(10) ifx%2==0]
print(result)
# [0, 4, 16, 36, 64]

Python 函数

基础

defhello_world(): print('Hello, World!')

defadd(x, y):
print("x is %s, y is %s"%(x, y))
returnx+yadd(5, 6) # => 11

位置参数

defvarargs(*args):
returnargsvarargs(1, 2, 3) # => (1, 2, 3)

args 的类型是 tuple

关键字参数

defkeyword_args(**kwargs):
returnkwargs# => {"big": "foot", "loch": "ness"}keyword_args(big="foot", loch="ness")

kwargs 的类型是 dict

返回多个

defswap(x, y):
returny, xx=1y=2x, y=swap(x, y) # => x = 2, y = 1

默认值

defadd(x, y=10):
returnx+yadd(5) # => 15add(5, 20) # => 25

匿名函数

# => True
(lambdax: x>2)(3)
# => 5
(lambdax, y: x**2+y**2)(2, 1)

Python 解包

解包是将一个序列内的多个元素依次重新分配到有限个容器的过程，这只发生在 变量赋值、参数传递 和 生成式生成 过程中。
_ 这个变量是命令行交互中最后一次计算得到的值，在程序设计中一般用来存放解包时不再需要的值。但它的含义会因赋值而改变，比如标准库 gettext 中常用作动态获取翻译文本。

等量解包

ip, port="127.0.0.1", 80print(ip) # -> "127.0.0.1"print(port) # -> 80# 与以下代码等价ip, port= ("127.0.0.1", 80)
# 与以下代码效果相同ip, port= ["127.0.0.1", 80]

适量解包

ip, _, port="127.0.0.1:80".rpartition(":")
print(ip) # -> "127.0.0.1"print(port) # -> "80"# _ 这个变量此刻的值是 ":" ，但一般不再使用。

_ 也是一个单一变量，不允许解包多个元素，因此变量与值必须一一对应。

过量解包

major, minor, *parts="3.10.2.beta".split(".")
print(major) # -> "3"print(minor) # -> "10"print(parts) # -> ["2", "beta"]# 可将 parts 改为 _ 来表示不再需要后面的元素

这里的 * 就是收集序列在解包过程中多出来的元素，只能有一个，与向函数传递位置参数时的 * 别无二致。

解包取左边

major, minor, *_="3.10.2.beta".split(".")
print(major) # -> "3"print(minor) # -> "10"

解包取两边

major, *_, level="3.10.2.beta".split(".")
print(major) # -> "3"print(level) # -> "beta"

解包取右边

*_, micro, level="3.10.2.beta".split(".")
print(micro) # -> "2"print(level) # -> "beta"

解包集合

a, b, *_= {3, 2, 1}
print(a) # -> 1print(b) # -> 2print(_) # -> [3]

集合中的元素是无序的，因此解包结果不能轻易确定。

解包迭代器

a, b, *_=range(3)
print(a) # -> 0print(b) # -> 1print(_) # -> [2]

支持迭代器协议的对象也可被解包。

解包字典

a, b, *_=dict(a=1, b=2, c=3)
print(a) # -> "a"print(_) # -> ["c"]a, b, *_=dict(a=1, b=2, c=3).values()
print(a) # -> 1print(_) # -> [3]

生成式中的解包

chars= (*"abc", *"def", "g", "h")
# -> ("a", "b", "c", "d", "e", "f", "g", "h")digits= [*range(10), *"abcdef"]
# -> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9,# "a", "b", "c", "d", "e", "f"]part= {"小明": 18, "小亮": 22}
summary= {"小花": 16, **part}
print(summary)
# -> {"小花": 16, "小明": 18, "小亮": 22}

仅在列表／元组生成式中可以使用多个 *
仅在字典生成式中可以使用多个 **

迭代中解包

students= [
("小明", 18),
("小亮", 22),
]
fork, vinstudents:
print(k) # -> "小明"、"小亮"print(v) # -> 18、22students= [
(0, ("小明", 18)),
(1, ("小亮", 22)),
]
fori, (k, v) instudents:
print(i) # -> 0、1print(k) # -> "小明"、"小亮"print(v) # -> 18、22

函数中的解包

defversion(major, minor, *parts):
print(major) # -> "3"print(minor) # -> "10"print(parts) # -> ("2", "beta", "0")version("3", "10", "2", "beta", "0")
# 过程类似于major, minor, *parts= ("3", "10", "2", "beta", "0")
defversion():
parts="3.10.2.beta.0".split(".")
return*parts, "x64"print(version())
# -> ("3", "10", "2", "beta", "0", "x64")

Python 模块

导入模块

importmathprint(math.sqrt(16)) # => 4.0

从一个模块导入

frommathimportceil, floorprint(ceil(3.7)) # => 4.0print(floor(3.7)) # => 3.0

导入一个模块的全部

frommathimport*

给模块起别名

importmathasm# => Truemath.sqrt(16) ==m.sqrt(16)

浏览模块的函数和属性

importmathdir(math)

Python 文件处理

读取文件

逐行

withopen("myfile.txt") asfile:
forlineinfile:
print(line)

带行号

file=open('myfile.txt', 'r')
fori, lineinenumerate(file, start=1):
print("Number %s: %s"% (i, line))

字符串

写入一个字符串

contents= {"aa": 12, "bb": 21}
withopen("myfile1.txt", "w+") asfile:
file.write(str(contents))

读取一个字符串

withopen('myfile1.txt', "r+") asfile:
contents=file.read()
print(contents)

对象

写一个对象

contents= {"aa": 12, "bb": 21}
withopen("myfile2.txt", "w+") asfile:
file.write(json.dumps(contents))

读取对象

withopen('myfile2.txt', "r+") asfile:
contents=json.load(file)
print(contents)

删除文件

importosos.remove("myfile.txt")

检查和删除

importosifos.path.exists("myfile.txt"):
os.remove("myfile.txt")
else:
print("The file does not exist")

删除文件夹

importosos.rmdir("myfolder")

Python 类和继承

定义

classMyNewClass:
pass# 类的实例化my=MyNewClass()

构造函数

classAnimal:
def__init__(self, voice):
self.voice=voicecat=Animal('Meow')
print(cat.voice) # => Meowdog=Animal('Woof') print(dog.voice) # => Woof

方法

classDog:
# 类的方法defbark(self):
print("Ham-Ham")
charlie=Dog()
charlie.bark() # => "Ham-Ham"

类变量

classMyClass:
class_variable="A class variable!"# => 一个类变量！print(MyClass.class_variable)
x=MyClass()
# => 一个类变量！print(x.class_variable)

super() 函数

classParentClass:
defprint_test(self):
print("Parent Method")
classChildClass(ParentClass):
defprint_test(self):
print("Child Method")
# 调用父级的 print_test()super().print_test()

>>>child_instance=ChildClass()
>>>child_instance.print_test()
ChildMethodParentMethod

repr() 方法

classEmployee:
def__init__(self, name):
self.name=namedef__repr__(self):
returnself.namejohn=Employee('John')
print(john) # => John

用户定义的异常

classCustomError(Exception):
pass

多态性

classParentClass:
defprint_self(self):
print('A')
classChildClass(ParentClass):
defprint_self(self):
print('B')
obj_A=ParentClass()
obj_B=ChildClass()
obj_A.print_self() # => Aobj_B.print_self() # => B

重写

classParentClass:
defprint_self(self):
print("Parent")
classChildClass(ParentClass):
defprint_self(self):
print("Child")
child_instance=ChildClass()
child_instance.print_self() # => Child

继承

classAnimal: def__init__(self, name, legs):
self.name=nameself.legs=legsclassDog(Animal):
defsound(self):
print("Woof!")
Yoki=Dog("Yoki", 4)
print(Yoki.name) # => YOKIprint(Yoki.legs) # => 4Yoki.sound() # => Woof!

Python 数据模型

自定义类创建

参见自定义类创建。

fromtypingimportAnyclassObject:
def__new__(cls, *args, **kwargs) ->"self":
# new 和 init 声明的参数必须一致# 或者用 *args 和 **kwargs 进行兼容returnobject.__new__(cls)
def__init__(self, *args, **kwargs):
# 初始化方法没有返回值，也不能返回值。passdef__call__(self, *args, **kwargs) ->Any:
pass# 依次调用了 new 和 init，所以如果# 手动调用 new，那么别忘了调用 initobj=Object()
# 触发 __call__ 方法，要给什么参数取决于声明obj()

上下文管理器

参见上下文管理器。

fromtypingimportAnyclassObject:
def__enter__(self) ->Optional[Any]:
# with 语句会将返回值绑定到 as 子句中的变量，如果有的话。returndef__exit__(self, exc_type, exc_value, traceback):
# 若 with 内没有发生异常，则三个参数都是 None 。# 不应该重新引发传入的异常，这是调用者的责任。passwithObject() asalias:
# 进入 with 之前调用 obj.__enter__() 并得到 alias（如果有返回的话）pass# 离开 with 后调用 obj.__exit__() ，不管是正常结束还是因异常抛出而离开。# 当需要获取 Object 的对象时可以这样写obj=Object()
withobjasalias:
pass

特殊方法

下表使用 -> * 代表返回值类型是任意的，或者需要视情况而定，实际上并不存在这种写法。
诸如 -> str 仅表示绝大多数情况下应当返回 str 类型，或者推荐返回 str 类型。
没有 -> 的方法一般没有返回值。
参见 https://docs.python.org/zh-cn/3/reference/datamodel.html

语句	特殊方法	备注
`repr(obj)`	`__repr__(self) -> str`	详见 `repr()` 。
`str(obj)`	`__str__(self) -> str`	详见 `str` 类型。
`bytes(obj)`	`__bytes__(self) -> bytes`	详见 `bytes()` 。
`format(obj, spec)`	`__format__(self, spec) -> str`	详见 `format()`、格式化字符串字面值、格式规格迷你语言。
`hash(obj)`	`__hash__(self) -> int`	详见 `hash()` 。
`bool(obj)`	`__bool__(self) -> bool`	未定义时调用 `obj.__len__() != 0` ，若 `__len__()` 也未定义，则所有对象都被视为 `True` 。另见 `bool()` 。
`dir(obj)`	`__dir__(self) -> list`	返回值必须是一个序列，`dir()` 会把返回的序列转换为列表并对其排序。
`Object[key]`	`__class_getitem__(cls, key) -> *`	不建议用于除了模拟泛型类型以外的用途，避免 IDE 误判。

自定义实例及子类检查，参见 https://docs.python.org/zh-cn/3/reference/datamodel.html#customizing-instance-and-subclass-checks

语句	特殊方法	备注
`isinstance(instance, class)`	`class.__instancecheck__(self, instance) -> bool`	如果 instance 应被视为 class 的一个（直接或间接）实例则返回真值。
`issubclass(subclass, class)`	`class.__subclasscheck__(self, subclass) -> bool`	如果 subclass 应被视为 class 的一个（直接或间接）子类则返回真值。

“富比较”方法，参见 https://docs.python.org/zh-cn/3/reference/datamodel.html#object.__lt__

语句	特殊方法	备注
`obj < other`	`__lt__(self, other) -> bool`
`obj <= other`	`__le__(self, other) -> bool`
`obj == other`	`__eq__(self, other) -> bool`	默认返回 `obj is other` ，如果结果为 `False` ，则会返回 `NotImplemented` 。
`obj != other`	`__ne__(self, other) -> bool`	默认返回 `not obj.__eq__(other)` 。
`obj > other`	`__gt__(self, other) -> bool`
`obj >= other`	`__ge__(self, other) -> bool`

自定义属性访问，参见 https://docs.python.org/zh-cn/3/reference/datamodel.html#customizing-attribute-access

语句	特殊方法	备注
`obj.name`	`__getattr__(self, name) -> *`	优先调用。当抛出 `AttributeError` 时转向调用 `__getattribute__()` 。
`obj.name`	`__getattribute__(self, name) -> *`	参见自定义属性访问避免无限递归。
`obj.name = value`	`__setattr__(self, name, value)`
`del obj.name`	`__delattr__(self, name)`	仅在 `del obj.name` 对于该对象有意义时才应该被实现。

模拟容器类型，参见 https://docs.python.org/zh-cn/3/reference/datamodel.html#emulating-container-types

语句	特殊方法	备注
`len(obj)`	`__len__(self) -> int`
`op.length_hint(obj)`	`__length_hint__(self) -> int`	在使用标准库 operator 的 `length_hint()` 时会被调用（Python 3.4+）。
`obj[key]`	`__getitem__(self, key) -> *`	需要抛出 IndexError 以便正确地结束 for 循环。
`obj[key]`	`__missing__(self, key) -> *`	仅在 dict 的子类找不到键时被调用（不能重写 `__getitem__` 方法）。
`obj[key] = value`	`__setitem__(self, key, value)`	`a[1:2] = b` 实际上是 `a[slice(1, 2, None)] = b` ，其它情形及在其余方法中同理。详见 `slice()` 。
`del obj[key]`	`__delitem__(self, key)`
调用途径有很多	`__iter__(self) -> Iterator`	在需要创建一个迭代器时被调用，例如使用 `iter()` 、 `for` 循环。最好返回一个新对象，因为迭代器在语义上是一次性的。若返回 `self` ，则必须实现 `__next__()` 方法。
`reversed(obj)`	`__reversed__(self) -> *`	详见 `reversed()` 。
`item in obj`	`__contains__(self, item) -> bool`	对于未定义该方法的对象在 `in` 和 `not in` 时，参考成员检测运算。

模拟数字类型，参见 https://docs.python.org/zh-cn/3/reference/datamodel.html#emulating-numeric-types

语句	特殊方法	备注
`+obj`	`__neg__(self) -> *`
`-obj`	`__pos__(self) -> *`
`~obj`	`__invert__(self) -> *`
`abs(obj)`	`__abs__(self) -> *`
`int(obj)`	`__int__(self) -> *`
`float(obj)`	`__float__(self) -> *`
`complex(obj)`	`__complex__(self) -> *`
`round(obj)`	`__round__(self) -> int`	详见 `round()` 。
`round(obj)`	`__round__(self, ndigits) -> *`	详见 `round()` 。
`math.ceil(obj)`	`__ceil__(self) -> int`	详见标准库 math 的 `ceil()` 。
`math.floor(obj)`	`__floor__(self) -> int`	详见标准库 math 的 `floor()` 。
`math.trunc(obj)`	`__trunc__(self) -> int`	详见标准库 math 的 `trunc()` 。
	`__index__(self) -> int`	需要无损地将数值转换为整数的时候会被调用。详见这里。
`obj + other`	`__add__(self, other) -> *`
`obj - other`	`__sub__(self, other) -> *`
`obj * other`	`__mul__(self, other) -> *`
`obj @ other`	`__matmul__(self, other) -> *`	为第三方库而生的矩阵乘法运算符，这里提了一嘴。（Python 3.5+）
`obj / other`	`__truediv__(self, other) -> *`
`obj // other`	`__floordiv__(self, other) -> *`
`obj % other`	`__mod__(self, other) -> *`
`divmod(obj, other)`	`__divmod__(self, other) -> tuple`	`divmod(a, b)` 返回一个元组 `(a // b, a % b)` ，详见 `divmod()` 。
`obj ** exp`	`__pow__(self, exp) -> *`
`pow(obj, exp, mod)`	`__pow__(self, exp, mod) -> *`	`pow(base, exp, mod)` 比 `pow(base, exp) % mod` 更高效。
`obj << other`	`__lshift__(self, other) -> *`
`obj >> other`	`__rshift__(self, other) -> *`
`obj & other`	`__and__(self, other) -> *`
`obj ^ other`	`__xor__(self, other) -> *`
`obj \| other`	`__or__(self, other) -> *`
`other + obj`	`__radd__(self, obj) -> *`	仅当 obj 未定义 `__add__()` 或其返回 `NotImplemented` ，且与 other 互相都没有继承关系时，调用 other 的 `__radd__()` 。详见这里。
`other - obj`	`__rsub__(self, obj) -> *`	以下，如此类推。
`other * obj`	`__rmul__(self, obj) -> *`
`other @ obj`	`__rmatmul__(self, obj) -> *`
`other / obj`	`__rtruediv__(self, obj) -> *`
`other // obj`	`__rfloordiv__(self, obj) -> *`
`other % obj`	`__rmod__(self, obj) -> *`
`divmod(other, obj)`	`__rdivmod__(self, obj) -> tuple`
`other ** obj`	`__rpow__(self, obj) -> *`
	`__rpow__(self, obj, mod) -> *`	`pow(obj, other, mod)` 不会尝试调用 `other.__rpow__(obj, mod)` ，因为强制转换规则会太过复杂。
`other << obj`	`__rlshift__(self, obj) -> *`
`other >> obj`	`__rrshift__(self, obj) -> *`
`other & obj`	`__rand__(self, obj) -> *`
`other ^ obj`	`__rxor__(self, obj) -> *`
`other \| obj`	`__ror__(self, obj) -> *`
`obj += other`	`__iadd__(self, other) -> *`	若方法已定义，则 `a += b` 等价于 `a.__iadd(b)` ；若未定义，则回退到 `a + b` 选择 `x.__add__(y)` 和 `y.__radd__(x)` 。
`obj -= other`	`__isub__(self, other) -> *`	以下，如此类推。
`obj *= other`	`__imul__(self, other) -> *`
`obj @= other`	`__imatmul__(self, other) -> *`
`obj /= other`	`__itruediv__(self, other) -> *`
`obj //= other`	`__ifloordiv__(self, other) -> *`
`obj %= other`	`__imod__(self, other) -> *`
`obj **= exp`	`__ipow__(self, other) -> *`
`obj <<= other`	`__ilshift__(self, other) -> *`
`obj >>= other`	`__irshift__(self, other) -> *`
`obj &= other`	`__iand__(self, other) -> *`
`obj ^= other`	`__ixor__(self, other) -> *`
`obj \|= other`	`__ior__(self, other) -> *`

Python 类型标注 (Python 3.5+)

变量

string: str="ha"times: int=3print(string*times) # => hahaha

变量

result: str=1+2print(result) # => 3

错误的类型标注不会影响正常运行，也不会报错

参数

defsay(name: str, start: str="Hi"):
returnstart+", "+nameprint(say("Python")) # => Hi, Python

位置参数

defcalc_summary(*args: int):
returnsum(args)
print(calc_summary(3, 1, 4)) # => 8

表示 args 的所有元素都是 int 类型的。

返回值

defsay_hello(name) ->str:
return"Hello, "+namevar="Python"print(say_hello(var)) # => Hello, Python

多种可能的返回值

fromtypingimportUniondefresp200(meaningful) ->Union[int, str]:
return"OK"ifmeaningfulelse200

表示返回值可能是 int，也可能是 str 。

关键字参数

defcalc_summary(**kwargs: int):
returnsum(kwargs.values())
print(calc_summary(a=1, b=2)) # => 3

表示 kwargs 的所有值都是 int 类型的。

多个返回值

defresp200() -> (int, str):
return200, "OK"

多种可能的返回值 (3.10+)

defresp200(meaningful) ->int|str:
return"OK"ifmeaningfulelse200

自 Python 3.10 起可用。

属性

classEmployee:
name: strage: intdef__init__(self, name, age):
self.name=nameself.age=ageself.graduated: bool=False

标注自己

classEmployee:
name: strage: intdefset_name(self, name) ->"Employee":
self.name=namereturnself

这里表示 set_name() 返回了一个 Employee 对象。

标注自己 (3.11+)

fromtypingimportSelfclassEmployee:
name: strage: intdefset_name(self: Self, name) ->Self:
self.name=namereturnself

标注一个值为类型的参数

fromtypingimportTypeVar, TypeT=TypeVar("T")
# "mapper" 的值是一个像 int、str、MyClass 这样的类型# "default" 是一个 T 类型的值，比如 314、"string"、MyClass()# 函数的返回值也是一个 T 类型的值defconverter(raw, mapper: Type[T], default: T) ->T:
try:
returnmapper(raw)
except:
returndefaultraw: str=input("请输入一个整数：")
result: int=converter(raw, mapper=int, default=0)

标注一个值为函数的参数

fromtypingimportTypeVar, Callable, AnyT=TypeVar("T")
defconverter(raw, mapper: Callable[[Any], T], default: T) ->T:
try:
returnmapper(raw)
except:
returndefault# Callable[[Any], T] 表示值是一个像这样声明的函数:# def anynomous(arg: Any) -> T:# passdefis_success(value) ->bool:
returnvaluein (0, "OK", True, "success")
resp=dict(code=0, message="OK", data=[])
successed: bool=converter(resp.message, mapper=is_success, default=False)

各种各样的

注释

# 这是单行注释

""" 可以写多行字符串 使用三个"，并且经常使用 作为文档。"""

''' 可以写多行字符串 使用三个'，并且经常使用 作为文档。'''

生成器

defdouble_numbers(iterable):
foriiniterable:
yieldi+i

生成器可帮助您编写惰性代码

要列出的生成器

values= (-xforxin [1,2,3,4,5])
gen_to_list=list(values)
# => [-1, -2, -3, -4, -5]print(gen_to_list)

处理异常

try:
# 使用“raise”来引发错误raiseIndexError("这是一个索引错误")
exceptIndexErrorase:
pass# pass只是一个空操作。 通常你会在这里做恢复。except (TypeError, NameError):
pass# 如果需要，可以一起处理多个异常。else: # try/except 块的可选子句。 必须遵循除块之外的所有内容print("All good!") # 仅当 try 中的代码未引发异常时运行finally: # 在所有情况下执行print("我们可以在这里清理资源")

pyenv & pipenv

pvenv 用于管理python版本，pipenv 用于管理项目包版本

pyenv

# 安装 pyenv
curl https://pyenv.run | bash

更多安装方式

# 安装 python 版本
pyenv install 3.10.12
# 设置 python 版本
pyenv global 3.10.12 # 全局设置
pyenv shell 3.10.12 # 针对当前 shell session
pyenv local 3.10.12 # 针对当前目录

pipenv

# 安装 pipenv
pip install pipenv --user # pip
brew install pipenv # homebrew# 更新 pipenv
pip install --user --upgrade pipenv # pip
brew upgrade pipenv # homebrew

# 将 pipenv 命令加入到系统环境变量 $PATH 中 (Unix and MacOS)
dir=$(python -c 'import site; print(site.USER_BASE + "/bin")')# 打印 python site-packages bin 路径echo'export PATH="'$dir':$PATH"'>>~/.zshrc # 将 dir 路径加入到 PATH 中source~/.zshrc
# 安装 package
pipenv install <package name># 不指定版本
pipenv install <package name>==<version># 精确指定版本
pipenv install <package name>~=<version># 指定版本范围，例如 1.1则表示安装1.x的最新版本，1.0.1则表示安装1.0.x的最新版本
pipenv install "<package name>=<version>"# 大于等于指定版本
pipenv install "<package name>=<version>"# 小于等于指定版本

# 指定 python 版本
pipenv --python 3.10.12
# 激活当前目录虚拟环境
pipenv shell

另见

Python 官方网站(python.org)
Python 文档(docs.python.org)
Y 分钟学会 Python(learnxinyminutes.com)
Python 中的正则表达式(jaywcjlove.github.io)

FilesExpand file tree

python.md

Latest commit

History