Python List Comprehensions – Concise & Powerful

# Traditional for loop
squares = []
for n in range(1, 11):
    squares.append(n ** 2)
print(squares)
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# Same result with a list comprehension – one line!
squares = [n ** 2 for n in range(1, 11)]
print(squares)
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# [expression  for  variable  in  iterable]
result = [expression for variable in iterable]

# Common patterns:
words = ["hello", "world", "python"]

# 1. Transform each element
upper = [w.upper() for w in words]
print(upper)   # ['HELLO', 'WORLD', 'PYTHON']

# 2. Apply a function
lengths = [len(w) for w in words]
print(lengths)  # [5, 5, 6]

# 3. From any iterable
chars = [c for c in "Python"]
print(chars)    # ['P', 'y', 't', 'h', 'o', 'n']

# 4. From a range
evens = [x * 2 for x in range(10)]
print(evens)    # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# [expression  for  variable  in  iterable  if  condition]

numbers = range(1, 21)

# Only even numbers
evens = [n for n in numbers if n % 2 == 0]
print(evens)   # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

# Only odd numbers > 10
big_odds = [n for n in numbers if n % 2 != 0 and n > 10]
print(big_odds)  # [11, 13, 15, 17, 19]

# Filter strings by length
words = ["cat", "elephant", "ant", "butterfly", "bee", "hippopotamus"]
long_words = [w for w in words if len(w) > 4]
print(long_words)  # ['elephant', 'butterfly', 'hippopotamus']

# Filter and transform together
scores = [45, 88, 92, 31, 70, 65, 99, 12]
passing_grades = [s for s in scores if s >= 60]
print(passing_grades)   # [88, 92, 70, 65, 99]
print(f"Average of passing: {sum(passing_grades)/len(passing_grades):.1f}")

# [value_if_true  if  condition  else  value_if_false  for  var  in  iterable]

numbers = range(-5, 6)

# Replace negatives with 0, keep positives
non_negative = [n if n >= 0 else 0 for n in numbers]
print(non_negative)  # [0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5]

# Label even/odd
labels = ["even" if n % 2 == 0 else "odd" for n in range(1, 8)]
print(labels)  # ['odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']

# Clamp values to a [0, 100] range
raw = [120, -10, 85, 101, 50, -5, 99]
clamped = [max(0, min(100, v)) for v in raw]
print(clamped)  # [100, 0, 85, 100, 50, 0, 99]

# Flatten a 2D list (list of lists)
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [num for row in matrix for num in row]
print(flat)   # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Equivalent loop:
# flat = []
# for row in matrix:
#     for num in row:
#         flat.append(num)

# Generate a multiplication table as a 2D list
table = [[i * j for j in range(1, 6)] for i in range(1, 6)]
for row in table:
    print(row)

# Cartesian product of two lists
colors = ["red", "blue"]
sizes  = ["S", "M", "L"]
products = [(color, size) for color in colors for size in sizes]
print(products)
# [('red', 'S'), ('red', 'M'), ('red', 'L'),
#  ('blue', 'S'), ('blue', 'M'), ('blue', 'L')]

import sys

# List comprehension – builds entire list in RAM
squares_list = [n ** 2 for n in range(1_000_000)]
print(f"List size: {sys.getsizeof(squares_list):,} bytes")

# Generator expression – produces one value at a time
squares_gen = (n ** 2 for n in range(1_000_000))
print(f"Generator size: {sys.getsizeof(squares_gen):,} bytes")

# Use a generator when you only need to iterate once
total = sum(n ** 2 for n in range(1_000_000))   # no [] needed inside sum()!
print(f"Sum of squares: {total:,}")

# Generator with condition
large_squares = (n ** 2 for n in range(100) if n % 7 == 0)
for val in large_squares:
    print(val, end=" ")
print()

# Generators are exhausted after one pass
gen = (x * 2 for x in range(5))
print(list(gen))  # [0, 2, 4, 6, 8]
print(list(gen))  # []  ← generator is now empty!

# Set comprehension – automatically removes duplicates
words = ["apple", "banana", "apple", "cherry", "banana", "date"]
unique_lengths = {len(w) for w in words}
print(unique_lengths)   # {4, 5, 6} (order may vary)

# Dict comprehension
# Build a word → length mapping
word_length = {w: len(w) for w in words}
print(word_length)
# {'apple': 5, 'banana': 6, 'cherry': 6, 'date': 4}

# Invert a dictionary (swap keys and values)
original = {"a": 1, "b": 2, "c": 3}
inverted = {v: k for k, v in original.items()}
print(inverted)    # {1: 'a', 2: 'b', 3: 'c'}

# Dict comprehension with condition
scores = {"Alice": 88, "Bob": 42, "Carol": 95, "Dave": 58}
passing = {name: score for name, score in scores.items() if score >= 60}
print(passing)     # {'Alice': 88, 'Carol': 95}

# Square numbers as a dict
square_map = {n: n**2 for n in range(1, 8)}
print(square_map)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49}

import timeit

# Method 1: for loop with append
def using_loop(n):
    result = []
    for i in range(n):
        result.append(i ** 2)
    return result

# Method 2: list comprehension
def using_comprehension(n):
    return [i ** 2 for i in range(n)]

# Method 3: map() with lambda
def using_map(n):
    return list(map(lambda i: i ** 2, range(n)))

n = 100_000
t_loop = timeit.timeit(lambda: using_loop(n), number=50)
t_comp = timeit.timeit(lambda: using_comprehension(n), number=50)
t_map  = timeit.timeit(lambda: using_map(n), number=50)

print(f"for loop:        {t_loop:.3f}s")
print(f"comprehension:   {t_comp:.3f}s")
print(f"map(lambda):     {t_map:.3f}s")

# ❌ BAD: using a comprehension just for side effects
# This creates a list that's thrown away immediately
[print(x) for x in range(5)]     # Wasteful!

# ✅ GOOD: use a regular loop for side effects
for x in range(5):
    print(x)

# ❌ BAD: comprehension that's too complex to read at a glance
result = [f(x) for x in [g(y) for y in data if pred(y)] if condition(x)]

# ✅ GOOD: break complex logic into named steps
filtered_y   = [g(y) for y in data if pred(y)]
transformed  = [f(x) for x in filtered_y if condition(x)]

# ❌ BAD: building a huge list you only iterate once
for item in [process(x) for x in huge_data]:   # builds entire list first!
    do_something(item)

# ✅ GOOD: use a generator expression
for item in (process(x) for x in huge_data):   # one item at a time
    do_something(item)

import os
from pathlib import Path

# 1. Get all Python files in a directory
py_files = [f for f in Path(".").iterdir() if f.suffix == ".py"]

# 2. Parse CSV rows into dicts (without the csv module)
csv_lines = [
    "Alice,30,Engineer",
    "Bob,25,Designer",
    "Carol,35,Manager",
]
headers = ["name", "age", "role"]
records = [
    dict(zip(headers, line.split(",")))
    for line in csv_lines
]
print(records)
# [{'name': 'Alice', 'age': '30', 'role': 'Engineer'}, ...]

# 3. Remove duplicates while preserving order
seen = set()
data = [1, 3, 2, 1, 4, 3, 5, 2]
unique_ordered = [x for x in data if not (x in seen or seen.add(x))]
print(unique_ordered)  # [1, 3, 2, 4, 5]

# 4. Transpose a matrix
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transposed = [[row[i] for row in matrix] for i in range(len(matrix[0]))]
for row in transposed:
    print(row)
# [1, 4, 7]
# [2, 5, 8]
# [3, 6, 9]

# 5. Extract numbers from mixed list
mixed = [1, "hello", 3.14, True, "world", 42, None, 7]
numbers_only = [x for x in mixed if isinstance(x, (int, float)) and not isinstance(x, bool)]
print(numbers_only)   # [1, 3.14, 42, 7]