Adventures in Machine Learning

Python List vs Array: Understanding the Differences and Operations

Python List and Array: Understanding the Key Differences and Mathematical Operations

Python is a popular programming language that is widely used in fields such as data science, machine learning, and web development. When working with data in Python, you can use two primary data structures: lists and arrays.

Although lists and arrays are often used interchangeably, they are fundamentally different in several ways. In this article, we will explore the differences between lists and arrays, how data gets stored, and mathematical operations that you can perform on lists and arrays.

Differences Between Python List and Array

Data Storage in Lists and Arrays

The primary difference between lists and arrays is how they store data. Lists store heterogeneous data types, which means you can store a combination of different data types like integers, strings, booleans, and even other lists .

Arrays, on the other hand, store homogeneous data types, which means all the elements in the array must be of the same data type.

Declaration of Lists and Arrays

Another significant difference between lists and arrays is how you declare them. Lists are built into the Python language, meaning you don’t need to import any modules to start using them.

You can declare a list by using square brackets [ ] and separating its elements with commas.

On the other hand, arrays have to be declared using the NumPy module which is specifically designed for working with scientific and mathematical arrays.

One of the key benefits of using NumPy arrays is that they offer a faster and more convenient way to manipulate data than lists. To declare an array, you need to import the NumPy module first and then create the array by calling its constructor function, numpy.array().

Mathematical Operations on Lists and Arrays

Mathematical Operations on Arrays

Arrays are widely used as the primary data structure for scientific and mathematical computations. NumPy provides built-in mathematical functions that allow you to manipulate arrays in various ways, such as finding the mean, median, and mode of an array.

Additionally, you can perform arithmetic operations between two or more arrays, such as adding, subtracting, multiplying, and dividing. Manipulating arrays with NumPy can be much faster and more convenient than manipulating lists.

This is because, NumPy implements these mathematical operations at the C level, which can process data much faster than the Python interpreter can.

Mathematical Operations on Lists

While manipulating an entire list with mathematical operators is not possible, a Python list allows you to iterate over its elements using a loop and manipulating these elements independently. One common example is transforming each element in the list by performing an arithmetic operation on it.

For example, if you have a list of temperatures in Fahrenheit, you can convert this list into Celsius by using the formula `C = (F-32)* 5/9`. With a simple for loop, you can transform the entire list of temperatures into Celsius:


temperatures = [68, 72, 80, 88]

for i in range(len(temperatures)):

temperatures[i] = (temperatures[i] – 32) * 5/9


Reflecting on Individual Elements

Lists enable you to transform individual elements inside the list. Its elements are not constrained by any conditions such as having a common data type.

This means that, unlike arrays, you can reflect on your datas contents and decide precisely what to transform. For example, if you have a list of names, you can convert all the names to uppercase or lowercase or perform any other transformation that Python supports.


In summary, lists and arrays are fundamental data structures in Python that allow you to store, manipulate, and perform mathematical operations on data. While both have their place, it’s essential to understand the differences so that you can choose the best data structure for your application.

Lists are more flexible and versatile than arrays. On the other hand, arrays are more efficient when it comes to scientific and mathematical computations.

Ultimately, the choice between the two depends on your use case, and knowing the differences between the two will help you make an informed decision. Resizing of Lists and Arrays: Understanding the Differences

When working with data in Python, there are times when you may need to resize a list or an array.

Resizing a data structure means increasing or decreasing the number of elements it contains. In this article, we will explore the differences between resizing lists and arrays and how efficient they are.

Resizing of Python Lists

Lists in Python feature inbuilt functions that allow you to resize them freely. One of these functions is append(), which adds an element to the end of the list, increasing its size by one.

Here’s an example:


my_list = [1, 2, 3]

my_list.append(4) # adds 4 to the end of the list

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


Similarly, you can use the insert() function to add an element at a specific index and increase the size of the list. It takes two arguments: the first is the index where you want to add the element, and the second is the value of the new element.

Here’s an example:


my_list = [1, 2, 3]

my_list.insert(1, 4) # inserts 4 at index 1

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


You can also remove elements from a list using functions such as remove(), pop(), and del. For instance, remove() method removes the first occurrence of the specified element from the list.

It takes the element’s value as the argument. Here’s an example:


my_list = [1, 2, 3, 4]

my_list.remove(2) # removes the element with value 2

print(my_list) # [1, 3, 4]


Overall, lists in Python have an efficient resizing operation that doesnt require copying data to a new memory location.

However, keep in mind that when you repeatedly append or insert elements into an empty list, the memory allocation will grow in chunks, consuming more memory space than you need.

Resizing of Python Arrays

Arrays in Python, however, do not have an efficient way of resizing. In fact, it’s not possible to resize an array once it’s created.

When you create a NumPy array, its size is fixed, meaning you can’t add or remove elements from it directly. The only way to append or insert elements into an array is by creating a new array with the new size and copying the existing elements to the new array.

Here’s an example:


import numpy as np

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

new_array = np.append(my_array, 4)

print(new_array) #[1, 2, 3, 4]


In the above example, we use the NumPy append() method to add an element to a new array with the updated size. The original array remains unchanged because NumPy’s append method creates a new array.

Another way of resizing NumPy arrays is by using the resize() method. The resize() method creates a new array with a new size and copies the original values.

However, in practice, this method is not efficient because it creates a new array and involves copying data to the new memory location. If your application requires frequent resizing, using arrays might result in poor performance.

Overall, resizing arrays in Python can be costly in terms of computational time and memory allocation. Resizing arrays is done by creating a new array and copying the existing elements to the new array.

Thus for cases that require updating arrays continually, lists are a better option.


In conclusion, Lists and arrays are essential data structures in python programming. They have their pros and cons, and you can utilize them to solve different data tasks efficiently.

Lists offer an efficient resizing operation, while arrays can be tricky to resize, and it can be memory-consuming to do so. Knowing the difference in resizing operations will help you make an informed choice between the two data structures, depending on the particular needs of your program.

In conclusion, Python provides two primary data structures – Lists and Arrays, which are essential in programming languages. Understanding the differences in how they store data, how to declare them, and their resizing operations will help you choose the best structure for a specific purpose.

Lists are flexible and suitable for storing heterogeneous data types whereas arrays store homogeneous data types. Additionally, lists have an efficient resizing operation while arrays lack an efficient resizing operation, which can lead to poor performance.

Therefore, it’s crucial to understand these differences and use them efficiently when developing various programs.

Popular Posts