# 5 Best Ways to Sort a List of Tuples in Increasing Order by the Last Element

Rate this post

π‘ Problem Formulation: This article provides various methods to sort a list of tuples based on the last element of each tuple. For instance, given the input `[(1, 2), (3, 1), (5, 0)]`, the desired output should be `[(5, 0), (3, 1), (1, 2)]`.

## Method 1: Using the Sorted Function and a Lambda Expression

The `sorted()` function in Python can sort any iterable. It accepts a key parameter where you can specify a function to apply to the items being sorted. By using a lambda expression as a key that returns the last element of each tuple, we can sort the list by the last element of the tuples in increasing order.

Here’s an example:

```tuples_list = [(1, 2), (3, 1), (5, 0)]
sorted_tuples = sorted(tuples_list, key=lambda x: x[-1])
print(sorted_tuples)```

The output of this code snippet is:

`[(5, 0), (3, 1), (1, 2)]`

This code snippet defines a list of tuples and sorts it by using a lambda function that accesses the last element of each tuple, which is `x[-1]`. This is passed to the key parameter of the `sorted()` function which performs the sorting based on the returned element from the lambda function.

## Method 2: Using the sort Method with a Custom Function

Python’s list method `sort()` can be used in-place to sort the list it is called on. Similar to the `sorted()` function, `sort()` also accepts a key parameter. By defining a custom function to return the last element of each tuple, you can achieve the intended sort order. This can be more verbose but also more explicit.

Here’s an example:

```def get_last(t):
return t[-1]

tuples_list = [(1, 2), (3, 1), (5, 0)]
tuples_list.sort(key=get_last)
print(tuples_list)```

The output of this code snippet is:

`[(5, 0), (3, 1), (1, 2)]`

In this example, a function `get_last()` is defined to return the last element of a tuple. This function is then used as the key in the `list.sort()` method to sort the list of tuples in-place.

## Method 3: Using Operator Module

The `operator` module in Python provides a set of efficient functions corresponding to the intrinsic operators of Python. Using `operator.itemgetter()`, which constructs a callable that assumes an iterable (like our tuple) can simplify the sorting operation.

Here’s an example:

```import operator

tuples_list = [(1, 2), (3, 1), (5, 0)]
sorted_tuples = sorted(tuples_list, key=operator.itemgetter(-1))
print(sorted_tuples)```

The output of this code snippet is:

`[(5, 0), (3, 1), (1, 2)]`

The code above uses `operator.itemgetter(-1)` as the key function for sorting the list of tuples. The `itemgetter()` fetches the last item from each tuple, and sorted uses these items to order the list.

## Method 4: Using a For Loop and Insertion Logic

This method manually sorts the list of tuples by extracting the last elements, comparing them, and inserting them into a new sorted list. It goes through each tuple and inserts it into the correct position of an initially empty list based on the last element’s value.

Here’s an example:

```def insert_sorted(tuples_list, new_tuple):
for i, current_tuple in enumerate(tuples_list):
if new_tuple[-1] < current_tuple[-1]:
tuples_list.insert(i, new_tuple)
return
tuples_list.append(new_tuple)

tuples_list = [(1, 2), (3, 1), (5, 0)]
sorted_tuples = []
for t in tuples_list:
insert_sorted(sorted_tuples, t)

print(sorted_tuples)```

The output of this code snippet is:

`[(5, 0), (3, 1), (1, 2)]`

This snippet illustrates a more manual approach to sorting where a new, sorted, list is created. Each tuple is inserted into the sorted list in the correct position using the custom `insert_sorted` function. While this method provides a clear understanding of the sorting process, it is less efficient than other methods presented.

## Bonus One-Liner Method 5: Using List Comprehensions with Sorted

Combine Python’s powerful list comprehensions with the sorted function to sort a list of tuples in a single line. This is a concise and elegant one-liner approach.

Here’s an example:

```tuples_list = [(1, 2), (3, 1), (5, 0)]
sorted_tuples = sorted([(t[-1], t) for t in tuples_list])
sorted_tuples = [t[1] for t in sorted_tuples]
print(sorted_tuples)```

The output of this code snippet is:

`[(5, 0), (3, 1), (1, 2)]`

This approach first creates a new list where each original tuple is paired with its last element for sorting, then sorts it and extracts the original tuples in a separate list comprehension. It’s a neat trick but perhaps less clear to read at a glance compared to a straightforward lambda.

## Summary/Discussion

• Method 1: Using sorted and lambda. Strength: Concise and Pythonic. Weakness: Can be less readable for lambda-averse programmers.
• Method 2: Using sort with a custom function. Strength: More explicit and possibly clearer. Weakness: Slightly more verbose than using a lambda.
• Method 3: Using the operator module. Strength: Clear and potentially faster for large datasets. Weakness: Requires importing an additional module.
• Method 4: Using a for loop with insertion logic. Strength: Explicit sorting logic which could be educational. Weakness: Not as efficient or elegant as other methods.
• Method 5: Using list comprehensions with sorted. Strength: Compact one-liner. Weakness: Less readability and the need for a two-step process.