sortedpython

『壹』 深入理解python中的排序sort

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

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

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

另一個區別是，list.sort()方法只是list也就是列表類型的方法，只可以在列表類型上調用。而sorted方法則是可以接受任何可迭代對象。

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

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

再如：

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

同時還支持多層排序

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

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

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

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

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

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

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

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

也可以反序排列

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

『貳』 python 排序,sort和sorted的區別是什麼

sort是一個值或變數等的一個樹形，對自己的值進行排序。
如
a
=
[1,3,5,7,4,2]
a.sort()之後，再print
a
就會發現a的值已經被排序了。[1,2,3,4,5,7]
sorted是一個命令，可以對任何integer排序。
如
a
=
[2,4,6,8,3,2,1]
sorted(a)，輸出的就是
[1,2,2,3,4,6,8]，可以把他賦給變數b，b
=
sorted(a)，這樣b就有值了。
再如b
=
sorted('cdefgab')，print
b輸出
[a,b,c,d,e,f,g]
b
=
sorted('456321')
,
print
b輸出
[1,2,3,4,5,6]

『叄』 python sorted怎麼降序排序

1、首先打開cmd命令提示符，輸入指令「ipython」打開python的命令行工具：

『肆』 Python中怎麼向sorted（）傳遞參數reverse=True

1、查看sorted()函數的幫助信息。sorted(iterable,/,*,key=None,reverse=False)。

『伍』 怎樣用python將數組里的數從高到低排序

1、首先我們定義一個列表輸入一串大小不一的數字。

『陸』 什麼是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])))

『柒』 python中sorted函數的作用是

這是排序函數

『捌』 python3.0中sorted函數怎麼用

【Python】 sorted函數
我們需要對List、Dict進行排序，Python提供了兩個方法
對給定的List L進行排序，
方法1.用List的成員函數sort進行排序，在本地進行排序，不返回副本
方法2.用built-in函數sorted進行排序（從2.4開始），返回副本，原始輸入不變

--------------------------------sorted---------------------------------------
>>> help(sorted)
Help on built-in function sorted in mole __builtin__:

sorted(...)
sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list
---------------------------------sort----------------------------------------
>>> help(list.sort)
Help on method_descriptor:

sort(...)
L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1
-----------------------------------------------------------------------------

iterable：是可迭代類型;
cmp：用於比較的函數，比較什麼由key決定;
key：用列表元素的某個屬性或函數進行作為關鍵字，有默認值，迭代集合中的一項;
reverse：排序規則. reverse = True 降序 或者 reverse = False 升序，有默認值。
返回值：是一個經過排序的可迭代類型，與iterable一樣。

參數說明：
(1) cmp參數
cmp接受一個函數，拿整形舉例，形式為:
def f(a,b):
return a-b
如果排序的元素是其他類型的，如果a邏輯小於b，函數返回負數；a邏輯等於b，函數返回0；a邏輯大於b，函數返回正數就行了

(2) key參數
key也是接受一個函數，不同的是，這個函數只接受一個元素,形式如下
def f(a):
return len(a)
key接受的函數返回值，表示此元素的權值，sort將按照權值大小進行排序

(3) reverse參數
接受False 或者True 表示是否逆序

例子：
(1)按照元素長度排序
L = [{1:5,3:4},{1:3,6:3},{1:1,2:4,5:6},{1:9}]
def f(x):
return len(x)
sort(key=f)
print L

輸出:
[{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}]
def f2(a,b):
return a[1]-b[1]
L.sort(cmp=f2)
print L
. 對由tuple組成的List排序
Python代碼
>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10),]

用key函數排序：返回由tuple組成的list
Python代碼
>>> sorted(students, key=lambda student : student[2]) # sort by age
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

用cmp函數排序
Python代碼
>>> sorted(students, cmp=lambda x,y : cmp(x[2], y[2])) # sort by age
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

用 operator 函數來加快速度,
Python代碼
>>> from operator import itemgetter, attrgetter
>>> sorted(students, key=itemgetter(2))

用 operator 函數進行多級排序
Python代碼
>>> sorted(students, key=itemgetter(1,2)) # sort by grade then by age
[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]

2. 對由字典排序 ，返回由tuple組成的List,不再是字典。
Python代碼
>>> d = {'data1':3, 'data2':1, 'data3':2, 'data4':4}
>>> sorted(d.iteritems(), key=itemgetter(1), reverse=True)
[('data4', 4), ('data1', 3), ('data3', 2), ('data2', 1)]