Python List Comprehensions

The Python List Comprehensions provides an easy and straightforward way to create a list based on another or some iterables. The fewer lines of code easy to read syntax of this Python List Comprehension syntax helps us to write more complex functionalities elegantly, and it is

[output_expression for item in L1]

[output_expression for item in L2 if condition]

[output_expression If Else conditions for item in L3]

From the above syntax, you can see that the comprehension consists of a for loop to read all the elements in an existing list. It is one of the powerful functions that can make the code more readable.

Python List Comprehensions Examples

The following examples help us to learn this.

Simple List Comprehension Example

Before we start using this, let us see the traditional approach to achieve the same result.

In general, we use the for loop syntax structure along with the append function to iterate elements and add them. However, you can use Python List comprehensions to get the same output. It is easy to read and takes less time to execute.

The following code uses for loop iterable objects and list comprehension to iterate items and append each item to a new one. In short, we are copying items to an entirely new one.

Here, we are using a common approach and the expression approach. We used the same for loop but removed the append function. I suggest you refer to the List, for loop, and functions from the Python page. As you can notice, the code has been written in a single line, and it returns a new list.

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
new = []
 
for num in numbers:
    new.append(num)
 
print(new)
 
print("===================")

my = [num for num in numbers]
print(my)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
===================
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

You can see this list comprehension example also. Here, we are multiplying each item by 2. If you look closely, we used the same for loop in both examples, but the only difference is the append function.

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
mul = []
 
for num in numbers:
    mul.append(num * 2)
 
print(mul)
 
print("===================")
 
my = [num * 2 for num in numbers]
print(my)
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
===================
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

We are using the Python List comprehensions to multiply elements by 2 and 3 and find each item’s square.

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
doubleA = [i * 2 for i in a]
print(doubleA)
 
tripleA = [i * 3 for i in a]
print(tripleA)
 
squareA = [i ** 2 for i in a]
print(squareA)
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
[3, 6, 9, 12, 15, 18, 21, 24, 27, 30]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

It is the same as the above example. However, this time, we are comparing the regular approach also.

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
new1 = []
new2 = []
new3 = []

for num in numbers:
    new1.append(num * 2)
    new2.append(num * 3)
    new3.append(num ** 2)
 
print(new1)
print(new2)
print(new3)
 
print("===================")
doubleN = [num * 2 for num in numbers]
print(doubleN)
 
tripleN = [num * 3 for num in numbers]
print(tripleN)
 
squareN = [num ** 2 for num in numbers]
print(squareN)
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
[3, 6, 9, 12, 15, 18, 21, 24, 27, 30]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
===================
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
[3, 6, 9, 12, 15, 18, 21, 24, 27, 30]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

In this example, the first statement multiplies each item with itself and so on. Here, the square brackets decide the priority of calculation. For example, 2 * 2 + 1 means 4 + 1, whereas 2 * (2 + 1) means 2 * 3 .

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
doubleLi = [n * n for n in numbers]
print(doubleLi)
 
tripleLi = [n * n + 1 for n in numbers]
print(tripleLi)
 
squareLi = [n * (n + 2) for n in numbers]
print(squareLi)
 
s_li = [n * (n + 4) for n in numbers]
print(s_li)
Python List Comprehensions 6

Python List Comprehension If

In all our previous examples, we used for loop to iterate each element and perform calculations. What if we want to check some conditions using this one?

Here, we use the if statement to check and display the even numbers from numbers. First, we placed for loop within the []. Next, we placed the if statement. At last, we placed the appended item before for loop.

n1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
a = []
 
for y in n1:
    if y % 2 == 0:
        a.append(y)
 
print(a)
 
print()
 
b = [y for y in n1 if y % 2 == 0]
print(b)
[2, 4, 6, 8, 10]

[2, 4, 6, 8, 10]

Python List Comprehension Multiple Conditions

This programming language also allows you to use multiple conditions. In this example, we are using multiple if statements to check the item or value divided by 2 equals 0. If True, it checks the item is also divisible by 5. If both are true, then that number is added to a.

a = []
 
for n in range(1, 150):
    if n % 2 == 0 and n % 5 == 0:
        a.append(n)
 
print(a)
 
print()
 
b = [n for n in range(1, 150) if n % 2 == 0 if n % 5 == 0]
print(b)
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140]

[10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140]

List Comprehension If Else

In this example, we are using the If else. The If else code checks and displays whether the value is even or odd.

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(a)
 
b = ["Even" if i % 2 == 0 else "Odd" for i in a]
 
print(b)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
['Odd', 'Even', 'Odd', 'Even', 'Odd', 'Even', 'Odd', 'Even', 'Odd', 'Even']

Nested For Loop

Here, we are printing the multiplication table using the nested for loops. The same can be done by nesting.

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
a = [[i * j for j in range(1, 11)] for i in range(2, 4)]
 
print(a)
 
# Same using For loop
print()
for i in range(2, 4):
    for j in range(1, 11):
        print(f"{i} * {j} = {i * j}")
[[2, 4, 6, 8, 10, 12, 14, 16, 18, 20], [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]]

2 * 1 = 2
2 * 2 = 4
2 * 3 = 6
2 * 4 = 8
2 * 5 = 10
2 * 6 = 12
2 * 7 = 14
2 * 8 = 16
2 * 9 = 18
2 * 10 = 20
3 * 1 = 3
3 * 2 = 6
3 * 3 = 9
3 * 4 = 12
3 * 5 = 15
3 * 6 = 18
3 * 7 = 21
3 * 8 = 24
3 * 9 = 27
3 * 10 = 30

To Transpose the 3 * 3 matrix, we need Nested List comprehension in Python.

a = [[10, 20, 30], [40, 50, 60], [70, 80, 90]]
print(a)
 
b = [[row[i] for row in a] for i in range(3)]
print(b)
[[10, 20, 30], [40, 50, 60], [70, 80, 90]]
[[10, 40, 70], [20, 50, 80], [30, 60, 90]]

The Nested one to convert the nested to a normal.

c = [[10, 20, 30], [40, 50, 60], [70, 80, 90]]
print(c)
            
d = [item for row in c for item in row]
print(d)
[[10, 20, 30], [40, 50, 60], [70, 80, 90]]
[10, 20, 30, 40, 50, 60, 70, 80, 90]

In this example, first, we used adding each item in the first one, i.e., a with each element in the second. I mean, [10 + 40, 20 + 40, 30 + 40], [10 + 50, 20 + 50, 30 + 50] so on. Within the second statement, we are using this one to create a list of tuples by combining two existing ones.

a = [10, 20, 30]
b = [40, 50, 60]
            
c = [[i + j for i in a] for j in b]
print(c)
 
print()
d = [[(i, j) for i in a] for j in b]
print(d)
[[50, 60, 70], [60, 70, 80], [70, 80, 90]]

[[(10, 40), (20, 40), (30, 40)], [(10, 50), (20, 50), (30, 50)], [(10, 60), (20, 60), (30, 60)]]

String Example

So far, we are using integer items to perform mathematical calculations. However, you can use this Python List comprehensions on the string.

This example shows how to use the Built-in functions within this. The first one applies lower on each item to convert them to lowercase. The second one applies the upper to convert the items to uppercase.

For a better understanding of this, we used a few more functions. The first one used the swapcase to swap the letter cases. The second line used the len function to find and return each item’s length in a string. Within the last one, we capture each item’s first letter.

fruits = ['ApplE', 'OraNGe', 'GrAPe', 'BaNAna']
print(fruits)
 
low = [a.lower() for a in fruits]
print(low)
 
upp = [a.upper() for a in fruits]
print(upp)

swap = [a.swapcase() for a in fruits]
print(swap)
 
ln = [len(a) for a in fruits]
print(ln)
 
first = [item[0] for item in fruits]
print(first)
['ApplE', 'OraNGe', 'GrAPe', 'BaNAna']
['apple', 'orange', 'grape', 'banana']
['APPLE', 'ORANGE', 'GRAPE', 'BANANA']
['aPPLe', 'oRAngEs', 'gRapE', 'bAnaNA']
[5, 7, 5, 6]
['A', 'O', 'G', 'B']

In this Nested List comprehensions example, we are mixing the numbers and string items. It returns the combination of each fruit with a number. I mean, Apple with 1, 2, 3, 4, 5, Orange with 1, 2, 3, 4, 5 so on.

fruits = ['Apple', 'Orange', 'Grape', 'Banana', 'Kiwi']
numbers = [1, 2, 3, 4, 5]
 
f = [[(fruit, num) for fruit in fruits] for num in numbers]
 
print(f)
 
# Same using For loop
print()
g = []
 
for fruit in fruits:
    for num in numbers:
        g.append((fruit, num))
 
print(g)
[[('Apple', 1), ('Orange', 1), ('Grape', 1), ('Banana', 1), ('Kiwi', 1)], [('Apple', 2), ('Orange', 2), ('Grape', 2), ('Banana', 2), ('Kiwi', 2)], [('Apple', 3), ('Orange', 3), ('Grape', 3), ('Banana', 3), ('Kiwi', 3)], [('Apple', 4), ('Orange', 4), ('Grape', 4), ('Banana', 4), ('Kiwi', 4)], [('Apple', 5), ('Orange', 5), ('Grape', 5), ('Banana', 5), ('Kiwi', 5)]]

[('Apple', 1), ('Apple', 2), ('Apple', 3), ('Apple', 4), ('Apple', 5), ('Orange', 1), ('Orange', 2), ('Orange', 3), ('Orange', 4), ('Orange', 5), ('Grape', 1), ('Grape', 2), ('Grape', 3), ('Grape', 4), ('Grape', 5), ('Banana', 1), ('Banana', 2), ('Banana', 3), ('Banana', 4), ('Banana', 5), ('Kiwi', 1), ('Kiwi', 2), ('Kiwi', 3), ('Kiwi', 4), ('Kiwi', 5)]

String Data

You can also use this Python list comprehension on string data. Here, we are extracting each character from a string and creating a new string. In this example, we declared the string value as Tutorial Gateway.

string = 'Tutorial Gateway' 
print(string)
 
my = [word for word in string]
print(my)
 
# Same using For loop
print()
new1 = []
 
for word in string:
    new1.append(word)
 
print(new1)
Tutorial Gateway
['T', 'u', 't', 'o', 'r', 'i', 'a', 'l', ' ', 'G', 'a', 't', 'e', 'w', 'a', 'y']

['T', 'u', 't', 'o', 'r', 'i', 'a', 'l', ' ', 'G', 'a', 't', 'e', 'w', 'a', 'y']

Python List Comprehensions Vs Lambda Function

If fewer code lines are our priority, then we are not limited to this. You can use the lambda function. Here, we are using the traditional approach and lambda function to multiply each item by itself.

By seeing the code, you can see that the lambda function is also very useful. However, the code is easy to read and execute faster.

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a = []

for num in numbers:
    a.append(num * num)

print(a)

print()

b = [num * num for num in numbers]
print(b)

print()

c = list(map(lambda num: num * num, numbers))
print(c)

List comprehensions vs lambda function final output

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

It is another example of differentiating the code readability between this and lambda functions.

numbers = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

doubleN = [num * 2 for num in numbers]
print(doubleN)

tripleN = [num * 3 for num in numbers]
print(tripleN)

squareN = [num ** 2 for num in numbers]
print(squareN)

#Lambda Function Example
print("===================")

dN = list(map(lambda num: num * 2, numbers))
print(dN)

tN = list(map(lambda num: num * 3, numbers))
print(tN)

sN = list(map(lambda num: num ** 2, numbers))
print(sN)
[20, 40, 60, 80, 100, 120, 140, 160, 180, 200]
[30, 60, 90, 120, 150, 180, 210, 240, 270, 300]
[100, 400, 900, 1600, 2500, 3600, 4900, 6400, 8100, 10000]
===================
[20, 40, 60, 80, 100, 120, 140, 160, 180, 200]
[30, 60, 90, 120, 150, 180, 210, 240, 270, 300]
[100, 400, 900, 1600, 2500, 3600, 4900, 6400, 8100, 10000]