如何修改Python替换密码解码代码实现增量式解密更新？

我正在开发一个支持用户手动输入替换规则的替换密码解密工具。当前程序每次输入字母替换规则后，会对整个加密文本重新执行全量映射，导致所有字符都发生变化。但我需要实现增量式更新：仅将已设置替换规则的加密字符替换为目标字符，未设置规则的字符保留原始加密状态。

当前实现代码 #

import random


class Cryptography:
    def __init__(self, input_file):
        self.input_file = input_file
        with open(self.input_file, 'r+') as file:
            self.content = file.read()
        self.sentence = ''
        self.code = {
            'A': 'A', 'Ą': 'A', 'B': 'A', 'C': 'A',
            'Ć': 'A', 'D': 'A', 'E': 'A', 'Ę': 'A',
            'F': 'A', 'G': 'A', 'H': 'A', 'I': 'A',
            'J': 'A', 'K': 'A', 'L': 'A', 'Ł': 'A',
            'M': 'A', 'N': 'A', 'Ń': 'A', 'O': 'A',
            'Ó': 'A', 'P': 'A', 'R': 'A', 'S': 'A',
            'Ś': 'A', 'T': 'A', 'U': 'A', 'W': 'A',
            'Y': 'A', 'Z': 'A', 'Ż': 'A', 'Ź': 'A',
        }
        self.replaced_sentence = ''
        self.welcome = '\nWITAJ\nMASZ TERAZ OKAZJE ODSZYFROWAĆ POWYŻSZĄ WIADOMOSĆ\nZA KAŻDYM RAZEM JAK ZAMIENISZ ' \
                       'LITERKI WYSWIETLONA ZOSTANIE\nCZĘŚCIOWO ODSZYFROWANA WIADOMOŚĆ.\nPOWODZENIA!\n '

    # repair converts whatever is in self.content to self.sentence, so it is one line of text without large whitespaces.
    def repair(self):
        for char in self.content:
            if char == '\n':
                char = char.replace('\n', ' ')
            char = char.capitalize()
            self.sentence += char
        self.sentence = " ".join(self.sentence.split())
        print(self.sentence)

    def encrypt(self):
        numbers = list(range(32))
        random.shuffle(numbers)
        letters = list(self.code.keys())
        encrypted_code = {}
        for i, letter in enumerate(letters):
            encrypted_code[letter] = letters[numbers[i]]
        self.code = encrypted_code
        print(f"Encrypted successfully!")

    def transform(self):
        special_char = [' ', ',', '!', '.', '(', ')', ';',]
        for char in self.sentence:
            if char in special_char:
                replaced_char = char
            else:
                replaced_char = self.code.get(char)
            self.replaced_sentence += replaced_char

    def decode(self):
        guessed_sentence = self.replaced_sentence
        spec_char = zip([' ', ',', '!', '.', '(', ')', ';'], [' ', ',', '!', '.', '(', ')', ';'])
        self.code.update(spec_char)
        while True:
            print(guessed_sentence)
            guess = input('please type eg. A = S : ')
            guess = guess.strip()
            guess = guess.replace(' ', '')
            letter1 = guess[0].upper()
            letter2 = guess[2].upper()
            char_mapping = self.code
            char_mapping[letter1] = letter2
            old_string = self.replaced_sentence
            guessed_sentence = ''
            for char in old_string:
                guessed_sentence += char_mapping[char]
            if guessed_sentence == self.sentence:
                break


test = Cryptography('message')
test.repair()
test.encrypt()
test.transform()
test.decode()

当前程序输出 #

LITWO! OJCZYZNO MOJA! TY JESTEŚ JAK ZDROWIE.
Encrypted successfully!
UDŹHĘ! ĘJZMŻMEĘ TĘJŃ! ŹŻ JAGŹAI JŃŁ MBĆĘHDA.
please type eg. A = S : U=L
LBCRL! LJMTWTAL ŹLJÓ! CW JŃOCŃD JÓF TĄSLRBŃ.
please type eg. A = S : D=I
LICRL! LJMTWTAL ŹLJÓ! CW JŃOCŃD JÓF TĄSLRIŃ.
please type eg. A = S : Ź=T
LITRL! LJMTWTAL ŹLJÓ! TW JŃOTŃD JÓF TĄSLRIŃ.
please type eg. A = S : 

期望输出效果 #

LITWO! OJCZYZNO MOJA! TY JESTEŚ JAK ZDROWIE.
Encrypted successfully!
UDŹHĘ! ĘJZMŻMEĘ TĘJŃ! ŹŻ JAGŹAI JŃŁ MBĆĘHDA.
please type eg. A = S : U=L
LDŹHĘ! ĘJZMŻMEĘ TĘJŃ! ŹŻ JAGŹAI JŃŁ MBĆĘHDA.
please type eg. A = S : D=I
LIŹHĘ! ĘJZMŻMEĘ TĘJŃ! ŹŻ JAGŹAI JŃŁ MBĆĘHIA.
please type eg. A = S : Ź=T
LITHĘ! ĘJZMŻMEĘ TĘJŃ! TŻ JAGTAI JŃŁ MBĆĘHIA.
please type eg. A = S : 

问题核心在于当前decode方法每次都从原始加密文本replaced_sentence重新映射，而非基于上一次的解密结果进行增量修改。同时，需要维护一个用户自定义替换规则字典，仅应用用户设置过的映射，未设置的字符保留当前状态。

修改后的完整代码：

import random


class Cryptography:
    def __init__(self, input_file):
        self.input_file = input_file
        with open(self.input_file, 'r+') as file:
            self.content = file.read()
        self.sentence = ''
        self.code = {
            'A': 'A', 'Ą': 'A', 'B': 'A', 'C': 'A',
            'Ć': 'A', 'D': 'A', 'E': 'A', 'Ę': 'A',
            'F': 'A', 'G': 'A', 'H': 'A', 'I': 'A',
            'J': 'A', 'K': 'A', 'L': 'A', 'Ł': 'A',
            'M': 'A', 'N': 'A', 'Ń': 'A', 'O': 'A',
            'Ó': 'A', 'P': 'A', 'R': 'A', 'S': 'A',
            'Ś': 'A', 'T': 'A', 'U': 'A', 'W': 'A',
            'Y': 'A', 'Z': 'A', 'Ż': 'A', 'Ź': 'A',
        }
        self.replaced_sentence = ''
        self.welcome = '\nWITAJ\nMASZ TERAZ OKAZJE ODSZYFROWAĆ POWYŻSZĄ WIADOMOSĆ\nZA KAŻDYM RAZEM JAK ZAMIENISZ ' \
                       'LITERKI WYSWIETLONA ZOSTANIE\nCZĘŚCIOWO ODSZYFROWANA WIADOMOŚĆ.\nPOWODZENIA!\n '
        # 新增：存储用户自定义的替换规则
        self.user_mappings = {}

    # repair converts whatever is in self.content to self.sentence, so it is one line of text without large whitespaces.
    def repair(self):
        for char in self.content:
            if char == '\n':
                char = char.replace('\n', ' ')
            char = char.capitalize()
            self.sentence += char
        self.sentence = " ".join(self.sentence.split())
        print(self.sentence)

    def encrypt(self):
        numbers = list(range(32))
        random.shuffle(numbers)
        letters = list(self.code.keys())
        encrypted_code = {}
        for i, letter in enumerate(letters):
            encrypted_code[letter] = letters[numbers[i]]
        self.code = encrypted_code
        print(f"Encrypted successfully!")

    def transform(self):
        special_char = [' ', ',', '!', '.', '(', ')', ';',]
        for char in self.sentence:
            if char in special_char:
                replaced_char = char
            else:
                replaced_char = self.code.get(char)
            self.replaced_sentence += replaced_char

    def decode(self):
        guessed_sentence = self.replaced_sentence
        # 特殊字符无需替换，直接加入用户映射
        special_chars = [' ', ',', '!', '.', '(', ')', ';']
        for char in special_chars:
            self.user_mappings[char] = char
            
        while True:
            print(guessed_sentence)
            guess = input('please type eg. A = S : ')
            guess = guess.strip()
            if not guess:
                continue  # 处理空输入
            guess = guess.replace(' ', '')
            # 简单校验输入格式
            if len(guess) < 3 or guess[1] != '=':
                print("Invalid format, use 'X=Y'")
                continue
            letter1 = guess[0].upper()
            letter2 = guess[2].upper()
            
            # 更新用户自定义映射
            self.user_mappings[letter1] = letter2
            
            # 增量更新猜测结果：基于上一次的结果，仅替换已设置规则的字符
            new_guessed = []
            for char in guessed_sentence:
                new_guessed.append(self.user_mappings.get(char, char))
            guessed_sentence = ''.join(new_guessed)
            
            # 判断是否解密完成
            if guessed_sentence == self.sentence:
                print("Decryption complete!")
                break


test = Cryptography('message')
test.repair()
test.encrypt()
test.transform()
test.decode()

修改说明 #

• 新增user_mappings：单独存储用户设置的替换规则，避免和加密用的code字典混淆。
• 增量替换逻辑：每次循环不再从原始加密文本重新生成，而是基于上一次的guessed_sentence，只替换存在于user_mappings中的字符，其他字符保持不变。
• 输入校验：增加了对空输入和无效格式的处理，提升程序健壮性。

这样修改后，程序就会按照期望的方式，每次仅更新已设置规则的字符，实现增量式解密更新。

内容的提问来源于stack exchange，提问作者Krzysztof Mrozik