我试图理解函数和生成器之间的区别,并为此使用了下面的代码。但是,我不理解输出。
class GeneratorsSample(object):
def DoReturn(self):
counter, maxCounter = 0, 5
listResults = []
while counter < maxCounter:
print "tic"
listResults.append(counter*2)
counter += 1
return listResults
def DoYield(self):
counter, maxCounter = 0, 5
listResults = []
while counter < maxCounter:
print "tic"
listResults.append(counter*2)
yield listResults #to return the entire list
#yield listResults[counter] #you can only return one item at a time
counter += 1
return
generatorSample = GeneratorsSample()
我不明白为什么 DoReturn() 的输出与 DoYield() 的输出不同。例如,
returnResults = generatorSample.DoReturn()
for r in returnResults:
print "toc", r
输出:
tic
tic
tic
tic
tic
toc 0
toc 2
toc 4
toc 6
toc 8
还有,
yieldResults = generatorSample.DoYield()
for r in yieldResults:
print "toc", r
输出:
tic
toc [0]
tic
toc [0, 2]
tic
toc [0, 2, 4]
tic
toc [0, 2, 4, 6]
tic
toc [0, 2, 4, 6, 8]
请您参考如下方法:
这可能是一个更好的例子:
class GeneratorsSample(object):
def DoReturn(self):
counter, maxCounter = 0, 5
listResults = []
while counter < maxCounter:
print "tic"
listResults.append(counter*2)
counter += 1
return listResults
def DoYield(self):
counter, maxCounter = 0, 5
while counter < maxCounter:
print "tic"
yield counter*2
counter += 1
return
generatorSample = GeneratorsSample()
ret = generatorSample.DoReturn()
yld = generatorSample.DoYield()
for r in ret: print "toc", r
for r in yld: print "toc", r
print ret
print yld
先看这几行:
for r in ret: print "toc", r
for r in yld: print "toc", r
生成了相同的值,但在“返回”版本中,所有的 tics 都在前面,然后是所有的目录。在“yield”版本中,tics 和 tocs 散布着。
但这两种方法之间的主要区别由以下几行说明:
print ret # prints: [0, 2, 4, 6, 8]
print yld # prints: <generator object DoYield at 0x0000000002202630>
这里,ret 是生成的所有值的列表。也就是说,当进行此分配时:
ret = generatorSample.DoReturn()
整个列表然后生成,并作为完整列表返回。
使用生成器方法,不会生成整个列表,实际上,不会计算任何元素。只是对生成器的引用,该生成器将根据需要“仅在飞行中”生成元素。
换句话说,“返回”方法:
generates a number generates a number generates a number ... uses that number uses that number uses that number ...
while the generator approach:
generates a number uses that number generates a number uses that number ...
The efficiency of generators are in the fact that they only take the time generate a single element, as they are needed (if they are ever needed). If the maxCounter was, say, 1 million, and the computation was more complex than counter * 2, there would be a noticeable improvement in the amount of time it took for you to get your first output.
In fact, you can see that by adding artificial delays (here, with time.sleep(1):
import time
class GeneratorsSample(object):
def DoReturn(self):
counter, maxCounter = 0, 5
listResults = []
while counter < maxCounter:
v = counter * 2
time.sleep(1)
print "[DoReturn] computed %d" % v
listResults.append(v)
counter += 1
return listResults
def DoYield(self):
counter, maxCounter = 0, 5
while counter < maxCounter:
v = counter * 2
time.sleep(1)
print "[DoYield] computed %d" % v
yield counter*2
counter += 1
return
generatorSample = GeneratorsSample()
ret = generatorSample.DoReturn()
yld = generatorSample.DoYield()
for r in ret: print "[return loop] using", r
print("")
for r in yld: print "[yield loop] using", r
输出为:
[DoReturn] computed 0 [DoReturn] computed 2 [DoReturn] computed 4 [DoReturn] computed 6 [DoReturn] computed 8 [return loop] using 0 [return loop] using 2 [return loop] using 4 [return loop] using 6 [return loop] using 8 [DoYield] computed 0 [yield loop] using 0 [DoYield] computed 2 [yield loop] using 2 [DoYield] computed 4 [yield loop] using 4 [DoYield] computed 6 [yield loop] using 6 [DoYield] computed 8 [yield loop] using 8
