返回函数
函数作为返回值。
def A(n):
def a():
return n
return a
调用A时，返回函数a，调用a时，返回值
>>> A(2)
<function A.<locals>.a at 0x1085fcea0>
>>> A(2)()
2
闭包
在函数里又定义了新函数，内部函数可以引用外部函数的参数和局部变量，当外部函数返回内部函数时，相关参数和变量都存在返回的函数中
调用A()时，每次调用都会返回一个新的函数，即使传入相同的参数
>>> A(2)==A(2)
False
返回的函数并没有立刻执行，而是直到调用了fs()才执行
def count():
fs = []
for i in range(1, 4):
def f():
return i*i
fs.append(f)
return fs
#此时 调用count函数， count()返回三个函数
>>> count
<function count at 0x108621048>
>>> count()
[<function count.<locals>.f at 0x1085f51e0>, <function count.<locals>.f at 0x108621158>, <function count.<locals>.f at 0x1086210d0>]
#看看调用每一个函数返回什么值
>>> [x() for x in count()]
[9, 9, 9]
都是9~返回一个函数时，牢记该函数并未执行，返回函数中不要引用任何可能会变化的变量。
def count():
def f(j):
def g():
return j*j
return g
fs = []
for i in range(1, 4):
fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
return fs
>>> [x() for x in count()]
[1, 4, 9]
fs.append(f) f最后才被计算
fs.append(f(i)) f(i)立刻被执行，因此i的当前值被传入f()
匿名函数
lambda 函数参数:函数式
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。几个常见用法：
- 高阶函数
>>> list(map(lambda x: x * x, [1, 2, 3]))
[1, 4, 9]
- 赋值给变量再通过变量调用
>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25
- 作为返回值返回
def build(x, y):
return lambda: x * x + y * y
装饰器
在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）
decorator就是一个返回函数的高阶函数，接受一个函数作为参数，并返回一个函数。
def log(func):
def wrapper():
print('call %s():' % func.__name__)
return func()
return wrapper
- 传入一个函数func，返回一个函数wrapper， wrapper就是装修后的func。网上有人讨论说不需要两层，一层就可以了，其实不行，因为一层会直接print后返回函数。我们要的是先拿到这个装饰器，是个把print含在里面的函数。
- 在这个例子中，使用方法：
func=log(func)等价于@log加在 func()函数定义处前
这时func成了wrapper，这时调用func()时，返回print以及原func()
@log
def now():
print('2015-3-25')
#相当于
now = log(now)
要自定义那个"call:"可以再嵌套一层（外面那层是为了注入里层变量text）
def log(text):
def decorator(func):
def wrapper():
print('%s %s():' % (text, func.__name__))
return func()
return wrapper
return decorator
@log('execute')
def now():
print('2015-3-25')
#相当于
now = log('execute')(now)
但是经过装饰后， func.__name__现在变成了 'wrapper'而不是'func'了，如下
>>> now.__name__
'wrapper'
因为now现在是log(now) 也就是wrapper
所以应该需要wrapper.__name__ = func.__name_这样一个过程，或者交给functools.wraps
import functools
def log(func):
@functools.wraps(func)
def wrapper():
print('call %s():' % func.__name__)
return func()
return wrapper
练习
请编写一个decorator，能在函数调用的前后打印出'begin call'和'end call'的日志。
import functools
def log(func):
@functools.wraps(func)
def wrapper():
print('begin call')
func()
print('end call')
return func()
return wrapper
@log
def now():
print(123)
>>> now()
begin call
123
end call
123
咋办呢，难道我就return None？这样岂不是破坏了原来的func函数
思考
关于能否写出一个@log的decorator，使它既支持log又支持log()
Opera2952162625 created at 4-8 17:21, Last updated at 4-8 17:21
这个问题的本质是
对于@log而言，以now()函数为例，变成now=log(now)
对于@log(text)而言，变成now=log(text)(now)
如何使得在函数log()中能够检测到这种区别是解决问题的关键
评论区中有使用到callable来判断@log(text)中的text是否为可调用的对象来区分此问题，显然将问题的本质理解成了如下：
log()函数中传入的是变量如果不是函数则使用的是@log(text)，如果是函数则使用的是@log
显然是不对的，如果@log(text)中参数text就是函数呢？
在函数里面去判断(调用该函数的语句的执行方案)，我觉得应该是不能够写出来的
偏函数
偏函数就是改变一个函数的默认参数后作为一个新函数
functools.partial帮助我们快捷创建一个偏函数
>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85
