blocks|key|1556674|text|当结果需要多次迭代时，或者速度非常重要时，请使用列表理解。在范围很大或无限大的地方使用生成器表达式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1556675|有关详细信息，请参阅Generator+expressions+and+list+comprehensions。|offset|length|1556676|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/howto/functional.html#generator-expressions-and-list-comprehensions^0|0|A|19|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

Use list comprehensions when the result needs to be iterated over multiple times, or where speed is paramount. Use generator expressions where the range is large or infinite.

See <a href="https://docs.python.org/3/howto/functional.html#generator-expressions-and-list-comprehensions" rel="noreferrer">Generator expressions and list comprehensions</a> for more info.

blocks|key|1556732|text|John's+answer是好的(当你想要多次迭代一些东西时，列表理解会更好)。但是，还值得注意的是，如果您想使用任何list方法，就应该使用list。例如，以下代码将不起作用：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1556733|def+gen():
++++return+(something+for+something+in+get_some_stuff())

print+gen()[:2]+++++#+generators+don't+support+indexing+or+slicing
print+[5,6]+%2B+gen()+#+generators+can't+be+added+to+lists|code-block|syntax|javascript|1556734|基本上，如果您所做的只是迭代一次，则使用生成器表达式。如果您想存储和使用生成的结果，那么使用列表理解可能会更好。|1556735|由于性能是选择一个而不是另一个的最常见原因，我的建议是不要担心这一点，只选择一个；如果您发现程序运行太慢，那么也只有到那时，您才应该回去考虑代码的调优问题。|1556736|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/47792/4518341^0|0|D|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

<a href="https://stackoverflow.com/a/47792/4518341">John's answer</a> is good (that list comprehensions are better when you want to iterate over something multiple times). However, it's also worth noting that you should use a list if you want to use any of the list methods. For example, the following code won't work:

<pre><code>def gen():
 return (something for something in get_some_stuff())

print gen()[:2] # generators don't support indexing or slicing
print [5,6] + gen() # generators can't be added to lists
</code></pre>

Basically, use a generator expression if all you're doing is iterating once. If you want to store and use the generated results, then you're probably better off with a list comprehension.

Since performance is the most common reason to choose one over the other, my advice is to not worry about it and just pick one; if you find that your program is running too slowly, then and only then should you go back and worry about tuning your code.

blocks|key|1771980|text|生成器表达式的好处是它使用较少的内存，因为它不会一次构建整个列表。生成器表达式最适合在列表作为中介时使用，例如对结果求和，或根据结果创建字典。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1771981|例如：|1771982|sum(x*2+for+x+in+xrange(256))

dict(+(k,+some_func(k))+for+k+in+some_list_of_keys+)|code-block|syntax|javascript|1771983|这样做的好处是列表不是完全生成的，因此使用的内存很少(而且应该会更快)|1771984|但是，当期望的最终产品是列表时，您应该使用列表理解。您不会使用生成器表达式保存任何内存，因为您需要生成的列表。您还可以使用任何列表函数，如排序或反转。|1771985|1771986|reversed(+[x*2+for+x+in+xrange(256)]+)|1771987|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|T|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|U|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|V|8|@]|9|@]|A|$]]|$1|M|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|N|3|O|5|F|7|X|8|@]|9|@]|A|$G|H]]|$1|P|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|Q|$]]

The benefit of a generator expression is that it uses less memory since it doesn't build the whole list at once. Generator expressions are best used when the list is an intermediary, such as summing the results, or creating a dict out of the results.

For example:

<pre><code>sum(x*2 for x in xrange(256))

dict( (k, some_func(k)) for k in some_list_of_keys )
</code></pre>

The advantage there is that the list isn't completely generated, and thus little memory is used (and should also be faster)

You should, though, use list comprehensions when the desired final product is a list. You are not going to save any memeory using generator expressions, since you want the generated list. You also get the benefit of being able to use any of the list functions like sorted or reversed.

For example:

<pre><code>reversed( [x*2 for x in xrange(256)] )
</code></pre>

blocks|key|1556903|text|我在用Hadoop+Mincemeat+module。我认为这是一个值得注意的很好的例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1556904|import+mincemeat

def+mapfn(k,v):
++++for+w+in+v:
++++++++yield+'sum',w
++++++++#yield+'count',1


def+reducefn(k,v):+
++++r1=sum(v)
++++r2=len(v)
++++print+r2
++++m=r1/r2
++++std=0
++++for+i+in+range(r2):
+++++++std%2B=pow(abs(v[i]-m),2)++
++++res=pow((std/r2),0.5)
++++return+r1,r2,res|code-block|syntax|javascript|1556905|在这里，生成器从一个文本文件(最大15+of+)中获取数字，并使用Hadoop的map-reduce对这些数字应用简单的数学运算。如果我没有使用收益函数，而是使用列表理解，那么计算总和和平均值会花费更长的时间(更不用说空间复杂性了)。|1556906|Hadoop是使用生成器的所有优点的一个很好的例子。|1556907|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/michaelfairley/mincemeatpy^0|3|N|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

I'm using the <a href="https://github.com/michaelfairley/mincemeatpy" rel="nofollow noreferrer">Hadoop Mincemeat module</a>. I think this is a great example to take a note of:

<pre><code>import mincemeat

def mapfn(k,v):
 for w in v:
 yield 'sum',w
 #yield 'count',1


def reducefn(k,v): 
 r1=sum(v)
 r2=len(v)
 print r2
 m=r1/r2
 std=0
 for i in range(r2):
 std+=pow(abs(v[i]-m),2) 
 res=pow((std/r2),0.5)
 return r1,r2,res
</code></pre>

Here the generator gets numbers out of a text file (as big as 15GB) and applies simple math on those numbers using Hadoop's map-reduce. If I had not used the yield function, but instead a list comprehension, it would have taken a much longer time calculating the sums and average (not to mention the space complexity).

Hadoop is a great example for using all the advantages of Generators.

blocks|key|1556955|text|从可变对象(如列表)创建生成器时，请注意生成器将在使用生成器时根据列表的状态进行评估，而不是在生成器创建时：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1556956|>>>+mylist+=+["a",+"b",+"c"]
>>>+gen+=+(elem+%2B+"1"+for+elem+in+mylist)
>>>+mylist.clear()
>>>+for+x+in+gen:+print+(x)
#+nothing|code-block|syntax|javascript|1556957|如果您的列表(或该列表中的可变对象)有可能被修改，但您在创建生成器时需要状态，则需要使用列表理解。|1556958|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

When creating a generator from a mutable object (like a list) be aware that the generator will get evaluated on the state of the list at time of using the generator, not at time of the creation of the generator:

<pre><code>&gt;&gt;&gt; mylist = ["a", "b", "c"]
&gt;&gt;&gt; gen = (elem + "1" for elem in mylist)
&gt;&gt;&gt; mylist.clear()
&gt;&gt;&gt; for x in gen: print (x)
# nothing
</code></pre>

If there is any chance of your list getting modified (or a mutable object inside that list) but you need the state at creation of the generator you need to use a list comprehension instead.

blocks|key|1557042|text|列表理解是急切的，但是生成器是懒惰的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1557043|在列表理解中，所有对象都是立即创建的，创建和返回列表需要更长的时间。在生成器表达式中，对象的创建会延迟到next()发出请求。在next()时，生成器对象被创建并立即返回。|offset|length|style|CODE|1557044|迭代在列表理解中更快，因为已经创建了对象。|1557045|如果迭代列表理解和生成器表达式中的所有元素，时间性能大致相同。即使生成器表达式立即返回生成器对象，它也不会创建所有元素。每次你迭代一个新的元素，它都会创建并返回它。|1557046|但是如果你不遍历所有的元素，生成器的效率会更高。假设您需要创建一个包含数百万项的列表理解，但您只使用了其中的10项。你仍然需要创建数百万个项目。你只是在浪费时间进行数百万次计算来创建数百万个只使用10个的条目，或者如果你发出了数百万个api请求，但最终只使用了其中的10个。因为生成器表达式是惰性的，所以除非被请求，否则它不会进行所有计算或api调用。在这种情况下，使用生成器表达式会更有效。|1557047|在列表理解中，整个集合被加载到内存中。但是生成器表达式，一旦它在你的next()调用中返回一个值给你，它就完成了，它不需要再将它存储在内存中。只有一个项目被加载到内存。如果你在磁盘上迭代一个大文件，如果文件太大，你可能会遇到内存问题。在这种情况下，使用生成器表达式更有效。|1557048|entityMap^0|0|1G|6|1S|6|0|0|0|0|Y|6|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@$D|T|E|U|F|G]|$D|V|E|W|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|Y|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|Z|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|10|8|@$D|11|E|12|F|G]]|9|@]|A|$]]|$1|P|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|Q|$]]

List comprehensions are eager but generators are lazy.
In list comprehensions all objects are created right away, it takes longer to create and return the list. In generator expressions, object creation is delayed until request by <code>next()</code>. Upon <code>next()</code> generator object is created and returned immediately.
Iteration is faster in list comprehensions because objects are already created.
If you iterate all the elements in list comprehension and generator expression, time performance is about the same. Even though generator expression return generator object right away, it does not create all the elements. Everytime you iterate over a new element, it will create and return it.
But if you do not iterate through all the elements generator are more efficient. Let's say you need to create a list comprehensions that contains millions of items but you are using only 10 of them. You still have to create millions of items. You are just wasting time for making millions of calculations to create millions of items to use only 10. Or if you are making millions of api requests but end up using only 10 of them. Since generator expressions are lazy, it does not make all the calculations or api calls unless it is requested. In this case using generator expressions will be more efficient.
In list comprehensions entire collection is loaded to the memory. But generator expressions, once it returns a value to you upon your <code>next()</code> call, it is done with it and it does not need to store it in the memory any more. Only a single item is loaded to the memory. If you are iterating over a huge file in disk, if file is too big you might get memory issue. In this case using generator expression is more efficient.

blocks|key|1772321|text|我认为大多数答案都遗漏了一些东西。列表理解基本上是创建一个列表并将其添加到堆栈中。在列表对象非常大的情况下，您的脚本进程将被终止。在这种情况下，生成器更可取，因为它的值不存储在内存中，而是作为有状态函数存储。同样，创建速度也很快；列表理解比生成器理解慢|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1772322|简而言之，当obj的大小不是太大时，使用列表理解，否则使用生成器理解。|1772323|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

There is something that I think most of the answers have missed. List comprehension basically creates a list and adds it to the stack. In cases where the list object is extremely large, your script process would be killed. A generator would be more preferred in this case as its values are not stored in memory but rather stored as a stateful function. Also speed of creation; list comprehension are slower than generator comprehension
In short;
use list comprehension when the size of the obj is not excessively large else use generator comprehension

blocks|key|1557191|text|对于函数式编程，我们希望使用尽可能少的索引。出于这个原因，如果我们想要在获取元素的第一个切片之后继续使用这些元素，islice()是一个更好的选择，因为迭代器状态已被保存。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1557192|from+itertools+import+islice

def+slice_and_continue(sequence):
++++ret+=+[]
++++seq_i+=+iter(sequence)+#create+an+iterator+from+the+list

++++seq_slice+=+islice(seq_i,3)+#take+first+3+elements+and+print
++++for+x+in+seq_slice:+print(x),

++++for+x+in+seq_i:+print(x**2),+#square+the+rest+of+the+numbers

slice_and_continue([1,2,3,4,5])|code-block|syntax|javascript|1557193|输出:1+2+3+16+25|1557194|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

For functional programming, we want to use as little indexing as possible. For this reason, If we want to continue using the elements after we take the first slice of elements, islice() is a better choice since the iterator state is saved.
<pre><code>from itertools import islice

def slice_and_continue(sequence):
 ret = []
 seq_i = iter(sequence) #create an iterator from the list

 seq_slice = islice(seq_i,3) #take first 3 elements and print
 for x in seq_slice: print(x),

 for x in seq_i: print(x**2), #square the rest of the numbers

slice_and_continue([1,2,3,4,5])
</code></pre>
output: 1 2 3 16 25

When should you use generator expressions and when should you use list comprehensions in Python?

<pre><code># Generator expression
(x*2 for x in range(256))

# List comprehension
[x*2 for x in range(256)]
</code></pre>

Generator expressions vs. list comprehensions

Hadoop 

Python

在Python中，什么时候应该使用生成器表达式，什么时候应该使用列表理解？# Generator expression(x*2 for x in range(256))# List comprehension[x*2 for x in range(256)]

问生成器表达式与列表理解
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问生成器表达式与列表理解EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问生成器表达式与列表理解
EN