Lists, Tuples & Sets
📦 Lists, Tuples & Sets
📋 Lists — Mutable, Ordered Sequences
fruits = ["apple", "banana", "cherry"] fruits.append("date") # ['apple', 'banana', 'cherry', 'date'] fruits.insert(1, "apricot") # insert at a specific index fruits.remove("banana") # removes the first matching value last = fruits.pop() # removes and returns the last item fruits.sort() # sorts in place, alphabetically print(fruits[0]) # indexing and slicing work exactly like strings print(fruits[1:])
Lists use the same indexing and slicing syntax you already know from strings (Chapter 5) — [start:stop:step], negative indices, all of it.
a = [1, 2, 3] b = a # b now points to the SAME list as a b.append(4) print(a) # [1, 2, 3, 4] — a changed too!
b = a does not create a second, independent list — it makes b a second name for the exact same list object in memory, since lists are mutable. Modifying b modifies the only list that exists. To get a real independent copy, use b = a.copy() or b = a[:].
🔒 Tuples — Immutable, Ordered Sequences
point = (3, 7) print(point[0]) # 3 — indexing works like a list # point[0] = 5 # TypeError — tuples can't be modified after creation # Tuple unpacking — a very common Python idiom x, y = point print(x, y) # 3 7
Tuples exist for data that shouldn't change after creation — coordinates, RGB values, a fixed record returned from a function. Because they're immutable, they can also be used as dictionary keys and set members (Chapter 7 covers dictionaries), which lists cannot.
🎯 Sets — Unordered, Unique Collections
numbers = {1, 2, 2, 3, 3, 3}
print(numbers) # {1, 2, 3} — duplicates automatically removed
a = {1, 2, 3}
b = {2, 3, 4}
print(a | b) # {1, 2, 3, 4} — union
print(a & b) # {2, 3} — intersection
print(a - b) # {1} — difference
print(3 in a) # True — membership tests on sets are very fast
Collections: Go vs Kotlin vs Python
| Concept | Go | Kotlin | Python |
|---|---|---|---|
| Mutable ordered | []T (slice) | MutableList<T> | list |
| Fixed-size ordered | [N]T (array) | List<T> (read-only view) | tuple |
| Unique/unordered | no built-in set — usually map[T]bool | MutableSet<T> | set |
Go's lack of a built-in set type is a real, sometimes-surprising gap coming from Python — reaching for map[T]bool as a workaround is the standard idiom there.
⚡ A First Look at List Comprehensions
A list comprehension builds a new list from an existing sequence in a single, compact expression:
numbers = [1, 2, 3, 4, 5] # The loop version, from Chapter 4: squares = [] for n in numbers: squares.append(n ** 2) # The comprehension version — same result, one line: squares = [n ** 2 for n in numbers] # With a filtering condition: even_squares = [n ** 2 for n in numbers if n % 2 == 0] print(even_squares) # [4, 16]
This is a preview, not the full picture — comprehensions get their own dedicated deep dive in Course 2 (dict/set comprehensions, nested comprehensions, and generator expressions). For now, just recognize the pattern: [expression for item in iterable if condition].
list
Mutable, ordered — the everyday, general-purpose collection.
tuple
Immutable, ordered — for fixed data, unpacking, and use as dict keys.
set
Unordered, unique — automatic deduplication and fast membership tests.
List comprehension
[expr for item in iterable if condition] — a compact way to build a list.
💻 Coding Challenges
Challenge 1: Remove Duplicates, Keep Order
Given numbers = [3, 1, 3, 2, 1, 4, 2], produce a new list with duplicates removed but the original first-seen order preserved: [3, 1, 2, 4]. (Hint: a plain set() alone won't preserve order.)
Goal: Understand the real trade-off between sets (fast, unordered) and lists (ordered) firsthand.
Challenge 2: Coordinate Unpacking
Given a list of three tuples, points = [(1, 2), (3, 4), (5, 6)], loop over it and print each point as "x=1, y=2" using tuple unpacking directly in the for loop header.
Goal: Practice tuple unpacking combined with iteration.
Challenge 3: Common Elements
Given two lists, a = [1, 2, 3, 4, 5] and b = [3, 4, 5, 6, 7], use sets to find and print the elements that appear in both, as a sorted list: [3, 4, 5].
Goal: Practice converting lists to sets to use set intersection, then converting back.
🎯 What's Next
Next chapter: Dictionaries — key-value operations, iterating, and dict comprehensions.