Comparador personalizado de Python Heapq
Aprenderá cómo aplicar HeapQ en los módulos de Python en esta guía. ¿Qué tipo de problemas se pueden usar un montón para resolver?? Cómo superar esos problemas con el módulo HeapQ de Python.
¿Qué es un módulo python??
Una estructura de datos del montón representa una cola de prioridad. El paquete "HeapQ" en Python lo pone a disposición. La peculiaridad de esto en Python es que siempre aparece la menor cantidad de piezas de montón (montón min). El elemento Heap [0] siempre da el elemento más pequeño.
Varias rutinas HeapQ toman una lista como entrada y la organizan en un orden mínimo. Un defecto con estas rutinas es que requieren una lista o incluso una colección de tuplas como parámetro. No le permiten comparar ningún otro iterable u objetos.
Echemos un vistazo a algunas de las operaciones básicas que admite el módulo Python Heapq. Para adquirir una mejor comprensión de cómo funciona el módulo Python HeapQ, revise las siguientes secciones para ver ejemplos implementados.
Ejemplo 1:
El módulo HeapQ en Python le permite realizar operaciones de almacenamiento en listas. A diferencia de algunos de los módulos adicionales, no especifica ninguna clase personalizada. El módulo Python HeapQ incluye rutinas que funcionan directamente con las listas.
Por lo general, los elementos se agregan uno por uno en un montón, comenzando con un montón vacío. Si ya hay una lista de elementos que deben convertirse en un montón, la función HeApify () en el módulo Python HeapQ se puede usar para convertir la lista en un montón válido.
Veamos el siguiente código paso a paso. El módulo HeAPQ se importa en la primera línea. Después de eso, le hemos dado a la lista el nombre 'uno.'Se ha llamado al método de Heapify, y la lista se ha proporcionado como parámetro. Finalmente, se muestra el resultado.
Importar montónuno = [7, 3, 8, 1, 3, 0, 2]
montón.Heapify (uno)
Imprimir (uno)
La salida del código mencionado se muestra a continuación.
Puede ver que, a pesar del hecho de que 7 ocurre después de las 8, la lista sigue siguiendo la propiedad del montón. Por ejemplo, el valor de a [2], que es 3, es menor que el valor de a [2*2 + 2], que es 7.
Heapify (), como puede ver, actualiza la lista en su lugar pero no la clasifica. No es necesario que se organice un montón para cumplir con la propiedad del montón. Cuando Heapify () se usa en una lista ordenada, el orden de los elementos en la lista se conserva porque cada lista clasificada se ajusta a la propiedad Heap.
Ejemplo 2:
Se puede aprobar una lista de elementos o una lista de tuplas como parámetro para las funciones del módulo HeapQ. Como resultado, hay dos opciones para alterar la técnica de clasificación. A modo de comparación, el primer paso es transformar el ITerable en una lista de tuplas/listas. Hacer una clase de envoltorio que extienda el "operador. En este ejemplo, veremos el primer enfoque mencionado. Este método es fácil de usar y puede aplicarse para comparar diccionarios.
Hacer un esfuerzo para comprender el siguiente código. Como puede ver, hemos importado el módulo HeAPQ y generamos un diccionario llamado dict_one. Después de eso, la lista se define para la conversión de tupla. La función HQ.Heapify (mi lista) organiza las listas en un mínimo de tiempo e imprime el resultado.
Finalmente, convertimos la lista en un diccionario y mostramos los resultados.
Importar montón como HQdict_one = 'z': 'zinc', 'b': 'bill', 'w': 'wicket', 'a': 'anna', 'c': 'caouch'
list_one = [(a, b) para a, b en dict_one.elementos()]
Imprimir ("Antes de organizar:", list_one)
albar.Heapify (list_one)
Imprimir ("Después de organizar:", list_one)
dict_one = dict (list_one)
Imprimir ("Diccionario final:", dict_one)
La salida se adjunta a continuación. El Diccionario Reconvertido final se muestra junto a la lista de antes y después de.
Ejemplo 3:
Vamos a incorporar una clase de envoltorio en este ejemplo. Considere un escenario en el que los objetos de una clase deben mantener. Considere una clase que tenga atributos como 'nombre ", grado" Dob' (fecha de nacimiento) y "Tarifa.'Los objetos de esta clase deben mantenerse en un mínimo de montón dependiendo de su' Dob '(fecha de nacimiento).
Ahora anulamos el operador relacional ”para comparar la tarifa de cada estudiante y devolver verdadero o falso.
A continuación se muestra el código que puede pasar paso a paso. Hemos importado el módulo HeAPQ y definimos la clase 'estudiante', en la que hemos escrito el constructor y la función para la impresión personalizada. Como puede ver, hemos anulado el operador de comparación.
Ahora hemos creado objetos para la clase y especificamos las listas del estudiante. Basado en el DOB, el Código HQ.Heapify (EMP) se convertirá en Min-Heap. El resultado se muestra en la pieza de código final.
Importar montón como HQEstudiante de clase:
def __init __ (self, a, b, yos, c):
ser.nombre = A
ser.Grado = B
ser.DOB = YOS
ser.tarifa = c
Def print_me (self):
Imprimir ("Nombre:", Self.nombre)
Imprimir ("Grado:", Self.grado)
Imprimir ("Fecha de nacimiento:", str (yo.Dob))
Imprimir ("Salario:", Str (Self.tarifa))
def __lt __ (self, nxt):
volver a ser.DoB < nxt.DOB
STD1 = Estudiante ('Alex', 'Law', 1990, 36000)
std2 = estudiante ('Mathew', 'PhD', 1998, 35000)
STD3 = Estudiante ('Tina', 'Informática', 1980, 70000)
std4 = estudiante ('Jack', 'It', 1978, 90000)
STD = [STD1, STD2, STD3, STD4]
albar.Heapify (STD)
Para I en el rango (0, Len (STD)):
std [i].imprimir()
imprimir()
Aquí está la salida completa del código de referencia mencionado anteriormente.
Conclusión:
Ahora tiene una mejor comprensión de las estructuras de datos de colas de montón y prioridad y cómo podrían ayudarlo a resolver diferentes tipos de problemas. Estudió cómo generar montones de las listas de Python utilizando el módulo Python Heapq. También estudió cómo utilizar las diversas operaciones del módulo Python Heapq. Para comprender mejor el tema, lea el artículo a fondo y aplique los ejemplos proporcionados.