Python | Which is faster to initialize lists?

29 Oct, 2021
Python is a very flexible language where a single task can be performed in a number of ways, for example initializing lists can be performed in many ways. However, there are subtle differences in these seemingly similar methods. Python which is popular for its simplicity and readability is equally infamous for being slow compared to C++ or Java. The ‘for’ loop is especially known to be slow whereas methods like map() and filter() are known to be faster because they are written in C. Knowing the better and faster way to initialize lists might give you a slight edge in competitive programming.
The following are some of the ways to initialize lists(we create lists of size 1000 and initialize with zeros) in Python.
Using a for loop and append()We create an empty an list and run a for loop for n times using the append() method to add elements to the list.
arr = []
for i in range(1000):
    arr.append(0)

Using a while loop with a counter variableThis is similar to the above method. However we use while loop instead.
arr = []
i = 0
while(i<1000):
    arr.append(0)

Using list comprehensionsIt consists of square brackets containing an expression followed by a for clause and further followed by an optional if clause. The expression can be any type of object that we want to put on the list. Since we are initializing the list with zeros, our expression will just be 0.
arr = [0 for i in range(1000)]

Using the * operatorThe * operator can be used as [object]*n where n is the no of elements in the array.
arr = [0]*1000

Lets look at the time taken by each of them. We will calculate the average time taken by each of these methods to initialize an array of 10000 elements over 500 times.
# import time module to calculate timesimport time  # initialize lists to save the timesforLoopTime = []whileLoopTime = []listComprehensionTime = []starOperatorTime = []  # repeat the process for 500 times# and calculate average of times taken.for k in range(500):       # start time    start = time.time()    # declare empty list    a = []    # run a for loop for 10000 times    for i in range(10000):        a.append(0)    # stop time    stop = time.time()    forLoopTime.append(stop-start)      # start time    start = time.time()    # declare an empty list    a = []    i = 0    # run a for loop 10000 times    while(i<10000):        a.append(0)        i+= 1    stop = time.time()    whileLoopTime.append(stop-start)      start = time.time()    # list comprehension to initialize list    a = [0 for i in range(10000)]     stop = time.time()    listComprehensionTime.append(stop-start)        start = time.time()    # using the * operator    a = [0]*10000     stop = time.time()    starOperatorTime.append(stop-start)      print("Average time taken by for loop: " + str(sum(forLoopTime)/100))print("Average time taken by while loop: " + str(sum(whileLoopTime)/100))print("Average time taken by list comprehensions: " + str(sum(listComprehensionTime)/100))print("Average time taken by * operator: " + str(sum(starOperatorTime)/100))    
Output
Average time taken by for loop: 0.012432687282562256
Average time taken by while loop: 0.017907898426055908
Average time taken by list comprehensions: 0.0034629487991333007
Average time taken by * operator: 0.0001951146125793457

Note: The times will vary based on the platform where this code is executed. These times are just for studying the relative performance of these methods of initializing.
As it can be seen, for and while loops take almost the same time with for loop having a slight edge.
List comprehensions perform much better than for and while loops with the former being around 3-5 times faster. Another example of this difference can be seen when we try to create a list of numbers from 1-1000. Using list comprehensions is much better than using append().a = [i for  i in range(1, 1001)]
a = [i for  i in range(1, 1001)]
Using the * operator is way faster than the remaining methods and this is the way you should be initializing lists
However one drawback of using the * operator is while declaring 2d arrays. Using this operator would create shallow lists i.e only one list object would be created and all the indices would refer to this object. This might create unwanted complications. Hence using list comprehensions is a safer way to create 2d lists.

Using * operator would create shallow lists
arr = [[0]*no_of_cols]*no_of_rows

Using list comprehensions is better for 2d arrays
arr = [[0 for i in range(no_of_cols)] for j in range(no_of_rows)]


chhabradhanvi
Python loop-programs
python-list
Python
python-list
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Python Dictionary
Different ways to create Pandas Dataframe
Read a file line by line in Python
Python String | replace()
How to Install PIP on Windows ?
*args and **kwargs in Python
Python Classes and Objects
Python OOPs Concepts
Convert integer to string in Python
Introduction To PYTHON