Python中的listcomprehension以及generator

一个小故事
三年前，我在一篇博客里不无自豪的记录了python编写的小函数，当时感觉python真强大，11行代码就写出了一个配置文件的解析器。

def loadUserl nfo(fileName):
useri nfo = {}
file = ope n( fileName, "r")
while file:
line = file.readli ne()
if len (I ine) == 0:
break
if lin e.startswith('#'):
con ti nue
key, value = lin e.split("=")
useri nfo[key.strip()] = value.strip()
retur n useri nfo
最近正在跟同事学习python在数据挖掘中的应用，又专门学习了一下python本身，然后用list comprehension简化了以下上面的代码：
def loadUserI nfo(file):
return dict([li ne.strip().split("=")
for line in ope n( file, "r")
if len(line) > 0 and not lin e.startswith("#")])
这个函数和上面的函数的功能一样，都是读取一个指定的key=value格式的文件，然后构建出来一个映射(当然，在Python中叫做字典)对象，该函数还会跳过空行和#开头的行。

比如，我想要查看一下.wgetrc配置文件：
if __name__ == "__main__":
prin t(loadUserI nfo("/Users/jtqiu/.wgetrc"))
假设我的.wgetrc文件配置如下：
http-proxy=10.18.0.254:3128
ftp-proxy=10.18.0.254:3128
#http_proxy=10.1.1.28:3128
use_proxy=yes
则上面的函数会产生这样的输出：
{'use_proxy': 'yes', 'ftp-proxy': '10.18.0.254:3128', 'http-proxy': '10.18.0.254:3128'}
list comprehension (歹U表推导式)
在python中，list comprehension (或译为列表推导式)可以很容易的从一个列表生成另外一个列表，从而完成诸如map, filter等的动作，比如：
要把一个字符串数组中的每个字符串都变成大写：
n ames = ["joh n", "jack", "sea n"]
result =[]
for n ame in n ames:
result.appe nd(n ame.upper())
如果用列表推导式，只需要一行：
[n ame.upper() for n ame in n ames]
结果都是一样：
['JOHN', 'JACK', 'SEAN']
另外一个例子，如果想要过滤出一个数字列表中的所有偶数：
numbers = [1,2, 3, 4, 5, 6]
result =[]
for nu mber in nu mbers:
if nu mber % 2 == 0:
result.appe nd(nu mber)
如果写成列表推导式
[x for x in nu mbers if x%2 == 0]
结果也是一样：
[2, 4, 6]
显然，列表推导更加短小，也更加表意。

迭代器
在了解generator之前，我们先来看一个迭代器的概念。

有时候我们不需要将整个列表都放在内存中，特别是当列表的尺寸比较大的时候。

比如我们定义一个函数，它会返回一个连续的整数的列表：
def myran ge( n):
num, nums = 0,[]
while num & It; n:
nu ms.appe nd(num)
num += 1
return nums
当我们计算诸如myrange(50)或者myrange(100)时，不会有任何问题，但是当获取诸如myrange(10000000000)的时候，由于这个函数的内部会将数字保存在一个临时的列表中，因此会有很多的内存占用。

因此在python有了迭代器的概念：
class myran ge(object):
def __init__(self, n):
self.i = 0
self. n = n
def __iter__(self):
return self
# for pytho n 3
def __next__(self):
return self. next()
def n ext(self):
if self.i & It; self. n:
i = self.i
self.i += 1
return i
else:
raise Stoplterati on()
这个对象其实实现了两个特殊的方法：_iter_ (对于python3来说，是_next__)和
next方法。

其中next每次只返回一个值，如果迭代已经结束，就抛出一个Stoplteration的异常。

实现了这两个方法的类都可以算作是一个迭代器，他们可以被用于可迭代的上下文中，比如：> > > from myrange import myrange
&gt ;& gt; > x = myra nge(10)
&gt ;& gt; > x. next()
&gt ;& gt; > x. next()
&gt ;& gt; > x. next()
但是可以看到这个函数中有很多的样板代码，因此我们有了生成器表达式来简化这个过
程：
def myran ge( n):
num = 0
while num & It; n:
yield num
num += 1
注意此处的yield关键字，每次使用next来调用这个函数时都会求值一次num并返回，具体的细节可以参考这里。

区别
简单来说，两者都可以在迭代器上下文中使用，看起来几乎是一样的。

不同的地方是gen erator 可以节省内存空间，从而提高执行速度。

gen erator更适合一次性的列表处理，比如只是需要一个中间列表作为转换。

而列表推导则更适合要将列表保存下来，以备后续使用的场景。

这里也有一些讨论，可以一并参看。

更多信息请查看IT技术专栏。