Python习惯地从改变数据的函数和方法中返回None，例如list。排序,列表。追加，随机。Shuffle，意思是它暗示了它正在变异的事实。

如果你想接受一个可迭代对象，并返回一个新的、已排序的可迭代对象项列表，请使用sorted内置函数。

这是我在其他答案中没有看到的一个小智慧:

python中所有修改列表的可变对象(如列表)的方法都返回None。因此，对于列表，这也包括list.append()， list.reverse()等。这就是为什么语法应该是

myList.sort（）

同时，任何不可变对象(比如字符串)的方法都必须这样赋值:

myString = myString.strip()

Python有两种类型的排序:排序方法(或“成员函数”)和排序函数。sort方法对指定对象的内容进行操作——可以将其视为对象对自身进行重新排序的操作。sort函数是对由对象表示的数据进行的操作，并返回一个新对象，该对象具有按顺序排序的相同内容。

给定一个名为l的整数列表，如果调用l.sort()，列表本身将被重新排序:

>>> l = [1, 5, 2341, 467, 213, 123]
>>> l.sort()
>>> l
[1, 5, 123, 213, 467, 2341]

此方法没有返回值。但是如果我们尝试分配l.sort()的结果呢?

>>> l = [1, 5, 2341, 467, 213, 123]
>>> r = l.sort()
>>> print(r)
None

现在R实际上等于零。这是一个奇怪的，有点烦人的细节，程序员在离开Python一段时间后很可能会忘记(这就是我写这篇文章的原因，这样我就不会再忘记了)。

另一方面，函数sorted()不会对l的内容做任何操作，而是返回一个与l内容相同的新的排序列表:

>>> l = [1, 5, 2341, 467, 213, 123]
>>> r = sorted(l)
>>> l
[1, 5, 2341, 467, 213, 123]
>>> r
[1, 5, 123, 213, 467, 2341]

注意，返回值不是深度副本，所以要谨慎对列表中包含的元素进行副作用操作:

>>> spam = [8, 2, 4, 7]
>>> eggs = [3, 1, 4, 5]
>>> l = [spam, eggs]
>>> r = sorted(l)
>>> l
[[8, 2, 4, 7], [3, 1, 4, 5]]
>>> r
[[3, 1, 4, 5], [8, 2, 4, 7]]
>>> spam.sort()
>>> eggs.sort()
>>> l
[[2, 4, 7, 8], [1, 3, 4, 5]]
>>> r
[[1, 3, 4, 5], [2, 4, 7, 8]]

问题就在这里:

answer = newList.sort()

Sort不会返回已排序的列表;相反，它对列表进行了适当的排序。

Use:

answer = sorted(newList)

要理解为什么它不返回列表:

Sort()方法不返回任何值，而Sort()方法只是按特定顺序对给定列表中的元素进行排序——升序或降序，而不返回任何值。

所以问题是answer = newList.sort()，其中答案为none。

相反，你可以只返回newList.sort()。

sort()方法的语法是:

list.sort(key=..., reverse=...)

或者，你也可以使用Python的内置函数sorted()来达到同样的目的。

sorted(list, key=..., reverse=...)

注意:sort()和sorted()之间最简单的区别是:sort()不返回任何值，而sorted()返回一个可迭代列表。

在这里，answer = sorted(newList)

下面是Guido van Rossum在Python开发列表中的一封电子邮件，解释了为什么他选择在影响对象的操作上不返回self，并且不返回新操作。

This comes from a coding style (popular in various other languages, I believe especially Lisp revels in it) where a series of side effects on a single object can be chained like this: x.compress().chop(y).sort(z) which would be the same as x.compress() x.chop(y) x.sort(z) I find the chaining form a threat to readability; it requires that the reader must be intimately familiar with each of the methods. The second form makes it clear that each of these calls acts on the same object, and so even if you don't know the class and its methods very well, you can understand that the second and third call are applied to x (and that all calls are made for their side-effects), and not to something else. I'd like to reserve chaining for operations that return new values, like string processing operations: y = x.rstrip("\n").split(":").lower()