Python3 sorted函数中key参数的作用原理

Question

这是一个字符串排序，排序规则：小写<大写<奇数<偶数

s = 'asdf234GDSdsf23'  #排序:小写-大写-奇数-偶数
print("".join(sorted(s, key=lambda x: (x.isdigit(), x.isdigit() and int(x) % 2 == 0, x.isupper(), x.islower(), x))))

这里key接受的函数返回的是一个元组？是如何进行比较的？

Answer 1

Comparez d'abord la première valeur du tuple, FALSE<TRUE, si elle est égale, comparez la valeur suivante du tuple, et ainsi de suite.

Answer 2

Commençons par un exemple simple :

items = [(1, 2), (2, 1)]
print(sorted(items))

Résultat :

[(1, 2), (2, 1)]

items est une liste de tuples. Si le tuple est trié, la fonction intégrée de Python sorted (ou sort) triera à partir du dernier élément du tuple, c'est-à-dire un ensemble de deux éléments. les tuples peuvent être imaginés comme deux tris de base :

À l'origine :

[(2, 1), (1, 2)]

Le premier tri utilise le deuxième élément comme clé, le résultat du tri est donc :

[(2, 1), (1, 2)]

Le deuxième tri utilise le premier élément comme clé, donc le résultat du tri est :

[(1, 2), (2, 1)] # 最終結果

Conclusion (1) :

Le tri des tuples est trié à partir du dernier élément vers l'avant
C'est-à-dire que le poids de tri des tuples commence à partir du premier élément et décroît vers l'arrière

---

Observons ensuite le tri des valeurs booléennes :

print(sorted([True, False])

Résultat :

[False, True] # False在前，True在後

Conclusion 2 :

Le tri booléen placera False devant et True en bas

---

Jetons ensuite un œil à l'exemple que vous avez donné. Écrivons une fonction simple pour observer les résultats :

def show(s):
    for x in s:
        print((x.isdigit(), x.isdigit() and int(x)%2==0, x.isupper(), x.islower(), x))

fonction show imprimera la chaîne actuelle s qui est utilisée pour générer la clé de tuple pour chaque caractère lors du tri.

Ensuite, nous appliquons la conclusion 1 tout à l'heure. Au lieu d'utiliser le tuple comme clé, nous utilisons l'équivalent pour trier la clé à partir du dernier élément vers l'avant , et observons progressivement les changements s et tuple. en clé :

print('key=x')
s = sorted(s ,key=lambda x: x)
show(s)

print('key=islower()')
s = sorted(s ,key=lambda x: x.islower())
show(s)

print('key=isupper()')
s = sorted(s ,key=lambda x: x.isupper())
show(s)

print('key=isdigit() and int(x)%2==0')
s = sorted(s ,key=lambda x: x.isdigit() and int(x)%2==0)
show(s)

Nous constaterons que, comme prévu, d'après la conclusion (1), cette approche équivaut effectivement à un tri avec tuple comme clé en une seule fois.
Observez en même temps, conclusion (2), pour les clés booléennes générées par isdigit(), isupper(), islower(), etc., les résultats du tri sont également comme prévu.

print('key=isdigit()')
s = sorted(s ,key=lambda x: x.isdigit())
show(s)

---

Mais je pense que ce n'est pas notre conclusion finale, car c'est un résultat fortuit (c'est peut-être trop dire que cela s'est produit, il faut dire que c'est un résultat moins intuitif), concluons sur la base de Conclusion (1) Analyse de l'exemple original :

sorted(s, key=lambda x: (x.isdigit(), x.isdigit() and int(x) % 2 == 0, x.isupper(), x.islower(), x))

On peut traduire ce tri par :

Triez d'abord le caractère x lui-même, puis triez si le caractère est en minuscule, si le caractère est en majuscule, si le caractère est un nombre pair et si le caractère est un nombre.

peut également être traduit par :

Nous utilisons si le caractère est un nombre comme poids de tri le plus élevé, puis nous utilisons si le caractère est un nombre pair, si le caractère est en majuscule, si le caractère est en minuscule et le caractère x lui-même comme le poids.

Cela semble différent de l'objectif initial (#Sort : minuscule-majuscule-impair-pair), du moins il n'a pas de correspondance intuitive avec l'objectif.

Il est recommandé de le changer en :

print("".join(sorted(s1, key=lambda x: (not x.islower(), not x.isupper(), not(x.isdigit() and int(x)%2==1), x))))

Cela peut être interprété comme :

Nous utilisons si le caractère est en minuscule comme poids le plus élevé, puis nous utilisons si le caractère est en majuscule, si le caractère est un nombre impair et le caractère x lui-même comme poids à trier

Ce qui est intéressant, c'est que nous voulons que les caractères dont la formule de jugement est True soient comparés à la position précédente une fois le tri terminé, donc sur la base de la conclusion (2), nous ajoutons un not pour que la correspondance les personnages peuvent être devant.

Answer 3

Le point clé est, comme donghui l'a dit, FAUX<VRAI.
key est la situation de tri des tuples. Chaque élément à trier génère un tuple (x.isdigit(), x.isdigit() and int(x) % 2 == 0, x.isupper(), x.islower(), x) Le tri est basé sur ce tuple. La base est FALSE<TRUE, false est classé en premier et true est classé en dernier. ce sont les mêmes, voir le suivant. sorted renvoie finalement les éléments qui doivent être triés.

Le code du test est le suivant : (de dokelung et donghui)

if __name__ == '__main__':
    s = 'asdf234GDSdsf23'

    print('key=x')
    s = sorted(s, key=lambda x: x)
    for x in s:
        print((x, x))

    print('key=islower()')
    s = sorted(s, key=lambda x: x.islower())
    for x in s:
        print((x.islower(), x))

    print('key=isupper()')
    s = sorted(s, key=lambda x: x.isupper())
    for x in s:
        print((x.isupper(), x))

    print('key=isdigit() and int(x)%2==0')
    s = sorted(s, key=lambda x: x.isdigit() and int(x) % 2 == 0)
    for x in s:
        print((x.isdigit() and int(x) % 2 == 0, x))

    print('key=(x.isupper(), x.islower())')
    s = sorted(s, key=lambda x: (x.isupper(), x.islower()))
    for x in s:
        print((x.isupper(), x.islower(), x))

    print('key=(x.isdigit(), x.isdigit() and int(x) % 2 == 0, x.isupper(), x.islower(), x))')
    s = sorted(s, key=lambda x: (x.isdigit(), x.isdigit() and int(x) % 2 == 0, x.isupper(), x.islower(), x))
    for x in s:
        print((x.isdigit(), x.isdigit() and int(x) % 2 == 0, x.isupper(), x.islower(), x))

Exécutez et affichez l'entrée pour découvrir des modèles.
Sortie :

key=x
('2', '2')
('2', '2')
('3', '3')
('3', '3')
('4', '4')
('D', 'D')
('G', 'G')
('S', 'S')
('a', 'a')
('d', 'd')
('d', 'd')
('f', 'f')
('f', 'f')
('s', 's')
('s', 's')
key=islower()
(False, '2')
(False, '2')
(False, '3')
(False, '3')
(False, '4')
(False, 'D')
(False, 'G')
(False, 'S')
(True, 'a')
(True, 'd')
(True, 'd')
(True, 'f')
(True, 'f')
(True, 's')
(True, 's')
key=isupper()
(False, '2')
(False, '2')
(False, '3')
(False, '3')
(False, '4')
(False, 'a')
(False, 'd')
(False, 'd')
(False, 'f')
(False, 'f')
(False, 's')
(False, 's')
(True, 'D')
(True, 'G')
(True, 'S')
key=isdigit() and int(x)%2==0
(False, '3')
(False, '3')
(False, 'a')
(False, 'd')
(False, 'd')
(False, 'f')
(False, 'f')
(False, 's')
(False, 's')
(False, 'D')
(False, 'G')
(False, 'S')
(True, '2')
(True, '2')
(True, '4')
key=(x.isupper(), x.islower())
(False, False, '3')
(False, False, '3')
(False, False, '2')
(False, False, '2')
(False, False, '4')
(False, True, 'a')
(False, True, 'd')
(False, True, 'd')
(False, True, 'f')
(False, True, 'f')
(False, True, 's')
(False, True, 's')
(True, False, 'D')
(True, False, 'G')
(True, False, 'S')
key=(x.isdigit(), x.isdigit() and int(x) % 2 == 0, x.isupper(), x.islower(), x))
(False, False, False, True, 'a')
(False, False, False, True, 'd')
(False, False, False, True, 'd')
(False, False, False, True, 'f')
(False, False, False, True, 'f')
(False, False, False, True, 's')
(False, False, False, True, 's')
(False, False, True, False, 'D')
(False, False, True, False, 'G')
(False, False, True, False, 'S')
(True, False, False, False, '3')
(True, False, False, False, '3')
(True, True, False, False, '2')
(True, True, False, False, '2')
(True, True, False, False, '4')