最近项目忙成狗，都没时间好好看看开发的东西了，正好最近开始看rest api的东西，真是个好东西啊。可以前后端分离，但是在学习的过程中，遇到各种问题。还是基础不够扎实。本次rest api的会一边遇坑一边补习之前的东西。
一 functools库
真是一个神奇的python库，以前一直没注意。
1 偏函数 partial
先找文档学习一下，最后看源码，源码能看懂就看，看不懂那就是真的看不懂了。
文档参考 https://blog.csdn.net/appleyk/article/details/77609114
partial 一共有三个部分：
（1）第一部分也就是第一个参数，是一个函数，这个函数可以是你定义的，也可以是Python内置函数
（2）第二部分是一个可变参数，*args，比如内置函数max的参数就是一个可变参数，max（1,2,3,4,5）=5
（3）第三部分是一个关键字参数，比如内置函数int的第二个参数就是命名关键字参数，默认base=10，表示int转换时默认是10进制的：
partial函数的作用就是：将所作用的函数作为partial（）函数的第一个参数，原函数的各个参数依次作为partial（）函数的后续参数，原函数有关键字参数的一定要带上关键字，没有的话，按原有参数顺序进行补充。
使用一下吧
A、偏函数的第二个部分(可变参数)，按原有函数的参数顺序进行补充，参数将作用在原函数上，最后偏函数返回一个新函数（类似于，装饰器decorator，对于函数进行二次包装，产生特殊效果；但又不同于装饰器，偏函数产生了一个新函数，而装饰器，可改变被装饰函数的函数入口地址也可以不影响原函数）
这里我的理解是：首先偏函数能做的事情，装饰器也能做，其次偏函数可以操作源函数的参数，可是装饰器可以操作函数的入口。那为啥还有偏函数，估计是因为比装饰器简单吧。用起来应该很爽。
案例：我们定义一个sum函数，参数为*args可变，计算这些可变参数的和。
扩展：我们想要对sum函数求和后的结果，再加上10加上20甚至加更多，得到一个新的结果。
实现：我们分别用decorator和partial来实现，对比一下二者的区别。
好激动，因为可以紧跟作者脚步可以复习一下装饰器的东西了。
（1）装饰器实现
基础：http://www.cnblogs.com/wanstack/p/9009932.html
# /usr/bin/env Python3
# -*- encoding:UTF-8 -*- from functools import wraps def sum_add(*args1): #我们要给我们的装饰器decorator，带上参数
def decorator(func):
@wraps(func) #加上这句，原函数func被decorator作用后，函数性质不变
def my_sum(*args2): #注意，参数要和原函数保持一致，真正实行扩展功能的是外层的装饰器
my_s = 0
for n in args1:
my_s = my_s +n #这个是我们新加的求和结果
return func(*args2) + my_s #这个，我们在原求和函数的结果上再加上s，并返回这个值
return my_sum #返回my_sum函数，该函数扩展原函数的功能
return decorator #返回我们的装饰器 @sum_add(10,20) #启用装饰器 对sum函数进行功能扩展
def sum(*args):
s = 0
for n in args:
s = s+n
return s
print(sum(1,2,3,4,5))
print(sum.__name__)
这里以前一直有一个疑问，今天突然间理解了，以前一直觉得为啥装饰器带上参数就需要写三层嵌套函数，因为@decorator没有()所以是不需要执行的，而加上参数@decorator(*args)是已经开始执行了啊。尼玛就是这么简单，当时困扰了好久。归根结底还是不理解。有时候想想做技术真的是理解了就是理解了，不理解死记硬背也不理解。
看看偏函数的实现：
# /usr/bin/env Python3
# -*- encoding:UTF-8 -*-
from functools import partial def sum(*args):
s = 0
for n in args:
s = s + n
return s sum_add_10 = partial(sum,10) #10 作用在sum第一个参数的位置
sum_add_10_20 = partial(sum,10,20) #10 20 分别作用在sum第一个和第二个参数的位置
print('A____________我们看下原函数sum的函数地址入口：')
print(sum)
print('B______我们看下partial函数返回函数的地址入口：')
print(partial(sum,10))
print(sum_add_10(1,2,3,4,5)) # --> 10 + 1 + 2 + 3 + 4 + 5 = 25
print(sum_add_10_20(1,2,3,4,5)) # --> 10 + 20 + 1 + 2 + 3 + 4 + 5 = 45
一步到位，当然还有其他方式一步到位的写法。这里的partial(函数，函数的第一个参数位置) 这部就是可以对已经存在的函数的参数中，继续传递参数吗。
B、偏函数的第三个部分(关键字参数)，按原有函数的关键字参数进行填补，参数将作用在原函数上，最后偏函数返回一个新函数
案例：我们定义一个mod求余函数，两个参数，一个是被除数，一个是除数，除数我们这里用命名关键字参数表示，默认值2
扩展：我们的除数不固定，可以是对2就行求余，也可以对3，对4，总之我们需要指定除数的值
返回结果： True 或 False
实现：原函数实现和partial函数实现
# /usr/bin/env Python3
# -*- encoding:UTF-8 -*-
import functools
def mod(m,*,key=2):
return m % key == 0
mod_to_2 = functools.partial(mod,key=2)
print('A__3___使用原函数的默认关键字参数对2进行求余：')
print(mod(3)) #对2进行求余-- 原函数 使用默认参数
print('B__3___使用偏函数对2进行求余：')
print(mod_to_2(3)) #对2进行求余-- 新函数 --偏函数产生
mod_to_5 = functools.partial(mod,key=5)
print('C__25___使用原函数的关键字参数对5进行求余：')
print(mod(25,key=5)) #对5进行求余 -- 原函数
print('D__25___使用偏函数对5进行求余：')
print(mod_to_5(25)) #对5进行求余 -- 新函数--偏函数产生
2 wraps
其实上面已经用到了wraps，一般在使用装饰器的时候会使用这个，他也是一个装饰器，至于为什么会用他，因为我们在使用装饰器的时候，会损失一些基本信息，比如fun.__name__等等，用上他，就不会了。
啥也不说了，直接上代码。
# coding:utf-8
from functools import partial WRAPPER_ASSIGNMENTS = ('__module__', '__name__', '__qualname__', '__doc__',
'__annotations__')
WRAPPER_UPDATES = ('__dict__',)
def update_wrapper(wrapper,
wrapped,
assigned = WRAPPER_ASSIGNMENTS,
updated = WRAPPER_UPDATES):
"""Update a wrapper function to look like the wrapped function wrapper is the function to be updated
wrapped is the original function
assigned is a tuple naming the attributes assigned directly
from the wrapped function to the wrapper function (defaults to
functools.WRAPPER_ASSIGNMENTS)
updated is a tuple naming the attributes of the wrapper that
are updated with the corresponding attribute from the wrapped
function (defaults to functools.WRAPPER_UPDATES)
"""
"""
try:
<语句>
except <name>：
<语句> #如果在try部份引发了名为'name'的异常，则执行这段代码
else:
<语句> #如果没有异常发生，则执行这段代码
finally:
print("不管有没有异常，我总是被执行了")
"""
print("wrapper==========" ,wrapper) # 这里的wrapper是一个inner函数
for attr in assigned:
try:
# 这里的wrapped应该是被装饰的函数，从wrapped中获取assigned的属性
value = getattr(wrapped, attr)
print("value============",value)
except AttributeError:
pass
else:
# 这里try执行了，这里就把value的值赋值给wrapper对象
setattr(wrapper, attr, value)
v = getattr(wrapper,attr)
print('v------',v)
for attr in updated:
print("getattr(wrapper, attr)",getattr(wrapper, attr)) # 这是个字典
getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
# Issue #17482: set __wrapped__ last so we don't inadvertently copy it
# from the wrapped function when updating __dict__
wrapper.__wrapped__ = wrapped
# Return the wrapper so this can be used as a decorator via partial()
return wrapper # 这个wrapper是一个inner def wraps(wrapped,
assigned = WRAPPER_ASSIGNMENTS,
updated = WRAPPER_UPDATES):
"""Decorator factory to apply update_wrapper() to a wrapper function Returns a decorator that invokes update_wrapper() with the decorated
function as the wrapper argument and the arguments to wraps() as the
remaining arguments. Default arguments are as for update_wrapper().
This is a convenience function to simplify applying partial() to
update_wrapper().
"""
# 其中update_wrapper是一个函数，wtrapped，assigned,updated是这个函数的关键字参数
# 这里执行update_wrapper函数，返回一个wrapper
return partial(update_wrapper, wrapped=wrapped,
assigned=assigned, updated=updated) def decorator(func):
"""
1. value = getattr(wrapped, attr) 从func中拿到一些属性信息
2. setattr(wrapper, attr, value) 把这些属性信息赋值给inner
3. return wrapper 返回inner
:param func:
:return:
"""
@wraps(func) # func = wraps(func)
def inner():
print('起床先睁眼')
func()
return inner @decorator # func = decorator(func)
def func():
print('早上起床') func() # 执行inner()
print(func.__name__)
print(func.__dict__)
可能看着有点乱，但是只要就是
1. value = getattr(wrapped, attr) 从func中拿到一些属性信息
2. setattr(wrapper, attr, value) 把这些属性信息赋值给inner
3. return wrapper 返回inner
做了这三件事情，当然了__dict__中的我没写，但是大概就是这么个流程，现在知道了即使，我们返回的是inner函数，也会对应的是func的信息。中间通过反射进行取值和赋值的操作。