### Introduction

A dictionary in Python is a collection of items that stores data as key-value pairs. In Python 3.7 and later versions, dictionaries are sorted by the order of item insertion. In earlier versions, they were unordered.

Let's have a look at how we can sort a dictionary on basis of the values they contain.

### Sort Dictionary Using a *for* Loop

We can sort a dictionary with the help of a `for`

loop. First, we use the `sorted()`

function to order the values of the dictionary. We then loop through the sorted values, finding the keys for each value. We add these keys-value pairs in the sorted order into a new dictionary.

**Note:** Sorting does not allow you to re-order the dictionary in-place. We are writing the ordered pairs in a completely new, empty dictionary.

```
dict1 = {1: 1, 2: 9, 3: 4}
sorted_values = sorted(dict1.values()) # Sort the values
sorted_dict = {}
for i in sorted_values:
for k in dict1.keys():
if dict1[k] == i:
sorted_dict[k] = dict1[k]
break
print(sorted_dict)
```

If you run this with the Python interpreter you would see:

```
{1: 1, 3: 4, 2: 9}
```

Now that we've seen how to sort with loops, let's look at a more popular alternative that uses the `sorted()`

function.

### Sort Dictionary Using the *sorted()* Function

We previously used the `sorted()`

function to sort the values of an array. When sorting a dictionary, we can pass one more argument to the `sorted()`

function like this: `sorted(dict1, key=dict1.get)`

.

Here, `key`

is a function that's called on each element before the values are compared for sorting. The `get()`

method on dictionary objects returns the value of for a dictionary's key.

The `sorted(dict1, key=dict1.get)`

expression will return the list of keys whose values are sorted in order. From there, we can create a new, sorted dictionary:

```
dict1 = {1: 1, 2: 9, 3: 4}
sorted_dict = {}
sorted_keys = sorted(dict1, key=dict1.get) # [1, 3, 2]
for w in sorted_keys:
sorted_dict[w] = dict1[w]
print(sorted_dict) # {1: 1, 3: 4, 2: 9}
```

Using the `sorted()`

function has reduced the amount of code we had to write when using `for`

loops. However, we can further combine the `sorted()`

function with the `itemgetter()`

function for a more succinct solution to sorting dictionaries by values.

#### Sort Dictionary Using the *operator* Module and *itemgetter()*

The `operator`

module includes the `itemgetter()`

function. This function returns a callable object that returns an item from an object.

For example, let's use to `itemgetter()`

to create a callable object that returns the value of any dictionary with a key that's `2`

:

```
import operator
dict1 = {1: 1, 2: 9}
get_item_with_key_2 = operator.itemgetter(2)
print(get_item_with_key_2(dict1)) # 9
```

Every dictionary has access to the `items()`

method. This function returns the key-value pairs of a dictionary as a list of tuples. We can sort the list of tuples by using the `itemgetter()`

function to pull the second value of the tuple i.e. the value of the keys in the dictionary.

Once it's sorted, we can create a dictionary based on those values:

```
import operator
dict1 = {1: 1, 2: 9, 3: 4}
sorted_tuples = sorted(dict1.items(), key=operator.itemgetter(1))
print(sorted_tuples) # [(1, 1), (3, 4), (2, 9)]
sorted_dict = {k: v for k, v in sorted_tuples}
print(sorted_dict) # {1: 1, 3: 4, 2: 9}
```

With much less effort, we have a dictionary sorted by values!

As the `key`

argument accepts any function, we can use lambda functions to return dictionary values so they can be sorted. Let's see how.

#### Sort Dictionary Using a Lambda Function

Lambda functions are anonymous, or nameless, functions in Python. We can use lamba functions to get the value of a dictionary item without having to import the `operator`

module for `itemgetter()`

. If you'd like to learn more about lambas, you can read about them in our guide to Lambda Functions in Python.

Let's sort a dictionary by values using a lambda function in the `key`

argument of `sorted()`

:

```
dict1 = {1: 1, 2: 9, 3: 4}
sorted_tuples = sorted(dict1.items(), key=lambda item: item[1])
print(sorted_tuples) # [(1, 1), (3, 4), (2, 9)]
sorted_dict = {k: v for k, v in sorted_tuples}
print(sorted_dict) # {1: 1, 3: 4, 2: 9}
```

Note that the methods we've discussed so far only work with Python 3.7 and later. Let's see what we can do for earlier versions of Python.

### Returning a New Dictionary with Sorted Values

After sorting a dictionary by values, to keep a sorted dictionary in Python versions before 3.7, you have to use the `OrderedDict`

- available in the `collections`

module. These objects are dictionaries that keep the order of insertion.

Here's an example of sorting and using `OrderedDict`

:

```
import operator
from collections import OrderedDict
dict1 = {1: 1, 2: 9, 3: 4}
sorted_tuples = sorted(dict1.items(), key=operator.itemgetter(1))
print(sorted_tuples) # [(1, 1), (3, 4), (2, 9)]
sorted_dict = OrderedDict()
for k, v in sorted_tuples:
sorted_dict[k] = v
print(sorted_dict) # {1: 1, 3: 4, 2: 9}
```

### Conclusion

This tutorial showed how a dictionary can be sorted based on its values. We first sorted a dictionary using two for loops. We then improved our sort by using the `sorted()`

function. We've also seen the `itemgetter()`

function from the `operator`

module can make our solution more succinct.

Lastly, we adapted our solution to work on Python versions lower than 3.7.

Variations of the `sorted()`

function are the most popular and reliable to sort a dictionary by values.