在python编程中，我们经常看到下面的函数用法：
with open("test.txt", "w") as f:
f.write("hello world!")
习惯了java开发的python初学者，心里不免犯嘀咕：
文件open操作之后，为什么没有close，不怕文件描述符资源耗尽吗？
文件write操作没有异常捕获，不怕中断程序主流程吗？如果您也有同样的忧虑，那太正常不过了，起码说明您是一位有“开发原则”的人，同时也说明您对其背后的原理了解存在盲区。如果是这种情况，本文强烈建议您耐心阅读完以下章节。为了系统的阐述其背后的奥秘，本文从最基本的函数讲起。
关于函数
在Python中，一切皆为对象，包括函数。
def foo(num):
return num + 1
value = foo(3)
print(value)
def bar():
print("bar")
foo = bar
foo()
上面简单的函数例子中，可以总结几点信息：
函数名字foo可以作为变量名字，指向函数对象
函数名字foo作为对象，可以赋值给变量value
函数名字foo可以作为变量名字，指向其他函数bar
函数名字（函数对象）通过括号调用函数 不仅如此，作为对象的函数也具有一般对象的特性，比如：
函数作为参数
def foo(num):
return num + 1
def bar(fun):
return fun(3)
value = bar(foo)
print(value)
函数作为返回值
def foo():
return 1
def bar():
return foo #注意这里没有括号
print(bar()) # <function foo at 0x10a2f4140>
print(bar()()) # 1
等价于
print(foo()) # 1
函数嵌套
def outer():
x = 1
def inner():
print(x)
inner() # 注意这里有括号，直接被调用
outer() #
闭包
def outer(x):
def inner():
print(x)
return inner #没括号，不被直接调用
closure = outer(1) # closure就是一个闭包
closure()
同样是嵌套函数，只是稍改动一下，把局部变量 x 作为参数了传递进来，嵌套函数不再直接在函数里被调用，而是作为返回值返回，这里的 closure就是一个闭包，本质上它还是函数，闭包是引用了自由变量(x)的函数(inner)。
装饰器
def outer(func):
def inner():
print("before call fun")
func()
print("after call fun")
return inner
def foo():
print("foo")
new_foo = outer(foo)
new_foo()
outer 函数其实就是一个装饰器:一个带有函数作为参数并返回一个新函数的闭包.本质上装饰器也是函数,outer 函数的返回值是 inner 函数。
注：上面示例中的装饰器函数调用，可以用语法糖@简写为：
@outer
def foo():
print("foo")
foo()
我们进一步抽象装饰器：
def decorator(func):
def wrapper(*args, **kw):
return func()
return wrapper
@decorator
def function():
print("hello, decorator")
可见，通过装饰器，可以让代码更加简练、优雅、可读性更强。
装饰器进阶
类装饰器 基于类装饰器的实现，必须实现 call 和init 两个内置函数。 init ：接收被装饰函数 call：实现装饰逻辑。以日志打印为例：
class logger(object):
def init(self, func):
self.func = func
def __call__(self, *args, **kwargs):
print("[INFO]: the function {func}() is running..."\
.format(func=self.func.__name__))
return self.func(*args, **kwargs)
@logger
def say(something):
print("say {}!".format(something))
say("hello")
装饰类的装饰器 装饰器不仅可以装饰函数，还可以装饰类，比如如果想改写类的方法的部分实现，除了通过类继承重载，还可以通过装饰器，实现如下：
def log_getattribute(cls):
# Get the original implementation
orig_getattribute = cls.getattribute
# Make a new definition
def new_getattribute(self, name):
print('getting:', name)
return orig_getattribute(self, name)
# Attach to the class and return
cls.__getattribute__ = new_getattribute
return cls
Example use
@log_getattribute
class A:
def init(self,x):
self.x = x
def spam(self):
pass
a = A(42)
print(a.x)
示例中，通过装饰器函数log_getattribute修改原有类的属性方法getattribute的指向来达到目的：通过指向新的方法new_getattribute，在新的方法中在调用原来方法之前，添加额外逻辑。
偏函数 使用装饰器的前提是装饰器必须是可被调用的对象，比如函数、实现了call 函数的类等，即将介绍的偏函数其实也是 callable 对象。在了解偏函数之前，先举个例子：计算 100 加任意个数字的和。我们用parital函数解决这个问题：
from functools import partial
def add(*args):
return sum(args)
add_100 = partial(add, 100)
print(add_100(1, 2)) # 103
print(add_100(1, 2, 3)) # 106
跟上面的例子那样，偏函数作用和装饰器一样，它可以扩展函数的功能，但又不完全等价于装饰器。通常应用的场景是当我们要频繁调用某个函数时，其中某些参数是已知的固定值，可以将这些固定值“固定”，然后用其他的参数参与调用。类似偏导数计算那样，固定几个变量，对剩下的变量求导。我们看下partial的函数参数定义：
func = functools.partial(func, *args, **keywords)
func: 需要被扩展的函数，返回的函数其实是一个类 func 的函数
*args: 需要被固定的位置参数
**kwargs: 需要被固定的关键字参数
如果在原来的函数 func 中关键字不存在，将会扩展，如果存在，则会覆盖
同样是刚刚求和的代码，不同的是加入的关键字参数
def add(*args, *kwargs):
# 打印位置参数
for n in args:
print(n)
print("-"20)
# 打印关键字参数
for k, v in kwargs.items():
print('%s:%s' % (k, v))
# 暂不做返回，只看下参数效果，理解 partial 用法
普通调用
add(1, 2, 3, v1=10, v2=20)
add_partial = partial(add, 10, k1=10, k2=20)
add_partial(1, 2, 3, k3=20)
偏函数与装饰器 我们再看看如何使用类和偏函数结合实现装饰器，如下所示，DelayFunc 是一个实现了call 的类，delay 返回一个偏函数，在这里 delay 就可以做为一个装饰器：
import time
import functools
class DelayFunc:
def init(self, duration, func):
self.duration = duration
self.func = func
def __call__(self, *args, **kwargs):
print(f'Wait for {self.duration} seconds...')
time.sleep(self.duration)
return self.func(*args, **kwargs)
def delay(duration):
"""
装饰器：推迟某个函数的执行。
"""
# 此处为了避免定义额外函数，
# 直接使用 functools.partial 帮助构造 DelayFunc 实例
return functools.partial(DelayFunc, duration)
@delay(duration=2)
def add(a, b):
return a+b
wraps
继续深入函数装饰器，首先打印被装饰的函数function的名字：
def decorator(func):
def wrapper(*args, **kw):
return func()
return wrapper
@decorator
def function():
print("hello, decorator")
print(function.name) #wrapper
输出发现是wrapper，其实这也好理解，因为decorator返回的就是wrapper。但有时我们需要返回function的本来名字，那怎么做呢？python 的functools模块提供了一系列的高阶函数以及对可调用对象的操作，比如reduce，partial，wraps等。其中partial作为偏函数，在前面已经介绍过，warps旨在消除装饰器对原函数造成的影响，即对原函数的相关属性（比如name）进行拷贝，以达到装饰器不修改原函数（属性）的目的:
from functools import wraps
def decorator(func):
@wraps(func)
def wrapper(*args, **kw):
print(func.name)
return func()
return wrapper
@decorator
def function():
print("hello, decorator")
function()
print(function.name)
注意代码中return func()，括号表示调用执行函数。作为对比，请看下面的调用：
from functools import wraps
def decorator(func):
@wraps(func)
def wrapper(*args, **kw):
print(func.name)
return func
return wrapper
@decorator
def function():
print("hello, decorator")
因为装饰返回func，不会发生调用，因此需要两对括号，其中function()返回的是函数定义。
print(function())
function()()
print(function.name)
装饰器应用之contextmanager
contextmanager是python中一个使用广泛的上下文管理器，（实际上也是装饰器）经常跟with语句一起使用，用于精确地控制资源的分配和释放。回忆以下常规代码结构：
def controlled_execution(callback):
try:
#比如环境初始化、资源分配等
set things up
callback(thing)
finally:
#比如资源回收、事物提交等
tear things down
def my_function(thing):
#执行具体的业务逻辑
do something
controlled_execution(my_function)
以上为了防止业务逻辑出现异常，导致一些必须要执行的操作无法执行，通常使用try...finally语句，保证必要操作一定被执行。但是如果代码中大量使用这种语句，又导致程序逻辑冗余，可读性变差。但是结合with，并将以上语句稍作改动：将try...finally的逻辑拆分成两个函数，分别执行比如资源的初始化和释放，封装在一个class中：
class controlled_execution:
def enter(self):
set things up
return thing
def exit(self, type, value, traceback):
tear things down
with controlled_execution() as thing:
# code body
do something
其中with expression [as variable],用来简化 try / finally 语句。当执行with语句、进入代码块前，调用enter方法，代码块执行结束之后执行exit方法。需要注意的是可以根据exit方法的返回值来决定是否抛出异常，如果没有返回值或者返回值为 False ，则异常由上下文管理器处理，如果为 True 则由用户自己处理。上述代码可以通过contextmanager进一步简化：
@contextmanager
def controlled_execution():
#set things up
yield thing
#tear things down
with controlled_execution() as t:
print(t)
引入yield将函数变成生成器，yield将函数体分为两部分：yield之前的语句在执行with代码块之前执行，yield之后的代码块在with代码块之后执行。到此为止，相信大家能够理解文章开篇提到的代码块了，然后基于此，我们也可以自定义一个open函数：
from contextlib import contextmanager
@contextmanager
def my_open(name):
f = open(name, 'w')
yield f
f.close()
with my_open('some_file') as f:
f.write('hola!')
