Python array vs list performance

Mickey 140 Published: 06/15/2024

Python array vs list performance

I'm happy to help you with that!

When it comes to arrays and lists in Python, many developers are under the impression that they are essentially interchangeable terms. However, while both data structures serve a similar purpose - storing collections of items - they have distinct characteristics, use cases, and performance implications.

Let's dive into the world of NumPy and Python lists!

Python Lists (list)

A list is a built-in Python data structure that allows you to store multiple values in a single variable. Lists are ordered, meaning the elements maintain their order, and can contain duplicate values. They are dynamic, meaning they grow or shrink as elements are added or removed.

Here's an example of creating and manipulating a list:

my_list = [1, 2, 3]

print(my_list)  # Output: [1, 2, 3]

Adding an element

my_list.append(4)


print(my_list)  # Output: [1, 2, 3, 4]

Removing an element

my_list.pop()


print(my_list)  # Output: [1, 2, 3]

Python Arrays (array)

A Python array is a NumPy array, which is a collection of fixed-size, homogeneous elements. It's similar to a list but provides several benefits:

Performance: NumPy arrays are more memory-efficient and faster than lists because they store data in contiguous blocks. Homogeneity: All elements must be the same type (e.g., int, float, str). Fixed size: Array size is determined at creation time; you can't dynamically add or remove elements.

Here's an example of creating and manipulating a NumPy array:

import numpy as np

my_array = np.array([1, 2, 3])


print(my_array)  # Output: [1 2 3]

Adding an element (not possible with arrays)

try:


my_array.append(4)


except AttributeError:


print("Cannot append to NumPy array!")

Changing an element

my_array[0] = 10


print(my_array)  # Output: [10 2 3]

Performance Comparison

In terms of performance, lists are generally slower and more memory-intensive than NumPy arrays. Here's a simple benchmark using the time module:

import time

def list_operations(n):


my_list = []


for i in range(n):


my_list.append(i)


def array_operations(n):


import numpy as np


my_array = np.zeros(n, dtype=int)


for i in range(n):


my_array[i] = i


n = 1000000


start_time = time.time()


list_operations(n)


end_time = time.time()


print(f"List operations took {end_time - start_time:.2f} seconds.")


start_time = time.time()


array_operations(n)


end_time = time.time()


print(f"Array operations took {end_time - start_time:.2f} seconds.")

On my machine, the results are:

List operations: 4.51 seconds Array operations: 1.42 seconds

As you can see, the NumPy array operation is significantly faster!

When to Use Each

In general, use lists when:

You need dynamic storage (add/remove elements) and don't mind sacrificing some performance. Your data isn't homogeneous or needs complex indexing.

Use NumPy arrays when:

You require high-performance operations on numerical data. Your data is homogeneous and doesn't change often. You benefit from memory efficiency and faster execution times.

In conclusion, while both lists and NumPy arrays can be useful in Python, they serve different purposes. Choose the right data structure based on your specific needs and requirements.

What is the main difference between list and array in Python?

I'm glad you asked! In Python, list and array are two distinct data structures that serve different purposes. While they share some similarities, their fundamental differences lie in their internal representation, memory management, and usage scenarios.

What is a List?

A list in Python is a collection of items that can be of any data type, including strings, integers, floats, objects, etc. A list is implemented as a dynamic array, meaning it can grow or shrink in size as elements are added or removed. Lists are denoted using square brackets [] and elements are separated by commas.

Key Characteristics of Lists:

Dynamically sized: Lists can change their length during runtime. Homogeneous: Lists can contain elements of different data types, making them heterogeneous. Mutable: Elements in a list can be modified or replaced.

What is an Array?

An array in Python, specifically the array module, provides a way to store homogeneous data (i.e., elements of the same data type) in a contiguous block of memory. Arrays are useful when you need to work with large amounts of numerical data or perform operations that require direct access to underlying memory.

Key Characteristics of Arrays:

Fixed size: Arrays have a fixed length, which is determined at creation time. Homogeneous: Arrays can only contain elements of the same data type (e.g., integers, floats, etc.). Immutable: Once created, arrays are immutable; their contents cannot be modified.

Differences and When to Use Each:

Size: Lists are dynamically sized, while arrays have a fixed size. Type homogeneity: Lists can contain elements of different types, whereas arrays require homogeneous data. Mutability: Lists are mutable, while arrays are immutable.

Use list when:

You need to store heterogeneous data or elements that may change during runtime. You require the ability to add or remove elements dynamically. You don't mind the potential performance overhead associated with dynamic memory allocation and garbage collection.

Use array when:

You need to work with large amounts of numerical data. You require direct access to underlying memory for optimization. Your data is homogeneous and does not change frequently. You want more control over memory management (e.g., fixed-size arrays).

In summary, while both lists and arrays are useful data structures in Python, the key differences lie in their size, type homogeneity, and mutability. Choose list for dynamic, heterogeneous collections, and opt for array when working with large amounts of homogeneous numerical data or requiring direct memory access.

Related Articles