We can use List, Tuple and Set to represent a group of individual objects as a single entity.

If we want to represent a group of objects as key-value pairs, then we should use a Dictionary.

A Dictionary is one of Python's built-in collection data types.

Some common examples of Dictionary are:

• Roll Number → Student Name
• Phone Number → Address
• IP Address → Domain Name

A Dictionary has the following characteristics:

• Data is stored as key-value pairs.
• Duplicate keys are not allowed.
• Duplicate values are allowed.
• Heterogeneous objects are allowed for both keys and values.
• Insertion order is not preserved.
• Dictionary objects are mutable.
• Dictionary objects are dynamic.
• Indexing and slicing are not applicable.

Note: In C++ and Java, a Dictionary is known as a Map, whereas in Perl and Ruby, it is known as a Hash.

Every element in a Dictionary consists of two parts:

• A Key
• A Value

A Dictionary cannot contain duplicate keys.

If we insert an entry with an existing key, the old value is replaced by the new value.

The key 101 already exists in the Dictionary.

Therefore, its old value "durga" is replaced with "sunny".

Unlike keys, duplicate values are allowed in a Dictionary.

A Dictionary can store different types of keys and values.

A Dictionary does not preserve the insertion order.

Therefore, the output order may be different from the insertion order.

Dictionary objects are mutable.

After creating a Dictionary, we can:

• Add new key-value pairs.
• Modify existing values.
• Remove key-value pairs.

The size of a Dictionary can be increased or decreased whenever required.

Dictionary elements are accessed using keys, not indexes.

Therefore:

• Indexing is not supported.
• Slicing is not supported.

There are different ways to create Dictionary objects in Python.

We can create an empty Dictionary in two ways.

After creating an empty Dictionary, we can add key-value pairs one by one.

If the data is already known, we can directly create a Dictionary.

Topic	Description
Dictionary	Collection of key-value pairs.
Duplicate Keys	Not Allowed.
Duplicate Values	Allowed.
Heterogeneous Keys	Allowed.
Heterogeneous Values	Allowed.
Insertion Order	Not Preserved.
Mutable	Yes.
Dynamic	Yes.
Indexing	Not Supported.
Slicing	Not Supported.
Empty Dictionary	{} or dict()
Dictionary with Data	{key: value}

• A Dictionary stores data as key-value pairs.
• Duplicate keys are not allowed.
• If a duplicate key is inserted, the old value is replaced with the new value.
• Duplicate values are allowed.
• Heterogeneous keys and values are allowed.
• Dictionary objects are mutable.
• Dictionary objects are dynamic.
• Dictionaries do not support indexing and slicing.
• An empty Dictionary can be created by using {} or dict().
• If the data is already known, a Dictionary can be created directly by using {key: value} syntax.
• In C++ and Java, a Dictionary is called a Map.
• In Perl and Ruby, a Dictionary is called a Hash.

Dictionary elements are accessed by using keys.

Unlike Lists and Tuples, Dictionary objects do not support indexing and slicing.

If the specified key is available, Python returns the corresponding value.

If the key is not available, Python raises a KeyError.

The Dictionary searches for the specified key.

If the key exists, the corresponding value is returned.

If we try to access a key that is not present in the Dictionary, Python raises a KeyError.

This error indicates that the specified key does not exist.

Before accessing a value, we can check whether the key is available in the Dictionary.

In Python 3, the recommended approach is to use the in operator.

In Python 2, the has_key() method was used to check whether a key exists.

This method has been removed from Python 3.

In Python 3, always use the in operator.

We can add a new key-value pair simply by assigning a value to a new key.

If the key does not exist, a new entry is created.

Initially the Dictionary is empty.

Each assignment creates a new key-value pair.

If the specified key already exists, assigning a new value updates the existing value.

No duplicate key is created.

The key 200 already exists.

Therefore, only its value is updated.

The following program stores student details in a Dictionary.

The Roll Number is used as the key and the Student Name is used as the value.

Operation	Description
Access Value	Use the key.
Missing Key	Raises KeyError.
Check Key	Use in operator.
Add New Entry	Assign a value to a new key.
Update Value	Assign a new value to an existing key.
Duplicate Key	Old value is replaced.

• Dictionary elements are accessed using keys.
• Indexing and slicing are not supported.
• If a key is not present, Python raises KeyError.
• Use the in operator to check whether a key exists.
• The has_key() method is available only in Python 2.
• Assigning a value to a new key creates a new entry.
• Assigning a value to an existing key updates the existing value.
• Duplicate keys are not created.
• The Dictionary size increases automatically when new entries are added.
• Dictionary objects are mutable and dynamic.

Python provides several built-in functions and methods to work with Dictionary objects.

In this part, we will learn the following:

• dict()
• len()
• get()
• pop()
• popitem()

The dict() function is used to create a Dictionary object.

It creates an empty Dictionary if no argument is provided.

It can also convert suitable objects into a Dictionary.

The len() function returns the total number of key-value pairs available in a Dictionary.

The get() method returns the value associated with the specified key.

If the key is not available, it returns None instead of raising a KeyError.

• Prevents KeyError.
• Returns None if the key is not available.
• A custom default value can also be returned.

The pop() method removes the specified key from the Dictionary.

It also returns the corresponding value.

If the key is not available, Python raises a KeyError.

• Removes the specified key-value pair.
• Returns the removed value.
• Raises KeyError if the key is not available.

The popitem() method removes and returns one key-value pair from the Dictionary.

The returned value is in the form of a tuple.

The removed item is returned as a tuple containing the key and its corresponding value.

The Dictionary is modified after removing the item.

Function / Method	Purpose
dict()	Create a Dictionary.
len()	Returns the number of key-value pairs.
get()	Returns the value safely.
pop()	Removes the specified key and returns its value.
popitem()	Removes and returns one key-value pair.

These Dictionary functions are commonly used in:

• Student management systems.
• Employee databases.
• Configuration files.
• API response processing.
• Inventory management applications.

• dict() creates a Dictionary.
• len() returns the total number of key-value pairs.
• get() is safer than using square brackets because it does not raise KeyError.
• get() can return a custom default value.
• pop() removes a specified key and returns its value.
• popitem() removes and returns one key-value pair as a tuple.
• Both pop() and popitem() modify the original Dictionary.

Method	Description
dict()	Create a Dictionary.
len()	Count key-value pairs.
get()	Return a value safely.
pop()	Remove a specified key.
popitem()	Remove one key-value pair.

Python provides several advanced Dictionary methods to access keys, values, items and to modify Dictionary objects.

In this part, we will learn:

• keys()
• values()
• items()
• copy()
• setdefault()
• update()

The keys() method returns all keys present in the Dictionary.

The returned object can be used for iteration.

The values() method returns all values present in the Dictionary.

The items() method returns all key-value pairs.

Each item is returned as a tuple.

Method	Returns
keys()	All keys.
values()	All values.
items()	Key-value pairs as tuples.

The copy() method creates a copy of the Dictionary.

The copied Dictionary is a new object.

The original Dictionary remains unchanged.

The setdefault() method returns the value associated with the specified key.

If the key is not available, it inserts the key with the specified default value and returns that value.

• If the key exists, its value is returned.
• If the key does not exist, a new key-value pair is created.
• The method returns the corresponding value.

The update() method adds multiple key-value pairs from another Dictionary.

If a key already exists, its value is updated.

The key 200 already exists in the first Dictionary.

Therefore, its value is updated.

The remaining key-value pairs are added as new entries.

Method	Purpose
keys()	Returns all keys.
values()	Returns all values.
items()	Returns key-value pairs.
copy()	Creates a copy of the Dictionary.
setdefault()	Returns a value or inserts a new key.
update()	Adds or updates multiple key-value pairs.

These methods are commonly used in:

• Student information systems.
• Inventory management.
• Employee databases.
• API response processing.
• Configuration management.

• keys() returns all keys.
• values() returns all values.
• items() returns key-value pairs as tuples.
• copy() creates a new Dictionary object.
• setdefault() adds a new key only if it is not already present.
• update() adds new entries and updates existing ones.
• update() modifies the original Dictionary.
• copy() does not modify the original Dictionary.

Method	Description
keys()	Returns all keys.
values()	Returns all values.
items()	Returns key-value pairs.
copy()	Creates a copy.
setdefault()	Returns or inserts a value.
update()	Adds or updates entries.

We can traverse a Dictionary by using a for loop.

By default, when we iterate over a Dictionary, only the keys are returned.

If we want the corresponding values, we can access them by using the key.

The for loop traverses the Dictionary.

By default, each iteration returns only the key.

The values are not displayed unless they are accessed explicitly.

We can use the keys() method to traverse all keys present in the Dictionary.

The keys() method returns a view object containing all keys.

The keys() method returns all keys in the Dictionary.

The for loop prints each key one by one.

We can use the values() method to traverse all values present in the Dictionary.

The values() method returns a view object containing all values.

The values() method returns all values stored in the Dictionary.

The for loop prints each value one by one.

We can use the items() method to traverse both keys and values together.

The items() method returns key-value pairs as tuples.

The items() method returns each Dictionary item as a tuple.

The first variable stores the key and the second variable stores the corresponding value.

This is the most commonly used method for traversing a Dictionary when both keys and values are required.

Method	Returns	Best Use
for k in d	Keys	Traverse only keys.
d.keys()	All keys	Display or process only keys.
d.values()	All values	Display or process only values.
d.items()	Key-value tuples	Access both keys and values together.

Dictionary traversal is commonly used in:

• Displaying student records.
• Processing employee information.
• Reading configuration settings.
• Generating reports.
• Processing API response data.

• By default, iterating over a Dictionary returns only the keys.
• keys() returns all keys in the Dictionary.
• values() returns all values in the Dictionary.
• items() returns key-value pairs as tuples.
• items() is the best choice when both keys and values are required.
• Dictionary traversal is performed by using a for loop.

Traversal	Description
for k in d	Traverses keys.
d.keys()	Returns all keys.
d.values()	Returns all values.
d.items()	Returns key-value pairs as tuples.

In many real-world applications, we need to calculate the total of all numeric values stored in a Dictionary.

Python provides the built-in sum() function, which makes this task very simple.

In this program, the Dictionary is entered from the keyboard, and the sum of all its values is displayed.

Write a Python program to take a Dictionary from the keyboard and print the sum of all its values.

Let us understand the program step by step.

• input() reads the Dictionary as a string.
• eval() converts the entered string into an actual Dictionary object.
• The Dictionary is stored in the variable d.

No output captured.

The values() method returns all values present in the Dictionary.

No output captured.

The sum() function adds all numeric values returned by d.values().

The result is stored in the variable s.

No output captured.

Step	Operation
1	Read the Dictionary from the keyboard.
2	Retrieve all values using values().
3	Calculate the total using sum().
4	Display the final sum.

This program is useful in many real-world situations.

• Calculating total student marks.
• Finding the total salary of employees.
• Calculating total sales.
• Summing product quantities.
• Preparing reports.

• values() returns all values stored in the Dictionary.
• sum() adds all numeric values.
• The values must be numeric (int or float).
• eval() converts the entered string into a Dictionary object.
• The returned value of sum() is stored in a variable before printing.

Statement	Purpose
eval(input())	Reads a Dictionary from the keyboard.
d.values()	Returns all values.
sum()	Calculates the total of all values.
print()	Displays the result.

One of the most common applications of a Dictionary is counting the frequency of characters in a string.

In this program, each character is stored as a key and its number of occurrences is stored as the corresponding value.

If the character already exists in the Dictionary, its count is increased by 1. Otherwise, a new key is created with the value 1.

Write a Python program to count the occurrence of each character present in a given string by using a Dictionary.

Let us understand the program step by step.

The input() function reads a string from the keyboard and stores it in the variable word.

No output captured.

The Dictionary d is initially empty.

It will store:

• Character → Key
• Frequency → Value

The for loop reads one character at a time from the string.

Each character is processed individually.

The get() method checks whether the character already exists in the Dictionary.

• If the character exists, its current count is returned.
• If the character does not exist, 0 is returned.
• Then 1 is added to the count.

This statement creates a new entry for a new character and updates the count for an existing character.

The items() method returns all key-value pairs.

The first variable stores the character and the second variable stores its frequency.

The program prints the frequency of every character.

Step	Operation
1	Read the input string.
2	Create an empty Dictionary.
3	Traverse every character.
4	Increase the character count using get().
5	Display all characters and their frequencies.

This program is useful in many applications such as:

• Word frequency analysis.
• Text processing.
• Search engines.
• Natural Language Processing (NLP).
• Data analysis.
• Password strength checking.

Statement	Purpose
input()	Read the input string.
{}	Create an empty Dictionary.
for ch in word	Traverse each character.
get(ch, 0)	Return the current count or 0.
items()	Return all key-value pairs.

• A Dictionary is used to store character-frequency pairs.
• Each character acts as a key.
• The occurrence count acts as the value.
• get(ch, 0) prevents KeyError.
• The count is increased by one every time the character appears.
• items() is used to print both the character and its frequency.
• This is one of the most important Dictionary interview programs.

Dictionary is one of the best data structures for storing data as key-value pairs.

In this program, the student name is stored as the key and the student marks are stored as the corresponding value.

The program allows the user to search for the marks of any student by entering the student's name.

Write a Python program to store student names and marks in a Dictionary and display the marks based on the student name entered by the user.

• An empty Dictionary is created.
• Student names are stored as keys.
• Student marks are stored as values.
• The get() method searches for the student's marks.
• If the student name is not found, "Student Not Found" is displayed.
• The user can search repeatedly until No is entered.

Comprehension concept is applicable for Dictionaries also.

Dictionary Comprehension provides a simple and compact way to create Dictionary objects.

The Dictionary stores:

• Key → Number
• Value → Square of that number

The Dictionary stores:

• Key → Number
• Value → Double of that number

Topic	Description
Dictionary	Collection of key-value pairs.
Duplicate Keys	Not Allowed.
Duplicate Values	Allowed.
Heterogeneous Keys	Allowed.
Heterogeneous Values	Allowed.
Insertion Order	Not Preserved.
Mutable	Yes.
Dynamic	Yes.
Indexing	Not Supported.
Slicing	Not Supported.
Access Data	Using Keys.
get()	Returns the value for a key or a default value.
len()	Returns the number of key-value pairs.
pop()	Removes the specified key and returns its value.
popitem()	Removes and returns an arbitrary key-value pair.
keys()	Returns all keys.
values()	Returns all values.
items()	Returns all key-value pairs.
copy()	Creates a cloned copy.
setdefault()	Adds a key if it does not exist.
update()	Copies items from another Dictionary.
Dictionary Comprehension	Supported.

• A Dictionary stores data as key-value pairs.
• Duplicate keys are not allowed.
• Duplicate values are allowed.
• Dictionary objects are mutable.
• Dictionary objects are dynamic.
• Dictionary elements are accessed by using keys, not indexes.
• The get() method prevents KeyError by returning a default value when the key is not found.
• keys(), values() and items() are commonly used while traversing a Dictionary.
• setdefault() adds a new key only if it is not already present.
• update() copies all key-value pairs from another Dictionary.
• Python supports Dictionary Comprehension.
• Dictionary Comprehension provides a compact way to create Dictionary objects from iterable objects.