Trier une liste par plusieurs attributs?

J'ai une liste de listes:

[[12, 'tall', 'blue', 1],
[2, 'short', 'red', 9],
[4, 'tall', 'blue', 13]]

Si je voulais trier par un élément, dire le grand et court élément, je pourrais le faire via s = sorted(s, key = itemgetter(1)).

Si je voulais trier par les deux grand et court et de couleur, je pourrais faire le tri à deux reprises, une fois pour chaque élément, mais est-il un moyen plus rapide?

  • Liées PPCG question
  • Si vous utilisez tuples au lieu de listes, python commandes sortes par des entrées de gauche à droite lorsque vous exécutez sort. C'est, sorted([(4, 2), (0, 3), (0, 1)]) == [(0, 1), (0, 3), (4, 2)].
InformationsquelleAutor headache | 2010-11-20
  1. 593

    Une clé peut être une fonction qui renvoie un tuple:

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

    Ou vous pouvez obtenir le même à l'aide de itemgetter (qui est plus rapide et évite de Python appel de fonction):

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

    Et remarquez que vous pouvez utiliser ici sort au lieu d'utiliser sorted et puis réaffectation:

    s.sort(key = operator.itemgetter(1, 2))
    • Vous apprenez quelque chose de nouveau tous les jours! Savez-vous si ce calcul est plus rapide que la méthode précédente? Ou est-il juste de faire la même chose dans le fond?
    • Je ne sais pas qui est plus rapide, je crois qu'ils sont sur la même. Vous pouvez utiliser le timeit module de mesure de la performance des deux si vous êtes intéressé.
    • Pour l'exhaustivité de timeit: pour moi, le premier a donné 6 us par boucle et la deuxième 4.4 nous par boucle
    • Est-il un moyen de trier le premier croissant et la seconde en descendant? (Suppose que les deux attributs sont des chaînes de caractères, donc pas de hacks comme l'ajout de - pour les entiers)
    • Malheureusement, je ne pense pas qu'il y est un non-hack façon. La méthode proposée dans la documentation est de trier par deux fois, en utilisant la propriété que le tri est stable. Voir ici pour plus de détails.
    • comment faire si je veux appliquer revrse=True seulement à x[1] est-ce possible ?
    • à l'inverse, pour qu'un attribut, vous pouvez les trier en deux fois: d'abord par le secondaire s = sorted(s, key = operator.itemgetter(2)) puis par le principal s = sorted(s, key = operator.itemgetter(1), reverse=True) Pas l'idéal, mais fonctionne.
    • Je pense que le tri deux fois, c'est la meilleure stratégie dans ce scénario comme sorted est garanti pour être stable (source)
    • ou une autre option, si la clé est de faire l'inverse, vous pouvez multipliez-le par -1.
    • À @Amyth commentaire de la négation, voir question ici.
    • j'ai une liste de tableau et j'ai utilisé ce linesOrderedLeft = lines_Left.sort(key= lambda t: (t[0][1],t[0][3]) ) mais il ne fonctionne pas avec moi car je suis en train de trier les tableaux basés sur leur premier et le troisième indice, en faisant la somme jusqu'Alors quel est le problème avec mon code
    • Il faut vous dire que key = operator.itemgetter(...) est beaucoup plus rapide que key = lambda: ..., et le déplacer vers le haut. Aussi, lambda est inutile plutôt que de itemgetter si le tri personnalisé est seulement accès à plusieurs domaines, et de ne pas les transformer (par exemple, la négation, en minuscules, commande personnalisée, ASCIIbetical ordre, une chaîne d'appels de méthode objet, etc.)
    • et ne travaille pas seulement pour int également boolean et string data = sorted(données, key=lambda x: x['active']*-1,x['nom']))
    • une autre façon d'utiliser reverse=True est d'envelopper les deux critères de tri dans la parenthèse: s = sorted(s, key=lambda i: ( criteria1(i), criteria2(i) ), reverse=True)

    InformationsquelleAutor Mark Byers
  2. 29

    Je ne suis pas sûr si c'est le plus pythonic méthode ...
    J'avais une liste de tuples qui devait 1er tri par ordre décroissant des valeurs entières et 2ème ordre alphabétique. Cette nécessaire d'inverser l'entier de tri, mais pas l'ordre alphabétique. C'était ma solution: (à la volée dans un examen btw, je n'étais même pas conscient que vous avez pu " nid " triés fonctions)

    a = [('Al', 2),('Bill', 1),('Carol', 2), ('Abel', 3), ('Zeke', 2), ('Chris', 1)]  
b = sorted(sorted(a, key = lambda x : x[0]), key = lambda x : x[1], reverse = True)  
print(b)  
[('Abel', 3), ('Al', 2), ('Carol', 2), ('Zeke', 2), ('Bill', 1), ('Chris', 1)]
    • depuis le 2ème est un nombre, il travaille à faire comme b = sorted(a, key = lambda x: (-x[1], x[0])) qui est plus visible sur les critères qui s'applique en premier. comme pour l'efficacité je ne suis pas sûr, quelqu'un doit timeit.
    • votre réponse fait beaucoup de sens pour moi. C'est tellement facile de se rappeler et de code. Je vous remercie.
    InformationsquelleAutor Clint Blatchford
  3. 3

    Il semble que vous pourriez utiliser un list au lieu d'un tuple.
    Cela devient de plus en plus important, je pense que lorsque vous prenez les attributs au lieu de " la magie des indices d'une liste ou un tuple.

    Dans mon cas, j'ai voulu trier par plusieurs attributs d'une classe, où les entrants les clés sont des chaînes de caractères. J'avais besoin de tri différents dans différents endroits, et je voulais une commune tri par défaut pour la classe parente que les clients ont été en interaction avec; de n'avoir à remplacer les "clés de tri" quand je suis vraiment "nécessaire pour", mais aussi dans une manière que je pourrais stocker sous forme de listes que la classe pourrait partager

    Alors d'abord j'ai défini une méthode d'assistance

    def attr_sort(self, attrs=['someAttributeString']:
  '''helper to sort by the attributes named by strings of attrs in order'''
  return lambda k: [ getattr(k, attr) for attr in attrs ]

    puis de l'utiliser

    # would defined elsewhere but showing here for consiseness
self.SortListA = ['attrA', 'attrB']
self.SortListB = ['attrC', 'attrA']
records = .... #list of my objects to sort
records.sort(key=self.attr_sort(attrs=self.SortListA))
# perhaps later nearby or in another function
more_records = .... #another list
more_records.sort(key=self.attr_sort(attrs=self.SortListB))

    Cela utiliser le générés fonction lambda trier la liste par object.attrA et puis object.attrB en supposant object a un getter correspondant à la chaîne les noms fournis. Et le deuxième cas serait de trier par object.attrC puis object.attrA.

    Cela permet également à risque d'exposer l'extérieur de tri des choix fragment de la même manière par un consommateur, un test unitaire, ou peut-être vous dire comment ils veulent le tri effectué pour une opération dans votre api en n'avez qu'à vous donner une liste et pas de couplage à votre back-end de mise en œuvre.

    InformationsquelleAutor UpAndAdam
  4. 1

    Voici un moyen: en gros, Vous ré-écrire votre fonction de tri de prendre une liste de fonctions de tri, chaque fonction de tri compare les attributs que vous souhaitez tester, sur chaque sorte de test, de vous regarder et de voir si la cmp fonction renvoie une valeur non nulle de retour si oui pause et envoyer la valeur de retour.
    Vous l'appelez par l'appel d'une Lambda d'une fonction d'une liste de Lambdas.

    Son avantage est qu'il ne passe unique à travers les données, et non une sorte de tri précédent que les autres méthodes. Une autre chose est qu'il trie en place, alors que triées semble en faire une copie.

    Je l'ai utilisé pour écrire une fonction rang, qui classe une liste de classes où chaque objet est dans un groupe et a une fonction de score, mais vous pouvez ajouter une liste d'attributs.
    Note de l'onu-lambda-comme, si hackish utilisation d'un lambda pour appeler un setter.
    Le rang de la partie de ne pas travailler pour un tableau de listes, mais le tri doit.

    #First, here's  a pure list version
my_sortLambdaLst = [lambda x,y:cmp(x[0], y[0]), lambda x,y:cmp(x[1], y[1])]
def multi_attribute_sort(x,y):
    r = 0
    for l in my_sortLambdaLst:
        r = l(x,y)
        if r!=0: return r #keep looping till you see a difference
    return r

Lst = [(4, 2.0), (4, 0.01), (4, 0.9), (4, 0.999),(4, 0.2), (1, 2.0), (1, 0.01), (1, 0.9), (1, 0.999), (1, 0.2) ]
Lst.sort(lambda x,y:multi_attribute_sort(x,y)) #The Lambda of the Lambda
for rec in Lst: print str(rec)

    Ici est une façon de classer une liste d'objets

    class probe:
def __init__(self, group, score):
self.group = group
self.score = score
self.rank =-1
def set_rank(self, r):
self.rank = r
def __str__(self):
return '\t'.join([str(self.group), str(self.score), str(self.rank)]) 
def RankLst(inLst, group_lambda= lambda x:x.group, sortLambdaLst = [lambda x,y:cmp(x.group, y.group), lambda x,y:cmp(x.score, y.score)], SetRank_Lambda = lambda x, rank:x.set_rank(rank)):
#Inner function is the only way (I could think of) to pass the sortLambdaLst into a sort function
def multi_attribute_sort(x,y):
r = 0
for l in sortLambdaLst:
r = l(x,y)
if r!=0: return r #keep looping till you see a difference
return r
inLst.sort(lambda x,y:multi_attribute_sort(x,y))
#Now Rank your probes
rank = 0
last_group = group_lambda(inLst[0])
for i in range(len(inLst)):
rec = inLst[i]
group = group_lambda(rec)
if last_group == group: 
rank+=1
else:
rank=1
last_group = group
SetRank_Lambda(inLst[i], rank) #This is pure evil!! The lambda purists are gnashing their teeth
Lst = [probe(4, 2.0), probe(4, 0.01), probe(4, 0.9), probe(4, 0.999), probe(4, 0.2), probe(1, 2.0), probe(1, 0.01), probe(1, 0.9), probe(1, 0.999), probe(1, 0.2) ]
RankLst(Lst, group_lambda= lambda x:x.group, sortLambdaLst = [lambda x,y:cmp(x.group, y.group), lambda x,y:cmp(x.score, y.score)], SetRank_Lambda = lambda x, rank:x.set_rank(rank))
print '\t'.join(['group', 'score', 'rank']) 
for r in Lst: print r
    InformationsquelleAutor Dominic Suciu
  5. 0

    Plusieurs années de retard à la fête, mais je veux les deux tri sur 2 critères et utilisation reverse=True. Dans le cas où quelqu'un d'autre veut savoir comment, vous pouvez envelopper vos critères (fonctions) entre parenthèses:

    s = sorted(my_list, key=lambda i: ( criteria_1(i), criteria_2(i) ), reverse=True)
    InformationsquelleAutor ron g