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

返回函数

函数作为返回值。

def A(n):
    def a():
        return n
    return a

调用A时,返回函数a,调用a时,返回值

>>> A(2)
.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

>>> count()
[.f at 0x1085f51e0>, .f at 0x108621158>, .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]
  1. 赋值给变量再通过变量调用
>>> f = lambda x: x * x
>>> f
 at 0x101c6ef28>
>>> f(5)
25
  1. 作为返回值返回
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

你可能感兴趣的:(【Python】返回函数/匿名函数/装饰器/偏函数)