Dictionary Basics

Why Python Has No Switch Statement

Many programming languages have a switch statement that lets you branch to different code paths based on a single value. Python does not have a switch statement. Instead, you can use an if..elif..else statement to accomplish the same goal. However, there is a third option that is often faster and cleaner: a dictionary.

This lesson introduces dictionaries as a practical alternative to branching logic. You will learn what a dictionary is, how it stores information, and when to reach for it instead of writing multiple conditional statements.

What Is a Dictionary?

A dictionary is one of Python's four built-in data structures (the others being list, tuple, and set). A dictionary works like a real-world address book: you look up a person by their name and get their contact details. In a dictionary, you associate keys (like names) with values (like details). The key must be unique, just as you cannot find the correct information if two people have the exact same name.

Dictionary Lookup vs. If-Elif-Else Branching

To understand why dictionaries matter, consider how a program makes decisions. When you write if..elif..else statements, the program checks each condition in order until one is true, then executes that branch. This is sequential: the program must evaluate conditions one by one. A dictionary lookup, by contrast, goes directly to the value associated with a key. The program does not check multiple conditions; it simply retrieves the value in a single step.

This difference becomes significant when you have many conditions to check. With if..elif..else, the program might need to evaluate ten or twenty conditions before finding a match. With a dictionary, the lookup is nearly instantaneous regardless of how many key-value pairs exist.

How Dictionary Lookup Works

When you provide a key to a dictionary, Python uses an internal mechanism called hashing to find the associated value. The key is transformed into a hash value, which points to a location in memory where the value is stored. This process is extremely fast, even for dictionaries with thousands of entries.

Worked Example: Contact Lookup

Dictionary vs. If-Elif-Else in Practice

Consider a program that translates color names to their hexadecimal codes. You could write this with if..elif..else or with a dictionary. Here is how the two approaches differ in structure and readability.

# Approach 1: If-Elif-Else
color_name = "red"

if color_name == "red":
    hex_code = "#FF0000"
elif color_name == "green":
    hex_code = "#00FF00"
elif color_name == "blue":
    hex_code = "#0000FF"
elif color_name == "yellow":
    hex_code = "#FFFF00"
else:
    hex_code = "#000000"

print(hex_code)

#FF0000

# Approach 2: Dictionary
color_codes = {
    "red": "#FF0000",
    "green": "#00FF00",
    "blue": "#0000FF",
    "yellow": "#FFFF00"
}

color_name = "red"
hex_code = color_codes[color_name]

print(hex_code)

#FF0000

Both approaches produce the same output. However, the dictionary approach is more concise and scales better. If you need to add ten more colors, the dictionary grows by ten lines (one per key-value pair), while the if..elif..else approach grows by ten elif blocks. Additionally, the dictionary lookup is faster because Python does not need to evaluate multiple conditions.

Common Mistakes with Dictionaries

• Using a non-unique key

  The second assignment overwrites the first. The dictionary will contain only one entry with key "name" and value "Bob". You lose the first value.

  Fix: Ensure each key is unique. If you need to store multiple people, use different keys or a different data structure like a list of dictionaries.

• Accessing a key that does not exist

  Python raises a KeyError because the key "age" does not exist in the dictionary. The program crashes.

  Fix: Check if the key exists before accessing it, or use the .get() method which returns None (or a default value) if the key is not found.

• Forgetting that keys must be unique

  A dictionary can only store one value per key. If you need multiple values for the same key, use a list or a different data structure.

  Fix: Use a list of dictionaries or a dictionary with a list as the value if you need to associate multiple values with a single key.

• Using a mutable object as a key

  Lists are mutable and cannot be used as dictionary keys. Python raises a TypeError. Only immutable objects (strings, numbers, tuples) can be keys.

  Fix: Use immutable objects as keys. If you need a compound key, use a tuple instead of a list.

When to Use a Dictionary

Use a dictionary when you need to look up a value by a meaningful key, especially if you have many possible keys. Dictionaries are ideal for storing configuration settings, translating between codes, mapping names to values, or any situation where you would otherwise write a long if..elif..else chain.

Do not use a dictionary if you need to preserve order in a specific way (though modern Python dictionaries do preserve insertion order), or if you need to store data that does not fit the key-value model. For example, if you have a list of numbers and need to access them by position, use a list, not a dictionary.

Practice: Build Your Own Dictionary

Summary

1. Python has no switch statement, but you can use if..elif..else or a dictionary to branch based on a value.
2. A dictionary stores key-value pairs, where keys must be unique and are used to look up values.
3. Dictionary lookup is faster than if..elif..else because Python goes directly to the value instead of checking multiple conditions sequentially.
4. Use a dictionary when you need to map meaningful keys to values, especially if you have many possible keys.
5. Keys must be unique and immutable (strings, numbers, tuples). Attempting to access a non-existent key raises a KeyError.