python编程实现Huffman编码

好的，下面是Python实现Huffman编码的示例代码：

# 定义节点类
class Node:
    def __init__(self, freq, symbol=None, left=None, right=None):
        self.freq = freq
        self.symbol = symbol
        self.left = left
        self.right = right
        
    def __lt__(self, other):
        return self.freq < other.freq
    
    def __eq__(self, other):
        if(other == None):
            return False
        if(not isinstance(other, Node)):
            return False
        return self.freq == other.freq

# 计算字符频率
def get_char_freq(data):
    freq = {}
    for char in data:
        if char in freq:
            freq[char] += 1
        else:
            freq[char] = 1
    return freq

# 构建Huffman树
def build_huffman_tree(freq):
    nodes = []
    for key in freq:
        nodes.append(Node(freq[key], key))
    heapq.heapify(nodes)
    while len(nodes) > 1:
        left = heapq.heappop(nodes)
        right = heapq.heappop(nodes)
        parent = Node(left.freq+right.freq, left.symbol+right.symbol, left, right)
        heapq.heappush(nodes, parent)
    return nodes[0]

# 递归遍历Huffman树，生成编码表
def traverse_tree(node, current_code, code_dict):
    if node == None:
        return
    if node.symbol != None:
        code_dict[node.symbol] = current_code
    traverse_tree(node.left, current_code + "0", code_dict)
    traverse_tree(node.right, current_code + "1", code_dict)

# 将文本编码为Huffman编码
def encode_text(data, code_dict):
    encoded_text = ""
    for char in data:
        encoded_text += code_dict[char]
    return encoded_text

# 将Huffman编码解码为原文本
def decode_text(encoded_text, node):
    decoded_text = ""
    current_node = node
    for bit in encoded_text:
        if bit == "0":
            current_node = current_node.left
        else:
            current_node = current_node.right
        if current_node.symbol != None:
            decoded_text += current_node.symbol
            current_node = node
    return decoded_text

# 测试
data = "hello world"
freq = get_char_freq(data)
huffman_tree = build_huffman_tree(freq)
code_dict = {}
traverse_tree(huffman_tree, "", code_dict)
encoded_text = encode_text(data, code_dict)
decoded_text = decode_text(encoded_text, huffman_tree)
print("Original text: ", data)
print("Encoded text: ", encoded_text)
print("Decoded text: ", decoded_text)

这个代码可以计算给定文本的字符频率，构建Huffman树，生成编码表，对文本进行编码和解码。