Python Heapq Comparator personnalisé

Les algorithmes et les concepts de structure de données sont notoirement difficiles. Il faut du temps et des efforts pour trouver la meilleure clarification prometteuse à un problème. En conséquence, si vous êtes coincé avec la mise en œuvre, vous ne pourrez peut-être pas terminer la tâche! En conséquence, savoir comment utiliser chacune des principales structures de données et être conscient des limitations spécifiques au Python rendra la mise en œuvre en douceur. Deux structures de données peu connues qui sont assez efficaces sont les tas et les files d'attente prioritaires.

Vous apprendrez comment appliquer le tas dans les modules Python dans ce guide. Quels types de problèmes peuvent être utilisés pour résoudre? Comment surmonter ces problèmes avec le module Heapq de Python.

Qu'est-ce qu'un module Python Heapq?

Une structure de données de tas représente une file d'attente prioritaire. Le package «Heapq» en Python le rend disponible. La particularité de cela dans Python est qu'elle éclate toujours le moindre des pièces de tas (min tas). L'élément tas [0] donne toujours le plus petit élément.

Plusieurs routines Heapq prennent une liste comme une entrée et l'organisent dans un ordre min-heap. Un défaut avec ces routines est qu'ils nécessitent une liste ou même une collection de tuples comme paramètre. Ils ne vous permettent pas de comparer d'autres itérables ou objets.

Jetons un coup d'œil à certaines des opérations de base que le module Python Heapq prend en charge. Pour acquérir une meilleure compréhension du fonctionnement du module Python Heapq, examinez les sections suivantes pour les exemples implémentés.

Exemple 1:

Le module Heapq en Python vous permet d'effectuer des opérations de tas sur les listes. Contrairement à certains des modules supplémentaires, il ne spécifie aucune classe personnalisée. Le module Python Heapq comprend des routines qui fonctionnent directement avec des listes.

En règle générale, les éléments sont ajoutés un par un dans un tas, en commençant par un tas vide. S'il y a déjà une liste d'éléments qui doivent être convertis en tas, la fonction Heapify () dans le module Python Heapq peut être utilisée pour convertir la liste en un tas valide.

Voyons le code suivant étape par étape. Le module Heapq est importé dans la première ligne. Suivant cela, nous avons donné à la liste le nom 'un.'La méthode de tas a été appelée et la liste a été fournie comme paramètre. Enfin, le résultat est montré.

Importer un tas
un = [7, 3, 8, 1, 3, 0, 2]
tas.tasify (un)
Imprimer (un)

La sortie du code susmentionné est illustrée ci-dessous.

Vous pouvez voir que, malgré le fait que 7 se produit après 8 ans, la liste suit toujours la propriété du tas. Par exemple, la valeur d'un [2], qui est de 3, est inférieure à la valeur d'un [2 * 2 + 2], qui est 7.

Heapify (), comme vous pouvez le voir, met à jour la liste en place mais ne le trie pas. Un tas n'a pas à être organisé pour réaliser la propriété du tas. Lorsque Heapify () est utilisé sur une liste triée, l'ordre des éléments de la liste est conservé car chaque liste triée s'adapte à la propriété du tas.

Exemple 2:

Une liste d'éléments ou une liste de tuples peut être transmise sous forme de paramètre pour les fonctions du module HEAPQ. En conséquence, il existe deux options pour modifier la technique de tri. À titre de comparaison, la première étape consiste à transformer l'itérable en une liste de tuples / listes. Faites une classe Wrapper qui étend l'opérateur. Dans cet exemple, nous examinerons la première approche mentionnée. Cette méthode est simple à utiliser et peut être appliquée à la comparaison des dictionnaires.

Faire un effort pour comprendre le code suivant. Comme vous pouvez le voir, nous avons importé le module Heapq et généré un dictionnaire appelé dict_one. Suivant cela, la liste est définie pour la conversion des tuple. Le QG de la fonction.Heapify (ma liste) organise les listes en un mine-heap et imprime le résultat.

Enfin, nous convertissons la liste en dictionnaire et affichons les résultats.

Importer du tas en tant que QG
dict_one = 'z': 'zinc', 'b': 'bill', 'w': 'wicket', 'a': 'anna', 'c': 'caouch'
list_one = [(a, b) pour a, b dans dict_one.articles()]
Print ("Avant d'organiser:", list_one)
siège social.taspify (list_one)
Print ("après l'organisation:", list_one)
dict_one = dict (list_one)
print ("Dictionnaire final:", dict_one)

La sortie est attachée ci-dessous. Le dictionnaire reconverti final s'affiche à côté de la liste avant et après arrangement.

Exemple 3:

Nous allons incorporer une classe d'emballage dans cet exemple. Considérez un scénario dans lequel les objets d'une classe doivent être conservés dans un mine-hap. Considérez une classe qui a des attributs tels que «nom», «Dob» (date de naissance) et «FEUX.`` Les objets de cette classe doivent être conservés dans un mine-hap en fonction de leur «dob» (date de naissance).

Nous remplacez maintenant l'opérateur relationnel »afin de comparer les frais de chaque étudiant et de retourner vrai ou faux.

Vous trouverez ci-dessous le code que vous pouvez passer par étape par étape. Nous avons importé le module Heapq et défini la classe «Student», dans laquelle nous avons écrit le constructeur et la fonction d'impression personnalisée. Comme vous pouvez le voir, nous avons remplacé l'opérateur de comparaison.

Nous avons maintenant créé des objets pour la classe et spécifié les listes de l'élève. Basé sur le DOB, le Code HQ.taspify (EMP) se convertira en mine-heap. Le résultat s'affiche dans le dernier morceau de code.

Importer du tas en tant que QG
Élève de classe:
def __init __ (self, a, b, yos, c):
soi.nom = a
soi.degré = b
soi.Dob = yos
soi.Frais = C
def print_me (self):
Print ("Nom:", Self.nom)
imprimer ("degré:", soi.degré)
Imprimer ("Date de naissance:", Str (Self.Dob)))
imprimer ("Salaire:", Str (Self.frais))
def __lt __ (self, nxt):
se retourner.Nœud < nxt.DOB
STD1 = Student ('Alex', 'Law', 1990, 36000)
STD2 = Student ('Mathew', 'PhD', 1998, 35000)
STD3 = Student ('Tina', 'Computer Science', 1980, 70000)
STD4 = Student ('Jack', 'It', 1978, 90000)
std = [std1, std2, std3, std4]
siège social.tasify (std)
pour i dans la gamme (0, Len (std)):
std [i].Imprime moi()
imprimer()

Voici la sortie complète du code de référence mentionné ci-dessus.

Conclusion:

Vous avez maintenant une meilleure compréhension du tas et des structures de données de file d'attente prioritaires et comment elles pourraient vous aider à résoudre différents types de problèmes. Vous avez étudié comment générer des tas à partir de listes Python à l'aide du module Python Heapq. Vous avez également étudié comment utiliser les différentes opérations du module Python Heapq. Pour mieux comprendre le sujet, lisez soigneusement l'article et appliquez les exemples fournis.