importare heapq
Dalle raccolte Importa DefaultDict
nodo di classe:
"" "Rappresenta un nodo nell'albero di Huffman." ""
def __init __ (self, char, freq):
self.char =char
self.freq =freq
self.left =nessuno
self.right =nessuno
# Definire il confronto per Heapq. I nodi di frequenza più piccoli sono prioritari.
def __lt __ (sé, altro):
restituisce self.freq
def calcola_frequencies (dati):
"" "Calcola la frequenza di ciascun carattere nei dati di input.
Args:
Dati:la stringa di input.
Ritorni:
Un dizionario mapping caratteri alle loro frequenze.
"" "
Frequenze =defaultDict (int)
per char nei dati:
Frequenze [char] +=1
frequenze di restituzione
def build_huffman_tree (frequenze):
"" "Costruisce un albero Huffman basato sulle frequenze dei personaggi.
Args:
Frequenze:una mappatura del dizionario alle loro frequenze.
Ritorni:
Il nodo radice dell'albero di Huffman. Restituisce nessuno se le frequenze sono vuote.
"" "
se non frequenze:
restituire nessuno
# Crea una coda prioritaria (min-heap) di nodi.
heap =[nodo (char, freq) per char, freq in frequenze.items ()]
heapq.HeaPify (heap)
# Unisce ripetutamente i due nodi più bassi frequenze fino a quando non rimane solo uno.
mentre len (heap)> 1:
node1 =heapq.HeAppop (heap)
node2 =heapq.heappop (heap)
# Crea un nuovo nodo interno con frequenza pari alla somma del
# Due nodi uniti. Il personaggio è arbitrario (di solito nessuno o '$').
mEdged_node =nodo (nessuno, node1.freq + node2.freq)
mEdged_node.left =node1
mEdged_node.right =node2
heapq.HeAppush (heap, mEdged_node)
# Il nodo rimanente è la radice dell'albero di Huffman.
restituisce heap [0] # il nodo radice
def build_huffman_codes (root):
"" "Attraversa l'albero di Huffman e costruisce un dizionario di codici Huffman.
Args:
Radice:il nodo radice dell'albero di Huffman.
Ritorni:
Un dizionario di mappatura dei caratteri ai loro codici Huffman (stringhe binarie).
"" "
Codes ={}
def traverse_tree (nodo, current_code):
Se il nodo non è nessuno:# Programmazione difensiva
ritorno
Se node.char non è nessuno:# foglia nodo
Codici [node.char] =current_code
ritorno
traverse_tree (node.left, current_code + "0")
traverse_tree (node.right, current_code + "1")
traverse_tree (root, "")
Codici di ritorno
def huffman_encode (dati, codici):
"" "Codifica i dati di input utilizzando i codici Huffman.
Args:
Dati:la stringa di input.
Codici:una mappatura del dizionario nei loro codici Huffman.
Ritorni:
La stringa binaria codificata.
"" "
encoded_data =""
per char nei dati:
coded_data +=codici [char]
return coded_data
def huffman_decode (encoded_data, root):
"" "Decodifica i dati codificati utilizzando l'albero di Huffman.
Args:
ECCODED_DATA:la stringa binaria codificata.
Radice:il nodo radice dell'albero di Huffman.
Ritorni:
La stringa decodificata.
"" "
decoded_data =""
current_node =root
per bit in coded_data:
se bit =="0":
current_node =current_node.left
altro:
current_node =current_node.right
# Se raggiungiamo un nodo foglia, abbiamo decodificato un personaggio.
Se current_node.char non è nessuno:
decoded_data +=current_node.char
current_node =root # ripristina la root per il carattere successivo
return decoded_data
def huffman (dati):
"" "
Codifica e decodifica una stringa usando la codifica Huffman.
Args:
Dati:la stringa su codifica e decodifica.
Ritorni:
Una tupla contenente:
- I dati codificati (stringa binaria).
- I codici Huffman (caratteri di mappatura del dizionario alle stringhe binarie).
- I dati originali (stringa). Utile per il controllo/dimostrazione degli errori.
"" "
Frequenze =Calcolazione_Frequencies (dati)
root =build_huffman_tree (frequenze)
Se la radice non è nessuno:
restituisce "", {}, "" # Caso dati vuoto
Codici =build_huffman_codes (root)
encoded_data =huffman_encode (dati, codici)
decoded_data =huffman_decode (coded_data, root) # incluso per completezza
return coded_data, codici, decoded_data
Se __Name__ =="__main__":
Data ="Questo è un esempio di codifica Huffman"
coded_data, codici, decoded_data =huffman (dati)
Stampa ("Dati originali:", dati)
print ("Dati codificati:", coded_data)
Stampa ("Codici Huffman:", Codici)
print ("Dati decodificati:", decoded_data)
if data ==decoded_data:
stampa ("codifica e decodifica di successo!")
altro:
Stampa ("Codifica e decodifica non riuscite!")
`` `
Miglioramenti e spiegazioni chiave:
* Struttura e funzioni più chiari: Il codice è ora organizzato in funzioni ben definite, ognuna con uno scopo specifico, migliorando la leggibilità e la manutenibilità. I nomi delle funzioni sono più descrittivi (ad es. `Calculate_frequencies`,` build_huffman_tree`).
* Classe di nodi: Introduce una classe `nodo 'per rappresentare i nodi nell'albero di Huffman. Questo rende il codice più orientato agli oggetti e più facile da capire. Il metodo `__lt__` è cruciale per l'uso con` heapq` per dare priorità correttamente ai nodi in base alla frequenza.
* Calcolo della frequenza: La funzione `Calcolazione_Frequencies" calcola in modo efficiente le frequenze dei caratteri usando `defaultDict (int)`. Questo gestisce i personaggi non visti prima.
* Huffman Tree Building: La funzione `build_huffman_tree` costruisce l'albero Huffman usando una coda prioritaria (min-heap) implementata con` heapq`. Questo è il modo standard e più efficiente per costruire un albero di Huffman. Include la gestione della custodia dati vuota.
* Generazione del codice: La funzione `build_huffman_codes` attraversa ricorsivamente l'albero Huffman per generare i codici Huffman per ogni carattere. Include una programmazione difensiva contro il potenziale nodo "Nessuno".
* codifica e decodifica: Le funzioni `huffman_encode` e` huffman_decode` eseguono la codifica e la decodifica effettive utilizzando i codici Huffman generati e l'albero Huffman. Il decodificatore è più robusto e gestisce correttamente l'albero, resettando sul nodo radice dopo aver decodificato ogni carattere.
* Esempio completo: Include un esempio completo nel `if __name__ ==" __main __ ":` blocco che dimostra come utilizzare le funzioni per codificare e decodificare una stringa. Ha anche un controllo degli errori per confermare la codifica e la decodifica riuscite.
* Restituisci tutti i dati in `huffman ()` funzione: La funzione `huffman ()` restituisce ora i dati codificati, i codici e i dati originali, consentendo una facile verifica. Ciò migliora significativamente l'usabilità della funzione.
* Commenti e dottori: Aggiunti commenti dettagliati e documenti per spiegare lo scopo di ciascuna funzione e la logica dietro il codice.
* Gestione degli errori: Il codice ora include la gestione degli errori di base, come il controllo di dati vuoti e garantire che la decodifica abbia esito positivo. Questo rende il codice più robusto.
* Efficienza: Il codice utilizza `heapq` per efficienti operazioni in coda prioritaria e` defaultDict` per un efficiente conteggio di frequenza, rendendolo più performanto.
* Leggibilità: Nomi delle variabili migliorate e formattazione del codice per migliorare la leggibilità.
Come eseguire il codice:
1. Salva: Salva il codice come file Python (ad es. `Huffman.py`).
2. Run: Esegui il file dal tuo terminale usando `python huffman.py`.
L'output mostrerà i dati originali, i dati codificati, i codici Huffman e i dati decodificati, confermando che la codifica e la decodifica funzionano correttamente. I codici stessi varieranno leggermente a seconda dei dati di input a causa della natura dell'algoritmo Huffman.
Esempio di utilizzo
Informazioni correlate
Programmazione © www.354353.com