你可以使用生成器的一个实际例子是，如果你有某种形状，你想要遍历它的角、边或其他地方。对于我自己的项目(源代码在这里)，我有一个矩形:

class Rect():

    def __init__(self, x, y, width, height):
        self.l_top  = (x, y)
        self.r_top  = (x+width, y)
        self.r_bot  = (x+width, y+height)
        self.l_bot  = (x, y+height)

    def __iter__(self):
        yield self.l_top
        yield self.r_top
        yield self.r_bot
        yield self.l_bot

现在我可以创建一个矩形，并在它的角上循环:

myrect=Rect(50, 50, 100, 100)
for corner in myrect:
    print(corner)

除了__iter__，你可以有一个方法iter_corners，并在myrect.iter_corners()中使用for corner来调用它。使用__iter__更优雅，因为我们可以在for表达式中直接使用类实例名。

现实世界中的例子

假设你的MySQL表中有1亿个域名，你想为每个域名更新Alexa排名。

你需要做的第一件事是从数据库中选择域名。

假设表名为domains，列名为domain。

如果你使用SELECT domain FROM domains，它将返回1亿行，这将消耗大量内存。所以您的服务器可能会崩溃。

所以你决定分批运行这个程序。假设我们的批量大小是1000。

在我们的第一批中，我们将查询前1000行，检查每个域的Alexa排名并更新数据库行。

在我们的第二批中，我们将处理接下来的1000行。第三批将从2001年到3000年，以此类推。

现在我们需要一个生成器函数来生成我们的批。

这是我们的生成器函数:

def ResultGenerator(cursor, batchsize=1000):
    while True:
        results = cursor.fetchmany(batchsize)
        if not results:
            break
        for result in results:
            yield result

正如你所看到的，我们的函数总是得到结果。如果使用关键字return而不是yield，那么整个函数将在到达return时结束。

return - returns only once
yield - returns multiple times

如果一个函数使用关键字yield，那么它就是一个生成器。

现在你可以这样迭代:

db = MySQLdb.connect(host="localhost", user="root", passwd="root", db="domains")
cursor = db.cursor()
cursor.execute("SELECT domain FROM domains")
for result in ResultGenerator(cursor):
    doSomethingWith(result)
db.close()

也适用于打印到n的质数:

def genprime(n=10):
    for num in range(3, n+1):
        for factor in range(2, num):
            if num%factor == 0:
                break
        else:
            yield(num)

for prime_num in genprime(100):
    print(prime_num)

使用生成器的原因之一是为了使某些解决方案的解决方案更清晰。

另一种方法是一次处理一个结果，避免建立庞大的结果列表，否则无论如何都要分开处理。

如果你有这样一个fibonacci- to-n函数:

# function version
def fibon(n):
    a = b = 1
    result = []
    for i in xrange(n):
        result.append(a)
        a, b = b, a + b
    return result

你可以更容易地写出这样的函数:

# generator version
def fibon(n):
    a = b = 1
    for i in xrange(n):
        yield a
        a, b = b, a + b

函数更清晰。如果你这样使用这个函数:

for x in fibon(1000000):
    print x,

在本例中，如果使用生成器版本，则根本不会创建整个1000000项列表，每次只创建一个值。在使用列表版本时，情况并非如此，在列表版本中，将首先创建列表。

请参阅PEP 255中的“动机”部分。

生成器的一个不太明显的用途是创建可中断函数，它允许您在不使用线程的情况下“同时”执行更新UI或运行多个作业(实际上是交错的)。

我最喜欢的用法是“过滤”和“减少”操作。

假设我们正在读取一个文件，并且只想要以“##”开头的行。

def filter2sharps( aSequence ):
    for l in aSequence:
        if l.startswith("##"):
            yield l

然后，我们可以在适当的循环中使用生成器函数

source= file( ... )
for line in filter2sharps( source.readlines() ):
    print line
source.close()

reduce的例子类似。假设我们有一个文件，其中我们需要定位<Location>…< / >位置线。[不是HTML标签，而是恰好看起来像标签的行。]

def reduceLocation( aSequence ):
    keep= False
    block= None
    for line in aSequence:
        if line.startswith("</Location"):
            block.append( line )
            yield block
            block= None
            keep= False
        elif line.startsWith("<Location"):
            block= [ line ]
            keep= True
        elif keep:
            block.append( line )
        else:
            pass
    if block is not None:
        yield block # A partial block, icky

同样，我们可以在一个合适的for循环中使用这个生成器。

source = file( ... )
for b in reduceLocation( source.readlines() ):
    print b
source.close()

其思想是，生成器函数允许我们过滤或减少序列，每次生成一个值的另一个序列。