Trier une liste Python par deux champs

J'ai la liste suivante créée à partir d'un csv trié

list1 = sorted(csv1, key=operator.itemgetter(1))

Je voudrais en fait trier la liste selon deux critères: d'abord par la valeur dans le champ 1 et ensuite par la valeur dans le champ 2. Comment faire?

comme ça:

import operator
list1 = sorted(csv1, key=operator.itemgetter(1, 2))

Pas besoin d'importer quoi que ce soit lors de l'utilisation des fonctions lambda.
Les éléments suivants sont triés listpar le premier élément, puis par le deuxième élément.

sorted(list, key=lambda x: (x[0], -x[1]))

Python a un tri stable, donc à condition que les performances ne soient pas un problème, le moyen le plus simple est de le trier par champ 2, puis de le trier à nouveau par champ 1.

Cela vous donnera le résultat que vous voulez, le seul hic, c'est que s'il s'agit d'une grande liste (ou si vous voulez la trier souvent), appeler tri deux fois peut être une surcharge inacceptable.

list1 = sorted(csv1, key=operator.itemgetter(2))
list1 = sorted(list1, key=operator.itemgetter(1))

En procédant de cette manière, il est également facile de gérer la situation dans laquelle vous souhaitez que certaines des colonnes soient triées de manière inversée, incluez simplement le paramètre 'reverse = True' si nécessaire.

Sinon, vous pouvez transmettre plusieurs paramètres à itemgetter ou créer manuellement un tuple. Cela va probablement être plus rapide, mais a le problème que cela ne se généralise pas bien si certaines des colonnes veulent être triées par inversion (les colonnes numériques peuvent toujours être inversées en les annulant, mais cela empêche le tri d'être stable).

Donc, si vous n'avez pas besoin de colonnes triées inversement, optez pour plusieurs arguments dans itemgetter, si vous le pouvez, et les colonnes ne sont pas numériques ou si vous voulez garder le tri stable pour plusieurs tris consécutifs.

Edit: Pour les commentateurs qui ont du mal à comprendre comment cela répond à la question d'origine, voici un exemple qui montre exactement comment la nature stable du tri garantit que nous pouvons faire des tris séparés sur chaque clé et finir avec des données triées sur plusieurs critères:

DATA = [
    ('Jones', 'Jane', 58),
    ('Smith', 'Anne', 30),
    ('Jones', 'Fred', 30),
    ('Smith', 'John', 60),
    ('Smith', 'Fred', 30),
    ('Jones', 'Anne', 30),
    ('Smith', 'Jane', 58),
    ('Smith', 'Twin2', 3),
    ('Jones', 'John', 60),
    ('Smith', 'Twin1', 3),
    ('Jones', 'Twin1', 3),
    ('Jones', 'Twin2', 3)
]

# Sort by Surname, Age DESCENDING, Firstname
print("Initial data in random order")
for d in DATA:
    print("{:10s} {:10s} {}".format(*d))

print('''
First we sort by first name, after this pass all
Twin1 come before Twin2 and Anne comes before Fred''')
DATA.sort(key=lambda row: row[1])

for d in DATA:
    print("{:10s} {:10s} {}".format(*d))

print('''
Second pass: sort by age in descending order.
Note that after this pass rows are sorted by age but
Twin1/Twin2 and Anne/Fred pairs are still in correct
firstname order.''')
DATA.sort(key=lambda row: row[2], reverse=True)
for d in DATA:
    print("{:10s} {:10s} {}".format(*d))

print('''
Final pass sorts the Jones from the Smiths.
Within each family members are sorted by age but equal
age members are sorted by first name.
''')
DATA.sort(key=lambda row: row[0])
for d in DATA:
    print("{:10s} {:10s} {}".format(*d))

Ceci est un exemple exécutable, mais pour sauver les personnes qui l'exécutent, le résultat est:

Initial data in random order
Jones      Jane       58
Smith      Anne       30
Jones      Fred       30
Smith      John       60
Smith      Fred       30
Jones      Anne       30
Smith      Jane       58
Smith      Twin2      3
Jones      John       60
Smith      Twin1      3
Jones      Twin1      3
Jones      Twin2      3

First we sort by first name, after this pass all
Twin1 come before Twin2 and Anne comes before Fred
Smith      Anne       30
Jones      Anne       30
Jones      Fred       30
Smith      Fred       30
Jones      Jane       58
Smith      Jane       58
Smith      John       60
Jones      John       60
Smith      Twin1      3
Jones      Twin1      3
Smith      Twin2      3
Jones      Twin2      3

Second pass: sort by age in descending order.
Note that after this pass rows are sorted by age but
Twin1/Twin2 and Anne/Fred pairs are still in correct
firstname order.
Smith      John       60
Jones      John       60
Jones      Jane       58
Smith      Jane       58
Smith      Anne       30
Jones      Anne       30
Jones      Fred       30
Smith      Fred       30
Smith      Twin1      3
Jones      Twin1      3
Smith      Twin2      3
Jones      Twin2      3

Final pass sorts the Jones from the Smiths.
Within each family members are sorted by age but equal
age members are sorted by first name.

Jones      John       60
Jones      Jane       58
Jones      Anne       30
Jones      Fred       30
Jones      Twin1      3
Jones      Twin2      3
Smith      John       60
Smith      Jane       58
Smith      Anne       30
Smith      Fred       30
Smith      Twin1      3
Smith      Twin2      3

Notez en particulier comment dans la deuxième étape le reverse=Trueparamètre maintient les prénoms dans l'ordre alors que le simple tri puis l'inversion de la liste perdraient l'ordre souhaité pour la troisième clé de tri.

list1 = sorted(csv1, key=lambda x: (x[1], x[2]) )

employees.sort(key = lambda x:x[1])
employees.sort(key = lambda x:x[0])

Nous pouvons également utiliser .sort avec lambda 2 fois car le tri python est en place et stable. Cela triera d'abord la liste en fonction du deuxième élément, x [1]. Ensuite, il triera le premier élément, x [0] (priorité la plus élevée).

employees[0] = Employee's Name
employees[1] = Employee's Salary

Cela équivaut à faire ce qui suit: employés.sort (clé = lambda x: (x [0], x [1]))

Par ordre croissant, vous pouvez utiliser:

sorted_data= sorted(non_sorted_data, key=lambda k: (k[1],k[0]))

ou dans l'ordre décroissant, vous pouvez utiliser:

sorted_data= sorted(non_sorted_data, key=lambda k: (k[1],k[0]),reverse=True)

Le tri de la liste des dictionnaires ci-dessous triera la liste par ordre décroissant sur la première colonne comme salaire et la deuxième colonne comme âge

d=[{'salary':123,'age':23},{'salary':123,'age':25}]
d=sorted(d, key=lambda i: (i['salary'], i['age']),reverse=True)

Résultat: [{'salaire': 123, 'âge': 25}, {'salaire': 123, 'âge': 23}]