List comprehension in Python is a concise and readable way to create new lists by applying an expression to each item in an existing iterable (like a list, tuple, or range), optionally filtering elements with a condition. It replaces verbose for loops and .append() calls with a single line of code.

Basic Syntax

[expression for item in iterable]

• expression: The operation applied to each item (e.g., x ** 2, word.upper()).

• item: A variable representing each element in the iterable.

• iterable: The source data (e.g., range(10), ['a', 'b', 'c']).

With Filtering (if condition)

[expression for item in iterable if condition]

• Only items satisfying the condition are included.

Examples

• Square numbers from 0 to 9:

  squares = [x ** 2 for x in range(10)]
  # Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

• Filter even numbers:

  evens = [x for x in range(10) if x % 2 == 0]
  # Output: [0, 2, 4, 6, 8]

• Capitalize words with more than 3 letters:

  words = ["fox", "giraffe", "rat", "zebra", "owl"]
  long_words = [word.upper() for word in words if len(word) > 3]
  # Output: ['GIRAFFE', 'ZEBRA']

Advanced Features

• Nested loops (e.g., flattening a 2D list):

  matrix = [[1, 2], [3, 4]]
  flat = [num for row in matrix for num in row]
  # Output: [1, 2, 3, 4]

• Conditional expressions (if/else):

  result = ["even" if x % 2 == 0 else "odd" for x in range(5)]
  # Output: ['even', 'odd', 'even', 'odd', 'even']

• Using enumerate():

  fruits = ['apple', 'banana']
  indexed = [f"{i}: {f}" for i, f in enumerate(fruits)]
  # Output: ['0: apple', '1: banana']

Performance & Best Practices

• Faster than equivalent for loops due to internal optimizations in Python.

• More readable and concise than traditional loops.

• Avoid overly complex comprehensions — if it exceeds 80–100 characters or contains multiple nested conditions, use a regular loop for clarity.

• For large datasets, use generator expressions ( ) instead of list comprehensions [ ] to save memory.

When to Use

• Creating transformed or filtered lists.

• Replacing simple for loops with .append().

• Writing "Pythonic" code that is both efficient and readable.

Alternatives

• map() and filter(): Functional approach, less readable for beginners.

• Generator expressions: Use () for memory efficiency with large datasets.

• Regular loops: Best for complex logic or debugging.

List comprehensions are a core Python feature that enhances code clarity and performance for common list creation tasks.