【Python】返回函数/匿名函数/装饰器/偏函数

返回函数

函数作为返回值。

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，返回值就是该表达式的结果。几个常见用法：

1. 高阶函数

>>> list(map(lambda x: x * x, [1, 2, 3]))
[1, 4, 9]

2. 赋值给变量再通过变量调用

>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25

3. 作为返回值返回

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