python 函数作为返回值

1. 函数作为返回值

下面例子中，我们在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力。

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function lazy_sum.<locals>.sum at 0x101c6ed90>
>>> f()
25

闭包

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()

>>> f1()
9
>>> f2()
9
>>> f3()
9
# 解析：
全部都是9！原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9。而非 1*1 2*2 3*3

# 修复bug
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

>>> f1, f2, f3 = count()
>>> f1()
1
>>> f2()
4
>>> f3()
9
# 利用lambda简化
>>> def count():
...  g = lambda x:x**2
...  def f(i):
...   return g(i)
...  fs = []
...  for i in range(1,4):
...   fs.append(f(i))
...  return fs
... 
>>> f1,f2,f3 = count()
>>> f1
1
>>> f2
4
>>> f3
9

# 小结：
一个函数可以返回一个计算结果，也可以返回一个函数。
返回一个函数时，牢记该函数并未执行，返回函数中不要引用任何可能会变化的变量。

2. 匿名函数

# 关键字lambda表示匿名函数，冒号前面的x表示函数参数。
# 匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。
lambda x: x * x

3. 装饰器（decorator）

//  __name__ 关键字：是查看函数名称的属性
>>> def now():
...     print('2015-3-25')
...
>>> f = now
>>> f()

>>> now.__name__
'now'
>>> f.__name__
'now'

# 假设我们要增强now()函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。

# 应用：写一个log函数用来打印函数名称，且给原有函数追加输出信息，wrapper就是func的装饰器
def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

@log
def now():
    print('2015-3-25')

# 调用now()函数，不仅会运行now()函数本身，还会在运行now()函数前打印一行日志：
>>> now()
call now():
2015-3-25
把@log放到now()函数的定义处，相当于执行了语句：now = log(now)

// 继续延展，decorator本身需要传入参数时
def log(text):
    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层嵌套的效果是这样的：
>>> decorator = log('execute')
>>> now = decorator(now)

// 出现了一个问题：
# 函数名称变了
>>> now.__name__
'wrapper'
# 修复
import functools
def log(func):

    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
#  @functools.wraps(func)  就是 wrapper.__name__ = func.__name__的意思。

#猜测wraps实现为:(瞎写的，可能不对！！)
def wraps(old_f):
 def decorator(func):
  def wrapper(*args, **kw):
    return func(*args, **kw)
  return wrapper
  wrapper.__name__ = old_f.__name__
 return decorator
  
# 作业：请设计一个decorator，它可作用于任何函数上，并打印该函数的执行时间：
def metric(fn):
 @functools.wraps(fn)
 def wrapper(*args,**kw):
  print('%s executed in %s ms' % (fn.__name__, 10.24))
  return fn(*args,**kw)
 return wrapper

# 作业2:写出一个@log的decorator，使它既支持@log也支持@log('execute')

import functools

def log(name):
    if callable(name):
        @functools.wraps(name)
        def wrapper(*args, **kw):
            print('begin call', name.__name__)
            f = name(*args, **kw)
            print('end call', name.__name__)
            return f
        return wrapper
    else:
        def decorator(func):
            @functools.wraps(func)
            def wrapper(*args, **kw):
                print('begin call', name)
                f = func(*args, **kw)
                print('end call', name)
                return f
            return wrapper
        return decorator

 

# 总结：
 1. @log的意思就是，有个装饰器叫做log
 2. @functools，是内置的一个装饰器，作用是更改__name__属性的，需要import functools模块

4. 偏函数：Python的functools模块提供了很多有用的功能，其中一个就是偏函数（Partial function）

>>> int('12345')
12345
>>> int('12345', base=8)
5349
>>> int('12345', 16)
74565
# 如果默认base=2，于是
def int2(x, base=2):
    return int(x, base)
# 用functools.partial替代上面的函数是这样的：不需要声明新的函数只需要用partial函数即可！意思就是生成一个上面的函数！
>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85
简单总结functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单

// 理解一下functools.partial的原理：
>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000', base=10)
1000000

int2('10010')
# 其实int2('10010')调用的时候实际是
# kw = { 'base': 2 }
# int('10010', **kw)
所以说：
max2 = functools.partial(max, 10)
# 这个其实是  arge = 10 + *arge
max2(5, 6, 7)
>>> 10

总结：偏函数------当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。