在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!')

参考

https://mp.weixin.qq.com/s/cMqJulHjfo5oYfnwKDP7zw