Working with Data Structures

Data structures are containers that hold collections of related data together in an organized way.

Programming

What Data Structures Are

Imagine you need to keep track of a shopping list, a student's grades, or a phone book. You could create separate variables for each item, but that quickly becomes unwieldy. Data structures are containers that hold collections of related data together in an organized way. They are the fundamental building blocks for storing and managing information efficiently in Python.

Python provides several built-in data structures, each designed for different purposes. Some are ordered and allow duplicates, others enforce uniqueness, and still others organize data as key-value pairs. The choice of data structure affects not only how your data is stored in memory, but also which operations are fast or slow, and what kinds of problems you can solve elegantly.

Python's Dynamic Typing and Data Structure Flexibility

One of Python's defining features is dynamic typing: a variable can hold any type of data, and that type can change at runtime. This flexibility extends to data structures. A single list can contain integers, strings, floats, and even other data structures—all at the same time. When you add a new element to a list, Python doesn't require you to declare what type it will be; it simply stores the object and adjusts the structure accordingly.

This dynamic nature means that when you create a data structure, Python allocates memory not just for the data itself, but for metadata about each element—including its type. As you add or remove elements, Python manages this memory automatically. The interpreter handles all the bookkeeping, so you can focus on your logic rather than manual memory management.

When you add different data types to a Python data structure, how does the structure adapt? What information does Python track for each element?

Memory Layout of Core Data Structures

Python's built-in data structures—lists, tuples, dictionaries, and sets—each organize data differently in memory. Understanding this layout helps you predict how operations will perform and why certain structures are better suited to certain tasks.

How are elements physically arranged in memory for lists, tuples, dictionaries, and sets? What information does Python store for each?

Lists and tuples store elements in a fixed sequence, with each element accessible by its numeric index (0, 1, 2, ...). The key difference: lists are mutable (you can change, add, or remove elements), while tuples are immutable (once created, they cannot be modified). Dictionaries organize data as key-value pairs, allowing you to access values by meaningful keys rather than numeric positions. Sets store unique elements with no particular order and no key-value association. Each structure's memory layout reflects its purpose: sequential access for lists and tuples, fast lookup by key for dictionaries, and uniqueness enforcement for sets.

Tracing Data Structure Operations

Let's trace what happens step-by-step when you create and modify a list. This will show you how Python manages the structure and its elements in memory.

Worked example

Creating and Modifying a List

Start with an empty list, add three elements of different types, then modify one element. What happens in memory at each step?

1
Step 1: Create an empty list
You write my_list = []. Python allocates memory for a list object and initializes it with zero elements. The list structure itself (the container) exists, but it holds no data yet.
2
Step 2: Add an integer
You write my_list.append(42). Python creates an integer object with value 42 and stores a reference to it in the list. The list now has one element at index 0.
3
Step 3: Add a string
You write my_list.append('hello'). Python creates a string object and adds a reference to it at index 1. The list now has two elements. Notice that the first element (42) remains unchanged.
4
Step 4: Add a float
You write my_list.append(3.14). Python creates a float object and adds a reference at index 2. The list now contains three elements of three different types, all stored together.
5
Step 5: Modify an element
You write my_list[1] = 'goodbye'. Python creates a new string object 'goodbye' and replaces the reference at index 1. The old string 'hello' is no longer referenced by this list (and may be garbage-collected if nothing else references it).

Result

After all operations, my_list contains [42, 'goodbye', 3.14]. Each element is a reference to an object in memory, and Python tracks the type of each object dynamically.

What changes in the list's memory layout when you modify index 1 from 'hello' to 'goodbye'?

Common Mistakes with Data Structures

Common mistake
Assuming all data structures behave the same way
What it looks like
Trying to modify a tuple by assigning a new value to an index: my_tuple[0] = 5
Why it fails
Tuples are immutable. Once created, you cannot change, add, or remove elements. This will raise a TypeError.
Do this instead
Use a list instead if you need to modify elements: my_list = [1, 2, 3]; my_list[0] = 5. Or create a new tuple if you need a modified version: my_tuple = (5, 2, 3).
Common mistake
Forgetting that sets are unordered
What it looks like
Expecting set elements to be in a specific order: my_set = {3, 1, 2}; print(my_set[0])
Why it fails
Sets do not support indexing because they have no guaranteed order. This will raise a TypeError.
Do this instead
If you need ordered access, convert to a list: my_list = list(my_set). Or use a list or tuple from the start if order matters.
Common mistake
Modifying a list while iterating over it
What it looks like
```
for item in my_list: if item == 5: my_list.remove(item)
```
Why it fails
Removing elements during iteration can cause elements to be skipped or the loop to behave unexpectedly.
Do this instead
Iterate over a copy: for item in my_list[:]: if item == 5: my_list.remove(item). Or collect items to remove and remove them after iteration.
Common mistake
Using mutable objects as dictionary keys
What it looks like
```
my_dict = {[1, 2]: 'value'}
```
Why it fails
Lists are mutable and cannot be used as dictionary keys. Python will raise a TypeError because keys must be hashable (immutable).
Do this instead
Use immutable types as keys: my_dict = {(1, 2): 'value'} or my_dict = {'key': 'value'}.
Common mistake
Assuming that adding a duplicate to a set will increase its size
What it looks like
```
my_set = {1, 2, 3}; my_set.add(2); print(len(my_set))
```
Why it fails
Sets only store unique elements. Adding 2 again has no effect because 2 is already in the set. The length remains 3.
Do this instead
Remember that sets automatically enforce uniqueness. If you need duplicates, use a list instead.

Choosing the Right Data Structure

Data Structure	Ordered?	Mutable?	Allows Duplicates?	Best Use Case
List	Yes	Yes	Yes	When you need a flexible, ordered collection that you can modify
Tuple	Yes	No	Yes	When you need a fixed collection or want to use it as a dictionary key
Dictionary	Yes (Python 3.7+)	Yes	Keys must be unique	When you need fast lookup by a meaningful key rather than numeric index
Set	No	Yes	No	When you need to store unique items and perform set operations (union, intersection)

Comparison of Python's core data structures and their characteristics

The choice of data structure directly affects your program's clarity and performance. If you need to frequently look up values by a meaningful identifier, a dictionary is far more natural and efficient than searching through a list. If you need to ensure all items are unique, a set is the right choice. If you need to pass a collection to a function and guarantee it won't be accidentally modified, a tuple is appropriate. Understanding the strengths and constraints of each structure helps you write clearer, more efficient code.

Practice: Identifying and Using Data Structures

MEDIUM

You are building a student grade tracker. You need to store a student's name, their course grades, and whether they have passed or failed. Which data structures would you use, and why? Write a brief description of how you would organize this data.

Hints

Think about what information needs to be stored together and how you will access it.
Consider whether you need to modify the data after creation.
Think about whether you need to look up values by name or by position.

Your attempt (not saved)

EASY

Given a list of numbers [3, 1, 4, 1, 5, 9, 2, 6], how would you find all unique numbers? What data structure would be most efficient, and why?