Python高级编程技巧

译注：本文的英文题目是《Advanced Design Patterns in Python》，可直译为《Python中的高级设计模式》。不过本人在通读完全文之后发现文章的内容与我们通常理解的设计模式有很大出入，原文后的评论中也有其他读者提出了这一点。因此，根据文章内容我将题目译为“Python高级编程技巧”。

正文：

本文展示一些高级的Python设计结构和它们的使用方法。在日常工作中，你可以根据需要选择合适的数据结构，例如对快速查找性的要求、对数据一致性的要求或是对索引的要求等，同时也可以将各种数据结构合适地结合在一起，从而生成具有逻辑性并易于理解的数据模型。Python的数据结构从句法上来看非常直观，并且提供了大量的可选操作。这篇指南尝试将大部分常用的数据结构知识放到一起，并且提供对其最佳用法的探讨。

推导式(Comprehensions)

如果你已经使用了很长时间的Python，那么你至少应该听说过列表推导(list comprehensions)。这是一种将for循环、if表达式以及赋值语句放到单一语句中的一种方法。换句话说，你能够通过一个表达式对一个列表做映射或过滤操作。

一个列表推导式包含以下几个部分：

• 一个输入序列
• 一个表示输入序列成员的变量
• 一个可选的断言表达式
• 一个将输入序列中满足断言表达式的成员变换成输出列表成员的输出表达式

举个例子，我们需要从一个输入列表中将所有大于0的整数平方生成一个新的序列，你也许会这么写：

1 num = [1, 4, -5, 10, -7, 2, 3, -1]
2 filtered_and_squared = []
3
4 for number in num:
5     if number > 0:
6         filtered_and_squared.append(number ** 2)
7 print filtered_and_squared
8
9 # [1, 16, 100, 4, 9]

很简单是吧？但是这就会有4行代码，两层嵌套外加一个完全不必要的append操作。而如果使用filter、lambda和map函数，则能够将代码大大简化：

1 num = [1, 4, -5, 10, -7, 2, 3, -1]
2 filtered_and_squared = map(lambda x: x ** 2, filter(lambda x: x > 0, num))
3 print filtered_and_squared
4
5 # [1, 16, 100, 4, 9]

嗯，这么一来代码就会在水平方向上展开。那么是否能够继续简化代码呢？列表推导能够给我们答案:

1 num = [1, 4, -5, 10, -7, 2, 3, -1]
2 filtered_and_squared = [ x**2 for x in num if x > 0]
3 print filtered_and_squared
4
5 # [1, 16, 100, 4, 9]

• 迭代器(iterator)遍历输入序列num的每个成员x
• 断言式判断每个成员是否大于零
• 如果成员大于零，则被交给输出表达式，平方之后成为输出列表的成员。

列表推导式被封装在一个列表中，所以很明显它能够立即生成一个新列表。这里只有一个type函数调用而没有隐式调用lambda函数，列表推导式正是使用了一个常规的迭代器、一个表达式和一个if表达式来控制可选的参数。

另一方面，列表推导也可能会有一些负面效应，那就是整个列表必须一次性加载于内存之中，这对上面举的例子而言不是问题，甚至扩大若干倍之后也都不是问题。但是总会达到极限，内存总会被用完。

针对上面的问题，生成器(Generator)能够很好的解决。生成器表达式不会一次将整个列表加载到内存之中，而是生成一个生成器对象(Generator objector)，所以一次只加载一个列表元素。

生成器表达式同列表推导式有着几乎相同的语法结构，区别在于生成器表达式是被圆括号包围，而不是方括号：

01 num = [1, 4, -5, 10, -7, 2, 3, -1]
02 filtered_and_squared = ( x**2 for x in num if x > 0 )
03 print filtered_and_squared
04
05 # <generator object <genexpr> at 0x00583E18>
06
07 for item in filtered_and_squared:
08     print item
09
10 # 1, 16, 100 4,9

这比列表推导效率稍微提高一些，让我们再一次改造一下代码：

01 num = [1, 4, -5, 10, -7, 2, 3, -1]
02
03 def square_generator(optional_parameter):
04     return (x ** 2 for x in num if x > optional_parameter)
05
06 print square_generator(0)
07 # <generator object <genexpr> at 0x004E6418>
08
09 # Option I
10 for k in square_generator(0):
11     print k
12 # 1, 16, 100, 4, 9
13
14 # Option II
15 g = list(square_generator(0))
16 print g
17 # [1, 16, 100, 4, 9]

除非特殊的原因，应该经常在代码中使用生成器表达式。但除非是面对非常大的列表，否则是不会看出明显区别的。

下例使用zip()函数一次处理两个或多个列表中的元素：

1 alist = ['a1', 'a2', 'a3']
2 blist = ['1', '2', '3']
3
4 for a, b in zip(alist, blist):
5     print a, b
6
7 # a1 1
8 # a2 2
9 # a3 3

再来看一个通过两阶列表推导式遍历目录的例子：

1 import os
2 def tree(top):
3     for path, names, fnames in os.walk(top):
4         for fname in fnames:
5             yield os.path.join(path, fname)
6
7 for name in tree('C:\Users\XXX\Downloads\Test'):
8     print name

装饰器(Decorators)

装饰器为我们提供了一个增加已有函数或类的功能的有效方法。听起来是不是很像Java中的面向切面编程(Aspect-Oriented Programming)概念？两者都很简单，并且装饰器有着更为强大的功能。举个例子，假定你希望在一个函数的入口和退出点做一些特别的操作(比如一些安全、追踪以及锁定等操作)就可以使用装饰器。

装饰器是一个包装了另一个函数的特殊函数：主函数被调用，并且其返回值将会被传给装饰器，接下来装饰器将返回一个包装了主函数的替代函数，程序的其他部分看到的将是这个包装函数。

01 def timethis(func):
02     '''
03     Decorator that reports the execution time.
04     '''
05     pass
06
07 @timethis
08 def countdown(n):
09     while n > 0:
10         n -= 1

语法糖@标识了装饰器。

好了，让我们回到刚才的例子。我们将用装饰器做一些更典型的操作：

01 import time
02 from functools import wraps
03
04 def timethis(func):
05     '''
06     Decorator that reports the execution time.
07     '''
08     @wraps(func)
09     def wrapper(*args, **kwargs):
10         start = time.time()
11         result = func(*args, **kwargs)
12         end = time.time()
13         print(func.__name__, end-start)
14         return result
15     return wrapper
16
17 @timethis
18 def countdown(n):
19     while n > 0:
20         n -= 1
21
22 countdown(100000)
23
24 # ('countdown', 0.006999969482421875)

当你写下如下代码时：

1 @timethis
2 def countdown(n):

意味着你分开执行了以下步骤：

1 def countdown(n):
2 ...
3 countdown = timethis(countdown)

装饰器函数中的代码创建了一个新的函数(正如此例中的wrapper函数)，它用 *args 和 **kwargs 接收任意的输入参数，并且在此函数内调用原函数并且返回其结果。你可以根据自己的需要放置任何额外的代码(例如本例中的计时操作)，新创建的包装函数将作为结果返回并取代原函数。

1 @decorator
2 def function():
3     print("inside function")

当编译器查看以上代码时，function()函数将会被编译，并且函数返回对象将会被传给装饰器代码，装饰器将会在做完相关操作之后用一个新的函数对象代替原函数。

装饰器代码是什么样的？大部分的例子都是将装饰器定义为函数，而我发觉将装饰器定义成类更容易理解其功能，并且这样更能发挥装饰器机制的威力。

对装饰器的类实现唯一要求是它必须能如函数一般使用，也就是说它必须是可调用的。所以，如果想这么做这个类必须实现__call__方法。

这样的装饰器应该用来做些什么？它可以做任何事，但通常它用在当你想在一些特殊的地方使用原函数时，但这不是必须的，例如：

01 class decorator(object):
02
03     def __init__(self, f):
04         print("inside decorator.__init__()")
05         f() # Prove that function definition has completed
06
07     def __call__(self):
08         print("inside decorator.__call__()")
09
10 @decorator
11 def function():
12     print("inside function()")
13
14 print("Finished decorating function()")
15
16 function()
17
18 # inside decorator.__init__()
19 # inside function()
20 # Finished decorating function()
21 # inside decorator.__call__()

译者注：
1. 语法糖@decorator相当于function=decorator(function)，在此调用decorator的__init__打印“inside decorator.__init__()”
2. 随后执行f()打印“inside function()”
3. 随后执行“print(“Finished decorating function()”)”
4. 最后在调用function函数时，由于使用装饰器包装，因此执行decorator的__call__打印 “inside decorator.__call__()”。

一个更实际的例子：

01 def decorator(func):
02     def modify(*args, **kwargs):
03         variable = kwargs.pop('variable', None)
04         print variable
05         x,y=func(*args, **kwargs)
06         return x,y
07     return modify
08
09 @decorator
10 def func(a,b):
11     print a**2,b**2
12     return a**2,b**2
13
14 func(a=4, b=5, variable="hi")
15 func(a=4, b=5)
16
17 # hi
18 # 16 25
19 # None
20 # 16 25

上下文管理库(ContextLib)

contextlib模块包含了与上下文管理器和with声明相关的工具。通常如果你想写一个上下文管理器，则你需要定义一个类包含__enter__方法以及__exit__方法，例如：

01 import time
02 class demo:
03     def __init__(self, label):
04         self.label = label
05
06     def __enter__(self):
07         self.start = time.time()
08
09     def __exit__(self, exc_ty, exc_val, exc_tb):
10         end = time.time()
11         print('{}: {}'.format(self.label, end - self.start))

完整的例子在此：

01 import time
02
03 class demo:
04     def __init__(self, label):
05         self.label = label
06
07     def __enter__(self):
08         self.start = time.time()
09
10     def __exit__(self, exc_ty, exc_val, exc_tb):
11         end = time.time()
12         print('{}: {}'.format(self.label, end - self.start))
13
14 with demo('counting'):
15     n = 10000000
16     while n > 0:
17         n -= 1