关于#python#的问题：词典编码程序没有提示错误，但是解码的结果出不来

Question

程序没有提示错误，甚至统计字符次数，编码表，编码结果，都能出来就是解码的结果出不来

这个是统计字符次数，编码表，编码结果的情况

这个是全部的代码情况，可以看看是哪里出错了吗，是有关于词典编码的程序，需要可自取

import tkinter as tk
import collections
import pickle
from tkinter import filedialog
from tkinter import messagebox

# 统计文章中每个字符出现的次数
def count_characters(text):
    char_count = collections.Counter(text)
    return char_count

def count_character(article):
    char_count = {}
    for char in article:
        if char in char_count:
            char_count[char] += 1
        else:
            char_count[char] = 1
    return char_count
# 构造编码表，其中编号从0开始，按字符出现次数从大到小排列
def build_encoding_table(char_count):
    encoding_table = {}
    code = 0
    for char, count in sorted(char_count.items(), key=lambda x: x[1], reverse=True):
        encoding_table[char] = code
        code += 1
    return encoding_table

# 对文章进行词典编码
def encode_article(article, encoding_table):
    encoded_data = []
    buffer = ''
    for char in article:
        if buffer + char in encoding_table:
            buffer += char
        else:
            encoded_data.append(encoding_table[buffer])
            encoding_table[buffer + char] = len(encoding_table)
            buffer = char
    encoded_data.append(encoding_table[buffer])
    return encoded_data

# 对编码结果进行解码
def decode_article(encoded_data, decoding_table):
    decoded_article = ''
    buffer = ''
    for code in encoded_data:
        if code in decoding_table:
            decoded_article += decoding_table[code]
            if buffer:
                decoding_table[len(decoding_table)] = buffer + decoding_table[code][0]
                buffer = ''
        else:
            if code - 1 in decoding_table:
                buffer = decoding_table[code - 1]
                decoded_article += buffer
                decoding_table[len(decoding_table)] = buffer + buffer[0]
                buffer = ''
            else:
                buffer = ''
    return decoded_article

class LZWEncoder:
    def __init__(self):
        self.window = tk.Tk()
        self.window.title('LZW编码器')
        self.window.geometry('400x250')
        btn_login = tk.Button(self.window, text='LZW编码器')

        tk.Label(self.window, text='输入文件路径：').grid(row=0, column=0, sticky='w')
        self.filepath_entry = tk.Entry(self.window, width=40)
        self.filepath_entry.grid(row=0, column=1, sticky='w')

        self.char_count_path = tk.StringVar(value='char_count.txt')
        tk.Label(self.window, text='字符出现的次数：').grid(row=1, column=0, sticky='w')
        tk.Entry(self.window, textvariable=self.char_count_path, width=40).grid(row=1, column=1, sticky='w')

        self.encoding_table_path = tk.StringVar(value='encoding_table.txt')
        tk.Label(self.window, text='编码表保存路径：').grid(row=2, column=0, sticky='w')
        tk.Entry(self.window, textvariable=self.encoding_table_path, width=40).grid(row=2, column=1, sticky='w')

        self.encoded_data_path = tk.StringVar(value='encoded_data.txt')
        tk.Label(self.window, text='编码结果保存路径：').grid(row=3, column=0, sticky='w')
        tk.Entry(self.window, textvariable=self.encoded_data_path, width=40).grid(row=3, column=1, sticky='w')

        self.decoded_article_path = tk.StringVar(value='decoded_article.txt')
        tk.Label(self.window, text='解码结果保存路径：').grid(row=4, column=0, sticky='w')
        tk.Entry(self.window, textvariable=self.decoded_article_path, width=40).grid(row=4, column=1, sticky='w')

        tk.Button(self.window, text='选择文件', command=self.select_file).grid(row=5, column=0, pady=10)
        tk.Button(self.window, text='编码', command=self.encode).grid(row=5, column=1, pady=10)
        tk.Button(self.window, text='解码', command=self.decode).grid(row=6, column=0, pady=10)

        self.window.mainloop()

    def select_file(self):
        filepath = filedialog.askopenfilename(filetypes=[('Text Files', '*.txt')])
        self.filepath_entry.delete(0, tk.END)
        self.filepath_entry.insert(0, filepath)

    def encode(self):
        # 读取文章
        with open(self.filepath_entry.get(), 'r') as f:
            article = f.read()

        # 统计字符出现次数，构造编码表，并对文章进行编码
        char_count = count_character(article)
        encoding_table = build_encoding_table(char_count)
        encoded_data = encode_article(article, encoding_table)

        # 将编码表和编码结果保存到文件中
        with open(self.char_count_path.get(), 'w') as f:
            for key, value in char_count.items():
                f.write(str(key) + ',' + str(value) + '\n')

        with open(self.encoding_table_path.get(), 'w') as f:
            for key, value in encoding_table.items():
                f.write(str(key) + ',' + str(value) + '\n')

        with open(self.encoded_data_path.get(), 'w') as f:
            for code in encoded_data:
                f.write(str(code) + ',')

        tk.messagebox.showinfo('LZW编码器', '编码完成。')

    def decode(self):
        # 从编码文件中读取编码表和编码结果，并使用词典解码得到原文章
        with open(self.encoding_table_path.get(), 'r') as f:
            encoding_table = {}
            for line in f.readlines():
                if len(line.strip().split('=')) == 2:
                    key, value = line.strip().split('=')
                    encoding_table[key] = int(value)

        decoding_table = {v: k for k, v in encoding_table.items()}

        with open(self.encoded_data_path.get(), 'r') as f:
            encoded_data = list(map(int, f.read().split(',')[:-1]))

        decoded_article = decode_article(encoded_data, decoding_table)

        with open(self.decoded_article_path.get(), 'w') as f:
            f.write(decoded_article)

        tk.messagebox.showinfo('LZW编码器', '解码完成。')

if __name__ == '__main__':
    LZWEncoder()

Answer 1

python调试三板斧 https://ask.csdn.net/questions/7908322/54130133