Python Tutorials

Python Comprehensions : List, Dict & Set

7 min read

When you first begin your programming journey, you learn to process data using standard for loops. While traditional loops get the job done, they often require writing four or five lines of code to accomplish a very simple task, like modifying a list of numbers.

As you transition from a beginner to an advanced developer, you will hear the term “Pythonic”. Writing Pythonic code means utilizing Python’s unique, built-in features to write clean, highly readable, and exceptionally fast code.

The ultimate hallmark of Pythonic code is the Comprehension. Comprehensions allow you to filter, modify, and generate entire lists, dictionaries, and sets in a single, elegant line of code. Mastering them will instantly make your codebase look more professional.

Comprehensions

In Python, a Comprehension is a concise syntactic construct that allows you to build a new collection (such as a List, Dictionary, or Set) by transforming or filtering an existing iterable (like another list, a string, or a range).

Under the hood, comprehensions are heavily optimized by Python’s C-backend, meaning they not only require fewer lines of code to write, but they often execute significantly faster than traditional for loops.

Syntax & Basic Usage

To understand the power of a comprehension, we must compare it to a standard loop. Let’s say we have a list of numbers, and we want to create a brand new list containing the squares of those numbers.

The Old Way (Traditional for loop)

original_numbers = [1, 2, 3, 4, 5]
squared_numbers = []

for number in original_numbers:
    squared_numbers.append(number ** 2)

print(f"Traditional Loop Result: {squared_numbers}")

# Expected Output:
# Traditional Loop Result: [1, 4, 9, 16, 25]

Code language: PHP (php)

The Pythonic Way (List Comprehension)

A list comprehension collapses the setup, the loop, and the .append() method into a single line enclosed in square brackets [].

Basic Syntax: [expression for item in iterable]

original_numbers = [1, 2, 3, 4, 5]

# Read this as: "Give me 'number squared' FOR every 'number' IN 'original_numbers'"
squared_numbers_comp = [number ** 2 for number in original_numbers]

print(f"Comprehension Result: {squared_numbers_comp}")

# Expected Output:
# Comprehension Result: [1, 4, 9, 16, 25]

Code language: PHP (php)

Complete Guide to Python Comprehension Methods and Function Arguments

Comprehensions are not limited to just lists, nor are they limited to simple transformations. You can add complex conditional logic and apply this syntax to dictionaries and sets.

1. List Comprehensions with Filtering (if condition)

You can append an if statement to the very end of a comprehension. This acts as a filter; the item is only added to the new list if the condition evaluates to True.

Syntax: [expression for item in iterable if condition]

temperature_readings = [72, 85, 90, 65, 95, 80]

# Filter out only the temperatures that are strictly greater than 80
hot_days = [temp for temp in temperature_readings if temp > 80]

print(f"Hot days recorded: {hot_days}")

# Expected Output:
# Hot days recorded: [85, 90, 95]

Code language: PHP (php)

2. Dictionary Comprehensions

You can build a Dictionary in a single line using curly braces {} and separating the key and value with a colon :.

Syntax: {key_expression: value_expression for item in iterable}

product_names = ["Laptop", "Mouse", "Keyboard"]

# Create a dictionary where the Key is the product name, 
# and the Value is the length of the product's name
product_name_lengths = {product: len(product) for product in product_names}

print(f"Dictionary Result: {product_name_lengths}")

# Expected Output:
# Dictionary Result: {'Laptop': 6, 'Mouse': 5, 'Keyboard': 8}

Code language: PHP (php)

3. Set Comprehensions

Sets are unordered collections that automatically remove duplicate values. You create a Set Comprehension using curly braces {} just like a dictionary, but you only provide a single expression, not a key-value pair.

Syntax: {expression for item in iterable}

user_input_tags = ["python", "Coding", "PYTHON", "java", "coding"]

# We want a clean set of unique tags, all in lowercase.
# Notice how the duplicate "python" and "coding" tags are automatically removed!
unique_clean_tags = {tag.lower() for tag in user_input_tags}

print(f"Unique Tags Set: {unique_clean_tags}")

# Expected Output:
# Unique Tags Set: {'java', 'coding', 'python'}

Code language: PHP (php)

(Note: Because sets are unordered, the output order may vary slightly every time you run the code, but the unique items remain the same).

4. Advanced If-Else Logic in Comprehensions

If you want to perform an if/else transformation (e.g., “If it is even, do X, else do Y”), the syntax shifts entirely. The if/else block must move to the front, right before the for keyword.

Syntax: [expression_if_true if condition else expression_if_false for item in iterable]

test_scores = [45, 90, 85, 30, 75]

# Tag scores >= 50 as "Pass", otherwise tag as "Fail"
graded_results = ["Pass" if score >= 50 else "Fail" for score in test_scores]

print(f"Graded Results: {graded_results}")

# Expected Output:
# Graded Results: ['Fail', 'Pass', 'Pass', 'Fail', 'Pass']

Code language: PHP (php)

5. Nested Comprehensions

You can place comprehensions inside of comprehensions to handle 2D data structures (like lists of lists, or matrices). To “flatten” a 2D list into a 1D list, you read the loops from left to right.

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

# Read as: "Give me the 'number', FOR every 'row' IN 'data_matrix', 
# and FOR every 'number' IN that 'row'"
flattened_list = [number for row in data_matrix for number in row]

print(f"Flattened Matrix: {flattened_list}")

# Expected Output:
# Flattened Matrix: [1, 2, 3, 4, 5, 6, 7, 8, 9]

Code language: PHP (php)

Real-World Practical Examples

Scenario 1: Data Cleaning Pipeline

In data science, you often receive messy data. Let’s write a python list comprehension tutorial example where we extract clean, valid email addresses from a messy list of raw strings.

raw_user_data = [
    "  alice@email.com \n", 
    "invalid_email", 
    "BOB@EMAIL.COM", 
    "   "
]

# 1. We check if "@" is in the string (filtering out invalid/blank strings)
# 2. We use .strip() to remove whitespace
# 3. We use .lower() to normalize the casing
clean_emails = [
    email.strip().lower() 
    for email in raw_user_data 
    if "@" in email
]

print(f"Cleaned Database: {clean_emails}")

# Expected Output:
# Cleaned Database: ['alice@email.com', 'bob@email.com']

Code language: PHP (php)

Scenario 2: Dynamic Pricing Updates (Dictionary Comprehension)

Imagine you manage an e-commerce store’s inventory. We want to apply a 10% discount to all products, but only if their original price is greater than $50. Let’s look at a powerful python dictionary comprehension example.

store_inventory = {
    "Headphones": 150.00,
    "Mousepad": 15.00,
    "Mechanical Keyboard": 120.00,
    "USB Cable": 10.00
}

# Apply a 10% discount (price * 0.9) IF the price is > 50, ELSE keep original price
# We iterate over .items() to get both the key (product) and value (price)
updated_inventory = {
    product: round(price * 0.9, 2) if price > 50 else price 
    for product, price in store_inventory.items()
}

print("--- Flash Sale Pricing ---")
for item, current_price in updated_inventory.items():
    print(f"{item}: ${current_price}")

# Expected Output:
# --- Flash Sale Pricing ---
# Headphones: $135.0
# Mousepad: $15.0
# Mechanical Keyboard: $108.0
# USB Cable: $10.0

Code language: PHP (php)

Best Practices & Common Pitfalls

  • The Over-Comprehension Trap: Just because you can write everything in one line doesn’t mean you should. If your comprehension is so complex that it spans three lines and requires immense mental effort to read, you are sacrificing readability. In those cases, revert to a standard for loop. “Pythonic” means readable, not just short.
  • Syntax Confusion with if/else: Remember the golden rule: If you are only filtering data (using just if), the if goes at the very end of the comprehension. If you are transforming data based on a condition (using if AND else), the logic must go at the very beginning.
  • Memory Limits: List comprehensions generate the entire list and store it in your computer’s RAM immediately. If you process 10 million records, a list comprehension will crash your computer. In these extreme cases, developers use Generator Expressions (which use () instead of []) to generate one item at a time memory-efficiently.

Summary

  • Comprehensions provide a clean, fast, and Pythonic way to generate collections in a single line of code.
  • List Comprehensions [expr for item in iterable] create new lists.
  • Dictionary Comprehensions {key: value for item in iterable} create new dictionaries.
  • Set Comprehensions {expr for item in iterable} create sets of unique values.
  • You can filter items by appending an if condition to the end of the comprehension.
  • You can route logic by placing an if/else expression at the very beginning of the comprehension.

Leave a Comment