# 5 Best Ways to Sort Lists of Floats in Descending Order in Python

π‘ Problem Formulation: You have a list of floating-point numbers, and you need to sort it in descending order. For example, given the input `[3.14, 2.71, 1.62]`, the desired output is `[3.14, 2.71, 1.62]` sorted to `[3.14, 2.71, 1.62]`.

## Method 1: Using the sorted() Function

This method involves using Python’s built-in `sorted()` function, specifying the `reverse=True` parameter to sort the list in descending order. This function returns a new list and does not change the original list.

Here’s an example:

```floats = [1.23, 2.34, 3.45, 4.56]
sorted_floats = sorted(floats, reverse=True)
print(sorted_floats)
```

Output:

```[4.56, 3.45, 2.34, 1.23]
```

This code snippet first defines a list of floats and then uses the `sorted()` function with `reverse=True` to sort them in descending order, which will return a new sorted list.

## Method 2: Using the sort() List Method

The `sort()` method is a list method that sorts the list in place. Like the `sorted()` function, it can take a `reverse=True` parameter to sort the list in descending order.

Here’s an example:

```floats = [4.67, 3.56, 2.45, 1.34]
floats.sort(reverse=True)
print(floats)
```

Output:

```[4.67, 3.56, 2.45, 1.34]
```

The `sort()` method modifies the original list. After calling `floats.sort(reverse=True)`, the list `floats` is sorted in descending order.

## Method 3: Using Lambda Functions

Lambda functions can be used in the `sorted()` function or `sort()` method to reverse the sorting order. While not strictly necessary for sorting in descending order, they can be helpful for more complex sorting criteria.

Here’s an example:

```floats = [7.89, 6.78, 5.67, 4.56]
sorted_floats = sorted(floats, key=lambda x: -x)
print(sorted_floats)
```

Output:

```[7.89, 6.78, 5.67, 4.56]
```

The lambda function returns the negative of each float, thus reversing the sorting order when passed as the `key` argument to the `sorted()` function.

## Method 4: Using List Comprehensions and reversed()

This method combines list comprehensions with the built-in `reversed()` function to reverse the sorted list. It is a two-step process but very readable.

Here’s an example:

```floats = [2.71, 1.61, 3.14]
sorted_floats = [x for x in reversed(sorted(floats))]
print(sorted_floats)
```

Output:

```[3.14, 2.71, 1.61]
```

By first sorting the list and then reversing it with a list comprehension, the floats are effectively sorted in descending order.

## Bonus One-Liner Method 5: Using the Reverse Parameter Directly

This is a variant one-liner that directly uses the `reverse` parameter with the `sort()` method for in-place sorting.

Here’s an example:

```floats = [3.14, 2.71, 1.61]
floats.sort(reverse=True)
print(floats)
```

Output:

```[3.14, 2.71, 1.61]
```

This concise one-liner sorts the list `floats` in-place in descending order by setting the `reverse` parameter of the `sort()` method to `True`.

## Summary/Discussion

• Method 1: Using the sorted() Function. Offers a quick, one-liner that sorts lists and returns a new list, leaving the original list unchanged. However, this method may not be as efficient memory-wise for large lists, as it creates a second list.
• Method 2: Using the sort() List Method. This method sorts the list in place without creating a new list, which can be more memory-efficient. However, because it modifies the original list, it isn’t suitable when you need to retain the original order.
• Method 3: Using Lambda Functions. Provides flexibility for custom sorting conditions, but in the case of descending sorting, it is a bit overkill since simpler options are available.
• Method 4: Using List Comprehensions and reversed(). This is a very Pythonic way to do it, combining functionality from multiple parts of the language, though it might be less direct and slightly slower than other methods due to the two-step process.
• Method 5: Bonus One-Liner. Perfect for a quick, in-place sort. It is as direct as you can get, but like Method 2, it alters the original list.