Python官方文档（3.10.8）

https://docs.python.org/zh-cn/3/

一、Python基础语法

版本：Python 3.7

1. 注释方法

单行注释：# 注释内容（快捷键：Ctrl+ /）
多行注释：''' 注释内容 ''' 或 """注释内容"""

2. 关键字

关键字一共33个，False、None和True的首字母大写，其他全部是小写

3. 标识符

1、标识符的命名规则（必须遵守）

由数字、字⺟、下划线_组成
不能数字开头
不能使⽤内置关键字
严格区分⼤⼩写

2、标识符的命名规范（建议遵守）

⻅名知意
⼤驼峰：即每个单词⾸字⺟都⼤写，例如： XxxYyyy
⼩驼峰：第⼆个（含）以后的单词⾸字⺟⼤写，例如： xxxYyy
下划线：例如： xxx_yyy

4. 变量

1、单个变量赋值
变量名 = 值

2、多个变量赋值
变量名1,变量名2,变量名3 = 值1，值2，值3

3.、多变量赋相同值
变量名1 = 变量名2 = 变量名3 = 值

5. 数据类型

（1）整型

1、整型：int

2、创建整型：变量名 = 整数

创建空整型： 变量名 = int()

（2）浮点型

1、浮点型：float

2、创建浮点型：变量名 = 浮点数

创建空浮点型： 变量名 = float()

（3）布尔型

1、布尔型：bool

2、创建布尔型：变量名 = True 或 变量名 = False

创建空布尔型： 变量名 = bool()

（4）字符串

1、字符串：str

2、创建字符串

单引号：'字符串'、"字符串"
三引号（支持换行）：'''字符串'''、"""字符串"""

创建空字符串：'' 或 str()

3、常用操作

查找

下标（计算机为数据序列中每个元素分配的从0开始的编号）：字符串序列[下标位置]

切片：字符串序列[开始位置下标:结束位置下标:步长]

结束位置下标：-1代表倒数第一个数据
步长：选取间隔，默认为1，正负数均可，-1代表从结束位置开始往前取
最多取到结束位置下标的前一个数据

方法：

find()
功能：检测某个⼦串是否包含在这个字符串中，如果在，则返回这个⼦串开始的位置下标，否则返回-1
语法：字符串序列.find(⼦串, 开始位置下标, 结束位置下标)
index()
功能：检测某个⼦串是否包含在这个字符串中，如果在，则返回这个⼦串开始的位置下标，否则抛出异常
语法：字符串序列.index(⼦串, 开始位置下标, 结束位置下标)
rfind()
功能：和find()功能相同，但查找⽅向为右侧开始
语法：字符串序列.rfind(⼦串, 开始位置下标, 结束位置下标)
rindex()
功能：和index()功能相同，但查找⽅向为右侧开始
语法：字符串序列.rindex(⼦串, 开始位置下标, 结束位置下标)
count()
功能：返回某个⼦串在字符串中出现的次数
语法：字符串序列.count(⼦串, 开始位置下标, 结束位置下标)
若省略开始和结束位置下标，表示在整个字符串序列中查找
修改（不能直接修改原字符串，需要赋值到变量）

方法：

replace()
功能：替换
语法：字符串序列.replace(旧⼦串, 新⼦串, 替换次数)
split()
功能：按照指定字符分割字符串
语法：字符串序列.split(分割字符, 分割字符出现的次数)
join()
功能：⽤⼀个字符或⼦串合并字符串
语法：字符或⼦串.join(多字符串序列组成的列表序列)
capitalize()
功能：将字符串的第⼀个字符转换成⼤写
语法：字符串序列.capitalize()
title()
功能：将字符串每个单词⾸字⺟转换成⼤写
语法：字符串序列.title()
lower()
功能：将字符串中的⼤写全部转成⼩写
语法：字符串序列.lower()
upper()
功能：将字符串中的⼩写全部转成⼤写
语法：字符串序列.upper()
lstrip()
功能：删除字符串左侧空⽩字符
语法：字符串序列.lstrip()
rstrip()
功能：删除字符串右侧空⽩字符
语法：字符串序列.rstrip()
strip()
功能：删除字符串两侧空⽩字符
语法：字符串序列.strip()
ljust()
功能：使⽤指定字符(默认空格)填充⾄对应⻓度的新字符串，且字符串左对⻬
语法：字符串序列.ljust()
rjust()
功能：使⽤指定字符(默认空格)填充⾄对应⻓度的新字符串，且字符串右对⻬
语法：字符串序列.rjust()
center()
功能：使⽤指定字符(默认空格)填充⾄对应⻓度的新字符串，且字符串居中对⻬
语法：字符串序列.center()
判断

方法：

startswith()
功能：检查字符串是否是以指定⼦串开头，是则返回 True，否则返回 False
语法：字符串序列.startswith(⼦串, 开始位置下标, 结束位置下标)
endswith()
功能：检查字符串是否是以指定⼦串结尾，是则返回 True，否则返回 False
语法：字符串序列.endswith(⼦串, 开始位置下标, 结束位置下标)
isalpha()
功能：如果字符串⾄少有⼀个字符，且所有字符都是字⺟，则返回 True, 否则返回 False
语法：字符串序列.isalpha()
isdigit()
功能：如果字符串只包含数字，则返回 True，否则返回 False
语法：字符串序列.isdigit()
isalnum()
功能：如果字符串⾄少有⼀个字符，且所有字符都是字⺟或数字，则返回 True，否则返回 False
语法：字符串序列.isalnum()
isspace()
功能：如果字符串中只包含空⽩，则返回 True，否则返回 False
语法：字符串序列.isspace()

（5）列表

1、列表：list，用来存储多个数据

2、创建列表：[数据1,数据2,数据3,数据4...]

创建空列表：[] 或 list()

3、常用操作

查找

下标：列表序列[下标位置]

切片：列表序列[开始位置下标:结束位置下标:步长]

结束位置下标：-1代表倒数第一个数据
步长：选取间隔，默认为1，正负数均可，-1代表从结束位置开始往前取
最多取到结束位置下标的前一个数据

方法：

index()
功能：返回指定数据所在位置的下标，如果查找的数据不存在则报错
语法：列表序列.index(数据, 开始位置下标, 结束位置下标)
count()
功能：统计指定数据在当前列表中出现的次数
语法：列表序列.count(数据)
len()
功能：返回列表⻓度，即列表中数据的个数
语法：len(列表序列)
增加（直接在原列表⾥加指定数据，即修改原列表）

方法：

append()
功能：在列表结尾追加数据，如果追加的数据是⼀个序列，则追加整个序列到列表
语法：列表序列.append(数据)
extend()
功能：在列表结尾追加数据，如果追加的数据是⼀个序列，则将此序列的数据逐⼀添加到列表
语法：列表序列.extend(数据)
insert()
功能：在指定位置新增数据
语法：列表序列.insert(位置下标, 数据)
删除

方法：

del / del()
功能：删除列表或列表指定数据
语法：del 列表序列 / del(列表序列[下标])
pop()
功能：删除指定下标的数据(默认为最后⼀个)，并返回该数据
语法：列表序列.pop(下标)
remove()
功能：移除列表中某个数据的第⼀个匹配项
语法：列表序列.remove(数据)
clear()
功能：清空列表
语法：列表序列.clear()
修改

下标：列表序列[下标] = 新值

方法：

reverse()
功能：逆置
语法：列表序列.reverse()
sort()
功能：排序
语法：列表序列.sort(key = 方法,reverse = 布尔值)
参数：key代表对列表内每个数据应用的方法（默认为None）；reverse代表排序规则，True为降序，False为升序（默认）

（6）元组

1、元组：tuple，用来存储多个数据，但数据不能直接修改

若存储的数据为可修改数据类型：如列表，则可以修改列表中的数据，但不能直接修改整个列表

2、创建元组：(数据1,数据2,数据3,数据4...)

创建空元组：() 或 tuple()
创建单个数据元组：(数据1,)

3、常用操作（查找）

下标：元组序列[下标]

方法：

index()
功能：查找某个数据，如果数据存在返回对应的下标，否则报错
语法：元组序列.index(数据)
count()
功能：统计某个数据在当前元组出现的次数
语法：元组序列.count(数据)
count()
功能：统计元组中数据的个数
语法：len(元组序列)

（7）字典

1、字典：dict，字典⾥⾯的数据以键值对（key:value）形式出现，但不⽀持下标

2、创建字典：{key1:value1,key1:value2...}

创建空字典：{} 或 dict()

3、常用操作

修改/增加（直接在原字典⾥修改/增加数据，即修改原字典）

方法：

append()
功能：如果字典中存在此key，则修改对应的值；如果不存在，则新增此键值对
语法：字典[key] = 值
删除

方法：

del / del()
功能：删除字典或删除字典中指定键值对
语法：del 字典 / del(字典[key])
clear()
功能：清空字典
语法：字典.clear()
查找

索引： 字典[key值]，如果当前查找的key存在，则返回对应的值，否则则报错

方法：

get()
功能：如果当前查找的key不存在，则返回第⼆个参数(默认值)，如果省略第⼆个参数，则返回
None
语法：字典.get(key, 默认值)
keys()
功能：返回字典中的所有key
语法：字典.keys()
values()
功能：返回字典中的所有value
语法：字典.values()
items()
功能：返回字典中的所有键值对
语法：字典.items()

（8）集合

1、集合：set，可以去掉重复数据，但不⽀持下标

2、创建集合：{数据1,数据2,数据3...}

创建空集合：set()

3、常用操作

增加

方法：

add()
功能：追加数据，但若追加的数据为当前集合已有数据，则不进⾏任何操作
语法：集合.add()
update()
功能：追加序列数据，将此序列的数据逐⼀添加到集合
语法：集合.update()
删除

方法：

remove()
功能：删除集合中的指定数据，如果数据不存在则报错
语法：集合.remove(数据)
discard()
功能：删除集合中的指定数据，如果数据不存在也不会报错
语法：集合.discard(数据)
pop()
功能：随机删除集合中的某个数据，并返回这个数据
语法：集合.pop()

6. 转换数据常用方法

方法	说明
`int(x [,base])`	将x转换为⼀个整数
`float(x)`	将x转换为⼀个浮点数
`str(x)`	将对象 x 转换为字符串
`list(s)`	将序列 s 转换为⼀个列表
`tuple(s)`	将序列 s 转换为⼀个元组
`set(s)`	将序列 s 转换为⼀个集合
`complex(real [,imag])`	创建⼀个复数，real为实部，imag为虚部
`repr(x)`	将对象 x 转换为表达式字符串
`eval(str)`	将str转换为str表达式原本的数据类型
`chr(x)`	将⼀个整数转换为⼀个Unicode字符
`ord(x)`	将⼀个字符转换为它的ASCII整数值
`hex(x)`	将⼀个整数转换为⼀个⼗六进制字符串
`oct(x)`	将⼀个整数转换为⼀个⼋进制字符串
`bin(x)`	将⼀个整数转换为⼀个⼆进制字符

7. 数据容器的通用操作

1、运算符

运算符	描述	⽀持的容器类型
`+`	合并	字符串、列表、元组
`*`	复制	字符串、列表、元组
`in`	元素是否存在	字符串、列表、元组、字典
`not in`	元素是否不存在	字符串、列表、元组、字典

2、常用方法

方法	描述	支持的容器类型
`len()`	计算容器中元素个数	字符串、列表、元组、字典、集合
`max()`	返回容器中元素最⼤值	字符串、列表、元组、字典、集合
`min()`	返回容器中元素最⼩值	字符串、列表、元组、字典、集合
`range(start,end,step)`	⽣成从start到end，步⻓为 step的数字列表，在for循环使⽤，做为数据对象的下标索引	字符串、列表、元组
`enumerate(数据对象,start = )`	将⼀个可遍历的数据对象组合为⼀个索引序列，同时列出数据和数据下标，start为索引起始值参数	字符串、列表、元组、字典、集合

3、推导式

列表：列表 = [xx for .. in 数据序列]

# 举例：返回0-9的偶数列表
list1 = [i for i in range(10) if i % 2 == 0]
print(list1)
# [0,2,4,6,8]

字典：字典 = {xx1:xx2 for .. in 数据序列}

 # 举例：将两个列表内元素打包为字典
list1 = ['name', 'age']
list2 = ['Jack', 18]
dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1)
# {'name': Jack, 'age': 18}

集合：集合 = {xx for .. in 数据序列}

 # 举例：用集合形式打印列表内元素的2次方
list1 = [1, 1, 2]
set1 = {i ** 2 for i in list1}
print(set1 )
# {1，4}

8. 运算符

分类	运算符
算数运算符	`+`、`-`、``、`/`、`//`、`%`、`*`、`()`
赋值运算符	`=`
复合赋值运算符	`+=`、`-=`、`=`、`/=`、`//=`、`%=`、`*=`
⽐较运算符	`=`、`!=`、`>`、`<`、`>=`、`<=`
逻辑运算符	`and`、`or`、`not`

1、算数运算符

运算符	描述
`+`	加
`-`	减
`*`	乘
`/`	除
`//`	整除
`%`	取余
`**`	指数
`()`	⼩括号

优先级：()⾼于 ** ⾼于 * / // % ⾼于 + -

2、赋值运算符

运算符	描述
`=`	赋值

3、复合赋值运算符

运算符	描述
`+=`	加法赋值运算符
`-=`	减法赋值运算符
`*=`	乘法赋值运算符
`/=`	除法赋值运算符
`//=`	整除赋值运算符
`%=`	取余赋值运算符
`**=`	幂赋值运算符

优先级

先算复合赋值运算符右侧的表达式
再算复合赋值运算的算数运算
最后算赋值运算

4、⽐较运算符

返回 True 或 False

运算符	描述]=
`==`	等于
`!=`	不等于
`>`	大于
`<`	小于
`>=`	大于等于
`<=`	小于等于

5、逻辑运算符

返回 True 或 False

运算符	描述
`and`	与
`or`	或
`not`	非

数字之间的逻辑运算

and运算符，只要有⼀个值为0，则结果为0，否则结果为最后⼀个⾮0数字
or运算符，只有所有值为0结果才为0，否则结果为第⼀个⾮0数字

9. 输入输出

1、输⼊

语法：input('提示⽂字')
input()会把接收到的任意数据都当做字符串处理

2、输出

语法：print('输出的字符串')
转义字符
\n ：换⾏
\t ：制表符，⼀个tab键（4个空格）的距离
结束符
end="\n"：默认结束符（默认换行），可修改
格式化输出
单个格式化输出：print('格式化符号' % 表达式)
多个格式化输出：print('格式化符号1，格式化符号2' % (表达式1, 表达式2))
Python3.6中新增的格式化⽅法：print(f'{表达式}')
常用格式符号

格式符号	转换
`%s`	字符串
`%d`	有符号的⼗进制整数
`%f`	浮点数
`%c`	字符
`%u`	⽆符号⼗进制整数
`%o`	⼋进制整数
`%x`	⼗六进制整数（⼩写ox）
`%X`	⼗六进制整数（⼤写OX）
`%e`	科学计数法（⼩写e）
`%E`	科学计数法（⼤写E）
`%g`	%f和%e的简写
`%G`	%f和%E的简写

%06d：表示输出的整数显示6位数，不⾜以0补全，超出当前位数则原样输出
%.2f：表示⼩数点后显示2位小数

10. 条件语句

if…

1 2	if 条件语句: 条件成⽴执⾏的代码

if…else…

if 条件语句:
	条件成⽴执⾏的代码
else:
	条件不成⽴执⾏的代码

多重判断

if 条件1:
	条件1成⽴执⾏的代码
elif 条件2:
	条件2成⽴执⾏的代码
else:
	以上条件都不成⽴执⾏的代码

if嵌套

if 条件1:
	条件1成⽴执⾏的代码
	if 条件2:
		条件2成⽴执⾏的代码
		...

三⽬运算符：条件成⽴执⾏的表达式 if 条件 else 条件不成⽴执⾏的表达式

11. 循环语句

1、while 循环

while…

1 2	while 条件: 条件成⽴重复执⾏的代码

while…else…

while 条件:
   条件成⽴重复执⾏的代码
else:
   循环正常结束后执⾏的代码

2、for 循环

for…in…

1 2	for 临时变量 in 序列: 重复执⾏的代码

for…in…else…

for 临时变量 in 序列:
	重复执⾏的代码
else:
	循环正常结束后执⾏的代码

3、跳出循环

continue：跳出本次循环，继续执⾏下⼀次重复执⾏的代码
break：跳出整个循环，且不执⾏else里的代码

二、函数

1. 定义函数

函数的作⽤：封装代码，⾼效的代码复用
定义方法（函数必须先定义后使⽤）

1
2
3

def 函数名(参数):
	# 也可以不带参数
	代码

2. 调用函数

调用方法：函数名(参数)

1、嵌套：⼀个函数⾥⾯⼜调⽤了另外⼀个函数

# 举例：
def testB():
	print('这⾥是testB函数执⾏的代码')

def testA():
	print('---- testA start----')
	testB()
	print('---- testA end----')
	
testA()
# ---- testA start----
# 这⾥是testB函数执⾏的代码
# ---- testA end----

2、递归：函数内部⾃⼰调⽤⾃⼰

# 举例：计算 1 + 2 + 3
def sum_numbers(num):

	# 如果是1，则直接返回1
	if num == 1:
		return 1
		
	# 如果不是1，则重复调用自己
	return num + sum_numbers(num-1)

sum_result = sum_numbers(3)
print(sum_result)
# 6

3. 函数参数

作用：函数调⽤的时候可以传⼊真实数据，增⼤函数的使⽤的灵活性
形参：函数定义时的参数
实参：函数调⽤时的参数

1、位置参数

调⽤函数时，根据函数定义的参数位置来传递参，形参和实参的个数和顺序必须⼀致

# 举例：
def user_info(name, age):
	print(f'您的名字是{name}, 年龄是{age}')

user_info('Jack', 18)
# 您的名字是Jack, 年龄是18

2、关键字参数

调⽤函数时，通过key=value形式加以指定，关键字参数之间不存在先后顺序
如果有位置参数，位置参数必须在关键字参数的前⾯

# 举例：
def user_info(name, age, gender):
	print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')

user_info('Jack', gender='男', age=18)
# 您的名字是Jack, 年龄是18, 性别是男

3、默认参数

定义函数时，通过key=value形式为参数提供默认值
调⽤函数时，可以修改默认参数值
如果有位置参数，位置参数必须出现在默认参数前面

# 举例：
def user_info(name, age, gender='男'):
	print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')

user_info('Jack', 20)
# 您的名字是Jack, 年龄是20, 性别是男
user_info('Rose', 18, '⼥')
# 您的名字是Rose, 年龄是18, 性别是女

4、可变位置参数

收集所有位置参数，返回⼀个元组

# 举例：
def user_info(*args):
	print(args)
	
user_info('Jack') 
# ('Jack',)
user_info('Jack', 18) 
# ('Jack', 18)

5、可变关键字参数

收集所有关键字参数，返回⼀个字典

# 举例：
def user_info(**kwargs):
	print(kwargs)

user_info(name='Jack', age=18, gender='男')
# {'name': 'Jack', 'age': 18, 'gender': '男'}

4. 函数返回值

1、返回值语法

返回单个数据：return 表达式
返回多个数据：
返回元组：return 表达式1, 表达式2.. 或 return (表达式1, 表达式2..)
返回列表：return [表达式1, 表达式2..]
返回字典/集合：return {表达式1, 表达式2..}

2、返回值拆包

列表/元组/集合拆包

# 举例：
def return_num():
	return [100, 200]
	# 也适用于以下表达式
	# return 100,200
	# return (100,200)
	# return {100,200}
	
num1, num2 = return_num()
print(num1) # 100
print(num2) # 20

字典拆包：取出来的是字典的key

# 举例：
dict1 = {'name': 'TOM', 'age': 18}
a, b = dict1

print(a) # name
print(b) # age

交换变量值
方法一：借助第三变量存储数据
方法二：变量对调

# 举例：
a, b = 1, 2
a, b = b, a
print(a)  # 2
print(b)  # 1

5. 函数说明文档

定义文档语法

1
2
3

def 函数名(参数):
	""" 说明⽂档的位置 """
	代码

查看文档语法：help(函数名)

6. 变量作⽤域

全局变量：在函数体内、外都能⽣效的变量
局部变量：只在函数体内部⽣效的变量（在函数体内临时保存数据，当函数调⽤完成后，则销毁局部变量）
在函数中修改全局变量：global关键字声明全局变量

# 举例：
a = 100

def test():
	global a
	a = 200
	print(a)

test() # 200

7. 变量值的引用

变量值是靠引⽤来传递的，当修改变量时，可以根据变量的内存地址变化情况，将数据分为可变类型和不可变类型

可变类型（内存地址不变）：列表、字典、集合
不可变类型（内存地址有变化）：整型、浮点型、字符串、元组

# 举例：1. 整型
a = 1
b = a

print(id(a)) # 140715006346912
print(id(b)) # 140715006346912

a = 2
print(id(a)) # 140715006346944，内存地址有变化
print(id(b)) # 140715006346912

# 举例：2. 列表
aa = [10, 20]
bb = aa
print(id(aa)) # 2011069398720
print(id(bb)) # 2011069398720

aa.append(30)
print(id(aa)) # 2011069398720，内存地址不变
print(id(bb)) # 2011069398720

可以⽤id()来判断两个变量是否为同⼀个值的引⽤，id的值代表变量内存的地址标识

8. lambda表达式

1、适用场景：函数有⼀个返回值，且只有⼀句代码

2、语法：lambda 参数列表:表达式

lambda表达式能接收任何数量的参数，但只能返回⼀个表达式的值
直接打印lambda表达式，输出的是此lambda的内存地址

3、lambda的参数形式

⽆参数：lambda: 表达式
位置/关键字参数：lambda 参数:表达式
默认参数：lambda key=value:表达式
可变位置参数：lambda *args:表达式
可变关键词参数：lambda **kwargs:表达式

# 举例：使列表数据按字典key的值排序
students = [
	{'name': 'TOM', 'age': 20},
	{'name': 'ROSE', 'age': 19},
	{'name': 'Jack', 'age': 22}
	]

# 按name值升序排列
students.sort(key=lambda x: x['name'], reverse=False)
print(students)
# [{'name': 'Jack', 'age': 22}, {'name': 'ROSE', 'age': 19}, {'name': 'TOM', 'age': 20}]

9. 高阶函数

1、高阶函数作⽤：把函数作为参数传⼊，化简代码

# 举例：任意两个数字，按照指定函数处理后再进⾏求和计算
def sum_num(a, b, f):
	return f(a) + f(b)

result = sum_num(-1, 2, abs)
print(result) # 3

2、内置⾼阶函数

map()

语法：map(func, lst)，将传⼊的函数变量func作⽤到序列的每个元素中，并将结果组成新的迭代器返回

# 举例：将列表内元素依次乘以2次方
list1 = [1, 2, 3, 4, 5]
def func(x):
	return x ** 2

result = map(func, list1)
print(result) # <map object at 0x000001D43D121C70>
print(list(result)) # [1, 4, 9, 16, 25]

filter()

语法：filter(func, lst)，⽤于过滤掉序列中不符合条件的元素，返回⼀个 filter 对象

# 举例：去掉列表中的奇数
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def func(x):
	return x % 2 == 0
	
result = filter(func, list1)
print(result) # <filter object at 0x000001D43D121AC0>
print(list(result)) # [2, 4, 6, 8, 10]

reduce()

语法：reduce(func，lst)，func每次计算的结果继续和序列的下⼀个元素做累积计算，其中func必须有两个参数

# 举例：计算列表中各个数字的累加和
import functools

list1 = [1, 2, 3, 4, 5]
def func(a, b):
	return a + b

result = functools.reduce(func, list1)
print(result) # 15