List Comprehension in Python

The scope of this article is to understand the concept of list comprehension in all possible scenarios. However, there are two ways to implement list comprehension in Python, i.e., List comprehension (one-liner approach) and non-list comprehension. Meanwhile, Iterating through data structures, performing calculations, and more are all possible with the Python for loop. Python makes it possible to write a for loop in just a one-liner list comprehension approach, unlike the traditional one that requires multiple lines of code. Moreover, It’s worth noting that list comprehension outperforms traditional loops in terms of speed and efficiency.  However, List comprehension in Python enables you to deal with different scenarios effortlessly and concisely. 

Getting started with the syntax structure of List Comprehension

A list comprehension creates a new list by applying the expression to each item in the iterable. However, list comprehension makes performing tasks within a one-liner command line easier. The syntax of List Comprehension is:

An expression is surrounded by brackets, followed by a for clause, zero or more for clauses, if clauses, or if-else clauses.

Here is the Pythonic way to represent the List Comprehension.

new_list = [expression for item in original_list]

Step to follow for constructing a List comprehension

  1. New_list ⇒ Construct a list enclosed within square brackets [ ] to create a list comprehension. You can choose any valid variable name. The output of this variable will be of list data type.
  2. expression ⇒ It represents an operation or expression that will be performed on each item in the original_list. However, this expression determines how each item will be transformed or manipulated to generate the corresponding element in the new_list.
  3. for item in original_list ⇒ This part specifies the iteration over the original list. It defines a temporary variable, an item, that takes on each item in the original list individually. We then apply the expression to each of these items.

Memorizing the Syntax of List comprehension 

Memorizing the list comprehension syntax from the simple sentence is the list contains if clause only.

"The boy doesn’t go for play Hockey if it rains”

Way to memorize the list comprehension syntax for the scenario in which the list contains if-else clauses.

"Customers will receive a free dessert if they order a meal from our new menu, else they will get a 10% discount on their total bill for their order from the regular menu."

However, to handle the if-else conditional clause, be sure the structure comes at the end.

List Comprehensions vs Lambda functions

Here’s an example to illustrate the basic syntax of list comprehension. Let’s say you have a numbers list, and you want to create a new list containing the squares of each number:

numbers = [1, 2, 3, 4, 5]
squared_numbers = [x ** 2 for x in numbers]
[1, 4, 9, 16, 25]

In the example above, x ** 2 is the expression that squares each x (the temporary variable) as it iterates through the numbers list. The resulting squared values are collected and saved in the squared_numbers list through list comprehension.

However, you can achieve similar results using the lambda function.

numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x ** 2, numbers))
[1, 4, 9, 16, 25]

You can define small, inline functions using the lambda keyword without explicitly specifying their names. The lambda function constructs one-time-use functions, reducing the requirement of using def.

The list comprehensions create new lists by combining existing data with expressions enclosed in square brackets [ ]. As opposed to list comprehensions, lambda functions help us create small, anonymous functions for specific tasks. Both are valuable tools in Python, and the choice between them depends on your case scenarios.

The benefit of using List Comprehension over other iterative methods

Here’s a simple example that uses a loop to iterate over a list and then demonstrates how it can be simplified using list comprehension:

# Define a pattern as a string
pattern = "#$"

# Square the pattern by repeating it
# Initialize an empty list for the squared pattern
squared_pattern = []

for char in pattern:
    squared_pattern.extend([char] * len(pattern))

# return a list
['#', '#', '$', '$']

In this example, we have a string of patterns. Using a for loop, we iterate over each character in the pattern, calculate its square using the * operator, and append the squared value to the squared_pattern list.

# consider a pattern as a string
pattern = "#$"

# Use list comprehension to create a list of squared patterns
squared_patterns = [char * len(pattern) for char in pattern]

# Print the squared pattern
['##', '$$']

Unlike the comprehension version, we have condensed the code into a single line. The expression char * len(pattern) squares each char element as iterates over the pattern. The resulting squared values are collected and stored directly in the squared_patterns list, eliminating the need for an explicit loop and append operation.

Hence, by utilizing list comprehension, you can achieve the same result more efficiently and with fewer lines of code. It simplifies transforming elements from a source list into a new one based on a given expression or operation.

Methods to transform data using List Comprehension

In Python, you can use List comprehension to transform the conditional data more concisely and readable. However, there are the following approaches to use list comprehension to convert data swiftly. 

  • Filtering elements  using Conditional clause
  • Handling scenarios of Multiple Iterable
  • Nested List Comprehension
  • Conditional Expressions (Ternary Operator):
  • Enumerating a string
  • Converting string to an integer type 

1) Filtering elements  using Conditional clause

Adding an if clause within the list comprehension allows you to filter elements based on specific conditions. The new list will only include and update the items that satisfy your condition. The syntax for the conditional if clause will be as structured below:

[item for item in iterable if conditional clause] 

In this program, each element of the numbers list is iterated through and multiplied by 2 only if it is even (i.e., its remainder, when divided by 2, is zero). As a result, it prints the table_of_2 list.

numbers = [1, 2, 3, 4, 5]
table_of_2 = [x * 2 for x in numbers if x % 2 == 0]
[4, 8]

2) Handling scenarios of Multiple Iterables

Furthermore, you can use multiple iterable within a single list comprehension by using nested loops. This technique allows you to combine elements from different sources to generate a new list. However, In the following example, a list of combinations of colors and sizes is created using list comprehensions. It produces a list of tuples representing each combination of color and size. The program creates every possible combination of color and size.

colors = ['red', 'green', 'blue']
sizes = ['S', 'M', 'L']
combinations = [(color, size) for color in colors for size in sizes]
[('red', 'S'), ('red', 'M'), ('red', 'L'), ('green', 'S'), ('green', 'M'), ('green', 'L'), ('blue', 'S'), ('blue', 'M'), ('blue', 'L')]

3) Nested List Comprehension

You can also nest list comprehension within another list comprehension. This technique is useful when working with nested data structures, such as lists of lists or matrices. However, If you loop through a nested for loop with nested conditions in a nested list comprehension, you can use an if statement. Below, you can see how a nested for loop with nested conditions executes with a one-liner. 

lists= [['*' * j for j in range(i) if j != 4] if i != 4 else [] for i in range(6)]
[[], [''], ['', '*'], ['', '*', '**'], [], ['', '*', '**', '***']]

4) Conditional Expressions (Ternary Operator)

In list comprehension, you can incorporate conditional expressions, the ternary operator, to conditionally transform or filter elements based on a condition. It creates a new list containing the string of grades of each student from the original list. 

Nesting ternary operators evaluate relationships between variables and display a message. An example depicts the relationship between student grades and corresponding scores by nested ternary operators. Additionally, remember that the structure should come at the end of the list comprehension syntax when handling the if-else conditional clause. Here’s how nested ternary operator explains in a one-liner list Comprehension gracefully: 

scores = [85, 92.3, 78, 95.5, 88, 64.6, 72]
grade_letters = ['A' if s >= 90 else 'B' if s >= 80 else 'C' if s >= 70 else 'D' if s >= 60 else 'F' for s in scores]
['B', 'A', 'C', 'A', 'B', 'D', 'C']

In this list comprehension, each element is evaluated using the ternary conditional expression, which checks students’ grades based on their scores concisely and assigns the corresponding string to the new list.

5) Enumerating a string

In this scenario, the list comprehension iterates over each character in the string. It constructs a tuple containing each character’s index and character using a Python one-liner list comprehension approach. 

A list comprehension uses the enumerate() function to iterate over a list of numbers. It returns a tuple containing the current element’s index and its value with each iteration. These constructed tuples are appended to a new list by the list comprehension. 

However, In the following example, the enumerate() function is used in aggregation with List Comprehension. Meanwhile,  the output is obtained using the enumerate() function, showing that the enumerate() object is converted into a list, which is a list of tuples containing index-char pairs.   

word = "Entechin - elearning platform"

# Using list comprehension with enumerate
enumerated_word_list_comprehension = [(index, char) for index, char in enumerate(word)]

# Printing the list
print(enumerated_word_list_comprehension, type(enumerated_word_list_comprehension))
[(0, 'E'), (1, 'n'), (2, 't'), (3, 'e'), (4, 'c'), (5, 'h'), (6, 'i'), (7, 'n'), (8, ' '), (9, '-'), (10, ' '), (11, 'e'), (12, 'l'), (13, 'e'), (14, 'a'), (15, 'r'), (16, 'n'), (17, 'i'), (18, 'n'), (19, 'g'), (20, ' '), (21, 'p'), (22, 'l'), (23, 'a'), (24, 't'), (25, 'f'), (26, 'o'), (27, 'r'), (28, 'm')] <class 'list'>

The above program correctly enumerates all characters in the provided “word” string, including spaces and special characters, and stores them in a list of tuples.

6) Converting String To An Integer Type Using List Comprehension 

To convert a string list into an integer list in Python, using the one-liner list comprehension approach with the int() function is efficient. However, by applying functions to a list, list comprehension simplifies the process. As a result of this method, you can efficiently perform various operations on a list.

In the following example, the list comprehension can convert the elements into integers using the int() function by iterating over each element of the string list in the above example. Meanwhile, this list of integers, as a result, collects and stores.

# List of strings representing the number of cars parked in different spaces
parking_cars_strings = ["5", "12", "8", "3"]

# Converting the strings to integers using list comprehension
parked_cars = [int(x) for x in parking_cars_strings]

# Printing the original list and the list of integers
print("Original Parking Cars List:", parking_cars_strings, type(parking_cars_strings))
print("Parked Cars List:", parked_cars, type(parked_cars))
Original Parking Cars List: ['5', '12', '8', '3'] <class 'list'>
Parked Cars List: [5, 12, 8, 3] <class 'list'>

The above program handles the scenario of parking cars. A list of strings represents the number of cars parked in different parking spaces, and the program converts them to actual integers using list comprehension.


Comprehending lists provides efficient methods for creating new lists from existing data in Python. However, to leverage the full potential of list comprehension, you should rely on its concise syntax, filtering capabilities, nesting support, and transformation capabilities. However, this tutorial covers the different ways to use list comprehension using if, if-else conditional clauses.

The key to maximizing the benefits of Python is to embrace experimentation and customize these methods to match your specific needs. However, to learn more about Python Programming, visit Python Programming Tutorials or contact us.

Leave a Comment

Your email address will not be published. Required fields are marked *