Learn What a Data Structure Is in Python: Absolute Beginners Tutorial

A data structure is how you organize and store information in a program so you can find it, use it, and change it efficiently. Python gives you four powerful built-in data structures right out of the box: lists, tuples, dictionaries, and sets. This tutorial walks you through each one from scratch, with runnable code and interactive exercises, so you can start using them in your own programs today.

If you have ever stored a value in a variable, you have already worked with data. But variables hold only one piece of information at a time. What happens when you need to track a hundred usernames, a set of unique IP addresses, or a table of configuration settings? That is where data structures come in. They give your data shape, rules, and efficient access patterns so your programs stay fast and organized as they grow.

What Is a Data Structure and Why Does It Matter?

A data structure is a format for organizing, storing, and managing data in computer memory so it can be accessed and used efficiently. Think of it like a filing system. A single sticky note works fine for one phone number, but if you need to manage hundreds of contacts, you need folders, labels, and an organizational system. Data structures are that system for your code.

Every data structure has trade-offs. Some are fast at looking things up but slow at inserting new items. Others are great at preserving order but waste memory on small datasets. Choosing the right one depends on what operations you perform the most in your specific program.

Python comes with four built-in data structures that handle the vast majority of everyday programming tasks: list, tuple, dict, and set. Unlike languages such as Java or C++ where you often import libraries for basic collections, Python includes these as core language features. You can start using them immediately without any imports.

# A single variable holds one value
username = "alice"

# A data structure holds many values in an organized way
usernames = ["alice", "bob", "carol", "dave"]

# You can access any item by its position (index)
print(usernames[0])   # alice
print(usernames[2])   # carol
print(len(usernames)) # 4

In the example above, a plain variable can only hold one username at a time. The list usernames holds four values in a single container, and you can retrieve any one of them by its index position. That is the core value of a data structure: it lets you work with collections of related data as a single unit.

The Four Built-in Data Structures in Python

Python's four built-in data structures each solve a different organizational problem. Understanding what makes each one unique is the first step toward choosing the right tool for any task.

Lists: Ordered and Changeable

A list is an ordered collection of items that you can modify after creation. You create one using square brackets []. Lists allow duplicate values, support mixed data types, and maintain the order in which you add items.

# Creating a list
colors = ["red", "green", "blue"]

# Adding an item to the end
colors.append("yellow")
print(colors)  # ['red', 'green', 'blue', 'yellow']

# Changing an item by index
colors[0] = "crimson"
print(colors)  # ['crimson', 'green', 'blue', 'yellow']

# Removing an item
colors.remove("green")
print(colors)  # ['crimson', 'blue', 'yellow']

Tuples: Ordered and Unchangeable

A tuple looks similar to a list but uses parentheses () instead of square brackets. The critical difference is that tuples are immutable. Once you create one, you cannot add, remove, or change its items. This makes tuples ideal for data that should stay constant, like geographic coordinates or RGB color values.

# Creating a tuple
coordinates = (29.7604, -95.3698)

# Accessing items by index
print(coordinates[0])  # 29.7604
print(coordinates[1])  # -95.3698

# Tuples support unpacking
latitude, longitude = coordinates
print(latitude)   # 29.7604
print(longitude)  # -95.3698

# This would raise a TypeError:
# coordinates[0] = 30.0

Dictionaries: Key-Value Pairs

A dictionary stores data as key-value pairs inside curly braces {}. Instead of accessing items by a numeric index, you look them up by a descriptive key. Keys must be unique and immutable (strings and numbers are common choices). Since Python 3.7, dictionaries preserve insertion order.

# Creating a dictionary
user = {
    "name": "Alice",
    "age": 30,
    "email": "alice@example.com"
}

# Accessing a value by key
print(user["name"])   # Alice

# Adding a new key-value pair
user["role"] = "admin"

# Safely accessing a key that might not exist
print(user.get("phone", "not provided"))  # not provided

# Looping through keys and values
for key, value in user.items():
    print(f"{key}: {value}")

Sets: Unique and Unordered

A set is an unordered collection that automatically discards duplicate values. You create one with curly braces {} or the set() constructor. Sets are excellent for membership testing, removing duplicates from a list, and performing mathematical operations like unions and intersections.

# Creating a set — duplicates are automatically removed
tags = {"python", "beginner", "tutorial", "python"}
print(tags)  # {'python', 'beginner', 'tutorial'}

# Adding an item
tags.add("data-structures")

# Checking membership (very fast)
print("python" in tags)     # True
print("javascript" in tags) # False

# Removing duplicates from a list
raw = [1, 2, 2, 3, 3, 3, 4]
unique = list(set(raw))
print(unique)  # [1, 2, 3, 4]

Mutable vs. Immutable: The Key Distinction

The single most important concept for understanding Python's data structures is mutability. A mutable object can be changed after creation. An immutable object cannot. This distinction affects how you use each data structure, how Python stores it in memory, and whether it can serve as a dictionary key.

Lists, dictionaries, and sets are mutable. You can add items, remove items, or change existing values in place. Tuples and strings are immutable. Any operation that appears to modify them creates an entirely new object instead.

# Mutable: lists can be changed in place
colors = ["red", "green", "blue"]
colors[0] = "crimson"     # this works
print(colors)             # ['crimson', 'green', 'blue']

# Immutable: tuples cannot be changed
dimensions = (1920, 1080)
# dimensions[0] = 2560    # TypeError: 'tuple' does not support item assignment

# Why it matters: only immutable types can be dictionary keys
valid_key = (10, 20)      # tuple — works as a key
coordinates = {valid_key: "office"}
print(coordinates[(10, 20)])  # office

# invalid_key = [10, 20]  # list — would raise TypeError as a key

The distinction between mutable and immutable types shapes how you design functions, pass arguments, and prevent unintended side effects. When a function receives a list as an argument, it receives a reference to the original list. Any changes the function makes to that list are visible to the caller. If you pass a tuple instead, the function cannot modify the original data, which makes your code safer and more predictable.

"Data structures are the fundamental constructs around which you build your programs." — Real Python

Python Learning Summary Points

1. A data structure is a way to organize and store data in memory so it can be accessed and modified efficiently. Python provides four built-in data structures that cover the majority of everyday programming needs.
2. Lists are ordered and mutable. Tuples are ordered and immutable. Dictionaries store key-value pairs with unique keys. Sets store unique, unordered elements.
3. Mutability is the most important distinction. Mutable objects (lists, dicts, sets) can be changed in place. Immutable objects (tuples, strings, frozensets) cannot, and any modification creates a new object.
4. Choosing the right data structure depends on four factors: whether you need key-based access, whether the data needs to change, whether duplicates are allowed, and whether order matters.
5. Since everything in Python is an object, each data structure comes with built-in methods. Using these methods (like .append(), .get(), .add(), and .items()) is the idiomatic way to work with data in Python.

Data structures are the foundation of every Python program. Once you understand lists, tuples, dictionaries, and sets, you have the tools to organize anything from a simple collection of names to a complex configuration system. Practice creating each one, experiment with their methods in the interpreter, and pay attention to how mutability affects your code. The more you use these structures, the more natural the choice between them becomes.