python/返回函数-匿名函数-装饰器-偏函数

eval()函数

功能：将字符串str当成有效表达式求值并返回结果
语法：eval(source[,globle[,locals]])->value
参数：
source：一个python表达式函数或者compile()返回的代码对象
globle:可选，必须是字典
locals:可选，任意映射对象

a = 1
b = 2
c = eval("a+b")
print(c)-->3
dict1 = dict(a=100,b=200)
d = eval("a+b",dict1)
print(d)-->300

nonlocal关键字

nonlocal 用来声明外层的局部变量。
global 用来声明全局变量。
【操作】使用nonlocal声明外层局部变量

## nonlocal
a = 100
def outer():
    b = 10

    def inner():
        # 声明是外部局部变量
        nonlocal b
        print("inner b:",b)
        b = 20

        global a 
        a =100
    inner()
    print("outer b:",b)

outer()
print("a:",a)
"输出："
20
inner b: 10
outer b: 20
a: 100

LEGB规则

Python在查找“名称"时，是按照LEGB规则查找的: Local-->Enclosed-->Global-->Built in。

• Local 指的就是函数或者类的方法内部
• Enclosed指的是嵌套函数(一个函数包裹另一个函数，闭包)
• Global 指的是模块中的全局变重
• Built in 指的是Python为自己保目心特殊名你。

即：如果某个name映射在局部(local)命名空间中没有找到，接下来就会在闭包作用域(enclosed)进行搜索，如果闭包作用域也没有找到，Python就会到全局(global)命名空间中进行查找，最后会在内建(built-in)命名空间搜索(如果一个名称在所有命名空间中都没有找到，就会产生一个NameError)。

返回函数

lambda匿名函数的格式：冒号前是参数，可以有多个，用逗号隔开，冒号右边的为表达式。其实lambda返回值是一个函数的地址，也就是函数对象。

from functools import reduce
print(reduce(lambda x,y: x+y,(1,2,3,4,5)))

函数作为返回值

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。
如：实现可变参数求和(功能:是不需要立刻求和，而是在后面的代码中，根据需要再计算):

#不返回求和的结果，而是返回求和的函数
def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

调用lazy_sum()时：
返回的求和函数，然后将求和函数赋给变量f

>>> f = lazy_sum(1, 3, 5, 7, 9)
>调用f，得到就和结果：
>print(f())--->25

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

*:当我们调用lazy_sum()时，每次调用都会返回一个新的函数，即使传入相同的参数：

>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False

且f1()和f2()的调用结果互不影响

闭包

另一个理解：转载：https://www.cnblogs.com/s-1314-521/p/9763376.html

注意到返回的函数在其定义内部引用了局部变量args，所以，当一个函数返回了一个函数后，其内部的局部变量还被新函数引用，所以，闭包用起来简单，实现起来可不容易。

一个需要注意的问题是，返回的函数并没有立刻执行，而是直到调用了f()才执行。我们来看一个例子：

'每次循环，都创建了一个新的函数，然后，把创建的3个函数都返回了'
def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs
f1, f2, f3 = count()

输出结果为

若：fg = count()
print(fg)-->打印的是三个函数的地址。
'[<function count.<locals>.f at 0x0000006AB751F158>, <function count.<locals>.f at 0x0000006AB751F510>, <function count.<locals>.f at 0x0000006AB751F598>]'
>>> f1()--->9
>>> f2()--->9
>>> f3()--->9
>而不是  1, 4， 9

原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为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
再看看结果：
>>> f1, f2, f3 = count()
>>> f1()--->1
>>> f2()--->4
>>> f3()--->9

实现计算器，每次递增1：

def createCounter():
    cnt = [0] # 将cnt设定为数组
    def counter():
        cnt[0] = cnt[0]+1 # 修改数组中的元素值
        return cnt[0] # 返回修改的元素值
    return counter
f = createCounter()
for i in range(1,10):
     print(f())

匿名函数

当传入参数，但是不需要显式地定义函数时，直接传入匿名函数更方便
如计算f(x)=x^2,可以省略f(x)函数的定义：
对lambda函数，冒号前时参数，冒号后是表达式。

L=list(map(lambda x: x*x,[1, 2, 3, 4, 5, 6, 7, 8, 9]))
print(L)-->[1, 4, 9, 16, 25, 36, 49, 64, 81]

匿名函数lambda x: x * x实际上就是：

def f(x):
    return x * x

匿名函数限制：只能写一个表达式，不用写return,表达式结果就是返回值
匿名函数优点：函数没有名字，因此不用担心冲突。
且匿名函数也可以赋给一个变量。

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

也可以作为返回值返回：

def build(x, y):
    return lambda: x * x + y * y

装饰器

函数也是一个对象，而且函数对象可以复制给变量，然后通过变量调用这个函数。
如:

def now():
    print('Fan')
 #函数赋给变量
 f = now
 print(f)--->Fan

函数对象有一个__name__属性，可以拿到函数的名字：

print(now.__name__)--->'now'
print(f.__name__)--->'now'

假设我们要增强now()函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
本质上，decorator就是一个返回函数的高阶函数，所以，我们要定义一个能打印日志的decorator，可以定义如下：

def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)#如果不加这一句，就不会执行now函数了
    return wrapper

观察上面的log，因为它是一个decorator，所以接受一个函数作为参数，并返回一个函数。我们要借助Python的@语法，把decorator置于函数的定义处：

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

这样，调用now()，不仅会运行now()函数本身，还会在运行now()函数前打印一行日志

'放在定义处，相当于执行了now = log(now),后面再次调用now()相当于执行力wapper函数。这也是个闭包'
>>> now()
call now():
2015-3-25

理解：
由于log()是一个decorator，返回一个函数，所以，原来的now()函数仍然存在，只是现在同名的now变量指向了新的函数，于是调用now()将执行新函数，即在log()函数中返回的wrapper()函数。

wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数。

有点不好理解-_-

now = log(now)-->now等于log()的返回函数
now= wapper--->now指向了wapper函数
然后执行wapper(func)-->func指向的是原now函数，所以后面才可以调用原函数
'此时，now指向的是wapper:'
>>> now.__name__
'wrapper'

如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数，写出来会更复杂。比如，要自定义log的文本(套娃)：

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')
'执行结果：'
3层的就是相当于：>>> now = log('execute')(now)
>>> now()
execute now():
2015-3-25

解释：首先执行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的写法如下：

'不带参数的decorator：'
import functools
def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        print('call %s():' % now.__name__)
        return func(*args, **kw)
    return wrapper
'结构：'
def log(func):#func是传入需要打印日志的函数now
	def wrapper(*args, **kw):#接收主函数传入的需要打印的函数func，打印其日志内容，
	     print(需要打印的%s,%func.__name__)
	     return func(*args, **kw)#调用需要打印日志的函数now
	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
需要传入文本的，只需要给打印函数外再加一个函数，来调用wrapper

import functools是导入functools模块。模块的概念稍候讲解。现在，只需记住在定义wrapper()的前面加上@functools.wraps(func)即可

练习

请设计一个decorator，它可作用于任何函数上，并打印该函数的执行时间：

刚开始学的原来写的这个，回顾发现，他并不能打印函数的执行时间，因为还是在最后调用了原函数

def metric(fn):
	start_time=time.time()
	@functools.wraps(fn)    #将原始函数（fn）的__name__复制到wraps
	def wrapper(*args,**kw):
		  end_time=time.time()
          exec_time=str(end_time-start_time)
          print('%s executed in %s ms' % (fn.__name__, exec_time))
          return fn(*args,**kw)
      return wapper

订：

import functools
import time
def protime(func):
    @functools.wraps(func)
    def wapper(*args,**kw):
        start_time = time.time()
        func(*args,**kw)
        end_time = time.time()
        exec_time=str(end_time-start_time)
        print('%s executed in %s ms' % (func.__name__, exec_time))
        return None
    return wapper

@protime
def counter():
    sum = 1
    for i in range(1,50):
        sum = i*sum
    print(sum)

counter()
'执行结果：'
608281864034267560872252163321295376887552831379210240000000000
counter executed in 0.0005023479461669922 ms

偏函数

偏函数也是functools模块提供的功能

在介绍函数参数的时候，我们讲到，通过设定参数的默认值，可以降低函数调用的难度。而偏函数也可以做到这一点。

举例如下：
int()函数可以把字符串转换为整数，当仅传入字符串时，int()函数默认按十进制转换：

>>> int('12345')
12345

但int()函数还提供额外的base参数，默认值为10。如果传入base参数，就可以做N进制的转换：

>>> int('12345', base=8)
5349
>>> int('12345', 16)
74565

如果需要转换大量二进制字符串，每次都传入int(x, base=2)非常麻烦，于是，我们想到，可以定义一个int2()的函数，默认把base=2传进去：

def int2(x, base=2):
    return int(x, base)
'这样，我们转换二进制就非常方便了：'
>>> int2('1000000')
64
>>> int2('1010101')
85

functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85

总结：

functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单

注意到上面的新的int2函数，仅仅是把base参数重新设定默认值为2，但也可以在函数调用时传入其他值：

>>> int2('1000000', base=10)
1000000

最后，创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数，当传入：

int2 = functools.partial(int, base=2)
实际上固定了int()函数的关键字参数base，也就是：
int2('10010')
相当于：
kw = { 'base': 2 }
int('10010', **kw)

max2 = functools.partial(max, 10)
'实际上会把10作为*args的一部分自动加到左边，也就是：'
max2(5, 6, 7)
相当于：
args = (10, 5, 6, 7)
print(max(*args))--->10