Building a Collection in One Line

squares = [] starts empty. The loop runs once per number, and squares.append(n * n) grows the list by one each time. Nothing here is wrong — it is just three lines to say one idea.

squares = []for n in numbers:    squares.append(n * n)

[n * n for n in numbers] is a list comprehension: the same loop and the same append, written in the order you would say it aloud — “n squared, for every n in numbers”. Adding if n % 2 == 0 at the end filters which values make it in, doing the work of the loop's if check without a separate line.

numbers = [1, 2, 3, 4, 5, 6] squares = [n * n for n in numbers]evens_squared = [n * n for n in numbers if n % 2 == 0]print(squares)print(evens_squared)

Try itChange the filter to if n > 3 and run it again.

The square-bracket version builds a list, but the same idea works with curly braces too. Add a colon between two expressions and you get a dict comprehension; leave the colon out and you get a set comprehension instead.

names = ["Ada", "Grace", "Alan", "Bob"] lengths = {name: len(name) for name in names}unique_lengths = {len(name) for name in names}print(lengths)print(unique_lengths)

Try itAdd a name of your own and see which of the two results grows.

{name: len(name) for name in names} builds a dictionary the same way the loop version would — one key, one value, per iteration. Drop the key entirely and keep only a value, and a set comprehension collapses duplicates the same way set() always does: four names with only three distinct lengths produce three entries in unique_lengths, not four.

A comprehension can hold more than one for clause, in the same order you would nest the loops. The most common reason is flattening — turning a list of lists into a single list.

rows = [[1, 2, 3], [4, 5], [6]] flat = []for row in rows:    for value in row:        flat.append(value)

$ >>> flat = [value for row in rows for value in row]$ >>> flat$ [1, 2, 3, 4, 5, 6]

Read the two for clauses left to right, in the same order the nested loops ran: the outer loop — for row in rows — comes first, then the inner one — for value in row. Reverse them and Python raises a NameError, because row has to exist before for value in row makes sense — or, worse, if a row is still lying around from an earlier loop, it quietly loops over that stale row and hands back the wrong list.

A comprehension earns its place when the body is one short expression. Nest two loops inside it, or stack three conditions, and it stops being readable in one glance — at that point the three-line loop is the clearer choice, not a worse one.

# technically one line — not obviously one ideareport = [f"{n}: {'even' if n % 2 == 0 else 'odd'}" for n in numbers if n > 2]

Nothing about that line is illegal, and nothing about it is fast to read either — a condition inside the expression, a filter at the end, and a format string all competing for attention in one clause. The three-line loop version of the same logic reads in the order your eye actually moves.