如何用脚本批量翻译多语言？

本文目录导读：

1. 方案一：使用Google Cloud Translation API（免费额度）
2. 方案二：使用DeepL API（精准度高，支持更多语言）
3. 方案三：使用阿里云翻译（支持中文优化，国内可用）
4. 方案四：使用简易脚本处理Excel文件
5. 批量翻译多语言的完整示例
6. 重要提示

要批量翻译多语言，推荐使用脚本调用翻译API（如Google Translate、DeepL、阿里云等），以下是几种常见方案,包含Python代码示例：

使用Google Cloud Translation API（免费额度）

import requests
import json
import pandas as pd
def google_translate_batch(texts, target_lang='zh'):
    """批量翻译文本"""
    api_key = 'YOUR_API_KEY'  # 替换为你的API密钥
    url = f'https://translation.googleapis.com/language/translate/v2'
    # Google API支持一次最多128个文本
    batch_size = 100
    translations = []
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i+batch_size]
        params = {
            'q': batch,
            'target': target_lang,
            'key': api_key,
            'format': 'text'
        }
        response = requests.post(url, params=params)
        if response.status_code == 200:
            result = response.json()
            for item in result['data']['translations']:
                translations.append(item['translatedText'])
        else:
            print(f"Error on batch {i}: {response.status_code}")
            translations.extend(['ERROR'] * len(batch))
    return translations
# 使用示例
texts_to_translate = ["Hello World", "How are you?", "Good morning"]
results = google_translate_batch(texts_to_translate, target_lang='es')
for original, translated in zip(texts_to_translate, results):
    print(f"{original} -> {translated}")

使用DeepL API（精准度高，支持更多语言）

import deepl
import csv
def deepL_batch_translate(file_path, source_lang='EN', target_langs=['ZH', 'JA', 'KO']):
    """从CSV读取内容并翻译到多种语言"""
    auth_key = 'YOUR_AUTH_KEY'  # 替换为你的DeepL API密钥
    translator = deepl.Translator(auth_key)
    # 读取CSV文件
    with open(file_path, 'r', encoding='utf-8') as f:
        reader = csv.reader(f)
        headers = next(reader)
        rows = list(reader)
    results = {lang: [] for lang in target_langs}
    # 翻译每行
    for row in rows:
        text = row[0]  # 假设第一列是需要翻译的内容
        for lang in target_langs:
            try:
                result = translator.translate_text(text, source_lang=source_lang, target_lang=lang)
                results[lang].append(result.text)
                print(f"Translated '{text[:30]}...' to {lang}")
            except Exception as e:
                print(f"Error translating to {lang}: {e}")
                results[lang].append('ERROR')
    # 保存到新CSV
    output_file = f"translated_{'_'.join(target_langs)}.csv"
    with open(output_file, 'w', encoding='utf-8', newline='') as f:
        writer = csv.writer(f)
        writer.writerow(['Original'] + target_langs)
        for i, row in enumerate(rows):
            original = row[0]
            translations = [results[lang][i] for lang in target_langs]
            writer.writerow([original] + translations)
    return output_file

使用阿里云翻译（支持中文优化，国内可用）

import requests
import json
import hmac
import hashlib
import base64
import time
import uuid
from urllib.parse import quote
def aliyun_translate(texts, source_lang='en', target_lang='zh'):
    """使用阿里云机器翻译批量处理"""
    access_key_id = 'YOUR_ACCESS_KEY_ID'
    access_key_secret = 'YOUR_ACCESS_KEY_SECRET'
    endpoint = 'https://mt.cn-hangzhou.aliyuncs.com'
    def sign_request(params):
        # 阿里云签名实现（简化版，实际需要完整签名算法）
        sorted_params = sorted(params.items())
        canonical = '&'.join([f'{quote(k, safe="")}={quote(v, safe="")}' 
                             for k, v in sorted_params])
        string_to_sign = f'POST&{quote("/", safe="")}&{quote(canonical, safe="")}'
        h = hmac.new(access_key_secret.encode(), string_to_sign.encode(), 
                    hashlib.sha1).digest()
        return base64.b64encode(h).decode()
    translations = []
    batch_size = 10  # 阿里云限制
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i+batch_size]
        batch_translations = []
        for text in batch:
            params = {
                'Action': 'TranslateGeneral',
                'FormatType': 'text',
                'SourceLanguage': source_lang,
                'TargetLanguage': target_lang,
                'SourceText': text,
                'AccessKeyId': access_key_id,
                'Timestamp': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
                'SignatureMethod': 'HMAC-SHA1',
                'SignatureVersion': '1.0',
                'SignatureNonce': str(uuid.uuid4())
            }
            params['Signature'] = sign_request(params)
            response = requests.post(endpoint, params=params)
            if response.status_code == 200:
                result = response.json()
                if 'Data' in result:
                    batch_translations.append(result['Data']['Translated'])
                else:
                    batch_translations.append('ERROR')
            else:
                batch_translations.append('ERROR')
        translations.extend(batch_translations)
        time.sleep(0.5)  # 避免触发速率限制
    return translations

使用简易脚本处理Excel文件

import openpyxl
from googletrans import Translator  # 免费但速度较慢
def translate_excel_file(input_file, output_file, target_lang='zh'):
    """翻译Excel文件中的所有内容"""
    wb = openpyxl.load_workbook(input_file)
    translator = Translator()
    for sheet_name in wb.sheetnames:
        ws = wb[sheet_name]
        for row in ws.iter_rows():
            for cell in row:
                if cell.value and isinstance(cell.value, str):
                    try:
                        translation = translator.translate(cell.value, dest=target_lang)
                        cell.value = translation.text
                        print(f"Translated: {original[:20]}... -> {translation.text[:20]}...")
                    except Exception as e:
                        print(f"Error translating '{cell.value[:20]}...': {e}")
    wb.save(output_file)
    print(f"Translation complete. Saved to {output_file}")

批量翻译多语言的完整示例

import json
import time
def batch_multi_language(input_file, languages=['zh', 'ja', 'ko', 'de', 'fr']):
    """将一个文本文件翻译成多种语言"""
    # 读取源文件
    with open(input_file, 'r', encoding='utf-8') as f:
        texts = [line.strip() for line in f if line.strip()]
    # 翻译到所有目标语言
    translations = {}
    for lang in languages:
        translations[lang] = google_translate_batch(texts, lang)
        time.sleep(1)  # API调用间隔
    # 输出为JSON格式
    output = []
    for i, original in enumerate(texts):
        entry = {
            'original': original,
            'translations': {lang: translations[lang][i] for lang in languages}
        }
        output.append(entry)
    # 保存结果
    with open('multi_language_translations.json', 'w', encoding='utf-8') as f:
        json.dump(output, f, ensure_ascii=False, indent=2)
    print(f"Translated {len(texts)} texts into {len(languages)} languages")
    return output

重要提示

1. API密钥安全：不要将API密钥硬编码在代码中，使用环境变量或配置文件
2. 速率限制：大多数API都有请求限制，需要添加适当的延迟
3. 费用：上述API通常有免费额度，但超出后需要付费
4. 语言代码：确认使用的语言代码正确（如zh-CN, zh-TW）
5. 文本长度限制：注意API对单次请求的文本长度限制

选择哪种方案取决于你的具体需求：

• 小规模免费：Google translate（googletrans库）
• 高精度：DeepL
• 国内使用：阿里云/百度翻译
• 大量数据：Google Cloud Translation API（商业级）