Create list of single item repeated N times

Common pitfalls with list multiplication

While list multiplication offers simplicity, be aware of these quirki-ness:

Handling mutable objects

If your item is a mutable object, like a list or dict, be aware that [e] * N creates N references to the same object, leading to code tricks:

nested_lists = [[]] * 3  # A seemingly innocent list of lists
nested_lists[0].append('A')  # Plot twist: They're all the same list under disguise!
print(nested_lists)  # Everyone is 'A'!


To avoid plot twists, create each object independently:

nested_lists = [[] for _ in range(N)]  # Now we're really talking


Memory concerns for large N

Got a colossal N in mind? Mind your memory usage. Use generator expressions instead:

gen_exp = ('item' for _ in range(N))  # Gentle on your memory


Making lazy use of itertools.repeat

from itertools import repeat
lazy_repeater = repeat('item', times=N)  # What's the hurry? Lazy generator at your service!


This prepares an iterator to lazily generate 'item' whenever asked, saving the rush to pre-allocate the whole list.

Let's multiply strategies!

Beyond list multiplication, Python offers numerous ways to get the job done:

List comprehensions: Python's gift to mathematical nerds!

comp_list = ['item' for _ in range(N)]  # Math! But more fun.


You repeat? Use numpy.repeat!

If NumPy is your speed, numpy.repeat can be your best buddy:

import numpy as np
np_repeated_array = np.repeat('item', N)  # NumPy: Ready for big operations!


This has the horsepower for handling large data array manipulation efficiently.

Everyone's favorite: Efficiency and performance!

The race: List multiplication vs itertools.repeat

List multiplication speeds past itertools.repeat when a list is required, thanks to built-in optimizations. Who knew Python liked race cars?

Housekeeping: Memory

The [e] * N approach smartly pre-allocates memory, creating a fixed-size list. Perfect for immutable types, unnecessary for lazy boys like itertools.repeat.

Stopwatch check: Performance testing

Don't just take my word for it. Timing is believing!

import timeit

# Start your engines: list multiplication
time_list_mult = timeit.timeit("['item'] * N", number=1000)

# Revving up itertools.repeat
time_it_repeat = timeit.timeit("list(repeat('item', times=N))", setup="from itertools import repeat", number=1000)

print(f"List multiplication: {time_list_mult} seconds!")
print(f"itertools.repeat: {time_it_repeat} seconds!")
