Python Data Structures: Lists, Tuples, Dicts & Sets

Picking the right data structure is one of the first decisions you make when writing a program. Python ships with four powerful built-in collections that cover the vast majority of real-world needs. Understanding how each one works — and when to use it — will make your code cleaner, faster, and easier to maintain.

Quick Comparison

Collection	Ordered	Mutable	Allows Duplicates	Best For
`list`	✅	✅	✅	Sequences that change over time
`tuple`	✅	❌	✅	Fixed records, function return values
`dict`	✅	✅	Keys: ❌	Named data, lookup by key
`set`	❌	✅	❌	Unique values, membership tests

Lists

A list is an ordered, mutable sequence. It is the most versatile collection in Python and the right default choice whenever you need to store items that may change.

fruits = ["apple", "banana", "cherry"]
mixed  = [1, "Python", 3.14, True]   # different types are fine
empty  = []

Indexing and Slicing

Lists are zero-indexed. Negative indices count from the end.

fruits = ["apple", "banana", "cherry", "mango"]

print(fruits[0])    # apple
print(fruits[-1])   # mango
print(fruits[1:3])  # ['banana', 'cherry']
print(fruits[::-1]) # reversed: ['mango', 'cherry', 'banana', 'apple']

Modifying a List

numbers = [10, 20, 30]

numbers.append(40)         # add to the end → [10, 20, 30, 40]
numbers.insert(1, 15)      # insert at index 1 → [10, 15, 20, 30, 40]
numbers.extend([50, 60])   # merge another list → [10, 15, 20, 30, 40, 50, 60]

numbers.remove(15)         # remove first occurrence of 15
numbers.pop()              # remove and return the last item
numbers.pop(0)             # remove and return item at index 0

numbers.sort()             # sort in place
numbers.reverse()          # reverse in place
print(numbers)

List Comprehension

Build a new list from an existing iterable in a single readable line:

squares    = [x ** 2 for x in range(1, 6)]
evens      = [x for x in range(10) if x % 2 == 0]
upper_name = [name.upper() for name in ["alice", "bob", "carol"]]

print(squares)    # [1, 4, 9, 16, 25]
print(evens)      # [0, 2, 4, 6, 8]
print(upper_name) # ['ALICE', 'BOB', 'CAROL']

List comprehensions are usually faster than equivalent for loops that call .append(), and they read more like plain English.

Tuples

A tuple is an ordered, immutable sequence. Once you create a tuple, you cannot add, remove, or change its elements. Use tuples for data that must stay constant — coordinates, RGB colours, database rows, function return values.

point    = (3, 7)
rgb      = (255, 128, 0)
single   = (42,)    # trailing comma is required for single-element tuples
empty    = ()

Writing (42) creates an int, not a tuple. You must write (42,) — the comma makes it a tuple.

Accessing Elements

Tuples support the same indexing and slicing as lists:

colors = ("red", "green", "blue")

print(colors[0])    # red
print(colors[-1])   # blue
print(colors[1:])   # ('green', 'blue')

Tuple Unpacking

Assign all elements to individual variables in one statement:

student = ("Alice", 20, "Computer Science")
name, age, course = student

print(name)    # Alice
print(age)     # 20
print(course)  # Computer Science

When to Choose a Tuple Over a List

Use a tuple when:

The data represents a single fixed record (e.g., a coordinate pair or a named row).
You want to protect the data from accidental modification.
You need to use the collection as a dictionary key (tuples are hashable; lists are not).

Dictionaries

A dictionary stores data as key-value pairs. Each key is unique and maps to exactly one value. Dictionaries preserve insertion order (Python 3.7+) and are the backbone of most real-world Python programs.

student = {
    "name": "Alice",
    "age": 20,
    "course": "Python for AI",
}

Reading Values

# Direct access — raises KeyError if key is missing
print(student["name"])          # Alice

# .get() — returns None (or a default) if key is missing
print(student.get("age"))       # 20
print(student.get("gpa", 0.0))  # 0.0 (default)

Adding, Updating, and Removing

student["city"] = "Hyderabad"   # add a new key
student["age"]  = 21            # update existing key

student.update({"city": "Mumbai", "gpa": 3.9})  # update multiple keys

student.pop("gpa")              # remove a key and return its value
del student["city"]             # remove a key (no return value)

Iterating

for key in student:
    print(key)                         # prints keys

for value in student.values():
    print(value)                       # prints values

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

Dictionary Comprehension

squares = {x: x ** 2 for x in range(1, 6)}
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Invert a dictionary
original = {"a": 1, "b": 2, "c": 3}
inverted = {v: k for k, v in original.items()}
# {1: 'a', 2: 'b', 3: 'c'}

Merging Dictionaries (Python 3.9+)

defaults = {"theme": "light", "lang": "en"}
overrides = {"theme": "dark", "font_size": 14}

merged = defaults | overrides
# {'theme': 'dark', 'lang': 'en', 'font_size': 14}

Sets

A set is an unordered collection of unique values. Sets automatically discard duplicates and excel at membership testing and set-algebra operations.

fruits  = {"apple", "banana", "cherry"}
numbers = {1, 2, 2, 3, 3, 4}   # duplicates removed automatically
empty   = set()                  # NOT {} — that creates an empty dict

{} creates an empty dictionary, not a set. Always use set() to create an empty set.

Adding and Removing

tags = {"python", "ai", "web"}

tags.add("data")             # add one element
tags.discard("web")          # remove if present (no error if missing)
tags.remove("ai")            # remove — raises KeyError if missing

print(tags)  # {'python', 'data'}

Set Operations

backend  = {"python", "go", "rust"}
frontend = {"javascript", "typescript", "python"}

print(backend | frontend)   # union — all elements from both
print(backend & frontend)   # intersection — elements in both
print(backend - frontend)   # difference — in backend but not frontend
print(backend ^ frontend)   # symmetric difference — in one but not both

Fast Membership Testing

Sets check membership in O(1) time, making them far faster than lists for this purpose:

valid_roles = {"admin", "editor", "viewer"}

user_role = "editor"
if user_role in valid_roles:
    print("Access granted")

Deduplication

Convert a list to a set and back to strip duplicates:

raw = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]
unique = list(set(raw))
print(unique)  # order is not guaranteed

Choosing the Right Collection

Use a list when…

You need an ordered sequence that will change (items added, removed, or reordered).
You need to access elements by numeric index.
Duplicates are meaningful (e.g., a log of events).

task_queue = ["fetch data", "clean data", "train model"]
task_queue.append("evaluate model")

Use a tuple when…

The data is a fixed record that should never change.
You need to use the collection as a dictionary key.
You are returning multiple values from a function.

def bounding_box(points):
    xs = [p[0] for p in points]
    ys = [p[1] for p in points]
    return (min(xs), min(ys), max(xs), max(ys))

Use a dict when…

You want to look up values by a meaningful name rather than a position.
You are modelling an object with named properties.
You need to count, group, or index items.

word_count = {}
for word in "to be or not to be".split():
    word_count[word] = word_count.get(word, 0) + 1
# {'to': 2, 'be': 2, 'or': 1, 'not': 1}

Use a set when…

You only care about whether a value exists (membership testing).
You need to remove duplicates.
You need to compare two collections (union, intersection, difference).

seen = set()
unique_visitors = []
for user_id in visitor_log:
    if user_id not in seen:
        seen.add(user_id)
        unique_visitors.append(user_id)

Practical Example: Processing Student Records

The following example uses all four collections together to process a class roster:

# Raw records as a list of tuples
records = [
    ("Alice",  91, "AI"),
    ("Bob",    74, "Web"),
    ("Carol",  91, "AI"),
    ("Dave",   74, "AI"),
    ("Eve",    85, "Web"),
]

# Build a dict: name → score
scores = {name: score for name, score, _ in records}
print(scores)

# All unique courses (set)
courses = {course for _, _, course in records}
print(courses)  # {'AI', 'Web'}

# Top students (list, filtered)
top_students = [name for name, score in scores.items() if score >= 85]
print(top_students)  # ['Alice', 'Carol', 'Eve']

# Highest score (tuple returned from a function)
def min_max(score_dict):
    values = list(score_dict.values())
    return min(values), max(values)

low, high = min_max(scores)
print(f"Range: {low} – {high}")  # Range: 74 – 91

Core Python

Advanced Python

Pydantic

Python Data Structures: Lists, Tuples, Dicts & Sets

Quick Comparison

Lists

Indexing and Slicing

Modifying a List

List Comprehension

Tuples

Accessing Elements

Tuple Unpacking

When to Choose a Tuple Over a List

Dictionaries

Reading Values

Adding, Updating, and Removing

Iterating

Dictionary Comprehension

Merging Dictionaries (Python 3.9+)

Sets

Adding and Removing

Set Operations

Fast Membership Testing

Deduplication

Choosing the Right Collection

Practical Example: Processing Student Records

​Quick Comparison

​Lists

​Indexing and Slicing

​Modifying a List

​List Comprehension

​Tuples

​Accessing Elements

​Tuple Unpacking

​When to Choose a Tuple Over a List

​Dictionaries

​Reading Values

​Adding, Updating, and Removing

​Iterating

​Dictionary Comprehension

​Merging Dictionaries (Python 3.9+)

​Sets

​Adding and Removing

​Set Operations

​Fast Membership Testing

​Deduplication

​Choosing the Right Collection

​Practical Example: Processing Student Records

Quick Comparison

Lists

Indexing and Slicing

Modifying a List

List Comprehension

Tuples

Accessing Elements

Tuple Unpacking

When to Choose a Tuple Over a List

Dictionaries

Reading Values

Adding, Updating, and Removing

Iterating

Dictionary Comprehension

Merging Dictionaries (Python 3.9+)

Sets

Adding and Removing

Set Operations

Fast Membership Testing

Deduplication

Choosing the Right Collection

Practical Example: Processing Student Records