---
title: Python Dictionaries and sets
description: In Python, a dictionary is an insertion-ordered (from Python > 3.7) collection of key, value pairs.
---
In Python, a dictionary is an _ordered_ (from Python > 3.7) collection of `key`: `value` pairs.
The main operations on a dictionary are storing a value with some key and extracting the value given the key. It is also possible to delete a key:value pair with <code>del</code>.
# Dictionaries
## Set key, value using subscript operator `[]`
```python
>>> my_cat = {
... 'size': 'fat',
... 'color': 'gray',
... 'disposition': 'loud',
... }
>>> my_cat['age_years'] = 2
>>> print(my_cat)
...
# {'size': 'fat', 'color': 'gray', 'disposition': 'loud', 'age_years': 2}
```
## Get value using subscript operator `[]`
In case the key is not present in dictionary <a target="_blank" href="https://docs.python.org/3/library/exceptions.html#KeyError">`KeyError`</a> is raised.
```python
>>> my_cat = {
... 'size': 'fat',
... 'color': 'gray',
... 'disposition': 'loud',
... }
>>> print(my_cat['size'])
...
# fat
>>> print(my_cat['eye_color'])
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# KeyError: 'eye_color'
```
## `values()`
The `values()` method gets the **values** of the dictionary:
```python
>>> pet = {'color': 'red', 'age': 42}
>>> for value in pet.values():
... print(value)
...
# red
# 42
```
## `keys()`
The `keys()` method gets the **keys** of the dictionary:
```python
>>> pet = {'color': 'red', 'age': 42}
>>> for key in pet.keys():
... print(key)
...
# color
# age
```
There is no need to use **.keys()** since by default you will loop through keys:
```python
>>> pet = {'color': 'red', 'age': 42}
>>> for key in pet:
... print(key)
...
# color
# age
```
## `items()`
The `items()` method gets the **items** of a dictionary and returns them as a <router-link to=/cheatsheet/lists-and-tuples#the-tuple-data-type>Tuple</router-link>:
```python
>>> pet = {'color': 'red', 'age': 42}
>>> for item in pet.items():
... print(item)
...
# ('color', 'red')
# ('age', 42)
```
Using the `keys()`, `values()`, and `items()` methods, a for loop can iterate over the keys, values, or key-value pairs in a dictionary, respectively.
```python
>>> pet = {'color': 'red', 'age': 42}
>>> for key, value in pet.items():
... print(f'Key: {key} Value: {value}')
...
# Key: color Value: red
# Key: age Value: 42
```
## `get()`
The `get()` method returns the value of an item with the given key. If the key doesn't exist, it returns `None`:
```python
>>> wife = {'name': 'Rose', 'age': 33}
>>> f'My wife name is {wife.get("name")}'
# 'My wife name is Rose'
>>> f'She is {wife.get("age")} years old.'
# 'She is 33 years old.'
>>> f'She is deeply in love with {wife.get("husband")}'
# 'She is deeply in love with None'
```
You can also change the default `None` value to one of your choice:
```python
>>> wife = {'name': 'Rose', 'age': 33}
>>> f'She is deeply in love with {wife.get("husband", "lover")}'
# 'She is deeply in love with lover'
```
## Adding items with `setdefault()`
It's possible to add an item to a dictionary in this way:
```python
>>> wife = {'name': 'Rose', 'age': 33}
>>> if 'has_hair' not in wife:
... wife['has_hair'] = True
```
Using the `setdefault` method, we can make the same code more short:
```python
>>> wife = {'name': 'Rose', 'age': 33}
>>> wife.setdefault('has_hair', True)
>>> wife
# {'name': 'Rose', 'age': 33, 'has_hair': True}
```
## Removing Items
### `del`
The `del` method removes an item based on a given key.
```python
>>> wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
>>> del wife['age']
>>> wife
# {'name': 'Rose', 'hair': 'brown'}
```
## Checking keys in a Dictionary
```python
>>> person = {'name': 'Rose', 'age': 33}
>>> 'name' in person.keys()
# True
>>> 'height' in person.keys()
# False
>>> 'skin' in person # You can omit keys()
# False
```
## Checking values in a Dictionary
```python
>>> person = {'name': 'Rose', 'age': 33}
>>> 'Rose' in person.values()
# True
>>> 33 in person.values()
# True
```
## Pretty Printing
```python
>>> import pprint
>>> wife = {'name': 'Rose', 'age': 33, 'has_hair': True, 'hair_color': 'brown', 'height': 1.6, 'eye_color': 'brown'}
>>> pprint.pprint(wife)
# {'age': 33,
# 'eye_color': 'brown',
# 'hair_color': 'brown',
# 'has_hair': True,
# 'height': 1.6,
# 'name': 'Rose'}
```
## Dict comprehension
```python
>>> c = {'name': 'Pooka', 'age': 5}
>>> {v: k for k, v in c.items()}
{'Pooka': 'name', 5: 'age'}
```
# Sets
A set is an unordered collection with no duplicate elements. Basic uses include membership testing and eliminating duplicate entries.
## Initializing a set
There are two ways to create sets: using curly braces `{}` and the built-in function `set()`
> When creating set, be sure to not use empty curly braces <code>{}</code> or you will get an empty dictionary instead.
```python
>>> s = {1, 2, 3}
>>> s = set([1, 2, 3])
>>> s = {} # this will create a dictionary instead of a set
>>> type(s)
# <class 'dict'>
```
## Unordered collections of unique elements
A set automatically remove all the duplicate values.
```python
>>> s = {1, 2, 3, 2, 3, 4}
>>> s
# {1, 2, 3, 4}
```
And as an unordered data type, they can't be indexed.
```python
>>> s = {1, 2, 3}
>>> s[0]
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# TypeError: 'set' object does not support indexing
```
## set `add()` and `update()`
Using the `add()` method we can add a single element to the set.
```python
>>> s = {1, 2, 3}
>>> s.add(4)
>>> s
# {1, 2, 3, 4}
```
And with `update()`, multiple ones:
```python
>>> s = {1, 2, 3}
>>> s.update([2, 3, 4, 5, 6])
>>> s
# {1, 2, 3, 4, 5, 6}
```
## set `remove()` and `discard()`
Both methods will remove an element from the set, but `remove()` will raise a `key error` if the value doesn't exist.
```python
>>> s = {1, 2, 3}
>>> s.remove(3)
>>> s
# {1, 2}
>>> s.remove(3)
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# KeyError: 3
```
`discard()` won't raise any errors.
```python
>>> s = {1, 2, 3}
>>> s.discard(3)
>>> s
# {1, 2}
>>> s.discard(3)
```
## set `union()`
`union()` or `|` will create a new set that with all the elements from the sets provided.
```python
>>> s1 = {1, 2, 3}
>>> s2 = {3, 4, 5}
>>> s1.union(s2) # or 's1 | s2'
# {1, 2, 3, 4, 5}
```
## set `intersection()`
`intersection` or `&` will return a set with only the elements that are common to all of them.
```python
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s3 = {3, 4, 5}
>>> s1.intersection(s2, s3) # or 's1 & s2 & s3'
# {3}
```
## set `difference()`
`difference` or `-` will return only the elements that are unique to the first set (invoked set).
```python
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s1.difference(s2) # or 's1 - s2'
# {1}
>>> s2.difference(s1) # or 's2 - s1'
# {4}
```
## set `symetric_difference()`
`symetric_difference` or `^` will return all the elements that are not common between them.
```python
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s1.symmetric_difference(s2) # or 's1 ^ s2'
# {1, 4}
```
## Set comprehension
```python
>>> b = {"abc", "def"}
>>> {s.upper() for s in b}
{"ABC", "DEF"}
```