（1）形参：函数定义时的参数
（2）实参：函数调用时的参数
（3）收集参数：
普通收集参数：*args，收集多余的普通参数，组成一个元组
关键字收集参数：**kw，收集多余的关键字参数，组成一个字典
（4）命名关键字参数：函数定义时放在 * 号后面，调用时必须指定关键字实参；（*，abc）abc是命名关键字参数
（5）* 和 ** ：打包和解包
函数定义处：打包（收集参数，放到元组或字典中）
函数调用处：解包（把容器类型里的数据，一个个拿出来传递给函数的形参）
（6）形参声明的顺序：
普通参数 > 默认参数 > 收集参数 > 命名关键字参数 > 关键字收集参数
（7）对于任何函数，都可以使用 def func(*args,**kw)来获取所有的参数
abs：绝对值
round：四舍五入
sum：求和
max：求最大值
min：求最小值
pow：n次方
range：产生指定范围的可迭代对象
bin：将十进制转成二进制
oct：将十进制转成八进制
hex：将十进制转成十六进制
chr：将二进制字节流转成字符串
ord：将字符串转成二进制字节流
eval：将字符串当做Python代码执行
exec：将字符串当做Python代码执行
repr：不转义字符输出字符串
input：接收输入的字符串
hash：生成哈希值
全局变量：函数外部的变量，作用范围：整个文件
局部变量：函数内部的变量，作用范围：仅函数内部
内置函数：内建命名空间
关键字：
globals（）：返回字典，存放全局作用域所有内容
locals（）：返回字典，存放当前作用域的所有内容
global：关键字：声明或修改全局变量
nonlocal：关键字：修改局部变量（当前函数上一层的局部变量）
变量的调用顺序采用LEGB原则
B -- Builtin（Python）；Python内置模块的命名空间
G -- Global（module）；函数外部所在的命名空间
E -- Enclosing function locals；外部嵌套函数的作用域
L -- Local（function）；当前函数内的作用域
依据就近原则，从上往下，从里到外依次寻找
# 获取闭包函数使用的变量 __closure__，cell_contents
（1）定义：内函数使用外函数的局部变量，并且外函数把内函数返回出来的方法叫闭包；返回的内函数叫闭包函数。
（2）特点：内函数使用了外函数的局部变量，外函数的局部变量与内函数发生绑定，延长该变量的生命周期
（3）意义：闭包可以优先使用外函数中的变量，并对闭包中的值起到了封装保护的作用，外部无法访问。
定义：用一句话表达只有返回值的函数。
语法：
lambda 参数 ：返回值
# （1）没有参数的 lambda 表达式
def func():
return "abc"
func = lambda : "abc"
res = func()
print(res)
# （2）有参数的 lambda 表达式
def func(num):
return num ** 2
func = lambda num : num ** 2
res = func(3)
print(res)
"""
三目运算符：
真区间值 if 条件表达式 else 假区间值
"""
# （3）带有判断条件的 lambda 表达式
def func(n):
if n % 2 == 0:
return "偶数"
else:
return "奇数"
func = lambda n : "偶数" if n % 2 == 0 else "奇数"
res = func(3)
print(res)
定义：能被 next 方法调用，并且不断获取下一个值的对象，叫迭代器（对象）
特征：迭代器会生成惰性序列，通过计算把值依次返回，边循环边计算而不是一次性返回所有值
优点：一次取一个值，节省空间
总结：
（1）惰性序列，节省内存空间
（2）遍历获取数据使用 next，方向不可逆
（3）迭代器可以遍历无限大的数据
可迭代对象：如果该对象成员中有 __iter__ 方法，就是可迭代对象。（dir 查看内部成员）
（1）iter(可迭代对象)（推荐使用）
（2）可迭代对象.__iter__()
# 定义一个迭代器
setvar = {"a","b","c","d"}
it = iter(setvar)
# 判断一个迭代器 1
lst = dir(it)
res = "__iter__" in lst and "__next__" in lst
print(res)
# 判断一个迭代器 2 （迭代器类型 可迭代对象类型）
from collections import Iterator,Iterable
res = isinstance(it,Iterator)
print(res)
# 调用迭代器
# （1）next 方法
res = next(it)
res = next(it)
res = next(it)
res = next(it)
print(res)
# （2）重置迭代器
it = iter(setvar)
# #### 获取迭代器中的数据
# （1）next
res = next(it)
print(res)
# （2）for 循环
for i in it:
print(i)
# （3）for + next
for i in range(2):
res = next(it)
print(res)
map(func,Iterable)
功能：
把 Iterable 可迭代对象中的值，逐个拿出来放到 func函数中进行处理，把处理的结果放到迭代器中返回出来
Iterable：可迭代对象（容器类型）
返回值：
迭代器
# ### map函数
lst = ["1,"2","3","4"]
lst_new = []
for i in lst:
lst_new.append( int(i) )
# map 改写
it = map(int,lst)
lst_new = list(it)
reduce(func,Iterable)
功能：
从Iterable 中一次性拿出2个数据，放到 func函数中进行计算，然后计算的结果和 Iterable 中的第三个数据再放到 func函数中，依次类推直到返回最终的结果。
返回值：
最后计算的结果
# ### reduce 函数
lst = [1,2,3,4] # --> 1234
# （1）
strvar = ""
for i in lst:
strvar += str(i)
intvar = int(strvar)
print(intvar)
# （2）reduce
from functools import reduce
def func(x,y):
return x * 10 + y
intvar = reduce(func,lst)
print(intvar)
sorted(Iterable,key=函数,reverse=False)
功能：排序
参数：
Iterable： 可迭代对象（容器类型数据、range对象、迭代器）
key：函数（自定义函数、或内置函数）
reverse = False 从小到大排序，reverse = True 从大到小排序
返回值：
排序后的结果（列表）
# ### sorted 函数
# （1）
tup = (1,3,2,11,-1,0)
lst = sorted(tup)
print(lst)
# （2）
tup = (1,3,2,55,11,24)
def func(n):
return n % 10
lst = sorted(tup,key=func)
print(lst)
总结：
sort 只能针对列表进行排序，直接修改原有列表
sorted 容器类型数据都可以排序，产生一个新的数据，数据类型是列表
filter(func,Iterable)
功能：
过滤
在自定义函数中，如果返回True，则保留该数据；如果返回False，则舍弃该数据。
返回值：
迭代器
# ### filter 函数
# （1）普通方法
lst = [1,2,3,4,5,6,7,8]
lst_new = []
for i in lst:
if i % 2 == 0:
lst_new.append(i)
print(lst_new)
# （2）filter
def func(n):
if n % 2 == 0:
return True
else:
return False
it = filter(func,lst)
lst_new = list(it)
print(lst_new)
# （3）匿名函数
it = filter(lambda n : True if n % 2 == 0 else False,lst)
lst_new = list(it)
print(lst_new)
通过一行循环判断，遍历出一系列数据的方式是推导式
列表推导式：[ var for var in Iterable ]
集合推导式：{ var for var in Iterable }
字典推导式：{ a:b for a,b in Iterable }
# （1）单循环推导式
lst = []
for i in range(1,11):
lst.append(i)
print(lst)
# 改写成推导式
lst = [ i for i in range(1,11) ]
print(lst)
# （2）带有单项分支判断条件的单循环推导式
lst = []
for i in range(1,11):
if i % 2 == 0:
lst.append(i)
print(lst)
# 改写成推导式
lst = [ i for i in range(1,11) if i % 2 == 0 ]
print(lst)
# （3）多循环推导式
lst1 = [1,3,5,7,9]
lst2 = [2,4,6,8,10]
lst_new = []
for i in lst1:
for j in lst2:
lst_new.append( i + j )
print(lst_new)
# 改写成推导式
lst_new = [ i + j for i in lst1 for j in lst2 ]
print(lst_new)
# （4）带有判断条件的多循环推导式
lst1 = [1,3,5,7,9]
lst2 = [2,4,6,8,10]
lst_new = []
for i in lst1:
for j in lst2:
if lst1.index(i) == lst2.index(j):
lst_new.append(i + j)
print(lst_new)
# 改写成推导式
lst_new = [ i + j for i in lst1 for j in lst2 if lst1.index(i) == lst2.index(j) ]
print(lst_new)
功能：枚举，将索引号和Iterable的值，一个个拿出来组成元组放到迭代器中。
参数：
Iterable：可迭代对象
start：开始的索引号（默认从 0 开始）
返回值：迭代器
listvar = ["a","b","c","d","e","f"]
dic = dict(enumerate(listvar))
print(dic)
# 字典推导式
dic = { b:a for a,b in enumerate(listvar) }
print(dic)
功能：将多个 Iterable 中的值，按照顺序一个个拿出来组成元组放到迭代器中，多出来的元素自动舍弃掉。
返回值：迭代器
lst1 = [1,2,3,4]
lst2 = ["a","b","c"]
lst3 = ["@","#","$","%"]
tup = tuple(zip(lst1,lst2,lst3))
print(tup)
# 字典推导式
dic = dict({ b:a for a,b in zip(lst1,lst2) })
print(dic)
#
dic1 = {"a":1,"b":2,"c":3}
dic2 = {1:100,2:200,3:300}
dic = dict( { a:b for a,b in zip(dic1.keys(),dic2.values()) } )
print(dic)
生成器：使用了 yield 的函数被称为生成器。
生成器是一个返回迭代器的函数，只能用于迭代操作，或生成器就是一个迭代器。
调用一个生成器函数，返回一个迭代器对象。
# 生成器
def fib(n):
a,b,count = 0,1,0
while count <= n:
yield a
a , b = b , a + b
count += 1
f = fib(10) # 返回一个迭代器
lst = list(f)
print(lst)
#
try:
f = fib(10)
while True:
print(next(f))
except:
pass
原文：https://www.cnblogs.com/weige007/p/12098648.html