We can sort lists in Python using either the `.sort()`

method.

```
list1 = [2,4,3,1]
list1.sort()
# list1 will be [1,2,3,4]
```

However, sometimes we need to sort a list by a certain condition. For instance, let’s say we’re given a list of strings, and we need to sort it by the *lengths* of the strings:

```
ç
# what we want:
# lis = ["pear", "apple", "orange"]
```

Here, `"pear"`

comes first as it is the shortest string, and `"orange"`

comes last as it is the longest string.

### What Sorting Normally Does

```
lis = ["apple", "orange", "pear"]
lis.sort()# lis = ["apple", "orange", "pear"]
```

If we use the `.sort()`

method normally, our list will get sorted by the default way. In this case, as we are sorting strings, our list will get sorted by alphabetical order and will remain as `["apple", "orange", "pear"]`

### How To Sort By Length Of String

```
lis = ["apple", "orange", "pear"]
lis.sort(key=len)
# lis = ["pear", "apple", "orange"]
```

Here, notice that we added `key=len`

into the arguments of `.sort`

. This `key`

argument is what allows us to sort the list by length.

```
lis = ["apple", "orange", "pear"]
# len("apple") -> 5
# len("orange") -> 6
# len("pear") -> 4
```

Here, we can observe that each fruit string passed into the `len`

function returns a number. This number is the length of each string and is used to sort the list.

`"pear"`

with a length of 4 is thus the smallest value`"apple"`

with a length of 5 is the second smallest value`"orange"`

with a length of 6 is the largest value

### The Key Argument In .sort

In `lis.sort(key=len)`

, the `key`

argument must be a *function* that takes in 1 argument. Whatever this function returns will be the condition that Python will sort our list by.

If the `key`

function returns a smaller value (compared to the other elements in the list), the current element will be considered to be *smaller*. Here are a couple more examples

### Writing Our Own Condition For Key

```
lis = ["zaaaaa", "pineapple", "aaa"]
```

Let’s say we’re given this list above, and we want to sort it by the number of `"a"`

characters.

```
# what we want:
# lis = ["pineapple", "aaa", "zaaaaa"]
```

Here, we need to write a function to specify this condition.

```
def condition(element):
return element.count("a")
```

Our function here must take in 1 argument. After writing our function, we can then use our `condition`

to sort our list.

```
lis.sort(key=condition)
```

Let’s run through what’s happening here:

```
# condition("zaaaaa") -> 5 -> largest
# condition("pineapple") -> 1 -> smallest
# condition("aaa") -> 3 -> second smallest
```

And thus we get a list sorted by `condition`

:

```
["pineapple", "aaa", "zaaaaa"]
```

### A Couple More Examples

Sorting by the digit at the *one’s* place:

```
lis = [4,5,11,12,13]
def condition(element):
return element % 10
lis.sort(key=condition)
# lis = [11,12,13,4,5]
# condition(4) -> 4 -> 4th element
# condition(5) -> 5 -> 5th element
# condition(11) -> 1 -> smallest, hence 1st element
# condition(12) -> 2 -> 2nd element
# condition(13) -> 3 -> 3rd element
```

Sorting by the number of vowels:

```
lis = ["apple", "orange", "pear", "pineapple"]def condition(element):
total = 0
for vowel in "aeiou":
total += element.count(vowel)
return total
lis.sort(key=condition)
# lis = ["apple", "pear", "orange", "pineapple"]
# condition("apple") -> 2 vowels -> 1st
# condition("orange") -> 3 vowels -> 3rd
# condition("pear") -> 2 vowels -> 2nd
# condition("pineapple") -> 4 vowels -> 4th
```

Sorting by age ( `"age"`

dictionary key ):

```
lis = [
{"name":"rocky", "age":5},
{"name":"fifi", "age":3},
{"name":"remi", "age":6}
]
def condition(element):
return element["age"]
lis.sort(key=condition)
# lis = lis = [
{"name":"fifi", "age":3},
{"name":"rocky", "age":5},
{"name":"remi", "age":6}
]
```

### Doing This In One Line Using Lambda Functions

Consider this code where we sort by the number of `"a"`

characters:

```
lis = ["pineapple", "aaa", "zaaaaa"]
def condition(element):
return element.count("a")
lis.sort(key=condition)
```

We can actually do this in *one* line using a *lambda* function:

```
lis = ["pineapple", "aaa", "zaaaaa"]
lis.sort(key=lambda x:x.count("a"))
```

### How Lambda Functions Work

```
lambda input: output
```

A lambda function is essentially a normal function, but we don’t need to give it a name use the `def`

keyword.

```
def condition(element):
return element.count("a")
```

does the exact same thing as:

```
condition = lambda x:x.count("a")
```

Note that the variable `x`

here is decided by us — we can use any variable name as long as it’s valid eg. `a`

, `b`

, `element`

, etc.

### Sorting With Lambda Functions — Some Examples

Sorting by number of `"a"`

characters:

```
lis.sort(key=lambda x:x.count("a"))
```

Sorting by the digit in *one’s* place:

```
lis.sort(key=lambda x:x%10)
```

Sorting by the number of vowels:

```
lis.sort(key=lambda x:sum([x.count(v) for v in "aeiou"]))
```

Sorting by `"age"`

dictionary key:

```
lis.sort(key=lambda x:x["age"])
```

### Examples — Lambda Functions & Their Equivalent Normal Functions

Sorting by number of `"a"`

characters:

```
lis.sort(key=lambda x:x.count("a"))
# SAME AS
def condition(x):
return x.count("a")
lis.sort(key=condition)
```

Sorting by a digit in *one’s* place:

```
lis.sort(key=lambda x:x%10)
# SAME AS
def condition(x):
return x%10
lis.sort(key=condition)
```

Sorting by the number of vowels:

```
lis.sort(key=lambda x:sum([x.count(v) for v in "aeiou"]))
# SAME AS
def condition(x):
return sum(x.count(v) for v in "aeiou")
lis.sort(key=condition)
```

Sorting by `"age"`

dictionary key:

```
lis.sort(key=lambda x:x["age"])
# SAME AS
def condition(x):
return x["age"]
lis.sort(key=condition)
```

### Some Final Words

If *lambda* functions scare you for now, just stick with normal functions and use them to sort your list, and come back to *lambda* functions when you’re more comfortable. They are essentially the *same thing —* just that we can do lambda stuff in one line. Hope this article was helpful!