装饰器
装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。
它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。
def foo():
print('i am foo')
现在有一个新的需求，希望可以记录下函数的执行日志，于是在代码中添加日志代码：
def foo():
print('i am foo')
logging.info("foo is running")
bar()、bar2()也有类似的需求，怎么做？再写一个logging在bar函数里？这样就造成大量雷同的代码，为了减少重复写代码，我们可以这样做，重新定义一个函数：专门处理日志 ，日志处理完之后再执行真正的业务代码
def use_logging(func):
logging.warn("%s is running" % func.__name__)
func()
def bar():
print('i am bar')
use_logging(bar)
逻辑上不难理解， 但是这样的话，我们每次都要将一个函数作为参数传递给use_logging函数。而且这种方式已经破坏了原有的代码逻辑结构，之前执行业务逻辑时，执行运行bar()，但是现在不得不改成use_logging(bar)。那么有没有更好的方式的呢？当然有，答案就是装饰器。
def use_logging(func): # 不带参数的装饰器 第一个def 参数就是func，带参数的装饰器，第一个def参数是装饰元素参数，第二个def参数才是func,注意区分（都是套路）
# 装饰器就是某种闭包，总是return一些函数
def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args, **kwargs)
return wrapper
def bar():
print('i am bar')
bar = use_logging(bar)
bar()
函数use_logging就是装饰器，它把执行真正业务方法的func包裹在函数里面，看起来像bar被use_logging装饰了。在这个例子中，函数进入和退出时 ，被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。
@符号是装饰器的语法糖，在定义函数的时候使用，避免再一次赋值操作
def use_logging(func):
# 不带参数的装饰器 第一个def 参数就是func，带参数的装饰器，第一个def参数是装饰元素参数，第二个def参数才是func,注意区分（都是套路）
def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper # return几回，最终回去的还是func
@use_logging
def foo():
print("i am foo")
@use_logging
def bar():
print("i am bar")
bar() # 相当于省去`bar = use_logging(bar)`
如上所示，这样我们就可以省去bar = use_logging(bar)这一句了，直接调用bar()即可得到想要的结果。如果我们有其他的类似函数，我们可以继续调用装饰器来修饰函数，而不用重复修改函数或者增加新的封装。这样，我们就提高了程序的可重复利用性，并增加了程序的可读性。
带参数的装饰器
装饰器还有更大的灵活性，例如带参数的装饰器：在上面的装饰器调用中，比如@use_logging，该装饰器唯一的参数就是执行业务的函数。装饰器的语法允许我们在调用时，提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。
In [10]: import logging
In [11]: def use_logging(level):
...: def decorator(func):
...: def wrapper(*args, **kwargs):
...: if level == 'warn':
...: logging.warn('%s is running'% func.__name__)
...: return func(*args)
...: return wrapper
...: return decorator
...:
In [12]: @use_logging(level="warn")
...: def foo(name="foo"):
...: print('i am %s'% name)
...:
In [13]: foo()
/usr/local/bin/ipython3:5: DeprecationWarning: The 'warn' function is deprecated, use 'warning' instead
import sys
WARNING:root:foo is running
i am foo
In [14]: @use_logging(level)
...: def foo(name="foo"):
...: print('i am %s'% name)
...:
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-14-203ce5546292> in <module>()
----> 1 @use_logging(level)
2 def foo(name="foo"):
3 print('i am %s'% name)
4
NameError: name 'level' is not defined
上面的use_logging是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当我 们使用@use_logging(level="warn")调用的时候，Python能够发现这一层的封装，并把参数传递到装饰器的环境中。
类装饰器
再来看看类装饰器，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器还可以依靠类内部的__call__方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。
In [19]: class Foo(object):
...: def __init__(self,func):
...: self._func = func
...: def __call__(self): # 内置的特殊函数
...: print('class decorator running')
...: self._func()
...: print('class decorator ending')
...:
In [20]: @Foo
...: def bar():
...: print('bar')
...:
In [21]: bar()
class decorator running
bar
class decorator ending
functools.wraps
使用装饰器极大地复用了代码，但是他有一个缺点就是原函数的元信息不见了，比如函数的docstring、__name__、参数列表，先看例子：
装饰器
def logged(func):
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging
函数
@logged
def f(x):
"""does some math"""
return x + x * x
该函数完成等价于：
def f(x):
"""does some math"""
return x + x * x
f = logged(f)
不难发现，函数f被with_logging取代了，当然它的docstring，__name__就是变成了with_logging函数的信息了。
print f.__name__ # prints 'with_logging'
print f.__doc__ # prints None
这个问题就比较严重的，好在我们有functools.wraps，wraps本身也是一个装饰器，它能把原函数的元信息拷贝到装饰器函数中，这使得装饰器函数也有和原函数一样的元信息了。
from functools import wraps
def logged(func):
@wraps(func) # 引入wraps,其他代码不动，即解决问题
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging
@logged
def f(x):
"""does some math"""
return x + x * x
print f.__name__ # prints 'f'
print f.__doc__ # prints 'does some math'
内置装饰器
@staticmathod、@classmethod、@property
装饰器的顺序
@a
@b
@c
def f ():
等效于
f = a(b(c(f)))
函数与方法
类的函数称为方法（method），模块里的函数称为函数（function）。凡是def foo()这种，都是函数，在类中定义的函数，就是方法。
每一个包，模块，类，函数，方法都应该包含文档，包括类的__init__方法
特殊函数__call__
所有的函数都是可调用对象。
一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法__call__()。
我们把 Person 类变成一个可调用对象：
class Person(object):
def __init__(self, name, gender):
self.name = name
self.gender = gender
def __call__(self, friend):
print 'My name is %s...' % self.name
print 'My friend is %s...' % friend
现在可以对 Person 实例直接调用：
>>> p = Person('Bob', 'male')
>>> p('Tim')
My name is Bob...
My friend is Tim...
单看p('Tim')你无法确定p是一个函数还是一个类实例，所以，在Python中，函数也是对象，对象和函数的区别并不显著。
函数封装
函数封装是一种函数的功能，它把一个程序员写的一个或者多个功能通过函数、类的方式封装起来，对外只提供一个简单的函数接口。当程序员在写程序的过程中需要执行同样的操作时，程序员（调用者）不需要写同样的函数来调用，直接可以从函数库里面调用。程序员也可以从网络上下载的功能函数，然后封装到[编译器]的[库函数]中，当需要执行这一功能的函数时，直接调用即可。而程序员不必知道函数内部如何实现的，只需要知道这个函数或者类提供什么功能。
语法糖
语法糖(Syntactic sugar),是由Peter J. Landin(和图灵一样的天才人物，是他最先发现了Lambda演算，由此而创立了函数式编程)创造的一个词语，它意指那些没有给计算机语言添加新功能，而只是对人类来说更“甜蜜”的语法。语法糖往往给程序员提供了更实用的编码方式，有益于更好的编码风格，更易读。不过其并没有给语言添加什么新东西。
对于列表形如list_1 = [[1, 2], [3, 4, 5], [6, 7], [8], [9]]转化成列表list_2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]的问题。
一般方法
list_1 = [[1, 2], [3, 4, 5], [6, 7], [8], [9]]
list_2 = []
for _ in list_1:
list_2 += _
print(list_2)
更Pythonic的方法二，列表推导
list_1 = [[1, 2], [3, 4, 5], [6, 7], [8], [9]]
[i for k in list_1 for i in k] # ⚠️注意，这里没有 , 号
抽象用法（知道就好但不推荐哦）
list_1 = [[1, 2], [3, 4, 5], [6, 7], [8], [9]]
sum(list_1, [])
sum的第一个参数为可迭代对象即可，第二个参数默认为0
lambda表达式
函数式那一套黑魔法-语法糖
+1函数
f=lambda x:x+1
max函数（条件语句的写法如下）
f_max=lambda x,y:x if x>y else y
filter, map, reduce
filter函数接受两个参数，第一个是过滤函数，第二个是可遍历的对象，用于选择出所有满足过滤条件的元素
去除小写字母
s=filter(lambda x:not str(x).islower(),"asdasfAsfBsdfC")
for ch in s:
print(ch)
map函数接受的参数类型与filter类似，它用于把函数作用于可遍历对象的每一个元素。类似于数学中映射的概念。
例：求y=2x+1（偷偷用了一下range函数生成定义域）
s=map(lambda x:2*x+1,range(6))
for x in s:
print(x)
range(6) = range(0, 6) = [ 0 ,1, 2, 3, 4, 5 ]
函数原型：range（start， end， scan):
range()函数可创建一个整数列表，一般用在 for 循环中计数从start开始到end结束，但不包括end,scan：每次跳跃的间距，默认为1
reduce函数对每个元素作累计操作，它接受的第一个参数必须是有两个参数的函数。
In [54]: from functools import reduce
In [55]: s = reduce( lambda x,y: x+y, range(1,6) )
In [56]: print(s)
15
求乘积（第三个可选参数表示累计变量的初值）
from functools import reduce
s=reduce(lambda x,y:x*y,range(1,6),1)
print(s)
# 120
柯里化(curry)函数
如果一个函数需要２个参数，而你只传入一个参数，那么你就可以得到一个柯里化的函数，这是函数式编程语言的重要特性之一
*3函数
f_mul=lambda x,y:x*y
from functools import partial
mul3=partial(f_mul,3)
print(mul3(1))
print(mul3(6))
注：匿名函数过多会影响代码效率，劲酒虽好，不能贪杯
廖神关于装饰器的解释
如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数，写出来会更复杂。比如，要自定义log的文本：
def log(text): # text是想打印出的装饰提示，func指代的就是需要被装饰的函数，都是这样的套路
def decorator(func): # 记住套路！！！
def wrapper(*args, **kw):
print('%s %s():' % (text, func.__name__))
return func(*args, **kw)
return wrapper
return decorator
这个3层嵌套的decorator用法如下：
@log('execute')
def now():
print('2015-3-25')
执行结果如下：
>>> now()
execute now():
2015-3-25
和两层嵌套的decorator相比，3层嵌套的效果是这样的：
>>> now = log('execute')(now)
我们来剖析上面的语句，首先执行log('execute')，返回的是decorator函数，再调用返回的函数，参数是now函数，返回值最终是wrapper函数。
以上两种decorator的定义都没有问题，但还差最后一步。因为我们讲了函数也是对象，它有__name__等属性，但你去看经过decorator装饰之后的函数，它们的__name__已经从原来的'now'变成了'wrapper'：
>>> now.__name__
'wrapper'
因为返回的那个wrapper()函数名字就是'wrapper'，所以，需要把原始函数的__name__等属性复制到wrapper()函数中，否则，有些依赖函数签名的代码执行就会出错。
不需要编写wrapper.__name__ = func.__name__这样的代码，Python内置的functools.wraps就是干这个事的，所以，一个完整的decorator的写法如下：
import functools
def log(func):
@functools.wraps(func) # 加这一行就可以了，其他代码不变
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper
或者针对带参数的decorator：
import functools
def log(text):
def decorator(func):
@functools.wraps(func) # 加这一行就可以了，其他代码不变
def wrapper(*args, **kw):
print('%s %s():' % (text, func.__name__))
return func(*args, **kw)
return wrapper
return decorator
