Python Dictionaries: Complete Guide for Beginners

In the previous section, you learned about Python sets and frozensets, which store collections of unique values. However, many real-world applications require storing information in pairs, where one value identifies another. For example, a student’s roll number identifies the student’s name, a product ID identifies its price, and a username identifies an email address. Python provides a powerful built-in data structure called a dictionary to store this type of information.

A dictionary stores data as key-value pairs, making it one of the most useful and frequently used data structures in Python. Dictionaries are widely used in web development, data analysis, machine learning, APIs, automation, configuration files, and database applications because they provide fast and efficient data retrieval using keys.

In this lesson, you will learn what Python dictionaries are, why they are useful, how to create them, understand their characteristics, learn the rules for keys and values, and explore practical examples from real-world programming.

Learning Objectives

After completing this lesson, you will be able to:

• Understand Python dictionaries.
• Explain key-value pairs.
• Create dictionaries using different methods.
• Understand the rules for dictionary keys and values.
• Create empty dictionaries.
• Identify practical applications of dictionaries.
• Avoid common beginner mistakes.

Understanding Python Dictionaries

A dictionary is a mutable collection that stores data as key-value pairs. Every key is unique and is associated with exactly one value. Instead of using numeric indexes like lists or tuples, dictionaries use keys to access values.

Dictionaries are ideal for representing structured information where each piece of data has a meaningful name.

Why Use Dictionaries?

Dictionaries make programs easier to read because values are accessed using descriptive keys rather than numeric indexes.

Common applications include:

• Student records.
• Employee information.
• Customer details.
• Product catalogs.
• User profiles.
• Configuration settings.
• JSON and API responses.

Characteristics of Dictionaries

• Store data as key-value pairs.
• Keys must be unique.
• Values may be duplicated.
• Dictionaries are mutable.
• Keys must be immutable data types.
• Dictionaries preserve insertion order.

Creating Python Dictionaries

Dictionaries are created using curly braces {} with keys and values separated by a colon (:).

Creating a Dictionary Using Curly Braces

student = {
    "name": "Rahul",
    "roll_no": 101,
    "course": "BCA",
    "marks": 92
}

print(student)

Output

{'name': 'Rahul', 'roll_no': 101, 'course': 'BCA', 'marks': 92}

Each key uniquely identifies its corresponding value.

Creating a Dictionary Using the dict() Function

student = dict(
    name="Rahul",
    roll_no=101,
    course="BCA",
    marks=92
)

print(student)

Output

{'name': 'Rahul', 'roll_no': 101, 'course': 'BCA', 'marks': 92}

Creating an Empty Dictionary

student = {}

print(student)

print(type(student))

Output

{}

<class 'dict'>

Empty curly braces create an empty dictionary.

Dictionary Keys Must Be Unique

If duplicate keys are provided, the last value replaces the earlier value.

student = {
    "name": "Rahul",
    "name": "Amit",
    "marks": 90
}

print(student)

Output

{'name': 'Amit', 'marks': 90}

The second name key overwrites the first because keys must be unique.

Dictionary Values Can Be Duplicated

students = {
    "student1": 85,
    "student2": 85,
    "student3": 90
}

print(students)

Output

{'student1': 85, 'student2': 85, 'student3': 90}

Unlike keys, values may be repeated.

Valid Dictionary Keys

Dictionary keys must be immutable. Common valid key types include:

• Strings
• Integers
• Floats
• Booleans
• Tuples (containing immutable values)

data = {
    "name": "Rahul",
    101: "Student ID",
    True: "Active"
}

print(data)

Invalid Dictionary Keys

Mutable objects such as lists, sets, and dictionaries cannot be used as dictionary keys.

data = {
    ["Python"]: "Programming"
}

Output

TypeError:
unhashable type: 'list'

Real-World Examples

Example 1: Student Record

student = {
    "name": "Rahul",
    "course": "BCA",
    "marks": 92
}

print(student)

Output

{'name': 'Rahul', 'course': 'BCA', 'marks': 92}

Example 2: Product Information

product = {
    "id": 1001,
    "name": "Laptop",
    "price": 55000
}

print(product)

Output

{'id': 1001, 'name': 'Laptop', 'price': 55000}

Execution Flow

Consider the following program.

employee = {
    "name": "Neha",
    "department": "HR",
    "salary": 50000
}

print(employee)

Execution Steps

1. Python reads each key-value pair.
2. A dictionary object is created.
3. Each key is associated with its corresponding value.
4. The dictionary is stored in memory.
5. The complete dictionary is displayed.

Output

{'name': 'Neha', 'department': 'HR', 'salary': 50000}

Common Beginner Mistakes

• Using duplicate keys and expecting both values to be stored.
• Trying to use lists or dictionaries as keys.
• Confusing dictionary keys with list indexes.
• Assuming dictionary values must be unique.
• Using parentheses instead of curly braces when creating dictionaries.

Chunk Summary

In this section, you learned what Python dictionaries are, why they are useful, their characteristics, how to create dictionaries using curly braces and the dict() function, the rules for dictionary keys and values, and how dictionaries are used in real-world applications. You also explored execution flow and common beginner mistakes. In the next section, you will learn how to access dictionary values, add and update key-value pairs, remove items, loop through dictionaries, perform membership testing, and apply these techniques in practical Python programs.

In the previous section, you learned how to create Python dictionaries and understand their structure using key-value pairs. Once a dictionary has been created, you can access values, add new key-value pairs, update existing data, remove items, iterate through the dictionary, and check whether a key exists. These operations make dictionaries one of the most flexible and widely used data structures in Python.

In this section, you will learn how to work with dictionary data using practical examples and understand how these operations are applied in real-world Python programs.

Working with Dictionary Items

Python provides several ways to access, add, update, and remove data from a dictionary. Since dictionaries use keys instead of numeric indexes, every operation is performed using the corresponding key.

Accessing Values Using Square Brackets

The most common way to access a value is by using its key inside square brackets.

student = {
    "name": "Rahul",
    "course": "BCA",
    "marks": 92
}

print(student["name"])

print(student["marks"])

Output

Rahul

92

If the specified key does not exist, Python raises a KeyError.

print(student["age"])

Output

KeyError: 'age'

Accessing Values Using get()

The get() method safely returns the value for a given key. If the key does not exist, it returns None or a default value.

student = {
    "name": "Rahul",
    "marks": 92
}

print(student.get("name"))

print(student.get("age"))

Output

Rahul

None

You can also specify a default value.

print(student.get("age", "Not Available"))

Output

Not Available

Adding a New Key-Value Pair

Assign a value to a new key to add an item to the dictionary.

student = {
    "name": "Rahul"
}

student["course"] = "BCA"

student["marks"] = 92

print(student)

Output

{'name': 'Rahul', 'course': 'BCA', 'marks': 92}

Updating an Existing Value

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

student = {
    "name": "Rahul",
    "marks": 92
}

student["marks"] = 95

print(student)

Output

{'name': 'Rahul', 'marks': 95}

Removing Items Using del

The del statement removes a specified key-value pair.

student = {
    "name": "Rahul",
    "course": "BCA",
    "marks": 92
}

del student["course"]

print(student)

Output

{'name': 'Rahul', 'marks': 92}

Removing Items Using pop()

The pop() method removes a key and returns its value.

student = {
    "name": "Rahul",
    "marks": 92
}

marks = student.pop("marks")

print(marks)

print(student)

Output

92

{'name': 'Rahul'}

Removing the Last Inserted Item Using popitem()

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

student = {
    "name": "Rahul",
    "course": "BCA",
    "marks": 92
}

print(student.popitem())

print(student)

Output

('marks', 92)

{'name': 'Rahul', 'course': 'BCA'}

Clearing a Dictionary

The clear() method removes every key-value pair from the dictionary.

student = {
    "name": "Rahul",
    "marks": 92
}

student.clear()

print(student)

Output

{}

Membership Testing

The in and not in operators check whether a key exists in a dictionary.

student = {
    "name": "Rahul",
    "marks": 92
}

print("name" in student)

print("age" in student)

print("age" not in student)

Output

True

False

True

Practical Examples

Example 1: Student Information

student = {
    "name": "Rahul",
    "course": "BCA"
}

student["marks"] = 90

print(student)

Output

{'name': 'Rahul', 'course': 'BCA', 'marks': 90}

Example 2: Product Price Update

product = {
    "name": "Laptop",
    "price": 55000
}

product["price"] = 53000

print(product)

Output

{'name': 'Laptop', 'price': 53000}

Example 3: Employee Record

employee = {
    "name": "Neha",
    "department": "HR",
    "salary": 50000
}

print(employee.get("salary"))

Output

50000

Execution Flow

Consider the following program.

student = {
    "name": "Rahul"
}

student["marks"] = 95

print(student)

Execution Steps

1. Python creates a dictionary with one key-value pair.
2. The assignment statement creates a new key called marks.
3. The value 95 is assigned to the new key.
4. The updated dictionary is stored in memory.
5. The complete dictionary is displayed.

Output

{'name': 'Rahul', 'marks': 95}

Common Beginner Mistakes

• Trying to access a missing key using square brackets.
• Confusing keys with values during membership testing.
• Using duplicate keys and expecting both values to be stored.
• Using pop() for a key that does not exist.
• Using clear() when only one item should be removed.

Chunk Summary

In this section, you learned how to access dictionary values using square brackets and the get() method, add new key-value pairs, update existing values, remove items using del, pop(), and popitem(), clear a dictionary, and perform membership testing using the in operator. You also explored practical examples, execution flow, and common beginner mistakes. In the next section, you will learn how to iterate through dictionaries, use important dictionary methods such as keys(), values(), items(), copy(), and clear(), and work with nested dictionaries.

In the previous section, you learned how to access dictionary values, add new key-value pairs, update existing data, remove items, and perform membership testing. Python also provides several built-in dictionary methods that make it easier to retrieve keys, values, and key-value pairs, create copies, determine the dictionary size, and work with nested dictionaries.

These methods are commonly used in data analysis, web development, APIs, automation, and database applications because they simplify working with structured data.

Dictionary Methods

Python provides several built-in methods for working with dictionaries. The most frequently used methods are:

• keys()
• values()
• items()
• copy()
• clear()
• len()

The keys() Method

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

student = {
    "name": "Rahul",
    "course": "BCA",
    "marks": 92
}

print(student.keys())

Output

dict_keys(['name', 'course', 'marks'])

The values() Method

The values() method returns all dictionary values.

student = {
    "name": "Rahul",
    "course": "BCA",
    "marks": 92
}

print(student.values())

Output

dict_values(['Rahul', 'BCA', 92])

The items() Method

The items() method returns each key-value pair as a tuple.

student = {
    "name": "Rahul",
    "course": "BCA",
    "marks": 92
}

print(student.items())

Output

dict_items([('name', 'Rahul'), ('course', 'BCA'), ('marks', 92)])

The copy() Method

The copy() method creates a shallow copy of a dictionary.

student = {
    "name": "Rahul",
    "marks": 92
}

backup = student.copy()

print(backup)

Output

{'name': 'Rahul', 'marks': 92}

The clear() Method

The clear() method removes every key-value pair from a dictionary.

student = {
    "name": "Rahul",
    "marks": 92
}

student.clear()

print(student)

Output

{}

The len() Function

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

student = {
    "name": "Rahul",
    "course": "BCA",
    "marks": 92
}

print(len(student))

Output

3

Looping Through Dictionaries

Dictionaries can be traversed using a for loop.

Looping Through Keys

student = {
    "name": "Rahul",
    "course": "BCA",
    "marks": 92
}

for key in student:
    print(key)

Output

name
course
marks

Looping Through Values

for value in student.values():
    print(value)

Output

Rahul
BCA
92

Looping Through Key-Value Pairs

for key, value in student.items():
    print(key, ":", value)

Output

name : Rahul
course : BCA
marks : 92

Nested Dictionaries

A dictionary can contain another dictionary as its value. This is called a nested dictionary.

students = {
    "student1": {
        "name": "Rahul",
        "marks": 90
    },
    "student2": {
        "name": "Priya",
        "marks": 95
    }
}

print(students)

Output

{
 'student1': {'name': 'Rahul', 'marks': 90},
 'student2': {'name': 'Priya', 'marks': 95}
}

Dictionary of Lists

A dictionary can also store lists as values.

student = {
    "name": "Rahul",
    "subjects": [
        "Python",
        "SQL",
        "Power BI"
    ]
}

print(student)

Output

{
 'name': 'Rahul',
 'subjects': ['Python', 'SQL', 'Power BI']
}

Practical Examples

Example 1: Employee Information

employee = {
    "name": "Neha",
    "department": "HR",
    "salary": 50000
}

for key, value in employee.items():
    print(key, ":", value)

Output

name : Neha
department : HR
salary : 50000

Example 2: Product Details

product = {
    "id": 1001,
    "name": "Laptop",
    "price": 55000
}

print(product.keys())
print(product.values())

Output

dict_keys(['id', 'name', 'price'])

dict_values([1001, 'Laptop', 55000])

Best Practices

• Use meaningful key names.
• Use get() when a key may not exist.
• Use items() when both keys and values are required.
• Use nested dictionaries for structured data.
• Keep dictionary keys consistent throughout your program.

Performance Tips

• Use dictionaries for fast key-based lookups.
• Avoid duplicate keys.
• Use items() instead of repeated key lookups inside loops.
• Copy dictionaries before making major modifications when backup is required.

Common Beginner Mistakes

• Using keys() when values are needed.
• Forgetting to use items() when looping through both keys and values.
• Assuming copy() creates a deep copy.
• Using clear() accidentally instead of removing a single item.
• Confusing nested dictionaries with dictionaries containing lists.

Chunk Summary

In this section, you learned how to use important dictionary methods such as keys(), values(), items(), copy(), clear(), and len(). You also learned how to iterate through dictionaries, work with nested dictionaries and dictionaries containing lists, and explored best practices, performance tips, and common beginner mistakes. In the final section, you will review the complete lesson with a lesson summary, key takeaways, FAQs, coding exercises, interview questions, a mini project, and a preview of the next lesson on Python Dictionary Methods: Complete Guide for Beginners.

Lesson Summary

In this lesson, you learned the fundamentals of Python dictionaries, one of the most powerful and frequently used data structures in Python. Dictionaries store data as key-value pairs, allowing information to be organized, accessed, and updated efficiently using meaningful keys instead of numeric indexes.

You began by understanding what dictionaries are, why they are useful, and how to create them using curly braces and the dict() function. You also learned the rules for dictionary keys and values, including the requirement that keys must be unique and immutable.

Next, you explored how to access dictionary values, add new key-value pairs, update existing values, remove items using different methods, and perform membership testing. These operations make dictionaries highly flexible for managing structured information.

Finally, you learned how to iterate through dictionaries, retrieve keys, values, and key-value pairs using built-in methods, work with nested dictionaries, and store lists inside dictionaries. You also explored best practices, performance tips, and common beginner mistakes.

Dictionaries are essential in Python programming because they provide fast key-based lookups and are widely used in data analysis, APIs, machine learning, web development, and database applications.

Key Takeaways

• Dictionaries store data as key-value pairs.
• Keys must be unique and immutable.
• Values can be of any data type and may be duplicated.
• Dictionaries are mutable.
• Use square brackets or get() to access values.
• Use assignment to add or update key-value pairs.
• Use del, pop(), or popitem() to remove items.
• Use keys(), values(), and items() to retrieve dictionary data.
• Use copy() to create a shallow copy.
• Use dictionaries whenever information is naturally represented as key-value pairs.

Frequently Asked Questions (FAQs)

1. What is a Python dictionary?

A Python dictionary is a mutable collection that stores data as key-value pairs.

2. Can dictionary keys be duplicated?

No. Dictionary keys must be unique.

3. Can dictionary values be duplicated?

Yes. Multiple keys can have the same value.

4. Which brackets are used to create dictionaries?

Dictionaries are created using curly braces {}.

5. How do you safely access a value if a key might not exist?

Use the get() method.

6. How do you add a new key-value pair?

Assign a value to a new key using the assignment operator.

7. Which method returns all dictionary keys?

The keys() method.

8. Which method returns both keys and values?

The items() method.

9. Can dictionaries contain other dictionaries?

Yes. These are called nested dictionaries.

10. When should dictionaries be used?

Use dictionaries whenever data has meaningful labels such as names, IDs, prices, or configuration settings.

Coding Exercises

1. Create a dictionary containing student information.
2. Create an empty dictionary using both {} and dict().
3. Add a new key-value pair to a dictionary.
4. Update an existing value.
5. Access values using square brackets and get().
6. Remove items using del and pop().
7. Display all keys, values, and key-value pairs.
8. Loop through a dictionary using items().
9. Create a nested dictionary containing two students.
10. Create a dictionary that stores a list of subjects.

Interview Questions

1. What is a Python dictionary?
2. How is a dictionary different from a list?
3. Why must dictionary keys be unique?
4. What is the difference between get() and square bracket notation?
5. How do you add and update values in a dictionary?
6. Explain the difference between pop() and popitem().
7. What do the keys(), values(), and items() methods return?
8. What is a nested dictionary?
9. Why are dictionaries efficient for searching data?
10. Give two real-world applications of Python dictionaries.

Mini Project: Student Management System Using Dictionaries

Create a Python program that stores and manages student information using dictionaries.

Your program should:

• Create a dictionary containing a student’s name, roll number, course, and marks.
• Add a new key called city.
• Update the student’s marks.
• Display all keys using keys().
• Display all values using values().
• Display all key-value pairs using items().
• Remove one key using pop().
• Display the final dictionary.

Sample Output

========== STUDENT MANAGEMENT SYSTEM ==========

Student Details

{'name': 'Rahul', 'roll_no': 101, 'course': 'BCA', 'marks': 92}

After Adding City

{'name': 'Rahul', 'roll_no': 101, 'course': 'BCA', 'marks': 92, 'city': 'Dehradun'}

After Updating Marks

{'name': 'Rahul', 'roll_no': 101, 'course': 'BCA', 'marks': 95, 'city': 'Dehradun'}

Dictionary Keys

dict_keys(['name', 'roll_no', 'course', 'marks', 'city'])

Dictionary Values

dict_values(['Rahul', 101, 'BCA', 95, 'Dehradun'])

After Removing City

{'name': 'Rahul', 'roll_no': 101, 'course': 'BCA', 'marks': 95}

================================================

What’s Next?

Congratulations! You have successfully learned the fundamentals of Python Dictionaries. You now understand how to create dictionaries, access values, add and update key-value pairs, remove items, iterate through dictionary data, and organize structured information efficiently.

In the next lesson, you will learn Python Dictionary Methods: Complete Guide for Beginners. You will explore advanced dictionary methods such as update(), setdefault(), fromkeys(), pop(), popitem(), copy(), and many more with practical examples and real-world applications.