Python实现文档精准分句并调用模型进行预翻译
作者：PythonFun
这篇文章主要为大家详细介绍了如何使用Python实现文档精准分句并调用模型进行预翻译功能,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下
一、问题的来源
计算机辅助翻译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或者大模型进行逐句翻译，并写入到新文件中。为了保持原有的段落格式，还要对段落进行标记，以便将预翻译和译后编辑的双语文本进行还原，以便进行段对段的校核。
1. 定义翻译函数
为了更好地维护代码，我们利用小牛机器翻译定义一个翻译模块，可以在主程序中进行调用，代码如下：
# 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)2. 编写主程序
主要执行读取要翻译的文件，记录段落信息，生成段落字符串组成的列表。然后，利用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工具从导入文件——分句——预翻译——导出双语文本。
3. 进阶优化
由于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文档分句与翻译的资料请关注脚本之家其它相关文章！