The `sorted()`

function takes a `key=`

parameter

```
newlist = sorted(list_to_be_sorted, key=lambda d: d['name'])
```

Alternatively, you can use `operator.itemgetter`

instead of defining the function yourself

```
from operator import itemgetter
newlist = sorted(list_to_be_sorted, key=itemgetter('name'))
```

For completeness, add `reverse=True`

to sort in descending order

```
newlist = sorted(list_to_be_sorted, key=itemgetter('name'), reverse=True)
```

### Python 3.7+ or CPython 3.6

Dicts preserve insertion order in Python 3.7+. Same in CPython 3.6, but it's an implementation detail.

```
>>> x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
>>> {k: v for k, v in sorted(x.items(), key=lambda item: item[1])}
{0: 0, 2: 1, 1: 2, 4: 3, 3: 4}
```

or

```
>>> dict(sorted(x.items(), key=lambda item: item[1]))
{0: 0, 2: 1, 1: 2, 4: 3, 3: 4}
```

### Older Python

It is not possible to sort a dictionary, only to get a representation of a dictionary that is sorted. Dictionaries are inherently orderless, but other types, such as lists and tuples, are not. So you need an ordered data type to represent sorted values, which will be a listâ€”probably a list of tuples.

For instance,

```
import operator
x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = sorted(x.items(), key=operator.itemgetter(1))
```

`sorted_x`

will be a list of tuples sorted by the second element in each tuple. `dict(sorted_x) == x`

.

And for those wishing to sort on keys instead of values:

```
import operator
x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = sorted(x.items(), key=operator.itemgetter(0))
```

In Python3 since unpacking is not allowed we can use

```
x = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_x = sorted(x.items(), key=lambda kv: kv[1])
```

If you want the output as a dict, you can use `collections.OrderedDict`

:

```
import collections
sorted_dict = collections.OrderedDict(sorted_x)
```

## Best Solution

I think the sortrows function is what you're looking for.