【编程语言】Python基础知识整理

一、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. 转换数据常用方法

7. 数据容器的通用操作

1、运算符

2、常用方法

3、推导式

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

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

• 字典：字典 = {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}
1
2
3
4
5
6

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

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

8. 运算符

1、算数运算符

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

2、赋值运算符

3、复合赋值运算符

优先级

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

4、⽐较运算符

• 返回 True 或 False

5、逻辑运算符

• 返回 True 或 False

数字之间的逻辑运算

• 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'{表达式}')

• 常用格式符号

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

10. 条件语句

• if…

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

• if…else…

if 条件语句:
	条件成⽴执⾏的代码
else:
	条件不成⽴执⾏的代码
1
2
3
4

• 多重判断

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

• if嵌套

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

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

11. 循环语句

1、while 循环

• while…

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

• while…else…

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

2、for 循环

• for…in…

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

• for…in…else…

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

3、跳出循环

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

二、函数

1. 定义函数

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

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

2. 调用函数

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

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

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

def testA():
	print('---- testA start----')
	testB()
	print('---- testA end----')
	
testA()
# ---- testA start----
# 这⾥是testB函数执⾏的代码
# ---- testA end----
1
2
3
4
5
6
7
8
9
10
11
12
13

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
1
2
3
4
5
6
7
8
9
10
11
12
13

3. 函数参数

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

1、位置参数

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

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

user_info('Jack', 18)
# 您的名字是Jack, 年龄是18
1
2
3
4
5
6

2、关键字参数

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

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

user_info('Jack', gender='男', age=18)
# 您的名字是Jack, 年龄是18, 性别是男
1
2
3
4
5
6

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, 性别是女
1
2
3
4
5
6
7
8

4、可变位置参数

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

# 举例：
def user_info(*args):
	print(args)
	
user_info('Jack') 
# ('Jack',)
user_info('Jack', 18) 
# ('Jack', 18)
1
2
3
4
5
6
7
8

5、可变关键字参数

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

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

user_info(name='Jack', age=18, gender='男')
# {'name': 'Jack', 'age': 18, 'gender': '男'}
1
2
3
4
5
6

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
1
2
3
4
5
6
7
8
9
10
11

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

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

print(a) # name
print(b) # age
1
2
3
4
5
6

• 交换变量值

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

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

5. 函数说明文档

• 定义文档语法

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

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

6. 变量作⽤域

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

# 举例：
a = 100

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

test() # 200
1
2
3
4
5
6
7
8
9

7. 变量值的引用

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

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

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

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

a = 2
print(id(a)) # 140715006346944，内存地址有变化
print(id(b)) # 140715006346912
1
2
3
4
5
6
7
8
9
10

# 举例：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
1
2
3
4
5
6
7
8
9

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

8. lambda表达式

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

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

1. lambda表达式能接收任何数量的参数，但只能返回⼀个表达式的值
2. 直接打印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}]
1
2
3
4
5
6
7
8
9
10
11

9. 高阶函数

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

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

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

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]
1
2
3
4
5
6
7
8

• 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]
1
2
3
4
5
6
7
8

• 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
1
2
3
4
5
6
7
8
9