¿Cómo clasifico una lista de objetos según un atributo de los objetos?

Question 1

Tengo una lista de objetos de Python que quiero ordenar por un atributo específico de cada objeto:

[Tag(name="toe", count=10), Tag(name="leg", count=2), ...]

¿Cómo ordeno la lista por .count ¿en orden descendente?

Question 2

Para ordenar la lista en su lugar:

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

Para devolver una nueva lista, utilice sorted:

new_list = sorted(orig_list, key=lambda x: x.count, reverse=True)

Explicación:

key=lambda x: x.count ordena por conteo.
reverse=True clasifica en orden descendente.

Más en clasificación por claves.

Question 3

Una forma que puede ser más rápida, especialmente si su lista tiene muchos registros, es usar operator.attrgetter("count"). Sin embargo, esto podría ejecutarse en una versión previa al operador de Python, por lo que sería bueno tener un mecanismo de respaldo. Es posible que desee hacer lo siguiente, entonces:

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

Question 4

Los lectores deben notar que el método key=:

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

es muchas veces más rápido que agregar operadores de comparación enriquecidos a los objetos. Me sorprendió leer esto (página 485 de “Python in a Nutshell”). Puede confirmar esto ejecutando pruebas en este pequeño 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

Mis pruebas, muy mínimas, muestran que el primer tipo es más de 10 veces más lento, pero el libro dice que es solo unas 5 veces más lento en general. La razón por la que dicen se debe al algoritmo de clasificación altamente optimizado utilizado en python (timsort).

Aún así, es muy extraño que .sort(lambda) sea más rápido que el antiguo .sort(). Espero que arreglen eso.

Question 5

Enfoque orientado a objetos

Es una buena práctica hacer que la lógica de clasificación de objetos, si corresponde, sea una propiedad de la clase en lugar de incorporarla en cada instancia en la que se requiera la clasificación.

Esto garantiza la coherencia y elimina la necesidad de un código repetitivo.

Como mínimo, debe especificar __eq__ y __lt__ operaciones para que esto funcione. Entonces solo usa 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]

Question 6

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

Question 7

Se parece mucho a una lista de instancias del modelo Django ORM.

¿Por qué no ordenarlos en una consulta como esta?

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

Question 8

Agregue operadores de comparación enriquecidos a la clase de objeto, luego use el método sort() de la lista.
Ver rica comparación en python.

Actualizar: Aunque este método funcionaría, creo que la solución de Triptych se adapta mejor a su caso porque es mucho más simple.

¿Ha sido útil esta solución?