# Basic list comprehension syntax
new_list = [expression for item in iterable]
# Example: Square each number in a list
numbers = [1, 2, 3, 4, 5]
squares = [num ** 2 for num in numbers]
print(squares) # Output: [1, 4, 9, 16, 25]
List comprehension python provides a single-line mechanism to construct new lists by applying operations to each element in an existing iterable. The syntax consists of square brackets containing an expression, followed by a for clause that iterates through a source iterable. This approach replaces multi-line for loops with compact, readable code that executes faster due to Python’s internal optimizations.
Understanding the basic structure of list comprehension
The fundamental pattern follows a specific order: the transformation expression appears first, then the for keyword with a variable name, followed by the in keyword and the source iterable. Python evaluates this structure from right to left, iterating through each item in the source and applying the expression to produce output values.
# Breaking down the components
fruits = ['apple', 'banana', 'cherry']
uppercase_fruits = [fruit.upper() for fruit in fruits]
# Expression: fruit.upper()
# Variable: fruit
# Iterable: fruits
# Result: ['APPLE', 'BANANA', 'CHERRY']
The expression component accepts any valid Python operation, from simple attribute access to complex function calls. The variable serves as a placeholder representing each element during iteration. The iterable can be any Python object that supports iteration, including lists, tuples, strings, ranges, or generator expressions.
Creating lists with conditional filtering
List comprehension python supports conditional logic through an optional if clause placed after the for statement. This filter evaluates each item before including it in the output list, processing only elements that satisfy the specified condition.
# Filter even numbers from a range
numbers = range(20)
even_numbers = [num for num in numbers if num % 2 == 0]
print(even_numbers) # Output: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
# Extract words longer than 4 characters
words = ['cat', 'elephant', 'dog', 'hippopotamus', 'ant']
long_words = [word for word in words if len(word) > 4]
print(long_words) # Output: ['elephant', 'hippopotamus']
The condition executes after the iteration variable receives each value but before the expression processes it. Only items returning True from the conditional check proceed to the expression evaluation stage. This filtering happens inline without requiring separate filter() function calls or intermediate variables.
Applying transformation and filtering simultaneously
Complex list comprehensions combine both transformation and filtering in a single statement. The expression transforms each element while the if clause determines which elements undergo transformation.
# Convert strings to integers, filtering out non-numeric values
mixed_data = ['42', 'apple', '17', 'banana', '99', 'cherry']
numbers = [int(item) for item in mixed_data if item.isdigit()]
print(numbers) # Output: [42, 17, 99]
# Square even numbers only
values = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_squares = [num ** 2 for num in values if num % 2 == 0]
print(even_squares) # Output: [4, 16, 36, 64, 100]
The filtering condition precedes the transformation, ensuring Python only applies expensive operations to relevant items. This sequence improves performance when processing large datasets with selective transformations.
Using if-else expressions in list comprehension
List comprehension python accommodates ternary conditional expressions within the output expression itself. This pattern differs from filtering because it processes every element but produces different outputs based on conditions.
# Classify numbers as even or odd
numbers = [1, 2, 3, 4, 5, 6]
classifications = ['even' if num % 2 == 0 else 'odd' for num in numbers]
print(classifications) # Output: ['odd', 'even', 'odd', 'even', 'odd', 'even']
# Replace negative numbers with zero
values = [5, -3, 8, -1, 12, -7]
non_negative = [num if num >= 0 else 0 for num in values]
print(non_negative) # Output: [5, 0, 8, 0, 12, 0]
The ternary expression follows the pattern value_if_true if condition else value_if_false, appearing before the for clause. This placement distinguishes it from the filter-style if statement that appears after the iteration specification.
Working with nested list comprehensions
Nested list comprehension python creates multi-dimensional structures or flattens existing ones. The nested comprehensions read left to right, with outer loops appearing first in the sequence.
# Create a multiplication table
multiplication_table = [[i * j for j in range(1, 6)] for i in range(1, 6)]
print(multiplication_table)
# Output: [[1, 2, 3, 4, 5], [2, 4, 6, 8, 10], [3, 6, 9, 12, 15], [4, 8, 12, 16, 20], [5, 10, 15, 20, 25]]
# Generate coordinate pairs for a grid
coordinates = [(x, y) for x in range(3) for y in range(3)]
print(coordinates)
# Output: [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
The coordinate example demonstrates how multiple for clauses create a Cartesian product of iterables. Python processes the leftmost for clause first, then iterates through the rightmost clause for each element from the left.
Flattening nested lists with list comprehension
List comprehension python excels at converting multi-dimensional structures into single-dimension lists. The technique employs two for clauses that iterate through outer and inner levels sequentially.
# Flatten a matrix into a single list
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print(flattened) # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]
# Extract all elements from nested lists of varying lengths
irregular_nested = [[10, 20], [30], [40, 50, 60], [70, 80]]
all_values = [item for sublist in irregular_nested for item in sublist]
print(all_values) # Output: [10, 20, 30, 40, 50, 60, 70, 80]
The flattening pattern reads naturally when translated to English: “for each row in the matrix, for each number in that row, include the number.” This ordering matches the nested for loop equivalent where the outer loop processes rows before the inner loop processes individual elements.
Combining multiple conditions in list comprehension
Multiple if clauses function as AND conditions, requiring all conditions to evaluate True before including an element. This pattern replaces complex boolean expressions with readable sequential checks.
# Find numbers divisible by both 3 and 5
numbers = range(100)
divisible_by_both = [num for num in numbers if num % 3 == 0 if num % 5 == 0]
print(divisible_by_both) # Output: [0, 15, 30, 45, 60, 75, 90]
# Filter strings by multiple criteria
words = ['Python', 'code', 'programming', 'data', 'analysis']
filtered = [word for word in words if len(word) > 4 if word[0] in 'Pp']
print(filtered) # Output: ['Python', 'programming']
Each if clause operates independently, evaluating only items that passed previous conditions. This sequential filtering stops processing items as soon as any condition fails, potentially improving performance over compound boolean expressions.
Using enumerate with list comprehension
List comprehension python integrates with enumerate() to access both index positions and values during iteration. This technique proves valuable when creating derived data structures that depend on element positions.
# Create tuples of indices and values
fruits = ['apple', 'banana', 'cherry', 'date']
indexed_fruits = [(index, fruit) for index, fruit in enumerate(fruits)]
print(indexed_fruits)
# Output: [(0, 'apple'), (1, 'banana'), (2, 'cherry'), (3, 'date')]
# Filter items based on their position
numbers = [10, 20, 30, 40, 50]
even_positioned = [num for index, num in enumerate(numbers) if index % 2 == 0]
print(even_positioned) # Output: [10, 30, 50]
The enumerate() function returns tuples containing indices and values, which the for clause unpacks into separate variables. This unpacking enables independent access to both components within the comprehension expression or conditions.
Processing strings with list comprehension
String iteration through list comprehension python treats each character as an individual element. This approach simplifies character-level transformations and filtering operations.
# Extract vowels from a string
text = 'comprehension'
vowels = [char for char in text if char in 'aeiou']
print(vowels) # Output: ['o', 'e', 'e', 'i', 'o']
# Convert characters to ASCII values
word = 'Python'
ascii_values = [ord(char) for char in word]
print(ascii_values) # Output: [80, 121, 116, 104, 111, 110]
# Remove whitespace and convert to uppercase
sentence = ' hello world '
cleaned = [char.upper() for char in sentence if not char.isspace()]
print(''.join(cleaned)) # Output: HELLOWORLD
String processing combines transformation functions like upper(), lower(), and ord() with filtering conditions that check character properties through methods like isspace(), isdigit(), and isalpha().
Replacing map and filter functions
List comprehension python provides a more readable alternative to functional programming constructs like map() and filter(). The comprehension syntax eliminates lambda function requirements while maintaining equivalent functionality.
# Traditional map approach
numbers = [1, 2, 3, 4, 5]
squared_map = list(map(lambda x: x ** 2, numbers))
# List comprehension equivalent
squared_comp = [num ** 2 for num in numbers]
# Traditional filter approach
even_filter = list(filter(lambda x: x % 2 == 0, numbers))
# List comprehension equivalent
even_comp = [num for num in numbers if num % 2 == 0]
# Combining map and filter
transformed = list(map(lambda x: x ** 2, filter(lambda x: x % 2 == 0, numbers)))
# Single list comprehension
combined = [num ** 2 for num in numbers if num % 2 == 0]
The comprehension approach maintains better readability because the transformation and filtering logic appear in a natural left-to-right reading order. The map() and filter() combination requires inside-out reading to understand the complete operation sequence.
Working with dictionary items in list comprehension
List comprehension python processes dictionary items through the items() method, enabling simultaneous access to keys and values. This technique supports creating filtered or transformed lists from dictionary data.
# Extract values meeting specific criteria
prices = {'apple': 1.20, 'banana': 0.50, 'cherry': 2.50, 'date': 3.00}
expensive_fruits = [fruit for fruit, price in prices.items() if price > 1.00]
print(expensive_fruits) # Output: ['apple', 'cherry', 'date']
# Create formatted strings from dictionary data
scores = {'Alice': 95, 'Bob': 87, 'Charlie': 92}
reports = [f"{name}: {score}%" for name, score in scores.items()]
print(reports) # Output: ['Alice: 95%', 'Bob: 87%', 'Charlie: 92%']
The items() method returns tuples of key-value pairs, which the comprehension unpacks into separate variables. This unpacking pattern extends to any iterable returning tuple-like structures.
Performance characteristics of list comprehension
List comprehension python executes faster than equivalent for loops because Python optimizes the comprehension syntax at the bytecode level. The interpreter recognizes the pattern and applies specific optimizations unavailable to general loop constructs.
import timeit
# For loop approach
def with_for_loop():
result = []
for i in range(1000):
result.append(i ** 2)
return result
# List comprehension approach
def with_comprehension():
return [i ** 2 for i in range(1000)]
# Timing comparison
loop_time = timeit.timeit(with_for_loop, number=10000)
comp_time = timeit.timeit(with_comprehension, number=10000)
print(f"For loop: {loop_time:.4f} seconds")
print(f"Comprehension: {comp_time:.4f} seconds")
The performance advantage stems from reduced function call overhead and optimized memory allocation patterns. List comprehensions pre-allocate memory for the entire result when possible, avoiding incremental reallocation as lists grow.
When to avoid list comprehension
Complex nested comprehensions or deeply nested conditions reduce code readability despite syntactic brevity. Traditional for loops provide clearer logic flow when comprehensions exceed comfortable single-line length.
# Avoid: Complex nested comprehension
result = [[item.upper() if len(item) > 3 else item.lower()
for item in sublist if item.isalpha()]
for sublist in nested_list if len(sublist) > 2]
# Prefer: Explicit for loops for complex logic
result = []
for sublist in nested_list:
if len(sublist) > 2:
filtered = []
for item in sublist:
if item.isalpha():
filtered.append(item.upper() if len(item) > 3 else item.lower())
result.append(filtered)
Side effects within comprehensions create unexpected behavior because comprehensions evaluate eagerly and cannot guarantee evaluation order for complex expressions. Functions with side effects belong in explicit loop structures where execution sequence remains clear.
Creating sets and dictionaries with comprehension
Python extends the comprehension syntax beyond lists to sets and dictionaries. Set comprehension eliminates duplicates automatically while dictionary comprehension creates key-value mappings.
# Set comprehension removes duplicates
numbers = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
unique_squares = {num ** 2 for num in numbers}
print(unique_squares) # Output: {16, 1, 4, 9}
# Dictionary comprehension creates mappings
words = ['apple', 'banana', 'cherry']
word_lengths = {word: len(word) for word in words}
print(word_lengths) # Output: {'apple': 5, 'banana': 6, 'cherry': 6}
# Invert a dictionary
original = {'a': 1, 'b': 2, 'c': 3}
inverted = {value: key for key, value in original.items()}
print(inverted) # Output: {1: 'a', 2: 'b', 3: 'c'}
Set comprehension uses curly braces without colons, while dictionary comprehension requires key-value pairs separated by colons. Both follow the same filtering and transformation patterns as list comprehension.
Practical applications of list comprehension
List comprehension python solves common data processing tasks with minimal code. These patterns appear frequently in data analysis, file processing, and transformation pipelines.
# Parse CSV-style data
csv_lines = ['name,age,city', 'Alice,30,NYC', 'Bob,25,LA', 'Charlie,35,Chicago']
data = [line.split(',') for line in csv_lines[1:]]
print(data)
# Output: [['Alice', '30', 'NYC'], ['Bob', '25', 'LA'], ['Charlie', '35', 'Chicago']]
# Extract file extensions
filenames = ['document.pdf', 'image.jpg', 'script.py', 'data.csv']
extensions = [name.split('.')[-1] for name in filenames]
print(extensions) # Output: ['pdf', 'jpg', 'py', 'csv']
# Normalize data to a specific range
values = [10, 20, 30, 40, 50]
min_val, max_val = min(values), max(values)
normalized = [(x - min_val) / (max_val - min_val) for x in values]
print(normalized) # Output: [0.0, 0.25, 0.5, 0.75, 1.0]
# Filter and clean user input
inputs = [' hello ', '', ' world ', ' ', 'python']
cleaned = [text.strip() for text in inputs if text.strip()]
print(cleaned) # Output: ['hello', 'world', 'python']
These patterns demonstrate how list comprehension python combines filtering, transformation, and extraction operations into single, expressive statements that communicate intent clearly while maintaining compact syntax.
