I am curious what the fastest way to consume an iterator would be, and the most Pythonic way.
For example, say that I want to create an iterator with the map
builtin that accumulates something as a side-effect. I don't actually care about the result of the map
, just the side effect, so I want to blow through the iteration with as little overhead or boilerplate as possible. Something like:
my_set = set()
my_map = map(lambda x, y: my_set.add((x, y)), my_x, my_y)
In this example, I just want to blow through the iterator to accumulate things in my_set
, and my_set
is just an empty set until I actually run through my_map
. Something like:
for _ in my_map:
pass
or a naked
[_ for _ in my_map]
works, but they both feel clunky. Is there a more Pythonic way to make sure an iterator iterates quickly so that you can benefit from some side-effect?
Benchmark
I tested the two methods above on the following:
my_x = np.random.randint(100, size=int(1e6))
my_y = np.random.randint(100, size=int(1e6))
with my_set
and my_map
as defined above. I got the following results with timeit:
for _ in my_map:
pass
468 ms ± 20.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
[_ for _ in my_map]
476 ms ± 12.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
No real difference between the two, and they both feel clunky.
Note, I got similar performance with list(my_map)
, which was a suggestion in the comments.
See Question&Answers more detail:
os 与恶龙缠斗过久,自身亦成为恶龙;凝视深渊过久,深渊将回以凝视…