其实你要做的就是类似ProGuard的Python版标识符重命名工具，核心要解决的是精准替换代码里的变量、方法、类名，同时不破坏代码逻辑——直接字符串替换肯定不行，会把字符串里的内容、注释甚至关键字搞错，所以最靠谱的方案是基于Python的AST（抽象语法树）来实现，我给你拆解下具体怎么做：

一、核心技术选型：用Python标准库ast做解析 #

Python自带的ast模块是处理这类问题的首选，它能把代码转换成结构化的AST树，精准识别出变量定义、函数定义、类定义等所有合法标识符，不会像正则那样误判。配合ast.NodeTransformer类，我们可以遍历整个AST，对指定节点进行重命名操作，这是最安全的方式。

二、具体实现步骤 #

1. 预处理词表和输入代码 #

• 先读取你的词表文件，把里面的词汇去重，还要过滤掉Python的关键字（比如if、def这些不能当变量名的），可以用keyword.iskeyword()来判断；另外最好验证下词汇是否符合Python标识符规则（只能以字母/下划线开头，包含字母、数字、下划线），避免替换后代码报错。
• 把处理好的词表做成一个队列，每次需要重命名时取一个新词，确保每个新名称只用到一次。

2. 遍历AST并批量替换标识符 #

继承ast.NodeTransformer类，重写对应的方法来处理不同类型的节点：

• 函数/异步函数定义：修改FunctionDef、AsyncFunctionDef节点的name属性
• 类定义：修改ClassDef节点的name属性
• 变量名：处理Name节点，这里要注意区分“赋值存储”（Store上下文）和“读取使用”（Load上下文），需要维护一个rename_map字典，把旧名称映射到新名称，确保同一个变量在所有地方都被替换成同一个新词。
• 参数名：还要处理函数参数（arguments节点里的args列表），这部分也属于需要替换的标识符。

3. 生成修改后的代码 #

用Python 3.9+支持的ast.unparse()方法，把修改后的AST重新转换成Python代码；如果要兼容旧版本Python，可以用astor这个第三方库来生成代码。

4. 命令行参数处理 #

用标准库的argparse模块处理--input、--wordlist、--output这些参数，完全符合你期望的使用方式。

三、示例代码片段 #

给你写个简化版的实现，你可以基于这个扩展：

import ast
import argparse
import keyword
from collections import deque

class RenameTransformer(ast.NodeTransformer):
    def __init__(self, word_list):
        # 过滤关键字和无效标识符，去重后转成队列
        valid_words = []
        for word in set(word_list):
            stripped_word = word.strip()
            if stripped_word and not keyword.iskeyword(stripped_word) and stripped_word.isidentifier():
                valid_words.append(stripped_word)
        self.available_words = deque(valid_words)
        self.rename_map = {}

    def _get_new_name(self, old_name):
        if old_name not in self.rename_map:
            if not self.available_words:
                raise ValueError("词表中的有效词汇已耗尽，请补充更多合法词汇！")
            new_name = self.available_words.popleft()
            self.rename_map[old_name] = new_name
        return self.rename_map[old_name]

    # 处理普通函数定义
    def visit_FunctionDef(self, node):
        node.name = self._get_new_name(node.name)
        return self.generic_visit(node)

    # 处理异步函数定义
    def visit_AsyncFunctionDef(self, node):
        node.name = self._get_new_name(node.name)
        return self.generic_visit(node)

    # 处理类定义
    def visit_ClassDef(self, node):
        node.name = self._get_new_name(node.name)
        return self.generic_visit(node)

    # 处理变量名（包括赋值和使用场景）
    def visit_Name(self, node):
        if node.id in self.rename_map:
            node.id = self.rename_map[node.id]
        elif isinstance(node.ctx, ast.Store):
            # 赋值场景下的变量，生成新名称
            node.id = self._get_new_name(node.id)
        return node

    # 处理函数参数
    def visit_arg(self, node):
        node.arg = self._get_new_name(node.arg)
        return node

def main():
    parser = argparse.ArgumentParser(description='用自定义词表重命名Python代码中的变量、函数和类')
    parser.add_argument('--input', required=True, help='输入Python文件路径')
    parser.add_argument('--wordlist', required=True, help='自定义词表文件路径（每行一个词汇）')
    parser.add_argument('--output', help='输出文件路径（默认输出到控制台）')
    args = parser.parse_args()

    # 读取词表
    with open(args.wordlist, 'r', encoding='utf-8') as f:
        word_list = f.readlines()

    # 读取输入代码
    with open(args.input, 'r', encoding='utf-8') as f:
        code_content = f.read()

    # 解析AST并修改
    try:
        tree = ast.parse(code_content)
        transformer = RenameTransformer(word_list)
        modified_tree = transformer.visit(tree)
        ast.fix_missing_locations(modified_tree)  # 修复节点位置信息，方便报错定位

        # 生成新代码
        new_code = ast.unparse(modified_tree)

        # 输出结果
        if args.output:
            with open(args.output, 'w', encoding='utf-8') as f:
                f.write(new_code)
            print(f"修改后的代码已保存到 {args.output}")
        else:
            print(new_code)
    except Exception as e:
        print(f"处理出错：{str(e)}")

if __name__ == '__main__':
    main()

四、优化和注意事项 #

• 作用域处理：上面的简化版是全局映射，如果你需要支持局部作用域（比如同一个名称在不同函数里可以替换成不同新词），可以维护一个作用域栈，在进入函数/类时压入新的映射表，退出时弹出。
• 避免冲突：替换前可以先扫描原代码中的所有标识符，过滤掉词表中已存在的词汇，防止替换后出现名称冲突。
• 第三方库保护：如果代码中用到了第三方库的函数/类，不要替换它们，可以通过判断标识符是否属于全局导入的外部名称来跳过替换。

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