Python实现文档精准分句并调用模型进行预翻译

目录

• 一、问题的来源
• 二、问题的解决
• 三、问题的延伸
• 1. 定义翻译函数
• 2. 编写主程序
• 3. 进阶优化
• 四、生成的文件展示
• 五、学后的总结

计算机辅助翻译CAT工具通常会把导入的文件如Docx文件进行分句，形成左右照的表格形式，再调用翻译记忆库、机器翻译或者大模型进行预翻译，译者根据术语库、预翻译结果进行译后编辑。

我一直想在Python中模拟这个过程，但是受限于分句工具NLTK工具箱中的sent_tokenize不够准确，经常把Mr. Washington D.C.中的句点分割成句子，造成分句结果十分不理想。

最近，我发现一个可以精准分句的模块。由开源社区出品PySBD模块可以处理缩写和多语言文本，精确识别句子的结束位置，为实现精准的句子分割提供了现成的“轮子”。看下面的例子，PySBD很好地识别出了句子结尾的位置，并把字符串精准分割句子列表，为后续的预翻译奠定了基础。

import pysbd
seg = pysbd.Segmenter(language="en", clean=True)
print(seg.segment("Dr. Smith went to Washington. It rained."))
# ['Dr. Smith went to Washington.', 'It rained.']

有了准确分句的支持，下一步就可以利用Python调用python-docx模块读取要翻译的文件，分割句子，然后调用机器翻译API或者大模型进行逐句翻译，并写入到新文件中。为了保持原有的段落格式，还要对段落进行标记，以便将预翻译和译后编辑的双语文本进行还原，以便进行段对段的校核。

为了更好地维护代码，我们利用小牛机器翻译定义一个翻译模块，可以在主程序中进行调用，代码如下：

# niutrans.py
import json
import requests

class Translator:
    def __init__(self, apikey="Your API"): #录入你的翻译API
        self.apikey = apikey
        self.url = 'http://api.niutrans.com/NiuTransServer/translation'

    def translate(self, sentence, src_lan="auto", tgt_lan="zh"):
        data = {"from": src_lan, "to": tgt_lan, "apikey": self.apikey, "src_text": sentence}
        res = requests.post(self.url, data=data)
        res_dict = json.loads(res.text)
        if "tgt_text" in res_dict:
            result = res_dict['tgt_text']
        else:
            result = res.text
        return result

def translate(sentence, src_lan, tgt_lan, apikey="Your API"):
    """便捷函数，直接调用翻译"""
    translator = Translator(apikey)
    return translator.translate(sentence, src_lan, tgt_lan)

if __name__ == "__main__":
    while True:
        line = input("请输入要翻译的文本：")
        try:
            trans = translate(line, 'auto', 'en')
            print(trans)
        except Exception as exc:
            print(exc)

在DeepSeek的辅助下，我们轻松定义这个翻译模块，可以使用当前代码或在另一个test.py文件中输入以下代码进行测试。调用上述模块的方法有三种，代码如下所示：

# 方式1：使用便捷函数
from niutrans import translate
result = translate("你好", "auto", "en")
print(result)

# 方式2：使用Translator类
from niutrans import Translator
translator = Translator()
result = translator.translate("你好", "auto", "en")
print(result)

# 方式3：使用自定义API密钥
from niutrans import Translator
translator = Translator(apikey="d99fc0600b16efa6e310f53579593c57")
result = translator.translate("你好", "auto", "en")
print(result)

主要执行读取要翻译的文件，记录段落信息，生成段落字符串组成的列表。然后，利用pysbd按照段落来分割句子，并存储在列表当中。最后逐句翻译后，生成英汉句级对照的文本，为译后编辑提供便利。

为了方便测试，DeepSeek还辅助生成了一个测试的函数。对于可能存在的错误信息也进行了及时的反馈。

import pysbd
from docx import Document
from niutrans import Translator
import re

class DocxSentenceProcessor:
    def __init__(self, language="en", clean=True):
        self.segmenter = pysbd.Segmenter(language=language, clean=clean)
        self.translator = Translator()

    def read_docx(self, file_path):
        """读取DOCX文件内容"""
        doc = Document(file_path)
        content = []
        for i, paragraph in enumerate(doc.paragraphs):
            if paragraph.text.strip():  # 忽略空段落
                content.append({
                    'paragraph_id': i,
                    'original_text': paragraph.text,
                    'sentences': []
                })
        return content

    def segment_sentences(self, text):
        """切分句子"""
        return self.segmenter.segment(text)

    def translate_sentence(self, sentence, dest_language='zh'):
        """翻译句子"""
        try:
            translation = self.translator.translate(sentence, "auto", dest_language)
            return translation  # 直接返回翻译结果，因为新版本返回的是字符串
        except Exception as e:
            print(f"翻译错误: {e}")
            return f"[翻译失败] {sentence}"

    def process_docx(self, input_file, output_file, dest_language='zh'):
        """处理DOCX文件：切分句子并翻译"""
        # 读取原始文档
        paragraphs = self.read_docx(input_file)

        # 处理每个段落
        for para in paragraphs:
            if para['original_text']:
                # 切分句子
                sentences = self.segment_sentences(para['original_text'])

                # 对每个句子进行翻译
                for i, sentence in enumerate(sentences):
                    if sentence.strip():  # 忽略空句子
                        translated = self.translate_sentence(sentence.strip(), dest_language)
                        para['sentences'].append({
                            'sentence_id': i,
                            'original': sentence.strip(),
                            'translated': translated
                        })

        # 保存处理后的文档
        self.save_processed_docx(paragraphs, output_file)

        return paragraphs

    def save_processed_docx(self, paragraphs, output_file):
        """保存处理后的DOCX文件（逐句对照）"""
        doc = Document()

        for para in paragraphs:
            if para['sentences']:
                # 添加段落标签
                p = doc.add_paragraph()
                p.add_run(f"[段落{para['paragraph_id']+1}] ").bold = True
                # 添加逐句照内容
                for sentence_data in para['sentences']:
                    p = doc.add_paragraph()
                    p.add_run(f"[{sentence_data['sentence_id']+1}] ")
                    p.add_run(sentence_data['original'])
                    p = doc.add_paragraph()
                    p.add_run(sentence_data['translated'])
                    p.add_run(" ")

        doc.save(output_file)
        print(f"处理后的文档已保存为: {output_file}")

    def restore_bilingual_docx(self, processed_paragraphs, output_file):
        """恢复为双语对照格式的DOCX（用换行分割）"""
        doc = Document()

        for para in processed_paragraphs:
            if para['sentences']:
                # 添加段落标签
                p_label = doc.add_paragraph()
                p_label.add_run(f"[段落{para['paragraph_id']+1}]").bold = True

                # 逐句添加双语对照，用换行分割
                for sentence_data in para['sentences']:
                    # 英文句子
                    p_en = doc.add_paragraph()
                    p_en.add_run(f"[{sentence_data['sentence_id']+1}] ").bold = True
                    p_en.add_run(sentence_data['original'])

                    # 中文翻译（换行）
                    p_zh = doc.add_paragraph()
                    p_zh.add_run(" " * 4)  # 缩进
                    p_zh.add_run(sentence_data['translated'])

                # 添加空行分隔段落
                doc.add_paragraph()

        doc.save(output_file)
        print(f"双语对照文档已保存为: {output_file}")

    def restore_bilingual_compact(self, processed_paragraphs, output_file):
        """恢复为紧凑双语对照格式（段落级别换行）"""
        doc = Document()

        for para in processed_paragraphs:
            if para['sentences']:
                # 添加段落标签
#                 p_label = doc.add_paragraph()
#                 p_label.add_run(f"[段落{para['paragraph_id']+1}]").bold = True

                # 英文段落
                p_en = doc.add_paragraph()
                p_en.add_run("EN: ").bold = True
                for sentence_data in para['sentences']:
                    p_en.add_run(f"[{sentence_data['sentence_id']+1}] {sentence_data['original']} ")

                # 中文段落（换行）
                p_zh = doc.add_paragraph()
                p_zh.add_run("CN: ").bold = True
                for sentence_data in para['sentences']:
                    p_zh.add_run(f"[{sentence_data['sentence_id']+1}] {sentence_data['translated']} ")

                # 添加空行分隔
                doc.add_paragraph()

        doc.save(output_file)
        print(f"紧凑双语对照文档已保存为: {output_file}")

# 使用示例
def main():
    # 初始化处理器
    processor = DocxSentenceProcessor()

    # 处理DOCX文件
    input_file = "input.docx"
    output_file = "processed_output.docx"
    bilingual_file = "bilingual_output.docx"
    bilingual_compact_file = "bilingual_compact_output.docx"

    try:
        # 处理文档：切分句子并翻译
        processed_data = processor.process_docx(input_file, output_file)

        # 恢复为双语对照格式（逐句换行）
        processor.restore_bilingual_docx(processed_data, bilingual_file)

        # 恢复为紧凑双语对照格式（段落级别换行）
        processor.restore_bilingual_compact(processed_data, bilingual_compact_file)

        # 打印处理结果示例
        print("n=== 处理结果示例 ===")
        for para in processed_data[:2]:  # 显示前2个段落
            print(f"n段落 {para['paragraph_id']+1}:")
            for sentence in para['sentences'][:3]:  # 显示前3个句子
                print(f"  [{sentence['sentence_id']+1}] EN: {sentence['original']}")
                print(f"      CN: {sentence['translated']}")
                print()  # 换行分割

    except FileNotFoundError:
        print(f"错误: 找不到输入文件 {input_file}")
        print("正在创建示例文件...")
        create_sample_docx(input_file)

if __name__ == "__main__":
    # 运行测试
    test_sentence_segmentation()
    print("n" + "="*50 + "n")

    # 运行主程序
    main()

最终用一百多行代码实现了文档读取、分句、翻译、存储的整个过程，模拟了普通CAT工具从导入文件——分句——预翻译——导出双语文本。

由于Python代码十分灵活，还可以定制个性化的翻译引擎，如调用DeepSeek的API实现句子翻译。而且只需要把niutrans.py中的内容替换成调用DeepSeek API的代码就可以了。

先在DeepSeek官方文档中找到调用的样例代码：

# Please install OpenAI SDK first: `pip3 install openai`
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get('DEEPSEEK_API_KEY'),
    base_url="https://api.deepseek.com")

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {"role": "system", "content": "You are a helpful assistant"},
        {"role": "user", "content": "Hello"},
    ],
    stream=False
)

print(response.choices[0].message.content)

然后，让DeepSeek模仿之前调用小牛机器翻译niutrans.py的代码，生成一个可以调用的模块：deepseek_translator.py

# deepseek_translator.py
import os
from openai import OpenAI

class DeepSeekTranslator:
    def __init__(self, api_key=None, base_url="https://api.deepseek.com", model="deepseek-chat"):
        """
        初始化DeepSeek翻译器

        Args:
            api_key: API密钥，如果为None则从环境变量DEEPSEEK_API_KEY获取
            base_url: API基础URL
            model: 使用的模型
        """
        self.api_key = api_key or os.environ.get('DEEPSEEK_API_KEY')
        if not self.api_key:
            raise ValueError("未提供API密钥，请设置api_key参数或DEEPSEEK_API_KEY环境变量")

        self.client = OpenAI(
            api_key=self.api_key,
            base_url=base_url
        )
        self.model = model

    def translate(self, text, target_language="中文", source_language="自动检测"):
        """
        翻译文本

        Args:
            text: 要翻译的文本
            target_language: 目标语言，默认为中文
            source_language: 源语言，默认为自动检测

        Returns:
            str: 翻译结果
        """
        system_prompt = f"""你是一名专业的翻译助手。请将文本从{source_language}翻译成{target_language}。

翻译要求：
1. 准确传达原文意思
2. 保持语言流畅自然
3. 符合目标语言的表达习惯
4. 保留专业术语和名称
5. 不要添加额外解释或评论

只需返回翻译结果，不需要其他内容。"""

        try:
            response = self.client.chat.completions.create(
                model=self.model,
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": text},
                ],
                stream=False,
                temperature=0.3  # 较低的温度使输出更稳定
            )

            return response.choices[0].message.content.strip()

        except Exception as e:
            print(f"翻译错误: {e}")
            return f"[翻译失败] {text}"

    def batch_translate(self, texts, target_language="中文", source_language="自动检测"):
        """
        批量翻译文本

        Args:
            texts: 文本列表
            target_language: 目标语言
            source_language: 源语言

        Returns:
            list: 翻译结果列表
        """
        results = []
        for i, text in enumerate(texts):
            print(f"翻译进度: {i+1}/{len(texts)}")
            result = self.translate(text, target_language, source_language)
            results.append(result)
        return results

# 便捷函数
def translate(text, target_language="中文", source_language="自动检测", api_key=None):
    """便捷翻译函数"""
    translator = DeepSeekTranslator(api_key=api_key)
    return translator.translate(text, target_language, source_language)

# 测试代码
if __name__ == "__main__":
    # 测试翻译
    try:
        translator = DeepSeekTranslator()

        # 单句翻译测试
        test_text = "Hello, how are you today? I hope you're doing well."
        result = translator.translate(test_text, "中文", "英语")
        print(f"原文: {test_text}")
        print(f"翻译: {result}")
        print("-" * 50)

        # 批量翻译测试
        test_texts = [
            "Good morning!",
            "What is your name?",
            "I love programming and artificial intelligence."
        ]
        results = translator.batch_translate(test_texts, "中文", "英语")
        for original, translated in zip(test_texts, results):
            print(f"原文: {original}")
            print(f"翻译: {translated}")
            print()

    except ValueError as e:
        print(f"初始化错误: {e}")
        print("请设置DEEPSEEK_API_KEY环境变量或提供api_key参数")
    except Exception as e:
        print(f"测试错误: {e}")

其调用的方式如下：

# 方式1：使用环境变量中的API密钥
from deepseek_translator import DeepSeekTranslator

translator = DeepSeekTranslator()
result = translator.translate("Hello, world!", "中文", "英语")
print(result)

# 方式2：直接传递API密钥
from deepseek_translator import DeepSeekTranslator

translator = DeepSeekTranslator(api_key="your_api_key_here")
result = translator.translate("Hello, world!", "中文", "英语")
print(result)

# 方式3：使用便捷函数
from deepseek_translator import translate

result = translate("Hello, world!", "中文", "英语")
print(result)

# 方式4：批量翻译
from deepseek_translator import DeepSeekTranslator

translator = DeepSeekTranslator()
texts = ["First sentence.", "Second sentence.", "Third sentence."]
results = translator.batch_translate(texts, "中文", "英语")
for original, translated in zip(texts, results):
    print(f"{original} -> {translated}")

将上面改造的DeepSeek翻译函数融合到文档翻译当中就可以了：

# 在DocxSentenceProcessor中使用DeepSeek翻译器
from deepseek_translator import DeepSeekTranslator

class DocxSentenceProcessor:
    def __init__(self, language="en", clean=True, translator_type="deepseek"):
        self.segmenter = pysbd.Segmenter(language=language, clean=clean)

        if translator_type == "deepseek":
            self.translator = DeepSeekTranslator()
        else:
            from niutrans import Translator
            self.translator = Translator()

    def translate_sentence(self, sentence, dest_language='中文'):
        """翻译句子"""
        try:
            if hasattr(self.translator, 'translate'):
                # DeepSeek翻译器
                translation = self.translator.translate(sentence, dest_language)
            else:
                # 小牛翻译器
                translation = self.translator.translate(sentence, "auto", dest_language)
            return translation
        except Exception as e:
            print(f"翻译错误: {e}")
            return f"[翻译失败] {sentence}"
# 其它内容不变。

生成的processed_output.docx文件当中可以看出清楚地标明了段医学，并进行了准确分句，每句句前都有序号标记，对于译者进行译后编辑也十分友好。

本案例基于Python开发了一套计算机辅助翻译流程，实现了文档导入、智能分句、机器翻译/DeepSeek大模型调用及句级对齐的全自动化处理。该方案具有个性化程度高、灵活性强、成本低廉等突出优势，有效解决了传统CAT工具无法调用大模型或使用成本过高的问题，使译者无需依赖专业CAT软件，在WPS或Word中即可直接进行译后编辑。目前该方案的主要局限在于格式标签保持方面存在一定难度，对复杂排版文档的支持尚不完善，且暂不支持PDF格式文档的处理。

后续还可以持续优化，增加UI界面，提供批量翻译，支持术语库支持和质量检测功能。

当前，人工智能技术日新月异，大模型辅助编程的能力日益强大。在掌握基础语法和程序逻辑的前提下，我们能够借助大模型实现文本处理与翻译流程的自动化，从而充分发挥Python作为“编程瑞士军刀”的强大功能，有效提升翻译工作的效率与质量。

以上就是Python实现文档精准分句并调用模型进行预翻译的详细内容，更多关于Python文档分句与翻译的资料请关注风君子博客其它相关文章！

您可能感兴趣的文章:

• 巧用Python实现自动化翻译任务分配详解
• 基于Python编写一个Word文件翻译器
• Python基于OCR实现图片识别翻译工具功能(附源码)
• 使用Python实现中文翻译为英文的三种方法小结
• 使用Python实现将中文语音翻译成英语音频功能
• 基于Python编写新手向的简易翻译工具
• python全自动脚本实现翻译英文pdf文件
• Python使用translate库实现多语种互相翻译