Logo
Python Introduction
Python Installation and Project Setup
Running Python Programs
Python Syntax and Indentation Rules
Python Variables
Python Comments
Python Data Types
Python Type Conversion and Type Checking
Python Input and Output Functions
Python Operators
Python Arithmetic Operators
Python Assignment Operators
Python Logical Operators
Python Comparison Operators
Python Bitwise Operators
Python Membership Operators
Python Identity Operators
Python Walrus Operator
Python Operator Precedence
Python Conditional Statements
Python if Statement
Python if else
Python if elif else
Python match case Statement
Python Loops
Python for Loop
Python for else Loop
Python while Loop
Python break statement
Python continue statement
Python pass statement
Python Strings
Python String Slicing
Python String Concatenation
Python String Formatting
Python Escape Characters
Python Lists
Python Access List Items
Python Add List Items
Python Change List Items
Python Remove List Items
Python Sort Lists
Python Copy Lists
Python Join Lists
Python List Methods
Python Tuples
Python Access Tuple Items
Python Update Tuples
Python Unpack Tuples
Python Loop Tuples
Python Join Tuples
Python Tuple Methods
Python Sets
Python Dictionaries
Python Functions
Python Lambda Functions
Python Higher Order Functions
Python Classes and Objects
Python OOP Principles
Python Magic Methods
Python Context Managers
Python Error Handling and Debugging
Python File Handling
Python Modules and Packages
Python Iterators and Generators

Python Access List Items

When you create a list in Python, the next thing you want to do is access list items to read, display, or work with the data stored inside it. Python access list items using index numbers, and understanding how indexing works is the foundation of everything you will do with lists. Each element in a Python list sits at a specific position, and you can reach any element directly by referring to its position number.

A Python list stores items in an ordered sequence, and every item gets an integer index starting from zero. The first item sits at index 0, the second at index 1, the third at index 2, and so on. This zero-based indexing system is consistent across Python and makes it straightforward to access list items once you know the position of the element you need.

Access List Items by Index

The most common way to access list items in Python is by using the index number inside square brackets. You place the index of the item you want right after the list name, enclosed in brackets, and Python returns the value stored at that position.

fruits = ["apple", "banana", "cherry", "date", "elderberry"]
print(fruits[0])
print(fruits[2])
print(fruits[4])

Output
apple
cherry
elderberry

The list called fruits contains five string elements. Using fruits[0] returns the first item, which is apple. Using fruits[2] returns cherry because indexing starts from zero, making cherry the third item but sitting at index position 2. The last item elderberry sits at index 4 since a list with five elements has indices running from 0 through 4.

You can also store the retrieved value in a variable and use it later in your program. This is how most real Python programs access list items rather than printing them directly.

colors = ["red", "green", "blue", "yellow"]
favorite = colors[1]
print("My favorite color is", favorite)

Output
My favorite color is green

Here colors[1] pulls out the string green from the list and stores it in the variable favorite. You can then use that variable anywhere else in your code.

Access List Items Using Negative Indexing

Python gives you a second way to access list items through negative indexing. Instead of counting from the beginning, negative indices count backward from the end of the list. The last item has index -1, the second to last has index -2, and so on. This is extremely useful when you want to grab elements from the end of a list without knowing how many items it contains.

languages = ["Python", "Java", "C++", "JavaScript", "Ruby"]
print(languages[-1])
print(languages[-2])
print(languages[-5])

Output
Ruby
JavaScript
Python

Using languages[-1] gives you Ruby, the last element. languages[-2] returns JavaScript, the second element from the end. And languages[-5] reaches all the way back to the first element, Python, because a list with five items has negative indices from -1 down to -5.

Negative indexing in Python is particularly handy when you are processing data and always need the most recent entry. Instead of calculating the length of the list and subtracting one, you simply use index -1 to access the last list item.

temperatures = [22.5, 23.1, 21.8, 24.0, 22.9]
latest_reading = temperatures[-1]
print("Latest temperature:", latest_reading)

Output
Latest temperature: 22.9

The variable latest_reading holds 22.9 because temperatures[-1] always points to whatever item is at the end of the list, regardless of how long the list is.

Access a Range of List Items with Slicing

When you need to access multiple list items at once, Python list slicing lets you pull out a subset of the list by specifying a start index and a stop index separated by a colon. The slice returns a new list containing all elements from the start index up to but not including the stop index.

numbers = [10, 20, 30, 40, 50, 60, 70]
subset = numbers[1:4]
print(subset)

Output
[20, 30, 40]

The slice numbers[1:4] starts at index 1 which is 20 and goes up to but does not include index 4 which is 50. So you get a new list containing the elements at indices 1, 2, and 3.

If you leave out the start index, Python assumes you want to start from the beginning of the list. If you leave out the stop index, it goes all the way to the end.

animals = ["cat", "dog", "bird", "fish", "hamster"]
first_three = animals[:3]
last_three = animals[2:]
print(first_three)
print(last_three)

Output
['cat', 'dog', 'bird']
['bird', 'fish', 'hamster']

animals[:3] grabs everything from the start up to index 3, giving you the first three items. animals[2:] starts at index 2 and grabs everything through the end, giving you the last three items. Both operations produce new lists and leave the original animals list unchanged.

You can also combine negative indices with slicing to access list items from the end.

scores = [88, 92, 75, 81, 95, 67, 73]
last_two = scores[-2:]
print(last_two)

Output
[67, 73]

The slice scores[-2:] starts two positions from the end and goes through the last element, returning a new list with the final two scores.

Access List Items with a Step Value

Python slicing also accepts a third parameter called the step value that controls how many positions to skip between each selected item. The syntax is list[start:stop:step], and the default step is 1 which means every item in the range gets selected.

digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
every_other = digits[::2]
print(every_other)

Output
[0, 2, 4, 6, 8]

Using digits[::2] starts at the beginning, goes to the end, and picks every second element. The step value of 2 skips one item between each selection.

You can combine a step value with start and stop indices to access specific list items within a range.

digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
selected = digits[1:8:3]
print(selected)

Output
[1, 4, 7]

This slice starts at index 1, stops before index 8, and takes every third item. So it picks up 1 at index 1, 4 at index 4, and 7 at index 7.

A negative step value lets you access list items in reverse order.

letters = ["a", "b", "c", "d", "e"]
reversed_list = letters[::-1]
print(reversed_list)

Output
['e', 'd', 'c', 'b', 'a']

Using letters[::-1] reverses the entire list by starting from the end and stepping backward one position at a time.

Check if an Item Exists in a List

Before trying to access list items, you often want to check whether a particular value exists in the list. Python provides the in keyword for this purpose. It returns True if the item is found and False if it is not.

cities = ["London", "Paris", "Tokyo", "New York", "Sydney"]
print("Paris" in cities)
print("Berlin" in cities)

Output
True
False

The expression "Paris" in cities checks every element in the list and confirms that Paris is present. "Berlin" in cities returns False because Berlin is not one of the items in the list.

You can use this membership test inside an if statement to safely access list items and avoid errors.

menu = ["burger", "pizza", "pasta", "salad"]
item = "pizza"
if item in menu:
    print(item, "is available")

Output
pizza is available

This pattern is common in real Python programs where you need to verify that an item exists before performing an operation on it.

Access List Items Using a Loop

When you want to access every item in a list one by one, a for loop is the natural tool. Python for loops are designed to iterate over sequences like lists, and each iteration gives you the next item.

planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter"]
for planet in planets:
    print(planet)

Output
Mercury
Venus
Earth
Mars
Jupiter

The for loop walks through the planets list from start to finish. On each pass, the variable planet holds the current item, and the print function displays it. This is the simplest and most readable way to access all list items in Python.

If you need both the index and the value while accessing list items, use the enumerate() function. It pairs each item with its index number automatically.

fruits = ["mango", "grape", "peach", "plum"]
for index, fruit in enumerate(fruits):
    print(index, fruit)

Output
0 mango
1 grape
2 peach
3 plum

The enumerate function wraps each element with its position number, letting you access both the index and the list item at the same time. This is much cleaner than manually tracking an index counter.

Access Nested List Items

Lists in Python can contain other lists as elements, creating nested lists. To access items inside a nested list, you use multiple sets of square brackets. The first bracket accesses the outer list, and the second bracket accesses the item within the inner list.

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(matrix[0])
print(matrix[0][1])
print(matrix[2][2])

Output
[1, 2, 3]
2
9

matrix[0] returns the entire first inner list [1, 2, 3]. Adding a second index with matrix[0][1] drills into that inner list and returns the element at index 1, which is 2. matrix[2][2] first accesses the third inner list [7, 8, 9] and then grabs the item at index 2 within it, which is 9.

You can combine negative indexing with nested list access to reach elements from the end of inner lists.

data = [["apple", "banana"], ["carrot", "broccoli"], ["salmon", "tuna"]]
print(data[-1][-1])
print(data[1][-2])

Output
tuna
carrot

data[-1][-1] accesses the last inner list ["salmon", "tuna"] and then grabs its last element, tuna. data[1][-2] accesses the second inner list and gets the second to last element, which is carrot.

Handling Index Errors

When you try to access a list item using an index that does not exist, Python raises an IndexError. This happens when the index is greater than or equal to the length of the list or when a negative index goes beyond the beginning.

colors = ["red", "blue", "green"]
try:
    print(colors[5])
except IndexError:
    print("That index does not exist in the list")

Output
That index does not exist in the list

The list colors has three items with valid indices 0, 1, and 2. Attempting to access index 5 triggers an IndexError. Wrapping the access in a try-except block catches the error and lets your program handle it gracefully instead of crashing.

You can also prevent index errors by checking the list length before trying to access a specific position.

items = [100, 200, 300]
position = 4
if position < len(items):
    print(items[position])
else:
    print("Position", position, "is out of range")

Output
Position 4 is out of range

The len() function returns the number of items in the list. Comparing your desired index against this length before accessing the list item prevents the IndexError entirely.

Full Working Example

This complete program demonstrates all the ways to access list items in Python, from basic indexing and negative indexing through slicing, membership checking, looping, and nested list access.

students = ["Alice", "Bob", "Charlie", "Diana", "Eve", "Frank"]

first_student = students[0]
print("First student:", first_student)

last_student = students[-1]
print("Last student:", last_student)

middle_group = students[1:4]
print("Middle group:", middle_group)

every_other = students[::2]
print("Every other student:", every_other)

reversed_students = students[::-1]
print("Reversed list:", reversed_students)

search_name = "Charlie"
if search_name in students:
    print(search_name, "is in the class")

print("All students:")
for index, name in enumerate(students):
    print(f"  {index}: {name}")

grades = [["Alice", 90], ["Bob", 85], ["Charlie", 92]]
print("First student name:", grades[0][0])
print("First student grade:", grades[0][1])
print("Last student grade:", grades[-1][-1])

try:
    print(students[10])
except IndexError:
    print("Index 10 is out of range for a list with", len(students), "items")

Output
First student: Alice
Last student: Frank
Middle group: ['Bob', 'Charlie', 'Diana']
Every other student: ['Alice', 'Charlie', 'Eve']
Reversed list: ['Frank', 'Eve', 'Diana', 'Charlie', 'Bob', 'Alice']
Charlie is in the class
All students:
  0: Alice
  1: Bob
  2: Charlie
  3: Diana
  4: Eve
  5: Frank
First student name: Alice
First student grade: 90
Last student grade: 92
Index 10 is out of range for a list with 6 items