Learn How to Create Labeled Containers in Python: Absolute Beginners Tutorial

Lists use numbers to track items. Dictionaries use names. If you have ever wanted to store data where each value has a meaningful label instead of a position number, Python dictionaries are the tool you need. This tutorial walks you through creating, reading, updating, and looping through labeled containers from the ground up.

When you first start programming, lists are a natural way to group related pieces of data together. You put items in a list, and Python assigns each one a numbered position starting at zero. That works well for ordered sequences, but it falls apart when the position number itself carries no meaning. If you store a person's name at index 0 and their email at index 1, nothing about the number 0 tells you it represents a name. Labeled containers solve this problem by letting you attach a descriptive name to each value.

What Is a Labeled Container?

A labeled container is Python's dict type, short for dictionary. Instead of looking up items by position number, you look them up by a key -- a name you choose that describes the data. Each entry in a dictionary is a key-value pair: the key is the label, and the value is the data attached to that label.

Think of a real dictionary. You look up a word (the key) and find its definition (the value). A Python dictionary works the same way. You look up a key and Python hands back the value paired with it.

Here is a quick comparison to see the difference between a list and a dictionary storing the same student record:

# List approach — positions carry no meaning
student_list = ["Ayumi", 20, "A"]
print(student_list[0])  # "Ayumi" — but 0 tells you nothing

# Dictionary approach — keys describe each value
student_dict = {"name": "Ayumi", "age": 20, "grade": "A"}
print(student_dict["name"])  # "Ayumi" — the label says it all

The dictionary version is self-documenting. Weeks later, when you read student_dict["name"], you know immediately what that value represents without checking a comment or counting positions.

Creating Your First Dictionary

There are two common ways to create a dictionary. The first, and by far the more popular, uses curly braces with colon-separated key-value pairs:

# Curly brace syntax — the standard approach
server = {
    "hostname": "web-prod-01",
    "ip": "10.0.1.42",
    "port": 443,
    "active": True
}
print(server)
# {'hostname': 'web-prod-01', 'ip': '10.0.1.42', 'port': 443, 'active': True}

The second way uses the dict() constructor with keyword arguments. This works only when keys are valid Python identifiers (no spaces or special characters):

# dict() constructor with keyword arguments
server = dict(hostname="web-prod-01", ip="10.0.1.42", port=443, active=True)
print(server)
# {'hostname': 'web-prod-01', 'ip': '10.0.1.42', 'port': 443, 'active': True}

You can also start with an empty dictionary and add pairs later:

# Start empty, then add entries one at a time
inventory = {}
inventory["apples"] = 12
inventory["bananas"] = 6
inventory["oranges"] = 9
print(inventory)
# {'apples': 12, 'bananas': 6, 'oranges': 9}

Reading, Adding, and Removing Data

Once a dictionary exists, you interact with it through square brackets and a handful of built-in methods. Reading a value is straightforward -- supply the key inside square brackets, and Python returns the paired value:

student = {"name": "Ayumi", "age": 20, "grade": "A"}

# Read a value by key
print(student["name"])   # Ayumi
print(student["grade"])  # A

# Safe access with .get() — returns None if key is missing
print(student.get("email"))          # None
print(student.get("email", "N/A"))   # N/A

Adding a new pair uses the same square-bracket syntax. If the key already exists, the value is updated. If it does not exist, a new entry is created:

student = {"name": "Ayumi", "age": 20, "grade": "A"}

# Add a new key-value pair
student["email"] = "ayumi@example.com"

# Update an existing value
student["grade"] = "A+"

print(student)
# {'name': 'Ayumi', 'age': 20, 'grade': 'A+', 'email': 'ayumi@example.com'}

Removing entries can be done with del or the .pop() method. The del keyword removes a pair silently, while .pop() removes it and returns the value so you can use it:

student = {"name": "Ayumi", "age": 20, "grade": "A+", "email": "ayumi@example.com"}

# Remove with del — raises KeyError if key is missing
del student["email"]

# Remove with .pop() — returns the removed value
removed_grade = student.pop("grade")
print(removed_grade)  # A+

# .pop() with a default — no error if key is missing
result = student.pop("phone", "not found")
print(result)  # not found

print(student)
# {'name': 'Ayumi', 'age': 20}

Looping Through a Dictionary

For loops and dictionaries work together naturally. When you loop directly over a dictionary, Python gives you each key one at a time. You can then use that key to grab the corresponding value:

config = {"theme": "dark", "language": "en", "font_size": 14}

# Loop over keys (default behavior)
for key in config:
    print(key, "->", config[key])

# Loop over values only
for value in config.values():
    print(value)

# Loop over both keys and values together
for key, value in config.items():
    print(f"{key}: {value}")

The .items() method is the approach you will use the majority of the time, because it unpacks both the key and value in a single step. The .keys() and .values() methods are available when you only need one half of each pair.

Common Dictionary Methods

Beyond the basics you have already seen, Python dictionaries come with several helpful methods. Here are the ones you will reach for regularly:

colors = {"sky": "blue", "grass": "green", "sun": "yellow"}

# Check if a key exists
print("sky" in colors)       # True
print("ocean" in colors)     # False

# Get the number of key-value pairs
print(len(colors))           # 3

# Merge another dictionary into this one
colors.update({"ocean": "teal", "sky": "azure"})
print(colors)
# {'sky': 'azure', 'grass': 'green', 'sun': 'yellow', 'ocean': 'teal'}

# Remove all entries
colors.clear()
print(colors)                # {}

# Create a shallow copy
original = {"a": 1, "b": 2}
copy = original.copy()
copy["c"] = 3
print(original)  # {'a': 1, 'b': 2} — original unchanged
print(copy)      # {'a': 1, 'b': 2, 'c': 3}

Notice that .update() both adds new keys and overwrites existing ones. In the example above, "sky" changed from "blue" to "azure" because the same key appeared in the dictionary passed to .update().

"Dictionaries are the building blocks of Python itself." — Python Documentation (paraphrased)

Python Learning Summary Points

1. A Python dictionary is a labeled container that stores data as key-value pairs, accessed by descriptive key names rather than numbered positions.
2. Create dictionaries with curly braces {} or the dict() constructor, and add or update entries using square bracket notation.
3. Use .get() for safe access that avoids KeyError, and .pop() to remove a pair while capturing the removed value.
4. Loop through dictionaries with .items() to unpack both keys and values, .keys() for just keys, or .values() for just values.
5. Dictionary keys must be immutable types (strings, numbers, tuples), while values can be any Python object with no restrictions.
6. Since Python 3.7, dictionaries preserve insertion order, so pairs are returned in the same sequence they were added.

Dictionaries are one of the foundational data structures in Python, and understanding how to create and use them opens the door to working with configuration files, API responses, database records, and nearly every other structured data format you will encounter as you continue learning.