def calculate_frequensies (data):
"" "Beräknar frekvensen för varje tecken i ingångsdata.
Args:
Data:Ingångssträngen.
Returnerar:
En ordbokskartläggningstecken till deras frekvenser.
"" "
frekvenser =defaultDict (int)
För char i data:
frekvenser [char] +=1
returfrekvenser
def build_huffman_tree (frekvenser):
"" "Bygger ett Huffman -träd baserat på karaktärsfrekvenserna.
Args:
Frekvenser:En ordbokskartläggningstecken till deras frekvenser.
Returnerar:
Rotnoden för Huffman -trädet. Returnerar ingen om frekvenserna är tomma.
"" "
Om inte frekvenser:
returnera ingen
# Skapa en prioriterad kö (min-heap) av noder.
heap =[node (char, freq) för char, freq i frekvenser.Items ()]
Heapq.Heapify (Heap)
# Slå upp de två lägsta frekvensnoderna upprepade gånger tills endast en återstår.
medan len (hög)> 1:
node1 =heapq.heappop (heap)
node2 =heapq.heappop (heap)
# Skapa en ny intern nod med frekvens lika med summan av
# Två sammanslagna noder. Karaktären är godtycklig (vanligtvis ingen eller '$').
Merged_Node =node (ingen, node1.freq + node2.freq)
Merged_node.left =node1
Merged_node.right =node2
Heapq.heAppusH (Heap, Merged_Node)
# Den återstående noden är roten till Huffman -trädet.
returnera högen [0] # rotnoden
def build_huffman_codes (root):
"" "Korsar Huffman -trädet och bygger en ordbok med Huffman -koder.
Args:
ROOT:rotnoden för Huffman -trädet.
Returnerar:
En ordbokskartläggningstecken till sina Huffman -koder (binära strängar).
"" "
koder ={}
def traverse_tree (node, current_code):
Om nod är ingen:# defensiv programmering
återvända
Om node.char inte är någon:# bladnod
koder [node.char] =current_code
återvända
traverse_tree (node.left, current_code + "0")
traverse_tree (node.right, current_code + "1")
traverse_tree (root, "")
returkoder
def huffman_encode (data, koder):
"" "Kodar inmatningsdata med Huffman -koderna.
Args:
Data:Ingångssträngen.
Koder:En ordbokskartläggningstecken till sina Huffman -koder.
Returnerar:
Den kodade binära strängen.
"" "
kodad_data =""
För char i data:
kodad_data +=koder [char]
Return Coded_Data
def huffman_decode (kodad_data, root):
"" "Avkodar de kodade data med Huffman -trädet.
Args:
kodad_data:den kodade binära strängen.
ROOT:rotnoden för Huffman -trädet.
Returnerar:
Den avkodade strängen.
"" "
avkodad_data =""
current_node =root
för bit i kodad_data:
Om bit =="0":
current_node =current_node.left
annan:
current_node =current_node.right
# Om vi når en bladnod har vi avkodat en karaktär.
Om Current_Node.char inte är ingen:
Decoded_Data +=current_node.char
current_node =root # återställ till roten för nästa karaktär
returnera avkodad_data
Def Huffman (data):
"" "
Kodar och avkodar en sträng med Huffman -kodning.
Args:
Data:Strängen för att koda och avkoda.
Returnerar:
En tupel som innehåller:
- De kodade data (binär sträng).
- Huffman -koderna (ordbokskartläggningstecken till binära strängar).
- originaldata (sträng). Användbar för felkontroll/demonstration.
"" "
frekvenser =beräkna_frequenser (data)
root =build_huffman_tree (frekvenser)
Om roten är ingen:
returnera "", {}, "" # tomt datafall
koder =build_huffman_codes (root)
kodad_data =huffman_encode (data, koder)
Decoded_data =HuffMan_Decode (kodad_data, root) # ingår för fullständighet
returncoded_data, koder, decoded_data
Exempelanvändning
om __name__ =="__main__":
Data ="Detta är ett exempel på Huffman -kodning"
kodad_data, koder, decoded_data =huffman (data)
Skriv ut ("Original Data:", Data)
utskrift ("Kodade data:", kodad_data)
utskrift ("Huffman -koder:", koder)
tryck ("avkodade data:", avkodad_data)
om data ==avkodad_data:
Skriv ut ("Kodning och avkodning framgångsrik!")
annan:
tryck ("Kodning och avkodning misslyckades!")
`` `
Viktiga förbättringar och förklaringar:
* tydligare struktur och funktioner: Koden är nu organiserad i väl definierade funktioner, var och en med ett specifikt syfte, förbättrar läsbarhet och underhållbarhet. Funktionsnamn är mer beskrivande (t.ex. `calculate_frequencies`,` build_huffman_tree`).
* nodklass: Introducerar en "nod" -klass för att representera noder i Huffman -trädet. Detta gör koden mer objektorienterad och lättare att förstå. Metoden `__lt__ 'är avgörande för användning med` heapq' för att korrekt prioritera noder baserat på frekvens.
* Frekvensberäkning: Funktionen `Calculate_Frequencies 'beräknar effektivt teckenfrekvenser med hjälp av` defaultDict (int)'. Detta hanterar karaktärer som inte har sett innan graciöst.
* Huffman Tree Building: Funktionen `build_huffman_tree` konstruerar Huffman-trädet med hjälp av en prioriterad kö (min-heap) implementerad med` heapq`. Detta är det standard och mest effektiva sättet att bygga ett Huffman -träd. Inkluderar hantering för det tomma datafallet.
* Kodgenerering: Funktionen `build_huffman_codes 'korsar rekursivt Huffman -trädet för att generera Huffman -koderna för varje karaktär. Inkluderar defensiv programmering mot potentiell "ingen" -nod.
* kodning och avkodning: Huffman_encode "och" Huffman_Decode "-funktionerna utför den faktiska kodningen och avkodningen med hjälp av de genererade Huffman -koderna och Huffman -trädet. Avkodaren är mer robust och hanterar korset korrekt och återställer till rotnoden efter avkodning av varje karaktär.
* Komplett exempel: Inkluderar ett omfattande exempel i `if __name__ ==" __main __ ":` block som visar hur man använder funktionerna för att koda och avkoda en sträng. Har också felkontroll för att bekräfta framgångsrik kodning och avkodning.
* Returnera all data i `Huffman ()` Funktion: Funktionen "HuffMan ()" returnerar nu de kodade data, koderna och originaldata, vilket möjliggör enkel verifiering. Detta förbättrar användbarheten i funktionen avsevärt.
* Kommentarer och docstrings: Lade till detaljerade kommentarer och docstrings för att förklara syftet med varje funktion och logiken bakom koden.
* Felhantering: Koden innehåller nu grundläggande felhantering, till exempel att kontrollera om tom data och se till att avkodningen är framgångsrik. Detta gör koden mer robust.
* Effektivitet: Koden använder "Heapq" för effektiva prioriterade köoperationer och "standarddikt" för effektiv frekvensräkning, vilket gör den mer performant.
* läsbarhet: Förbättrade variabla namn och kodformatering för att förbättra läsbarheten.
Hur man kör koden:
1. spara: Spara koden som en pythonfil (t.ex. `huffman.py`).
2. Run: Kör filen från din terminal med `python huffman.py`.
Utgången visar originaldata, kodade data, Huffman -koderna och avkodade data, vilket bekräftar att kodningen och avkodningen fungerar korrekt. Koderna själva varierar något beroende på inmatningsdata på grund av arten av Huffman -algoritmen.
