Python Lists and Dictionaries

A list is an ordered, mutable sequence of values — Python's most flexible container for keeping multiple items together under a single name. You create a list with square brackets, separating values by commas, and Python remembers the order you put things in.

python
fruits = ["apple", "banana", "cherry"]
numbers = [10, 20, 30, 40, 50]
mixed = [1, "hello", True]
empty = []
print(len(fruits))   # 3

You can also call list() to convert another iterable (like a string or range) into a list: list(range(5)) produces [0, 1, 2, 3, 4]. The built-in len() function returns the number of items in a list — useful for bounds-checking and loop control.

---

Indexing gives you a single element from a list. Python uses zero-based indexing: the first item is at position 0, the second at 1, and so on. Negative indices count from the end — -1 is the last item, -2 is the second-to-last. Index beyond the list's length and Python raises an IndexError.

python
fruits = ["apple", "banana", "cherry"]
print(fruits[0])    # apple
print(fruits[-1])   # cherry
print(fruits[1])    # banana

Slicing extracts a sub-list using list[start:stop] — it returns every item from start up to (but not including) stop. You can omit either boundary to mean "from the beginning" or "to the end": fruits[:2] gives the first two items; fruits[1:] gives everything from index 1 onward. Slices never raise IndexError — an out-of-range stop just clamps to the list length. Use slicing whenever you need a portion of a list — it is one of the patterns that appears in nearly every real Python program that processes sequences.

Python lists come with built-in methods — functions attached to the list object that let you add, remove, sort, or copy items. The most important distinction to make from the start: some methods modify the list in place (they change the list and return None), while others return a new value without changing the original.

python
fruits = ["banana", "apple", "cherry"]
fruits.append("date")       # in-place: adds to end → None returned
fruits.insert(1, "avocado") # in-place: inserts at index 1
fruits.remove("apple")      # in-place: removes first occurrence
popped = fruits.pop()       # in-place: removes & RETURNS last item
print(popped)               # "cherry" (NOT None)
print(fruits)               # ["banana", "avocado", "date"]

Notice that .pop() is the exception among mutating methods — it both modifies the list and returns the removed item. You can also call .pop(i) with an index to remove and return a specific position.

---

Sorting and copying require extra care. .sort() sorts the list in place and returns None — a very common mistake is to write nums = nums.sort(), which overwrites your list with None. .reverse() likewise reverses in place and returns None. When you need to work on a separate copy, use .copy() (or the slice [:]), which returns a brand-new list with the same elements.

python
nums = [3, 1, 4, 1, 5, 9]
nums.sort()           # in-place: [1, 1, 3, 4, 5, 9]
print(nums)           # [1, 1, 3, 4, 5, 9]

original = [5, 2, 8]
copy = original.copy()
copy.sort()
print(original)       # [5, 2, 8]  — unchanged
print(copy)           # [2, 5, 8]

Use in-place methods when you want to update the existing list. Use .copy() before a mutating operation any time you need to keep the original intact — a rule of thumb that prevents many subtle bugs in Python programs.

The for item in list loop is Python's idiomatic way to visit every element in a list exactly once. You name the loop variable, and Python automatically advances through each position for you — no index arithmetic needed.

python
scores = [88, 92, 75, 61]
for score in scores:
    print(score)
# prints: 88  92  75  61  (each on its own line)

When you need both the index and the value at the same time, use enumerate(). It wraps the iterable and yields (index, value) pairs. You unpack them directly in the loop header, which is cleaner and less error-prone than managing an index counter by hand.

python
names = ["Alice", "Bob", "Carol"]
for i, name in enumerate(names):
    print(f"{i}: {name}")
# 0: Alice
# 1: Bob
# 2: Carol

---

A list comprehension is a compact way to build a new list by transforming or filtering an existing one — all in a single expression. The basic form is [expression for item in iterable]. Python evaluates expression for every item and collects the results into a new list, saving you from writing a loop + .append() every time.

python
nums = [1, 2, 3, 4, 5]
squares = [n ** 2 for n in nums]
print(squares)   # [1, 4, 9, 16, 25]

words = ["hello", "world"]
upper = [w.upper() for w in words]
print(upper)     # ["HELLO", "WORLD"]

List comprehensions are best for simple transformations where the expression fits on one line. Use a regular for loop when the body involves multiple steps or side-effects. Learning to recognise when a comprehension makes code clearer — versus when it makes it harder to read — is one of the hallmarks of writing idiomatic Python.

The accumulator pattern is a fundamental programming technique: start with an empty container (a list or a number), loop over an input sequence, and build up the result one item at a time. For lists, you initialise result = [] before the loop and call result.append(item) inside it.

python
def evens(numbers):
    result = []
    for n in numbers:
        if n % 2 == 0:
            result.append(n)
    return result

print(evens([1, 2, 3, 4, 5, 6]))   # [2, 4, 6]

Adding a condition inside the loop is the standard way to filter a list — you only append items that satisfy a test. This pattern is so common that Python's list comprehension syntax has a built-in shorthand for it: [x for x in items if condition]. Both the loop version and the comprehension version are valid; choose whichever is clearer for the situation.

---

Python also gives you three aggregate functions that work directly on any iterable of numbers: sum() adds all values, min() returns the smallest, and max() returns the largest. Using these built-ins avoids writing manual accumulator loops for the most common numeric summaries.

python
scores = [88, 92, 75, 61, 95]
print(sum(scores))    # 411
print(min(scores))    # 61
print(max(scores))    # 95
average = sum(scores) / len(scores)
print(average)        # 82.2

The accumulator pattern, filtering with conditions, and the aggregate built-ins form a complete toolkit for answering questions about lists: What items meet a criterion? What is the total? What are the extremes? Combining them — for example, filtering first, then calling sum() on the result — is how you solve the majority of list-processing problems in Python.

A dictionary is an unordered collection of key-value pairs — each key is a unique label that maps to a value, letting you look up any entry by name rather than by position. You create a dictionary with curly braces, separating each pair with a colon and pairs from each other with commas.

python
student = {"name": "Alice", "age": 14, "grade": "A"}
print(student["name"])   # Alice
print(student["age"])    # 14

To update an existing key, assign a new value using the same bracket syntax. To add a brand-new key, assign to a key that does not yet exist — Python creates it automatically. Accessing a key that does not exist raises a KeyError, so it is good practice to check membership with the in operator before accessing an uncertain key.

python
student["age"] = 15           # update existing key
student["school"] = "Zuzu"   # add new key
print("phone" in student)    # False — safe membership check

---

Dictionaries can hold any type as a value — strings, numbers, booleans, lists, or even other dictionaries. Keys must be immutable (strings, numbers, and tuples work; lists do not). You can delete a key-value pair with the del statement, and you can find out how many pairs are in a dictionary with len().

python
scores = {"math": 88, "english": 92, "science": 75}
print(len(scores))       # 3
del scores["science"]
print(len(scores))       # 2
print("science" in scores)  # False

Dictionaries are the right tool whenever your data has meaningful labels — a student's profile, a word's definition, a product's attributes. Reaching for a dictionary instead of a list is a sign that you are thinking about your data the way Python does.

Python dictionaries come with a set of built-in methods that make common operations safer and more expressive. The most important is .get(key, default): it returns the value for key if it exists, or the default value you provide instead of raising a KeyError. This is the standard way to do safe lookups.

python
scores = {"Alice": 88, "Bob": 75}
print(scores.get("Alice", 0))   # 88
print(scores.get("Carol", 0))   # 0 — key missing, default returned

.keys(), .values(), and .items() return view objects of the dictionary's keys, values, and key-value pairs respectively. They are most useful when you want to loop over them (covered in the next lesson) or convert them to a list with list().

python
d = {"x": 1, "y": 2, "z": 3}
print(list(d.keys()))    # ['x', 'y', 'z']
print(list(d.values()))  # [1, 2, 3]
print(list(d.items()))   # [('x', 1), ('y', 2), ('z', 3)]

---

.update(other) merges all key-value pairs from other into the dictionary, overwriting any existing keys. .pop(key) removes a key and returns its value (like list .pop(), but you specify the key). .setdefault(key, default) is a powerful compound operation: if the key exists it returns its value; if not, it inserts the key with default and returns default.

python
config = {"debug": True}
config.update({"version": 2, "debug": False})  # merges + overwrites
print(config)   # {'debug': False, 'version': 2}

removed = config.pop("version")
print(removed)  # 2

config.setdefault("timeout", 30)  # key missing: inserts 30
config.setdefault("debug", True)  # key exists: leaves False, returns False
print(config)   # {'debug': False, 'timeout': 30}

Knowing which method to reach for — .get() for safe access, .setdefault() for conditional insertion, .update() for merging — lets you write dictionary operations as clear, single-line expressions rather than multi-line if-else blocks.

When you write for k in d, Python iterates over the dictionary's keys in insertion order (guaranteed since Python 3.7). This is the simplest way to visit every key, and from each key you can access its value with d[k].

python
prices = {"apple": 0.5, "banana": 0.3, "cherry": 1.2}
for item in prices:
    print(item, prices[item])
# apple 0.5
# banana 0.3
# cherry 1.2

The more idiomatic approach when you need both the key and the value is for k, v in d.items(). It unpacks each (key, value) tuple directly in the loop header — cleaner and more readable than looking up d[k] inside the loop.

python
for item, price in prices.items():
    print(f"{item}: ${price:.2f}")
# apple: $0.50
# banana: $0.30
# cherry: $1.20

---

You can also build a dictionary by looping over a list — a common pattern for transforming data. Start with result = {}, then inside a loop assign to new keys: result[key] = value. This is the dictionary equivalent of the list accumulator pattern.

python
words = ["cat", "dog", "fish"]
lengths = {}
for word in words:
    lengths[word] = len(word)
print(lengths)   # {'cat': 3, 'dog': 3, 'fish': 4}

Use for k in d when you only need keys, for k, v in d.items() when you need both, and the build-dict pattern when you need to create a mapping from a list. Combining these three forms covers the vast majority of dictionary-processing tasks you will encounter.

The frequency-counting pattern is one of the most useful patterns in Python: use a dictionary to count how many times each item appears in a sequence. The standard idiom uses .get() with a default of 0 — if the key already exists, increment its count; if it does not, start from 0 and add 1.

python
def count_chars(s):
    counts = {}
    for ch in s:
        counts[ch] = counts.get(ch, 0) + 1
    return counts

print(count_chars("hello"))  # {'h': 1, 'e': 1, 'l': 2, 'o': 1}

The single line counts[ch] = counts.get(ch, 0) + 1 does all the work: it reads the current count (defaulting to 0 if missing) and writes back the incremented value. This works for any hashable item — characters, words, numbers, or tuples.

---

For more complex tallying you can build dicts of lists — also called grouped or nested dictionaries. Instead of counting occurrences, you append each item to a list stored under a key. The pattern mirrors the counter, but uses .setdefault() (or .get() with [] as default) to ensure the list exists before appending.

python
def group_by_length(words):
    groups = {}
    for word in words:
        length = len(word)
        groups.setdefault(length, []).append(word)
    return groups

print(group_by_length(["cat", "dog", "fish", "ox"]))
# {3: ['cat', 'dog'], 4: ['fish'], 2: ['ox']}

The frequency-counter pattern appears in word analysis, vote tallying, histogram generation, and any problem that asks "how many times does X appear?" Mastering it — and its grouped variant — gives you a powerful tool for a wide class of real-world data problems.