Comment faire heapq évaluer le tas hors d'un attribut spécifique?

Je souhaite organiser un tas d'objets, pas seulement des chiffres. Ils ont un attribut entier en eux que le tas peut trier par. La façon la plus simple d'utiliser des tas de python est heapq, mais comment dois-je le dire à trier par un attribut spécifique lors de l'utilisation de heapq?

InformationsquelleAutor coffee | 2010-10-17

49

heapq sortes d'objets de la même façon list.sort n', il suffit donc de définir une méthode __cmp__() au sein de votre définition de classe, ce qui permettra de comparer lui-même à une autre instance de la même classe:
```
def __cmp__(self, other):
    return cmp(self.intAttribute, other.intAttribute)
```
Œuvres en Python 2.x.

En 3.x utilisation:
```
def __lt__(self, other):
    return self.intAttribute < other.intAttribute
```
- __cmp__ est parti en 3.x. Utilisation __lt__ à la place.
- __lt__ œuvres en Python 2 aussi, il est donc préférable de simplement les éviter __cmp__ tout à fait.
- Comme vous pouvez le dire à tout trier pour trier selon un critère autre que l'objet naturel de tri (par exemple. cmp et key pour sort), vous devez être en mesure de dire heapq de tri basé sur une clé différente. En d'autres termes, vous ne devriez pas avoir à redéfinir l'objet lui-même pour modifier les données particulières de la structure de holding, vous devriez être en mesure de simplement dire la structure de données elle-même. C'est un notable fondamentaux de l'élément manquant de la heapq API.
InformationsquelleAutor eumiro
38

Selon l'exemple de la la documentation, vous pouvez utiliser les tuples, et il va trier par le premier élément du tuple:
```
>>> h = []
>>> heappush(h, (5, 'write code'))
>>> heappush(h, (7, 'release product'))
>>> heappush(h, (1, 'write spec'))
>>> heappush(h, (3, 'create tests'))
>>> heappop(h)
(1, 'write spec')
```
Donc, si vous ne voulez pas (ou ne peuvent pas?) faire un __cmp__ méthode, vous pouvez extraire manuellement votre clé de tri à pousser de temps.

Noter que si les premiers éléments d'une paire de n-uplets sont égaux, d'autres éléments seront comparés. Si ce n'est pas ce que vous voulez, vous devez vous assurer que chaque premier élément est unique.
- "Notez que si les premiers éléments d'une paire de n-uplets sont égaux, d'autres éléments seront comparés." Vous devez, en gras, puisque dans la documentation il n'est pas clair. J'ai pris le même niveau de priorité, il serait de retour moi le premier objet trouvé (pas de bonne raison pour justifier cette hypothèse, il est donc de ma faute, je le vois).
- Bon point. Si vous insérez un tuple qui est de (nombre, dict) il ne sait pas comment évaluer les dicts.
- Si vous avez un tuple comme (some_value, dict), vous pouvez insérer (some_value, counter, dict) dans le tas de rompre les liens avec une incrémentation du compteur en cas some_value est égale pour les 2 tuples.
InformationsquelleAutor Jander

Selon la Document Officiel, une solution consiste à stocker des entrées comme des n-uplets (veuillez consulter les Sections 8.4.1 et 8.4.2).

Par exemple, votre objet est quelque chose comme cela dans tuple's format
(clé, valeur_1, value_2)

Quand vous mettez les objets (c'est à dire tuples) dans tas, il va comparer le premier attribut de l'objet (dans ce cas, est clé) pour comparer. Si une égalité se produit, tas testaments utiliser l'attribut suivant (c'est à dire valeur_1) et ainsi de suite.

Par exemple:

import heapq

heap = []
heapq.heappush(heap, (0,'one', 1))
heapq.heappush(heap, (1,'two', 11))
heapq.heappush(heap, (1, 'two', 2))
heapq.heappush(heap, (1, 'one', 3))
heapq.heappush(heap, (1,'two', 3))
heapq.heappush(heap, (1,'one', 4))
heapq.heappush(heap, (1,'two', 5))
heapq.heappush(heap, (1,'one', 1))

show_tree(heap)

De sortie:

                                      (0, 'one', 1)                                       
                (1, 'one', 1)                                (1, 'one', 4)                
    (1, 'one', 3)         (1, 'two', 3)         (1, 'two', 2)         (1, 'two', 5)     
(1, 'two', 11)

Sur à peu l'impression d'un tas en python (mis à jour le lien): show_tree()

Le show_tree() lien ne fonctionne plus.
J'ai juste mis à jour le lien.

InformationsquelleAutor Catbuilts

3

Malheureusement, vous ne pouvez pas, même si c'est souvent une demande de fonctionnalité.

Une option consisterait à insérer (clé, valeur) de n-uplets dans le tas. Toutefois, cela ne fonctionnera pas si les valeurs de lever une exception au regard (ils seront comparés dans le cas d'une égalité entre les touches).

Une deuxième option serait de définir un __lt__ (moins) de la méthode dans la classe qui utilisent l'attribut approprié pour comparer les éléments pour le tri. Toutefois, cela pourrait ne pas être possible si les objets ont été créés par un autre paquet ou si vous avez besoin de comparer différemment ailleurs dans le programme.

Une troisième option serait d'utiliser la sortedlist classe à partir de la blist module (disclaimer: je suis l'auteur). Le constructeur de sortedlist prend un key paramètre vous permet de spécifier une fonction de retourner la clé de tri d'un élément, semblable à la key paramètre de list.sort et sorted.
- J'ai supprimé mon commentaire précédent depuis mon problème avec blist était probablement un PEBCAK (encore une fois merci pour votre module), donc je ne copie la première partie du commentaire précédent: Il est toujours possible de définir une classe avec un __lt__ soit par le biais de sous-classement ou par l'intermédiaire de l'encapsulation.
InformationsquelleAutor Daniel Stutzbach

Vous pourriez mettre en œuvre un heapdict. Notez l'utilisation de popitem() pour obtenir la priorité la plus basse de l'élément.

import heapdict as hd
import string
import numpy as np

h = hd.heapdict()
keys = [char for char in string.ascii_lowercase[:10]]
vals = [i for i in np.random.randint(0,10, 10)]
for k,v in zip(keys,vals):
    h[k] = v
for i in range(len(vals)):
    print h.popitem()

InformationsquelleAutor DanGoodrick

Vous devez vous connecter pour publier un commentaire.