Python基础目录
一、Python基础语法1. 注释方法2. 关键字3. 标识符4. 变量5. 数据类型（1）整型（2）浮点型（3）布尔型（4）字符串（5）列表（6）元组（7）字典（8）集合 6. 转换数据常用方法7. 数据容器的通用操作8. 运算符9. 输入输出10. 条件语句11. 循环语句 二、函数1. 定义函数2. 调用函数3. 函数参数4. 函数返回值5. 函数说明文档6. 变量作⽤域7. 变量值的引用8. lambda表达式9. 高阶函数一、Python基础语法
版本：Python 3.71. 注释方法
单行注释：# 注释内容（快捷键：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]
字典：字典 = {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. 运算符
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 条件语句:条件成⽴执⾏的代码
if…else…
if 条件语句:条件成⽴执⾏的代码else:条件不成⽴执⾏的代码
多重判断
if 条件1:条件1成⽴执⾏的代码elif 条件2:条件2成⽴执⾏的代码else:以上条件都不成⽴执⾏的代码
if嵌套
if 条件1:条件1成⽴执⾏的代码if 条件2:条件2成⽴执⾏的代码...
三⽬运算符：条件成⽴执⾏的表达式 if 条件 else 条件不成⽴执⾏的表达式
11. 循环语句
1、while 循环
while…
while 条件:条件成⽴重复执⾏的代码
while…else…
while 条件:条件成⽴重复执⾏的代码else:循环正常结束后执⾏的代码
2、for 循环
for…in…
for 临时变量 in 序列:重复执⾏的代码
for…in…else…
for 临时变量 in 序列:重复执⾏的代码else:循环正常结束后执⾏的代码
3、跳出循环
continue：跳出本次循环，继续执⾏下⼀次重复执⾏的代码break：跳出整个循环，且不执⾏else里的代码
二、函数
1. 定义函数
函数的作⽤：封装代码，⾼效的代码复用定义方法（函数必须先定义后使⽤）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 + 3def sum_numbers(num):# 如果是1，则直接返回1if 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) # 100print(num2) # 20
字典拆包：取出来的是字典的key
# 举例：dict1 = {'name': 'TOM', 'age': 18}a, b = dict1print(a) # nameprint(b) # age
交换变量值
方法一：借助第三变量存储数据方法二：变量对调
# 举例：a, b = 1, 2a, b = b, aprint(a) # 2print(b) # 1
5. 函数说明文档
定义文档语法def 函数名(参数):""" 说明⽂档的位置 """代码
查看文档语法：help(函数名)
6. 变量作⽤域
全局变量：在函数体内、外都能⽣效的变量局部变量：只在函数体内部⽣效的变量（在函数体内临时保存数据，当函数调⽤完成后，则销毁局部变量）在函数中修改全局变量：global关键字声明全局变量# 举例：a = 100def test():global aa = 200print(a)test() # 200
7. 变量值的引用
变量值是靠引⽤来传递的，当修改变量时，可以根据变量的内存地址变化情况，将数据分为可变类型和不可变类型
可变类型（内存地址不变）：列表、字典、集合不可变类型（内存地址有变化）：整型、浮点型、字符串、元组
# 举例：1. 整型a = 1b = aprint(id(a)) # 140715006346912print(id(b)) # 140715006346912a = 2print(id(a)) # 140715006346944，内存地址有变化print(id(b)) # 140715006346912
# 举例：2. 列表aa = [10, 20]bb = aaprint(id(aa)) # 069398720print(id(bb)) # 069398720aa.append(30)print(id(aa)) # 069398720，内存地址不变print(id(bb)) # 069398720
可以⽤
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 ** 2result = 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 == 0result = filter(func, list1)print(result) # <filter object at 0x000001D43D121AC0>print(list(result)) # [2, 4, 6, 8, 10]
reduce()
语法：reduce(func，lst)，func每次计算的结果继续和序列的下⼀个元素做累积计算，其中func必须有两个参数
# 举例：计算列表中各个数字的累加和import functoolslist1 = [1, 2, 3, 4, 5]def func(a, b):return a + bresult = functools.reduce(func, list1)print(result) # 15
