Python Interview Questions

List comprehensions are a concise and expressive way to create lists in Python. They provide a syntactic sugar for generating lists by embedding a for-loop and an optional condition inside a pair of square brackets. List comprehensions can significantly reduce the amount of code you need to write compared to traditional for-loops.

Basic Syntax

The basic syntax of a list comprehension is:

[expression for item in iterable]

• expression: An expression that produces the items of the new list.
• item: A variable that takes the value of each element from the iterable.
• iterable: An iterable (like a list, tuple, string, etc.) from which items are taken.

Examples

Example 1: Creating a List of Squares

Using a traditional for-loop:

squares = []
for x in range(10):
    squares.append(x**2)

Using a list comprehension:

squares = [x**2 for x in range(10)]

Both methods produce the same result:

print(squares)  # Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Example 2: Filtering with a Condition

You can add an if condition to a list comprehension to filter elements.

Using a traditional for-loop:

even_squares = []
for x in range(10):
    if x % 2 == 0:
        even_squares.append(x**2)

Using a list comprehension:

even_squares = [x**2 for x in range(10) if x % 2 == 0]

Both methods produce the same result:

print(even_squares)  # Output: [0, 4, 16, 36, 64]

Nested List Comprehensions

You can also use nested list comprehensions to work with nested loops.

Example 3: Flattening a List of Lists

Using a traditional nested for-loop:

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = []
for row in matrix:
    for item in row:
        flattened.append(item)

Using a nested list comprehension:

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [item for row in matrix for item in row]

Both methods produce the same result:

print(flattened)  # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

List Comprehensions with Functions

List comprehensions can also include function calls.

Example 4: Applying a Function to Each Element

Using a traditional for-loop:

def square(x):
    return x**2

squares = []
for x in range(10):
    squares.append(square(x))

Using a list comprehension:

def square(x):
    return x**2

squares = [square(x) for x in range(10)]

Both methods produce the same result:

print(squares)  # Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Advanced Example: Conditional Logic in Expression

You can include conditional logic within the expression part of a list comprehension.

Example 5: Including an Else Clause

Using a traditional for-loop:

numbers = range(10)
result = []
for x in numbers:
    if x % 2 == 0:
        result.append(x**2)
    else:
        result.append(x**3)

Using a list comprehension with an else clause:

numbers = range(10)
result = [x**2 if x % 2 == 0 else x**3 for x in numbers]

Both methods produce the same result:

print(result)  # Output: [0, 1, 4, 27, 16, 125, 36, 343, 64, 729]

Summary

• List Comprehensions: A concise way to create lists using an expression and an optional condition within square brackets.
• Syntax: [expression for item in iterable if condition]
• Benefits: More readable, compact, and often faster than traditional for-loops for creating lists.
• Use Cases: Creating lists, filtering elements, applying functions, nested loops, and more.

List comprehensions are a powerful feature in Python that can make your code cleaner and more efficient when used appropriately.