Python Lists are used to store an ordered collection of objects, which can be of any data type – integers, strings, floats, objects, etc. Python lists are one of the most versatile and commonly used data structures in Python. In this tutorial, we will explore Python lists in-depth, discussing their use, benefits, performance, examples, and everything relevant to Python lists.

What will you learn?

Creating a List:

In Python, a list can be created by enclosing a comma-separated sequence of items within square brackets []. A list can also be created by using the list() constructor and passing an iterable as an argument. Below you will find examples of a list of integers, list of strings, floats, or any other data type and example of list creation by using list() constructor:

my_list = [1, 2, 3, 4, 5]
my_list = ['apple', 'banana', 'cherry']
my_list = [1.1, 2.2, 3.3, 4.4]
my_list = [True, False, True, True]

my_list = list(range(1, 6))

Accessing Elements of a List:

You can access individual elements of a list by specifying the index number in square brackets. Python uses zero-based indexing, meaning that the first element of the list has an index of 0. You can also use negative indexing to access elements from the end of the list:

my_list = ['apple', 'banana', 'cherry']
print(my_list[0])    
# Output: apple

print(my_list[1])    
# Output: banana

print(my_list[2])    
# Output: cherry

#Accesing using negative indexes
my_list = ['apple', 'banana', 'cherry']
print(my_list[-1])    
# Output: cherry

print(my_list[-2])    
# Output: banana

print(my_list[-3])    
# Output: apple

Slicing a List:

List slicing is a powerful feature of Python lists that allows you to extract a portion of a list by specifying a range of indices. The syntax for list slicing is as follows:

my_list[start:stop:step]

where start is the index of the first element to include in the slice (inclusive), stop is the index of the last element to include in the slice (exclusive), and step is the step size between elements in the slice. All three parameters are optional, and default to the following values:

start: 0
stop: the length of the list
step: 1

Here are some examples of list slicing:

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Get the first three elements
print(my_list[:3])  
# Output: [0, 1, 2]

# Get every other element starting from the second
print(my_list[1::2])  
# Output: [1, 3, 5, 7, 9]

# Get the last three elements
print(my_list[-3:])  
# Output: [7, 8, 9]

# Reverse the list
print(my_list[::-1])
# Output: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

In addition to the start, stop, and step parameters, there are a few other things to keep in mind when using list slicing:

The slice includes all elements from the start index up to, but not including, the stop index.
If the step parameter is negative, the slice will be taken in reverse order, starting from the end of the list and moving towards the beginning.
The start and stop indices can be negative, in which case they are interpreted as being relative to the end of the list. For example, my_list[-3:] returns the last three elements of the list.
Slicing a list creates a new list, which is a copy of the original list containing only the sliced elements.

Overall, list slicing is a very useful tool for working with lists in Python. It allows you to extract subsets of a list quickly and easily, and can be used in a variety of different contexts, from data processing to algorithm design.

Modifying Elements of a List:

You can change the value of individual elements of a list by assigning a new value to the corresponding index.

my_list = ['apple', 'banana', 'cherry']
my_list[1] = 'orange'
print(my_list)    

# Output: ['apple', 'orange', 'cherry']

Adding Elements to a List:

You can add new elements to a list using the append() method. The append() method adds the new element to the end of the list.

my_list = ['apple', 'banana', 'cherry']
my_list.append('orange')
print(my_list)    

# Output: ['apple', 'banana', 'cherry', 'orange']

You can also add new elements to a specific position in the list using the insert() method.

my_list = ['apple', 'banana', 'cherry']
my_list.insert(1, 'orange')
print(my_list)    

# Output: ['apple', 'orange', 'banana', 'cherry']

Removing Elements from a List:

You can remove an element from a list using the remove() method. The remove() method removes the first occurrence of the specified element.

my_list = ['apple', 'banana', 'cherry']
my_list.remove('banana')
print(my_list)    

# Output: ['apple', 'cherry']

You can also remove an element from a specific position in the list using the pop() method. The pop() method removes the element at the specified index.

my_list = ['apple', 'banana', 'cherry']
my_list.pop(1)
print(my_list)    

# Output: ['apple', 'cherry']

If you don’t specify the index, the pop() method will remove the last element of the list.

my_list = ['apple', 'banana', 'cherry']
my_list.pop()
print(my_list)    
# Output: ['apple', 'banana']

Searching Elements in a List:

You can check if an element is present in a list using the in keyword.

my_list = ['apple', 'banana', 'cherry']
if 'banana' in my_list:
    print("Yes, 'banana' is in the list")

Looping Through a List:

You can loop through the elements of a list using a for loop.

my_list = ['apple', 'banana', 'cherry']
for x in my_list:
    print(x)

Complexities in Python List.

Operation	Time Complexity	Space Complexity
Creating a list with n elements	O(n)	O(n)
Indexing	O(1)	O(1)
Appending	O(1) amortized	O(1)
Extending	O(k)	O(k)
Inserting	O(n)	O(n)
Deleting	O(n)	O(n)
Popping	O(1) (from end), O(n) (from any other position)	O(1)
Sorting	O(n log n)	O(n)
Searching	O(n)	O(1)

List Benefits

Lists are flexible, mutable, and can contain elements of any data type.
Lists provide a convenient way to store and manipulate collections of data.
Lists can be easily looped through, sliced, and modified.

List Performance

Lists are implemented as dynamic arrays in Python.
Accessing an element in a list has a time complexity of O(1).
Inserting or deleting an element at the end of a list has a time complexity of O(1).
Inserting or deleting an element at the beginning or middle of a list has a time complexity of O(n).

Conclusion:

Python lists are an important data structure in Python, providing a flexible and convenient way to store and manipulate collections of data. Lists can be easily looped through, sliced, and modified, and can contain elements of any data type. List comprehensions provide a concise way to create new lists based on existing lists. Knowing how to use lists effectively is an important skill for any Python programmer.

The codes mentioned in this post can be downloaded from github.com. Share the post with someone you think can benefit from the information.