浅析Python中的列表解析和生成表达式


列表解析

在需要改变列表而不是需要新建某列表时,可以使用列表解析。列表解析表达式为:

  1. [expr for iter_var in iterable]   
  2. [expr for iter_var in iterable if cond_expr]  

第一种语法:首先迭代iterable里所有内容,每一次迭代,都把iterable里相应内容放到iter_var中,再在表达式中应用该iter_var的内容,最后用表达式的计算值生成一个列表。

第二种语法:加入了判断语句,只有满足条件的内容才把iterable里相应内容放到iter_var中,再在表达式中应用该iter_var的内容,最后用表达式的计算值生成一个列表。

举例如下:

  1. >>> L= [(x+1,y+1for x in range(3for y in range(5)]   
  2. >>> L  
  3. [(11), (12), (13), (14), (15), (21), (22), (23), (24), (25), (31), (32), (33), (34), (35)] 
  1. >>> N=[x+10 for x in range(10if x>5]  
  2. >>> N  
  3. [16171819
  1. newlist=[x+5 for x in olderlist if x>10] 

一个更复杂的例子:

  1. <span style="font-size: 14px;">>>> num = [j for i in range(28for j in range(i*250, i)]  
  2. >>> num  
  3. [46810121416182022242628303234363840424446486,
  4.  91215182124273033363942454881216202428323640
  5. 4448101520253035404512182430364248142128354249]  
  6. </span>  
  1. >>> words = 'The quick brown fox jumps over the lazy dog'.split()  
  2. >>> words  
  3. ['The''quick''brown''fox''jumps''over''the''lazy''dog']  
  4. >>> stuff = [[w.upper(), w.lower(), len(w)] for w in words]  
  5. >>> for i in stuff:  
  6.     print i  
  7.  
  8.       
  9. ['THE''the'3]  
  10. ['QUICK''quick'5]  
  11. ['BROWN''brown'5]  
  12. ['FOX''fox'3]  
  13. ['JUMPS''jumps'5]  
  14. ['OVER''over'4]  
  15. ['THE''the'3]  
  16. ['LAZY''lazy'4]  
  17. ['DOG''dog'3]  

上述代码的map()实现:

  1. >>> stuff = map(lambda w: [w.upper(), w.lower(), len(w)], words)  
  2. >>> for i in stuff:  
  3. ...     print i  
  4. ...   
  5. ['THE''the'3]  
  6. ['QUICK''quick'5]  
  7. ['BROWN''brown'5]  
  8. ['FOX''fox'3]  
  9. ['JUMPS''jumps'5]  
  10. ['OVER''over'4]  
  11. ['THE''the'3]  
  12. ['LAZY''lazy'4]  
  13. ['DOG''dog'3

生成器表达式

生成器表达式是在python2.4中引入的,当序列过长, 而每次只需要获取一个元素时,应当考虑使用生成器表达式而不是列表解析。生成器表达式的语法和列表解析一样,只不过生成器表达式是被()括起来的,而不是[],如下:

  1. (expr for iter_var in iterable)   
  2. (expr for iter_var in iterable if cond_expr) 

例:

  1. >>> L= (i + 1 for i in range(10if i % 2)  
  2. >>> L  
  3. <generator object <genexpr> at 0xb749a52c>  
  4. >>> L1=[]  
  5. >>> for i in L:  
  6. ...     L1.append(i)  
  7. ...   
  8. >>> L1  
  9. [246810

生成器表达式并不真正创建数字列表, 而是返回一个生成器,这个生成器在每次计算出一个条目后,把这个条目“产生”(yield)出来。 生成器表达式使用了“惰性计算”(lazy evaluation,也有翻译为“延迟求值”,我以为这种按需调用call by need的方式翻译为惰性更好一些),只有在检索时才被赋值( evaluated),所以在列表比较长的情况下使用内存上更有效。A generator object in python is something like a lazy list. The elements are only evaluated as soon as you iterate over them.

一些说明:

1. 当需要只是执行一个循环的时候尽量使用循环而不是列表解析,这样更符合python提倡的直观性。

  1. for item in sequence:  
  2.     process(item) 

2. 当有内建的操作或者类型能够以更直接的方式实现的,不要使用列表解析。

例如复制一个列表时,使用:L1=list(L)即可,不必使用:

  1. L1=[x for x in L] 

3. 当序列过长, 而每次只需要获取一个元素时,使用生成器表达式。

4. 列表解析的性能相比要比map要好,参考http://www.qingliangcn.com/2010/02/list-comprehensions%E4%B8%8Elist-map%E6%80%A7%E8%83%BD%E5%AF%B9%E6%AF%94/
 

原文链接:http://www.cnblogs.com/moinmoin/archive/2011/03/10/lsit-comprehensions-generators.html

评论关闭