Comment trier une liste d'objets en fonction d'un attribut de ces objets ?

Question

J'ai une liste d'objets Python que j'aimerais trier par un attribut des objets eux-mêmes. La liste ressemble à :

>>> ut
[<Tag: 128>, <Tag: 2008>, <Tag: <>, <Tag: actionscript>, <Tag: addresses>,
 <Tag: aes>, <Tag: ajax> ...]

Chaque objet a un compte :

>>> ut[1].count
1L

J'ai besoin de trier la liste par nombre de comptes de manière descendante.

J'ai vu plusieurs méthodes pour cela, mais je recherche les meilleures pratiques en Python.

Answer 1

# To sort the list in place...
ut.sort(key=lambda x: x.count, reverse=True)

# To return a new list, use the sorted() built-in function...
newlist = sorted(ut, key=lambda x: x.count, reverse=True)

En savoir plus trier par clés .

Answer 2

Une façon qui peut être la plus rapide, surtout si votre liste a beaucoup d'enregistrements, est d'utiliser operator.attrgetter("count") . Cependant, cela pourrait fonctionner sur une version de Python antérieure à celle de l'opérateur, et il serait bon d'avoir un mécanisme de secours. Vous pourriez donc faire ce qui suit :

try: import operator
except ImportError: keyfun= lambda x: x.count # use a lambda if no operator module
else: keyfun= operator.attrgetter("count") # use operator since it's faster than lambda

ut.sort(key=keyfun, reverse=True) # sort in-place

Answer 3

Le lecteur remarquera que la méthode key= :

ut.sort(key=lambda x: x.count, reverse=True)

est plusieurs fois plus rapide que l'ajout d'opérateurs de comparaison riches aux objets. J'ai été surpris de lire cela (page 485 de "Python in a Nutshell"). Vous pouvez le confirmer en effectuant des tests sur ce petit programme :

#!/usr/bin/env python
import random

class C:
    def __init__(self,count):
        self.count = count

    def __cmp__(self,other):
        return cmp(self.count,other.count)

longList = [C(random.random()) for i in xrange(1000000)] #about 6.1 secs
longList2 = longList[:]

longList.sort() #about 52 - 6.1 = 46 secs
longList2.sort(key = lambda c: c.count) #about 9 - 6.1 = 3 secs

Mes tests, très minimes, montrent que le premier tri est plus de 10 fois plus lent, mais le livre dit qu'il n'est qu'environ 5 fois plus lent en général. La raison pour laquelle ils disent cela est due à l'algorithme de tri hautement optimisé utilisé dans python ( timsort ).

Néanmoins, il est très étrange que .sort(lambda) soit plus rapide que le bon vieux .sort(). J'espère qu'ils corrigeront cela.

Answer 4

Approche orientée objet

Une bonne pratique consiste à faire de la logique de tri des objets, le cas échéant, une propriété de la classe plutôt que de l'incorporer dans chaque instance où le tri est requis.

Cela permet de garantir la cohérence et de supprimer le code passe-partout.

Au minimum, vous devez préciser __eq__ y __lt__ opérations pour que cela fonctionne. Il suffit alors d'utiliser sorted(list_of_objects) .

class Card(object):

    def __init__(self, rank, suit):
        self.rank = rank
        self.suit = suit

    def __eq__(self, other):
        return self.rank == other.rank and self.suit == other.suit

    def __lt__(self, other):
        return self.rank < other.rank

hand = [Card(10, 'H'), Card(2, 'h'), Card(12, 'h'), Card(13, 'h'), Card(14, 'h')]
hand_order = [c.rank for c in hand]  # [10, 2, 12, 13, 14]

hand_sorted = sorted(hand)
hand_sorted_order = [c.rank for c in hand_sorted]  # [2, 10, 12, 13, 14]

Answer 5

from operator import attrgetter
ut.sort(key = attrgetter('count'), reverse = True)