函数:
函数也是一个对象，函数可以用来保存一些可以执行的代码，并且可以进行多次调用。
函数创建：
def 函数名([形参...])
def fun():
print('进来了')
print('要调用了')
fun()
当函数有返回值时：
def fun(a,b,**c):
return 'rel'
print(fun(a=1,b=3,c=2,e=4,h=6)) #rel
python是值传递还是引用传递
值传递就是函数调用时用的变量，函数内值发生变化时，函数外变量值不发生变化。
引用传递就是，函数内值发生变化时，函数外变量值也发生变化。
通过下面例子，我们可以得出，py的变量是普通变量时，其传递为值传递。如果变量是list，元组，dict，set等时，其为引用传递
a=2
def fun(a):
a=3
print(a) #3
fun(a)
print(a) #2
a=[1,3,4]
def fun(a):
a.pop()
print(a) #[1, 3]
fun(a)
print(a) #[1, 3]
函数的参数：
在定义函数时，可以在函数名后面的()中定义数量不等的形参。
- 形参，定义形参相当于在函数内部声明了变量，但是并不赋值
- 实参，如果在函数定义时，指定了形参，那么在调用函数时也必须传递实参，实参将赋值给对应的形参。
函数参数:
- 普通函数参数: fun(a,b,c)
- 指定形参默认值:fun(a=1,b=3,c=5)
函数调用时，如果传递了参数，则默认值无用，如果没有传递，则使用默认值，如果传递的参数不够，则按顺序赋值
def fun(a=2,b=3,c=10):
print(a) #1
print(b) #3
print(c)#10
fun(1)
- 关键字参数: 可以不按照形参定义的顺序去传递，直接根据参数名去传递
def fun(a=2,b=3,c=10):
print(a) #6
print(b) #3
print(c)#1
fun(c=1,b=3,a=6)
位置参数和关键字参数可以混用，混用时，必须将位置参数写到前面，并且位置参数和关键字参数传值不能针对同一个变量，否则会报错
def fun(a=2,b=3,c=10):
print(a) #1
print(b) #6
print(c)#3
fun(1,c=3,b=6)
不定长参数
- def fun(*num): 实际就是可变参数，实际上就是一个元组。
函数的参数中，带星号的形参只能传递一个，可以和其它参数配合使用，需要注意的是，带星号的形参并不需要是最后一个形参，只不过它后面的形参在传值时，必须以关键字参数形式传递。如果后面的参数没有指定，则会报错
def fun(a,*b,c):
print(a) #1
print(b) #(3, 5, 6, 3)
print(c)#2
fun(1,3,5,6,3,c=2)
- 如果在形参的开头直接写一个*，则要求所有参数必须关键字传参
def fun(*,a,b,c):
print(a) #1
print(b) #3
print(c)#2
fun(a=1,b=3,c=2)
- ** 形参可以接收其它关键字参数，并会将其保存在dict中国，key为参数名字，value就是参数的值
def fun(a,b,**c):
print(a) #1
print(b) #3
print(c)#{'c': 2, 'e': 4, 'h': 6}
fun(a=1,b=3,c=2,e=4,h=6)
help()函数
- help()函数是py中的内置函数，可以通过help(fun)来查看函数的用法
- 文档字符串： 在定义函数时，可以在函数内部编写文档字符串。当我们调用help() 查看函数时，就可以看到文档字符串，也就是说明书。
def fun(a,b,**c):
'''
文档说明书
:param a:
:param b:
:param c:
:return:
'''
return 'rel'
help(fun)
命名空间(namespace)/locals()
命名空间指的是变量存储的位置，每一个变量都需要存储到指定的命名空间当中，每一个作用域都会有一个对应的命名空间。函数的namespace实际上就是一个存储变量的字典
def fun(a,b,**c):
print(locals()) #函数
e=2
h=1
print(locals()) #全局
fun(a=1,b=3,c=2,e=4,h=6)
#结果
{'__spec__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000220E4B76C50>, '__doc__': None, 'h': 1, '__name__': '__main__', 'fun': , '__builtins__': , 'e': 2, '__package__': None, '__cached__': None, '__file__': 'E:/python/data/01.py'}
{'c': {'c': 2, 'h': 6, 'e': 4}, 'a': 1, 'b': 3}
函数式编程
在py中，函数是一等对象。一等对象有以下特点:
- 对象是运行时创建的
- 能赋值给变量或者作为数据结构中的元素
- 能作为参数传递
- 能作为返回值返回
高阶函数：
高阶函数需要符合以下两个特点中的一个：
- 接收一个或者多个函数作为参数
- 将函数作为返回值返回
当我们使用一个函数作为参数时，实际上是将指定的代码传递进了目标函数。
map()函数：
常规来说，我们需要对list每一个元素进行操作，那么我们创建一个函数，里面进行循环，实际上我们可以使用map()函数。这种方法，实际上就比传统写循环快
def fun(x):
return x*x
a=[1,3,4,5]
ll=map(fun,a)
#map（）返回的是一个Itertor（迭代器），需要将其转化为list
print(list(ll))
filter()函数:过滤器
传入两个参数，一个函数和一个序列，将函数作用于序列中每一个数，用函数条件进行判断，函数返回结果为True的才进行保留
def fun(x):
return x%2==1
a=[1,3,4,5]
ll=filter(fun,a)
#map（）返回的是一个Itertor（迭代器），需要将其转化为list
print(list(ll)) #[1, 3, 5]
sort()函数:
sorted函数也是一个高阶函数，他可以额外接受一个key函数来实现自定义排序,如按照绝对值排序
>>> sorted([12,-12,32,45,67,-1212],key=abs)
[12, -12, 32, 45, 67, -1212]
如果要实现忽略大小写的排序，则可以这样写
>>> sorted(['bob','about','Zoo','Credit'],key=str.lower)
['about', 'bob', 'Credit', 'Zoo']
当要进行反向排序时，可以传入第三个参数reverse=True
>>>sorted(['bob','about','Zoo','Credit'],key=str.lower,reverse=True)
['Zoo', 'Credit', 'bob', 'about']
闭包:
当一个函数返回了一个函数后，其内部的局部变量还被新函数引用。返回的函数没有被立即执行，知道调用返回的函数时才被执行。
>>> def count():
... fs=[]
... for i in range(1,4):
... def f():
... return i*i
... fs.append(f)
... return fs
...
>>> f1,f2,f3=count()
>>> f1()
9
>>> f2()
9
>>> f3()
9
因为i*i是函数，因此实际上返回的是函数，此时结果并么有计算出来，并且i还被后边的循环继续使用。
- 注意: 返回闭包时，不要让返回函数引用任何的循环变量，或者后续会发生变化的变量
lambda表达式(匿名函数)
专门用来创建一些简单的函数
语法：lambda 参数列表：返回值
a=1
b=12
print(lambda a,b:a+b)
#lambda表达式也可以进行赋值
f=lambda a,b:a+b
print(f(a,b))
装饰器
在一些情况下，希望为函数增加功能，又不想修改原函数，可以使用装饰器。
def log(old):
'''
:param old: 需要增强的函数
:return:
'''
def new_fun(*args,**kw):
print('开始')
res=old(*args,**kw)
print('结束')
return res
return new_fun
def log1(old):
'''
:param old: 需要增强的函数
:return:
'''
def new_fun1(*args,**kw):
print('log1开始')
old(*args, **kw)
print('log1结束')
return old(*args,**kw)
return new_fun1
#存在多个装饰器时，远离函数的装饰器，在最远离函数的地方执行，如log就在最远离函数的地方执行
@log
@log1
def fun(a):
print(a)
fun('s')