{"id":6117,"date":"2026-01-24T12:08:14","date_gmt":"2026-01-24T12:08:14","guid":{"rendered":"https:\/\/www.askpython.com\/?p=6117"},"modified":"2026-01-25T14:55:34","modified_gmt":"2026-01-25T14:55:34","slug":"python-list-comprehension","status":"publish","type":"post","link":"https:\/\/www.askpython.com\/python\/list\/python-list-comprehension","title":{"rendered":"List Comprehension Python: Write Concise Code"},"content":{"rendered":"
\n# Basic list comprehension syntax\nnew_list = [expression for item in iterable]\n\n# Example: Square each number in a list\nnumbers = [1, 2, 3, 4, 5]\nsquares = [num ** 2 for num in numbers]\nprint(squares)  # Output: [1, 4, 9, 16, 25]\n\n<\/pre><\/div>\n\n\n
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.<\/p>\n\n\n\n
Understanding the basic structure of list comprehension<\/h2>\n\n\n\n
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.<\/p>\n\n\n
\n# Breaking down the components\nfruits = ['apple', 'banana', 'cherry']\nuppercase_fruits = [fruit.upper() for fruit in fruits]\n# Expression: fruit.upper()\n# Variable: fruit\n# Iterable: fruits\n# Result: ['APPLE', 'BANANA', 'CHERRY']\n\n<\/pre><\/div>\n\n\n
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.<\/p>\n\n\n\n
Creating lists with conditional filtering<\/h2>\n\n\n\n
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.<\/p>\n\n\n
\n# Filter even numbers from a range\nnumbers = range(20)\neven_numbers = [num for num in numbers if num % 2 == 0]\nprint(even_numbers)  # Output: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]\n\n# Extract words longer than 4 characters\nwords = ['cat', 'elephant', 'dog', 'hippopotamus', 'ant']\nlong_words = [word for word in words if len(word) > 4]\nprint(long_words)  # Output: ['elephant', 'hippopotamus']\n\n<\/pre><\/div>\n\n\n
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.<\/p>\n\n\n\n
Applying transformation and filtering simultaneously<\/h2>\n\n\n\n
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.<\/p>\n\n\n
\n# Convert strings to integers, filtering out non-numeric values\nmixed_data = ['42', 'apple', '17', 'banana', '99', 'cherry']\nnumbers = [int(item) for item in mixed_data if item.isdigit()]\nprint(numbers)  # Output: [42, 17, 99]\n\n# Square even numbers only\nvalues = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\neven_squares = [num ** 2 for num in values if num % 2 == 0]\nprint(even_squares)  # Output: [4, 16, 36, 64, 100]\n\n<\/pre><\/div>\n\n\n
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.<\/p>\n\n\n\n
Using if-else expressions in list comprehension<\/h2>\n\n\n\n
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.<\/p>\n\n\n
\n# Classify numbers as even or odd\nnumbers = [1, 2, 3, 4, 5, 6]\nclassifications = ['even' if num % 2 == 0 else 'odd' for num in numbers]\nprint(classifications)  # Output: ['odd', 'even', 'odd', 'even', 'odd', 'even']\n\n# Replace negative numbers with zero\nvalues = [5, -3, 8, -1, 12, -7]\nnon_negative = [num if num >= 0 else 0 for num in values]\nprint(non_negative)  # Output: [5, 0, 8, 0, 12, 0]\n\n<\/pre><\/div>\n\n\n
The ternary expression follows the pattern value_if_true if condition else value_if_false<\/code>, appearing before the for clause. This placement distinguishes it from the filter-style if statement that appears after the iteration specification.<\/p>\n\n\n\n
Working with nested list comprehensions<\/h2>\n\n\n\n
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.<\/p>\n\n\n
\n# Create a multiplication table\nmultiplication_table = [[i * j for j in range(1, 6)] for i in range(1, 6)]\nprint(multiplication_table)\n# 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]]\n\n# Generate coordinate pairs for a grid\ncoordinates = [(x, y) for x in range(3) for y in range(3)]\nprint(coordinates)\n# Output: [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]\n\n<\/pre><\/div>\n\n\n
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.<\/p>\n\n\n\n
Flattening nested lists with list comprehension<\/h2>\n\n\n\n
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.<\/p>\n\n\n
\n# Flatten a matrix into a single list\nmatrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\nflattened = [num for row in matrix for num in row]\nprint(flattened)  # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n\n# Extract all elements from nested lists of varying lengths\nirregular_nested = [[10, 20], [30], [40, 50, 60], [70, 80]]\nall_values = [item for sublist in irregular_nested for item in sublist]\nprint(all_values)  # Output: [10, 20, 30, 40, 50, 60, 70, 80]\n\n<\/pre><\/div>\n\n\n
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.<\/p>\n\n\n\n
Combining multiple conditions in list comprehension<\/h2>\n\n\n\n
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.<\/p>\n\n\n
\n# Find numbers divisible by both 3 and 5\nnumbers = range(100)\ndivisible_by_both = [num for num in numbers if num % 3 == 0 if num % 5 == 0]\nprint(divisible_by_both)  # Output: [0, 15, 30, 45, 60, 75, 90]\n\n# Filter strings by multiple criteria\nwords = ['Python', 'code', 'programming', 'data', 'analysis']\nfiltered = [word for word in words if len(word) > 4 if word[0] in 'Pp']\nprint(filtered)  # Output: ['Python', 'programming']\n\n<\/pre><\/div>\n\n\n
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.<\/p>\n\n\n\n
Using enumerate with list comprehension<\/h2>\n\n\n\n
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.<\/p>\n\n\n
\n# Create tuples of indices and values\nfruits = ['apple', 'banana', 'cherry', 'date']\nindexed_fruits = [(index, fruit) for index, fruit in enumerate(fruits)]\nprint(indexed_fruits)\n# Output: [(0, 'apple'), (1, 'banana'), (2, 'cherry'), (3, 'date')]\n\n# Filter items based on their position\nnumbers = [10, 20, 30, 40, 50]\neven_positioned = [num for index, num in enumerate(numbers) if index % 2 == 0]\nprint(even_positioned)  # Output: [10, 30, 50]\n\n<\/pre><\/div>\n\n\n
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.<\/p>\n\n\n\n
Processing strings with list comprehension<\/h2>\n\n\n\n
String iteration through list comprehension python treats each character as an individual element. This approach simplifies character-level transformations and filtering operations.<\/p>\n\n\n
\n# Extract vowels from a string\ntext = 'comprehension'\nvowels = [char for char in text if char in 'aeiou']\nprint(vowels)  # Output: ['o', 'e', 'e', 'i', 'o']\n\n# Convert characters to ASCII values\nword = 'Python'\nascii_values = [ord(char) for char in word]\nprint(ascii_values)  # Output: [80, 121, 116, 104, 111, 110]\n\n# Remove whitespace and convert to uppercase\nsentence = '  hello world  '\ncleaned = [char.upper() for char in sentence if not char.isspace()]\nprint(''.join(cleaned))  # Output: HELLOWORLD\n\n<\/pre><\/div>\n\n\n
String processing combines transformation functions like upper(), lower(), and ord() with filtering conditions that check character properties through methods like isspace(), isdigit(), and isalpha().<\/p>\n\n\n\n
Replacing map and filter functions<\/h2>\n\n\n\n
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.<\/p>\n\n\n
\n# Traditional map approach\nnumbers = [1, 2, 3, 4, 5]\nsquared_map = list(map(lambda x: x ** 2, numbers))\n\n# List comprehension equivalent\nsquared_comp = [num ** 2 for num in numbers]\n\n# Traditional filter approach\neven_filter = list(filter(lambda x: x % 2 == 0, numbers))\n\n# List comprehension equivalent\neven_comp = [num for num in numbers if num % 2 == 0]\n\n# Combining map and filter\ntransformed = list(map(lambda x: x ** 2, filter(lambda x: x % 2 == 0, numbers)))\n\n# Single list comprehension\ncombined = [num ** 2 for num in numbers if num % 2 == 0]\n\n<\/pre><\/div>\n\n\n
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.<\/p>\n\n\n\n
Working with dictionary items in list comprehension<\/h2>\n\n\n\n
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.<\/p>\n\n\n
\n# Extract values meeting specific criteria\nprices = {'apple': 1.20, 'banana': 0.50, 'cherry': 2.50, 'date': 3.00}\nexpensive_fruits = [fruit for fruit, price in prices.items() if price > 1.00]\nprint(expensive_fruits)  # Output: ['apple', 'cherry', 'date']\n\n# Create formatted strings from dictionary data\nscores = {'Alice': 95, 'Bob': 87, 'Charlie': 92}\nreports = [f"{name}: {score}%" for name, score in scores.items()]\nprint(reports)  # Output: ['Alice: 95%', 'Bob: 87%', 'Charlie: 92%']\n\n<\/pre><\/div>\n\n\n
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.<\/p>\n\n\n\n
Performance characteristics of list comprehension<\/h2>\n\n\n\n
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.<\/p>\n\n\n
\nimport timeit\n\n# For loop approach\ndef with_for_loop():\n    result = []\n    for i in range(1000):\n        result.append(i ** 2)\n    return result\n\n# List comprehension approach\ndef with_comprehension():\n    return [i ** 2 for i in range(1000)]\n\n# Timing comparison\nloop_time = timeit.timeit(with_for_loop, number=10000)\ncomp_time = timeit.timeit(with_comprehension, number=10000)\n\nprint(f"For loop: {loop_time:.4f} seconds")\nprint(f"Comprehension: {comp_time:.4f} seconds")\n\n<\/pre><\/div>\n\n\n
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.<\/p>\n\n\n\n
When to avoid list comprehension<\/h2>\n\n\n\n
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.<\/p>\n\n\n
\n# Avoid: Complex nested comprehension\nresult = [[item.upper() if len(item) > 3 else item.lower() \n           for item in sublist if item.isalpha()] \n          for sublist in nested_list if len(sublist) > 2]\n\n# Prefer: Explicit for loops for complex logic\nresult = []\nfor sublist in nested_list:\n    if len(sublist) > 2:\n        filtered = []\n        for item in sublist:\n            if item.isalpha():\n                filtered.append(item.upper() if len(item) > 3 else item.lower())\n        result.append(filtered)\n\n<\/pre><\/div>\n\n\n
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.<\/p>\n\n\n\n
Creating sets and dictionaries with comprehension<\/h2>\n\n\n\n
Python extends the comprehension syntax beyond lists to sets and dictionaries. Set comprehension eliminates duplicates automatically while dictionary comprehension creates key-value mappings.<\/p>\n\n\n
\n# Set comprehension removes duplicates\nnumbers = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]\nunique_squares = {num ** 2 for num in numbers}\nprint(unique_squares)  # Output: {16, 1, 4, 9}\n\n# Dictionary comprehension creates mappings\nwords = ['apple', 'banana', 'cherry']\nword_lengths = {word: len(word) for word in words}\nprint(word_lengths)  # Output: {'apple': 5, 'banana': 6, 'cherry': 6}\n\n# Invert a dictionary\noriginal = {'a': 1, 'b': 2, 'c': 3}\ninverted = {value: key for key, value in original.items()}\nprint(inverted)  # Output: {1: 'a', 2: 'b', 3: 'c'}\n\n<\/pre><\/div>\n\n\n
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.<\/p>\n\n\n\n
Practical applications of list comprehension<\/h2>\n\n\n\n
List comprehension python solves common data processing tasks with minimal code. These patterns appear frequently in data analysis, file processing, and transformation pipelines.<\/p>\n\n\n
\n# Parse CSV-style data\ncsv_lines = ['name,age,city', 'Alice,30,NYC', 'Bob,25,LA', 'Charlie,35,Chicago']\ndata = [line.split(',') for line in csv_lines[1:]]\nprint(data)\n# Output: [['Alice', '30', 'NYC'], ['Bob', '25', 'LA'], ['Charlie', '35', 'Chicago']]\n\n# Extract file extensions\nfilenames = ['document.pdf', 'image.jpg', 'script.py', 'data.csv']\nextensions = [name.split('.')[-1] for name in filenames]\nprint(extensions)  # Output: ['pdf', 'jpg', 'py', 'csv']\n\n# Normalize data to a specific range\nvalues = [10, 20, 30, 40, 50]\nmin_val, max_val = min(values), max(values)\nnormalized = [(x - min_val) \/ (max_val - min_val) for x in values]\nprint(normalized)  # Output: [0.0, 0.25, 0.5, 0.75, 1.0]\n\n# Filter and clean user input\ninputs = ['  hello  ', '', '  world  ', '   ', 'python']\ncleaned = [text.strip() for text in inputs if text.strip()]\nprint(cleaned)  # Output: ['hello', 'world', 'python']\n\n<\/pre><\/div>\n\n\n
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.<\/p>\n\n\n\n
<\/p>\n","protected":false},"excerpt":{"rendered":"
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 […]<\/p>\n","protected":false},"author":6,"featured_media":65726,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-6117","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-list"],"blocksy_meta":[],"_links":{"self":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/posts\/6117","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/comments?post=6117"}],"version-history":[{"count":0,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/posts\/6117\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/media\/65726"}],"wp:attachment":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/media?parent=6117"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/categories?post=6117"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/tags?post=6117"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}