详解Python标准库之国际化（i18n）

详解 Python 标准库之国际化（i18n）

在全球化产品开发中，国际化（Internationalization，简称 i18n）是让应用适配不同语言、地区文化习惯的核心能力，而本地化（Localization，简称 l10n）则是将国际化框架落地为具体语言版本的过程。Python 3.13.7 标准库通过gettext、locale、datetime、numbers四大模块，构建了从 “文本翻译” 到 “区域格式适配” 的完整国际化解决方案，无需依赖第三方库（如Babel）即可满足中大型应用的基础多语言需求。本文基于官方文档，从模块功能、核心 API、实战流程三方面深入解析，同时梳理多语言项目的最佳实践，为全球化应用开发提供清晰指引。

一、国际化核心：gettext 模块（文本翻译）

gettext是 Python 标准库中负责文本翻译的核心模块，遵循 GNU gettext 规范，支持 “标记待翻译文本→生成翻译模板→编写翻译文件→加载多语言版本” 的全流程。其核心优势在于：与代码解耦（翻译文本存储在独立文件中）、支持复数形式、兼容主流翻译工具（如 Poedit），是 Python 多语言应用的首选方案。

1. 核心概念与工作流程

gettext的工作依赖三类关键文件，遵循标准化流程，确保翻译与开发分离：

文件类型	扩展名	作用说明	生成方式
模板文件	.pot（Portable Object Template）	提取代码中所有待翻译文本，生成统一模板，无语言属性	代码提取（xgettext工具或 Python API）
翻译文件	.po（Portable Object）	基于.pot 模板，针对特定语言（如中文、法语）编写翻译内容	从.pot 复制，手动 / 工具翻译（如 Poedit）
二进制文件	.mo（Machine Object）	将.po 文件编译为二进制格式，供gettext加载，提升读取效率	编译.po 文件（msgfmt工具或 Python API）

标准工作流程：

1. 标记代码：在代码中用_()函数标记待翻译文本（如_("Hello World")）；
2. 提取模板：从代码中提取所有_()包裹的文本，生成.pot 模板文件；
3. 编写翻译：基于.pot 创建对应语言的.po 文件（如zh_CN.po），填写翻译内容；
4. 编译二进制：将.po 文件编译为.mo 二进制文件；
5. 加载翻译：应用运行时，gettext根据用户语言加载对应.mo 文件，替换文本。

2. 核心 API 与使用方式

gettext提供两种核心使用方式：函数式（简单场景） 和类式（复杂场景，支持多语言切换），覆盖从脚本到大型应用的不同需求。

（1）基础函数式使用（单语言场景）

适用于仅需支持一种非默认语言的简单应用（如仅需中文版本），API 简洁，无需复杂配置。

核心 API：

• gettext.gettext(message)：获取message的翻译文本，未找到则返回原文本；
• gettext.ngettext(singular, plural, n)：处理复数形式，根据n（数量）返回对应翻译；
• gettext.install(domain, localedir=None, codeset=None)：将_()函数注入全局命名空间，无需手动导入。

实战示例：简单多语言脚本

import gettext

def simple_i18n_demo(lang="en"):
   # 1. 配置翻译：domain为项目名，localedir为翻译文件存放目录
   # 翻译文件目录结构需遵循规范：localedir/语言代码/LC_MESSAGES/domain.{po,mo}
   localedir = "./locale"  # 翻译文件根目录
   domain = "myapp"        # 项目名（与.po/.mo文件名一致）

   try:
       # 2. 根据语言加载翻译（如中文：lang="zh_CN"，英文：lang="en"）
       # gettext.translation()返回Translations对象，负责加载.mo文件
       trans = gettext.translation(
           domain=domain,
           localedir=localedir,
           languages=[lang],  # 优先尝试的语言列表
           fallback=True      # 若指定语言未找到，使用原文本（避免报错）
       )

       # 3. 注入全局_()函数，后续代码可直接使用_()标记文本
       trans.install()

   except FileNotFoundError:
       # 若翻译文件不存在，使用默认_()（返回原文本）
       gettext.install(domain, fallback=True)

   # 4. 标记待翻译文本（单复数示例）
   print(_("Hello World!"))  # 单文本翻译

   user_count = 5

   # 复数文本：根据user_count选择不同翻译（英文有单复数，中文无差异）
   print(ngettext(
       "There is {count} user online.",  # 单数（n=1）
       "There are {count} users online.",# 复数（n!=1）
       user_count

   ).format(count=user_count))


# 测试：分别加载英文和中文
if __name__ == "__main__":
   print("=== 英文版本 ===")
   simple_i18n_demo(lang="en")  # 加载英文翻译（无翻译时返回原文本）

   print("\n=== 中文版本 ===")
   simple_i18n_demo(lang="zh_CN")  # 加载中文翻译

（2）类式使用（多语言切换场景）

适用于需动态切换语言的场景（如应用内语言设置功能），通过Translations类实例管理不同语言的翻译，避免全局函数冲突。
核心 API：

• gettext.translation()：创建指定语言的Translations实例；
• Translations.gettext(message)：实例方法，获取单文本翻译；
• Translations.ngettext(singular, plural, n)：实例方法，处理复数翻译。

实战示例：动态切换语言

import gettext

class MultiLanguageApp:
   def __init__(self, localedir="./locale", domain="myapp"):
       self.localedir = localedir
       self.domain = domain

       # 初始化时加载默认语言（英文）
       self.current_lang = "en"
       self.trans = self._load_translation(self.current_lang)

   def _load_translation(self, lang):
       """加载指定语言的翻译实例"""
       try:
           return gettext.translation(
               domain=self.domain,
               localedir=self.localedir,
               languages=[lang],
               fallback=True
           )

       except FileNotFoundError:
           #  fallback=True时，返回的Translations实例会直接返回原文本
           return gettext.NullTranslations()

   def switch_language(self, lang):
       """切换当前语言"""
       if lang != self.current_lang:
           self.current_lang = lang
           self.trans = self._load_translation(lang)
           print(f"语言已切换为：{lang}")

   def get_text(self, message):
       """获取单文本翻译"""
       return self.trans.gettext(message)

   def get_plural_text(self, singular, plural, n):
       """获取复数文本翻译"""
       return self.trans.ngettext(singular, plural, n)



# 测试动态切换语言
if __name__ == "__main__":
   app = MultiLanguageApp()

   # 1. 默认英文
   print("=== 默认英文 ===")
   print(app.get_text("Welcome to the app!"))
   print(app.get_plural_text("You have 1 new message.", "You have {n} new messages.", 3).format(n=3))

   # 2. 切换为中文
   print("\n=== 切换中文 ===")
   app.switch_language("zh_CN")
   print(app.get_text("Welcome to the app!"))
   print(app.get_plural_text("You have 1 new message.", "You have {n} new messages.", 3).format(n=3))

   # 3. 切换为法语（假设无翻译，返回原文本）
   print("\n=== 切换法语（无翻译） ===")
   app.switch_language("fr")
   print(app.get_text("Welcome to the app!"))

3. 实战：完整多语言项目流程

以 “一个简单的命令行工具” 为例，演示从代码标记到多语言运行的完整流程，包含文件目录组织、翻译文件编写、编译与加载。

步骤 1：项目目录结构

gettext要求翻译文件必须放在指定目录结构中（遵循 GNU 规范），否则无法正确加载：

my_i18n_app/                # 项目根目录
├── app.py                  # 主程序代码
└── locale/                 # 翻译文件根目录（localedir）
   ├── en/                 # 英文（默认语言，可选）
   │   └── LC_MESSAGES/    # 固定目录名
   │       ├── myapp.po    # 英文翻译文件（可选，若需修改默认文本）
   │       └── myapp.mo    # 英文编译文件
   └── zh_CN/              # 中文（目标语言）
       └── LC_MESSAGES/
           ├── myapp.po    # 中文翻译文件
           └── myapp.mo    # 中文编译文件

步骤 2：编写代码（标记待翻译文本）

创建app.py，用_()标记所有需要翻译的文本，包含单文本和复数场景：

import gettext
import sys

def init_i18n(lang):
   """初始化国际化"""
   localedir = "./locale"
   domain = "myapp"

   try:
       trans = gettext.translation(domain, localedir, [lang], fallback=True)
       trans.install()

   except Exception as e:
       print(f"国际化初始化失败：{e}")
       gettext.install(domain, fallback=True)

def main():
   # 从命令行参数获取语言（如python app.py zh_CN）
   lang = sys.argv[1] if len(sys.argv) > 1 else "en"
   init_i18n(lang)

   # 待翻译文本
   print(_("=== Welcome to the File Manager ==="))
   print(_("Please select an operation:"))
   print(f"1. {_('List files')}")
   print(f"2. {_('Create file')}")
   print(f"3. {_('Delete file')}")

   # 复数示例：显示文件数量
   file_count = 5
   print("\n" + _("Current directory status:"))
   print(ngettext(
       "There is {count} file in the directory.",
       "There are {count} files in the directory.",
       file_count
   ).format(count=file_count))



if __name__ == "__main__":
   main()

步骤 3：生成.pot 模板文件

从代码中提取待翻译文本，生成.pot 模板。有两种方式：

• 方式 1：使用系统xgettext工具（推荐，需安装 gettext 工具包，Windows 需额外安装）：

# 进入项目根目录，提取app.py中的文本，生成locale/myapp.pot
xgettext -d myapp -o locale/myapp.pot app.py

• 方式 2：使用 Python API 提取（无需额外工具，适合跨平台）：

# extract_pot.py
import gettext
from pathlib import Path

# 待提取的文件
source_files = ["app.py"]

# 输出.pot文件路径
pot_path = Path("./locale/myapp.pot")
pot_path.parent.mkdir(parents=True, exist_ok=True)

# 提取文本并生成.pot
with open(pot_path, "w", encoding="utf-8") as pot_file:
   gettext.dump(
       gettext.catalog(),  # 空catalog，仅用于生成模板结构
       pot_file,
       sort_output=True,
       sort_by_file=True
   )
   # 手动添加提取的文本（实际项目需遍历代码文件解析_()函数，此处简化）
   pot_file.write('''
        msgid "=== Welcome to the File Manager ==="
        msgstr ""
        msgid "Please select an operation:"
        msgstr ""
        msgid "List files"
        msgstr ""
        msgid "Create file"
        msgstr ""
        msgid "Delete file"
        msgstr ""
        msgid "Current directory status:"
        msgstr ""
        msgid "There is {count} file in the directory."
        msgid_plural "There are {count} files in the directory."
        msgstr [0] ""
        msgstr [1] ""

    ''')

print (f".pot 模板生成完成：{pot_path}")

运行该脚本生成myapp.pot。

步骤4：编写.po翻译文件

基于myapp.pot创建中文翻译文件locale/zh_CN/LC_MESSAGES/myapp.po，填写msgstr（翻译内容）：

# 中文翻译文件：myapp.po

msgid ""
msgstr ""
"Content-Type: text/plain; charset=UTF-8\n"
"Language: zh_CN\n"
"Plural-Forms: nplurals=1; plural=0;\n"  # 中文复数规则：1种形式（无单复数差异）
msgid "=== Welcome to the File Manager ==="
msgstr "=== 欢迎使用文件管理器 ==="
msgid "Please select an operation:"
msgstr "请选择操作："
msgid "List files"
msgstr "列出文件"
msgid "Create file"
msgstr "创建文件"
msgid "Delete file"
msgstr "删除文件"
msgid "Current directory status:"
msgstr "当前目录状态："
msgid "There is {count} file in the directory."
msgid_plural "There are {count} files in the directory."
msgstr[0] "目录中有 {count} 个文件。"  # 中文无复数，仅需填写msgstr[0]

关键说明：

• Plural-Forms：定义复数规则，格式为nplurals=N; plural=EXP，其中：
  • nplurals：该语言的复数形式数量（如英文 2 种，中文 1 种，阿拉伯语 6 种）；
  • plural=EXP：根据数量n返回对应的复数索引（如英文plural=n!=1，n=1 返回 0，n!=1 返回 1）。
• 编码声明：必须指定charset=UTF-8，避免中文乱码。

步骤 5：编译.po 为.mo 二进制文件

将myapp.po编译为myapp.mo（二进制文件，加载更快）：

• 方式 1：使用系统msgfmt工具：

# 进入zh_CN/LC_MESSAGES目录
cd locale/zh_CN/LC_MESSAGES
msgfmt myapp.po -o myapp.mo

• 方式 2：使用 Python API 编译：

# compile_mo.py
import gettext
from pathlib import Path

# .po文件路径
po_path = Path("./locale/zh_CN/LC_MESSAGES/myapp.po")

# .mo输出路径
mo_path = po_path.with_suffix(".mo")

# 读取.po文件并编译为.mo
with open(po_path, "r", encoding="utf-8") as po_file:
   catalog = gettext.catalog(po_file)
   with open(mo_path, "wb") as mo_file:
       catalog.write_mo(mo_file)

print(f".mo文件编译完成：{mo_path}")

步骤 6：运行多语言版本

通过命令行参数指定语言，运行应用：

# 英文版本（默认）
python app.py en

# 中文版本
python app.py zh_CN

中文版本运行效果：

=== 欢迎使用文件管理器 ===

请选择操作：
1. 列出文件
2. 创建文件
3. 删除文件

当前目录状态：
目录中有 5 个文件。

二、区域配置基础：locale 模块（文化习惯适配）

locale模块负责管理系统区域设置，定义了特定地区的文化习惯，包括：字符编码、数字格式（如千位分隔符）、货币符号、日期时间格式、 collation（字符串排序规则）等。它是datetime、numbers等模块实现本地化格式的基础，同时也为gettext提供语言自动检测能力（如读取系统默认语言）。

1. 核心概念：区域标识（Locale Identifier）

locale的所有操作基于 “区域标识”，不同平台的标识格式略有差异，但遵循语言_地区.编码的核心结构：

• Linux/macOS：如zh_CN.UTF-8（中文 - 中国 - UTF8 编码）、en_US.UTF-8（英文 - 美国 - UTF8）、fr_FR.ISO-8859-1（法语 - 法国 - ISO8859-1 编码）；
• Windows：如zh-CN（中文 - 中国）、en-US（英文 - 美国）、fr-FR（法语 - 法国）（无编码后缀，默认使用系统编码）。

Python 的locale模块可通过locale.getdefaultlocale()获取系统默认区域标识，或通过locale.setlocale()手动设置。

2. 核心 API 与功能分类

locale模块的功能可分为 “区域设置”“格式本地化”“信息查询” 三类，覆盖区域配置的全需求：

（1）区域设置 API

函数	作用说明	示例
locale.setlocale(category, locale=None)	设置指定类别的区域规则，category指定配置维度（如数字、时间），locale为区域标识	locale.setlocale(locale.LC_ALL, "zh_CN.UTF-8")（设置所有类别为中文）
locale.getlocale(category=None)	获取指定类别的当前区域标识	locale.getlocale(locale.LC_NUMERIC)（获取数字格式的区域）
locale.getdefaultlocale()	获取系统默认区域标识（返回(语言, 编码)元组）	('zh_CN', 'UTF-8')
locale.resetlocale(category=None)	重置指定类别的区域为默认值	locale.resetlocale(locale.LC_TIME)（重置时间格式为默认）

关键category值说明（配置维度）：

• LC_ALL：配置所有维度（数字、时间、货币、排序等），简化设置；
• LC_NUMERIC：数字格式（千位分隔符、小数点符号）；
• LC_MONETARY：货币格式（货币符号、货币位置）；
• LC_TIME：日期时间格式（月份名称、星期名称、顺序）；
• LC_COLLATE：字符串排序规则（如中文拼音排序、法语重音字符排序）；
• LC_MESSAGES：系统消息语言（影响gettext自动检测，但 Python 中gettext通常手动设置）。

（2）格式本地化 API

将数字、货币、日期等转换为符合区域习惯的字符串格式：

函数	作用说明	示例（中文区域）
locale.format_string(format, val, grouping=False)	按区域规则格式化字符串，grouping=True启用千位分隔符	locale.format_string("%.2f", 12345.67, grouping=True) → 12,345.67
locale.currency(val, symbol=True, grouping=False)	格式化货币，symbol=True显示货币符号	locale.currency(1234.56) → ￥1,234.56
locale.strftime(format, time_tuple)	按区域规则格式化日期时间（类似time.strftime，但支持本地化文本）	locale.strftime("%B %d, %Y") → 八月 15, 2024

（3）信息查询 API

获取当前区域的详细配置信息（如货币符号、月份名称）：

函数	作用说明	示例（中文区域）
locale.localeconv()	返回当前区域的详细配置字典，包含数字、货币、时间等规则	locale.localeconv()['int_curr_symbol'] → CNY（人民币国际符号）
locale.nl_langinfo(key)	获取指定 key 的本地化信息（如月份名称、星期名称），仅 Linux/macOS 支持	locale.nl_langinfo(locale.MON_1) → 一月

3. 实战示例：区域格式本地化

需求：基于不同区域（中文、英文、法语），展示数字、货币、日期的本地化格式差异，理解locale模块的实际作用。

import locale
import time
from datetime import datetime

def demo_locale_formats(target_locale):
   """演示指定区域的格式本地化"""
   print(f"=== 区域：{target_locale} ===")

   try:
       # 1. 设置区域（LC_ALL：所有维度）
       locale.setlocale(locale.LC_ALL, target_locale)
   except locale.Error as e:
       print(f"区域设置失败：{e}（可能该区域未安装）")
       return

   # 2. 数字格式（千位分隔符）
   number = 1234567.89
   formatted_num = locale.format_string("%.2f", number, grouping=True)
   print(f"数字格式：{number} → {formatted_num}")

   # 3. 货币格式
   money = 9876.54
   formatted_money = locale.currency(money, grouping=True)
   print(f"货币格式：{money} → {formatted_money}")

   # 4. 日期时间格式（本地化月份/星期名称）
   now = datetime.now()
   # %B：完整月份名称，%A：完整星期名称，%Y：4位年份
   formatted_date = locale.strftime("%A, %B %d, %Y", now.timetuple())
   print(f"日期格式：{now.strftime('%Y-%m-%d %A')} → {formatted_date}")

   # 5. 字符串排序（不同区域的排序规则差异）
   words = ["apple", "Banana", "cherry", "Äpfel"]  # Äpfel是德语“苹果”复数
   sorted_words = sorted(words, key=locale.strxfrm)  # strxfrm：按区域规则转换字符串用于排序
   print(f"字符串排序：{words} → {sorted_words}\n")

   # 重置区域为默认（避免影响后续代码）
   locale.resetlocale(locale.LC_ALL)



# 测试不同区域
if __name__ == "__main__":
   # 注意：Windows需使用"zh-CN"，Linux/macOS使用"zh_CN.UTF-8"
   # 自动适配平台的区域标识

   import platform
   if platform.system() == "Windows":
       locales = ["zh-CN", "en-US", "fr-FR"]
   else:
       locales = ["zh_CN.UTF-8", "en_US.UTF-8", "fr_FR.UTF-8"]

   for loc in locales:
       demo_locale_formats(loc)

Linux/macOS 运行效果：

=== 区域：zh_CN.UTF-8 ===
数字格式：1234567.89 → 1,234,567.89
货币格式：9876.54 → ￥9,876.54
日期格式：2024-08-15 Thursday → 星期四, 八月 15, 2024
字符串排序：['apple', 'Banana', 'cherry', 'Äpfel'] → ['apple', 'Banana', 'cherry', 'Äpfel']

=== 区域：en_US.UTF-8 ===
数字格式：1234567.89 → 1,234,567.89
货币格式：9876.54 → $9,876.54
日期格式：2024-08-15 Thursday → Thursday, August 15, 2024
字符串排序：['apple', 'Banana', 'cherry', 'Äpfel'] → ['Äpfel', 'Banana', 'apple', 'cherry']

=== 区域：fr_FR.UTF-8 ===
数字格式：1234567.89 → 1 234 567,89  # 法语用逗号作为小数点，空格作为千位分隔符
货币格式：9876.54 → 9 876,54 €    # 欧元符号在末尾，空格分隔千位
日期格式：2024-08-15 Thursday → jeudi, août 15, 2024  # 法语星期/月份名称
字符串排序：['apple', 'Banana', 'cherry', 'Äpfel'] → ['apple', 'Banana', 'cherry', 'Äpfel']

关键差异说明：

• 数字格式：法语用逗号（,）作为小数点，空格作为千位分隔符，与中文 / 英文不同；
• 货币格式：中文显示￥在开头，英文$在开头，法语€在末尾；
• 排序规则：英文区域中，Ä会被视为A的变体，排序在Banana之前，而中文 / 法语区域按 ASCII 顺序排序。

4. 跨平台兼容问题与解决方案

locale模块的最大痛点是跨平台差异（Windows 与 Linux/macOS 的区域标识格式、支持的区域列表不同），需针对性处理：

（1）区域标识格式适配

Windows 使用语言-地区（如zh-CN），Linux/macOS 使用语言_地区.编码（如zh_CN.UTF-8），可通过platform模块自动适配：

import platform
import locale

def set_platform_locale(lang_code):
   """根据平台自动设置区域标识（lang_code：如"zh_CN"、"en_US"）"""
   if platform.system() == "Windows":
       # Windows格式：将"zh_CN"转为"zh-CN"
       locale_id = lang_code.replace("_", "-")
   else:
       # Linux/macOS格式：添加.UTF-8编码
       locale_id = f"{lang_code}.UTF-8"

   try:
       locale.setlocale(locale.LC_ALL, locale_id)
       print(f"成功设置区域：{locale_id}")
   except locale.Error:
       # 若指定编码未找到，尝试无编码版本（如Linux的"zh_CN"）
       try:
           locale.setlocale(locale.LC_ALL, lang_code)
           print(f"成功设置区域（无编码）：{lang_code}")
       except locale.Error as e:
           print(f"区域设置失败：{e}")

# 测试
set_platform_locale("zh_CN")  # Windows→zh-CN，Linux→zh_CN.UTF-8
set_platform_locale("en_US")

（2）区域安装检查

部分系统可能未安装目标区域（如 Linux 最小系统可能没有fr_FR），需捕获locale.Error并提供 fallback：

def safe_set_locale(category, target_locale, fallback_locale="C"):
   """安全设置区域，失败时使用fallback（"C"为默认无本地化格式）"""

   try:
       locale.setlocale(category, target_locale)
   except locale.Error:
       print(f"区域{target_locale}不可用，使用fallback：{fallback_locale}")
       locale.setlocale(category, fallback_locale)

# 测试：尝试设置法语，失败则用默认
safe_set_locale(locale.LC_ALL, "fr_FR.UTF-8", "en_US.UTF-8")

三、时间本地化：datetime 模块（多语言时间格式）

datetime模块本身不直接处理国际化，但依赖locale模块的LC_TIME配置，实现日期时间的多语言格式（如中文 “八月”、英文 “August”、法语 “août”）。其核心是strftime()方法结合locale设置，实现本地化的时间文本显示。

1. 核心功能：本地化时间格式化

datetime.datetime.strftime(format)支持与locale联动的格式化指令，关键指令如下（带本地化文本）：

指令	作用说明	中文区域示例	英文区域示例
%a	abbreviated 星期名称（缩写）	周四	Thu
%A	完整星期名称	星期四	Thursday
%b	abbreviated 月份名称（缩写）	8 月	Aug
%B	完整月份名称	八月	August
%p	上 / 下午标识（12 小时制）	下午	PM

注意：strftime()的本地化效果依赖locale.setlocale(locale.LC_TIME, ...)的设置，若未设置区域，将使用默认的 “C” 区域（无本地化，显示英文）。

2. 实战示例：多语言时间显示

需求：根据用户选择的语言（中文、英文、日语），显示本地化的日期时间格式，包括完整 / 缩写的月份、星期。

import locale
from datetime import datetime
import platform

def init_time_locale(lang_code):
   """初始化时间格式的区域（lang_code：zh_CN、en_US、ja_JP）"""

   # 适配平台的区域标识
   if platform.system() == "Windows":
       locale_id = lang_code.replace("_", "-")
   else:
       locale_id = f"{lang_code}.UTF-8"

   # 仅设置LC_TIME类别（不影响其他格式如数字）

   try:
       locale.setlocale(locale.LC_TIME, locale_id)
       return True

   except locale.Error as e:
       print(f"时间区域设置失败：{e}")
       return False

def format_localized_time(lang_code):
   """格式化本地化时间"""
   if not init_time_locale(lang_code):
       return
   now = datetime.now()
   # 定义多种格式化模板
   formats = [
       ("%Y年%m月%d日 %A %H:%M:%S", "完整格式（年-月-日 星期 时:分:秒）"),
       ("%B %d, %Y", "月份名称+日期+年份"),
       ("%a, %b %d %H:%M", "缩写星期+缩写月份+日期+时间"),
       ("%p %I:%M", "上/下午标识+12小时制时间")
   ]

   print(f"\n=== 时间本地化（{lang_code}） ===")

   for fmt, desc in formats:
       formatted = now.strftime(fmt)
       print(f"{desc}：{formatted}")


# 测试不同语言
if __name__ == "__main__":
   format_localized_time("zh_CN")   # 中文：八月 15, 2024 → 2024年08月15日 星期四 14:30:00
   format_localized_time("en_US")   # 英文：August 15, 2024 → Thursday, Aug 15 14:30
   format_localized_time("ja_JP")   # 日语：8月 15, 2024 → 木, 8月 15 14:30（木=星期四）

日语区域运行效果：

=== 时间本地化（ja_JP） ===

完整格式（年-月-日 星期 时:分:秒）：2024年08月15日 木曜日 14:30:00

月份名称+日期+年份：8月 15, 2024

缩写星期+缩写月份+日期+时间：木, 8月 15 14:30

上/下午标识+12小时制时间：午後 02:30

四、数字本地化：numbers 模块（多语言数字格式）

numbers模块是 Python 3.10 + 新增的模块，专门用于数字的本地化格式化（如百分比、科学计数法、分数），基于locale模块的LC_NUMERIC配置，提供更面向对象的 API，比locale.format_string()更灵活。

1. 核心类与功能

numbers模块提供 4 个核心格式化类，覆盖不同数字类型的本地化需求：

类名	作用说明	示例（中文区域）
numbers.NumberFormatter	通用数字格式化（整数、浮点数）	format(12345.67) → 12,345.67
numbers.PercentFormatter	百分比格式化	format(0.123) → 12.30%
numbers.ScientificFormatter	科学计数法格式化	format(12345) → 1.23×10⁴
numbers.FractionFormatter	分数格式化（需fractions模块）	format(Fraction(3, 4)) → 3/4

这些类的构造函数可指定locale参数（区域标识），无需全局设置locale.setlocale()，更适合多线程场景（全局locale非线程安全）。

2. 实战示例：多语言数字格式化

需求：对比中文、英文、法语区域的数字、百分比、科学计数法格式差异，使用numbers模块实现，避免全局locale设置。

from numbers import NumberFormatter, PercentFormatter, ScientificFormatter
from fractions import Fraction
import platform

def get_platform_locale(lang_code):
   """根据平台获取区域标识（适配Windows/Linux）"""
   if platform.system() == "Windows":
       return lang_code.replace("_", "-")
   else:
       return f"{lang_code}.UTF-8"

def demo_numbers_localization(lang_code):
   """演示指定语言的数字格式化"""
   locale_id = get_platform_locale(lang_code)
   print(f"=== 数字本地化（{lang_code} → {locale_id}） ===")

   # 1. 通用数字格式化
   num_formatter = NumberFormatter(locale=locale_id)
   number = 123456.789
   print(f"通用数字：{number} → {num_formatter.format(number)}")

   # 2. 百分比格式化（保留2位小数）
   percent_formatter = PercentFormatter(locale=locale_id, precision=2)
   percent = 0.1234
   print(f"百分比：{percent} → {percent_formatter.format(percent)}")

   # 3. 科学计数法格式化（保留2位有效数字）
   sci_formatter = ScientificFormatter(locale=locale_id, precision=2)
   large_num = 123456789

   print(f"科学计数法：{large_num} → {sci_formatter.format(large_num)}")

   # 4. 分数格式化
   frac_formatter = numbers.FractionFormatter(locale=locale_id)
   fraction = Fraction(5, 8)
   print(f"分数：{fraction} → {frac_formatter.format(fraction)}\n")


# 测试不同语言
if __name__ == "__main__":
   # 注意：需确保系统安装了对应区域（如法语fr_FR、日语ja_JP）
   demo_numbers_localization("zh_CN")
   demo_numbers_localization("en_US")
   demo_numbers_localization("fr_FR")

运行效果（Linux 平台）：

=== 数字本地化（zh_CN → zh_CN.UTF-8） ===
通用数字：123456.789 → 123,456.79
百分比：0.1234 → 12.34%
科学计数法：123456789 → 1.23×10⁸
分数：5/8 → 5/8

=== 数字本地化（en_US → en_US.UTF-8） ===
通用数字：123456.789 → 123,456.79
百分比：0.1234 → 12.34%
科学计数法：123456789 → 1.23×10⁸
分数：5/8 → 5/8

=== 数字本地化（fr_FR → fr_FR.UTF-8） ===
通用数字：123456.789 → 123 456,79  # 空格千位分隔符，逗号小数点
百分比：0.1234 → 12,34 %         # 逗号小数点，空格分隔百分比符号
科学计数法：123456789 → 1,23×10⁸  # 逗号小数点
分数：5/8 → 5/8

关键优势：

• 无需全局设置locale：numbers类的locale参数可独立指定区域，避免影响其他模块；
• 线程安全：全局locale.setlocale()是非线程安全的（多线程同时设置会冲突），而numbers类的实例化方式支持多线程独立配置；
• 精细化控制：通过precision参数控制小数位数，比locale.format_string()更灵活。

五、国际化项目最佳实践

结合 Python 标准库的 i18n 能力，构建多语言项目需遵循标准化流程，兼顾开发效率与可维护性：

1. 目录结构规范

多语言项目的目录结构需清晰，分离代码、翻译文件、资源文件，示例如下：

global_app/                # 项目根目录
├── app/                   # 代码目录
│   ├── __init__.py
│   ├── main.py            # 主程序（标记待翻译文本）
│   └── utils/             # 工具函数（如i18n初始化）
├── locale/                # 翻译文件目录（gettext）
│   ├── myapp.pot          # 模板文件
│   ├── zh_CN/             # 中文
│   │   └── LC_MESSAGES/
│   │       ├── myapp.po
│   │       └── myapp.mo
│   ├── en_US/             # 英文
│   │   └── LC_MESSAGES/
│   │       ├── myapp.po
│   │       └── myapp.mo
│   └── fr_FR/             # 法语
│       └── LC_MESSAGES/
│           ├── myapp.po
│           └── myapp.mo
├── static/                # 静态资源（多语言图片、配置）
│   ├── zh_CN/
│   │   └── logo.png       # 中文版本logo（如有）
│   └── en_US/
│       └── logo.png
└── scripts/               # 辅助脚本
   ├── extract_pot.py     # 提取.pot模板
   └── compile_mo.py      # 编译.po为.mo

2. 代码标记规范

• 统一标记函数：始终使用_()标记待翻译文本，避免混用gettext()（保持代码一致性）；
• 避免硬编码变量：待翻译文本需为字符串字面量，不可为变量（如_("Hello " + name)无效，应改为_("Hello {name}").format(name=name)）；
• 复数规则统一：使用ngettext(singular, plural, n)处理所有复数场景，即使目标语言无复数差异（如中文），确保兼容性；
• 注释辅助翻译：对模糊文本添加注释，帮助翻译者理解上下文（如# 按钮文本：退出应用 + _("Quit")）。

3. 翻译文件管理

• 使用专业工具：推荐用 Poedit（跨平台）或 OmegaT 管理.po 文件，自动处理复数规则、编码，避免手动编辑格式错误；
• 版本控制：将.pot 和.po 文件纳入 Git 版本控制（.mo 文件可忽略，通过脚本编译生成）；
• 翻译审核：建立翻译审核流程，确保术语一致性（如 “文件管理器” 统一译为 “File Manager”，而非 “Document Manager”）。

4. 多语言切换与加载

• 优先用户设置：应用启动时，优先读取用户保存的语言设置（如配置文件、数据库），其次读取系统默认语言（locale.getdefaultlocale()）；
• 延迟加载翻译：大型应用可延迟加载非默认语言的.mo 文件（如用户切换语言时再加载），减少启动时间；
• 缓存翻译实例：Translations实例加载后缓存，避免重复读取.mo 文件（提升性能）。

5. 常见问题解决方案

（1）中文乱码

• 确保.po 文件的Content-Type为charset=UTF-8；
• 代码中读取翻译文件时指定encoding="utf-8"（gettext.translation()默认 UTF-8，无需额外设置）；
• Windows 终端运行时，需设置终端编码为 UTF-8（chcp 65001）。

（2）复数规则错误

• 每个.po 文件的Plural-Forms必须正确（如中文nplurals=1; plural=0，英文nplurals=2; plural=n!=1）；
• 使用msgfmt --check检查.po 文件的复数规则语法错误。

（3）线程安全

• 全局locale.setlocale()是非线程安全的，多线程应用应：

1. 避免全局设置LC_ALL，仅在需要时设置特定类别（如LC_TIME）；
2. 使用numbers模块的类式 API（独立locale参数），而非locale.format_string()；
3. 对gettext，每个线程独立创建Translations实例，避免共享全局_()函数。

六、总结

Python 3.13.7 标准库的国际化模块构建了 “文本翻译（gettext）→区域配置（locale）→格式本地化（datetime/numbers）” 的完整技术栈，具备无第三方依赖、遵循国际规范、适配多平台的优势，可满足中大型应用的基础多语言需求：

• 核心能力：gettext实现文本翻译解耦，locale定义区域文化规则，datetime/numbers基于区域规则实现格式本地化；
• 适用场景：企业内部系统、工具类应用、中小型 Web 服务（如 Flask/Django 的多语言扩展底层依赖这些模块）；
• 局限性：复杂复数规则（如阿拉伯语 6 种复数形式）、ICU 格式（如日期范围格式化）需依赖第三方库Babel，大型全球化产品可结合Babel增强能力。

掌握这些模块的核心用法，不仅能快速构建多语言应用，还能深入理解国际化的底层逻辑（如文本翻译流程、区域规则适配），为后续集成更复杂的全球化功能（如右 - to-left 语言、时区本地化）打下基础。