객체의 속성을 기반으로 객체 목록을 정렬하는 방법은 무엇입니까?

Question

객체 자체의 속성으로 정렬하고 싶은 파이썬 객체 목록이 있습니다. 목록은 다음과 같습니다.

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

각 객체에는 카운트가 있습니다.

>>> ut[1].count
1L

내림차순으로 목록을 정렬해야합니다.

나는 이것에 대한 몇 가지 방법을 보았지만 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)

더 키에 의해 정렬»

Answer 2

가장 빠른 방법, 특히 목록이 많은 레코드가있는 경우 사용하는 것입니다. operator.attrgetter("count"). 그러나 이것은 사전 수술 자 버전의 Python에서 실행될 수 있으므로 폴백 메커니즘을 갖는 것이 좋을 것입니다. 그런 다음 다음을 수행하고 싶을 수도 있습니다.

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

Readers should notice that the key= method:

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

is many times faster than adding rich comparison operators to the objects. I was surprised to read this (page 485 of "Python in a Nutshell"). You can confirm this by running tests on this little program:

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

My, very minimal, tests show the first sort is more than 10 times slower, but the book says it is only about 5 times slower in general. The reason they say is due to the highly optimizes sort algorithm used in python (timsort).

Still, its very odd that .sort(lambda) is faster than plain old .sort(). I hope they fix that.

Answer 4

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

Answer 5

Object-oriented approach

It's good practice to make object sorting logic, if applicable, a property of the class rather than incorporated in each instance the ordering is required.

This ensures consistency and removes the need for boilerplate code.

At a minimum, you should specify __eq__ and __lt__ operations for this to work. Then just use 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 6

It looks much like a list of Django ORM model instances.

Why not sort them on query like this:

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

Answer 7

Add rich comparison operators to the object class, then use sort() method of the list.
See rich comparison in python.

---

Update: Although this method would work, I think solution from Triptych is better suited to your case because way simpler.