Take list comprehensions for example they look simple enough on the surface, but once you start digging into them, things get complicated fast.
Let’s say we have a list of numbers and we want to find all the even ones. In Python 2, this would be easy:
# Define a list of numbers
numbers = [1, 2, 3, 4, 5]
# Create an empty list to store even numbers
evens = []
# Loop through each number in the list
for num in numbers:
# Check if the number is even by using the modulo operator to check for a remainder of 0
if num % 2 == 0:
# If the number is even, append it to the evens list
evens.append(num)
# Print the list of even numbers
print(evens)
# Output: [2, 4]
# The script takes a list of numbers and finds all the even ones, storing them in a new list called "evens".
# The for loop iterates through each number in the original list and checks if it is even.
# If it is, it is added to the evens list using the append() method.
# Finally, the list of even numbers is printed.
But with list comprehensions, it’s a one-liner:
# This script creates a list of even numbers from a given list of numbers using list comprehensions
# Define a list of numbers
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# Create a new list using list comprehensions
# The new list will only contain numbers from the original list that are divisible by 2 (even numbers)
even_list = [num for num in numbers if num % 2 == 0]
# Print the new list
print(even_list)
# Output: [2, 4, 6, 8, 10]
That’s great and all, but what about when we want to do something more complex? Let’s say we have a list of dictionaries and we want to filter out the ones that don’t meet certain criteria. In Python 2:
# Here is the context before the script:
# That's great and all, but what about when we want to do something more complex? Let's say we have a list of dictionaries and we want to filter out the ones that don't meet certain criteria. In Python 2:
# Here is the script:
# Create a list of dictionaries with name and age as key-value pairs
data = [{'name': 'Alice', 'age': 30}, {'name': 'Bob', 'age': 45}, {'name': 'Charlie', 'age': 18}]
# Create an empty list to store the filtered data
filtered_data = []
# Loop through each item in the data list
for item in data:
# Check if the age of the current item is greater than 25
if item['age'] > 25:
# If it is, append the item to the filtered_data list
filtered_data.append(item)
# Print the filtered_data list
print(filtered_data)
# Output: [{'name': 'Alice', 'age': 30}, {'name': 'Bob', 'age': 45}]
# Explanation:
# The script creates a list of dictionaries called "data" with name and age as key-value pairs.
# Then, an empty list called "filtered_data" is created to store the filtered data.
# The for loop iterates through each item in the "data" list.
# The if statement checks if the age of the current item is greater than 25.
# If it is, the item is appended to the "filtered_data" list.
# Finally, the filtered_data list is printed, showing only the items with an age greater than 25.
But with list comprehensions, it’s a bit more complicated:
# This script uses list comprehensions to filter a list of dictionaries based on the value of the 'age' key.
# First, we create a new list called 'filtered' using list comprehension.
# The list comprehension iterates through the 'data' list and adds each dictionary to 'filtered' if the value of the 'age' key is greater than 25.
filtered = [d for d in data if d['age'] > 25]
# Finally, we print the filtered list.
print(filtered)
Wait, what? We have to use an ‘if’ statement inside the list comprehension? That doesn’t make any sense! But it does. Let’s break down how this works:
1. First, we create a new empty list called `filtered`. This is where our filtered data will go.
2. We loop through each item in the original list using a for-loop.
3. Inside the for-loop, we check if the current item’s ‘age’ value is greater than 25. If it is, we append that item to the `filtered` list.
4. Once the for-loop has finished iterating through all items in the original list, we have our filtered data stored in the `filtered` list.
Now let’s look at how this works with a list comprehension:
1. We create an empty list called `filtered`. This is where our filtered data will go.
2. Inside the list comprehension, we loop through each item in the original list using a for-loop (implicitly).
3. Inside the list comprehension’s if statement, we check if the current item’s ‘age’ value is greater than 25. If it is, we create a new dictionary that contains only the items from the current item that meet our criteria. This new dictionary gets added to the `filtered` list.
4. Once the for-loop has finished iterating through all items in the original list (implicitly), we have our filtered data stored in the `filtered` list.
So, what’s going on inside that if statement? Let’s break it down:
1. We create a new dictionary called `new_item`. This is where our filtered item will go.
2. Inside the for-loop (implicitly), we loop through each item in the original list using another for-loop (also implicitly).
3. Inside this inner for-loop, we check if the current item’s ‘age’ value is greater than 25. If it is, we add that item to our `new_item` dictionary.
4. Once the inner for-loop has finished iterating through all items in the original list (implicitly), we have a new dictionary called `new_item`. This gets added to the `filtered` list if its ‘age’ value is greater than 25.
And thats that! List comprehensions can be complex, but they’re also incredibly powerful once you get the hang of them. Just remember that for every list comprehension, there’s a corresponding for-loop somewhere in your code. And if you ever find yourself struggling with a list comprehension, just break it down into its component parts and see what’s going on under the hood.