基于Python编写一个Word文件翻译器

目录

• 一AKocaUAwDp、背景介绍
• 二、使用方法
• 三、部分代码分享
• 四、工具代码展示
• 五、总结

一、背景介绍

在日常教学、科研与跨境商务活动中，外文资料（论文、合同、技术文档）和中文资料的互译需求非常频繁。传统人工翻译虽然准确，但耗时耗力；使用CAT工具，或者通用在线翻译平台，又需要支付费用，而且操作繁琐，无法方便地处理大批量文件。

为解决这一痛点，本软件Word文件翻译器应运而生。它基于 python + Tkinter 图形界面开发，集成了小牛机器翻译API，支持 Word（.docx）、文本（.txt）等常见文件的快速翻译，解决网页翻译工具5000字符限制，并能将结果导出为 DOCX、TXT、XLSX 多种格式。从而实现本地一键翻译文档，减少繁琐操作，提升翻译效率。

使用小牛翻译，主要是考虑其专业的服务品质，而且服务器在国内，支持QPS数量，免费用户为5，付费为50，即每秒可以向服务器发送5次请求，每次请求字符长度也在5000字符，每天提供高达20万的免费额度，个人用户申请也很方便。

二、使用方法

第一次使用时，双击Niutrans.exe，界面会弹出主窗口，提示输入API信息。

加载API

当你输入完API，界面上会提示【已经加载API】。

接下来，通过设置语言对，打开要翻译的文件，选择要生成的文件格式，默认是先原文后译文，如果想原文在后，可以去掉【原文在先】前的勾，再点击【开始翻译】就可以了。使用过程中，有可能会有卡顿现象，但是不影响正常的翻译过程。

翻译成功提示

当得到【恭喜您，翻译已经完成】的信息时，双语对照格式的文件已经生成，并以【文件名_translated.docx】结尾。以下是结果展示。

接下来，我们就可以借助这个生成的英中对照文件进行译后编辑，也可以借用于人工智能进行改写和润色，虽然这样不一定有CAT工具快捷，但是它提供了一种新的问题解决路径，实现了Python+机器翻译+人工译校的有效结合。

三、部分代码分享

以上工具借用了Python中的tkinter搭建了界面，利用小牛机器翻译api来实现了文本的翻译，又借助了python-docx这个模块来读取和写入docx文件，最后在ChatGPT的协作下，排除掉了部分bug。

工具的核心代码是小牛调用机器翻译api，特地把代码分享给大家。

import json
import requests
apikey="<你自己申请的免费的小牛翻译api>"
def translate(sentence, src_lan, tgt_lan):
    url = 'http://api.niutrans.com/NiuTransServer/translation?'
    data = {"from": src_lan, "to": tgt_lan, "apikey": apikey, "src_text": sentence}
    res = requests.post(url, data = data)
    res_dict = json.loads(res.text)
    if "tgt_text" in res_dict:
        result = res_dict['tgt_text']
    else:
        result = res
    return result
if __name__ == "__main__":
    while True:
        line = input("请输入要翻译的文本：")
        try:
            trans = translate(line, 'auto', 'en')
            print(trans+"\n---------")
        except Exception as exc:
            print(exc)

四、工具代码展示

为方便大家使用，我已经把源码放在下面：

from tkinter import *
from tkinter import ttk, messagebox, filedialog
import os, sys, json
from docx import Document
import xlsxwriter
import tkinter.font as tkFont
import requests
from urllib import parse

class TranslatorApp:
    def __init__(self):
        self.title = "Word文件翻译器 1.6  20250820 | Gordon编写"
        self.file_path = ""
        self.file_ext = ""
        self.save_base = ""
        self.output_type = "DOCX"
        self.from_lang_sel = None
        self.to_lang_sel = None
        self.api = None   # 保存API
    def init_ui(self):
        self.root = Tk()
        self.root.title(self.title)
        # self.root.iconbitmap('icon.ico')
        # ✅ 在 Tk() 建立之后初始化 BooleanVar
        self.show_source_first = BooleanVar(master编程=self.root, value=True)
        
        width, height = 600, 400
        sw, sh = self.root.winfo_screenwidth(), self.root.winfo_screenheight()
        alignstr = f"{width}x{height}+{int((sw-width)/2)}+{int((sh-height)/2)}"
        self.root.geometry(alignstr)
        self.root.resizable(False, False)

        font12 = tkFont.Font(family='宋体', size=12, weight=tkFont.BOLD)

        # 语言选择
        frame1 = Frame(self.root)
        frame1.pack(pady=5)
        Label(frame1, text="1.选择原文和译文的语种", font=font12, justify=LEFT).pack()
        self.com_from = ttk.Combobox(frame1, width=17, font=font12, values=['日文', '英文', '中文'])
        self.com_from.current(0)
        self.com_from.pack(side="left")
        self.com_to = ttk.Combobox(frame1, width=17, font=font12, values=['英文', '日文', '中文'])
        self.com_to.current(2)
        self.com_to.pack(side="left")

        # 翻译引擎
        frame2 = Frame(self.root)
        frame2.pack(pady=5)
        Label(frame2, text="2.选择要使用的翻译引擎", font=font12, justify=LEFT).pack()
        self.com_engine = ttk.Combobox(frame2, width=36, font=font12, values=['小牛'])
        self.com_engine.current(0)
        self.com_engine.pack()

        # 选择文件
        frame3 = Frame(self.root)
        frame3.pack(pady=5)
        Label(frame3, text="3.打开要翻译的文本文件", font=font12).pack()
        self.filename_var = StringVar()
        file_frame = Frame(self.root)
        file_frame.pack()
        Entry(file_frame, textvariable=self.filename_var, width=36).pack(side="left")
        Button(file_frame, text="打开文件", font=font12, command=self.select_file).pack(side="right")

        # 输出格式
        Label(self.root, text="4.选择要生成的文件格式", font=font12).pack()
        format_frame = Frame(self.root)
        format_frame.pack(pady=5)
        self.com_format = ttk.Combobox(format_frame, width=33, values=['DOCX', 'TXT', 'XLSX'])
        self.com_format.current(0)
        self.com_format.pack(side="left")
        Button(format_frame, text="开始翻译", font=font12, command=self.start_translation).pack(side="right")

        # ---------------- 底部按钮 ----------------
        bottom_frame = Frame(self.root)
        bottom_frame.pack(pady=15)

        self.api_btn=Button(bottom_frame, text="加载API", font=font12, command=self.show_settings)
        self.api_btn.pack(side="left", padx=10)
        Checkbutton(bottom_frame, text="原文在先", font=font12, variable=self.show_source_first).pack(side="left", padx=10)
        Button(bottom_frame, text="退出程序", font=font12, command=self.root.quit).pack(side="left", padx=10)
        
        # 检查文件是否存在
        json_filename = "config.json"
        if not os.path.exists(json_filename):
            # 创建 JSON 文件并提示输入 API
            with open(json_filename, "w") as json_file:
                json.dump({"api_key": self.api}, json_file)
            print("JSON 文件已创建。")
        else:
            # 读取 JSON 文件内容
            with open(json_filename, "r") as json_file:
                data = json.load(json_file)
            self.api = data.get("api")
            self.api_btn.configure(text="已经加载API")
            #print(self.api)
        if self.api==None:
            self.show_settings()
        
        self.root.mainloop()

    # ========== API设置窗口 ==========
    def show_settings(self):
        self.settings_window = Toplevel(self.root)
        self.settings_window.attributes('-topmost', True)
        self.settings_window.title("小牛 API设置")

        Label(self.settings_window, text="请把小牛机器翻译的API放在这里,使用ctrl+V:").pack(pady=5)
        self.api_var = StringVar()
        self.entry = Entry(self.settings_window, textvariable=self.api_var, width=30, font=("微软雅黑", 12))
        self.entry.pack()

        confirm_button = Button(self.setti编程ngs_window, text="确认", command=self.apply_settings)
        confirm_button.pack(pady=10)

        # 居中窗口
        screen_width = self.settings_window.winfo_screenwidth()
        screen_height = self.settings_window.winfo_screenheight()
        self.settings_window.update_idletasks()
        window_width = self.settings_window.winfo_width()
        window_height = self.settings_window.winfo_height()
        x_position = (screen_width - window_width) // 2
        y_position = (screen_height - window_height) // 2
        self.settings_window.geometry(f"{window_width}x{window_height}+{x_position}+{y_position}")

    def apply_settings(self):
        new_api = self.api_var.get()
        self.api = new_api.strip()
        data = {'api': self.api}
        with open('config.json', 'w+', encoding='utf-8') as f:
            json.dump(data, f, indent=4, ensure_ascii=False)
        self.settings_window.destroy()
        messagebox.showinfo("提示", "API保存成功！")
        self.api_btn.configure(text="已经加载API")
    def select_file(self):
        path = filedialog.askopenfilename(
            title="基于Python编写一个Word文件翻译器",
            filetypes=[("Word", "*.docx"), ("文本", "*.txt"), ("All Files", "*")],
            initialdir="."
        )
        if path:
            self.file_path = path
            self.file_ext = os.path.splitext(path)[1].lower()
            self.save_base = os.path.splitext(path)[0]
            self.filename_var.set(path)

    #apikey="5c85f7de0c9cf798b5c44204632eca85"
    def translate(self,sentence, src_lan, tgt_lan):
        url = 'http://api.niphputrans.com/NiuTransServer/translation?'
        data = {"from": src_lan, "to": tgt_lan, "apikey": self.api, "src_text": sentence}
        res = requests.post(url, data = data)
        res_dict = json.loads(res.text)
        if "tgt_text" in res_dict:
            result = res_dict['tgt_text']
        else:
            result = res
        return result

    def niutrans_api(self, text, from_lang, to_lang):
        return self.translate(text,"auto", to_lang)
    def get_lang_pair(self):
        mapping = {
            ("中文", "英文"): ("zh", "en"),
            ("英文", "中文"): ("en", "zh"),
            ("日文", "中文"): ("ja", "zh"),
            ("中文", "日文"): ("zh", "ja"),
            ("英文", "日文"): ("en", "ja"),
            ("日文", "英文"): ("ja", "en")
        }
        self.from_lang_sel, self.to_lang_sel = self.com_from.get(), self.com_to.get()
        return mapping.get((self.from_lang_sel, self.to_lang_sel))

    def translate_texts(self, texts):
        lang_pair = self.get_lang_pair()
        if not lang_pair:
            sys.exit(0)
        return [self.niutrans_api(t, 'auto',lang_pair[1]) if t.strip() else "" for t in texts]

    def txt_trans(self):
        with open(self.file_path, "r", encoding="utf-8") as f:
            src = [line.strip() for line in f if line.strip()]
        if self.show_source_first.get():
            return src, self.translate_texts(src)
        else:
            return self.translate_texts(src),src

    def docx_trans(self):
        doc = Document(self.file_path)
        src = [p.text for p in doc.paragraphs]
        if self.show_source_first.get():
            return src, self.translate_texts(src)
        else:
            return self.translate_texts(src),src

    def to_excel(self, src, tgt):
        wb = xlsxwriter.Workbook(self.save_base + "_translated.xlsx")
        ws = wb.add_worksheet()
        for r, (x, y) in enumerate(zip(src, tgt)):
            ws.write(r, 0, x)
            ws.write(r, 1, y)
        wb.close()

    def to_txt(self, src, tgt):
        with open(self.save_base + "_translated.txt", "w", encoding="utf-8") as f:
            for x, y in zip(src, tgt):
                f.write(f"{x}\n{y}\n")

    def convert_file(self, src, tgt):
        fmt = self.com_format.get()
        if fmt == "XLSX":
            self.to_excel(src, tgt)
        elif fmt == "DOCX":
            doc = Document()
            for x, y in zip(src, tgt):
                doc.add_paragraph(f"{x}\n{y}")
            doc.save(self.save_base + "_translated.docx")
        elif fmt == "TXT":
            self.to_txt(src, tgt)

    def start_translation(self):
        if not self.file_path:
            messagebox.showinfo("提示", "请先打开要翻译的文件！")
            return
        if self.file_ext == ".docx":
            编程客栈src, tgt = self.docx_trans()
        elif self.file_ext == ".txt":
            src, tgt = self.txt_trans()
        else:
            messagebox.showinfo("提示", "文件类型错误，请重新选择！")
            return
        self.convert_file(src, tgt)
        messagebox.showinfo("提示", "恭喜您，翻译已经完成！")

    def run(self):
        self.init_ui()

if __name__ == "__main__":
    TranslatorApp().run()

五、总结

以上代码中包括了中、英、日三种语言的互转，速度快、效率高，但是无法保证原文一样的格式。后期可以持续改进，简化翻译程序，力争保留Word翻译后的格式。

到此这篇关于基于Python编写一个Word文件翻译器的文章就介绍到这了,更多相关Python Word文件翻译器内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！