> For the complete documentation index, see [llms.txt](https://codingnotes.gitbook.io/coding_notes/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://codingnotes.gitbook.io/coding_notes/coding/python/dictionary-in-python.md).

# Dictionary In Python

## 1. DICTIONARY 101

### 1.1. Defining a Dictionary

A dictionary in Python is a collection of **key-value** pairs.

* A dictionary is wrapped in braces, `{}`
* Every *key* is connected to its *value* by a colon `:`, and individual *key-value* pairs are separated by commas `,`
* You can use a key to access the value associated with that key
* A key’s value can be a number, a string, a list, another dictionary or virtually any object in Python
* You can store as many key-value pairs as you want in a dictionary

Let’s define a simple dictionary that stores some pieces of information about and store it inside a variable `user_car`

```python
user_car ={'make': 'honda','model': 'fit','year': 2015}
```

In the above example, there are three key-value pairs. Keys are `make`, `model` and `year` with their associated values — `honda`, `fit` and `2015` , respectively.

### 1.2. Accessing Values in a Dictionary

To get the value associated with a key, give the name of the dictionary and then place the key inside a set of square brackets

```python
print(user_car['make'].title())
print(user_car['model'].title())
```

```
Honda
Fit
```

### 1.3 Adding New Key-Value Pairs

To add a new key-value pair, you would provide the name of the dictionary followed by the new key in square brackets and assign a value. Let’s add the color and country to our previous dictionary `user_car`

```python
user_car ={'make': 'honda','model': 'fit','year': 2015}
# dictionary before adding new key-value pairs
print(user_car)

# adding new key-value pairs
user_car['color'] = 'silver'
user_car['country'] = 'japan'

# dictionary after adding new key-value pairs
print(user_car)
```

```
{'make': 'honda', 'model': 'fit', 'year': 2015}
{'make': 'honda', 'model': 'fit', 'year': 2015, 'color': 'silver', 'country': 'japan'}
```

### 1.4. Starting with an Empty Dictionary

Why we need an empty dictionary? One case would be when storing user-supplied data in a dictionary or when you write code that generates a large number of key-value pairs programatically. Let define an empty dictionary `user_car` and add few key-value pairs in it:

```python
# defining an empty dictionary
user_car ={}
#printing the same empty dictionary
print(user_car)

# adding new key-value pairs
user_car['make'] = 'honda'
user_car['model'] = 'fit'
user_car['year'] = 2015

# printing dictionary
print(user_car)
```

```
{}
{'make': 'honda', 'model': 'fit', 'year': 2015}
```

### 1.5. Modifying Values in a Dictionary

To modify a value in a dictionary, the methodology is the same as creating new key-value pair — i.e, give the name of the dictionary with the key in square brackets and then the new value you want associated with that key.

```python
# original dictionary
user_car ={'make': 'honda','model': 'fit','year': 2015}
print(f"The car is made in {user_car['year']}")

# modifying year value
user_car['year'] = 2014
print(f"\nWe modified the car year to {user_car['year']}")
```

```
The car is made in 2015

We modified the car year to 2014
```

### 1.6. Removing Key-Value Pairs

Sometimes, we no longer require a piece of information that’s stored in a dictionary, in such cases, we can use the `del` statement to permanently remove a key-value pair. All `del` statement needs is the *name* of the dictionary and the *key* that we want to remove.

```python
# defining the dictionary in original form
user_car ={'make': 'honda','model': 'fit','year': 2015}
print(user_car)

# deleting the key-value pair of 'year' key
del user_car['year']

# after removing, printing the dictionary
print(user_car)
```

```
{'make': 'honda', 'model': 'fit', 'year': 2015}
{'make': 'honda', 'model': 'fit'}
```

### 1.7. A Dictionary of Similar Objects

Up-till now, we are *storing different kinds of information about one object*, a `user car` We can also use a dictionary to *store one kind of information about many objects* as we will do in the following example

```python
# defining dictionary
fav_cars = {
    'tom':'honda',
    'jerry':'toyota',
    'dexter':'tesla',
    'frank':'tesla',
    }

# accessingthe required value from dict
print(f"Dexter loves to drive {fav_cars['dexter'].title()}")
```

```
Dexter loves to drive Tesla
```

In the above example, we wrote a *multi-line dictionary*, in which each key-value pair is written in new line. The comma at the end of last value is not needed but a good practice.

## 2. LOOPING THROUGH A DICTIONARY

Several different ways exist to loop through a dictionary:

### 2.1. Looping Through *all Key-Value* Pairs

#### a. Example 1:

In the following example, we will print all the key-value pairs in the dictionary:

```python
# defining dict
user_car ={'make': 'honda','model': 'fit','year': 2015}

# looping through dict
for key, value in user_car.items():
    print(f"\nKey: {key}")
    print(f"Value: {value}")
    
print("\nAll key-value pairs are printed")
```

```
Key: make
Value: honda

Key: model
Value: fit

Key: year
Value: 2015

All key-value pairs are printed
```

The `for` loop was defined in the following line:

```python
for key, value in user_car.items():
```

the `user_car.items():` part of the code read the entire key-value pairs.

However, you can use any keyword for the `key` and `value`, for example:

```python
for k, v in user_car.items():
```

#### b. Example 2:

Let’s loop through a dictionary that stores *one kind of information for several objects*:

```python
# defining dict
fav_cars = {
    'tom':'honda',
    'jerry':'toyota',
    'dexter':'tesla',
    'frank':'tesla',
    }

# looping through dict
for name, car in fav_cars.items():
    print(f"{name.title()} favorite car is {car.title()}")
```

```
Tom favorite car is Honda
Jerry favorite car is Toyota
Dexter favorite car is Tesla
Frank favorite car is Tesla
```

### 2.2. Looping Through *all the Keys*

The *keys() method* is useful when we don’t need to work with all of the values in a dictionary.

```python
# defining dict
fav_cars = {
    'tom':'honda',
    'jerry':'toyota',
    'dexter':'tesla',
    'frank':'tesla',
    }

# looping and printing 'keys' only
print("Dictionary keys:")
for name in fav_cars.keys():
    print (f"\t{name.title()}")
```

```
Dictionary keys:
	Tom
	Jerry
	Dexter
	Frank
```

The `for` loop was defined in the following line :

```python
for name in fav_cars.keys():
```

whereas the `fav_cars.keys():` part of the code only read `key`

However, we can use the following shortcut:

```python
for name in fav_cars:
```

#### a. Looping with if statement

In this example, we will print custom message if the key value is **Dexter**:

```python
# defining dict
fav_cars = {
    'tom':'honda',
    'jerry':'toyota',
    'dexter':'tesla',
    'frank':'tesla',
    }

# looping with if statement
for name in fav_cars.keys():
    if name == 'dexter':
        print(f"Hello {name.title()}, please go to room 007")
    else:
        print(f"Hello {name.title()}, please go to room B101")
```

```
Hello Tom, please go to room B101
Hello Jerry, please go to room B101
Hello Dexter, please go to room 007
Hello Frank, please go to room B101
```

#### b. Looping through keys in order

For example, we want to print the key names in alphabetic order. To do this, we will use `sorted` function

```python
# defining dict
fav_cars = {
    'tom':'honda',
    'jerry':'toyota',
    'dexter':'tesla',
    'frank':'tesla',
    }

# printing keys in order
print("Keys in the dictionary are:")
for name in sorted(fav_cars.keys()):
    print(f"\t{name.title()}")
```

```
Keys in the dictionary are:
	Dexter
	Frank
	Jerry
	Tom
```

### 2.3. Looping Through *All Values*

We can use the `.values()` method to return a list of values without any keys. For example, we would like to print the favorite cars without any associated key:

```python
# defining dict
fav_cars = {
    'tom':'honda',
    'jerry':'toyota',
    'dexter':'tesla',
    'frank':'tesla',
    }

# printing values of dict
print("Favorite cars are:")
for car in fav_cars.values():
    print(f"\t{car.title()}")
```

```
Favorite cars are:
	Honda
	Toyota
	Tesla
	Tesla
```

#### a. Looping through values without repetition

In above example, ‘Tesla’ is printed twice. However, we are only interested in the **unique values** of car names. For this purpose, we can use the `set()` function

```python
# defining dict
fav_cars = {
    'tom':'honda',
    'jerry':'toyota',
    'dexter':'tesla',
    'frank':'tesla',
    }

# printing only the unique values of dict
print("Favorite cars in the list are:")
for car in set(fav_cars.values()):
    print(f"\t{car.title()}")
```

```
Favorite cars in the list are:
	Tesla
	Honda
	Toyota
```

ALERT: If you have noticed that the order of printed values are not in the same order as contained in the original dictionary, this is how the Python work this out internally.

## 3. NESTING

Sometimes you want to store:

* a *set of dictionaries* inside a *list*, or
* a *list of items* as a `value` in a *dictionary*, or
* a *dictionary* inside another *dictionary* … this is called **Nesting**

### 3.1. A List of Dictionaries

In the following example, we store two `dictionaries` inside a `list`:

```python
# defining first dict
car_1 = {'make': 'honda','model': 'fit','year': 2015}
# defining second dict
car_2 = {'make': 'tesla', 'model': '3', 'year': 2018}

# storing dictionaries inside list
cars = [car_1, car_2]

# looping through list
for car in cars:
    print(car)
```

```
{'make': 'honda', 'model': 'fit', 'year': 2015}
{'make': 'tesla', 'model': '3', 'year': 2018}
```

### 3.2. A List in a Dictionary

We can also nest a `list` inside a `dictionary`. Let’s suppose we are storing information about blog post in a dictionary and within this dictionary, we will store the tags related to this blog post inside a list:

```python
# defining dict
blog_post ={
    'title':'This is title',
    'description':'This is description',
    'tags':['tag1', 'tag2', 'tag3']
    } 

# running for loop to retrieve
# list of tags associated with key 'tags' 
for tag in blog_post['tags']:
    print(tag)
```

```
tag1
tag2
tag3
```

#### a. One object, multiple information

In earlier example, we stored a single value of car for each person. However, we can use a list to store more than one cars for each person:

```python
# defining dict with 'values' as list
fav_cars = {
    'tom':['honda'],
    'jerry':['toyota', 'bmw'],
    'dexter':['tesla', 'byd'],
    'frank':['tesla','buick'],
    }

# running primary 'for' loop for dict key-values
for name, cars in fav_cars.items():
    print(f"\n{name.title()}'s favorite cars are:")
    # running another 'for' loop for list
    for car in cars:
        print(f"\t{car.title()}")
```

```
Tom's favorite cars are:
	Honda

Jerry's favorite cars are:
	Toyota
	Bmw

Dexter's favorite cars are:
	Tesla
	Byd

Frank's favorite cars are:
	Tesla
	Buick
```

#### b. Refining the code

We can see in the above example that even for person with single favorite cars, we are printing the word “**… cars are:**” , instead of “**… car is:**” Let refine the code using `if` statement to handle this situation:

```python
# defining dict with 'values' as list
fav_cars = {
    'tom':['honda'],
    'jerry':['toyota', 'bmw'],
    'dexter':['tesla', 'byd'],
    'frank':['tesla','buick'],
    }

# running primary 'for' loop for dict key-values
for name, cars in fav_cars.items():
    # checking if the number of cars is equal to 1
    if len(cars) == 1:
        print(f"{name.title()}'s favorite car is:")
    else:
        print(f"{name.title()}'s favorite cars are:")
    for car in cars:
        print(f"\t{car.title()}")
```

```
Tom's favorite car is:
	Honda
Jerry's favorite cars are:
	Toyota
	Bmw
Dexter's favorite cars are:
	Tesla
	Byd
Frank's favorite cars are:
	Tesla
	Buick
```

### 3.3. A Dictionary in a Dictionary

Suppose our dictionary stores user information, where the `key` is the username and `value` is another dictionary including the related information about the user:

```python
# defining dict with 'values' as another dictionary
users = {
    'tommy': {
        'first':'tom',
        'last':'cruise',
        'location':'new york',
    },
    'dex':{
        'first':'dexter',
        'last':'morgan',
        'location':'florida',
    },
}

# running for loop inside dict
for name, user_info in users.items():
    full_name = f"{user_info['first'].title()} {user_info['last'].title()}"
    location = f"{user_info['location'].title()}"
    
    print(f"\nUsername: {name}")
    print(f"Full name: {full_name}")
    print(f"Location: {location}")
```

```
Username: tommy
Full name: Tom Cruise
Location: New York

Username: dex
Full name: Dexter Morgan
Location: Florida
```

ALERT: Please note that the structure of each `user` dictionary is identical. However, we can make it different but the code will be more complicated.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://codingnotes.gitbook.io/coding_notes/coding/python/dictionary-in-python.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.