‘ sort (list)’和‘ list.sort()’的区别是什么？

list.sort()对列表进行排序并替换原始列表，而 sorted(list)返回列表的排序副本，而不更改原始列表。

  • 什么时候一个比另一个更受欢迎？
  • 哪个更有效率? 多少？
  • 在执行 list.sort()之后，是否可以将列表恢复到未排序状态？

请使用 为什么这些列表操作(方法)返回 Nothing，而不是返回结果列表？来结束 OP 无意中给出 .sort()结果的问题，而不是使用 sorted或单独的语句。正确的调试会显示 .sort()返回了 None，这时“为什么?”是剩下的问题。

141861 次浏览
小开

主要的区别是sorted(some_list)返回新list:

a = [3, 2, 1]
print sorted(a) # new list
print a         # is not modified

和some_list.sort()， 将的列表排序在的位置:

a = [3, 2, 1]
print a.sort() # in place
print a         # it's modified

由于a.sort()不返回任何东西，print a.sort()将打印None。

list.sort()后可以检索列表原始位置吗?

不，因为它修改了原始列表。

小开
最佳答案

sorted()返回一个新排序列表，原始列表不受影响。list.sort()对列表就地进行排序，改变列表索引，并返回None(像所有就地操作一样)。

sorted()适用于任何可迭代对象，而不仅仅是列表。字符串，元组，字典(你会得到键)，生成器等，返回一个包含所有元素的列表，排序。

  • 当你想要改变列表时使用list.sort()，当你想要返回一个新的排序对象时使用sorted()。当你想排序一个可迭代对象，而不是一个列表yet时，使用sorted()。

  • 对于列表，list.sort()比sorted()快，因为它不需要创建副本。对于任何其他可迭代对象，您没有选择。

  • 不，您不能检索原始位置。一旦你调用list.sort()，原来的顺序就消失了。

小开

sorted(list)和list.sort()之间的区别是什么?

  • list.sort就地改变列表返回None
  • sorted接受任意可迭代对象&返回一个排序后的新列表。

sorted相当于这个Python实现，但CPython内置函数应该运行得更快，因为它是用C编写的:

def sorted(iterable, key=None):
new_list = list(iterable)    # make a new list
new_list.sort(key=key)       # sort it
return new_list              # return it

什么时候用哪个?

  • 当你不希望保留原始排序顺序时，使用list.sort (因此，您将能够在内存中重用该列表) 您是列表的唯一所有者(如果该列表由其他代码共享) 如果你改变它，你可能会在使用列表的地方引入错误。)
  • 当你想保留原来的排序顺序或当你 希望创建一个只有本地代码拥有的新列表

在list.sort()之后可以检索列表的原始位置吗?

不会——除非你自己复制了一份，否则这些信息会丢失，因为排序是在原地完成的。

“哪一个更快?”快多少?”

为了说明创建一个新列表的代价，使用timeit模块，下面是我们的设置:

import timeit
setup = """
import random
lists = [list(range(10000)) for _ in range(1000)]  # list of lists
for l in lists:
random.shuffle(l) # shuffle each list
shuffled_iter = iter(lists) # wrap as iterator so next() yields one at a time
"""

下面是随机排列的10000个整数列表的结果，正如我们在这里看到的，我们已经推翻了一个旧的列表创建费用神话:

Python 2.7

>>> timeit.repeat("next(shuffled_iter).sort()", setup=setup, number = 1000)
[3.75168503401801, 3.7473005310166627, 3.753129180986434]
>>> timeit.repeat("sorted(next(shuffled_iter))", setup=setup, number = 1000)
[3.702025591977872, 3.709248117986135, 3.71071034099441]

Python 3

>>> timeit.repeat("next(shuffled_iter).sort()", setup=setup, number = 1000)
[2.797430992126465, 2.796825885772705, 2.7744789123535156]
>>> timeit.repeat("sorted(next(shuffled_iter))", setup=setup, number = 1000)
[2.675589084625244, 2.8019039630889893, 2.849375009536743]

经过一些反馈后，我决定另一个具有不同特性的测试是可取的。在这里，我为每一次迭代1000次提供相同的100,000长度的随机排序列表。

import timeit
setup = """
import random
random.seed(0)
lst = list(range(100000))
random.shuffle(lst)
"""

我认为这种更大的差异来自马丁提到的复制，但它并没有占主导地位在更古老更流行的答案中，这里时间的增加只有大约10%

>>> timeit.repeat("lst[:].sort()", setup=setup, number = 10000)
[572.919036605, 573.1384446719999, 568.5923951]
>>> timeit.repeat("sorted(lst[:])", setup=setup, number = 10000)
[647.0584738299999, 653.4040515829997, 657.9457361929999]

我还在一个更小的排序上运行了上面的代码，并看到新的sorted复制版本在长度为1000的排序上仍然需要大约2%的运行时间。

Poke也运行了他自己的代码，下面是代码:

setup = '''
import random
random.seed(12122353453462456)
lst = list(range({length}))
random.shuffle(lst)
lists = [lst[:] for _ in range({repeats})]
it = iter(lists)
'''
t1 = 'l = next(it); l.sort()'
t2 = 'l = next(it); sorted(l)'
length = 10 ** 7
repeats = 10 ** 2
print(length, repeats)
for t in t1, t2:
print(t)
print(timeit(t, setup=setup.format(length=length, repeats=repeats), number=repeats))

他发现对于1000000长度的排序，(运行100次)有类似的结果，但只增加了大约5%的时间，以下是输出:

10000000 100
l = next(it); l.sort()
610.5015971539542
l = next(it); sorted(l)
646.7786222379655

结论:

使用sorted进行副本排序的大型列表可能会主导差异，但排序本身主导操作，并且围绕这些差异组织代码将是不成熟的优化。当我需要一个新的数据排序列表时，我将使用sorted，当我需要对列表进行排序时，我将使用list.sort，并让它决定我的用法。

小开
sort()函数将new list的值直接存储在list变量中;所以你的第三个问题的答案是否定的。 此外，如果使用sorted(list)来执行此操作，则可以使用它，因为它没有存储在list变量中。有时.sort()方法也可以作为函数，或者在其中使用参数

您必须显式地将sorted(list)的值存储在变量中。

同样对于短数据的处理速度也不会有差别;但对于长列表;你应该直接使用.sort()方法来快速工作;但你将再次面临不可逆转的行动。

小开

下面是几个简单的例子，可以看出其中的区别:

请看这里的数字列表:

nums = [1, 9, -3, 4, 8, 5, 7, 14]

当调用该列表上的sorted时，sorted将生成该列表的复制。(这意味着您原来的列表将保持不变。)

让我们来看看。

sorted(nums)

返回

[-3, 1, 4, 5, 7, 8, 9, 14]

再次查看nums

nums

我们看到的是原始列表(未修改且未排序)。sorted没有改变原来的列表

[1, 2, -3, 4, 8, 5, 7, 14]

获取相同的nums列表并在其上应用sort函数，将改变实际的列表。

让我们来看看。

从nums列表开始，以确保内容仍然相同。

nums


[-3, 1, 4, 5, 7, 8, 9, 14]


nums.sort()

现在原始的nums列表改变了，看看nums，我们看到原始的列表改变了，现在排序了。

nums
[-3, 1, 2, 4, 5, 7, 8, 14]
小开
注意:sort()和sorted()之间最简单的区别是:sort() 不返回任何值，而sorted()返回一个可迭代列表

Sort()不返回任何值。

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

sort()方法的语法是:

list.sort(key=..., reverse=...)
或者，也可以使用Python的内置函数sorted() 出于同样的目的。排序函数返回排序列表

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

使用list.sort()你改变的是列表变量，而使用sorted(list)你没有改变变量。

使用排序:

list = [4, 5, 20, 1, 3, 2]
list.sort()
print(list)
print(type(list))
print(type(list.sort())

应该返回这个:

[1, 2, 3, 4, 5, 20]
<class 'NoneType'>

但是使用sorted():

list = [4, 5, 20, 1, 3, 2]
print(sorted(list))
print(list)
print(type(sorted(list)))

应该返回这个:

[1, 2, 3, 4, 5, 20]
[4, 5, 20, 1, 3, 2]
<class 'list'>

提交答案