标签：内存 极限 日常 with 函数调用 进入 选择 退出 展开
正文：
本文展示一些高级的Python设计结构和它们的使用方法。在日常工作中，你可以根据需要选择合适的数据结构，例如对快速查找性的要求、对数据一致性的要求或是对索引的要求等，同时也可以将各种数据结构合适地结合在一起，从而生成具有逻辑性并易于理解的数据模型。Python的数据结构从句法上来看非常直观，并且提供了大量的可选操作。这篇指南尝试将大部分常用的数据结构知识放到一起，并且提供对其最佳用法的探讨。
推导式(Comprehensions)
如果你已经使用了很长时间的Python，那么你至少应该听说过列表推导(list
comprehensions)。这是一种将for循环、if表达式以及赋值语句放到单一语句中的一种方法。换句话说，你能够通过一个表达式对一个列表做映射或过滤操作。
一个列表推导式包含以下几个部分：
举个例子，我们需要从一个输入列表中将所有大于0的整数平方生成一个新的序列，你也许会这么写：
num = [1, 4, -5, 10, -7, 2, 3, -1]
filtered_and_squared = []
for number in num:
if number > 0:
filtered_and_squared.append(number ** 2)
print filtered_and_squared
# [1, 16, 100, 4, 9]
很简单是吧？但是这就会有4行代码，两层嵌套外加一个完全不必要的append操作。而如果使用filter、lambda和map函数，则能够将代码大大简化：
num = [1, 4, -5, 10, -7, 2, 3, -1]
filtered_and_squared = map(lambda x: x ** 2, filter(lambda x: x > 0, num))
print filtered_and_squared
# [1, 16, 100, 4, 9]
嗯，这么一来代码就会在水平方向上展开。那么是否能够继续简化代码呢？列表推导能够给我们答案:
num = [1, 4, -5, 10, -7, 2, 3, -1]
filtered_and_squared = [ x**2 for x in num if x > 0]
print filtered_and_squared
# [1, 16, 100, 4, 9]
列表推导式被封装在一个列表中，所以很明显它能够立即生成一个新列表。这里只有一个type函数调用而没有隐式调用lambda函数，列表推导式正是使用了一个常规的迭代器、一个表达式和一个if表达式来控制可选的参数。
另一方面，列表推导也可能会有一些负面效应，那就是整个列表必须一次性加载于内存之中，这对上面举的例子而言不是问题，甚至扩大若干倍之后也都不是问题。但是总会达到极限，内存总会被用完。
针对上面的问题，生成器(Generator)能够很好的解决。生成器表达式不会一次将整个列表加载到内存之中，而是生成一个生成器对象(Generator
objector)，所以一次只加载一个列表元素。
生成器表达式同列表推导式有着几乎相同的语法结构，区别在于生成器表达式是被圆括号包围，而不是方括号：
num = [1, 4, -5, 10, -7, 2, 3, -1]
filtered_and_squared = ( x**2 for x in num if x > 0 )
print filtered_and_squared
# <generator object <genexpr> at 0x00583E18>
for item in filtered_and_squared:
print item
# 1, 16, 100 4,9
这比列表推导效率稍微提高一些，让我们再一次改造一下代码：
num = [1, 4, -5, 10, -7, 2, 3, -1]
def square_generator(optional_parameter):
return (x ** 2 for x in num if x > optional_parameter)
print square_generator(0)
# <generator object <genexpr> at 0x004E6418>
# Option I
for k in square_generator(0):
print k
# 1, 16, 100, 4, 9
# Option II
g = list(square_generator(0))
print g
# [1, 16, 100, 4, 9]
除非特殊的原因，应该经常在代码中使用生成器表达式。但除非是面对非常大的列表，否则是不会看出明显区别的。
下例使用zip()函数一次处理两个或多个列表中的元素：
alist = [‘a1‘, ‘a2‘, ‘a3‘]
blist = [‘1‘, ‘2‘, ‘3‘]
for a, b in zip(alist, blist):
print a, b
# a1 1
# a2 2
# a3 3
再来看一个通过两阶列表推导式遍历目录的例子：
import os
def tree(top):
for path, names, fnames in os.walk(top):
for fname in fnames:
yield os.path.join(path, fname)
for name in tree(‘C:\Users\XXX\Downloads\Test‘):
print name
装饰器(Decorators)
装饰器为我们提供了一个增加已有函数或类的功能的有效方法。听起来是不是很像Java中的面向切面编程(Aspect-Oriented
Programming)概念？两者都很简单，并且装饰器有着更为强大的功能。举个例子，假定你希望在一个函数的入口和退出点做一些特别的操作(比如一些安全、追踪以及锁定等操作)就可以使用装饰器。
装饰器是一个包装了另一个函数的特殊函数：主函数被调用，并且其返回值将会被传给装饰器，接下来装饰器将返回一个包装了主函数的替代函数，程序的其他部分看到的将是这个包装函数。
def timethis(func):
‘‘‘
Decorator that reports the execution time.
‘‘‘
pass
@timethis
def countdown(n):
while n > 0:
n -= 1
语法糖@标识了装饰器。
好了，让我们回到刚才的例子。我们将用装饰器做一些更典型的操作：
import time
from functools import wraps
def timethis(func):
‘‘‘
Decorator that reports the execution time.
‘‘‘
@wraps(func)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print(func.__name__, end-start)
return result
return wrapper
@timethis
def countdown(n):
while n > 0:
n -= 1
countdown(100000)
# (‘countdown‘, 0.006999969482421875)
当你写下如下代码时：
@timethis
def countdown(n):
意味着你分开执行了以下步骤：
def countdown(n):
...
countdown = timethis(countdown)
装饰器函数中的代码创建了一个新的函数(正如此例中的wrapper函数)，它用 *args 和 **kwargs
接收任意的输入参数，并且在此函数内调用原函数并且返回其结果。你可以根据自己的需要放置任何额外的代码(例如本例中的计时操作)，新创建的包装函数将作为结果返回并取代原函数。
@decorator
def function():
print("inside function")
当编译器查看以上代码时，function()函数将会被编译，并且函数返回对象将会被传给装饰器代码，装饰器将会在做完相关操作之后用一个新的函数对象代替原函数。
装饰器代码是什么样的？大部分的例子都是将装饰器定义为函数，而我发觉将装饰器定义成类更容易理解其功能，并且这样更能发挥装饰器机制的威力。
对装饰器的类实现唯一要求是它必须能如函数一般使用，也就是说它必须是可调用的。所以，如果想这么做这个类必须实现__call__方法。
这样的装饰器应该用来做些什么？它可以做任何事，但通常它用在当你想在一些特殊的地方使用原函数时，但这不是必须的，例如：
class decorator(object):
def __init__(self, f):
print("inside decorator.__init__()")
f() # Prove that function definition has completed
def __call__(self):
print("inside decorator.__call__()")
@decorator
def function():
print("inside function()")
print("Finished decorating function()")
function()
# inside decorator.__init__()
# inside function()
# Finished decorating function()
# inside decorator.__call__()
译者注：
一个更实际的例子：
def decorator(func):
def modify(*args, **kwargs):
variable = kwargs.pop(‘variable‘, None)
print variable
x,y=func(*args, **kwargs)
return x,y
return modify
@decorator
def func(a,b):
print a**2,b**2
return a**2,b**2
func(a=4, b=5, variable="hi")
func(a=4, b=5)
# hi
# 16 25
# None
# 16 25
上下文管理库(ContextLib)
contextlib模块包含了与上下文管理器和with声明相关的工具。通常如果你想写一个上下文管理器，则你需要定义一个类包含__enter__方法以及__exit__方法，例如：
import time
class demo:
def __init__(self, label):
self.label = label
def __enter__(self):
self.start = time.time()
def __exit__(self, exc_ty, exc_val, exc_tb):
end = time.time()
print(‘{}: {}‘.format(self.label, end - self.start))
完整的例子在此：
import time
class demo:
def __init__(self, label):
self.label = label
def __enter__(self):
self.start = time.time()
def __exit__(self, exc_ty, exc_val, exc_tb):
end = time.time()
print(‘{}: {}‘.format(self.label, end - self.start))
with demo(‘counting‘):
n = 10000000
while n > 0:
n -= 1
# counting: 1.36000013351
上下文管理器被with声明所激活，这个API涉及到两个方法。
利用@contextmanager装饰器改写上面那个例子：
from contextlib import contextmanager
import time
@contextmanager
def demo(label):
start = time.time()
try:
yield
finally:
end = time.time()
print(‘{}: {}‘.format(label, end - start))
with demo(‘counting‘):
n = 10000000
while n > 0:
n -= 1
# counting: 1.32399988174
看上面这个例子，函数中yield之前的所有代码都类似于上下文管理器中__enter__方法的内容。而yield之后的所有代码都如__exit__方法的内容。如果执行过程中发生了异常，则会在yield语句触发。
描述器(Descriptors)
描述器决定了对象属性是如何被访问的。描述器的作用是定制当你想引用一个属性时所发生的操作。
构建描述器的方法是至少定义以下三个方法中的一个。需要注意，下文中的instance是包含被访问属性的对象实例，而owner则是被描述器修辞的类。
标签：内存 极限 日常 with 函数调用 进入 选择 退出 展开
原文地址：https://www.cnblogs.com/lj-C/p/14889801.html
