Analysis of list parsing and generating expressions in Python

List Parsing

You can use list resolution when you need to change the list instead of creating a new list. The list parsing expression is:

 
 

  
  
[expr for iter_var in iterable]   
  
  
[expr for iter_var in iterable if cond_expr]  
 
 

First, iterate all the content in iterable. In each iteration, the corresponding content in iterable is put into iter_var, and then the content of iter_var is applied to the expression, finally, a list is generated using the calculated value of the expression.

Syntax 2: A judgment statement is added. Only the content that meets the conditions puts the corresponding content in iterable into iter_var, and then applies the content of the iter_var in the expression, finally, a list is generated using the calculated value of the expression.

Example:

 
 

  
  
>>> L= [(x+1,y+1) for x in range(3) for y in range(5)]   
  
  
>>> L  
  
  
[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5)] 
 
 

 
 

  
  
>>> N=[x+10 for x in range(10) if x>5]  
  
  
>>> N  
  
  
[16, 17, 18, 19] 
 
 

 
 

  
  
newlist=[x+5 for x in olderlist if x>10] 
 
 

A more complex example:

 
 

  
  
<span style="font-size: 14px;">>>> num = [j for i in range(2, 8) for j in range(i*2, 50, i)]  
  
  
>>> num  
  
  
[4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 6,
  
  
 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 8, 12, 16, 20, 24, 28, 32, 36, 40, 
  
  
44, 48, 10, 15, 20, 25, 30, 35, 40, 45, 12, 18, 24, 30, 36, 42, 48, 14, 21, 28, 35, 42, 49]  
  
  
</span>  
 
 

 
 

  
  
>>> words = 'The quick brown fox jumps over the lazy dog'.split()  
  
  
>>> words  
  
  
['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog']  
  
  
>>> stuff = [[w.upper(), w.lower(), len(w)] for w in words]  
  
  
>>> for i in stuff:  
  
  
    print i  
  
  
 
  
  
      
  
  
['THE', 'the', 3]  
  
  
['QUICK', 'quick', 5]  
  
  
['BROWN', 'brown', 5]  
  
  
['FOX', 'fox', 3]  
  
  
['JUMPS', 'jumps', 5]  
  
  
['OVER', 'over', 4]  
  
  
['THE', 'the', 3]  
  
  
['LAZY', 'lazy', 4]  
  
  
['DOG', 'dog', 3]  
 
 

Map () implementation of the above Code:

 
 

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

Generator expression

Generator expressions are introduced in python2.4. When the sequence is too long and you only need to get one element at a time, you should consider using generator expressions instead of list parsing. The syntax of the generator expression is the same as that of list parsing, except that the generator expression is enclosed by () instead of [], as follows:

 
 

  
  
(expr for iter_var in iterable)   
  
  
(expr for iter_var in iterable if cond_expr) 
 
 

Example:

 
 

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

The generator expression does not actually create a number list. Instead, it returns a generator. After calculating an entry, the generator "generates" the entry (yield. The generator expression uses lazy evaluation, which is also translated as "latency evaluation". I thought it would be better to translate the call by need Method on demand into inertia ), the value is assigned (evaluated) only during retrieval, so the memory usage is more effective when the list is relatively long. A generator object in python is something like a lazy list. The elements are only evaluated as soon as you iterate over them.

Notes:

1. When you need to execute only one loop, try to use the loop instead of list parsing, which is more intuitive as python advocates.

 
 

  
  
for item in sequence:  
  
  
    process(item) 
 
 

2. When built-in operations or types can be implemented in a more direct way, do not use list resolution.

For example, when copying a list, you can use L1 = list (L) instead:

 
 

  
  
L1=[x for x in L] 
 
 

3. When the sequence is too long and only one element needs to be obtained each time, use the generator expression.

4. List parsing performance is better than map, refer to http://www.qingliangcn.com/2010/02/list-comprehensions%E4%B8%8Elist-map%E6%80%A7%E8%83%BD%E5%AF%B9%E6%AF%94/
 

Link: http://www.cnblogs.com/moinmoin/archive/2011/03/10/lsit-comprehensions-generators.html