In Post #47, we learned how to use indexing (like my_list[0]) to access a single item from a list. This is great for retrieving one piece of data, but what if we need a whole section of the list? What if we want the first three items, the last two, or every other item?
For this, Python provides an incredibly powerful and concise feature called slicing. In this post, you’ll learn how to “slice” a list to extract any portion you need, creating a new list from the contents of an old one.
The Basic Slice: my_list[start:stop]
Slicing is a way to create a new list that contains a sub-section of an original list. The basic syntax uses a colon : inside the square brackets.
The syntax is: my_list[start:stop]
This will give you a new list containing all the items starting from the start index and going up to, but not including, the stop index. This “up to, but not including” rule is the exact same one we saw with the range() function in Post #35.
Let’s visualize this with a list of players:
players = ["Alice", "Bob", "Charlie", "David", "Eve"]
Index: 0 1 2 3 4If we want to get the players from index 1 up to index 4 (Bob, Charlie, and David), we would write:
players = ["Alice", "Bob", "Charlie", "David", "Eve"]
middle_players = players[1:4]
print(middle_players)The output will be a new list: ['Bob', 'Charlie', 'David']. Notice that “Eve” at index 4 is not included.
Omitting Indexes for Convenience
Python allows you to omit the start or stop indexes for common slicing operations.
Slicing from the Beginning
If you omit the start index, Python assumes you mean “start from the beginning” (index 0).
# Get the first three players (from index 0 up to, not including, 3)
first_three = players[:3]
print(first_three) # Output: ['Alice', 'Bob', 'Charlie']
Slicing to the End
Similarly, if you omit the stop index, Python assumes you mean “go all the way to the end of the list.”
# Get all players from index 2 onwards
all_but_first_two = players[2:]
print(all_but_first_two) # Output: ['Charlie', 'David', 'Eve']Copying a Whole List
If you omit both the start and stop indexes, you get a slice of the entire list. This is the simplest way to create a “shallow copy” of a list—a new list that is a duplicate of the original.
players_copy = players[:]
print(players_copy) # Output: ['Alice', 'Bob', 'Charlie', 'David', 'Eve']The Full Slice: Adding a step
The full slicing syntax is my_list[start:stop:step]. The step value dictates which items to take and how many to skip over, just like the step in the range() function.
Getting Every Other Item
To get every second item from a list, you can use a step of 2.
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Omit start and stop to go through the whole list, with a step of 2
even_numbers = numbers[::2]
print(even_numbers) # Output: [0, 2, 4, 6, 8]The Famous Trick: Reversing a List
A step of -1 tells Python to go backward through the list one item at a time. This is the most common and “Pythonic” trick to reverse a list.
my_list = ["a", "b", "c", "d"]
reversed_list = my_list[::-1]
print(reversed_list) # Output: ['d', 'c', 'b', 'a']What’s Next?
Slicing is a fundamental and powerful feature for working with lists. You can now extract any sub-section you need, from a simple range to complex, stepped selections, all with a concise and readable syntax.
We’ve now learned how to create lists, access their items, and create new lists from them using slicing. But one of the most defining features of a list is that we can change it after it’s been created. In Post #49, we will explore the core concept of mutability and see how it makes lists so dynamic.
Author
Experienced Cloud & DevOps Engineer with hands-on experience in AWS, GCP, Terraform, Ansible, ELK, Docker, Git, GitLab, Python, PowerShell, Shell, and theoretical knowledge on Azure, Kubernetes & Jenkins. In my free time, I write blogs on ckdbtech.com