python中的sort函数什么意思,python的sorted函数什么意思

　　python中使用Sort和sorted对常用词列表(或类列表)进行排序，但python中有区别。

　　他们唯一的共同点恐怕就是都可以对列表进行排序和区分：

　　1.sorted是python的内置函数，可以对链表(list)、祖先(tuple)、字典(dict)、字符串(str)进行排序。排序对象用作排序函数的参数，示例如下：

　　a元组=(1，3，2，4)

　　已排序(列表)

　　(1，2，3，4) #返回

　　2.sort()是list类的方法，只能对列表进行排序。对列表排序时，Sorted()有返回值；Sorte()在对列表排序时不能返回值(直接在原列表中操作)。

　　a_list=[1，3，5，2]

　　执行后不能返回A_list.sort() #。

　　A_list #当你再次访问A_list时，列表已经被排序了。

　　[1,2,3,5]

　　a_list=[1，3，5，2]

　　Sorted(a_list) #执行后直接返回结果，不改变原列表。

　　[1,2,3,5]

　　-

　　排序方法与排序函数的异同

　　官方用法

　　排序的用法：

　　排序(self，/，*，key=None，reverse=False)

　　按升序对列表排序，返回None。

　　排序是就地的(即列表本身被修改)和稳定的(即

　　保持两个相等元素的顺序)。

　　如果给定了一个键函数，就对每个列表项应用一次，

　　根据它们的函数值升序或降序。

　　反向标志可以设置为降序排序。

　　排序的用法：

　　关于在模块内置中排序的内置函数的帮助：

　　已排序(iterable，/，*，key=None，reverse=False)

　　返回一个新的列表，包含iterable中的所有条目，按升序排列。

　　可以提供一个自定义键函数来自定义排序顺序，而

　　可以设置反向标志，以降序请求结果。

　　相同点：

　　Sort和sorted有两个可选的仅关键字参数，key和reverse，默认情况下按升序排序。

　　差异：

　　1.sort是list的一个方法，它的第一个参数是self，也就是list实例对象本身；

　　Sorted是一个内置函数，它的第一个参数是iterable，即迭代对象。

　　So sorted不仅可以应用于列表，还可以应用于元组和字典等可迭代对象。

　　2.2.sort方法就地对列表进行排序，返回值为None；

　　排序的功能是返回一个新的列表，而不改变原来的iterable对象。

　　3 .排序方法不能级联调用，排序后的函数可以级联调用。

　　-

　　排序方法和排序函数的基本用法

　　方法和函数，很多时候，大部分人是不区分方法和函数的，基本上把它们当成一个东西，其实是没有问题的。但在阅读Python官方文档时，有时出现方法，有时出现函数，这是一个令人头疼的问题，所以区分方法和函数是有益的。其实区别比较简单。

　　方法：通过obj.funcname()引用调用。

　　例如，列表的排序方法称为list.sort()。

　　函数：通过funcname()直接调用。

　　如果内置函数)已排序，则称为sorted()。

　　注意：Python API的一个约定是：

　　如果一个函数或方法改变了一个对象，它应该返回None。

　　这样做的目的是告诉调用者对象已经被就地改变了。

　　这种约定的缺点是不可能级联这些方法。

　　返回新对象的方法可以级联调用，从而形成一个流畅的接口。

　　排序方法的基本使用和排序

　　List.sort():对列表进行就地排序，默认为升序，返回值为None。

　　Sorted():对iterable对象进行排序，默认为升序，并将排序后的结果作为一个新的列表返回，原来被迭代对象的顺序不会受到影响。

　　list_a=[1，5，6，4，2，3]

　　Sorted(list_a) #返回一个新的排序列表

　　[1, 2, 3, 4, 5, 6]

　　list_a # list_a不变。

　　[1, 5, 6, 4, 2, 3]

　　print(list _ a . sort())# list _ a . sort()就地排序，返回值为None

　　没有人

　　list_a # list_a已更改。

　　[1, 2, 3, 4, 5, 6]

　　排序函数可用于其他可迭代对象，如元组、生成器等。除了名单。

　　排序的((1，5，9，2，6，8，7)) #排序元组

　　[1, 2, 5, 6, 7, 8, 9]

　　Sorted(afbcedh) #排序字符串

　　[a ， b ， c ， d ， e ， f ， h]

　　列表(范围(10，0，-1))

　　[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

　　Sorted(范围(10，0，-1)) #对生成器进行排序

　　[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

　　已排序({1: D ，2: B ，3: B ，4: E ，5: A})

　　[1, 2, 3, 4, 5]

　　可选的降序关键字仅参数反转

　　sort方法和sorted函数都可以接收一个可选的关键字-唯一参数)reverse，用于指定是升序还是降序。

　　默认的reverse=False是升序排序。

　　list_a=[3，1，2，4]

　　Sorted(list_a) #默认升序

　　[1, 2, 3, 4]

　　Sorted(list_a，reverse=True) #降序排序

　　[4, 3, 2, 1]

　　list_a # list_a不变。

　　[3, 1, 2, 4]

　　List_a.sort() #默认就地升序排序

　　列表_a

　　[1, 2, 3, 4]

　　List_a.sort(reverse=True) #就地降序排序

　　列表_a

　　[4, 3, 2, 1]

　　注意：仅关键字参数，即只能通过keyword=value传递的参数，称为仅关键字参数。Python函数，仅关键字参数，仅位置参数，变量参数，默认参数，位置参数，变量关键字参数，请参考我的另一个总结。了解Python函数。

　　接下来，我们引入另一个更强大的可选关键字-仅参数键。

　　仅可选关键字参数key

　　Sort方法和sorted函数也可以接收一个可选的只有关键字的参数key，这是一个只有一个参数的函数。这个函数会依次作用于序列的每个元素，结果作为排序的依据。key的默认值为None，即identity function，即元素默认按自身值排序。

　　举栗子：

　　list_a=[This ， is ， a ， test ， string ， from ， Andrew]

　　已排序(list_a，key=str.lower)

　　[a ， Andrew ， from ， is ， string ， test ， This]

　　列表_a

　　[This ， is ， a ， test ， string ， from ， Andrew]

　　这里key=str.lower是指list_a中的每一个元素都经过str.lower方法处理，也就是全部小写，然后通过比较排序。

　　对于复杂的数据对象，我们可以利用对象的索引，取对象的一部分作为比较的关键。这时候匿名功能就帮到我们了，举个栗子：

　　student_tuples=[

　　.(《约翰福音》，《答》，15)，

　　.(智能麦片， B ，12)，

　　.(戴夫， B ，10)，

　　.]

　　Sorted (student _ tuples，key=lambda student: student [2]) #按年龄排序

　　[(戴夫， B ，10)，(智能麦片， B ，12)，(约翰， A ，15)]

　　我们也可以把物体的属性作为比较的关键，举个栗子：

　　班级学生：

　　.def __init__(本人，姓名，年级，年龄):

　　.self.name=name

　　.自我等级=等级

　　.年龄=年龄

　　.def __repr__(self):

　　.return repr((自我姓名，自我等级，自我年龄))

　　.

　　student_objects=[

　　.学生(约翰，甲，15)，

　　.学生(智能麦片， B ，12)，

　　.学生(戴夫， B ，10)，

　　.]

　　Sorted (student _ objects，key=lambda student:student . age)#按年龄排序

　　[(戴夫， B ，10)，(智能麦片， B ，12)，(约翰， A ，15)]

　　可以看到那把钥匙很厉害！这样复杂的数据结构就可以按照我们自己的意愿排序了。

　　list.sort、sorted、max和min中可选的仅关键字参数key的设计非常出色！使用key会更加高效简洁。简单意味着只需要定义一个只有一个参数的函数进行排序。高效意味着key的函数在每个元素上只被调用一次，而双参数比较函数将在每次进行两两比较时被调用。(PS:这个不是特别懂)

　　操作员模块的使用

　　因为按索引或属性和函数排序非常常见，所以Python内置的运算符模块提供了itemgetter()、attrgetter()和methodcaller()函数来更简单快捷地实现相关函数。

　　从operator导入item getter，attrgetter #导入相关函数。

　　Sorted (student _ tuples，key=itemgetter (2)) #按索引值排序

　　[(戴夫， B ，10)，(智能麦片， B ，12)，(约翰， A ，15)]

　　Sorted (student _ objects，key=attr getter( age )#按属性值排序

　　[(戴夫， B ，10)，(智能麦片， B ，12)，(约翰， A ，15)]

　　此外，运算符模块还可以轻松实现多级排序，比如上面的学生列表，先按年级排序，再按年龄排序。

　　已排序(student_tuples，key=itemgetter(1，2))

　　[(约翰，甲，15)，(戴夫，乙，10)，(智能麦片，乙，12)]

　　已排序(student_objects，key=attrgetter(grade ， age ))

　　[(约翰，甲，15)，(戴夫，乙，10)，(智能麦片，乙，12)]

　　排序方法和排序函数背后的排序算法

　　sorted和list.sort后面的排序算法是Timsort算法，这是一种自适应算法，会根据原始数据的特点交替使用归并排序和插入排序。

　　这是实际应用场景中非常有效的稳定排序算法。Timsort从2002年开始在CPython中使用，从2009年开始在Java和Android中使用。

　　这里解释的是稳定排序算法，是指排序前后，值相同的元素不交换位置。

　　data=[(红色，1)，(蓝色，1)，(红色，2)，(蓝色，2)]

　　Sorted (data，key=itemgetter (0)) #按颜色排序

　　[(蓝，1)，(蓝，2)，(红，1)，(红，2)]

　　可以看出，原来的顺序是(红，1)在(红，2)前面。排序后，由于红色相同，两者不交换位置，且(红色，1)仍在(红色，2)前面。这称为稳定排序。反之，如果是交换，那就叫不稳定。

　　稳定排序非常重要，因为它允许我们在多个步骤中进行排序。

　　比如我们要对学生的数据进行排序，要求按照年级降序排序，如果年级相同，那么按照年龄升序排序。

　　那么我们可以分两步来做：第一步按年龄升序排列，第二步按年级降序排列。注：根据算法，按升序排列，B的等级在a的等级之后。

　　代码如下：

　　s=sorted(student_objects，key=attrgetter(age ))

　　已排序(s，key=attrgetter(grade )，reverse=True)

　　[(戴夫， B ，10)，(智能麦片， B ，12)，(约翰， A ，15)]

　　以上结果按降序排序，相同结果按年龄升序排序。我们也可以把上面的代码整合成一行，注意顺序：

　　sorted(sorted(student_objects，key=attrgetter(age ))，key=attrgetter(grade )，reverse=True)

　　[(戴夫， B ，10)，(智能麦片， B ，12)，(约翰， A ，15)]

　　大多数Python排序(排序方法和排序函数)使用的是Timsort算法，这是一种混合且稳定的排序算法。关于Timsort算法的更多信息，请参考Wiki Timsort。

　　巨人的肩膀

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。