Python Data Structures: Choosing the Right Container for Your Data

So far every variable in these posts has held a single value. Real programs deal with collections: a list of customers, a record for each student. Python has four built-in containers for that: lists, tuples, dictionaries, and sets.

Lists and dictionaries especially are the backbone of what comes next. A pandas DataFrame can be built from a dictionary of lists, where each key is a column, and every API response or JSON record arrives in Python as a dictionary.

Lists: ordered and changeable

A list keeps items in order, and you can add, remove, or change them whenever you like.

fruits = ["mango", "banana", "pineapple"]

print(fruits[0])       # mango
print(fruits[-1])      # pineapple
print(fruits[0:2])     # ['mango', 'banana']

fruits.append("orange")
print(len(fruits))     # 4

Positions start at 0, and -1 is always the last item. Lists also come with methods for changing them:

Method	What it does
append(x)	Adds x to the end
insert(i, x)	Inserts x at position i
extend(list2)	Adds every item from another list
remove(x)	Removes the first x it finds
pop() / pop(i)	Removes and returns the last item, or the one at i
index(x) / count(x)	Position of x / how many times it appears
sort() / reverse()	Sorts or reverses the list in place

register = ["Bob", "John", "Faith", "Mercy", "Wanjiku"]

register.insert(0, "Amina")
register.extend(["Brian", "David"])
print(register.pop())                # David
register.remove("John")
print(register.index("Faith"))       # 2

marks = [78, 45, 92, 60]
print(sorted(marks))                 # [45, 60, 78, 92]  new list, marks unchanged
marks.sort(reverse=True)
print(marks)                         # [92, 78, 60, 45]  marks itself changed

Most of these methods change the list in place and return None, so marks = marks.sort() leaves you with None. Use sorted(marks) when you want a new list back.

Tuples: a list that's locked

A tuple can't be changed after it's created, which is exactly right for data that should never move: GPS coordinates, RGB colour codes, a row from a database.

nairobi = (-1.2921, 36.8219)

latitude, longitude = nairobi        # unpacking
print(latitude, longitude)           # -1.2921 36.8219

nairobi[0] = 0                       # TypeError: 'tuple' object does not support item assignment

Dictionaries: values with labels

With a list you find things by position. With a dictionary you find them by a label, called a key, which is far more readable when each value means something different. It's the natural fit for student records, phone books, configs, and JSON.

student = {"name": "Amina", "age": 17, "class": "Form 3"}

print(student["name"])                        # Amina
student["city"] = "Nairobi"                   # add a key
student["age"] = 18                           # update a key

for key, value in student.items():
    print(f"{key}: {value}")

print(student.get("phone", "not provided"))   # not provided

student["phone"] would crash with a KeyError since that key doesn't exist, so .get() with a fallback is the safer choice when you're not sure.

Sets: unique items only

A set drops duplicates automatically and doesn't care about order, which makes it good for removing repeats and comparing groups.

cities = ["Nairobi", "Mombasa", "Nairobi", "Kisumu", "Mombasa"]
print(sorted(set(cities)))           # ['Kisumu', 'Mombasa', 'Nairobi']

morning = {"Amina", "Brian", "Cynthia"}
evening = {"Brian", "David"}
print(morning & evening)             # {'Brian'}  in both
print(sorted(morning | evening))     # ['Amina', 'Brian', 'Cynthia', 'David']  in either

Which one should I reach for?

Container	Ordered?	Changeable?	Duplicates?	Best for
List	Yes	Yes	Allowed	A sequence you add to or loop over
Tuple	Yes	No	Allowed	Fixed data like coordinates
Dictionary	Yes	Yes	Unique keys	Looking things up by label
Set	No	Yes	Not allowed	Removing repeats, checking membership

If position matters, use a list. If a label matters, use a dictionary. If it must never change, use a tuple. If you only care about uniqueness, use a set.

Nesting them: a small grade book

The real power shows up when you combine them. Here a dictionary maps each student to a list of marks:

grades = {
    "Amina":   [78, 85, 90],
    "Brian":   [92, 55, 71],
    "Cynthia": [49, 59, 71],
}

for student, marks in grades.items():
    average = sum(marks) / len(marks)
    print(f"{student}: {average:.1f}")     # Amina: 84.3, Brian: 72.7, Cynthia: 59.7

Where this showed up in my project

The data for my Bundle Purchase Simulator is this kind of nesting. The catalogue is a dictionary where each category maps to a list, and each bundle in that list is its own dictionary:

bundles = {
    "Data": [
        {"name": "50MB - Daily",   "price": 5,   "validity": "24 hours"},
        {"name": "500MB - Weekly", "price": 50,  "validity": "7 days"},
        {"name": "2GB - Monthly",  "price": 200, "validity": "30 days"},
    ],
    # "SMS" and "Minutes" follow the same pattern
}

print(bundles["Data"][1]["name"])    # 500MB - Weekly
print(bundles["Data"][1]["price"])   # 50

Each choice fits the job. Categories are looked up by name, so a dictionary. Bundles within a category are shown in numbered order, so a list. Each bundle has a name, a price and a validity that mean different things, so a dictionary again. Read left to right, bundles["Data"][1]["price"] is the Data category, its second bundle, then the price.

What I took from it

Nothing here is hard on its own. The skill is choosing well. Once I stopped squeezing everything into lists and gave each record labelled fields, the code started explaining itself.