Lists: Advanced

Build transformed lists in one expression

In the beginner lesson, you learned to build lists by starting with an empty list and using append() in a loop. List comprehensions offer a more concise and often faster alternative. A comprehension creates a list by applying an expression to each item in an iterable, all in a single line.

The basic syntax is [expression for item in iterable]. The expression defines what goes into the new list. The for clause iterates over the source data. Python evaluates the expression for each item and collects the results into a new list.

Both approaches produce the same result: a list of squares from 1 to 25. The comprehension expresses the same logic in one line instead of three. The expression x ** 2 is evaluated for each value of x as it iterates through range(1, 6).

[ ] brackets

Opening and closing brackets define the new list being created.

expression

The value to compute for each item, like x ** 2 or name.upper().

for item in iterable

Iterates over the source data, binding each element to a variable.

if condition (optional)

Only includes items where the condition evaluates to True.

The first comprehension applies .upper() to each name, converting all strings to uppercase. The second applies len() to each name, producing a list of string lengths. The expression can be any valid Python expression that uses the loop variable.

Add an if clause to filter which items are included. Only items where the condition evaluates to True will be processed. The condition comes after the for clause.

The first comprehension includes only numbers where x % 2 == 0 (even numbers). The second adds another condition: x > 5. The third both filters to evens and transforms by squaring. You can combine filtering and transformation in one comprehension.

nums = [1, 2, 3, 4, 5, 6]
result = [___xx ** 2x * 10 for x in nums if ___x > 3x % 2 == 0]
print(result)

Notice the syntax: value_if_true if condition else value_if_false comes BEFORE the for clause. This is a conditional expression (also called a ternary operator). Contrast this with filter conditions that come AFTER the for clause.

Read nested for clauses left to right, as if they were nested loops. In [num for row in matrix for num in row], the outer loop iterates rows, and for each row, the inner loop iterates numbers. The result is all numbers in a single flat list.

Avoid accidental data sharing bugs

Think of a variable as a label or nametag attached to an object. When you write a = [1, 2, 3], Python creates a list object in memory and attaches the label "a" to it. The variable a points to that object; it does not contain the object itself.

The id() function returns a unique identifier for each object in memory. Both original and alias have the same id, proving they point to the exact same list object. The is operator confirms this: it checks object identity, not just equality.

Now original and copy are different objects (different ids, is returns False). Modifying copy does not affect original. The integers 1, 2, 3 are shared between both lists, but since integers are immutable, this sharing causes no problems.

We modified shallow[0][0], but original[0][0] also changed! This happened because both original[0] and shallow[0] point to the same inner list [1, 2]. The shallow copy created a new outer list, but the inner lists are shared. Changing an inner list through either reference affects both.

original = [1, 2, 3]
clone = original.___()
clone.append(4)
print(___(original))
print(len(clone))

When in doubt about whether two variables point to the same object, use the is operator or id() to check. This quick inspection can save hours of debugging unexpected shared-state behavior.

Duplicate nested structures safely

When you need completely independent copies of nested data structures, you need a deep copy. A deep copy recursively copies all objects: not just the outer list, but all nested lists, dictionaries, and other mutable objects inside. Python provides this through the copy module.

The copy module provides two functions: copy.copy() for shallow copies and copy.deepcopy() for deep copies. You must import the module before using it.

Now modifying deep[0][0] does not affect original. The deepcopy() function created new copies of all inner lists, so original and deep share no mutable objects. They are completely independent.

The deepcopy() function traverses the object graph recursively. For each mutable object it encounters, it creates a new copy. For immutable objects like integers, strings, and tuples, it can safely share references since those objects cannot be modified anyway.

Even with a complex structure containing dictionaries with nested lists, deepcopy() creates a completely independent copy. Modifications to deep_data do not affect data at any nesting level.

A common mistake when creating 2D lists is using the * operator with mutable objects. This creates multiple references to the same inner list, not independent copies.

With [[0] * 3] * 3, all three rows are the same list object. Changing one row changes all of them. With the comprehension [[0] * 3 for _ in range(3)], each iteration creates a new inner list, so the rows are independent.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

row = [0] * 3
grid = [row] * 3
grid[0][0] = 1
print(grid)

The multiplication trap [[row] * n] is one of the most common Python pitfalls. Always use a list comprehension to initialize 2D grids so each row is an independent list object.

Deep copies guarantee independence at every level of nesting. Use copy.deepcopy() whenever you need to work with a modified version of a nested structure without touching the original.

Use lists for last-in first-out processing

Stacks have two fundamental operations: push (add to top) and pop (remove from top). In Python lists, append() is push, and pop() without arguments is pop. Both operations are O(1), meaning they take constant time regardless of list size.

Each write() saves the current text before changing it. The undo() pops the most recent saved state, restoring the previous text. Multiple undos walk backward through the history.

While lists work well as stacks, they are inefficient as queues (First-In-First-Out). Adding and removing from the end is O(1), but adding or removing from the beginning is O(n) because all elements must shift.

For queue operations, use collections.deque (double-ended queue). It provides O(1) operations at both ends: append(), appendleft(), pop(), and popleft().

stack = []
stack.___("undo")
stack.append("redo")
top = stack.___()
print(top)
print(len(stack))

Python lists make natural stacks because append() and pop() both operate on the end of the list, which is the most memory-efficient position. Neither operation requires shifting any existing elements.

For queue (FIFO) behavior, use collections.deque instead of a list. A deque provides O(1) popleft() and appendleft() operations that a plain list cannot match efficiently.

Predict which methods modify the original

List methods that modify the list in place return None by convention. This is intentional: it signals that the operation changed the original object rather than creating a new one.

append(x) / extend(iter)

Add one item or unpack many items to the end of the list.

insert(i, x)

Place item x at index i, shifting later elements right.

remove(x) / pop([i])

Delete by value or by position. pop() also returns the item.

sort() / reverse()

Reorder elements in place. Both return None, not the list.

clear()

Empties the entire list, leaving it with zero elements.

The variable result is None because sort() returns None. The sorted data is in numbers, which was modified in place. If you assign the result, you lose access to your list.

Built-in functions like sorted() and reversed() do not modify the original; they return new objects. You must capture the return value.