摘要：一需要用到的函數(shù)需要用到的函數(shù)很少，基本上就是和。這個參數(shù)的默認(rèn)值是恒等函數(shù)，也就是默認(rèn)用元素自己的值來排序。后的函數(shù)會代入列表里的每一項(xiàng)返回一個優(yōu)先級數(shù)字，并以這個優(yōu)先級數(shù)字排序

一、需要用到的函數(shù)

需要用到的函數(shù)很少，基本上就是sorted()和lambda。

sorted()函數(shù)原型：

sorted(iterable[,key][,reverse])

可見sorted()可以接受3個參數(shù)，需要排序的變量必不可少，然后是key指定排序的元素，reverse指定是否逆序。

key:一個只有一個參數(shù)的函數(shù)，這個函數(shù)會被用在序列里的每一個元素上，所產(chǎn)生的結(jié)果將是排序算法依賴的對比關(guān)鍵字。比如說，在對一些字符串排序時，可以用key=len來實(shí)現(xiàn)根據(jù)字符串的長度進(jìn)行排序。這個參數(shù)的默認(rèn)值是恒等函數(shù)，也就是默認(rèn)用元素自己的值來排序 (key=lambda x: x)。

lambda實(shí)際上就是匿名函數(shù)

一般形式：

lambda arguments: expression

寫成函數(shù)形式就是

def (arguments):
    return expression

當(dāng)lambda和sorted()的key參數(shù)結(jié)合就有意想不到的效果了。

二、各種排序

1.簡單list排序

lis = ["a", "b", "c"]
print(sorted(lis))
# ["a", "b", "c"]
print(sorted(lis, reverse=True))
# ["c", "b", "a"]

2.dict的key排序

dic = {"c": 1, "b": 2, "a": 3} #字典排序默認(rèn)按照字典的key排序，返回的也是字典的key
print(sorted(dic))
# ["a", "b", "c"]
print(sorted(dic, reverse=True))
# ["c", "b", "a"]

3.dict的value排序

dic = {"c": 1, "b": 2, "a": 3}
print(sorted(dic, key=lambda k: dic[k])) #dic([k])就是value
# ["c", "b", "a"]
print(sorted(dic, key=lambda k: dic[k], reverse=True))
# ["a", "b", "c"]

4.list內(nèi)嵌套list排序

lis = [[4, 2, 9], [1, 5, 6], [7, 8, 3]]
print(sorted(lis, key=lambda k: k[0])) #列表內(nèi)的沒項(xiàng)代入key后的表達(dá)式，根據(jù)返回值排序
# [[1, 5, 6], [4, 2, 9], [7, 8, 3]]
print(sorted(lis, key=lambda k: k[1]))
# [[4, 2, 9], [1, 5, 6], [7, 8, 3]]
print(sorted(lis, key=lambda k: k[2]))
# [[7, 8, 3], [1, 5, 6], [4, 2, 9]]
print(sorted(lis, key=lambda k: k[0], reverse=True))
# [[7, 8, 3], [4, 2, 9], [1, 5, 6]]

5.dict內(nèi)嵌套dict排序

dic = {
    "a": {"x": 3, "y": 2, "z": 1},
    "b": {"x": 2, "y": 1, "z": 3},
    "c": {"x": 1, "y": 3, "z": 2},
}
print(sorted(dic, key=lambda k: dic[k]["x"]))
# ["c", "b", "a"]
print(sorted(dic, key=lambda k: dic[k]["y"]))
# ["b", "a", "c"]
print(sorted(dic, key=lambda k: dic[k]["z"]))
# ["a", "c", "b"]
print(sorted(dic, key=lambda k: dic[k]["x"], reverse=True))
# ["a", "b", "c"]

6.list內(nèi)嵌套dict排序

lis = [
    {"x": 3, "y": 2, "z": 1},
    {"x": 2, "y": 1, "z": 3},
    {"x": 1, "y": 3, "z": 2},
]
print(sorted(lis, key=lambda k: k["x"]))
# [{"z": 2, "x": 1, "y": 3}, {"z": 3, "x": 2, "y": 1}, {"z": 1, "x": 3, "y": 2}]
print(sorted(lis, key=lambda k: k["y"]))
# [{"z": 3, "x": 2, "y": 1}, {"z": 1, "x": 3, "y": 2}, {"z": 2, "x": 1, "y": 3}]
print(sorted(lis, key=lambda k: k["z"]))
# [{"z": 1, "x": 3, "y": 2}, {"z": 2, "x": 1, "y": 3}, {"z": 3, "x": 2, "y": 1}]
print(sorted(lis, key=lambda k: k["x"], reverse=True))
# [{"z": 1, "x": 3, "y": 2}, {"z": 3, "x": 2, "y": 1}, {"z": 2, "x": 1, "y": 3}]

7.dict內(nèi)嵌套list排序

dic = {
    "a": [1, 2, 3],
    "b": [2, 1, 3],
    "c": [3, 1, 2],
}
print(sorted(dic, key=lambda k: dic[k][0]))
# ["a", "b", "c"]
print(sorted(dic, key=lambda k: dic[k][1]))
# ["b", "c", "a"]
print(sorted(dic, key=lambda k: dic[k][2]))
# ["c", "b", "a"]
print(sorted(dic, key=lambda k: dic[k][0], reverse=True))
# ["c", "b", "a"]

實(shí)例

1、給定一個只包含大小寫字母，數(shù)字的字符串，對其進(jìn)行排序，保證：

所有的小寫字母在大寫字母前面；
所有的字母在數(shù)字前面；
所有的奇數(shù)在偶數(shù)前面；

>>> s = "Sorting1234"
>>> "".join(sorted(s, key=lambda x: (x.isdigit(), x.isdigit() and int(x) % 2 == 0, x.isupper(), x.islower(), x)))
"ginortS1324"

2、排序一副FranchDeck。流暢的python書中示例

import collections

Card = collections.namedtuple("Card", ["rank", "suit"]) #命名元組

class FrenchDeck:
    ranks = [str(n) for n in range(2, 11)] + list("JQKA")  #2到10和JQKA
    suits = "spades diamonds clubs hearts".split()  #split默認(rèn)按空格生成列表

    def __init__(self):
        self._cards = [Card(rank, suit) for suit in self.suits for rank in self.ranks] #生成所有52張牌

    def __len__(self):
        return len(self._cards)  #可以用Len()方法

    def __getitem__(self, position):
        return self._cards[position]  #可以用索引或切片

suit_values = dict(spades=3, hearts=2, diamonds=1, clubs=0) #設(shè)置花色優(yōu)先級

def spades_high(card):
        rank_value = FrenchDeck.ranks.index(card.rank)  #找到當(dāng)前Card所在的索引：2的索引為0
        return rank_value * len(suit_values) + suit_values[card.suit] #返回當(dāng)前牌對應(yīng)的優(yōu)先級數(shù)字，如果沒有乘于len(suit_values)那么("2", "spades")和("4", "diamonds")的優(yōu)先級數(shù)字就一樣了，這里也可以直接乘于4或5，6....
    
#排序
>>> import Frenchcard
>>> deck = Frenchcard.FrenchDeck()
>>> for i in sorted(deck, key=b.spades_high): #sorted返回一個列表。key后的函數(shù)會代入deck列表里的每一項(xiàng)返回一個優(yōu)先級數(shù)字，并以這個優(yōu)先級數(shù)字排序
...     print(i)
Card(rank="2", suit="clubs")
Card(rank="2", suit="diamonds")
Card(rank="2", suit="hearts")
Card(rank="2", suit="spades")
Card(rank="3", suit="clubs")
Card(rank="3", suit="diamonds")
.............