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

J'ai une liste d'objets Python que j'aimerais trier par 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 décompte:

>>> ut[1].count
1L

J'ai besoin de trier la liste par nombre de décomptes décroissants.

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

# 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)

Plus d'informations sur le tri par clés .

Un moyen qui peut être plus rapide, surtout si votre liste contient beaucoup d'enregistrements, est d'utiliser operator.attrgetter("count"). Cependant, cela pourrait fonctionner sur une version pré-opérateur de Python, donc ce serait bien d'avoir un mécanisme de secours. Vous pouvez alors 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

Les lecteurs doivent noter que la méthode key =:

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

est beaucoup plus rapide que l'ajout d'opérateurs de comparaison riches aux objets. J'ai été surpris de lire ceci (page 485 de "Python en bref"). Vous pouvez le confirmer en exécutant 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 que 5 fois plus lent en général. La raison pour laquelle ils disent est due à l'algorithme de tri hautement optimisé utilisé en python ( timsort ).

Pourtant, il est très étrange que .sort (lambda) soit plus rapide que l'ancien .sort (). J'espère qu'ils corrigent cela.

Approche orientée objet

Il est recommandé de faire de la logique de tri des objets, le cas échéant, une propriété de la classe plutôt qu'incorporée dans chaque instance, le classement est requis.

Cela garantit la cohérence et élimine le besoin de code passe-partout.

Au minimum, vous devez spécifier __eq__et les __lt__opérations pour que cela fonctionne. Ensuite, utilisez simplement 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]

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

Cela ressemble beaucoup à une liste d'instances de modèle Django ORM.

Pourquoi ne pas les trier sur une requête comme celle-ci:

ut = Tag.objects.order_by('-count')

Ajoutez des opérateurs de comparaison riches à la classe d'objets, puis utilisez la méthode sort () de la liste.
Voir une comparaison riche en python .

Mise à jour : Bien que cette méthode fonctionne, je pense que la solution de Triptych est mieux adaptée à votre cas car beaucoup plus simple.

Si l'attribut que vous souhaitez trier est une propriété , vous pouvez éviter d'importer operator.attrgetteret utiliser la fgetméthode de la propriété à la place.

Par exemple, pour une classe Circleavec une propriété, radiusnous pourrions trier une liste de circlesrayons comme suit:

result = sorted(circles, key=Circle.radius.fget)

Ce n'est pas la fonctionnalité la plus connue, mais cela me sauve souvent une ligne avec l'importation.