Como classificar uma lista de objetos com base em um atributo dos objetos?

Eu tenho uma lista de objetos Python que gostaria de classificar por um atributo dos próprios objetos. A lista se parece com:

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

Cada objeto tem uma contagem:

>>> ut[1].count
1L

Preciso classificar a lista pelo número de contagens decrescente.

Eu já vi vários métodos para isso, mas estou procurando as melhores práticas em 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)

Mais sobre a classificação por chaves .

Uma maneira que pode ser mais rápida, principalmente se a sua lista tiver muitos registros, é usar operator.attrgetter("count"). No entanto, isso pode ser executado em uma versão pré-operador do Python, portanto, seria bom ter um mecanismo de fallback. Você pode fazer o seguinte, então:

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

Os leitores devem observar que o método key =:

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

é muitas vezes mais rápido do que adicionar operadores de comparação avançados aos objetos. Fiquei surpreso ao ler isso (página 485 de "Python em poucas palavras"). Você pode confirmar isso executando testes neste pequeno programa:

#!/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

Meus testes muito mínimos mostram que o primeiro tipo é 10 vezes mais lento, mas o livro diz que é apenas 5 vezes mais lento em geral. O motivo é que eles dizem que se deve ao algoritmo de classificação altamente otimizado usado em python ( timsort ).

Ainda assim, é muito estranho que .sort (lambda) seja mais rápido que o antigo .sort (). Espero que eles consertem isso.

Abordagem orientada a objetos

É uma boa prática criar lógica de classificação de objetos, se aplicável, uma propriedade da classe em vez de incorporar em cada instância em que a ordem é necessária.

Isso garante consistência e elimina a necessidade de código padrão.

No mínimo, você deve especificar __eq__e __lt__operações para que isso funcione. Então é só usar 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)

Parece muito com uma lista de instâncias do modelo Django ORM.

Por que não classificá-los em consultas como esta:

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

Adicione operadores de comparação avançados à classe de objeto e use o método sort () da lista.
Veja uma comparação rica em python .

Atualização : Embora esse método funcione, acho que a solução da Triptych é mais adequada ao seu caso, porque é muito mais simples.

Se o atributo que você deseja classificar for uma propriedade , evite importar operator.attrgettere usar os atributos da propriedade.fget método .

Por exemplo, para uma classe Circlecom uma propriedade, radiuspodemos classificar uma lista circlespor raio da seguinte maneira:

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

Esse não é o recurso mais conhecido, mas geralmente me poupa uma linha com a importação.