一.函数
1.函数定义
# 定义一个函数:
def my_len():
函数体
# def 关键字 -- 定义
# func 函数名 -- 和变量定义规则一样
# () 必须要写格式
# : 声明语句结束
2.参数
# 形参: 函数的定义中括号里是形参
# 实参: 函数的调用括号里是实参
# 位置传参时 形参和实参必须一一对应
# 传参: 将实参传递给形参的过程就是传参
1.位置参数
def fun(a,b):
print(a,b)
fun("A","B")
2.默认参数
def fun2(a=1,b=2):
pass
# fun2() #不传参，默认打印1，2
# fun2(a=10,b=20) #传参，覆盖
3.混合参数(位置参数必须在默认参数前面)
def fun3(a,b,c=1):
print(a,b)
fun3(1,2,c=10)
4.仅限关键字参数(必须在*args和**kwargs之间，如c)
def fun4(a,*args,b=10,c,**kwargs)
print(a,*args,b,c,kwargs) #1 12 10 20 {'m': 10}
fun4(1,12,b=10,c=20,m=10) #注意实参必须是c=10
3.动态参数
#参数优先级：位置参数>动态参数>默认参数>动态关键字
'''
def fun(a,b,*args,c=1,d=2,**kwargs):
print(a,b,args,c,d,kwargs)
fun(1,2,3,4,e=5,f=6) #1 2 (3,4) 1 2 {e:5,f:6}
'''
1.动态位置参数
--函数定义时星号加变量(*args)将传入的值聚合为元组赋值给变量args，在函数内部使用时星号加变量(*args)为打散
def fun(*args):
print(args) #打印元组, (1,2,3)
print(*args) #打散 1,2,3
fun(1,2,3)
2.动态默认参数
--函数定义时双星号加变量(**kwargs)将传入的关键参数聚合为字典赋值给变量kwargs，在函数内部使用星号加变量(*kwargs)将键打散
def fun(**kwargs):
print(kwargs) #{"a":1,"b":2}
print(*kwargs) #打散键 得到两值a b
#print(**kwargs) #报错
fun(a=1,b=2)
3.动态参数混合
-优先级：位置参数>默认参数
def fun(*args,**kwargs):
print(args,kwargs) #(1,2) {"a":1,"b":2}
fun(1,2,a=1,b=2)
4.其他
dic = {"key":1,"key1":34}
def func(**kwargs):
print(kwargs)
func(**dic) #此处将dic打散成key=1,key1=34
lst = [1,2,3,4]
def fun(*args):
print(args)
fun(*lst) #此处将lst打散成1 2 3 4传入
4.return返回值(终止的是函数，非for循环)
1.
def fun():
print("你好")
print(fun()) #fun()调用函数执行print("你好"),没有return，返回None
# 打印结果：
# 你好 None
5.函数的注释
1.添加注释：在函数内部打上6个引号('''''' or """""")回车即可。
def func(a,b):
"""
逻辑判断...
:param a: str
:param b: int
:return: bool
"""
print(a,b)
2.查看注释
print(fun.__doc__)
6.global和nonlocal
1.global：golbal的两个作用1:修改全局变量。2:在局部定义全局变量。
a = 1
def fun1():
a = 2
def fun2():
a = 3
def fun3():
global a
a +=1
fun3()
fun2()
fun1() #执行结果 a=2
#由上个例子可知：无论嵌套多深，global只修改最外层全局变量的值
2.nonlocal:修改局部变量(修改最近的上一层变量，如果上一层没有找到，则继续向上找，直到第一层函数)
a = 1
def fun1():
a =2
def fun2():
def fun3():
nonlocal a
a += 1
fun3()
fun()
fun1()
# fun1()中的a找上层fun2()，没有，继续向上找，fun1()中有,如果fun1()中如果没有，报错
二.函数名的第一类对象及使用
1.1 函数名可以当做值被赋值
1.2 函数名可以改当做元素存放在容器中
1.3 函数名可以当做另一个函数的参数
1.4 函数名可以当做返回值
三.名称空间
内置名称空间：我们从python官网下载的python解释器，也就是安装的python文件目录
全局名称空间：当前的py文件，我们将全局中变量和值的对应关系存储的空间，叫做全局名称空间。
局部名称空间：函数中开辟的空间
加载顺序：内置空间>全局空间>局部空间
--名称空间加载到内存的顺序
取值顺序：局部空间>全局空间>内置空间
--先从局部找，直到内置空间，如果内置空间找不到，则报错
#python解释器执行时，就会将内置名称空间加载到内存，程序向下运行，遇到变量和值就开辟全局名称空间，并将其加载到全局名称空间，遇到函数，将函数名和对应地址加载到内存，此时不创建局部命名空间。一旦函数执行，就创建临时空间(局部名称空间)，此时再依次将函数中的变量和值的对应关系添加到局部名称空间，函数调用完毕，就关闭局部名称空间。
---------------------------------------------------------------------------
作用域：
全局作用域：内置空间+全局空间
局部作用域：局部空间
四.匿名函数
1.匿名函数定义
def 用来定义有名函数; lambda 用来定义无名函数 结构： lambda 参数:函数体 (lambda函数默认有返回值)
2.lambda函数使用原因
#我们先简单定义一个函数
def foo(x,y):
return x**y
#下面使用lambda函数重新定义上面的函数
f = lambda x,y:x**n #此处默认就是return x**n
print(f(2,2))
#打印结果 4
#ps:2
f = lambda x,y:print(x**y)
print(f(2,2))
#打印结果 4 None
#因为lambda函数有默认返回值，此处函数体中有print()，外部调用返回None
五.内置函数
引用：http://39.97.99.7/python/14%20%E5%86%85%E7%BD%AE%E5%87%BD%E6%95%B0%E4%BA%8C.html
高阶函数(函数内部将可迭代对象for循环遍历)-------------------------------
# map() func iter1 返回map对象
# filter() func iterable 返回filter对象
# reduce() fun iterable 返回值
# sorted() iterable key 返回新列表
# max() iterable key
# min() iterable key
--------------------------------------
# zip() 返回zip对象
#max,min,sorted,map,filter,reduce
1.max()
--得到下列字典中薪酬最多的人名
s1 = {"egon":3000,"alex":100000,"wupeizhi":1000,"yuanhao":200}
...调用有名函数
def fun(k):
return s1[k]
max(s1,key=fun)
...调用匿名函数
max(s1,key=lambda x:s1[x])
#简述上方调用有名函数：
'''
max()中默认参数是一个序列，如果没有key值，就是按照s1取大小，并返回最大值；如果有key，就是按照key值来取大小，但同样返回s1中的值。此处将循环s1，将得到的值依次作为参数传递给fun()函数，max()函数就是比较key中值的大小，并返回对应的s1中的值。
'''
2.sorted()
--按照列表中数据的平方来排序
lst = [1,4,3,-6,9,2]
print(sorted(lst,key = lambda x:x**2))
#打印结果：[1, 2, 3, 4, -6, 9]
#简述上述方法：
'''
sorted()本来返回排序好的列表序列，此处将lst遍历循环，同时将每个值作为参数传递给lambda函数中的x，比较x的平方的大小
因为1**2 < 2**2 < 3**2 < 4**2 < -6**2 <-9**2,因此返回列表[1, 2, 3, 4, -6, 9]
'''
3.map() 映射
--将lst列表中的每个值平方
lst = [1,2,4,6]
res = map(lambda x:x**2,lst) #将lst列表中每个值传给lambda函数，返回平方后的值
print(list(res))
--拼接_SB,最后一个_NB
lst1 = ["小芳","大狗","王丹","黎明"]
res = map(lambda x:x+"_NB" if x == "黎明" else x+"_SB",lst1)
print(list(res)) #["小芳_SB","大狗_SB","王丹_SB","黎明_NB"]
4.reduce 拼接
from functools import reduce
--1到100相加
res = reduce(lambda x,y:x + y,range(1,101),0) #将0作为初始值与函数中的1相加，得到结果再与函数中的下个数相加，依次类推
--拼接下列列表为字符串
lsts = ["my","xx","42","fg","s2"]
reduce(lambda x,y:x+y,lsts) #将lsts中的第一二个值作为参数传递给x,y，得到的结果再与lsts中第三个数拼接，依次类推
print(reduce(lambda x,y:x+y,lsts)) #'myxx42fgs2'
5.filter() 过滤
--过滤下面列表中大于2的数
lsts = [4,2,1,5,62,1,0]
filter(lambda x:x>2,lsts)
print(list(filter(lambda x:x>2,lsts))) #[4,5,62]
6.reversed 反转
lst = [1,2,3,4,5]
lst1 = list(reversed(lst))
print(lst)
print(lst1)
7.zip
lst = [1,2,3,4]
lst1 = (1,2,3)
for i in zip(lst,lst1):
print(i)
#(1,1)
#(2,2)
#(3,3)
8.format
print(format(13,">20")) # 右对齐
print(format(13,"<20")) # 左对齐
print(format(13,"^20")) # 居中
#十进制转换成其他进制
print(format(13,"08b")) # 2
print(format(13,"08d")) # 10
print(format(13,"08o")) # 8
print(format(12,"08x")) # 16
六.闭包
参考:http://39.97.99.7/python/13-2%20%E9%97%AD%E5%8C%85.html
1.定义
在嵌套函数内，使用非全局变量（且不是本层变量）就是闭包。
2.格式
def fun():
avg_lst = [] #自由变量
def f2(price): #price是本层变量
avg_lst.append(price)
return avg_lst
return f2
ret = fun()
print(ret.__closure__) #判断是否是闭包
print(ret.__code__.co_cellvars)#判断是否有avg_lst这个自由变量
print(ret.__code__.co_varnames)#获取局部变量
3.坑
1.闭包不一定非得有return返回值
def wrapper():
lst = []
def inner():
lst.append(6)
print(lst)
print(inner.__code__.co_freevars)
wrapper()
2.
def wrapper():
lst = []
def inner():
lst.append(6)
print(lst)
return inner
wrapper()() #[6]
wrapper()() #[6]
wrapper()() #[6]
#ret = wrapper()
#ret() #[6]
#ret() #[6,6]
#ret() #[6,6,6]
4.应用
1.可以保存一些非全局变量但是不易被销毁、改变的数据
2.装饰器
a = []
def fun1():
for i in range(10):
a.append(i)
a.append(10) #这样的话外部也能修改，因此将此嵌套进函数内（保证数据的安全性）
5.作用
保存局部信息不被销毁，保证数据安全性
来源：https://www.cnblogs.com/gaoyukun/p/11196845.html