如何让Generator expressions可复用？解决其仅能单次使用的局限

Great question! That single-use quirk of generator expressions is such a common gotcha—especially when you love their memory efficiency but need to run the same logic multiple times. Let's walk through your best options to fix this:

Option 1: Wrap the Generator Expression in a Function #

The simplest and most flexible solution is to turn your generator expression into a function. Every time you call the function, it will return a brand new generator instance, giving you a fresh iterable each time:

names = ['John', 'George', 'Paul', 'Ringo']

def get_has_o_generator():
    # Each call creates a new generator expression instance
    return (name for name in names if 'o' in name)

# First use
for name in get_has_o_generator():
    print(name.upper())

# Second use works perfectly
for name in get_has_o_generator():
    print(name.lower())

This approach keeps the memory efficiency of generators while making your logic reusable. It's also easy to modify later—if you need to adjust the filtering logic or input list, you only change the function once.

Option 2: Use a Lambda for a More Concise Wrapper #

If you prefer something shorter and don't need a full-named function, a lambda works just as well. It's essentially a tiny, anonymous function that returns your generator expression:

names = ['John', 'George', 'Paul', 'Ringo']
has_o = lambda: (name for name in names if 'o' in name)

# Usage is identical
for name in has_o():
    print(name.upper())

for name in has_o():
    print(name.lower())

Option 3: Clone with itertools.tee (For One-Time Cloning) #

If you only need to reuse the generator a fixed number of times before you iterate over it, you can use itertools.tee to create multiple clones of the original generator. Just note this only works if you haven't started iterating over the original yet:

import itertools

names = ['John', 'George', 'Paul', 'Ringo']
original_gen = (name for name in names if 'o' in name)

# Create two clones before using the original
gen1, gen2 = itertools.tee(original_gen)

# Iterate over the first clone
for name in gen1:
    print(name.upper())

# Iterate over the second clone
for name in gen2:
    print(name.lower())

⚠️ A word of caution: tee shares the underlying state of the original generator, so if the original generator depends on external variables that change between uses, the clones will reflect those changes. Also, once any of the clones (or the original) is fully iterated, all of them will be exhausted. This makes it less flexible than the function wrapper approach for most reuse cases.

Why This Works #

Generator expressions return a single generator instance—once you iterate over it, it's exhausted (there's no more data to yield). By wrapping the expression in a function, you're creating a "generator factory": every call to the function constructs a new, fresh generator that starts from the beginning.

内容的提问来源于stack exchange，提问作者AgvaniaRekuva