Python函数式编程

此时，内部函数对外部函数作用域里变量的引用（非全局变量），则称内部函数为闭包。这里闭包需要有三个条件
三个条件，缺一不可：
1)必须有一个内嵌函数(函数里定义的函数）——这对应函数之间的嵌套
2)内嵌函数必须引用一个定义在闭合范围内(外部函数里)的变量——内部函数引用外部变量
3)外部函数必须返回内嵌函数——必须返回那个内部函数
当一个函数在本地作用域找不到变量申明时会向外层函数寻找，这在函数闭包中很常见
但是在本地作用域中使用的变量后，还想对此变量进行更改赋值就会报错
报错信息
in test_in 函数, number_in is 10
20
in test_in 函数, number_in is 90
100
# python交互环境编辑器
>>> def counter(start=0):
count = [start]
def incr():
count[0] += 1
return count[0]
return incr
>>> c1 = counter(5)
>>> print(c1())
6
>>> print(c1())
7
>>> c2=counter(50)
>>> print(c2())
51
>>> print(c2())
52
>>>
def test():
count = 1
def add():
print(count)
count += 1
return add
a = test()
a()

如果我在函数内加一行nonlocal count就可解决这个问题
代码
nonlocal声明的变量不是局部变量,也不是全局变量,而是外部嵌套函数内的变量。
如果从另一个角度来看我们给此函数增加了记录函数状态的功能。当然，这也可以通过申明全局变量来实现增加函
数状态的功能。当这样会出现以下问题：
使用nonlocal的好处是，在为函数添加状态时不用额外地添加全局变量，因此可以大量地调用此函数并同时记录
着多个函数状态，每个函数都是独立、独特的。针对此项功能其实还个一个方法，就是使用类，通过定义
__call__ 可实现在一个实例上直接像函数一样调用
代码如下：
Traceback (most recent call last):
......
UnboundLocalError: local variable 'count' referenced before assignment
# -*- coding: UTF-8 -*-
# 文件名 : nonlocal_a.py
def test():
count = 1
def add():
nonlocal count
print(count)
count += 1
return count
return add
a = test()
a()
# 1
a()
# 2
1. 每次调用函数时，都得在全局作用域申明变量。别人调用函数时还得查看函数内部代码。
2. 当函数在多个地方被调用并且同时记录着很多状态时，会造成非常地混乱。
# -*- coding: UTF-8 -*-
# 文件名：clos_c.py
def line_conf(a, b):
def line(x):
return a * x + b
return line

运行结果为
从这段代码中，函数line与变量a,b构成闭包。在创建闭包的时候，我们通过line_conf的参数a,b说明了这两个变量
的取值，这样，我们就确定了函数的最终形式(y = x + 1和y = 4x + 5)。我们只需要变换参数a,b，就可以获得不同的
直线表达函数。由此，我们可以看到，闭包也具有提高代码可复用性的作用。如果没有闭包，我们需要每次创建函
数的时候同时说明a,b,x。这样，我们就需要更多的参数传递，也减少了代码的可移植性。
但是还没有结束，我们知道，函数内部函数，引用外部函数参数或值，进行内部函数运算执行，并不是完全返回一
个函数，也有可能是一个在外部函数的值，我们还需要知道返回的函数不会立刻执行，而是直到调用了函数才会执
行。
看代码：
这里创建了一个fun_a函数，外部函数的参数fun_list定义了一个列表，在进行遍历，循环函数fun_b，引用外部变
量i 计算返回结果，加入列表，每次循环，都创建了一个新的函数，然后，把创建的3个函数都返回了
但是实际结果并不是我们想要的1,4,9,而是9，9，9，这是为什么尼？
这是因为，返回的函数引用了变量 i ，但不是立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，
每一个独立的函数引用的对象是相同的变量，但是返回的值时候，3个函数都返回时，此时值已经完整了运算，并
存储，当调用函数，产生值不会达成想要的，返回函数不要引用任何循环变量，或者将来会发生变化的变量，但是
如果一定需要尼，如何修改这个函数尼？
line1 = line_conf(1, 1)
line2 = line_conf(4, 5)
print(line1(5))
print(line2(5))
6
25
1.闭包似优化了变量，原来需要类对象完成的工作，闭包也可以完成
2.由于闭包引用了外部函数的局部变量，则外部函数的局部变量没有及时释放，消耗内存
def fun_a():
fun_list = []
for i in range(1, 4):
def fun_b():
return i * i
fun_list.append(fun_b)
return fun_list
f1, f2, f3 = fun_a()
print(f1(), f2(), f3())
# 结果：9，9，9

可以再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数
的值不变，那我们就可以完成下面的代码
7、装饰器
看一段代码：
# -*- coding: UTF-8 -*-
# 文件名 : closure_a.py
def fun_a():
def fun_c(i):
def fun_b():
return i * i
return fun_b
fun_list = []
for i in range(1, 4):
# f(i)立刻被执行，因此i的当前值被传入f()
fun_list.append(fun_c(i))
return fun_list
f1, f2, f3 = fun_a()
print(f1(), f2(), f3())
# 1 4 9
# -*- coding: UTF-8 -*-
# 文件名 : decor_b.py
def decor_a(func):
def decor_b():
print("I am decor_b")
func()
print("I am func")
return decor_b
def decor_c():
print("I am decor_c")
decor_c()
# outputs: "I am decor_c"

由于函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数。也可以将函数赋值变
量，做参传入另一个函数。
那什么是装饰器
装饰器的作用就是为已经存在的对象添加额外的功能
先看代码：
我们没有直接将decor_c函数作为参数传入decor_a中，只是将decor_a函数以@方式装饰在decor_c函数上。
也就是说，被装饰的函数，函数名作为参数，传入到装饰器函数上，不影响decor_c函数的功能，再次基础上可以
根据业务或者功能增加条件或者信息。
(注意：@在装饰器这里是作为Python语法里面的语法糖写法，用来做修饰。)
decor_c = decor_a(decor_c)
decor_c()
# outputs: I am decor_b
# I am decor_c
# I am func
装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值
也是一个函数对象。
它经常用于有以下场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝
佳设计
# -*- coding: UTF-8 -*-
# 文件名 : decor_b.py
# 装饰器
def decor_a(fun):
def decor_b():
print('I am decor_b')
fun()
print('I am fun')
return decor_b
@decor_a
def decor_c():
print('I am decor_c')
decor_c()
#outputs: I am decor_b
# I am decor_c
# I am fun

但是我们这里就存在一个问题这里引入魔术方法 __name__ 这是属于 python 中的内置类属性，就是它会天生就存
在与一个 python 程序中，代表对应程序名称，一般一段程序作为主线运行程序时其内置名称就是 __main__ ,当
自己作为模块被调用时就是自己的名字
代码：
这并不是我们想要的！输出应该是" decor_c "。这里的函数被decor_b替代了。它重写了我们函数的名字和注释文
档，那怎么阻止变化尼，Python提供functools模块里面的wraps函数解决了问题
代码：
我们在装饰器函数内，作用decor_c的decor_b函数上也增加了一个装饰器wraps还是带参数的。
这个装饰器的功能就是不改变使用装饰器原有函数的结构。
我们熟悉了操作，拿来熟悉一下具体的功能实现，我们可以写一个打印日志的功能
print(decor_c.__name__)
#outputs: decor_b
# -*- coding: UTF-8 -*-
# 文件名 : decor_c.py
from functools import wraps
# 装饰器
def decor_a(fun):
@wraps(fun)
def decor_b():
print('I am decor_b')
fun()
print('I am fun()')
return decor_b
@decor_a
def decor_c():
print('I am decor_c')
print(decor_c.__name__)
#outputs: decor_c
# -*- coding: UTF-8 -*-
# 文件名 : decor_d.py
from functools import wraps

带参装饰器
我们也看到装饰器wraps也是带参数的，那我们是不是也可以定义带参数的装饰器尼，
我们可以使用一个函数来包裹装饰器，调入这个参数。
def logs(fun):
@wraps(fun)
def with_logging(*args, **kwargs):
print(fun.__name__ + " Debug")
return fun(*args, **kwargs)
return with_logging
@logs
def decor(x):
return x + x
result = decor(4)
#outputs: decor Debug
# -*- coding: UTF-8 -*-
# 文件名 : log_b.py
from functools import wraps
def logs(logfile='out.log'):
def logging_decorator(fun):
@wraps(fun)
def wrapped_function(*args, **kwargs):
log_string = fun.__name__ + " Debug"
print(log_string)
# 打开logfile，并写入内容
with open(logfile, 'a') as opened_file:
# 现在将日志打到指定的logfile
opened_file.write(log_string + '\n')
return fun(*args, **kwargs)
return wrapped_function
return logging_decorator
@logs()
def decor_a():
pass
decor_a()

这里我们将带参数的带入进去根据代码流程执行生成了两个文件并将文件打印进去
现在我们有了能用于正式环境的logs装饰器，但当我们的应用的某些部分还比较脆弱时，异常也许是需要更紧急关
注的事情。比方说有时你只想打日志到一个文件。而有时你想把引起你注意的问题发送到一个email，同时也保留
日志，留个记录。这是一个使用继承的场景，但目前为止我们只看到过用来构建装饰器的函数。
# Output: decor_a Debug
# 现在一个叫做 out.log 的文件出现了，里面的内容就是上面的字符串
@logs(logfile='out1.log')
def decor_b():
pass
decor_b()
# Output: decor_b Debug
# 现在一个叫做 func2.log 的文件出现了，里面的内容就是上面的字符串
# -*- coding: UTF-8 -*-
# 文件名 : log_c.py
from functools import wraps
class Logs(object):
def __init__(self, logfile='out.log'):
self.logfile = logfile
def __call__(self, fun):
@wraps(fun)
def wrapped_function(*args, **kwargs):
log_string = fun.__name__ + " was called"
print(log_string)
# 打开logfile并写入
with open(self.logfile, 'a') as opened_file:
# 现在将日志打到指定的文件
opened_file.write(log_string + '\n')
# 现在，发送一个通知
self.notify()
return fun(*args, **kwargs)
return wrapped_function
def notify(self):
# Logs只打日志，不做别的
pass
@Logs()
def decor_a():
pass

这个实现有一个优势，在于比嵌套函数的方式更加整洁，而且包裹一个函数还是使用跟以前一样的语法
现在，我们给 logit 创建子类，来添加 email 的功能，当然这个功能不在这里详细赘述
这里我们继续继承并重写notify方法，完成发送邮件的功能
此时@EmailLogs 将会和 @Logs 产生同样的效果，但是在打日志的基础上，还会多发送一封邮件给管理员。
8、偏函数
Python的 functools 模块提供了很多有用的功能，其中一个就是偏函数（Partial function）。要注意，这里的
偏函数和数学意义上的偏函数不一样。
在介绍函数参数的时候，我们讲到，通过设定参数的默认值，可以降低函数调用的难度。而偏函数也可以做到这一
点。
例如：int() 函数可以把字符串转换为整数，当仅传入字符串时， int() 函数默认按十进制转换
但 int() 函数还提供额外的 base 参数，默认值为 10 。如果传入 base 参数，就可以做进制的转换
如果要转换大量的二进制字符串，每次都传入 int(x, base=2) 非常麻烦，于是，我们想到，可以定义一个
int2() 的函数，默认把 base=2 传进去：
# -*- coding: UTF-8 -*-
# 文件名 : log_c.py
from mysit.text4.log_c import Logs
class EmailLogs(Logs):
'''
一个logit的实现版本，可以在函数调用时发送email给管理员
'''
def __init__(self, email='admin@myproject.com', *args, **kwargs):
self.email = email
super(EmailLogs, self).__init__(*args, **kwargs)
def notify(self):
# 发送一封email到self.email
# 这里就不做实现了
pass
>>> int('123')
123
>>> int('12345', base=8)
5349
>>> int('12345', 16)
74565

代码：
把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单
继续优化，functools.partial 就是帮助我们创建一个偏函数的，不需要我们自己定义 int_1() ，可以直接使用下面的代码创
建一个新的函数 int_1
理清了 functools.partial 的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的
函数，调用这个新函数会更简单。
注意到上面的新的 int_2 函数，仅仅是把 base 参数重新设定默认值为 2 ，但也可以在函数调用时传入其他值
实际上固定了int()函数的关键字参数 base
相当于是：
当函数的参数个数太多，需要简化时，使用 functools.partial 可以创建一个新的函数，这个新函数可以固定住
原函数的部分参数，从而在调用时更简单
# 定一个转换义函数
>>> def int_1(num, base=2):
return int(num, base)
>>> int_1('1000000')
64
>>> int_1('1010101')
85
# 导入
>>> import functools
# 偏函数处理
>>> int_2 = functools.partial(int, base=2)
>>> int_2('1000000')
64
>>> int_2('1010101')
85
int2('10010')
kw = { base: 2 }
int('10010', **kw)