DICTIONARY

A dictionary is a data type in Python that stores data as key-value pairs. Unlike lists, dictionaries use unique keys to access values instead of indices. Dictionaries can be created using the dict() constructor or curly braces {}.

Characteristics of Dictionaries

• A dictionary is an unordered set of key-value pairs.
• Keys are unique and must be immutable (e.g., strings, numbers, tuples).
• Values are mutable and can be of any data type.
• Dictionaries are stored internally as mappings.

Examples of Dictionaries

# Creating a dictionary with student names as keys and marks as values
student = {'Raghav': 89, 'Nitya': 91, 'Asif': 88}
print(student)
# Output: {'Raghav': 89, 'Nitya': 91, 'Asif': 88}
 
# Creating an empty dictionary
dict_marks = {}
# Or
dict_marks = dict()
 
# Creating a nested dictionary
student = {'Raghav': {'Eng': 78, 'Maths': 87}, 'Nitya': {'Eng': 78, 'Maths': 87}}
print(student)
# Output: {'Raghav': {'Eng': 78, 'Maths': 87}, 'Nitya': {'Eng': 78, 'Maths': 87}}

Working with Dictionaries

1. Accessing a Value

Values in a dictionary are accessed using their corresponding keys.

student = {'Raghav': 89, 'Nitya': 91, 'Asif': 88}
print(student['Raghav'])  # Output: 89

2. Accessing Keys

The keys() function retrieves all keys from the dictionary.

print(student.keys())  # Output: dict_keys(['Raghav', 'Nitya', 'Asif'])

3. Accessing Values

The values() function retrieves all values from the dictionary.

print(student.values())  # Output: dict_values([89, 91, 88])

4. Accessing Items

The items() function retrieves all key-value pairs as tuples.

print(student.items())  
# Output: dict_items([('Raghav', 89), ('Nitya', 91), ('Asif', 88)])

5. Membership

The in and not in operators check if a key exists in the dictionary.

print('Nitya' in student)  # Output: True
print('Pihu' not in student)  # Output: True

6. Traversing a Dictionary

Traversing a dictionary means iterating over its key-value pairs.

Method 1:

for key in student:
    print(f"Key= {key} and Value= {student[key]}")
# Output:
# Key= Raghav and Value= 89
# Key= Nitya and Value= 91
# Key= Asif and Value= 88

Method 2:

for key, value in student.items():
    print(f"Key= {key} and Value= {value}")
# Output:
# Key= Raghav and Value= 89
# Key= Nitya and Value= 91
# Key= Asif and Value= 88

7. Adding a New Element

New elements can be added to a dictionary using the assignment operator =.

student['Pihu'] = 90
print(student)
# Output: {'Raghav': 89, 'Nitya': 91, 'Asif': 88, 'Pihu': 90}

8. Updating an Existing Element

If a key already exists, its value can be updated.

student['Pihu'] = 94
print(student)
# Output: {'Raghav': 89, 'Nitya': 91, 'Asif': 88, 'Pihu': 94}

9. Deleting an Element

Use the del statement to remove a key-value pair.

del student['Asif']
print(student)
# Output: {'Raghav': 89, 'Nitya': 91}

Note: If a non-existing key is passed, it raises a KeyError.

Key Notes:

• Keys must be unique and immutable.
• Values can be mutable and of any data type.
• Dictionaries are mutable and efficient for lookups.

Dictionary Built-in Functions

Python provides several built-in functions to work with dictionaries efficiently.

len() - Get the number of key-value pairs

print(len(student))  # Output: 3

get() - Retrieve a value safely

print(student.get('Nitya'))  # Output: 91
print(student.get('Pihu', 'Not Found'))  # Output: Not Found

pop() - Remove and return the value of a key

removed_value = student.pop('Asif')
print(removed_value)  # Output: 88
print(student)  # Output: {'Raghav': 89, 'Nitya': 91}

popitem() - Remove and return the last inserted key-value pair

last_item = student.popitem()
print(last_item)  # Output: ('Nitya', 91)

clear() - Remove all elements from a dictionary

student.clear()
print(student)  # Output: {}

copy() - Create a shallow copy of the dictionary

original = {'a': 1, 'b': 2}
copied = original.copy()
print(copied)  # Output: {'a': 1, 'b': 2}

Understanding Shallow Copy

A shallow copy creates a new dictionary but does not create independent copies of nested mutable objects. If the dictionary contains mutable values (like lists or other dictionaries), both the original and the copied dictionary will share references to those objects.

original = {'a': 1, 'b': [2, 3, 4]}
copied = original.copy()
copied['b'].append(5)
print(original)  # Output: {'a': 1, 'b': [2, 3, 4, 5]}
print(copied)  # Output: {'a': 1, 'b': [2, 3, 4, 5]}

To create a completely independent copy, use deepcopy() from the copy module:

import copy
deep_copied = copy.deepcopy(original)

update() - Merge another dictionary into an existing dictionary

d1 = {'a': 1, 'b': 2}
d2 = {'b': 3, 'c': 4}
d1.update(d2)
print(d1)  # Output: {'a': 1, 'b': 3, 'c': 4}

Try It Yourself

Problem 1: Add and Update a Dictionary

Write a program to create a dictionary of 3 friends’ names and their ages. Add a new friend and update the age of one existing friend.

Problem 2: Count Occurrences of Characters

Write a program to count the occurrences of each character in a given string and store the result in a dictionary.

Problem 3: Use Dictionary Methods

Write a program to create a dictionary, update it with new key-value pairs, and remove an element using built-in methods.