In this lesson, you will learn how to create dictionaries, which map a set of keys to a set of values. Once you can create dictionaries, you open doors to more complicated concepts like data processing and web development.

Creating Dictionaries

If we wanted to add multiple key : value pairs to a dictionary at once, we can use the [`.update()`](https://www.codecademy.com/resources/docs/python/dictionaries/update?page_ref=catalog) method.

Looking at our `sensors` object from a previous exercise:

```py
sensors = {"living room": 21, "kitchen": 23, "bedroom": 20}
```

If we wanted to add 3 new rooms, we could use:

```py
sensors.update({"pantry": 22, "guest room": 25, "patio": 34})
```

This would add all three items to the `sensors` dictionary.

Now, `sensors` looks like:

```py
{"living room": 21, "kitchen": 23, "bedroom": 20, "pantry": 22, "guest room": 25, "patio": 34}
```


Add Multiple Keys

Let's say we have two lists that we want to combine into a dictionary, like a list of students and a list of their heights, in inches:

```py
names = ['Jenny', 'Alexus', 'Sam', 'Grace']
heights = [61, 70, 67, 64]
```

Python allows you to create a dictionary using a dict comprehension, with this syntax:

```py
students = {key:value for key, value in zip(names, heights)}
#students is now {'Jenny': 61, 'Alexus': 70, 'Sam': 67, 'Grace': 64}
```

Remember that [`zip()`](https://www.codecademy.com/resources/docs/python/built-in-functions/zip?page_ref=catalog) combines two lists into an iterator of tuples with the list elements paired together. This dict comprehension:
1. Takes a pair from the iterator of tuples
2. Names the elements in the pair `key` (the one originally from the `names` list) and `value` (the one originally from the `heights` list)
3. Creates a `key` : `value` item in the `students` dictionary
4. Repeats steps 1-3 for the entire iterator of pairs


Dict Comprehensions

We know that we can add a key by using the following syntax:

```py
menu["banana"] = 3
```

This will create a key `"banana"` and set its value to `3`. But what if we used a key that already has an entry in the `menu` dictionary?

In that case, our value assignment would overwrite the existing value attached to that key. We can overwrite the value of `"oatmeal"` like this: 

```py
menu = {"oatmeal": 3, "avocado toast": 6, "carrot juice": 5, "blueberry muffin": 2}
menu["oatmeal"] = 5
print(menu)
```

This would yield:

```py
{"oatmeal": 5, "avocado toast": 6, "carrot juice": 5, "blueberry muffin": 2}
```

Notice the value of `"oatmeal"` has now changed to `5`.


Overwrite Values

We can have a list or a dictionary as a _value_ of an item in a dictionary, but we cannot use these data types as keys of the dictionary. If we try to, we will get a `TypeError`. 

For example:

```py
powers = {[1, 2, 4, 8, 16]: 2, [1, 3, 9, 27, 81]: 3}
```

This code will yield:

```error
TypeError: unhashable type: 'list'
```

The word "unhashable" in this context means that this 'list' is an object that can be changed. 

Dictionaries in Python rely on each key having a _hash value_, a specific identifier for the key. If the key can change, that hash value would not be reliable. So the keys must always be unchangeable, hashable data types, like numbers or strings.

Invalid Keys

In the previous exercise, we saw a dictionary that maps strings to numbers (i.e., `"avocado toast": 6`). However, the keys can be numbers as well. 

For example, if we were mapping restaurant bill subtotals to the bill total after tip, a dictionary could look like:

```py
subtotal_to_total = {20: 24, 10: 12, 5: 6, 15: 18}
``` 

Values can be of any [type](https://www.codecademy.com/resources/docs/python/data-types?page_ref=catalog). We can use a string, a number, a list, or even another dictionary as the value associated with a key!

For example:

```py
students_in_classes = {"software design": ["Aaron", "Delila", "Samson"], "cartography": ["Christopher", "Juan", "Marco"], "philosophy": ["Frederica", "Manuel"]}
```

The list `["Aaron", "Delila", "Samson"]`, which is the value for the key `"software design"`, represents the students in that class.

We can also mix and match key and value types. For example:

```py
person = {"name": "Shuri", "age": 18, "family": ["T'Chaka", "Ramonda"]}
```

Make a Dictionary

To add a single `key: value` pair to a dictionary, we can use the syntax:

```pseudo
dictionary[key] = value
```

For example, if we had our `menu` dictionary from the first exercise:

```py
menu = {"oatmeal": 3, "avocado toast": 6, "carrot juice": 5, "blueberry muffin": 2}
```

And we wanted to add a new item, `"cheesecake"` for `8` dollars, we could use:

```py
menu["cheesecake"] = 8
```

Now, `menu` looks like:

```py
{"oatmeal": 3, "avocado toast": 6, "carrot juice": 5, "blueberry muffin": 2, "cheesecake": 8}
```


Add A Key

A [_dictionary_](https://www.codecademy.com/resources/docs/python/dictionaries?page_ref=catalog) is an unordered set of `key: value` pairs. 

It provides us with a way to map pieces of data to each other so that we can quickly find values that are associated with one another.

Suppose we want to store the prices of various items sold at a cafe:

- Avocado Toast is 6 dollars
- Carrot Juice is 5 dollars
- Blueberry Muffin is 2 dollars

In Python, we can create a dictionary called `menu` to store this data:

```py
menu = {"avocado toast": 6, "carrot juice": 5, "blueberry muffin": 2}
```

Notice that:

1. A dictionary begins and ends with curly braces `{` and `}`.
2. Each item consists of a key (`"avocado toast"`) and a value (`6`).
3. Each `key: value` pair is separated by a comma.

It's considered good practice to insert a space (` `) after each comma, but our code will still run without the space.


Introduction to Python Dictionaries

So far we have learned:
- How to create a dictionary
- How to add elements to a dictionary
- How to update elements in a dictionary
- How to use a dict comprehension to create a dictionary from two lists

Let's practice these skills!


Review

A dictionary doesn't have to contain anything. Sometimes we need to create an empty dictionary when we plan to fill it later based on some other input.

We can create an empty dictionary like this:

```py
empty_dict = {}
```

We will explore ways to fill a dictionary in the next exercise.
