Lists in Python are one of the most popular and convenient data structures, used to store an ordered collection of items. In this section, we’ll dive deep into how to access list elements, i.e., how to “read” them. We’ll cover indexing, slicing, and other useful techniques for working with list elements.
To access an element in a list, you need to know its index—its position in the list. In Python, indexes start at 0 (the first element has index 0, the second has index 1, and so on). Python also supports negative indexes, which allow you to access elements from the end of the list: -1 is the last element, -2 is the second-to-last, and so forth.
✳️ The syntax for accessing an element is simple:
list[index]The easiest way to retrieve a list element is to specify its index in square brackets.
📌 Example:
fruits = ["apple", "banana", "orange"]
print(fruits[0]) # Output: apple
print(fruits[1]) # Output: banana
print(fruits[2]) # Output: orange
Here, we created a list fruits with three elements.
Using indexes 0, 1, and 2, we accessed each element individually.
Every element in a list has two indexes for direct access:
📌 Example with negative indexes:
fruits = ["apple", "banana", "orange"]
print(fruits[-1]) # Output: orange
print(fruits[-2]) # Output: banana
print(fruits[-3]) # Output: apple
Negative indexes are counted from the end of the list.
-1 is the last element, -2 is the
second-to-last, and so on. This is handy when you need to quickly access
an element from the end without knowing the list’s length.
If you try to access an index that doesn’t exist in the list, Python
raises an IndexError.
📌 Example:
fruits = ["apple", "banana", "orange"]
print(fruits[3]) # Error: IndexError: list index out of range
The fruits list has only 3 elements (indexes 0, 1, 2).
Attempting to access index 3 causes an error because no such element
exists.
To avoid this error, you can check the list’s length using the
len() function:
fruits = ["apple", "banana", "orange"]
if len(fruits) > 2:
print(fruits[2]) # Output: orange
else:
print("Index is out of range")
Slicing allows you to retrieve a sublist—a range of elements from the list.
✳️ Slice syntax:
list[start:end:step]If any parameter is omitted, Python uses default values:
start = 0 (beginning of the list),end = length of the list,step = 1.📌 Example:
numbers = [0, 1, 2, 3, 4, 5]
print(numbers[1:4]) # Output: [1, 2, 3]
We extracted elements from index 1 (inclusive) to index 4 (exclusive), i.e., elements at indexes 1, 2, and 3.
📌 Example with omitted parameters:
numbers = [0, 1, 2, 3, 4, 5]
print(numbers[:3]) # Output: [0, 1, 2] (from start to index 3)
print(numbers[3:]) # Output: [3, 4, 5] (from index 3 to end)
print(numbers[:]) # Output: [0, 1, 2, 3, 4, 5] (entire list)
If start is omitted, the slice begins at 0. If
end is omitted, it goes to the end of the list. If both are
omitted, you get a copy of the entire list.
📌 Example with a step:
numbers = [0, 1, 2, 3, 4, 5]
print(numbers[0:6:2]) # Output: [0, 2, 4]
Here, the step is 2, so every second element is taken from start to end: 0, 2, 4.
📌 Example with a negative step:
numbers = [0, 1, 2, 3, 4, 5]
print(numbers[5:1:-1]) # Output: [5, 4, 3, 2]
A negative step (-1) means moving through the list in reverse order, from end to start. We started at index 5 and went to index 2 (index 1 is excluded).
The .index() method returns the index of the first
occurrence of a specified value.
📌 Example 1:
fruits = ["apple", "banana", "cherry"]
index = fruits.index("cherry")
print(index) # Output: 2
📌 Example 2: Searching from a specific position
fruits = ["apple", "banana", "cherry", "orange", "kiwi", "banana"]
index = fruits.index("banana", 2) # Search for "banana" starting at index 2
print(index) # Output: 5 (index of the second "banana")
The .index() method raises a ValueError if
the element isn’t found, so it’s a good idea to check for the element’s
presence using the in operator first.
Sometimes you need to check if an element exists in a list before
accessing it. Use the in operator for this.
📌 Example:
fruits = ["apple", "banana", "orange"]
if "banana" in fruits:
print("Banana is in the list!")
else:
print("Banana is not in the list.")
# Output: Banana is in the list!
The in operator returns True if the element
is present and False if it’s not.
Attempting to access a nonexistent index raises an
IndexError. You can handle this with a try-except
block.
📌 Example:
fruits = ["apple", "banana", "cherry"]
try:
print(fruits[10]) # This index is out of range
except IndexError:
print("Index out of range!") # This will execute
You can also use conditional checks before accessing an element:
📌 Example:
fruits = ["apple", "banana", "cherry"]
index = 5
if 0 <= index < len(fruits):
print(fruits[index])
else:
print(f"Index {index} is out of the valid range!")
Python allows you to unpack list elements into separate variables, offering another way to access them.
first, second, third = ["apple", "banana", "cherry"]
print(first) # Output: apple
print(second) # Output: banana
print(third) # Output: cherry
Read more in the section on list unpacking.
Lists in Python can contain other lists (nested lists or lists of lists). To access an element in a nested list, use multiple indexes sequentially.
📌 Example:
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(matrix[0][1]) # Output: 2
print(matrix[2][0]) # Output: 7
# Accessing an entire row of the matrix
print(matrix[1]) # Output: [4, 5, 6] (second row of the matrix)
matrix[0] returns the first nested list
[1, 2, 3], and matrix[0][1] retrieves the
element at index 1 from that list, which is 2. Similarly,
matrix[2][0] returns 7 from the list
[7, 8, 9].
Nested lists are often used to represent multidimensional data, like matrices or tables. When working with them, remember that the first index refers to the nested list, and the second index refers to an element within it.
While not a direct way to access elements, the len()
function is often used alongside indexing. It returns the number of
elements in a list.
📌 Example:
fruits = ["apple", "banana", "orange"]
print(len(fruits)) # Output: 3
print(fruits[len(fruits) - 1]) # Output: orange
len(fruits) returns 3, and len(fruits) - 1
gives the index of the last element (2). This way, we retrieved the last
element of the list.
IndexError.We’ve covered indexing (both positive and negative), slicing with various parameters, and working with nested lists. Mastering these techniques will allow you to easily extract the data you need from lists, which is invaluable for a wide range of programming tasks.
You can use the fact that the first element has index 0 and the last element has index -1.
def swap_first_last(lst):
# Check that the list isn’t empty
if len(lst) >= 2:
# Use multiple assignment to swap
lst[0], lst[-1] = lst[-1], lst[0]
return lst
my_list = [1, 2, 3, 4, 5]
swapped = swap_first_last(my_list)
print(swapped) # Output: [5, 2, 3, 4, 1]
Use a slice with a negative index.
numbers = [1, 2, 3, 4, 5, 6]
print(numbers[-3:]) # Output: [4, 5, 6]
The slice [::2] takes every second element of the list
from start to end.