【Python基础】Python基础语法知识汇总，个人整理向~~~（文末附自制Python思维导图）

一、Python简介

1.编程语言的分类：

（1）分类方式一：

①编译型：
一个整体先编译为一个半成品文件，重复性高
例：C/C++
②解释型：
一行一行地去编译代码
例：Python
（Python是偏解释型的，但其实是半解释半编译型的）

（2）分类方式二：

①静态语言
需要实现定义好再去使用
例：C/C++
②动态语言(又叫脚本语言)
不需要在编程时定义变量地数据类型
例：Python

2.Python的程序执行原理：

源代码m.py —(Python解释器)> 字节码m.pyc —(运行时PVM)>结果
①先把源代码通过Python解释器编译成字节码
②把编译好的字节码转发到Python虚拟机(PVM)中执行

二、Python基础语法

1.基本语法

（1）注释

①单行注释
python中的单行注释以#开头
②多行注释
多行注释使用三引号作为开头和结束符号

（2）代码缩进

①缩进是指每一行代码开始前的空白区域，用来表示代码之间的包含和层次关系
②Python中采用严格的缩进来表明程序的格式框架。
③代码缩进需注意：严格明确、所属关系、长度一致

（3）语句换行

python通常是一行写完一条语句，但如果语句很长需要换行时，可以使用\来实现
需注意：
在[]、{}、()中的语句，不需要使用反斜杠进行换行

2.变量和命名

（1）变量

Python是动态语言，变量不需要先定义，随那随用，类似于一个标签
①变量是用来保存和表示数据的占位符号
②python中的变量用来存储数据，变量采用标识符(名字)来表示，
关联标识符的过程叫做命名
③变量的定义必须命名规则
④可以使用赋值符号=向变量赋值，挥着修改变量的值

（2）命名

①命名是给变量或其他程序元素关联名称或标识符的过程
②命名规则：
大小写字母、数字、下划线和汉字及其组合进行命名
③注意：
区分大小写
首字符不能是数字
不能与保留字相同
中间不能出现空格
长度没有限制

3.标识符和关键字

（1）标识符

即命名，命名规则与变量的命名规则相同

（2）关键字

又叫保留字，指被编程语言内部定义并保留使用的标识符

4.简单数值类型

（1）整型

①与数学中的整数概念一致，没有取值范围的限制
②进制间的运算结果默认以十进制方式显示

（2）浮点型

①浮点型与数学中的实数的概念一致，表示带有小数的数值，必须有小数部分，小数部分可以是0
②E或e表示基是10，后面的整数表示指数，指数的正负使用±表示
③整数的运算精度比浮点数更高
(因为python中的值都是转化为二进制直接计算的，如果是浮点数二进制进行运算，结果可能取近似值)

（3）复数

①Python中复数可以看做是二元有序实数对(a,b)，表示a+bj
其中a是实数部分，b是虚数部分
②实部和虚部都是浮点型

（4）布尔类型

①布尔型数据只有两个取值：True和False
②bool值没有操作
③所有的空都是False，所有的非空都是True
以下布尔值都是False：
None、False、0、0.0、0.0+0.0j、空字符串、空列表、空元组、空字典

（5）数值类型转换

①type(x)
对变量x进行类型判断，适用于任何数据类型
②int(x)
将x转换为一个整数
注意：浮点数类型转换为整数类型时，小数部分会被直接舍弃（不使用四舍五入）
③float(x)
将x转换为一个浮点数，默认为六位小数
④complex(a,b)
创建一个复数

5.运算符

（1）算数运算符
x//y：取整除，返回商的整数部分
x**y：幂，返回x的y次幂
（2）赋值运算符
同步赋值语句：
x,y=y,x
（3）复合赋值运算符
（4）比较赋值运算符
（5）逻辑运算符
and、 or、 not
（6）成员运算符
in 、 not in 
运算符优先级

6.数值运算函数

（Python中6个与数值运算相关的内置函数）
（1）abs(x)： 绝对值
求x的绝对值
x也可以是复数，但由于实部和虚部都是浮点数，所以复数的绝对值也是浮点数
abs(-3+4j) #5.0

（2）divmod(x,y)： 除余
(x//y,x%y)，输出为二元组形式（也称元组类型）
计算x和y的除余结果，返回两个值，分别是x和y的乘除商x//y，以及x与y的余数x%y
（3）pow(x,y)或pow(x,y,z)：幂运算
x** y或x ** y%z ，幂运算
（4）round(x)或round(x,d)：四舍五入
对x四舍五入，保留d位小数，无参数d则返回四舍五入的整数值

注意：
并非所有的.5都会进位，将所有x.5的情况分为两类：
采用“奇进偶不进”的方式运算，即当x为偶数时，x.5并不进位；当x为奇数时，x.5进位

（5）max(x1,x2…xn)：最大值
返回里面的最大值，n没有限定
（6）min(x1,x2…xn)：最小值
返回里面的最小值，n没有限定

7.基本输入输出

（1）input() 输入函数
①格式：
A.变量=input()
B.变量=input(“提示性文字”)

②返回结果：
字符串类型

③注意：
input()是通过换行来读取数据结果的，所以不能同时多行输入
要想实现同时输入多个换行的值，要通过循环+input语句结合实现

④格式转换：
s=int(input())#强制类型转换
s=eval(input())

（2）eval() 评估函数
①作用：
把字符串外的引号去掉，将字符串自动识别评估为类型
eval(‘hello’) #出错
eval(‘“hello”’) #输出hello

②注意：
eval()处理字符串内容进行运算的结果可以用变量保存
hello=5
eval(‘hello’)

③如果用户希望输入一个数字并计算，可以采用以下组合实现
变量=eval(input(“提示性文字”))

即当需要对字符串进行强制类型转换时，一般不直接使用强制类型转换，而是用eval()评估函数

（3）print() 输出函数
①作用：
输出运算结果
有两种输出格式：默认输出格式和特定格式输出

②默认格式输出：
A.仅用于输出字符串
print(“中国梦，我的梦”) #中国梦，我的梦
print() #输出空行

B.仅用于输出一个或多个变量
value=123.456
print(value,value)

C.默认下：
print(,sep="',end=“_”)
sep：指定在同一个print()语句中，变量与变量之间的分隔符，不写则默认为空格
end：指定多个print()语句之间的分隔符，不写则默认为换行

③特定格式输出：
print(‘文字描述%_’ %(变量,…))

三、Python字符串

1.字符串的介绍

（1）字符串的定义：
字符串是一种表示文本的数据类型，根据字符串内容的多少，分为：
①单行字符串:用一对单引号或双引号包围的是单行字符串，二者作用相同
②多行字符串:用一对三单引号或三双引号包围的是多行字符串，二者作用相同

注意：为什么Python中会有单引号与双引号并行的情况？

print(‘今天真是’美好’的一天’)#错误，会把美好看作变量
print(‘今天真是"美好"的一天’)#正确，今天真是"美好"的一天

（2）转义字符
转义字符由反斜杠\引导，与后面相邻的字符组成了新的含义

2.字符串的索引

（1）含义：
对字符串中某个字符的检索成为索引
（2）形式：
<字符串>[序号]
（3）分类：
字符串中每个字符都有一个对应下标，下标编号方式有两种：正向递增和反向递减
如果字符串的长度为L：
正向递增：0~L-1 向右依次递增
反向递减：-1~-L 向左依次递减

3.字符串的切片

（1）含义：
对字符串中某个子串或区间的检索称为切片
（2）形式：
s[start : end : step]
默认从前往后切，正向递增
step：正负代表方向，大小代表步长
（3）注意：
①切片区间是左闭右开型区间，即获取的字符串从start到end的子字符串，不包含索引end
②切片的索引序号可以混合使用正向递增和反响递减序号

4.字符串的操作

（1）基本运算符

①x+y：连接两个字符串x与y
②xn或nx :复制n次字符串x
③x in s :如果x是s的字串，返回True，否则返回False

（2）处理函数

①len(x)：返回字符串x的长度
②str(x)：返回任意类型x所对应的字符串形式
③chr(x)：返回unicode编码x对应的字符串
④ord(x)：返回单字符表示的unicode编码
⑤oct(x)：返回整数x对应的八进制编码数的小写形式字符串
⑥hex(x)：返回整数x对应的十六进制编码数的小写形式字符串

（3）处理方法

①find方法
作用：检测字符串是否包含子字符串
形式：str.find(sring,beg=0,end=len(ser))
str指定检索的字符串
beg开始索引，默认为0
end结束索引，默认为字符串的长度
如果找到，返回索引，如果找不到，结果是-1

②index方法
作用：检测字符串中是否包含子字符串
形式：str.index(sring,beg=0,end=len(ser))
str指定检索的字符串
beg开始索引，默认为0
end结束索引，默认为字符串的长度
返回索引，如果找不到，报错

③replace方法
作用：将旧字符串替换为新字符串
形式：str.replace(old,new[max])
old将被替换的字符串
new新字符串，用于替换old字符串
max可选字符串，替换不超过max次

④split方法
作用：通过指定分隔符对字符串进行切片
形式：str.split(string=“”,num=str.count(string))
string以string为分隔符切片str
num分割次数，可选参数，如果num有指定值，则仅分割num+1个字符串
结果生成列表(可以实现字符串转列表)
注意：
如果string不在在str中，则不会切片，还是原串

⑤join方法
作用：将括号中所有的元素合并为一个新的字符串
形式：str.join(seq)
seq要连接的元素序列
str连接符
返回通过指定字符连接序列中元素后生成的新字符串
注意：
当seq为字符串类型时，会以每个字符分隔
当seq为列表类型时，会以列表中每个逗号隔开，因为列表中是以逗号隔开最小单元

⑥count方法
作用：统计字符串中某个字符的个数
形式：
str.count(sub,start=0,end=len(str))
sub搜索的字符串
start字符串开始搜索的位置
end字符串中结束搜索的位置

⑦upper方法
作用：将小写字母转化为大写字母
形式：str.upper()

⑧lower方法
作用：将大写字母转为小写字母
形式：str.lower()

5.字符串的输出

（1）format方法

format方法：格式化字符串
形式：
<模板字符串>.format(<逗号分隔的参数>)
模板字符串：由字符串和槽组成的字符串，用来控制字符串和变量的显示效果
槽：用大括号{}表示，相当于占位符，对应format()方法中逗号分隔的参数

（2）f-string方法

说明：
①f-string方法：格式化字符串常量
②f-string本质上并不是字符串常量，而是一个在运行时运算求值的表达式
③对于Python3.6及以后的版本，推荐使用f-string对字符串进行格式化
形式：
f-string在形式上是以f或F修饰符引领的字符串（f’xxx’或 F’xxx’），以大括号{}标明被替换的字段
f"{content:format}"
content：替换并填入字符串的内容，可以是变量、表达式或函数等
{:format}：与format方法类似
注意：
①引号：
f-string大括号内所用的引号不能和大括号外的引号定界符冲突，可根据情况灵活切换
②反斜杠：
大括号外的引号还可以使用\转义，但大括号内不能使用\转义
③大括号：
f-string大括号外如果需要显示大括号，则应输入连续两个大括号{{和}}

四、Python结构控制

1.判断语句

（1）简单分支结构：if语句

（2）选择分支结构：if…else语句
注意：
双分支中还有一种更简洁的表达式：
<表达式1>if<条件>else<表达式2>
适合语句块中都只包含简单表达式的情况。

（3）多分支结构：if…elif…else

（4）分支的嵌套
分支的嵌套是指分支中还存在分支的情况，即if语句中还包含着if语句

2.循环语句

（1）for循环：遍历循环

①形式：
for <循环变量> in <遍历结构>:
                    <语句块>

②遍历结构可以是字符串、文件、range()函数、组合数据类型

③range()函数的三种用法：
生成一个数字序列
A.range(N): 0~N-1
B.range(start,end): start~end-1
C.range(start,end,step): start~end-1,但有步长：隔step个数取一个

④for语句中的逻辑结构：
将遍历结构中的每一项拿出来赋值给循环变量，每一项循环变量来执行语句块，遍历结构遍历完成时循环结束

（2）while循环：条件循环

①形式：
while <条件>：
          <语句块>

②当条件不满足时，循环结束；
当条件表达式永远为true时，无线循环

③while循环可用于实现多行输入的情况

（3）循环的嵌套

无论是while循环还是for循环，其中都可以再包含一个循环，从而构成了循环的嵌套

3.Python其他语句

（1）break语句：结束整个循环（断路）

（2）continue语句：结束本次循环（短路）

紧接着执行下一次循环

（3）pass语句：空语句（占位）

不起任何作用，用作占位，保持程序结构的完整性

（4）else语句：循环的扩展模式——else奖励机制

①当for循环、while循环正常执行之后 ，程序会继续执行else语句中的内容。
else语句只在循环正常执行之后才执行并结束
②else语句中常放置判断循环执行情况的语句
③else奖励：可以把循环中的else想象成一种奖励，只有程序完整执行循环，才执行else语句里的内容
循环中使用了break或者return之后不会在执行else，continue对else语句没有影响

4.异常处理

（1）异常类型

当Python中程序报错时会有异常信息，异常信息中最重要的就是异常类型。
它表明了异常发生的原因，也是程序处理异常的依据

（2）try-except语句

①形式：
try：
    要运行的程序语句
except+异常类型：
    该异常想输出的语句
except：
     其他异常错误想输出的语句

②和if-else语句的区别：
else语句后不能直接跟内容，而except后可以紧跟内容，但是该内容必须是异常类型名称

③注意：
平时如果不加try-except语句，如果有异常，编辑器会自动帮我们识别，返回异常，也可以人为修改

五、Python组合数据类型

1.列表类型

（1）列表概述

①列表是Python中的一种数据结构，可以用于存储不同类型的数据
②列表索引是从0开始的，可以通过下标索引的方式访问列表中元素的值
③列表中的元素类型可以不同，列表可以包含列表，列表没有长度限制
A.以一定的形式存储一定的数据（列表中的元素之间存在先后顺序）
B.存储一组长度为L的数据（长度为0—L，长度可变）
④注意：
可变数据类型：
随着程序的修改数据类型定义的元素本身可以修改 的数据类型为可变数据类型
否则，为不可变数据类型
字符串、元组为不可变数据类型
列表、字典、集合为可变数据类型

（2）定义列表

①[]
s=[]#创建空列表
s=[1,2,3,4,5]

②list()
s=list()#创建空列表
s=list(“12345”)
s=list(12345)#错误，list()中要跟序列类型或者range()

（3）循环遍历列表

①使用for循环遍历列表
A.值遍历
for i in s:
    print(i)
B.下标遍历
for i in range(len(s)):
    print(s[i])
②使用while循环遍历列表 

（4）列表是一种序列类型，所以拥有序列通用的使用方法
序列类型只有三种：字符串、列表、元组
相同点：
①切片
②索引
③+(拼接)、*(重复)
④in、not in  存不存在
⑤len() 求序列长度

（5）列表的操作

增：

①append()
append(单一元素x)：向列表中最后增加一个元素x
②insert()
insert(待插入到i的下标位置，单一元素x)：向列表的第i位增加元素x
③extend()
extend(序列)：向列表中最后增加一段序列(不仅是列表)中的元素

删：

①del
用保留字方式，结合切片删除
②s.pop(i)
i是被删除元素的下标，不加默认删除最后一位
③s.remove(x)
x是想要删除元素的值，重复的话只会删除第一个
④s.clear()
不需要加参数，清空整个列表，变为空列表，但列表还存在

改：

①通过索引切片赋值的方式进行修改
s=[0,1,2,3,4,5]
s=s[0:3]
print(s)  #[0, 1, 2]
注意：
如果切片的位置后元素更多，会多增少补
如果切片的位置后元素更少，会正常切，然后补进这些元素（先把左边元素切掉，再把右边的元素补进来）

②copy()
将列表复制一份
注意：为什么不直接用=呢？
因为在python中变量名可以看作是标签，随拿随用
b=a： 赋值相当于变量名赋值，实际空间没有改变
b=a[:]或b=a.copy() ：会单独开辟一段空间

查：

①in、not in 
in(存在)：如果存在结果为True，否则为False
not in(不存在)：如果不存在结果为True，否则为False
②index(x)
查找列表中元素x第一次出现下标值
（如果不存在，会报错，可进行异常处理）
③count(x)
查找列表中元素x出现的次数
排序：
①reverse()
反转列表
②sort()
默认升序排序
s.sort(reverse=True)降序排序
s.sort(key=)key后要跟一个函数，必须是一种排序规则，按照特定顺序排序

（6）列表中常用的操作符、函数

①常用操作符：列表连接符+、列表复制符*
②常用函数：
min()
max()
sum()
使用时要求列表中的元素必须为同一数据类型

（7）列表推导式

类似于双分支选择结构，使用其他列表来创建一个新列表

①普通写法：
s=[x2 for x in range(1,11)]
等价于：
s=[]
for x in range(1,11):
    s.append(x2)

②开放写法：
s=[x2 for x in range(1,11) if x%20]
等价于：
s=[]
for x in range(1,11):
    if x%20:
        s.append(x2)

2.元组类型

（1）元组的定义

①含义：
元组是不可变的，相当于是不可变的列表
②创建：
使用()小括号或者tuple()函数

（2）元组的操作

①因为元素中的元素值不能被修改，所以元组本身不能进行增、删、改等操作
只能进行索引、切片、和求长度等序列操作

②如果想修改元组中的值，可以将元组转换为列表，修改完后，再转换为元组

③del 关键字。元组中不能删除某一元素值，但能删除一整个元组
a=(1,2,3,4,5)
del a
#这个元组a就删除掉了，在内存中就没有了

（3）元组中常用的操作符、函数

①常用操作符：元组连接符+、元组复制符*
②常用函数：
min(tuple)
max(tuple)
sum(tuple)
使用时要求元组中的元素必须为同一数据类型
len(tuple)：计算元组中元素的个数
tuple(seq)：将列表转化为元组

（4）注意：

元组中只包含一个元素时，需要在元素后面加逗号，否则括号会被当做运算符使用
tup1=(12)
tup2=(12,)
print(tup1,tup2)

3.字典类型

（1）字典的定义

①含义：
字典是另一种可变容器模型，且可存储任意类型对象。

②形式：
字典的每个键值 key:value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }

③注意：
A.dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。
B.键key一般是唯一的，如果重复最后的一个键值对会替换前面的，值value不需要唯一。
C.值value可以取任何数据类型，但键key必须是不可变类型的，如字符串，数字或元组。
D.列表与字典的区别：
列表： 下标——值 ，下标索引有大小范围，所以是有序的顺序结构
字典：键——值  ， 键是无序的不能重复的，所以字典里的元素是无序的，不能通过下标来查找，也不能切片
E.
a=[] #定义列表 
a=() #定义元组
a={} #定义字典

（2）字典的常见操作

①创建字典
A.{}
B.dict()函数
②检索字典元素
A.使用in运算符检索 key in dicts
B.使用关键字检索 dict[“key”]
③添加与修改字典元素
利用键索引+赋值：dicts[key]=value
④删除字典元素
A.del
可以用于删除整个字典，也可以删除其中某一元素
B.clear()方法
只会清空字典中的数据，但字典还存在，变为空字典

（3）字典中常用的内置函数和方法

内置函数：

①cmp(dict1, dict2)
比较两个字典元素。
②len(dict)
计算字典元素个数，即键的总数。
③str(dict)
输出字典可打印的字符串表示。
④type(variable)
返回输入的变量类型，如果变量是字典就返回字典类型。
⑤sorted(dict)
以key值对字典进行排序，默认为unicode编码大小

常用方法：

①dict.clear()
删除字典内所有元素
②dict.copy()
返回一个字典的浅复制
③dict.fromkeys(seq[, val])
创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
④dict.get(key, default=None)
返回指定键的值，如果值不在字典中返回default值
⑤dict.has_key(key)
如果键在字典dict里返回true，否则返回false
⑥dict.items()
以列表返回可遍历的(键, 值) 元组数组
⑦dict.keys()
以列表返回一个字典所有的键
⑧dict.setdefault(key, default=None)
和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
⑨dict.update(dict2)
把字典dict2的键/值对更新到dict里
⑩dict.values()
以列表返回字典中的所有值
①①pop(key[,default])
删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
①②popitem()
返回并删除字典中的最后一对键和值。

4.集合类型

（1）集合的定义

①含义：
Python中的集合set是包含0个或多个不重复数据项的无序组合
②使用场景：
因为集合中元素不可重复，可用于当需要对一维数据进行去重或者进行数据重复处理时
③创建：
可以使用{ }或者set()函数创建一个集合
注意创建一个空集合必须使用set()而不是{},因为{}是用来创建一个空字典

（2）集合的操作

增：

①s.add(x)
将元素x添加到集合s中，如果已存在，则不会进行任何操作
②s.update(x)
更新集合，将元素x添加到集合s中，x可以是列表，元组，字典

删：

①s.pop()
从集合s中随机删除一个元素，集合为空时返回异常
②s.remove(x)
从集合s中删除元素x，如果x不在集合中，返回异常
③s.discard(x)
从集合s中删除元素x，如果x不在集合中，不会返回异常

改：

s.copy()
复制集合，返回集合的一个副本

查：

①s.isdisjoint(t)
判断集合s和集合t中是否存在相同元素，如果没有相同元素，返回True
②len(s)
len函数返回集合s中元素的个数

（3）集合的运算

（Python中的集合与数学中集合概念是一致的，方法现用现查即可）
交&
差-
并|
补^

六、Python函数

1.函数的定义和调用

（1）什么是函数？
函数是组织好的，可重复使用的代码段

（2）函数的定义
Python定义函数使用def关键字，格式：

def 函数名(参数列表)：
       函数体
       return 返回值列表
（3）函数的调用
定义了函数之后，如果想使用函数，就需要调用函数，格式：

函数名(<实参列表>)

注意：函数要先定义后使用

2.函数的参数

（1）位置参数
函数调用时，默认情况下，实参将按照位置顺序传递给形参
（2）赋值参数
按照形参名称输入实参的方式
（3）默认参数(又叫可选参数)
定义函数时，可以给函数的形式参数设置默认值，这种参数被称为默认参数
注意：
①如果默认参数没有传入值，则直接使用默认值；如果默认参数传入了值，则使用传入的新值替代
②带有默认值的参数一定要位于参数列表的最后面，否则程序运行时会报异常
（4）可变参数(又叫不定长参数)
在函数定义时可以接受任意个参数，可以是0个，1个或者多个
形式：
参数名称前加星号*，或者加两个星号**
注意：
①加一个星号的变量：会存放所有未命名的变量参数，为元组
②加两个星号的变量：会存放命名参数，为字典

3.函数的返回值

（1）函数的返回值是使用return语句来完成的
（2）return语句可以同时返回0个、1个或多个函数运算结果
注意：返回多个值时以元组类型保存，不带参数值的return语句返回None

4.函数的四种类型

（1）无参数，无返回值的函数
（2）无参数，有返回值的函数
（3）有参数，无返回值的函数
（4）有参数，有返回值的函数

5.函数的嵌套调用

函数与函数之前可以嵌套使用

6.变量的作用域

（1）命名空间
①目的：
为了避免变量的名称发生冲突，Python引入了命名空间的概念
②含义：
命名空间是指名称到对象的映射，类似于字典：键名是变量的名字，值是变量的值。
（2）作用域
命名空间是相互独立存在的，将命名空间这些层次结构组合起来就是作用域
（3）局部变量
①含义：
在函数内部定义的变量
②作用域：
局部变量的作用域是在函数内部。
只在定义它的函数内有效，一旦函数结束就会消失
（4）全局变量
①含义：
定义在函数外的拥有全局作用域
②作用域：
全局变量可以在整个程序范围内访问
③注意：
如果全局变量和局部变量名字相同的情况，则在函数中访问的是局部变量
④语法形式：
globa <全局变量>

7.匿名函数和递归函数

（1）匿名函数

①含义：
形式上匿名函数就是没有名称的函数。
但匿名函数并非真的没有名字，而是将函数名作为函数的结果返回

②形式：
<函数名>=lambda [形参列表]：函数返回值的表达式

③例：以下两个等价
def s(a,b):
    return a+b
print(s(2,3))

s=lambda a,b:a+b
print(s(2,3))

④什么时候使用lambda函数？
A.定义简单的，能在一行内表示的函数，返回一个函数类型
B.可以与map、sorted、filter结合使用

⑤注意：
A.lambda表达式中不能包含分支或循环语句
B.lambda函数只能返回一个表达式的值，匿名函数不能直接调用print
C.可以将lambda表达式作为列表的元素，从而实现跳转表的功能，也就是函数的列表

（2）map函数

①作用：
对指定的序列做映射。
即以参数序列中的每个元素分别调用function函数，把每次调用后返回的结果保存为对象
②定义：
map(函数名，迭代器)
③例：
func=lambda x:x+2
result=map(func,[1,2,3,4,5])
print(list(result))

（3）filter函数

①作用：
对指定序列进行过滤操作
②定义：
filter(函数名，序列或迭代器)
③例：
func=lambda x:x%2
result=filter(func,[1,2,3,4,5])
print(list(result))

（4）递归函数

①含义：
程序调用自身
②形式：
在函数定义时直接或间接的调用自己
③解决问题的思想：

if 问题足够简单：
    直接解决问题
    返回解
else：
    将问题分解为与原问题同构的一个或多个更小的问题
    逐个解决这些更小的问题
    将结果组合为，获得最终解
    返回解

8.日期时间函数

（现用现查即可）

①时间戳
通常来讲，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量
②格式化的时间字符串
③时间元组
（1）时间函数
(使用time库)
（2）日期函数
(使用calendar库)

9.随机数函数

random库中的函数主要用于产生各种分布的伪随机数序列
随机数是由随机种子决定的，其概率是确定的、可见的，被称为伪随机数
（1）random.random()
随机生成一个[0,1.0]之间的浮点数，闭区间
（2）random.seed(随机种子)
初始化伪随机数生成器，如果未提供或者随机种子=None，默认用当前的系统时间戳为随机种子
随机种子必须是一个整数
（3）random.uniform(a,b)
随机返回[a,b]或[b,a]之间的浮点数
（4）random.randint(a,b)
随机返回[a,b]之间的一个随机整数，这里必须要保证b>a
（5）random.randrang([start],stop,[step])
随机返回[start,stop)之间的一个整数，参数step为步长
（6）random.choice(seq)
从非空序列seq中随机选取一个元素
（7）random.shuffle(x,[random])
随机打乱可变序列x内元素的排序顺序，俗称"洗牌"
（8）random.sample(seq,k)
从指定序列seq中随机获取k个元素作为片段返回

10.闭包

（1）内部函数和外部函数
Python是支持嵌套的，如果在一个函数内部定义了另外一个函数，
外部的函数叫做外部函数，内部的函数叫做内部函数
注意：
①内部函数的本质就是局部变量(函数就是一个变量)
②内部函数在函数外部不可以直接调用，内部函数在函数内部调用
（2）闭包
定义：
如果一个内部函数引用了外部函数作用域中的变量，那么这个内部函数就被称为闭包
（将局部变量(内部函数)引入到全局环境中使用，这就是闭包操作）

注意：
①闭包是一个可以由另一个函数动态生成的函数，并且可以创建和改变函数外创建的变量值
②函数闭包会记得外层函数的作用域

使用条件：
①闭包必须有嵌套函数
②嵌套函数需要引用外部函数中的变量(包括外部函数的参数)
③外部函数需要将嵌套函数名作为返回值返回

例：
def outer(a,b):
    def inner(c,d):
        return c+d+a+b
    return inner
print(outer(1,2)(2,4))

七、Python文件操作

1.文件的类型

根据文件的存储格式不同，可以分为文本文件和二进制文件

2.文件的打开和关闭

（1）文件处理的步骤：打开->操作->关闭
（2）文件的打开：
<变量名>=open(<文件名>,<打开模式>)
文件名：可以写绝对路径，写相对路径要保证在同一源文件下
打开模式：文本文件or二进制文件 读or写
（3）文件的关闭：
<文件名>.close()
使用内存缓冲区缓存文件数据

3.文件内容的读取

（1）读：
①read()：读取全部文件内容
②readline()：读取一行文件内容
③readlines()：读取文件的所有行
（2）写：
①write(str)：将字符串str写入文件
②writelines(seq_of_str)：写多行到文件中，参数seq_of_str可迭代的对象
（3）seek()方法：
文件的指针—就是那个光标
调用seek()方法可以手动移动指针的位置

4.数据文件的写入

CSV文件主要用于数据的组织和处理，将数据划分为三种类型：
①一维数据：线性（列表、集合、元组）
②二维数据：也称关系，行列矩阵（表格）
③多维数据：二维数据的扩展（常用字典键值对表示）

八、Python模块操作

1.模块的基本使用

模块的概念：
你写的程序就称为模块
导入模块
①import 语句
②from…import 语句
③from…import* 语句
_name_属性：
自定义模块测试时常用
if name==‘main’

2.模块的制作

3.Python中的包

每一层目录一般包含一个 int.py文件

4.模块的发布

5.模块的安装

自制思维导图：

(版权所属，创作不易)