Python Dictionary

1. What is a Python Dictionary?

user = {
    "name": "Raj",
    "age": 25,
    "city": "Mumbai"
}

In the above example:

• "name", "age", "city" are keys

• "Raj", 25, "Mumbai" are values

Please remember that each key is unique and it acts like a label for the data as well.

You don’t need to remember positions (like index 0, 1, 2). You can access its data by meaningful names or labels like:

user["name"]

user["age"]

In short, dictionary data structure has following benefits:

• Easier to read

• Easier to maintain

• Very close to how real applications work

Why Dictionaries Matter?

Python dictionary is a popular data structure in Python which is frequently used in real-world and production code.

Let me explain now, why, in simple words.

a) Fast Lookup (Average O(1))

In Python language, dictionary is internally implemented using a hash table.

In other words:

• Python does not search one-by-one

• It directly jumps to the value using the hash function on key

So, if you need to search for value of:

user["city"]

Python will always take the same time to find its value, whether your dictionary has:

• 3 items

• 300 items

• 3 million items

This is the power of hash tables.

If you want to know how hashing works internally in simple words, then I would suggest you read my next blog in which I would explain it step-by-step.

ALWAYS REMEMBER:

Internally, Python dictionaries use a hash table, which allows it to jump directly to a value (by using the key). This operation always takes the same amount of time, no matter how big the data is. This is O(1) access.

user["email"] = "raj@yahoo.com"
user["age"] = 40
del user["city"]

Explanation:

In first line of code, we have added a new key-value pair and once you run it, Python adds this entry to the dictionary.

In second line of code, we have updated the age. Earlier, it was 25 and now it is 40.

In last line of code, we have deleted a key-value pair using the del keyword.

Please note that when you remove a key using del keyword, then its value (Mumbai) is deleted automatically.

["Raj", 40, "Mumbai"]



{
    "name": "Raj",
    "age": 40,
    "city": "Mumbai"
}

In first one, you need to remember the meaning of each position.

On the other side, in second one, you don’t need to remember — data explains itself.

That is why experienced developers always prefer to use dictionaries to have clarity and safety.

car = {
    "brand": "Tesla",
    "year": 2026
}

Explanation:

Curly braces {} are used to create a dictionary.

"brand" and "year" are keys and it contains values "Tesla" and 2026.

Important thing to note that each key is linked to its value.

Using:

car["brand"]

Output:

Tesla

b) Using dict() Function

In this method, we use the built-in function dict().

It is mainly used to store application settings and configuration values.

Example:

car = dict(brand="Tesla", year=2026)

c) From Tuples (DB / CSV Style)

This pattern is used when data comes from databases or CSV files, where records are returned as tuples of key-value pairs.

Example:

pairs = [("a", 10), ("b", 20)]
d = dict(pairs)

Explanation:

In this example, we have a list that contains two tuples returned from a database query (for example).

Each tuple has 2 things — first element is key and second element is the value.

The dict() reads each tuple and finally converts it into a dictionary.

Here, d stores the reference of the dictionary object created by dict(pairs).

d = dict(zip(["id", "name"], [101, "Raj"]))

Firstly, zip() will create pairs like these:

("id", 101), ("name", "Raj")

Finally, dict() function will create these pairs into dictionary as shown below:

{

    "id": 101,

    "name": "Raj"

}

We use zip() function when we need to map API response fields to their values in a correct way.

e) Using fromkeys() (Configuration Defaults)

Sometimes, we want multiple keys with same default value.

This is very common in configuration settings. Before we start working on a website, we decide how a website should behave and these decisions are most normally stored as configuration settings.

Example:

Before starting a website, work or writing any code, stakeholders decide following requirements:

• The website should support a debug mode for developers

• The website should enable caching for better performance

Once we define the requirements, we design configuration keys:

• debug_mode

• enable_cache

After that, we start writing code and define default behavior, like:

config = dict.fromkeys(

    ["debug_mode", "enable_cache"],

    False

)

After this, Python assigns the same value to each key like shown below:

{

    "debug_mode": False,

    "enable_cache": False

}

In short, we use fromkeys() when many settings have the same default value, as it avoids repetitive code.

squares = {x: x*x for x in range(5)}

Explanation:

In above example, range(5) is used to define numbers from 0 to 4.

A dictionary always stores data in key-value form. So key is x and value is x * x.

So, output will be a dictionary like shown below:

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

3. Must-Know Dictionary Methods

In my day-to-day work, I have realized that there are few methods given below which are often used in real production code. So, it is really important for you to know them, like:

• how to read a dictionary data

• how to update and remove dictionary data

• and how to merge dictionary data

Let me explain each one in simple words so that you could also use them in your real projects with confidence.

user = {
    "name": "Raj",
    "age": 40
}

email = user.get("email", "not provided")
print(email)

Output:

not provided

Explanation:

In this example, first we have defined a dictionary (with the user name) that has two keys (name and age).

After this, we have used .get() method that looks for the key "email". Because key name "email" is not present, Python returns the default value "not provided" as an output.

In this case, no error is raised and program is run smoothly without any error.

If we hadn’t defined a key with a default value ("not provided") and we try to access it directly, then the above program may crash.

user = {
    "name": "Raj",
    "age": 40,
    "city": "Mumbai"
}

Let us discuss each method one-by-one.

(i) keys()

This method is used to get only keys.

Example:

for k in user.keys():
    print(k)

Output:

name

age

city

Explanation:

In above example, keys() method returns all the keys present in a dictionary user.

For loop runs 3 times in this case and in each loop iteration, key name is printed.

(ii) values()

This method is used to get values from the dictionary.

Example:

for v in user.values():
    print(v)

Output:

Raj

40

Mumbai

Explanation:

In above example, values() method returns all values present in a dictionary.

With the help of for loop, each of the value is printed one-by-one.

(iii) items()

This method is used to get key and value together.

Example:

for k, v in user.items():
    print(k, "=>", v)

Output:

name => Raj

age => 40

city => Mumbai

Explanation:

In above example, items() method returns both key and value in pairs and each pair is a tuple.

In each iteration of for loop, k gets the key and v gets the value. Hence, it is printed one - by - one.

user = {
    "name": "Raj",
    "age": 40
}

user.update({
    "age": 45,
    "email": "raj@yahoo.com"
})

print(user)

Output:

{'name': 'Raj', 'age': 45, 'email': 'raj@yahoo.com'}

Explanation:

In above example, we have modified age from 40 to 45 and added a new pair i.e. "email": "raj@yahoo.com".

Honestly, I have seen in many projects .update() method is used, so it becomes important to have a good understanding of this method.

user = {
    "name": "Raj",
    "age": 40,
    "city": "Mumbai"
}

age = user.pop("age")
print(age)

Output:

40

Explanation:

In above example, .pop("age") method removes the given key from dictionary user and it returns the value (40) of that key ("age").

Hence, it is printed (40) using print statement.

Please note that if the key doesn’t exist in dictionary object, then .pop() method will crash the program.

(ii) popitem()

This method is used to remove the last inserted item from a dictionary.

This method is mainly used in those scenarios when you want to take one item from a dictionary, use it and remove it immediately, so that data should not stay in memory longer than needed.

Example:

user = {
    "name": "Raj",
    "age": 40,
    "city": "Mumbai"
}

user.popitem()
print(user)

Output:

{'name': 'Raj', 'age': 40}

In this example, popitem() method is used to remove the last added key-value pair.

This method is useful for stack-like operations.

settings = {}

value = settings.setdefault("theme", "light")
print(value)
print(settings)

Output:

light

{'theme': 'light'}

Explanation:

In above example, first we have created an empty dictionary named as settings.

In next statement, we have used setdefault() method. Since the key "theme" was not present, it adds the key with default value ("light") in the dictionary settings. That is why when we print dictionary settings in the last statement, it prints key and value (both).

Personally, I have used setdefault() method in real projects to group logs, errors, and user data, where Python creates the key with a default value if it does not already exist.

4. Merging & Updating Dictionaries

In real projects, data often comes from multiple sources like configs, APIs, environment variables, and user input.

There are several built-in methods in Python to merge such dictionaries. Let us now look at a few such methods in Python.

(i) Using | (Merge Operator)

This is used to create a new dictionary by merging two dictionaries.

Please remember that the merge operator (|) does not modify the original dictionaries.

Example:

d1 = {"a": 10, "b": 20}
d2 = {"b": 25, "c": 30}

merged = d1 | d2
print(merged)

Output:

{'a': 10, 'b': 25, 'c': 30}

Explanation:

In above example, first we have defined two dictionaries with names d1 and d2.

After that, we have used merge operator (|) to merge these two dictionaries d1 and d2.

Finally, a new dictionary merged is printed using print statement.

Please note that key "b" exists in both dictionaries d1 and d2. Value from d2 (25) replaces the value from d1 (20).

Note: d1 and d2 dictionaries (both) remain unchanged.

d1 = {"a": 10, "b": 20}
d2 = {"b": 25, "c": 30}

d1 |= d2
print(d1)

Output:

{'a': 10, 'b': 25, 'c': 30}

Explanation:

In above example, we have used in-place update (|=) operator, which basically updates dictionary d1 using values from dictionary d2.

Please note that key "b" exists in both dictionaries d1 and d2. Value from the right-side dictionary (d2) is used.

Also, in-place update (|=) does not create any new dictionary.

d1 = {"a": 10, "b": 20}
d2 = {"b": 25, "c": 30}

merged = {**d1, **d2}
print(merged)

Output:

{'a': 10, 'b': 25, 'c': 30}

Explanation:

In this example, there are two dictionaries d1 and d2.

When you write **d1, then it expands all key-value pairs of d1. Similarly, all key-value pairs are expanded of d2 by writing **d2.

After that, Python inserts all key-value pairs (from both dictionaries) into a new dictionary called merged.

Please note that if the same key (in this case "b") appears in both d1 and d2 dictionaries, then key-value pair is added from the right-side dictionary. That is why "b": 25 is added into a new dictionary merged.

d = {"a": 10}
v = d.keys()

d["b"] = 20
print(list(v))

Output:

['a', 'b']

Explanation:

In this example, firstly we have created a dictionary d with only one key "a".

In next statement, v stores a view object of the dictionary keys.

After that, in the 3rd line, we have added a new key "b" to the dictionary.

Now, the view object v is updated automatically. That is why when we print it using print statement, both keys are printed (as a list) in the output.

ALWAYS REMEMBER:

Views are always memory efficient because they don’t create a new copy. They act as a live window/connection to the dictionary. That is why if you do any change to a dictionary, those changes would be reflected instantly.

6. Dictionary Comprehensions (Real Use Cases)

Personally, I have used dictionary comprehensions a lot in my projects, especially in scenarios where raw data needs to be cleaned, filtered, or reshaped in a quick way.

Let us discuss a few real use cases here in simple words, that will help you in your career as well.

a) Filter Logs (Production Monitoring)

When you start working in real projects, then you will notice that a log file contains many entries, but we only need error logs to perform debugging.

In this scenario, dictionary comprehension helps to filter the required data in one clean step.

Example:

errors = {
    k: v for k, v in logs.items()
    if v["status"] == "error"
}

Explanation:

Please don’t panic. This is a very simple code. I would explain each part of this in an easy way.

Here, logs is just a dictionary variable which has following data:

logs = {

    "req1": {"status": "success", "time": 120},

    "req2": {"status": "error", "time": 500},

    "req3": {"status": "error", "time": 300}

}

Please note that here "req1", "req2" and "req3" are keys.

And each value is another dictionary with log details.

Here, logs.items() returns key-value pairs from the dictionary.

Next statement to understand is:

for k, v in logs.items()

Here, k holds key (like "req1", "req2" etc.) and v holds value (log details).

Example:

k = "req2"

v = {"status": "error", "time": 500}

Now, let’s look at v["status"].

Here, v is a dictionary and "status" is a key inside that dictionary.

v["status"] == "error"

Checks whether this log entry represents an error.

In other words, only those logs with "status" == "error" are selected. All others are ignored.

So, in simple words, the below code:

errors = {

    k: v for k, v in logs.items()

    if v["status"] == "error"

}

Creates a new dictionary called errors.

It loops through all log entries and keeps only those records/logs where status is error and also stores them in key-value pairs.

encode_map = {val: i for i, val in enumerate(unique_vals)}

Explanation:

Based on my experience, I would explain it in a simple way, so that everyone could understand above use-case completely.

In above example, unique_vals is a list which contains unique category values from a dataset.

Let’s take an example for this:

unique_vals = ["low", "medium", "high"]

Please note that ML models cannot understand these categorical values directly. ML models only work with numbers, so we will convert these into numbers and this mapping is called encoding.

After that, let’s understand enumerate() function.

The enumerate(unique_vals) function produces index-value pairs like below:

(0, "low")

(1, "medium")

(2, "high")

This is exactly what helps us create the dictionary mapping in a clean way.

for i, val in enumerate(unique_vals):

In each iteration of the for loop, i contains the index number (like 0, 1, 2) and val contains category value (like low, medium, high).

Now, let’s understand main logic as written below:

encode_map = {val: i ...}

Finally, a dictionary is created like:

encode_map = {

    "low": 0,

    "medium": 1,

    "high": 2

}

After this step, whenever an ML model needs input, we provide numeric values instead of text, because ML models work with numbers (not strings).

Don’t worry if you don’t understand these two use-cases completely at first. Most people struggle in the beginning, this is normal.

My suggestion is to read these two use-cases again and things will start to make sense gradually.

7. Advanced Internals

Firstly, you need to understand the meaning of internals. In simple words, internals mean how Python works behind the scenes.

When we write normal Python code, we don’t see this because Python does a lot of work behind the scenes (internally) to make things fast and more efficient.

Mostly, interviewers ask about internals because they want to know:

a) Why keys are immutable?

b) How dictionaries are fast?

c) How does Python use dictionary internally?

When you write Python code, it is converted to bytecode. After that, CPython (written in C language) executes that bytecode.

How Dictionaries work in CPython:

In CPython, a dictionary is built using a hash table.That is why dictionary lookups are very fast.

In simple words, when you insert a key, then behind the scenes Python calculates a hash value using this key. After that, this hash value is mapped to a memory location. And finally, that slot is used to store key-value pairs together.

This is the reason why dictionary access is always O(1) on average.

Always remember the following three points:

a) In Python dictionaries, keys must be immutable because it ensures stable hashing. Otherwise, Python won’t be able to find the value for a particular key.

b) Python dictionaries are smart and memory-optimized because they always start small and if you add more items, then it is resized automatically, which avoids frequent memory reallocation.

c) Please remember that dictionaries are used everywhere in Python. In interviews, this is often asked. Internally, Python itself is built using dictionaries.

x = 10
y = 20
print(globals())

In the above program, first we create two variables x and y (outside any function). Python keeps all such types of variables in a common place called the global namespace.

When the globals() function is called, Python returns a dictionary that stores all global variables.

In this dictionary, variable names are keys and their values are values. Many default entries (__name__, __builtins__, etc.) are also added.

Output:

{

    'x': 10,

    'y': 20,

    '__name__': '__main__',

    '__file__': 'example.py',

    '__builtins__': {...}

}

Please note that every global variable in Python language is stored inside a dictionary.

class User:
    def __init__(self, name):
        self.name = name

u = User("Aman")
print(u.__dict__)

Output:

{'name': 'Aman'}

8. Real-World Applications of Dictionaries

# data from API (sample)
payload = {
    "age": 25,
    "hours_studied": 5,
    "attendance": 80
}

# fixed feature order
features = ["age", "hours_studied", "attendance"]

# convert dictionary into numbers
X = [payload[f] for f in features]

# train the model using numbers
model.fit([X], y)

Golden line:

Dictionary is only for humans for better understanding of data. Machine or ML models only understand numbers.

raw_data = {
    "Name": "amit",
    "AGE": "20",
    "Marks": "80"
}

If you observe it carefully, this data is not clean because of wrong case and numbers are stored as strings.

Step 2: Transform (Clean & Change Data)

In this step, we will transform the data using a dictionary as shown below:

clean_data = {
    "name": raw_data["Name"].title(),
    "age": int(raw_data["AGE"]),
    "marks": int(raw_data["Marks"])
}

In the above program, text (amit) is standardized using .title(). String numbers are converted to integers. Now, the data is neat and consistent.

Step 3: Load (Store the Clean Data)

After the transformation step, the above data can be either stored into a database or data warehouse or can be sent to another application (based on need).

save_to_db(clean_data)

Note: save_to_db() is a user-defined function which is used to store the cleaned data into a database.

9. Production-Level Patterns

That is why in production systems, before running any logic, it is critical to validate required fields.

REQUIRED_FIELDS = ("name", "email", "age")

def validate_payload(payload: dict):
    missing = [f for f in REQUIRED_FIELDS if f not in payload]

    if missing:
        raise ValueError(f"Missing fields: {missing}")

    return {
        "name": payload["name"].strip(),
        "email": payload["email"].lower(),
        "age": int(payload["age"])
    }

Explanation

In the above code, when a client (like a web app, mobile app, etc.) sends data to the API, that data is received by the function as a payload dictionary argument.

It holds the user-provided values in key-value form such as name, email, and age.

This function first validates the payload and checks if any required field is missing.

Once it is confirmed that nothing is missing, only after that the data is cleaned and prepared for further processing and returned as a dictionary object.

cache = {}

def fetch_user(uid):
    if uid in cache:
        return cache[uid]

    data = load_from_db(uid)
    cache[uid] = data
    return data

Explanation:

In this code, first a dictionary cache = {} is created that works as in-memory storage. It is used to store data on a temporary basis in memory.

When fetch_user(uid) function is called, first it checks if data is already available in cache. If it is available, then data is returned directly from memory using return statement.

On the other side, if data is not available in cache, then it is loaded from database (which is slow and expensive) and then stored in cache and finally, it is returned.

10. Why Dictionaries Matter

11. Common Mistakes