Lists: Intermediate

Extract portions of a list efficiently

In the beginner lesson, you learned to access individual items using a single index like list[0] or list[-1]. Slicing extends this concept to extract multiple items at once. Instead of one index, you provide a range using the colon character. The result is a new list containing just the items in that range.

The basic slice syntax is list[start:end]. The start index is included in the result, but the end index is excluded. This might seem counterintuitive at first, but it has practical benefits: the number of items in the slice equals end minus start, and consecutive slices fit together without gaps or overlaps.

The slice [2:6] gives us items at indices 2, 3, 4, and 5. Notice that index 6 is NOT included. The slice contains exactly 6 - 2 = 4 items. Similarly, [0:3] gives indices 0, 1, 2 (three items), and [7:10] gives indices 7, 8, 9 (three items).

The exclusive end index is a deliberate design choice with several advantages. First, the length of the slice equals end - start, making calculations easy. Second, you can split a list into non-overlapping parts: list[:n] and list[n:] together contain all items exactly once. Third, it matches how range() works, creating consistency throughout Python.

The expression letters[:3] means "from the start up to index 3." The expression letters[4:] means "from index 4 to the end." The expression letters[:] with both omitted means "from start to end," which creates a complete copy of the list.

The slice [-3:] gives the last 3 items. The slice [:-2] gives everything except the last 2. The slice [-5:-2] gives a window from the 5th-last item up to (but not including) the 2nd-last item.

Slices can take a third parameter called the step, written as list[start:end:step]. The step determines how many positions to advance between each item. A step of 2 takes every other item, a step of 3 takes every third item, and so on.

When you use a step, you can still omit start and end to mean "from beginning" and "to end." The expression [::2] means "from start to end, taking every second item." The expression [1::2] means "start at index 1, go to end, taking every second item."

The idiom [::-1] is the standard Python way to reverse a sequence. It creates a new reversed list without modifying the original. This works on strings and tuples too, making it a universally useful pattern.

nums = [10, 20, 30, 40, 50, 60]
result = nums[___::21:5::-1-3:]
print(result)

When we changed slice_copy[0] to 99, the original list remained unchanged at [1, 2, 3, 4, 5]. This is because slicing created an independent copy. This behavior is called a shallow copy, which we will explore more in the advanced lesson.

Merge multiple lists together

Often you need to combine data from multiple lists into one. Python provides several ways to do this, each with different behaviors. The extend() method adds items from one list to another, modifying the original. The + operator creates a new combined list without changing the originals. Understanding when to use each approach is essential for writing clear, efficient code.

The .extend() method takes all items from another iterable (like a list) and adds them to the end of the current list. It modifies the list in place and returns None. The syntax is list1.extend(list2).

Team A grew from 3 members to 5 members by adding everyone from Team B. Team B itself was not modified; its items were copied into Team A. The extend() method modified team_a directly rather than creating a new list.

One of the most common mistakes with lists is confusing extend() with append(). They behave very differently. The append() method adds its argument as a single item, even if that argument is a list. The extend() method unpacks its argument and adds each item individually.

With append(), the entire list [4, 5, 6] became a single nested element at index 3. The result is a list of 4 items, where the last item is itself a list. With extend(), the items 4, 5, and 6 were added individually. The result is a flat list of 6 integers.

The extend() method accepts any iterable, not just lists. An iterable is any object you can loop over: strings, tuples, ranges, and more. Each item from the iterable is added to the list.

The + operator creates a new list by concatenating two lists together. Unlike extend(), it does not modify either original list. This is useful when you need to combine lists but want to preserve the originals, or when you want to chain multiple concatenations.

The + operator returns a new list without changing first, second, or third. You can chain multiple + operators to combine many lists in one expression. The result is evaluated left to right: (first + second) + third.

The += operator combines assignment with concatenation. For lists, list1 += list2 is equivalent to list1.extend(list2). It modifies list1 in place rather than creating a new list.

The id() function returns a unique identifier for an object in memory. Notice that the ID remains the same before and after the += operation, proving that we modified the same list object rather than creating a new one. This is more memory-efficient than using + and reassigning.

The * operator repeats a list a specified number of times. This is useful for initializing lists with default values or creating patterns.

The expression [0] * 5 creates a new list with five zeros. The expression [1, 2] * 4 repeats the two-element pattern four times for eight total elements. This is a quick way to initialize lists of known sizes.

a = [1, 2, 3]
b = [4, 5]
combined = a ___ b
print(len(combined))
print(___(a))

The + operator always creates a new list, making it safe to use when you need to preserve both originals. Use extend() when you want to grow a list in place without creating a new object.

The * operator is a quick way to initialize lists with repeated values, like [0] * 10 for ten zeros. Be careful using * with nested mutable objects, since all copies share the same inner reference.

Arrange items in any custom order

Sorting is one of the most fundamental operations in programming. Python provides two ways to sort lists: the sort() method modifies the list in place, while the sorted() function returns a new sorted list. Both use the same underlying algorithm and accept the same customization options.

The .sort() method sorts a list in place, meaning it modifies the original list and returns None. By default, it sorts in ascending order: smallest to largest for numbers, alphabetical for strings.

The built-in sorted() function takes any iterable and returns a new sorted list, leaving the original unchanged. This is useful when you need both the original order and a sorted version.

Both sort() and sorted() accept a reverse=True parameter to sort in descending order instead of ascending.

The key parameter lets you customize how items are compared. You pass a function that takes an item and returns the value to use for comparison. This is extremely powerful for sorting complex data.

The key=len sorts strings by their length. The key=str.lower converts each string to lowercase for comparison, achieving case-insensitive sorting. The key=abs sorts numbers by their distance from zero, ignoring the sign.

The lambda x: x[1] is a small anonymous function that returns the second element of each tuple (the score). Lambda functions are useful when you need a simple key function without defining a named function.

A very common bug is assigning the result of sort() and expecting a sorted list. Since sort() returns None, the variable ends up empty. Fix the code below by removing the offending tiles.

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

scores = [88, 72, 95, 63]
scores = scores.sort()
print(scores)

The in-place vs return-value distinction applies to many Python methods. sort() and reverse() modify in place and return None, while sorted() and reversed() return new objects without touching the original.

Use sort() when you do not need to preserve the original order, saving memory. Use sorted() when you need both the original and a sorted version available at the same time.

Custom sorting with the key= argument is one of the most powerful features Python offers. Any function that maps an item to a comparable value can serve as a key, giving you precise control over sort order.

Flip list order for different traversals

Python provides multiple ways to reverse a list, each suited for different situations. The reverse() method modifies in place, the reversed() function returns an iterator, and slice notation creates a reversed copy.

The .reverse() method reverses a list in place and returns None. The original list is modified.

The built-in reversed() function returns an iterator that yields items in reverse order. To get a list, you must wrap it with list().

The reversed() function is memory-efficient because it does not create a new list immediately. It creates an iterator that generates items on demand. This is useful when you only need to iterate through the reversed order once.

As you learned earlier, the slice [::-1] creates a reversed copy. This is often the most concise approach when you need a reversed list.

list.reverse()

Modifies the list in place and returns None. The original order is lost.

reversed(list)

Returns a memory-efficient iterator. Wrap with list() to get a list.

list[::-1]

Creates a reversed copy in one expression. The original stays unchanged.

Find items and check membership quickly

The .index(value) method returns the index of the first occurrence of a value. If the value is not found, it raises a ValueError.

Even though "banana" appears twice (at indices 1 and 3), index() returns only the first occurrence at index 1. The method scans from the beginning and stops as soon as it finds a match.

You can provide a starting index to begin the search from a specific position: list.index(value, start). You can also provide an end index: list.index(value, start, end).

If the value is not in the list, index() raises a ValueError. You should handle this case either by checking with in first, or by using try/except.

The .count(value) method returns the number of times a value appears in the list. If the value is not found, it returns 0 rather than raising an error.

The count() method scans the entire list and counts matches. "D" appears 0 times, which is returned as 0 rather than causing an error. This makes count() safe to use without checking if the value exists first.

Sometimes you need to find all positions where a value appears, not just the first. You can combine index() with a loop, or use a list comprehension with enumerate().

The enumerate() function yields pairs of (index, value) as you iterate. The list comprehension keeps only those indices where the letter equals "a". This is more efficient than calling index() repeatedly.

letters = ["a", "b", "c", "b", "a"]
pos = letters.___("c")
total = letters.___("b")
print(pos)
print(total)

index() raises a ValueError if the item is not found, so wrap it in a try-except block or check with in first when the item might be absent.

count() is a safe alternative to index() when you just need to know whether duplicates exist. A count of 0 means the item is absent; any positive number tells you exactly how many times it appears.