Dictionary Introduction and Basic Operations

Introduction

In Python, a Dictionary is one of the most powerful and commonly used built-in data structures. Unlike lists and tuples, which store elements in a sequential order and access them using numerical index positions, dictionaries store information in the form of key-value pairs. Each key acts as a unique identifier that is associated with a particular value.

A dictionary is known as a mapping data type because it maps one piece of information (the key) to another piece of information (the value). Instead of searching through an entire collection to find data, Python directly uses the key to retrieve its corresponding value, making dictionary operations extremely fast and efficient.

Dictionaries are widely used in real-world software development because most data naturally exists in key-value form. For example, a student's roll number maps to their name, an employee ID maps to employee information, a country's code maps to its name, or a username maps to a user's profile.

Unlike lists, dictionaries do not rely on the position of elements. The order of keys is not important when retrieving values because access is always performed using the corresponding key rather than an index.

Creating Dictionaries

Dictionaries are created using curly braces { }. Every element inside the dictionary consists of a key followed by a colon (:) and its corresponding value. Multiple key-value pairs are separated by commas.

The general syntax of a dictionary is:

dictionary_name = {
    key1 : value1,
    key2 : value2,
    key3 : value3
}

Each key should be unique because duplicate keys are not allowed. If the same key appears multiple times, Python keeps only the last assigned value.

Example 1: Creating a Dictionary

student = {
    "name": "John",
    "age": 21,
    "courses": [
        "Math",
        "CS"
    ]
}

print(student)

Output

Understanding the Example

• "name" is the key and "John" is its value.
• "age" stores an integer value.
• "courses" stores an entire list as its value.
• A dictionary can store different data types simultaneously.

Example 2: Different Types of Values

employee = {
    "name": "Alice",
    "age": 30,
    "salary": 50000,
    "married": False,
    "skills": ["Python", "SQL"],
    "address": {
        "city": "Delhi",
        "pin": 110001
    }
}

print(employee)

This example demonstrates that a dictionary can store values of different data types simultaneously, including another dictionary. Such dictionaries are known as nested dictionaries.

Accessing and Modifying Key-Values

One of the biggest advantages of a dictionary is that values can be accessed directly using their corresponding keys. Unlike lists, where elements are accessed using numerical indexes, dictionaries use unique keys to retrieve values. This makes searching much faster because Python directly locates the required value instead of checking every element one by one.

To access a value, write the dictionary name followed by the key inside square brackets []. Python searches for the key and returns its corresponding value.

Syntax for Accessing Values

dictionary_name[key]

Example 1: Accessing Values

student = {
    "name": "John",
    "age": 21,
    "city": "Delhi"
}

print(student["name"])
print(student["age"])

Output

Step-by-Step Execution

1. Python searches for the key "name".
2. It finds the value "John".
3. The value is returned and printed.
4. The same process is repeated for the key "age".

Modifying Existing Values

Dictionaries are mutable, meaning their contents can be changed after creation. To update an existing value, assign a new value to an existing key.

student = {
    "name": "John",
    "age": 21
}

student["age"] = 22

print(student)

Output

Here, Python finds the key "age" and replaces its old value (21) with the new value (22). The key itself remains unchanged.

Adding New Key-Value Pairs

If the specified key does not already exist in the dictionary, Python automatically creates a new key-value pair.

student = {
    "name": "John",
    "age": 21
}

student["city"] = "New York"

print(student)

Output

Since the key "city" was not present, Python created a new entry automatically.

Updating Multiple Values

student = {
    "name": "John",
    "age": 21,
    "city": "Delhi"
}

student["age"] = 22
student["city"] = "Mumbai"

print(student)

Accessing Nested Dictionaries

Dictionaries can contain other dictionaries as values. Such dictionaries are called nested dictionaries. To access a nested value, specify each key one after another.

student = {
    "name": "John",
    "address": {
        "city": "Delhi",
        "pin": 110001
    }
}

print(student["address"]["city"])

Accessing a Non-Existing Key

If you try to access a key that does not exist using square brackets, Python raises a KeyError.

student = {
    "name": "John"
}

print(student["age"])

To avoid this error, Python provides the get() method, which safely returns a default value if the key is missing. This method is discussed later in this chapter.

Rules for Keys

A dictionary stores data in the form of key-value pairs. Since every value is identified using its key, Python follows certain rules while creating dictionary keys. Understanding these rules is important because many programming errors occur due to incorrect key usage.

A key acts as the unique identifier of its corresponding value. Therefore, every key must satisfy specific conditions so that Python can locate values quickly and efficiently.

Rule 1: Keys Must Be Unique

Every key in a dictionary must be unique. If the same key is written more than once, Python keeps only the last assigned value and automatically replaces the previous one.

student = {
    "name": "John",
    "name": "David"
}

print(student)

Since the key "name" appears twice, Python ignores the first value and stores only the last one.

Rule 2: Keys Must Be Immutable

Immutable objects are objects whose values cannot change after creation. Python allows only immutable objects to be used as dictionary keys because their values remain constant throughout program execution.

marks = {
    101: "Ankit",
    102: "Rahul",
    True: "Present"
}

print(marks)

Rule 3: Mutable Objects Cannot Be Keys

Lists, dictionaries and sets are mutable because their contents can change after creation. Therefore, Python does not allow them to be used as dictionary keys.

data = {
    [1,2,3] : "Numbers"
}

Rule 4: Values Can Be Repeated

Unlike keys, values are not required to be unique. Multiple keys can store exactly the same value.

marks = {
    "Math": 95,
    "Physics": 95,
    "Chemistry": 95
}

print(marks)

Here, three different keys store the same value (95). This is perfectly valid.

Rule 5: Keys Are Case-Sensitive

Python treats uppercase and lowercase letters differently. Therefore, two keys differing only in case are considered completely different keys.

student = {
    "Name": "John",
    "name": "David"
}

print(student)

Common Dictionary Methods

Python provides several built-in methods that make working with dictionaries easier. These methods help programmers retrieve keys, values, complete key-value pairs, safely access missing data, update dictionaries, and perform many other useful operations.

Among these methods, the most commonly used in university examinations and practical programming are:

• keys()
• values()
• items()
• get()

1. keys() Method

The keys() method returns a view object containing all the keys present in the dictionary. It is useful when you need to iterate through every key.

info = {
    "brand": "Ford",
    "model": "Mustang",
    "year": 2024
}

print(info.keys())

2. values() Method

The values() method returns all the values stored in a dictionary.

info = {
    "brand": "Ford",
    "model": "Mustang",
    "year": 2024
}

print(info.values())

3. items() Method

The items() method returns every key-value pair as a tuple inside a view object. It is commonly used while traversing dictionaries using loops.

info = {
    "brand": "Ford",
    "model": "Mustang"
}

print(info.items())

4. get() Method

The get() method is used to safely retrieve the value associated with a key. Unlike square bracket notation ([]), it does not generate a KeyError if the key is missing. Instead, it returns None or a default value specified by the programmer.

Syntax

dictionary.get(key)

dictionary.get(key, default_value)

Example

info = {
    "brand": "Ford",
    "model": "Mustang"
}

print(info.get("brand"))
print(info.get("year"))
print(info.get("year", 2024))

Output

5. update() Method

The update() method inserts new key-value pairs or updates existing ones. If a key already exists, its value is replaced; otherwise, a new key is created.

student = {
    "name": "John",
    "age": 21
}

student.update({
    "age": 22,
    "city": "Delhi"
})

print(student)

6. pop() Method

The pop() method removes a specific key from the dictionary and returns its corresponding value.

student = {
    "name": "John",
    "age": 21
}

age = student.pop("age")

print(age)
print(student)

7. popitem() Method

The popitem() method removes and returns the last inserted key-value pair from the dictionary.

student = {
    "name": "John",
    "age": 21,
    "city": "Delhi"
}

print(student.popitem())
print(student)

8. clear() Method

The clear() method removes all key-value pairs from a dictionary, leaving it empty.

student = {
    "name": "John",
    "age": 21
}

student.clear()

print(student)

9. copy() Method

The copy() method creates a shallow copy of a dictionary. The copied dictionary contains the same key-value pairs but is a separate object.

student = {
    "name": "John",
    "age": 21
}

new_student = student.copy()

print(new_student)

Summary

A dictionary is one of Python's most powerful and flexible data structures. It stores information as key-value pairs, making it possible to retrieve data quickly using unique keys instead of numerical indexes.

Dictionaries are mutable, meaning their contents can be modified after creation. You can add new key-value pairs, update existing values, remove entries, or safely retrieve values using built-in methods such as get().

Keys must always be unique and immutable, while values can be of any data type and may be repeated. Because of their fast lookup capability, dictionaries are widely used in real-world software such as databases, web applications, APIs, configuration files, and machine learning projects.