为了使 Django 项目可以翻译，你需要在 Python 代码和模板中添加少量钩子。这些钩子被成为 translation strings 。它们告知Django：如果在终端用户语言里，这个文本有对应的翻译，那么应该使用翻译。标记字符串是你的职责，系统只会翻译它知道的字符串。
\n然后 Django 提供工具将翻译字符串提取到 message file 中。这个文件让翻译者方便地提供翻译字符串。一旦翻译者填写了 message file ，就必须编译它。这个过程依赖 GNU gettext 工具集。
\n完成后，Django 会根据用户的语言偏好，使用每种可用语言对网页进行即时翻译。
\nDjango 的国际化钩子默认是开启的，这意味着在框架的某些位置存在一些 i18n 相关的开销。如果你不使用国际化，你应该在配置文件里设置 USE_I18N = False 。然后 Django 将进行优化，以免加载国际化机制。
使用函数 gettext() 来指定翻译字符串。按照惯例，将其作为下划线( _ )导入，以保存输入。
在这个例子里，文本 "Welcome to my site." 被标记为翻译字符串：
from django.http import HttpResponse\nfrom django.utils.translation import gettext as _\n\ndef my_view(request):\n output = _("Welcome to my site.")\n return HttpResponse(output)\n代码里可以不使用别名。这个例子与上一个例子等同：
\nfrom django.http import HttpResponse\nfrom django.utils.translation import gettext\n\ndef my_view(request):\n output = gettext("Welcome to my site.")\n return HttpResponse(output)\n翻译适用于计算值。这个例子与前面两个例子等同：
\ndef my_view(request):\n words = ['Welcome', 'to', 'my', 'site.']\n output = _(' '.join(words))\n return HttpResponse(output)\n翻译适用于变量。同样，这个例子和上面的等同：
\ndef my_view(request):\n sentence = 'Welcome to my site.'\n output = _(sentence)\n return HttpResponse(output)\n(像上述两个例子那样，使用变量或计算值的警告是： Django 的翻译字符检测实用程序 django-admin makemessages 不能找到这些字符串。更多细节在稍后的 makemessages 介绍。)
传递到 _() or gettext() 的字符串可以使用占位符，这是 Python 标准命名字符串插值语法指定的。例如：
def my_view(request, m, d):\n output = _('Today is %(month)s %(day)s.') % {'month': m, 'day': d}\n return HttpResponse(output)\n这是技巧使得特定语言翻译可以重新排序占位符字段。比如，一条英文翻译可能是 "Today is November 26." ，而对于西班牙翻译可能就是 "Hoy es 26 de noviembre." ——其中月份和日期占位符互相交换。
所以，当你有多个参数的时候，你应该使用命名字符串插值（比如 %(day)s ）而不是位置插值（比如 %s 或 %d ）。如果你使用位置插值，翻译时就不会对占位符字段重新排序。
\n因为字符串提取由 xgettext 命令行完成，Django 仅支持由 gettext 支持的语法。特别是，xgettext 尚未支持 Python f-strings ，而 JavaScript 模板字符串需要 gettext 0.21+ 。
如果你想为翻译者提供一些翻译字段的提示，你可以添加以 Translators 为前缀的注释。例如：
def my_view(request):\n # Translators: This message appears on the home page only\n output = gettext("Welcome to my site.")\n这个注释将出现在 .po 文件中与所翻译词条相关的词条下方，并且也应该由大部分翻译工具显示。
这个办法在模板里也同样适用。查看 模板内对翻译的注释 来获取更多详情。
\n使用 django.utils.translation.gettext_noop() 来将字符串标记不用翻译的翻译字符串。这个字符会稍后使用变量来翻译。
使用该方法的场景是：如果你有一个常量字符串，该字符串以源语言存储，它们通过系统或用户进行交换（比如数据库里的字符串），但应该最后可能的时间点进行翻译，比如当字符串展示给用户时。
\n使用 django.utils.translation.ngettext() 函数指定多元化信息。
ngettext() 带有三个参数：单数翻译字符串，复数翻译字符串和一些对象。
当你需要 Django 应用本地化为复数形式的数量和复杂度大于英语中使用的两种形式的语言时，该函数非常有用。（'object' 表示单数，'objects' 表示 count 不同于1时的所有情况，不论其值如何）
例如:
\nfrom django.http import HttpResponse\nfrom django.utils.translation import ngettext\n\ndef hello_world(request, count):\n page = ngettext(\n 'there is %(count)d object',\n 'there are %(count)d objects',\n count) % {\n 'count': count,\n }\n return HttpResponse(page)\n在这个例子里，对象的数量作为 count 变量传递给翻译语言。
\n要注意复数形式是复杂的，并且在每种语言中工作方式不同。比较 count 和 1 并不总是正确的规则。该代码看着很复杂，但会对某些语言产生不正确的结果：
\nfrom django.utils.translation import ngettext\nfrom myapp.models import Report\n\ncount = Report.objects.count()\nif count == 1:\n name = Report._meta.verbose_name\nelse:\n name = Report._meta.verbose_name_plural\n\ntext = ngettext(\n 'There is %(count)d %(name)s available.',\n 'There are %(count)d %(name)s available.',\n count\n) % {\n 'count': count,\n 'name': name\n}\n不要尝试实现自定义的单数或复数逻辑，它会出错的。像在这种例子中，请考虑以下内容：
\ntext = ngettext(\n 'There is %(count)d %(name)s object available.',\n 'There are %(count)d %(name)s objects available.',\n count\n) % {\n 'count': count,\n 'name': Report._meta.verbose_name,\n}\n一些词组有很多不同含义，比如 "May" ，它指五月或者表示一个动词。为了使翻译者在不同上下文中正确翻译这些词组，可以使用 django.utils.translation.pgettext() 函数，或者如果字符串需要复数形式的话，可以使用 django.utils.translation.npgettext() 函数。两者都使用上下文字符串作为第一个变量。
在生成的 .po 文件中，字符串将会频繁出现，因为相同字符串 ( 上下文将在 msgctxt 行上显示) 有不同的上下文标记，所以允许翻译者为每个字符串给出不同翻译。
例如:
\nfrom django.utils.translation import pgettext\n\nmonth = pgettext("month name", "May")\n或者：
\nfrom django.db import models\nfrom django.utils.translation import pgettext_lazy\n\nclass MyThing(models.Model):\n name = models.CharField(help_text=pgettext_lazy(\n 'help text for MyThing model', 'This is the help text'))\n将以下方形式出现在 .po 文件中：
msgctxt "month name"\nmsgid "May"\nmsgstr ""\nContextual markers are also supported by the trans and\nblocktrans template tags.
当访问值而不是调用它们时，使用 django.utils.translation 中翻译函数的惰性版本 (在名称中加入 lazy 前缀来识别) 来延迟翻译字符串。
这些函数存储对字符串的惰性引用 —— 并非真实的翻译。当在字符串上下文里使用字符串时，才会翻译。比如模板渲染。
\n当对这些函数的调用位于模块加载时执行的代码路径中时，这一点非常重要。
\n在定义模型、表单和模型表单的时候，很容易遇见这种情况，因为 Django 已经实现了这些，所以它们的字段实际是类级别的属性。因此，请确保以下情况下使用惰性翻译：
\nverbose_name 与 help_text 选项值Link to this heading#比如下面这个模型，为了翻译其中 name 字段的帮助提示，可以这么做：
\nfrom django.db import models\nfrom django.utils.translation import gettext_lazy as _\n\nclass MyThing(models.Model):\n name = models.CharField(help_text=_('This is the help text'))\n你可以通过使用 verbose_name 选项来将 ForeignKey, ManyToManyField 或 OneToOneField 关系标记为可翻译：
class MyThing(models.Model):\n kind = models.ForeignKey(\n ThingKind,\n on_delete=models.CASCADE,\n related_name='kinds',\n verbose_name=_('kind'),\n )\n就像你在 verbose_name 中所做的那样，你应该为关系提供一个小写的详细名称文本，因为 Django 会在需要时自动为其命名。
建议始终提供显式的 verbose_name 和 verbose_name_plural 选项，而不是依赖 Django 查看模型的类名来确定以英文为主而且有点简单的详细名称：
from django.db import models\nfrom django.utils.translation import gettext_lazy as _\n\nclass MyThing(models.Model):\n name = models.CharField(_('name'), help_text=_('This is the help text'))\n\n class Meta:\n verbose_name = _('my thing')\n verbose_name_plural = _('my things')\nshort_description 的属性值Link to this heading#对于模型方法，可以使用 short_description 属性来为 Django 和 admin管理后台提供翻译：
from django.db import models\nfrom django.utils.translation import gettext_lazy as _\n\nclass MyThing(models.Model):\n kind = models.ForeignKey(\n ThingKind,\n on_delete=models.CASCADE,\n related_name='kinds',\n verbose_name=_('kind'),\n )\n\n def is_mouse(self):\n return self.kind.type == MOUSE_TYPE\n is_mouse.short_description = _('Is it a mouse?')\ngettext_lazy() 调用的结果可以在其他 Django 代码使用字符串( str 对象)的任何地方使用，但它可能不适用于任何 Python 代码。比如，下面这种情况就不行，因为 requests 库不会处理 gettext_lazy 对象：
body = gettext_lazy("I \\u2764 Django") # (unicode :heart:)\nrequests.post('https://example.com/send', data={'body': body})\n要想避免这些问题，你可以在文本字符传递给非 Django 代码之前，将 gettext_lazy() 对象转换为文本字符。
requests.post('https://example.com/send', data={'body': str(body)})\n如果你觉得 gettext_lazy 这个名字有点长，你可以定义它的别名为下划线 _ ，像这样：
from django.db import models\nfrom django.utils.translation import gettext_lazy as _\n\nclass MyThing(models.Model):\n name = models.CharField(help_text=_('This is the help text'))\n在模型和工具函数里使用 gettext_lazy() 和 ngettext_lazy() 来标记字符串是个常用方法。但在代码的其他地方使用这些对象时，你要确保它们不会被不小心转化为字符串，因为它们要尽量晚一些被转换（以便正确的语言环境生效）。这需要使用下面所描述的帮助函数。
当为复数字符串 (n[p]gettext_lazy) 使用惰性翻译时，通常不知道字符串定义时 number 参数值。因此，你可以传递一个关键字名称来作为 number 参数而不是整数。然后，在插值期间，会在字典里查找 number。例如：
from django import forms\nfrom django.utils.translation import ngettext_lazy\n\nclass MyForm(forms.Form):\n error_message = ngettext_lazy("You only provided %(num)d argument",\n "You only provided %(num)d arguments", 'num')\n\n def clean(self):\n # ...\n if error:\n raise forms.ValidationError(self.error_message % {'num': number})\n如果字符串恰好包含一个未命名的占位符，你可以直接插入 number 参数：
class MyForm(forms.Form):\n error_message = ngettext_lazy(\n "You provided %d argument",\n "You provided %d arguments",\n )\n\n def clean(self):\n # ...\n if error:\n raise forms.ValidationError(self.error_message % number)\nformat_lazy()Link to this heading#当 format_string 或 str.format() 的任何参数包含惰性转换对象时，Python的 str.format() 方法将不起作用。相反，你可以使用 django.utils.text.format_lazy() ，它会创建一个仅当结果包含在字符串里时会才运行 str.format() 的惰性对象。比如：
from django.utils.text import format_lazy\nfrom django.utils.translation import gettext_lazy\n...\nname = gettext_lazy('John Lennon')\ninstrument = gettext_lazy('guitar')\nresult = format_lazy('{name}: {instrument}', name=name, instrument=instrument)\n在这种情况下，在 result 中的惰性翻译仅在字符串(通常在模板渲染时间)里使用 result 时才会被转换成字符串。
对于“你想延迟翻译，但不得不传递要翻译的字符串作为参数到其他函数”的情况，你可以在惰性调用中包装这个函数。比如：
\nfrom django.utils.functional import lazy\nfrom django.utils.safestring import mark_safe\nfrom django.utils.translation import gettext_lazy as _\n\nmark_safe_lazy = lazy(mark_safe, str)\n然后：
\nlazy_string = mark_safe_lazy(_("<p>My <strong>string!</strong></p>"))\nget_language_info() 函数提供关于语言的详细信息：
>>> from django.utils.translation import activate, get_language_info\n>>> activate('fr')\n>>> li = get_language_info('de')\n>>> print(li['name'], li['name_local'], li['name_translated'], li['bidi'])\nGerman Deutsch Allemand False\n字典的 name, name_local, 以及 name_translated 属性分别包含用英语、该语言本身以及当前启用的语言的名称。bidi 属性仅对于双向(bi-directional)语言为 True 。
语言信息的来源是 django.conf.locale 模块。模板代码也可以使用类似方式访问信息。
Django templates 中的翻译使用两个模板标签，并且语法与 Python 代码中的语法略有不同。要使模板访问这些标签，需要在模板顶部加入 {% load i18n %} 。与所有模板标签一样，这个标签需要在所有需要翻译的模板中加载，甚至那些从其他模板继承(extend)而来的模板，也需要继承 i18n 标签。
trans 模板标签Link to this heading#{% trans %} 模板标签可翻译常量字符串(用单引号或双引号括起来)或变量内容：
<title>{% trans "This is the title." %}</title>\n<title>{% trans myvar %}</title>\n如果存在 noop 选项，则变量查找仍会发生，但会跳过翻译。这在“剔除”将来需要翻译的内容时非常有用：
<title>{% trans "myvar" noop %}</title>\n在内部，内联翻译使用 gettext() 调用。
如果模板变量（如上面的 myvar ）传递给了一个标签，该标签将在运行时首先将这些变量解析为字符串，然后在消息目录里查找变量。
无法在 {% trans %} 的字符串内混合模板变量。如果你的翻译需要带有变量的字符串，可以使用 {% blocktrans %} 来代替。
如果你想检索翻译的字符串而不显示它，那你可以使用下面的语法：
\n{% trans "This is the title" as the_title %}\n\n<title>{{ the_title }}</title>\n<meta name="description" content="{{ the_title }}">\n事实上你可以使用这个办法来获取一个在模板中多处使用的字符串，或将输出作为其他模板标签或过滤器的参数：
\n{% trans "starting point" as start %}\n{% trans "end point" as end %}\n{% trans "La Grande Boucle" as race %}\n\n<h1>\n <a href="/" title="{% blocktrans %}Back to '{{ race }}' homepage{% endblocktrans %}">{{ race }}</a>\n</h1>\n<p>\n{% for stage in tour_stages %}\n {% cycle start end %}: {{ stage }}{% if forloop.counter|divisibleby:2 %}<br>{% else %}, {% endif %}\n{% endfor %}\n</p>\n{% trans %} 也支持使用 context 的 contextual markers ：
{% trans "May" context "month name" %}\nblocktrans 模板标签Link to this heading#与 trans 相反，blocktrans 标签允许你使用占位符来标记由文本和可变内容组成的复杂句子，以便进行翻译:
{% blocktrans %}This string will have {{ value }} inside.{% endblocktrans %}\n要翻译模板表达式（比如，访问对象属性或使用模板过滤器），你需要绑定表达式到本地变量，以便在翻译块中使用。例如：
\n{% blocktrans with amount=article.price %}\nThat will cost $ {{ amount }}.\n{% endblocktrans %}\n\n{% blocktrans with myvar=value|filter %}\nThis will have {{ myvar }} inside.\n{% endblocktrans %}\n可以在单个 blocktrans 标签中使用多个表达式：
{% blocktrans with book_t=book|title author_t=author|title %}\nThis is {{ book_t }} by {{ author_t }}\n{% endblocktrans %}\n其他块标签（比如 {% for %} 或 {% if %}）不允许包含在 blocktrans 标签里。
如果解析其中一个块参数失败，blocktrans 将通过使用 deactivate_all() 函数来暂时停用当前活动的语言，回退到默认语言。
该标签也提供复数形式。要使用它：
\n指定并绑定名称为 count 的计数器值。该值将用于选择正确的复数形式。
在 {% blocktrans %} 和 {% endblocktrans %} 标签内使用 {% plural %} 标签分别指定单数和复数形式。
一个例子:
\n{% blocktrans count counter=list|length %}\nThere is only one {{ name }} object.\n{% plural %}\nThere are {{ counter }} {{ name }} objects.\n{% endblocktrans %}\n一个更复杂的例子：
\n{% blocktrans with amount=article.price count years=i.length %}\nThat will cost $ {{ amount }} per year.\n{% plural %}\nThat will cost $ {{ amount }} per {{ years }} years.\n{% endblocktrans %}\n当你同时使用复数特性和将值绑定给除了计数器值之外的局部变量时，要记住 blocktrans 构造在内部转换为 ngettext 调用。这意味着有关ngettext变量的注意事项（notes regarding ngettext variables）同样适用于此。
反向 URL 查找不能在 blocktrans 中执行，应该预先检索（并保存）：
{% url 'path.to.view' arg arg2 as the_url %}\n{% blocktrans %}\nThis is a URL: {{ the_url }}\n{% endblocktrans %}\n如果你想检索翻译的字符串而不显示它，那你可以使用下面的语法：
\n{% blocktrans asvar the_title %}The title is {{ title }}.{% endblocktrans %}\n<title>{{ the_title }}</title>\n<meta name="description" content="{{ the_title }}">\n事实上你可以使用这个办法来获取一个在模板中多处使用的字符串，或将输出作为其他模板标签或过滤器的参数。
\n{% blocktrans %} 也支持使用 context 的 contextual markers ：
{% blocktrans with name=user.username context "greeting" %}Hi {{ name }}{% endblocktrans %}\n{% blocktrans %} 支持的另一个特性是 trimmed 选项。这个选项将删除从 {% blocktrans %} 标签开头到结尾的换行符，替换所有的行首和行位的空格，并且使用空格将所有行合并为一行。这对缩进 {% blocktrans %} 标签的内容非常有用，而且缩进字符不会出现在 PO 文件的相应条目中，这会让翻译过程变得容易。
例如，下面的 {% blocktrans %} 标签：
{% blocktrans trimmed %}\n First sentence.\n Second paragraph.\n{% endblocktrans %}\n如果没有 trimmed 选项，那么 PO 文件中的条目 "First sentence. Second paragraph." 成为 "\\n First sentence.\\n Second sentence.\\n"。
就像 Python 代码一样，对翻译者的提示可以使用注释来标注，使用 comment 标签：
{% comment %}Translators: View verb{% endcomment %}\n{% trans "View" %}\n\n{% comment %}Translators: Short intro blurb{% endcomment %}\n<p>{% blocktrans %}A multiline translatable\nliteral.{% endblocktrans %}</p>\n或者使用 {# ... #} 单行注释：
{# Translators: Label of a button that triggers search #}\n<button type="submit">{% trans "Go" %}</button>\n\n{# Translators: This is a text of the base template #}\n{% blocktrans %}Ambiguous translatable block of text{% endblocktrans %}\n如果想在模板中选择语言，可以使用 language 模板标签：
{% load i18n %}\n\n{% get_current_language as LANGUAGE_CODE %}\n<!-- Current language: {{ LANGUAGE_CODE }} -->\n<p>{% trans "Welcome to our page" %}</p>\n\n{% language 'en' %}\n {% get_current_language as LANGUAGE_CODE %}\n <!-- Current language: {{ LANGUAGE_CODE }} -->\n <p>{% trans "Welcome to our page" %}</p>\n{% endlanguage %}\n第一次出现的 "Welcome to our page" 使用当前语言，后面出现的使用英语。
\n向 JavaScript 添加翻译会带来一些问题：
\nJavaScript 代码无权访问 gettext 实现。
JavaScript 代码无权访问 .po 或 .mo 文件；它们需要通过服务器传递。
JavaScript 的翻译目录应该尽可能小。
Django 为这三个问题提供了解决方案：它将翻译传递给Javascript，因此你可以从 JavaScript 内部调用 gettext 等。
解决这三个问题的主要解决办法是下面的 JavaScriptCatalog 视图，该视图生成一个JavaScript 库，该库具有模仿 gettext 接口的函数，外加一个翻译字符串数组。
JavaScriptCatalog 视图Link to this heading#一个视图，该视图生成一个 JavaScript 代码库，该库带有一个模仿 gettext 界面的函数，外加一个翻译字符串的数组。
属性
\n翻译域包含要添加到视图输出中的字符串。默认为 'djangojs' 。
已安装的应用程序的程序名列表。这些 app 应包含一个 locale 目录。所有这些目录加上 LOCALE_PATHS 里的目录会合并到一个目录里。默认是 None ，意味着在 JavaScript 输出中提供所有来自 INSTALLED_APPS 的可用翻译。
默认值实例 ：
\nfrom django.views.i18n import JavaScriptCatalog\n\nurlpatterns = [\n path('jsi18n/', JavaScriptCatalog.as_view(), name='javascript-catalog'),\n]\n自定义包实例 ：
\nurlpatterns = [\n path('jsi18n/myapp/',\n JavaScriptCatalog.as_view(packages=['your.app.label']),\n name='javascript-catalog'),\n]\n如果你的根 URLconf 使用 i18n_patterns() ，JavaScriptCatalog 也必须被 i18n_patterns() 包装，这样目录才会被正确的生成。
i18n_patterns() 实例：
from django.conf.urls.i18n import i18n_patterns\n\nurlpatterns = i18n_patterns(\n path('jsi18n/', JavaScriptCatalog.as_view(), name='javascript-catalog'),\n)\n后面出现的 packages 参数比前面出现的参数优先级更高。在相同文字出现冲突翻译的时候，这点很重要。
如果你使用多个 JavaScriptCatalog 视图，并且它们中的某些视图定义了相同的字符串，那么最后加载的目录中的字符串拥有优先级。
要使用目录，请像这样引入动态生成的js：
\n<script type="text/javascript" src="{% url 'javascript-catalog' %}"></script>\n这使用反向 URL 查询来查找 JavaScript 目录视图。当加载目录后，JavaScript 代码能使用以下方法：
\ngettext
ngettext
interpolate
get_format
gettext_noop
pgettext
npgettext
pluralidx
gettextLink to this heading#gettext 函数的行为类似于 Python 代码中的标准 gettext 接口：
document.write(gettext('this is to be translated'));\nngettextLink to this heading#ngettext 函数提供一个接口来复数化词组和短语：
const objectCount = 1 // or 0, or 2, or 3, ...\nconst string = ngettext(\n 'literal for the singular case',\n 'literal for the plural case',\n objectCount\n);\ninterpolateLink to this heading#interpolate 函数支持动态填充格式字符串(format string)。插值语法借鉴自 Python，因此 interpolate 函数支持位置插值和命名插值。
位置插入：obj 包含一个 JavaScript 数组对象，它的元素值随后以相同的顺序依次插值到相应的 fmt 占位符中。例如：
const formats = ngettext(\n 'There is %s object. Remaining: %s',\n 'There are %s objects. Remaining: %s',\n 11\n);\nconst string = interpolate(formats, [11, 20]);\n// string is 'There are 11 objects. Remaining: 20'\n命名插入：通过将可选的布尔 named 参数设为 true 来选择这个模式。obj 包含 JavaScript 对象或者关联数组。例如：
const data = {\n count: 10,\n total: 50\n};\n\nconst formats = ngettext(\n 'Total: %(total)s, there is %(count)s object',\n 'there are %(count)s of a total of %(total)s objects',\n data.count\n);\nconst string = interpolate(formats, data, true);\n尽管如此，你不应该使用字符串插值：这仍然是 JavaScript，因此代码必须进行重复的正则表达式替换。这并不像 Python 中的字符串插值那么快，所以请确保你真的需要这么做（比如，与 ngettext 结合产生合适的复数形式）。
get_formatLink to this heading#get_format 函数可以访问已配置的 i18n 格式化设置，而且可以检索指定配置名称的格式字符串：
document.write(get_format('DATE_FORMAT'));\n// 'N j, Y'\n它可以访问以下设置：
\n这对于保持与Python呈现的值的格式一致性非常有用。
\ngettext_noopLink to this heading#这模拟了 gettext 函数，但不执行任何操作，返回那传递给它的所有内容：
document.write(gettext_noop('this will not be translated'));\n这对于在将来需要翻译的代码中删除部分代码时很有用。
\npgettextLink to this heading#pgettext 函数的行为类似于 Python 变体(pgettext())，它提供了一个上下文相关的单词：
document.write(pgettext('month name', 'May'));\nnpgettextLink to this heading#npgettext 函数的行为类似于 Python 变体(npgettext())，它提供了一个上下文相关的 复数 单词：
document.write(npgettext('group', 'party', 1));\n// party\ndocument.write(npgettext('group', 'party', 2));\n// parties\npluralidxLink to this heading#pluralidx 函数的工作方式类似于 pluralize 模板过滤器，决定给定的 count 是否应该使用单词的复数形式：
document.write(pluralidx(0));\n// true\ndocument.write(pluralidx(1));\n// false\ndocument.write(pluralidx(2));\n// true\n在这种最简单的情况下，如果不需要自定义复数，那么会对整数 1 返回 false ，其他数返回 true 。
然而，在所有语言中复数化并不是这么简单。如果语言不支持复数化，那么就需要提供一个空值。
\n此外，如果复数的规则复杂，目录视图将渲染一个条件表达式。它将返回 true (如果是复数) 或 false (如果不是复数) 的值。
JSONCatalog 视图Link to this heading#为了使用其他客户端的库来控制翻译，你可能需要利用 JSONCatalog 视图。它类似于 JavaScriptCatalog ，但返回一个 JSON 响应。
查看 JavaScriptCatalog 文档来了解关于 domain 和 packages 属性的可能值和使用。
响应格式如下：
\n{\n "catalog": {\n # Translations catalog\n },\n "formats": {\n # Language formats for date, time, etc.\n },\n "plural": "..." # Expression for plural forms, or null.\n}\n各种 JavaScript/JSON i18n 视图在每次请求时从 .mo 文件生成日历。因为其输出是恒定的，至少对于给定版本的站点来说，它是缓存的一个很好的选择。
服务端缓存将减少 CPU 负载。使用 cache_page() 装饰器很容易实现。要在翻译变化时让缓存失效，需要提供一个版本相关的键前缀，如下例所示，或将视图映射到版本相关的 URL ：
from django.views.decorators.cache import cache_page\nfrom django.views.i18n import JavaScriptCatalog\n\n# The value returned by get_version() must change when translations change.\nurlpatterns = [\n path('jsi18n/',\n cache_page(86400, key_prefix='js18n-%s' % get_version())(JavaScriptCatalog.as_view()),\n name='javascript-catalog'),\n]\n客户端缓存将节省带宽并让网站加载速度变快。如果你正在使用 ETags（ConditionalGetMiddleware），那么你已经被覆盖了。否则，你可以应用条件装饰器（conditional decorators）。在下面的例子中，当你重启应用程序服务时，缓存将失效。
from django.utils import timezone\nfrom django.views.decorators.http import last_modified\nfrom django.views.i18n import JavaScriptCatalog\n\nlast_modified_date = timezone.now()\n\nurlpatterns = [\n path('jsi18n/',\n last_modified(lambda req, **kw: last_modified_date)(JavaScriptCatalog.as_view()),\n name='javascript-catalog'),\n]\n你甚至可以在部署过程中预先生成JavaScript目录，并将其作为静态文件。该技术已在 django-statici18n 中实现。
\nDjango 提供两种方式来国际化 URL 模式：
\n将语言前缀添加到 URL 模式的根，来使得 LocaleMiddleware 从请求的 URL 中检测要激活的语言。
通过 django.utils.translation.gettext_lazy() 函数使得 URL 模式本身可翻译。
这个函数可以在根URLconf中使用，Django 会自动将当前激活的语言代码添加到 i18n_patterns() 中定义的所有 URL 模式中。
设置 prefix_default_language 为 False 会从默认语言( LANGUAGE_CODE )中删除前缀。这在向现有网站添加翻译时非常有用，这样当前的网址就不会改变。
URL 模式举例：
\nfrom django.conf.urls.i18n import i18n_patterns\nfrom django.urls import include, path\n\nfrom about import views as about_views\nfrom news import views as news_views\nfrom sitemap.views import sitemap\n\nurlpatterns = [\n path('sitemap.xml', sitemap, name='sitemap-xml'),\n]\n\nnews_patterns = ([\n path('', news_views.index, name='index'),\n path('category/<slug:slug>/', news_views.category, name='category'),\n path('<slug:slug>/', news_views.details, name='detail'),\n], 'news')\n\nurlpatterns += i18n_patterns(\n path('about/', about_views.main, name='about'),\n path('news/', include(news_patterns, namespace='news')),\n)\n定义这些 URL 模式后，Django 会自动将语言前缀添加到由 i18n_patterns 函数添加的URL模式中。例如：
>>> from django.urls import reverse\n>>> from django.utils.translation import activate\n\n>>> activate('en')\n>>> reverse('sitemap-xml')\n'/sitemap.xml'\n>>> reverse('news:index')\n'/en/news/'\n\n>>> activate('nl')\n>>> reverse('news:detail', kwargs={'slug': 'news-slug'})\n'/nl/news/news-slug/'\n如果 prefix_default_language=False 并且 LANGUAGE_CODE='en' ，URLs 将会是：
>>> activate('en')\n>>> reverse('news:index')\n'/news/'\n\n>>> activate('nl')\n>>> reverse('news:index')\n'/nl/news/'\nURL模式也可以使用 gettext_lazy() 函数标记。例如：
from django.conf.urls.i18n import i18n_patterns\nfrom django.urls import include, path\nfrom django.utils.translation import gettext_lazy as _\n\nfrom about import views as about_views\nfrom news import views as news_views\nfrom sitemaps.views import sitemap\n\nurlpatterns = [\n path('sitemap.xml', sitemap, name='sitemap-xml'),\n]\n\nnews_patterns = ([\n path('', news_views.index, name='index'),\n path(_('category/<slug:slug>/'), news_views.category, name='category'),\n path('<slug:slug>/', news_views.details, name='detail'),\n], 'news')\n\nurlpatterns += i18n_patterns(\n path(_('about/'), about_views.main, name='about'),\n path(_('news/'), include(news_patterns, namespace='news')),\n)\n然后你可以创建翻译，reverse() 函数将以激活的语言返回URL。例如：
>>> from django.urls import reverse\n>>> from django.utils.translation import activate\n\n>>> activate('en')\n>>> reverse('news:category', kwargs={'slug': 'recent'})\n'/en/news/category/recent/'\n\n>>> activate('nl')\n>>> reverse('news:category', kwargs={'slug': 'recent'})\n'/nl/nieuws/categorie/recent/'\n如果本地化的URLs在模板中解析，那么它们会始终使用当前的语言。要链接其他语言中的URL，需使用 language 模板标签。它可以在随附的模板部分中启用给定的语言：
{% load i18n %}\n\n{% get_available_languages as languages %}\n\n{% trans "View this category in:" %}\n{% for lang_code, lang_name in languages %}\n {% language lang_code %}\n <a href="{% url 'category' slug=category.slug %}">{{ lang_name }}</a>\n {% endlanguage %}\n{% endfor %}\nlanguage 标签将语言代码作为唯一的参数。
一旦标记了应用程序的字符串文字以供以后翻译，就需要写入（或获取）翻译。这里介绍一下方法。
\n首先需要为新语言创建 message file 文件。消息文件是一个纯文本文件，代表一种语言，它包含所有可用的翻译字段以及如何以给定语言表示。消息文件扩展名是 .po 文件。
Django 附带的工具 django-admin makemessages 会自动创建并保存这些文件。
要创建或更新消息文件，需执行这个命令：
\ndjango-admin makemessages -l de\n...其中 de 是你要创建的消息文件的 locale name 。例如，pt_BR 是葡萄牙语，de_AT 是奥地利德语，id 是印尼语。
脚本应该从以下两个位置之一来运行：
\n你的 Django 项目的根目录（就是包含 manage.py 的那个目录）。
Django app的根目录。
脚本会遍历你的项目源代码树或者应用程序源代码库，并抽出所有要被翻译的字符串（查看 Django 如何发现翻译 并确保 LOCALE_PATHS 被正确设置）。它在 locale/LANG/LC_MESSAGES 目录中创建（或更新）消息文件。以德语为例，这个文件会是 locale/de/LC_MESSAGES/django.po 。
在项目的根目录执行 makemessages 命令时，提取的字符串将自动分发到合适的消息文件。这就是说，从包含 locale 目录的 app 文件中提取的字符串将进入该目录下的消息文件中。从不包含任何 locale 目录的 app 文件中提取的字符串将进入 LOCALE_PATHS 中列出的第一个目录下的消息文件，如果 LOCALE_PATHS 为空，则会报错。
默认情况下， django-admin makemessages 会检查每一个以 .html, .txt or .py 为后缀的文件。如果想覆盖默认值，需使用 --extension 或 -e 选项来指定要检查的文件扩展名：
django-admin makemessages -l de -e txt\n使用逗号和(或)多次使用 -e 或 --extension 来分隔多个扩展名：
django-admin makemessages -l de -e html,txt -e xml\n每个 .po 文件包含少量的元数据（例如翻译维护者的联系方式等等）以及大量的翻译文件 —— 要翻译的字符串以及实际翻译的字段之间的映射。
例如，如果 Djanog 程序包含一段 "Welcome to my site." 的翻译字符串，像这样：
_("Welcome to my site.")\n... 然后 django-admin makemessages 将创建一个包含以下代码片段的 .po 文件 —— 一条消息：
#: path/to/python/module.py:23\nmsgid "Welcome to my site."\nmsgstr ""\n快速解释：
\nmsgid 是显示在源代码中需要翻译的字符串。不要改动它。
msgstr 是你翻译后的字符串。一开始它是空的，因此你需要填充它。确保在翻译中保留引号。
为了方便，每个消息包含以前缀为 # 且位于 msgid 行上方的注释行的形式的注释行，这个注释行报货文件名和需要翻译字符串的行号。
长消息是特殊的情况。这里，在 msgstr (or msgid) 后的第一个字符串是空字符串。然后内容本身就会在接下来的几行中以每行一串的形式写出来。这些字符串被直接连接起来。不要忘了字符串中尾部的空格，否则，它们会被粘贴在一起而不留空白！
要重新检查新翻译字符串的源代码和模板并更新所有语言的所有消息，运行这行：
\ndjango-admin makemessages -a\n创建消息文件后，以及每次修改它时，你需要把它编译成更有效的形式，以供 gettext 使用。使用 django-admin compilemessages 工具来执行此操作。
该工具运行所有可用的 .po 文件并创建 .mo 文件，这些文件是为 gettext 使用而优化的二进制文件。
django-admin compilemessages\n这就行了。可以使用你的翻译文件了。
\n\n\ngettext() 在带有百分号的字符串中错误地检测 python-formatLink to this heading#在某些情况下,带有百分号的字符串跟着一个空格和一个字符串转换换类型( string conversion type ) (例如 _("10% interest") ),:func:~django.utils.translation.gettext 会错误地使用 python-format 标记字符串.
如果试着使用已被错误标记的字符串来编译消息文件,会得到一个消息,例如" 'msgid' 和 'msgstr' 格式数量不匹配"( number of format specifications in 'msgid' and 'msgstr' does not match ),或者"'msgstr' 不是有效的 Python 格式字符串,与'msgid'不同 "( 'msgstr' is not a valid Python format string, unlike 'msgid').
\n要解决这个问题，可以通过添加第二个百分号来转义百分号：
\nfrom django.utils.translation import gettext as _\noutput = _("10%% interest")\n或者可以使用非python格式（ no-python-format ），这样所有百分号会被视为文字：
# xgettext:no-python-format\noutput = _("10% interest")\n使用 django-admin makemessages ，你可以像其他Django消息文件一样创建并更新消息文件。唯一的区别是，你需要提供一个 -d djangojs 参数，明确指定gettext术语中的域，本例中是 djangojs 域，如下所示：
django-admin makemessages -d djangojs -l de\n这会创建或更新德语的JavaScript 消息文件。更新消息文件后，像执行普通 Django 消息文件那样运行 django-admin compilemessages 即可。
gettextLink to this heading#仅适用于需要提取消息ID或编译消息文件（.po）的场景。翻译工作本身涉及编辑这种已存在的文件，但如果你想创建你自己的消息文件，或者想要测试或编译一个已改动的消息文件，需下载一个预编译的二进制安装器（a precompiled binary installer）。
你可能也想使用在其他地方获得的 gettext 二进制文件，只要 xgettext --version 命令工作正常即可。如果在命令行下输入 xgettext --version ，会导致报错："xgettext.exe 生成错误，并将被 Windows 关闭。"，所以请不要试图使用带有 gettext 包的 Django 翻译工具。
makemessages 命令Link to this heading#如果要给 xgettext 传递额外的参数，则需要创建自定义的 makemessages 命令，并覆盖它的 xgettext_options 属性：
from django.core.management.commands import makemessages\n\nclass Command(makemessages.Command):\n xgettext_options = makemessages.Command.xgettext_options + ['--keyword=mytrans']\n如果需要更多的灵活性，也可以给自定义的 makemessages 命令添加新的参数：
from django.core.management.commands import makemessages\n\nclass Command(makemessages.Command):\n\n def add_arguments(self, parser):\n super().add_arguments(parser)\n parser.add_argument(\n '--extra-keyword',\n dest='xgettext_keywords',\n action='append',\n )\n\n def handle(self, *args, **options):\n xgettext_keywords = options.pop('xgettext_keywords')\n if xgettext_keywords:\n self.xgettext_options = (\n makemessages.Command.xgettext_options[:] +\n ['--keyword=%s' % kwd for kwd in xgettext_keywords]\n )\n super().handle(*args, **options)\nset_language 重定向试图Link to this heading#方便起见，Django 附带了一个视图 django.views.i18n.set_language() ，它可以设置用户语言首选项，并且重定向到一个给定的URL，或者默认情况下，会返回到上一页。
要激活这个视图，需要在你的 URLconf 中添加下面这行代码：
\npath('i18n/', include('django.conf.urls.i18n')),\n（注意这个例子会使视图在 /i18n/setlang/ 下可用。）
视图期望通过 POST 方法调用，并在请求中设置 language 参数。如果 session 支持是可用的，视图会在用户的 session 中保存语言选择。它也会将语言选择保存在默认名为 django_language （名称可以通过 LANGUAGE_COOKIE_NAME 设置改变）的 cookie 中。
在设置语言选择后，Django 会检查 POST 或 GET 数据中的 next 参数。如果找到这个参数并且 Django 认为它是一个安全的链接（也就是说它不指向其他主机并使用安全模式），将会重定向到这个链接。否则，Django 可能会重定向到 Referer header 里的 URL，如果没设置这个 URL，则会跳转到 / ，这取决于请求的性质。
对于 AJAX 请求，仅在设置了 next 参数时执行回退。否则会返回 204 状态码（无内容）。
对于非AJAX请求，回退将会一直执行。
这里是一个模板代码的例子：
\n{% load i18n %}\n\n<form action="{% url 'set_language' %}" method="post">{% csrf_token %}\n <input name="next" type="hidden" value="{{ redirect_to }}">\n <select name="language">\n {% get_current_language as LANGUAGE_CODE %}\n {% get_available_languages as LANGUAGES %}\n {% get_language_info_list for LANGUAGES as languages %}\n {% for language in languages %}\n <option value="{{ language.code }}"{% if language.code == LANGUAGE_CODE %} selected{% endif %}>\n {{ language.name_local }} ({{ language.code }})\n </option>\n {% endfor %}\n </select>\n <input type="submit" value="Go">\n</form>\n在这个例子中，Django 会在 redirect_to 变量中查找用户将要重定向的网址。
你可能想显式地为当前会话设置语言。例如，可能是从另一个系统检索用户的语言偏好。你已经了解了 django.utils.translation.activate() 。这只适用于当前进程。要将整个会话的语言保留在 cookie 中，请在响应上设置 LANGUAGE_COOKIE_NAME ：
from django.conf import settings\nfrom django.http import HttpResponse\nfrom django.utils import translation\nuser_language = 'fr'\ntranslation.activate(user_language)\nresponse = HttpResponse(...)\nresponse.set_cookie(settings.LANGUAGE_COOKIE_NAME, user_language)\n通常你想同时使用这两者：django.utils.translation.activate() 改变这个线程的语言，并设置cookie使此首选项在以后的请求中保持不变。
虽然 Django 提供了一套丰富的i18n工具用于视图和模板，但它并不会限制 Django 特定代码的使用。Django 翻译机制可用于将任何文本翻译成 Django 支持的语言（当然，需要存在合适的翻译目录）。你可以加载翻译目录，激活它并翻译你选择的语言，但记住要切换回原始语言，因为激活语言目录是在每个线程基础上完成的，这样的改变将影响在同一线程中运行的代码。
\n例如:
\nfrom django.utils import translation\n\ndef welcome_translated(language):\n cur_language = translation.get_language()\n try:\n translation.activate(language)\n text = translation.gettext('welcome')\n finally:\n translation.activate(cur_language)\n return text\n不论 LANGUAGE_CODE 和中间件设置的是什么，用 'de' 值调用的这个函数都会得到 "Willkommen" 。
django.utils.translation.get_language() 会返回当前进程所使用的语言，django.utils.translation.activate() 会为当前进程激活翻译目录，django.utils.translation.check_for_language() 会检查 Django 是否支持给定的语言。
为了协助编写更简洁的代码，这里还有一个上下文管理器 django.utils.translation.override() ，它会在输入时存储当前语言，并在退出时恢复它。有了它，上面的例子可变为：
from django.utils import translation\n\ndef welcome_translated(language):\n with translation.override(language):\n return translation.gettext('welcome')\nDjango's translation machinery uses the standard gettext module that comes\nwith Python. If you know gettext, you might note these specialties in the\nway Django does translation:
The string domain is django or djangojs. This string domain is\nused to differentiate between different programs that store their data\nin a common message-file library (usually /usr/share/locale/). The\ndjango domain is used for Python and template translation strings\nand is loaded into the global translation catalogs. The djangojs\ndomain is only used for JavaScript translation catalogs to make sure\nthat those are as small as possible.
Django doesn't use xgettext alone. It uses Python wrappers around\nxgettext and msgfmt. This is mostly for convenience.
Once you've prepared your translations -- or, if you want to use the\ntranslations that come with Django -- you'll need to activate translation for\nyour app.
\nBehind the scenes, Django has a very flexible model of deciding which language\nshould be used -- installation-wide, for a particular user, or both.
\nTo set an installation-wide language preference, set LANGUAGE_CODE.\nDjango uses this language as the default translation -- the final attempt if no\nbetter matching translation is found through one of the methods employed by the\nlocale middleware (see below).
If all you want is to run Django with your native language all you need to do\nis set LANGUAGE_CODE and make sure the corresponding message\nfiles and their compiled versions (.mo) exist.
If you want to let each individual user specify which language they\nprefer, then you also need to use the LocaleMiddleware.\nLocaleMiddleware enables language selection based on data from the request.\nIt customizes content for each user.
To use LocaleMiddleware, add 'django.middleware.locale.LocaleMiddleware'\nto your MIDDLEWARE setting. Because middleware order matters, follow\nthese guidelines:
Make sure it's one of the first middleware installed.
It should come after SessionMiddleware, because LocaleMiddleware\nmakes use of session data. And it should come before CommonMiddleware\nbecause CommonMiddleware needs an activated language in order\nto resolve the requested URL.
If you use CacheMiddleware, put LocaleMiddleware after it.
For example, your MIDDLEWARE might look like this:
MIDDLEWARE = [\n 'django.contrib.sessions.middleware.SessionMiddleware',\n 'django.middleware.locale.LocaleMiddleware',\n 'django.middleware.common.CommonMiddleware',\n]\n(For more on middleware, see the middleware documentation.)
\nLocaleMiddleware tries to determine the user's language preference by\nfollowing this algorithm:
First, it looks for the language prefix in the requested URL. This is\nonly performed when you are using the i18n_patterns function in your\nroot URLconf. See 国际化：在 URL 模式中 for more information\nabout the language prefix and how to internationalize URL patterns.
Failing that, it looks for a cookie.
\nThe name of the cookie used is set by the LANGUAGE_COOKIE_NAME\nsetting. (The default name is django_language.)
Failing that, it looks at the Accept-Language HTTP header. This\nheader is sent by your browser and tells the server which language(s) you\nprefer, in order by priority. Django tries each language in the header\nuntil it finds one with available translations.
Failing that, it uses the global LANGUAGE_CODE setting.
注意：
\nIn each of these places, the language preference is expected to be in the\nstandard language format, as a string. For example,\nBrazilian Portuguese is pt-br.
If a base language is available but the sublanguage specified is not,\nDjango uses the base language. For example, if a user specifies de-at\n(Austrian German) but Django only has de available, Django uses\nde.
Only languages listed in the LANGUAGES setting can be selected.\nIf you want to restrict the language selection to a subset of provided\nlanguages (because your application doesn't provide all those languages),\nset LANGUAGES to a list of languages. For example:
LANGUAGES = [\n ('de', _('German')),\n ('en', _('English')),\n]\nThis example restricts languages that are available for automatic\nselection to German and English (and any sublanguage, like de-ch or\nen-us).
If you define a custom LANGUAGES setting, as explained in the\nprevious bullet, you can mark the language names as translation strings\n-- but use gettext_lazy() instead of\ngettext() to avoid a circular import.
以下是一个实例配置文件:
\nfrom django.utils.translation import gettext_lazy as _\n\nLANGUAGES = [\n ('de', _('German')),\n ('en', _('English')),\n]\nOnce LocaleMiddleware determines the user's preference, it makes this\npreference available as request.LANGUAGE_CODE for each\nHttpRequest. Feel free to read this value in your view\ncode. Here's an example:
from django.http import HttpResponse\n\ndef hello_world(request, count):\n if request.LANGUAGE_CODE == 'de-at':\n return HttpResponse("You prefer to read Austrian German.")\n else:\n return HttpResponse("You prefer to read another language.")\nNote that, with static (middleware-less) translation, the language is in\nsettings.LANGUAGE_CODE, while with dynamic (middleware) translation, it's\nin request.LANGUAGE_CODE.
At runtime, Django builds an in-memory unified catalog of literals-translations.\nTo achieve this it looks for translations by following this algorithm regarding\nthe order in which it examines the different file paths to load the compiled\nmessage files (.mo) and the precedence of multiple\ntranslations for the same literal:
The directories listed in LOCALE_PATHS have the highest\nprecedence, with the ones appearing first having higher precedence than\nthe ones appearing later.
Then, it looks for and uses if it exists a locale directory in each\nof the installed apps listed in INSTALLED_APPS. The ones\nappearing first have higher precedence than the ones appearing later.
Finally, the Django-provided base translation in django/conf/locale\nis used as a fallback.
In all cases the name of the directory containing the translation is expected to\nbe named using locale name notation. E.g. de, pt_BR, es_AR,\netc. Untranslated strings for territorial language variants use the translations\nof the generic language. For example, untranslated pt_BR strings use pt\ntranslations.
This way, you can write applications that include their own translations, and\nyou can override base translations in your project. Or, you can build a big\nproject out of several apps and put all translations into one big common\nmessage file specific to the project you are composing. The choice is yours.
\nAll message file repositories are structured the same way. They are:
\nAll paths listed in LOCALE_PATHS in your settings file are\nsearched for <language>/LC_MESSAGES/django.(po|mo)
$APPPATH/locale/<language>/LC_MESSAGES/django.(po|mo)
$PYTHONPATH/django/conf/locale/<language>/LC_MESSAGES/django.(po|mo)
To create message files, you use the django-admin makemessages\ntool. And you use django-admin compilemessages\nto produce the binary .mo files that are used by gettext.
You can also run django-admin compilemessages\n--settings=path.to.settings to make the compiler process all\nthe directories in your LOCALE_PATHS setting.
Django makes the general assumption that the original strings in a translatable\nproject are written in English. You can choose another language, but you must be\naware of certain limitations:
\ngettext only provides two plural forms for the original messages, so you\nwill also need to provide a translation for the base language to include all\nplural forms if the plural rules for the base language are different from\nEnglish.
When an English variant is activated and English strings are missing, the\nfallback language will not be the LANGUAGE_CODE of the project,\nbut the original strings. For example, an English user visiting a site with\nLANGUAGE_CODE set to Spanish and original strings written in\nRussian will see Russian text rather than Spanish.