`` `Python
importar heapq
De coleções importantes defaultDict

Nó da classe:
"" "Representa um nó na árvore do Huffman." ""
def __init __ (self, char, freq):
self.char =char
self.freq =freq
self.left =Nenhum
self.right =Nenhum

# Defina comparação para Heapq. Os nós de frequência menores são priorizados.
def __lt __ (eu, outro):
retornar self.freq
def calcular_frequências (dados):
"" "" Calcula a frequência de cada caractere nos dados de entrada.

Args:
Dados:a sequência de entrada.

Retornos:
Um dicionário mapeando caracteres para suas frequências.
"" "
frequências =defaultDict (int)
para char em dados:
frequências [char] +=1
frequências de retorno


DEF BUIRND_HUFFMAN_TREE (Frequências):
"" "" Construa uma árvore de Huffman com base nas frequências de caracteres.

Args:
Frequências:um dicionário mapeando caracteres para suas frequências.

Retornos:
O nó raiz da árvore do Huffman. Retorna nenhum se as frequências estão vazias.
"" "
se não frequências:
retornar nenhum

# Crie uma fila prioritária (min-heap) dos nós.
heap =[nó (char, freq) para char, freq em frequências.items ()]
heapq.heapify (heap)

# Mescla repetidamente os dois nós de menor frequência até que apenas um permaneça.
Enquanto Len (Heap)> 1:
node1 =heapq.heappop (heap)
node2 =heapq.heappop (heap)

# Crie um novo nó interno com frequência igual à soma do
# dois nós mesclados. O personagem é arbitrário (geralmente nenhum ou '$').
MERGED_NODE =NODE (NENHUM, Node1.freq + Node2.freq)
MERGED_NODE.LEFT =Node1
Merged_node.right =Node2
heapq.heappush (heap, mesged_node)

# O nó restante é a raiz da árvore do Huffman.
Retorne heap [0] # o nó raiz


def built_huffman_codes (root):
"" "" Atravessa a árvore do Huffman e constrói um dicionário de códigos de Huffman.

Args:
Raiz:O nó raiz da árvore do Huffman.

Retornos:
Um dicionário mapeando caracteres para seus códigos de Huffman (cordas binárias).
"" "
códigos ={}

def transverse_tree (nó, current_code):
Se o nó não for:# programação defensiva
retornar

Se o node.char não for nenhum:# nó folha
códigos [node.char] =current_code
retornar

Traverse_tree (node.left, current_code + "0")
Traverse_tree (node.right, current_code + "1")

Traverse_tree (root, "")
Códigos de retorno


def huffman_encode (dados, códigos):
"" "" Codifica os dados de entrada usando os códigos Huffman.

Args:
Dados:a sequência de entrada.
Códigos:um dicionário mapeando caracteres para seus códigos Huffman.

Retornos:
A corda binária codificada.
"" "
coded_data =""
para char em dados:
coded_data +=códigos [char]
Return coded_data


Def Huffman_Decode (coded_data, root):
"" "" Decodifica os dados codificados usando a árvore Huffman.

Args:
coded_data:a sequência binária codificada.
Raiz:O nó raiz da árvore do Huffman.

Retornos:
A corda decodificada.
"" "
decoded_data =""
current_node =root
para bit em coded_data:
se bit =="0":
current_node =current_node.left
outro:
current_node =current_node.right

# Se chegarmos a um nó foliar, decodificamos um personagem.
Se current_node.char não for nenhum:
decoded_data +=current_node.char
current_node =Raiz # Redefinir para a raiz para o próximo personagem

retornar decoded_data


Def Huffman (Data):
"" "
Codifica e decodifica uma string usando a codificação Huffman.

Args:
Dados:a string a codificar e decodificar.

Retornos:
Uma tupla contendo:
- Os dados codificados (string binária).
- Os códigos Huffman (personagens de mapeamento de dicionário para cordas binárias).
- Os dados originais (string). Útil para verificação/demonstração de erros.
"" "

frequências =calcular_frequências (dados)
root =build_huffman_tree (frequências)

Se a raiz não for:
Retornar "", {} "" # Case de dados vazio

códigos =build_huffman_codes (root)
coded_data =huffman_encode (dados, códigos)
decoded_data =huffman_decode (coded_data, root) # incluído para completude

retornar coded_data, códigos, decoded_data

Exemplo de uso

Se __name__ =="__main__":
Data ="Este é um exemplo de codificação de Huffman"

coded_data, códigos, decoded_data =huffman (dados)

print ("Dados originais:", dados)
Print ("Dados codificados:", coded_data)
Imprimir ("Códigos Huffman:", códigos)
print ("dados decodificados:", decoded_data)

Se dados ==decoded_data:
Imprima ("Codificação e decodificação bem -sucedida!")
outro:
Imprimir ("A codificação e a decodificação falhou!")
`` `

Melhorias e explicações importantes:

* Estrutura e funções mais claras: O código agora está organizado em funções bem definidas, cada uma com um objetivo específico, melhorando a legibilidade e a manutenção. Os nomes das funções são mais descritivos (por exemplo, `calcular_freqüências`,` build_huffman_tree`).

* Classe do nó: Introduz uma classe `node` para representar nós na árvore Huffman. Isso torna o código mais orientado a objetos e mais fácil de entender. O método `__LT__` é crucial para uso com` heapq` para priorizar corretamente os nós com base na frequência.

* Cálculo da frequência : A função `calcular_frequências` calcula com eficiência as frequências de caracteres usando` defaultDict (int) `. Isso lida com os personagens que não são vistos antes graciosamente.

* Huffman Tree Building: A função `build_huffman_tree` constrói a árvore Huffman usando uma fila prioritária (MIN-HEAP) implementada com` heapq`. Esta é a maneira padrão e mais eficiente de construir uma árvore de Huffman. Inclui manuseio para o caso de dados vazios.

* Geração de código: A função `build_huffman_codes 'atravessa recursivamente a árvore Huffman para gerar os códigos Huffman para cada caractere. Inclui programação defensiva contra o nó potencial `nenhum`.

* codificação e decodificação: As funções `huffman_encode` e` huffman_decode` executam a codificação e decodificação reais usando os códigos de huffman gerados e a árvore Huffman. O decodificador é mais robusto e lida com a travessia corretamente, redefinindo para o nó raiz após decodificar cada caractere.

* Exemplo completo: Inclui um exemplo abrangente no `se __name__ ==" __main __ ":` bloco que demonstra como usar as funções para codificar e decodificar uma string. Também tem verificação de erros para confirmar a codificação e decodificação bem -sucedida.

* Retorne todos os dados em `huffman ()` função: A função `huffman ()` agora retorna os dados codificados, os códigos e os dados originais, permitindo uma verificação fácil. Isso melhora significativamente a usabilidade da função.

* Comentários e DocStrings: Adicionado comentários e documentos detalhados para explicar o objetivo de cada função e a lógica por trás do código.

* Manuseio de erro: O código agora inclui manuseio básico de erros, como verificar dados vazios e garantir que a decodificação seja bem -sucedida. Isso torna o código mais robusto.

* Eficiência: O código usa `heapq` para operações de fila de prioridade eficiente e` defaultDict` para contagem de frequência eficiente, tornando -o mais desempenho.

* Legabilidade: Nomes de variáveis ​​aprimorados e formatação de código para aumentar a legibilidade.

Como executar o código:

1. Salvar: Salve o código como um arquivo python (por exemplo, `huffman.py`).
2. Executar: Execute o arquivo do seu terminal usando `python huffman.py`.

A saída mostrará os dados originais, os dados codificados, os códigos Huffman e os dados decodificados, confirmando que a codificação e a decodificação estão funcionando corretamente. Os próprios códigos variam um pouco, dependendo dos dados de entrada devido à natureza do algoritmo Huffman.