如何多次遍历长列表？寻求优于itertools方案的低辅助存储实现

Great question! You’re already on the right track with your itertools solution, but let’s dig into the most memory-efficient options since you’re dealing with a long list and want to avoid nested loops in your main code.

First, let’s clarify: your current approach using chain.from_iterable(repeat(mylist, 3)) is already memory-friendly because repeat returns an iterator that references the original list (it doesn’t copy the list multiple times) and chain.from_iterable just chains those iterators together—no extra list copies are created. But there’s an even more straightforward, zero-overhead option if you want to keep your main code clean.

The Most Memory-Efficient Solution: Use a Generator Function #

Wrap the nested loop logic inside a generator function. This keeps your main code free of nested loops, and the generator doesn’t create any additional list copies—it just iterates over the original list repeatedly, using almost no extra memory:

def iterate_multiple_times(lst, times):
    for _ in range(times):
        yield from lst  # Shortcut for iterating and yielding each item

mylist = [10, 2, 58]
for i in iterate_multiple_times(mylist, 3):
    print(i, end=' ')
# Output: 10 2 58 10 2 58 10 2 58

Why this works: #

• yield from lst directly iterates over the original list and yields each item, no copies made.
• The generator only holds a reference to the original list and a counter for the number of iterations—no extra memory is used for duplicate list elements.
• Your main code uses a single for loop, avoiding the nested structure you wanted to skip.

Avoid This Inefficient Approach #

Steer clear of creating a new list with mylist * 3—this will create a full copy of your list three times over, which is terrible for memory when dealing with long lists:

# Bad for memory with long lists!
for i in mylist * 3:
    print(i)

Comparing to Your Itertools Solution #

Your original itertools approach is also memory-efficient (it uses iterators instead of copying lists), and it’s a concise one-liner if you prefer that style. The generator function approach is just more explicit and might be easier to read for someone unfamiliar with itertools chain/repeat mechanics.

Both options avoid extra memory overhead, so it’s mostly a matter of code style preference.

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