pythonsort函數原理

A. python里的sort語句

Python中的sort()函數是序列的內部函數，函數原型：

L.sort(cmp=None,key=None,reverse=False)

函數作用：它是把L原地排序，也就是使用後並不是返回一個有序的序列副本，而是把當前序列變得有序。

Python中sort()參數說明：

(1) cmp參數

cmp接受一個函數，拿整形舉例，形式為：

deff(a,b):
returna-b

如果排序的元素是其他類型的，如果a邏輯小於b，函數返回負數；a邏輯等於b，函數返回0；a邏輯大於b，函數返回正數就行了。

(2) key參數

key也是接受一個函數，不同的是，這個函數只接受一個元素，形式如下：

deff(a):
returnlen(a)

key接受的函數返回值，表示此元素的權值，sort將按照權值大小進行排序

(3) reverse參數

接受False 或者True 表示是否逆序

Python中sort()函數舉例：

(1)按照元素長度排序

L=[{1:5,3:4},{1:3,6:3},{1:1,2:4,5:6},{1:9}]
deff(x):
returnlen(x)
sort(key=f)
printL
//輸出：
//[{1:9},{1:5,3:4},{1:3,6:3},{1:1,2:4,5:6}]

(2)按照每個字典元素裡面key為1的元素的值排序

L=[{1:5,3:4},{1:3,6:3},{1:1,2:4,5:6},{1:9}]
deff2(a,b):
returna[1]-b[1]
L.sort(cmp=f2)
printL
//輸出：
//[{1:1,2:4,5:6},{1:3,6:3},{1:5,3:4},{1:9}]

B. python中，sort函數是按照什麼方式排序的sorted又是按照什麼方式排的

a.sort是對a進行排序，返回None，sorted(a)返回一個排好序的副本，a不變。請多看看相關教程。

C. python sort()用法

Python中的sort()方法用於數組排序，下面以實例形式對此加以詳細說明：

一、基本形式

列表有自己的sort方法，其對列表進行原址排序，既然是原址排序，那顯然元組不可能擁有這種方法，因為元組是不可修改的。

x=[4,6,2,1,7,9]x.sort()
printx#[1,2,4,6,7,9]

如果需要一個排序好的副本，同時保持原有列表不變，怎麼實現呢

x=[4,6,2,1,7,9]
y=x[:]
y.sort()
printy#[1,2,4,6,7,9]
printx#[4,6,2,1,7,9]

注意：y = x[:] 通過分片操作將列表x的元素全部拷貝給y，如果簡單的把x賦值給y：y = x，y和x還是指向同一個列表，並沒有產生新的副本。

另一種獲取已排序的列表副本的方法是使用sorted函數：

x=[4,6,2,1,7,9]
y=sorted(x)
printy#[1,2,4,6,7,9]
printx#[4,6,2,1,7,9]

sorted返回一個有序的副本，並且類型總是列表，如下：

printsorted('Python')#['P','h','n','o','t','y']

二、自定義比較函數

可以定義自己的比較函數，然後通過參數傳遞給sort方法：

defcomp(x,y):
ifx<y:
return1
elifx>y:
return-1
else:
return0
nums=[3,2,8,0,1]
nums.sort(comp)
printnums#降序排序[8,3,2,1,0]
nums.sort(cmp)#調用內建函數cmp，升序排序
printnums#降序排序[0,1,2,3,8]

三、可選參數

sort方法還有兩個可選參數：key和reverse
1、key在使用時必須提供一個排序過程總調用的函數：

x=['mmm','mm','mm','m']
x.sort(key=len)
printx#['m','mm','mm','mmm']

2、reverse實現降序排序，需要提供一個布爾值：

y=[3,2,8,0,1]
y.sort(reverse=True)
printy#[8,3,2,1,0]

D. python sort函數

在遍歷列表的過程中改變列表，大概是有規定會發生什麼，不過別指望這個規定很好理解……

E. 關於python sort

就是按列表中元素小寫之後去排序

F. 什麼是python內置函數sorted

Python對容器內數據的排序有兩種，一種是容器自己的sort函數，一種是內建的sorted函數。
sort函數和sorted函數唯一的不同是，sort是在容器內排序，sorted生成一個新的排好序的容器。

對於一個簡單的數組 L=[5,2,3,1,4].
sort: L.sort()

sorted(...)
sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list
iterable：待排序的可迭代類型的容器;
cmp：用於比較的函數，比較什麼由key決定,有默認值，迭代集合中的一項;
key：用列表元素的某個已命名的屬性或函數（只有一個參數並且返回一個用於排序的值）作為關鍵字，有默認值，迭代集合中的一項;
reverse：排序規則. reverse = True 或者 reverse = False，有默認值。
返回值：是一個經過排序的可迭代類型，與iterable一樣。

如果是一個多維的列表 L=[(『b』,2),(『a』,1),(『c』,3),(『d』,4)].
有三種選擇對這個多維列表進行排序
利用cmp函數
sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))
L.sort(cmp=lambda x,y:cmp(x[1],y[1]))
利用key
sorted(L, key=lambda x:x[1]);
L.sort(key=lambda x:x[1]);
反序
以上幾種排序均可加上參數reverse.
例如 sorted(reverse=True), L.sort(reverse=True). 或者改成False
OrderedDict是collections中的一個包，能夠記錄字典元素插入的順序，常常和排序函數一起使用來生成一個排序的字典。
比如，比如一個無序的字典
d = {『banana』:3,』apple』:4,』pear』:1,』orange』:2}
通過排序來生成一個有序的字典，有以下幾種方式
collections.OrderedDict(sorted(d.items(),key = lambda t:t[0]))
或者
collections.OrderedDict(sorted(d.items(),key = lambda t:t[1]))
或者
collections.OrderedDict(sorted(d.items(),key = lambda t:len(t[0])))

G. python怎麼使用sort

一、基本形式
sorted(iterable[, cmp[, key[, reverse]]])

iterable.sort(cmp[, key[, reverse]])

參數解釋：
（1）iterable指定要排序的list或者iterable，不用多說；
（2）cmp為函數，指定排序時進行比較的函數，可以指定一個函數或者lambda函數，如：
students為類對象的list，沒個成員有三個域，用sorted進行比較時可以自己定cmp函數，例如這里要通過比較第三個數據成員來排序，代碼可以這樣寫：
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda student : student[2])

（3）key為函數，指定取待排序元素的哪一項進行排序，函數用上面的例子來說明，代碼如下：
sorted(students, key=lambda student : student[2])

key指定的lambda函數功能是去元素student的第三個域（即：student[2]），因此sorted排序時，會以students所有元素的第三個域來進行排序。
二、普通用法：
1.原址排序
1）列表有自己的sort方法，其對列表進行原址排序，既然是原址排序，那顯然元組不可能擁有這種方法，因為元組是不可修改的。

x = [4, 6, 2, 1, 7, 9]
x.sort()
print x # [1, 2, 4, 6, 7, 9]

2.副本排序
1）[:]分片方法

x =[4, 6, 2, 1, 7, 9]
y = x[ : ]
y.sort()
print y #[1, 2, 4, 6, 7, 9]
print x #[4, 6, 2, 1, 7, 9]

注意：y = x[:] 通過分片操作將列表x的元素全部拷貝給y，如果簡單的把x賦值給y：y = x，y和x還是指向同一個列表，並沒有產生新的副本。
2）sorted方法
sorted返回一個有序的副本，並且類型總是列表，如下：

x =[4, 6, 2, 1, 7, 9]
y = sorted(x)
print y #[1, 2, 4, 6, 7, 9]
print x #[4, 6, 2, 1, 7, 9]

print sorted('Python') #['P', 'h', 'n', 'o', 't', 'y']

三、高級用法
1.自定義cmp比較函數

def comp(x, y):
if x < y:
return 1
elif x > y:
return -1
else:
return 0

nums = [3, 2, 8 ,0 , 1]
nums.sort(comp)
print nums # 降序排序[8, 3, 2, 1, 0]
nums.sort(cmp) # 調用內建函數cmp ，升序排序
print nums # 降序排序[0, 1, 2, 3, 8]

2.自定義key和reverse
1.reverse實現降序排序，需要提供一個布爾值，默認為False（升序排列）。
2.key在使用時必須提供一個排序過程總調用的函數：

alist = [('2', '3', '10'), ('1', '2', '3'), ('5', '6', '7'), ('2', '5', '10'), ('2', '4', '10')]
# 多級排序，先按照第3個元素排序，然後按照第2個元素排序：
print sorted(alist, cmp = None, key = lambda x:(int(x[2]), int(x[1])), reverse = False)
-------------------------------------------------------------------------------------------
[('1', '2', '3'), ('5', '6', '7'), ('2', '3', '10'), ('2', '4', '10'), ('2', '5', '10')]

四、operator.itemgetter函數
operator模塊提供的itemgetter函數用於獲取對象的哪些維的數據，參數為一些序號（即需要獲取的數據在對象中的序號），下面看例子。

a = [1,2,3]
>>> b=operator.itemgetter(1) //定義函數b，獲取對象的第1個域的值
>>> b(a)
2
>>> b=operator.itemgetter(1,0) //定義函數b，獲取對象的第1個域和第0個的值
>>> b(a)
(2, 1)

要注意，operator.itemgetter函數獲取的不是值，而是定義了一個函數，通過該函數作用到對象上才能獲取值。
itemgetter在sort中的用法：

from operator import itemgetter

alist = [('2', '3', '10'), ('1', '2', '3'), ('5', '6', '7'), ('2', '5', '10'), ('2', '4', '10')]

# 多級排序，先按照第3個元素排序，然後按照第2個元素排序：
print sorted(alist, cmp = None, key = itemgetter(2, 1), reverse = False)
print sorted(alist, cmp = None, key = lambda x:itemgetter(2, 1)(x), reverse = False)
print sorted(alist, cmp = None, key = lambda x:map(int, itemgetter(2, 1)(x)), reverse = False)
--------------------------------------------------------------------------------------------------

[('2', '3', '10'), ('2', '4', '10'), ('2', '5', '10'), ('1', '2', '3'), ('5', '6', '7')]
[('2', '3', '10'), ('2', '4', '10'), ('2', '5', '10'), ('1', '2', '3'), ('5', '6', '7')]
[('1', '2', '3'), ('5', '6', '7'), ('2', '3', '10'), ('2', '4', '10'), ('2', '5', '10')]

H. 關於python里sort的疑問

li.sort(cmp=None, key=None, reverse=False)
uMinNum = li[0]
li.sort(cmp=None, key=None, reverse=True)
uMaxNum = li[0]
-----------------------------------------
li是一個列表,用列表存儲這些數據， 然後用列表的排序方法sort()。
li.sort(cmp=None, key=None, reverse=False)也可以寫成li.sort()， 因為sort()函數的原形就是這樣。默認的為是升序排序。
li.sort(cmp=None, key=None, reverse=True)修改sort()的reverse變數， 讓sort（）進行降序排序。
li[0] 是取排好序後的第一個元素

I. python中sort用法的問題

sorted是一個函數，函數返回一個排序結果。目標list本身不變

J. 想知道python中sort(cmp) 排序原理。比如對於一個列表 [1,5,4,78]的排序過程，和c排序的過程一樣嗎

其實用Python就是為了不去考慮中間那些沒有必要的過程，重視的是代碼邏輯和編寫速度，而不是運行速度。sort這個列表的方法由於是內置的，很有可能是由c寫的，也就是你需要查python的源代碼你才能知道。