List of zeros in Python

Pro-level techniques and potential issues

Beyond basic list initialization, Python offers various methodologies that you could consider based on the nature of your specific task.

Custom function for zeros-lists

You can encapsulate the zero list creation into a function for the sake of readability:

# Function: Python's magic wand to generate zero list!
def zero_list(n):
    return [0] * n

example_list = zero_list(5)  # [0, 0, 0, 0, 0]


Scalability with numpy

When dealing with a Godzilla-sized dataset that might explode your RAM, numpy.zeros is your savior:

import numpy as np

# Announcing the arrival of a thousand zeros!
large_zero_array = np.zeros(1000)


Lazy evaluation with itertools.repeat

itertools.repeat, a real Python ninja, lazily creates zeros for memory performance on data structures that make galaxies look small:

from itertools import repeat

lazy_zeros = repeat(0)
first_ten_zeros = [next(lazy_zeros) for _ in range(10)]  # The first ten lazy zeroes appear!


Avoid copy-paste trap with mutable objects

Guard yourself from cloning the same mutable object using **[[]] * n**. All created instances refer to the same memory location – a scary horror movie!

To create individual empty lists:

# Every list needs its own home!
distinct_lists = [[] for _ in range(5)]


Choose the fastest horse using performance comparison

Use the timeit module to start a race between different techniques and pick the fastest horse:

import timeit

# Python Olympics: May the fastest code win!
simple_time = timeit.timeit('zero_list = [0] * 1000', number=10000)
numpy_time = timeit.timeit('import numpy; zero_array = numpy.zeros(1000)', number=10000)


Generate sequential zero lists in a snap

Magic! Turn your Python wand into a zero list factory that spits out sequential zero lists:

# Python the genie: Your wish is my command!
zlists = [[0] * i for i in range(10)]


Yes, zlists[3] will gift you [0, 0, 0]. Elegant, isn't it?

Advanced scenarios, use cases and alternatives

Mutable elements variation

With mutable elements like list, **my_list * n** replicates the same reference, leading to unwanted shenanigans. To create unique copies, use:

unique_lists = [list(my_list) for _ in range(n)]


Zero-filled multidimensional lists

Quench your thirst for a two-dimensional list of zeros using nested comprehensions:

rows, cols = 3, 4

# Creating a 3x4 zero-filled matrix, because we can!
two_d_list = [[0] * cols for _ in range(rows)]


Right tool, right job

While [0] * n is fabulous for lightweight tasks, numpy or itertools might save the day in large-scale or performance-demanding tasks.

References