深入理解python中的排序sort

chi633發表於2017-12-21
Python排序
  • 基本排序 Sorting Basics
  • key函式Key Functions
  • operator庫函式自定義排序（ Operator Module Functions）
  • 升序和降序Ascending and Descending
  • 排序的穩定性和複雜排序 （Sort Stability and Complex Sorts）
  • 傳統的DSU(Decorate-Sort-Undecorate)的排序方法
  • 利用cmp方法進行排序的原始方式
  • 其他

基本排序 Sorting Basics

進行一個簡單的升序排列直接呼叫sorted()函式，函式將會返回一個排序後的列表：

>>> sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]
複製程式碼

sorted函式不會改變原有的list，而是返回一個新的排好序的list

>>> list = [1,3,2,4,5,3,2]
>>> sorted(list)
[1, 2, 2, 3, 3, 4, 5]
>>> list
[1, 3, 2, 4, 5, 3, 2]
複製程式碼

如果你想使用就地排序，也就是改變原list的內容，那麼可以使用list.sort()的方法，這個方法的返回值是None。

>>> a = [5, 2, 3, 1, 4]
>>> a.sort()
>>> a
[1, 2, 3, 4, 5]
複製程式碼

另一個區別是，list.sort()方法只是list也就是列表型別的方法，只可以在列表型別上呼叫。而sorted方法則是可以接受任何可迭代物件。

>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]
複製程式碼

key函式Key Functions

list.sort()和sorted()函式都有一個key引數，可以用來指定一個函式來確定排序的一個優先順序。比如，這個例子就是根據大小寫的優先順序進行排序：

>>> sorted("This is a test string from Andrew".split(), key=str.lower)
['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']
複製程式碼

key引數的值應該是一個函式，這個函式接受一個引數然後返回以一個key，這個key就被用作進行排序。這個方法很高效，因為對於每一個輸入的記錄只需要呼叫一次key函式。 一個常用的場景就是當我們需要對一個複雜物件的某些屬性進行排序時：

>>> student_tuples = [
... ('john', 'A', 15),
... ('jane', 'B', 12),
... ('dave', 'B', 10),
... ]
>>> sorted(student_tuples, key=lambda student: student[2]) # sort by age
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
複製程式碼

再如：

>>> class Student:
... def __init__(self, name, grade, age):
... self.name = name
... self.grade = grade
... self.age = age
... def __repr__(self):
... return repr((self.name, self.grade, self.age))
複製程式碼
>>> student_objects = [
... Student('john', 'A', 15),
... Student('jane', 'B', 12),
... Student('dave', 'B', 10),
... ]
>>> sorted(student_objects, key=lambda student: student.age) # sort by age
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
複製程式碼

operator庫函式自定義排序（ Operator Module Functions）

前面我們看到的利用key-function來自定義排序，同時Python也可以通過operator庫來自定義排序，而且通常這種方法更好理解並且效率更高。 operator庫提供了 itemgetter(), attrgetter(), and a methodcaller()三個函式

>>> from operator import itemgetter, attrgetter
複製程式碼
>>> sorted(student_tuples, key=itemgetter(2))
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
複製程式碼
>>> sorted(student_objects, key=attrgetter('age'))
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
複製程式碼

同時還支援多層排序

>>> sorted(student_tuples, key=itemgetter(1,2))
[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]
複製程式碼
>>> sorted(student_objects, key=attrgetter('grade', 'age'))
[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]
複製程式碼

升序和降序Ascending and Descending

list.sort()和sorted()都有一個boolean型別的reverse引數，可以用來指定升序和降序排列，預設為false，也就是升序排序，如果需要降序排列，則需將reverse引數指定為true。

>>> sorted(student_tuples, key=itemgetter(2), reverse=True)
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
複製程式碼
>>> sorted(student_objects, key=attrgetter('age'), reverse=True)
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
複製程式碼

排序的穩定性和複雜排序 （Sort Stability and Complex Sorts）

排序的穩定性指，有相同key值的多個記錄進行排序之後，原始的前後關係保持不變

>>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]
>>> sorted(data, key=itemgetter(0))
[('blue', 1), ('blue', 2), ('red', 1), ('red', 2)]
複製程式碼

我們可以看到python中的排序是穩定的。

我們可以利用這個穩定的特性來進行一些複雜的排序步驟，比如，我們將學生的資料先按成績降序然後年齡升序。當排序是穩定的時候，我們可以先將年齡升序，再將成績降序會得到相同的結果。

>>> s = sorted(student_objects, key=attrgetter('age')) # sort on secondary key
>>> sorted(s, key=attrgetter('grade'), reverse=True) # now sort on primary key, descending
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
複製程式碼

傳統的DSU(Decorate-Sort-Undecorate)的排序方法

傳統的DSU(Decorate-Sort-Undecorate)的排序方法主要有三個步驟：

  • 給list新增一個新的值，這個值一般是用來控制排序的順序（Decorate）
  • 排序
  • 將新增的值去掉，也就是Undecorate 具體可以看下面的例子：
>>> decorated = [(student.grade, i, student) for i, student in enumerate(student_objects)]
>>> decorated.sort()
>>> [student for grade, i, student in decorated] # undecorate
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
複製程式碼

因為元組是按字典序比較的，比較完grade之後，會繼續比較i。 新增index的i值不是必須的，但是新增i值有以下好處：

  • 可以保證排序的穩定性，如果key值相同，就可以利用i來維持原有的順序
  • 原始物件的item不用進行比較，因為通過key和i的比較就能將陣列排序好

現在python3提供了key-function，所以DSU方法已經不常用了

利用cmp方法進行排序的原始方式

python2.x版本中，是利用cmp引數自定義排序。 python3.x已經將這個方法移除了，但是我們還是有必要了解一下cmp引數 cmp引數的使用方法就是指定一個函式，自定義排序的規則，和java等其他語言很類似

>>> def numeric_compare(x, y):
... return x - y
>>> sorted([5, 2, 4, 1, 3], cmp=numeric_compare)
[1, 2, 3, 4, 5]
複製程式碼

也可以反序排列

>>> def reverse_numeric(x, y):
... return y - x
>>> sorted([5, 2, 4, 1, 3], cmp=reverse_numeric)
[5, 4, 3, 2, 1]
複製程式碼

python3.x中可以用如下方式：

def cmp_to_key(mycmp):
'Convert a cmp= function into a key= function'
class K:
def __init__(self, obj, *args):
self.obj = obj
def __lt__(self, other):
return mycmp(self.obj, other.obj) < 0
def __gt__(self, other):
return mycmp(self.obj, other.obj) > 0
def __eq__(self, other):
return mycmp(self.obj, other.obj) == 0
def __le__(self, other):
return mycmp(self.obj, other.obj) <= 0
def __ge__(self, other):
return mycmp(self.obj, other.obj) >= 0
def __ne__(self, other):
return mycmp(self.obj, other.obj) != 0
return K
複製程式碼
>>> sorted([5, 2, 4, 1, 3], key=cmp_to_key(reverse_numeric))
[5, 4, 3, 2, 1]
複製程式碼

其他

  • 可以通過以下方式定義__lt__函式來指定兩個物件比較的方式
>>> Student.__lt__ = lambda self, other: self.age < other.age
>>> sorted(student_objects)
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
複製程式碼
  • 排序的ley-function引數不僅僅可以依賴於排序的物件，也可以依賴於外部的物件. 如下例，成績姓名分開儲存。
>>> students = ['dave', 'john', 'jane']
>>> newgrades = {'john': 'F', 'jane':'A', 'dave': 'C'}
>>> sorted(students, key=newgrades.__getitem__)
['jane', 'dave', 'john']
複製程式碼

相關文章