If you want to learn how to work with the sort() method in your Python projects, then this article is for you. This method is very powerful and you can customize it to fit your needs, so let's see how it works in detail.

如果您想学习如何在Python项目中使用sort()方法,那么本文适合您。 此方法功能非常强大,您可以根据需要对其进行自定义,因此让我们详细了解它的工作原理。

You will learn:


  • How to use this method and customize its functionality.

  • When to use it and when not to use it.

  • How to call it passing different combinations of arguments.

  • How to sort a list in ascending and descending order.

  • How to compare the elements of a list based on intermediate values.

  • How you can pass lambda functions to this method.

  • How this method compares to the sorted() function.


  • Why the sort() method performs a stable sort.


  • How the process of mutation works behind the scenes.


Are you ready? Let's begin! ⭐

你准备好了吗? 让我们开始! ⭐

目的和用例 (Purpose and Use Cases)

With the sort() method, you can sort a list in either:


  • Ascending Order

  • Descending Order


This method is used to sort a list in place, which means that it mutates it or modifies it directly without creating additional copies, so remember:


You will learn more about mutation in this article (I promise!), but for now it's very important that you know that the sort() method modifies the list, so its original version is lost.


Because of this, you should only use this method if:


  • You want to modify (sort) the list permanently.

  • You don't need to keep the original version of the list.


If this fits your needs, then the .sort() method is exactly what you are looking for.


🔸语法和参数 (🔸 Syntax and Arguments)

Let's see how you can call .sort() to take advantage of its full power.


This is the most basic call (with no arguments):


If you don't pass any arguments, by default:


  • The list will be sorted in ascending order.

  • The elements of the list will be compared directly using their values with the < operator.


For example:


>>> b = [6, 3, 8, 2, 7, 3, 9]
>>> b.sort()
>>> b
[2, 3, 3, 6, 7, 8, 9] # Sorted!

自定义参数 (Custom Arguments  )

To customize how the sort() method works, you can pass two optional arguments:


  • Key

  • Reverse


Let's see how they change the behavior of this method. Here we have a method call with these two arguments:

让我们看看它们如何更改此方法的行为。 这里有两个参数的方法调用:

Before explaining how they work, I would like to explain something that you probably noticed in the diagram above – in the method call, the names of the parameters have to be included before their corresponding values, like this:


  • key=<f>


  • reverse=<value>


This is because they are keyword-only arguments. If you are passing a custom value for them, their names have to be specified in the method call, followed by an equal sign = and their corresponding values, like this:

这是因为它们是仅关键字的参数 。 如果要为它们传递自定义值,则必须在方法调用中指定它们的名称 ,后跟等号=及其对应的值,如下所示:

Otherwise, if you try to pass the arguments directly as we normally do for positional parameters, you will see this error because the function will not know which argument corresponds to which parameter:


TypeError: sort() takes no positional arguments

逆转 (Reverse)

Now that you know what keyword-only arguments are, let's start with reverse.


The value of reverse can be either True or False:


  • False means that the list will be sorted in ascending order.


  • True means that the list will be sorted in descending (reverse) order.


💡 Tip: By default, its value is False – if you don't pass any arguments for this parameter, the list is sorted in ascending order.

💡 提示:默认情况下,其值为False –如果您不为此参数传递任何参数,则列表将按升序排序。

Here we have a few examples:


# List of Integers
>>> b = [6, 3, 8, 2, 7, 3, 9]
>>> b.sort()
>>> b
[2, 3, 3, 6, 7, 8, 9]

# List of Strings
>>> c = ["A", "Z", "D", "T", "U"]
>>> c.sort()
>>> c
['A', 'D', 'T', 'U', 'Z']

💡 Tip: If the elements of the list are strings, they are sorted alphabetically.

💡 提示:如果列表中的元素是字符串,则它们将按字母顺序排序。

# List of Integers
>>> b = [6, 3, 8, 2, 7, 3, 9]
>>> b.sort(reverse=True)
>>> b
[9, 8, 7, 6, 3, 3, 2]

# List of Strings
>>> c = ["A", "Z", "D", "T", "U"]
>>> c.sort(reverse=True)
>>> c
['Z', 'U', 'T', 'D', 'A']

💡 Tip: Notice how the list is sorted in descending order if reverse is True.

💡 提示:请注意,如果reverseTrue则列表将按降序排序。


Now that you know how to work with the reverse parameter, let's see the key parameter.


This parameter is a little bit more detailed because it determines how the elements of the list are be compared during the sorting process.


The value of key is either:


  • None, which means that the elements of the list will be compared directly. For example, in a list of integers, the integers themselves can be used for the comparison.

    None ,这意味着将直接比较列表中的元素。 例如,在整数列表中,整数本身可用于比较。

  • A function of one argument that generates an intermediate value for each element. This intermediate value is calculated only once and it's used to make the comparisons during the entire sorting process. We use this when we don't want to compare the elements directly, for example, when we want to compare strings based on their length (the intermediate value).

    一个参数 函数 ,为每个元素生成一个中间值。 该中间值仅计算一次,并在整个排序过程中用于进行比较。 当我们不想直接比较元素时,例如当我们要根据字符串的长度(中间值)比较字符串时,可以使用它。

💡 Tip: By default, the value of key is None, so the elements are compared directly.

💡 提示:默认情况下, key值为None ,因此可以直接比较元素。

For example:


Let's say that we want to sort a list of strings based on their length, from the shortest string to the longest string. We can pass the function len as the value of key, like this:

假设我们要根据字符串的长度(从最短的字符串到最长的字符串)对字符串列表进行排序。 我们可以将函数len作为key的值传递,如下所示:

>>> d = ["aaa", "bb", "c"]
>>> d.sort(key=len)
>>> d
['c', 'bb', 'aaa']

💡 Tip: Notice that we are only passing the name of the function (len) without parenthesis because we are not calling the function. This is very important.

提示:请注意,由于我们没有调用函数,因此仅传递函数名称( len )而没有括号。 这个非常重要。

Notice the difference between comparing the elements directly and comparing their length (see below). Using the default value of key (None) would have sorted the strings alphabetically (left), but now we are sorting them based on their length (right):

注意直接比较元素和比较元素长度之间的区别(请参见下文)。 使用key的默认值( None )可以按字母顺序对字符串进行排序(左),但是现在我们根据字符串的长度(右)对其进行排序:

What happens behind the scenes? Each element is passed as an argument to the len() function, and the value returned by this function call is used to perform the comparisons during the sorting process:

幕后发生了什么? 每个元素都作为参数传递给len()函数,此函数调用返回的值用于在排序过程中执行比较:

This results in a list with a different sorting criteria: length.


Here we have another example:


Another interesting example is sorting a list of strings as if they were all written in lowercase letters (for example, making "Aa" equivalent to "aa").

另一个有趣的示例是对字符串列表进行排序,就好像它们都是用小写字母书写一样(例如,使“ Aa”等效于“ aa”)。

According to lexicographical order, capital letters come before lowercase letters:


>>> "E" < "e"

So the string "Emma" would come before "emily" in a sorted list, even if their lowercase versions would be in the opposite order:


>>> "Emma" < "emily"
>>> "emma" < "emily"

To avoid distinguishing between capital and lowercase letters, we can pass the function str.lower as key. This will generate a lowercase version of the strings that will be used for the comparisons:

为了避免区分大小写字母,我们可以将函数str.lower作为key传递。 这将生成将用于比较的字符串的小写版本:

>>> e = ["Emma", "emily", "Amy", "Jason"]
>>> e.sort(key=str.lower)
>>> e
['Amy', 'emily', 'Emma', 'Jason']

Notice that now, "emily" comes before "Emma" in the sorted list, which is exactly what we wanted.

请注意,现在,已排序列表中的"Emma"之前是"emily" ,这正是我们想要的。

💡 Tip: if we had used the default sorting process, all the strings that started with an uppercase letter would have come before all the strings that started with a lowercase letter:

💡 提示:如果我们使用了默认的排序过程,则所有以大写字母开头的字符串都将排在所有以小写字母开头的字符串之前:

>>> e = ["Emma", "emily", "Amy", "Jason"]
>>> e.sort()
>>> e
['Amy', 'Emma', 'Jason', 'emily']

Here is an example using Object-Oriented Programming (OOP):


If we have this very simple Python class:


>>> class Client:
	def __init__(self, age):
		self.age = age

And we create four instances:


>>> client1 = Client(67)
>>> client2 = Client(23)
>>> client3 = Client(13)
>>> client4 = Client(35)

We can make a list that references them:


>>> clients = [client1, client2, client3, client4]

Then, if we define a function to get the age of these instances:


>>> def get_age(client):
	return client.age

We can sort the list based on their age by passing the get_age function an an argument:


>>> clients.sort(key=get_age)

This is the final, sorted version of the list. We use a for loop to print the age of the instances in the order that they appear in the list:

这是列表的最终排序版本。 我们使用一个for循环按照实例在列表中出现的顺序来打印实例的寿命:

>>> for client in clients:


Exactly what we wanted – now the list is sorted in ascending order based on the age of the instances.


💡 Tip: Instead of defining a get_age function, we could have used a lambda function to get the age of each instance, like this:


>>> clients.sort(key=lambda x: x.age)

Lambda functions are small and simple anonymous functions, which means that they don't have a name. They are very helpful for these scenarios when we only want to use them in particular places for a very short period of time.

Lambda函数是小型且简单的匿名函数,这意味着它们没有名称。 当我们只想在特定位置短时间使用它们时,它们对于这些情况非常有用。

This is the basic structure of the lambda function that we are using to sort the list:


传递两个参数 (Passing Both Arguments)

Awesome! Now you know to customize the functionality of the sort() method. But you can take your skills to a whole new level by combining the effect of key and reverse in the same method call:

太棒了! 现在您知道了自定义sort()方法的功能。 但是您可以通过在同一方法调用中组合keyreverse key的效果,将您的技能提升到一个全新的水平:

These are the different combinations of the arguments and their effect:


仅关键字参数的顺序不重要 (The Order of Keyword-Only Arguments Doesn't Matter)

Since we are specifying the names of the arguments, we already know which value corresponds to which parameter, so we can include either key or reverse first in the list and the effect will be exactly the same.

由于我们正在指定参数的名称,因此我们已经知道哪个值对应于哪个参数,因此我们可以在列表中首先包含keyreverse ,并且效果将完全相同。

So this method call:


Is equivalent to:


This is an example:


>>> a = ["Zz", "c", "y", "o", "F"]
>>> a.sort(key=str.lower, reverse=True)
>>> a
['Zz', 'y', 'o', 'F', 'c']

If we change the order of the arguments, we get the exact same result:


>>> a = ["Zz", "c", "y", "o", "F"]
>>> a.sort(reverse=True, key=str.lower)
>>> a
['Zz', 'y', 'o', 'F', 'c']

🔹返回值 (🔹 Return Value)

Now let's talk a little bit about the return value of this method. The sort() method returns None – it does not return a sorted version of the list, like we might intuitively expect.

现在让我们谈谈该方法的返回值。 该sort()方法返回None - 返回列表的排序版本,就像我们可以直观地期待。

According to the Python Documentation:


To remind users that it operates by side effect, it does not return the sorted sequence.

Basically, this is used to remind us that we are modifying the original list in memory, not generating a new copy of the list.


This is an example of the return value of sort():


>>> nums = [6.5, 2.4, 7.3, 3.5, 2.6, 7.4]

# Assign the return value to this variable:
>>> val = nums.sort()

# Check the return value:
>>> print(val)

See? None was returned by the method call.

看到? 方法调用None返回None

💡 Tip: It is very important not to confuse the sort() method with the sorted() function, which is a function that works very similarly, but doesn't modify the original list. Instead sorted() generates and returns a new copy of the list, already sorted.

提示:不要将sort()方法与sorted()函数混淆,这是一个非常相似的函数,但不会修改原始列表,这一点非常重要。 而是sorted()生成并返回已排序的列表的新副本。

This is an example that we can use to compare them:


This is very important because their effect is very different. Using the sort() method when you intended to use sorted() can introduce serious bugs into your program because you might not realize that the list is being mutated.

这非常重要,因为它们的效果有很大不同。 当您打算使用sorted()时使用sort()方法可能会在程序中引入严重的错误,因为您可能没有意识到列表已被更改。

(sort()方法执行稳定的排序 (🔸 The sort() Method Performs a Stable Sort)

Now let's talk a little bit about the characteristics of the sorting algorithm used by sort().


This method performs a stable sort because it works with an implementation of TimSort, a very efficient and stable sorting algorithm.


According to the Python Documentation:


A sort is stable if it guarantees not to change the relative order of elements that compare equal — this is helpful for sorting in multiple passes (for example, sort by department, then by salary grade).


This means that if two elements have the same value or intermediate value (key), they are guaranteed to stay in the same order relative to each other.


Let's see what I mean with this. Please take a look at this example for a few moments:

让我们看看我的意思。 请花一点时间看一下此示例:

>>> d = ["BB", "AA", "CC", "A", "B", "AAA", "BBB"]
>>> d.sort(key=len)
>>> d
['A', 'B', 'BB', 'AA', 'CC', 'AAA', 'BBB']

We are comparing the elements based on their length because we passed the len function as the argument for key.


We can see that there are three elements with length 2: "BB", "AA", and "CC" in that order.

我们可以看到有三个长度分别为2的元素: "BB""AA""CC"

Now, notice that these three elements are in the same relative order in the final sorted list:


This is because the algorithm is guaranteed to be stable and the three of them had the same intermediate value (key) during the sorting process (their length was 2, so their key was 2).


💡 Tip: The same happened with "A" and "B" (length 1) and "AAA" and "BBB" (length 3), their original order relative to each other was preserved.

💡 提示: "A""B" (长度为1)以及"AAA""BBB" (长度为3)也是如此,它们相对的原始顺序得以保留。

Now you know how the sort() method works, so let's dive into mutation and how it can affect your program.


🔹变异与风险 (🔹 Mutation and Risks)

As promised, let's see how the process of mutation works behind the scenes:


When you define a list in Python, like this:


a = [1, 2, 3, 4]

You create an object at a specific memory location. This location is called the "memory address" of the object, represented by a unique integer called an id.

您在特定的内存位置创建一个对象。 此位置称为对象的“内存地址”,由称为id的唯一整数表示。

You can think of an id as a "tag" used to identify a specific place in memory:


You can access a list's id using the id() function, passing the list as argument:


>>> a = [1, 2, 3, 4]
>>> id(a)

When you mutate the list, you change it directly in memory. You may ask, why is this so risky?

当你发生变异的名单,你直接在内存中修改它。 您可能会问,为什么这样有风险?

It's risky because it affects every single line of code that uses the list after the mutation, so you may be writing code to work with a list that is completely different from the actual list that exists in memory after the mutation.


This is why you need to be very careful with methods that cause mutation.


In particular, the sort() method mutates the list. This is an example of its effect:

特别地, sort()方法使列表变异 。 这是其效果的一个示例:

Here is an example:


# Define a list
>>> a = [7, 3, 5, 1]

# Check its id
>>> id(a)

# Sort the list using .sort()
>>> a.sort()

# Check its id (it's the same, so the list is the same object in memory)
>>> id(a)

# Now the list is sorted. It has been mutated!
>>> a
[1, 3, 5, 7]

The list was mutated after calling .sort().


Every single line of code that works with list a after the mutation has occurred will use the new, sorted version of the list. If this was not what you intended, you may not realize that other parts of your program are working with the new version of the list.

发生突变后,与list a配合使用的每一行代码都将使用列表的新排序版本。 如果这不是您想要的,您可能不会意识到程序的其他部分正在使用列表的新版本。

Here is another example of the risks of mutation within a function:


# List 
>>> a = [7, 3, 5, 1]

# Function that prints the elements of the list in ascending order.
>>> def print_sorted(x):
	for elem in x:

# Call the function passing 'a' as argument	
>>> print_sorted(a)

# Oops! The original list was mutated.
>>> a
[1, 3, 5, 7]

The list a that was passed as argument was mutated, even if that wasn't what you intended when you initially wrote the function.


💡 Tip: If a function mutates an argument, it should be clearly stated to avoid introducing bugs into other parts of your program.

💡 提示:如果函数改变了参数,则应明确声明该参数,以避免将错误引入程序的其他部分。

🔸sort()方法摘要 (🔸 Summary of the sort() Method)

  • The sort() method lets you sort a list in ascending or descending order.


  • It takes two keyword-only arguments: key and reverse.

    它使用两个仅关键字的参数: keyreverse

  • reverse determines if the list is sorted in ascending or descending order.


  • key is a function that generates an intermediate value for each element, and this value is used to do the comparisons during the sorting process.


  • The sort() method mutates the list, causing permanent changes. You need to be very careful and only use it if you do not need the original version of the list.

    sort()方法会使列表发生变化,从而导致永久更改。 您需要非常小心,仅在不需要列表的原始版本时才使用它。

I really hope that you liked my article and found it helpful. Now you can work with the sort() method in your Python projects. Check out my online courses. Follow me on Twitter. 👍

我真的希望您喜欢我的文章并认为对您有所帮助。 现在,您可以在Python项目中使用sort()方法。 查看我的在线课程 。 在Twitter上关注我。 👍



  • 2
  • 0
  • 15
  • 一键三连
  • 扫一扫,分享海报

评论将由博主筛选后显示,对所有人可见 | 还能输入1000个字符
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页
钱包余额 0