Django プロジェクトを翻訳可能にするためには、Python コードやテンプレートに、多少のフックを加筆しなければなりません。このフックは 翻訳文字列 と呼ばれます。翻訳文字列は Django に「このテキストに対する翻訳が有効な場合、このテキストはエンドユーザの言語に翻訳すべきだ」ということを通知します。翻訳可能な文字列をマークすることは開発者の責任です。システムが翻訳できるのは指定された文字列だけなのです。
\nDjango は、翻訳文字列を メッセージファイル に抽出するユーティリティを提供します。このファイルがあるため、翻訳者が対象の言語において翻訳文字列に対応する文字列を用意することが簡単になります。翻訳者がメッセージファイルの中身を書き終わったら、それをコンパイルしなければなりません。このプロセスは GNU gettext ツー ルキットに依存しています。
\nOnce this is done, Django takes care of translating web apps on the fly in each\navailable language, according to users' language preferences.
\nDjango の国際化フックはデフォルトで有効になっており、これは、フレームワークの特定の箇所で i18n に関する小さなオーバーヘッドが発生することを意味します。国際化を使わない場合は、 USE_I18N = False を設定ファイルに記述してください。そうすれば Django は国際化の部品を読み込まないようにして多少の最適化をします。
Specify a translation string by using the function\ngettext(). It's convention to import this\nas a shorter alias, _, to save typing.
この例では、"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)\nYou could code this without using the alias. This example is identical to the\nprevious one:
\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翻訳は、計算済みの値に適用されます。次の例は、上の2つの例とまったく同一です:
\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(上の 2 つの例のように変数や計算済みの値を使う場合の注意点として、Django の翻訳文字列検出ユーティリティ django-admin makemessages はこれらの文字列を検出できません。詳しくは後の makemessages の節で説明します。)
The strings you pass to _() or gettext() can take placeholders,\nspecified with Python's standard named-string interpolation syntax. Example:
def my_view(request, m, d):\n output = _('Today is %(month)s %(day)s.') % {'month': m, 'day': d}\n return HttpResponse(output)\nThis technique lets language-specific translations reorder the placeholder\ntext. For example, an English translation may be "Today is November 26.",\nwhile a Spanish translation may be "Hoy es 26 de noviembre." -- with the\nmonth and the day placeholders swapped.
この理由から、引数が複数ある場合には、固定引数を使った補完 (%s や %d) ではなく、名前付きの補完 (%(day)s) を使ってください。固定引数による補完を使った場合、プレースホルダを正しい順番で翻訳できない場合があります。
Since string extraction is done by the xgettext command, only syntaxes\nsupported by gettext are supported by Django. In particular, Python\nf-strings are not yet supported by xgettext, and\nJavaScript template strings need 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 ファイル内に表示され、ほとんどの翻訳ツールで表示されます。
これはテンプレート内でも動作します。詳しくは Comments for translators in templates を参照してください。
\nUse the function django.utils.translation.gettext_noop() to mark a\nstring as a translation string without translating it. The string is later\ntranslated from a variable.
ソース言語内に保持すべき構成文字列がある場合、これを使ってください。これは、システムやユーザー (たとえばデータベース内の文字列) を介して交換される一方で、最後の時点 (たとえばユーザに文字列が表示されるとき) で翻訳される必要があるからです。
\nUse the function django.utils.translation.ngettext() to specify\npluralized messages.
ngettext() takes three arguments: the singular translation string, the\nplural translation string and the number of objects.
この関数は、Django アプリケーションを数と 複数形 の複雑さが英語で 2 より大きい (その値にかかわらず、単数には 'object'、そして count が 1 ではない全ての場合に 'objects' となります。) 言語にローカル化させる必要がある場合に役立ちます。
例:
\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 ) % {\n 'count': count,\n }\n return HttpResponse(page)\nこの例では、オブジェクトの数値は count 変数として翻訳言語に渡されます。
複数形は、複雑で言語によって異なる動作をすることに注意してください。count と 1 の比較は正しいルールではないことがあります。以下のコードは洗練されて見えますが、いくつかの言語に対しては誤った結果を生み出します:
from 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}\nDon't try to implement your own singular-or-plural logic; it won't be correct.\nIn a case like this, consider something like the following:
\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() 関数を使うことができます。両方とも、第 1 変数として文脈文字列を取ります。
結果の .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 translate and\nblocktranslate template tags.
Lazy に -- 値が呼ばれたときではなくアクセスされたときに -- 文字列を翻訳するためには、django.utils.translation (名前の lazy 接尾辞ですぐ分かります) の翻訳関数の lazy バージョンを使ってください、
これらの関数は、Lazy な文字列参照を保持します -- 実際の翻訳ではありません。翻訳自体はテンプレートレンダリング内のように、文字列が文字列コンテキスト内で使われるときに行われます。
\nこれらの関数への呼び出しがモジュールのロード時に実行されるコードパスにある場合は、これは不可欠です。
\nこれは、モデル、フォーム、モデルフォームを定義するときに簡単に発生することができるものです。これは、Django がフィールドを実際にクラスレベルの属性にするように実装するためです。 そのため、以下のような場合は lazy な翻訳を使用してください:
\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'))\nverbose_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 )\nverbose_name と同様に、必要に応じて Django が自動的にタイトルケースに直すので、リレーションシップに対する小文字の冗長な名前テキストを提供する必要があります。
フォールバックの英語中心とモデルのクラス名を見ることによって Django が動作する冗長な名前の純粋な決定に頼るよりも、明示的な verbose_name と verbose_name_plural オプションを指定することが推奨されます:
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')\ndescription argument to the @display decoratorLink to this heading#For model methods, you can provide translations to Django and the admin site\nwith the description argument to the display()\ndecorator:
from django.contrib import admin\nfrom 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 @admin.display(description=_('Is it a mouse?'))\n def is_mouse(self):\n return self.kind.type == MOUSE_TYPE\nThe result of a gettext_lazy() call can be used wherever you would use a\nstring (a str object) in other Django code, but it may not work with\narbitrary Python code. For example, the following won't work because the\nrequests library doesn't handle\ngettext_lazy objects:
body = gettext_lazy("I \\u2764 Django") # (Unicode :heart:)\nrequests.post('https://example.com/send', data={'body': body})\nYou can avoid such problems by casting gettext_lazy() objects to text\nstrings before passing them to non-Django code:
requests.post('https://example.com/send', data={'body': str(body)})\nIf you don't like the long gettext_lazy name, you can alias it as _\n(underscore), like so:
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'))\nUsing gettext_lazy() and ngettext_lazy() to mark strings in models\nand utility functions is a common operation. When you're working with these\nobjects elsewhere in your code, you should ensure that you don't accidentally\nconvert them to strings, because they should be converted as late as possible\n(so that the correct locale is in effect). This necessitates the use of the\nhelper function described next.
When using lazy translation for a plural string (n[p]gettext_lazy), you\ngenerally don't know the number argument at the time of the string\ndefinition. Therefore, you are authorized to pass a key name instead of an\ninteger as the number argument. Then number will be looked up in the\ndictionary under that key during string interpolation. Here's example:
from django import forms\nfrom django.core.exceptions import ValidationError\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 ValidationError(self.error_message % {'num': number})\nIf the string contains exactly one unnamed placeholder, you can interpolate\ndirectly with the number argument:
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 ValidationError(self.error_message % number)\nformat_lazy()Link to this heading#Python's str.format() method will not work when either the\nformat_string or any of the arguments to str.format()\ncontains lazy translation objects. Instead, you can use\ndjango.utils.text.format_lazy(), which creates a lazy object\nthat runs the str.format() method only when the result is included\nin a string. For example:
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)\nIn this case, the lazy translations in result will only be converted to\nstrings when result itself is used in a string (usually at template\nrendering time).
For any other case where you would like to delay the translation, but have to\npass the translatable string as argument to another function, you can wrap\nthis function inside a lazy call yourself. For example:
\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)\nAnd then later:
\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 属性は双方向性の言語に対してのみ True です。
言語情報のソースは django.conf.locale モジュールです。テンプレートコードでも、この情報に対して同じようにアクセスすることができます。以下を参照してください。
Django テンプレート 内での翻訳は 2 つのテンプレートタグと Pthon コードとはやや異なるシンタックスを使います。テンプレートでこれらのタグを使えるようにするには、{% load i18n %} をテンプレートの先頭に対して設置してください。全てのテンプレートタグと同じように、すでに i18n をロードしているテンプレートを extend している場合であっても、翻訳を使用する全てのテンプレートでロードする必要があります。
translate template tagLink to this heading#The {% translate %} template tag translates either a constant string\n(enclosed in single or double quotes) or variable content:
<title>{% translate "This is the title." %}</title>\n<title>{% translate myvar %}</title>\nnoop オプションが存在する場合、変数はそのままですが翻訳の対象外となります。将来的に翻訳を必要とするコンテンツを "もみ消している" ときに役立ちます:
<title>{% translate "myvar" noop %}</title>\nInternally, inline translations use a\ngettext() call.
テンプレート var (上記の myvar) がタグに渡された場合、最初にランタイムで変数から文字列へと解決し、それからメッセージカタログ内でその文字列をルックアップします。
It's not possible to mix a template variable inside a string within\n{% translate %}. If your translations require strings with variables\n(placeholders), use {% blocktranslate %} instead.
翻訳された文字列を表示させずに取り出したい場合は、以下のシンタックスを使うことができます:
\n{% translate "This is the title" as the_title %}\n\n<title>{{ the_title }}</title>\n<meta name="description" content="{{ the_title }}">\n実際には、テンプレート内の複数の箇所で使用できる文字列を取得するためか、他のテンプレートタグやフィルタに対する引数としてアウトプットを使うために、この方法を使うことになるでしょう:
\n{% translate "starting point" as start %}\n{% translate "end point" as end %}\n{% translate "La Grande Boucle" as race %}\n\n<h1>\n <a href="/" title="{% blocktranslate %}Back to '{{ race }}' homepage{% endblocktranslate %}">{{ 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{% translate %} also supports contextual markers\nusing the context keyword:
{% translate "May" context "month name" %}\nblocktranslate template tagLink to this heading#Contrarily to the translate tag, the blocktranslate tag allows you\nto mark complex sentences consisting of literals and variable content for\ntranslation by making use of placeholders:
{% blocktranslate %}This string will have {{ value }} inside.{% endblocktranslate %}\nテンプレート表現を翻訳するには -- 例えば、オブジェクトの属性にアクセスしたりテンプレートフィルタを使う -- 翻訳ブロック内で使うローカル変数に対する表現をくくる必要があります。例えば:
\n{% blocktranslate with amount=article.price %}\nThat will cost $ {{ amount }}.\n{% endblocktranslate %}\n\n{% blocktranslate with myvar=value|filter %}\nThis will have {{ myvar }} inside.\n{% endblocktranslate %}\nYou can use multiple expressions inside a single blocktranslate tag:
{% blocktranslate with book_t=book|title author_t=author|title %}\nThis is {{ book_t }} by {{ author_t }}\n{% endblocktranslate %}\nOther block tags (for example {% for %} or {% if %}) are not allowed\ninside a blocktranslate tag.
If resolving one of the block arguments fails, blocktranslate will fall\nback to the default language by deactivating the currently active language\ntemporarily with the deactivate_all()\nfunction.
This tag also provides for pluralization. To use it:
\nDesignate and bind a counter value with the name count. This value will\nbe the one used to select the right plural form.
Specify both the singular and plural forms separating them with the\n{% plural %} tag within the {% blocktranslate %} and\n{% endblocktranslate %} tags.
実装例:
\n{% blocktranslate count counter=list|length %}\nThere is only one {{ name }} object.\n{% plural %}\nThere are {{ counter }} {{ name }} objects.\n{% endblocktranslate %}\nA more complex example:
\n{% blocktranslate with amount=article.price count years=i.length %}\nThat will cost $ {{ amount }} per year.\n{% plural %}\nThat will cost $ {{ amount }} per {{ years }} years.\n{% endblocktranslate %}\nWhen you use both the pluralization feature and bind values to local variables\nin addition to the counter value, keep in mind that the blocktranslate\nconstruct is internally converted to an ngettext call. This means the\nsame notes regarding ngettext variables\napply.
Reverse URL lookups cannot be carried out within the blocktranslate and\nshould be retrieved (and stored) beforehand:
{% url 'path.to.view' arg arg2 as the_url %}\n{% blocktranslate %}\nThis is a URL: {{ the_url }}\n{% endblocktranslate %}\n翻訳された文字列を表示させずに取り出したい場合は、以下のシンタックスを使うことができます:
\n{% blocktranslate asvar the_title %}The title is {{ title }}.{% endblocktranslate %}\n<title>{{ the_title }}</title>\n<meta name="description" content="{{ the_title }}">\nIn practice you'll use this to get a string you can use in multiple places in a\ntemplate or so you can use the output as an argument for other template tags or\nfilters.
\n{% blocktranslate %} also supports contextual\nmarkers using the context keyword:
{% blocktranslate with name=user.username context "greeting" %}Hi {{ name }}{% endblocktranslate %}\nAnother feature {% blocktranslate %} supports is the trimmed option.\nThis option will remove newline characters from the beginning and the end of\nthe content of the {% blocktranslate %} tag, replace any whitespace at the\nbeginning and end of a line and merge all lines into one using a space\ncharacter to separate them. This is quite useful for indenting the content of a\n{% blocktranslate %} tag without having the indentation characters end up\nin the corresponding entry in the .po file, which makes the translation\nprocess easier.
For instance, the following {% blocktranslate %} tag:
{% blocktranslate trimmed %}\n First sentence.\n Second paragraph.\n{% endblocktranslate %}\nwill result in the entry "First sentence. Second paragraph." in the .po\nfile, compared to "\\n First sentence.\\n Second paragraph.\\n", if the\ntrimmed option had not been specified.
Just like with Python code, these notes for\ntranslators can be specified using comments, either with the comment\ntag:
{% comment %}Translators: View verb{% endcomment %}\n{% translate "View" %}\n\n{% comment %}Translators: Short intro blurb{% endcomment %}\n<p>{% blocktranslate %}A multiline translatable\nliteral.{% endblocktranslate %}</p>\nor with the {# ... #} one-line comment constructs:
{# Translators: Label of a button that triggers search #}\n<button type="submit">{% translate "Go" %}</button>\n\n{# Translators: This is a text of the base template #}\n{% blocktranslate %}Ambiguous translatable block of text{% endblocktranslate %}\nIf you want to select a language within a template, you can use the\nlanguage template tag:
{% load i18n %}\n\n{% get_current_language as LANGUAGE_CODE %}\n<!-- Current language: {{ LANGUAGE_CODE }} -->\n<p>{% translate "Welcome to our page" %}</p>\n\n{% language 'en' %}\n {% get_current_language as LANGUAGE_CODE %}\n <!-- Current language: {{ LANGUAGE_CODE }} -->\n <p>{% translate "Welcome to our page" %}</p>\n{% endlanguage %}\nWhile the first occurrence of "Welcome to our page" uses the current language,\nthe second will always be in English.
\nJavaScript に対する翻訳には、いくつか問題があります:
\nJavaScript コードは gettext 実行にアクセスできません。
JavaScript コードは .po や .mo ファイルにアクセスできません; サーバーによって配布される必要があります。
JavaScript 用の翻訳カタログはできる限り小さくなければなりません。
Django には、これらの問題に対する総合的な解決策が用意されています: 翻訳を JavaScript に渡し、gettext などを JavaScript 内から呼び出せるようにする方法です。
主な解決策は以下の JavaScriptCatalog ビューです。これは、gettext を擬似的に再現する関数と翻訳文字列の配列で JavaScript コードライブラリを生成します。
JavaScriptCatalog ビューLink to this heading#gettext インターフェイスを擬似的に再現する関数と翻訳文字列の配列で、JavaScriptのコードライブラリを生成するビューです。
属性
\nビューの出力に追加する文字列を含む翻訳ドメインです。デフォルトは 'djangojs' です。
インストールされたアプリケーション間の application names のリストです。これらのアプリケーションは locale ディレクトリを含んでいる必要があります。これらのカタログに加えて (常に含まれている) LOCALE_PATHS 内で見つかった全てのカタログは、1 つのカタログに統合されます。デフォルトは None で、全ての INSTALLED_APPS からの利用可能な翻訳は JavaScript の出力に渡されることを意味します。
デフォルト値を使った例:
\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 ビューを使っていてそのうちのいくつかが同じ文字列を定義している場合、最後にロードされたカタログ内の文字列が優先されます。
To use the catalog, pull in the dynamically generated script like this:
\n<script src="{% url 'javascript-catalog' %}"></script>\nこれは、reverse URL を使用して、JavaScript カタログビューの URL をルックアップします。カタログがロードされると、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 関数は表示形式の文字列の動的な記入をサポートします。補完シンタックスは Python を模しているので、interpolate 関数は位置および名前付きの補完の両方をサポートします。
位置による補完: obj は、表示されるのと同じ順番で要素の値が一致する fmt プレースホルダ内で連続的に補完される JavaScript Array オブジェクトを含んでいます。例えば:
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='jsi18n-%s' % get_version())(JavaScriptCatalog.as_view()),\n name='javascript-catalog'),\n]\nClient-side caching will save bandwidth and make your site load faster. If\nyou're using ETags (ConditionalGetMiddleware),\nyou're already covered. Otherwise, you can apply conditional decorators. In the following example, the cache is invalidated\nwhenever you restart your application server:
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 パターンを国際化するための 2 つの仕組みが用意されています:
\nLocaleMiddleware が、リクエストされた URL からアクティブにする言語を検出できるようにするため、URL パターンのルートに言語のプレフィックスを追加します。
Making URL patterns themselves translatable via the\ndjango.utils.translation.gettext_lazy() function.
この関数は、ルートの URLconf で使うことができ、Django は自動的に現在アクティブな言語のコードを i18n_patterns() で定義された全ての URL パターンの先頭に追加します。
prefix_default_language を False にセットすると、デフォルト言語 (LANGUAGE_CODE) からプレフィックスを除去します。これは、現在の URL を変更しないよう既存のサイトに翻訳を追加するとき、役に立ちます。
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)\nAfter defining these URL patterns, Django will automatically add the\nlanguage prefix to the URL patterns that were added by the i18n_patterns\nfunction. Example:
>>> 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/'\nprefix_default_language=False と LANGUAGE_CODE='en' を使うと、URL は以下のようになります:
>>> activate('en')\n>>> reverse('news:index')\n'/news/'\n\n>>> activate('nl')\n>>> reverse('news:index')\n'/nl/news/'\nURL patterns can also be marked translatable using the\ngettext_lazy() function. Example:
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ローカル化された URL がテンプレート内でリバースされる場合、常に現在の言語が使用されます。他の言語の URL にリンクを貼るには、language テンプレートタグを使ってください。これは、テンプレートの囲まれた範囲内で、指定された言語を有効化します:
{% load i18n %}\n\n{% get_available_languages as languages %}\n\n{% translate "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 などです。
スクリプトは、2 つの場所のうち 1 つから実行する必要があります:
\nDjango プロジェクトのルートディレクトリ (manage.py を含むところ)。
Django アプリケーションのルートディレクトリ。
スクリプトは、プロジェクトのソースツリーもしくはアプリケーションのソースツリーを通じて実行され、翻訳用にマークされた全ての文字列 (How Django discovers translations を参照して LOCALE_PATHS を正しく設定してください) を抽出します。ディレクトリ locale/LANG/LC_MESSAGES にメッセージファイルを作成 (もしくは更新) します。de の例では、ファイルは locale/de/LC_MESSAGES/django.po となります。
プロジェクトのルートディレクトリから makemessages を実行したとき、抽出された文字列は自動的に適切なメッセージファイルへと分配されます。つまり、locale ディレクトリを含むアプリケーションのファイルから抽出された文字列は、そのディレクトリ下のメッセージファイルに格納されます。locale ディレクトリがないアプリケーションのファイルから抽出された文字列は、LOCALE_PATHS 内に最初にリストアップされたディレクトリ下にあるメッセージファイルか、もしくは LOCALE_PATHS が空の場合はエラーを生成します。
By default django-admin makemessages examines every\nfile that has the .html, .txt or .py file extension. If you want to\noverride that default, use the --extension\nor -e option to specify the file extensions to examine:
django-admin makemessages -l de -e txt\nカンマで複数の拡張子を区切って、そして/あるいは -e や --extension を複数回使ってください:
django-admin makemessages -l de -e html,txt -e xml\nEach .po file contains a small bit of metadata, such as the translation\nmaintainer's contact information, but the bulk of the file is a list of\nmessages -- mappings between translation strings and the actual translated\ntext for the particular language.
例えば以下のように、Django アプリケーションが "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 (もしくは msgid) 直後の最初の文字列は空の文字列です。それからコンテンツ自身が行ごとに 1 つの文字列として次の数行にわたって記述されます。これらの文字列は直接連結されます。文字列内で最後のスペースを忘れないでください; さもなくば、空白スペースなしで接合されることになります！
新しい翻訳文字列に対して全てのコードとテンプレートを再検査して 全ての 言語に対する全てのメッセージファイルを更新するには、以下を実行してください:
\ndjango-admin makemessages -a\nメッセージファイルを作成した後 -- そして変更を加えたときそれぞれで -- gettext による使用のために、より効率的な形式にコンパイルする必要があります。django-admin compilemessages ユーティリティを利用してください。
このツールは、全ての有効な .po ファイルを通じて動作し、.mo ファイルを生成します。これは gettext による使用のために最適化されたバイナリファイルです。django-admin makemessages を実行した同じディレクトリで、以下のように django-admin compilemessages を実行してください:
django-admin compilemessages\nこれで終わりです。翻訳は使う準備ができました。
\n\n\ngettext() incorrectly detects python-format in strings with percent signsLink to this heading#In some cases, such as strings with a percent sign followed by a space and a\nstring conversion type (e.g.\n_("10% interest")), gettext() incorrectly\nflags strings with python-format.
誤ってフラグが立てられた文字列でメッセージファイルをコンパイルしようとすると、number of format specifications in 'msgid' and 'msgstr' does not match もしくは 'msgstr' is not a valid Python format string, unlike 'msgid'. といったエラーが発生します。
これを解決するには、パーセント文字を 2 つ重ねることでエスケープすることができます:
\nfrom django.utils.translation import gettext as _\noutput = _("10%% interest")\nもしくは no-python-format を使ってパーセント文字がリテラルとして扱われるようにします:
# xgettext:no-python-format\noutput = _("10% interest")\n他の Django メッセージファイルと同じ方法で -- django-admin makemessages ツールを使って -- 作成や更新を行います。唯一の違いは、-d djangojs パラメータを提供することによって、gettext 用語がドメインであること (このケースでは djangojs ドメイン) を、以下のように明示的に指定する必要があることです:
django-admin makemessages -d djangojs -l de\nThis would create or update the message file for JavaScript for German. After\nupdating message files, run django-admin compilemessages the same way as you do with normal Django message files.
gettextLink to this heading#This is only needed for people who either want to extract message IDs or compile\nmessage files (.po). Translation work itself involves editing existing\nfiles of this type, but if you want to create your own message files, or want\nto test or compile a changed message file, download a precompiled binary\ninstaller.
You may also use gettext binaries you have obtained elsewhere, so long as\nthe xgettext --version command works properly. Do not attempt to use Django\ntranslation utilities with a gettext package if the command xgettext\n--version entered at a Windows command prompt causes a popup window saying\n"xgettext.exe has generated errors and will be closed by Windows".
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 redirect viewLink to this heading#As a convenience, Django comes with a view, django.views.i18n.set_language(),\nthat sets a user's language preference and redirects to a given URL or, by default,\nback to the previous page.
Activate this view by adding the following line to your URLconf:
\npath('i18n/', include('django.conf.urls.i18n')),\n(Note that this example makes the view available at /i18n/setlang/.)
The view expects to be called via the POST method, with a language\nparameter set in request. If session support is enabled, the view saves the\nlanguage choice in the user's session. It also saves the language choice in a\ncookie that is named django_language by default. (The name can be changed\nthrough the LANGUAGE_COOKIE_NAME setting.)
After setting the language choice, Django looks for a next parameter in the\nPOST or GET data. If that is found and Django considers it to be a safe\nURL (i.e. it doesn't point to a different host and uses a safe scheme), a\nredirect to that URL will be performed. Otherwise, Django may fall back to\nredirecting the user to the URL from the Referer header or, if it is not\nset, to /, depending on the nature of the request:
If the request accepts HTML content (based on its Accept HTTP header),\nthe fallback will always be performed.
If the request doesn't accept HTML, the fallback will be performed only if\nthe next parameter was set. Otherwise a 204 status code (No Content) will\nbe returned.
Here's example HTML template code:
\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>\nIn this example, Django looks up the URL of the page to which the user will be\nredirected in the redirect_to context variable.
You may want to set the active language for the current session explicitly. Perhaps\na user's language preference is retrieved from another system, for example.\nYou've already been introduced to django.utils.translation.activate(). That\napplies to the current thread only. To persist the language for the entire\nsession in a cookie, set the LANGUAGE_COOKIE_NAME cookie on the\nresponse:
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)\nYou would typically want to use both: django.utils.translation.activate()\nchanges the language for this thread, and setting the cookie makes this\npreference persist in future requests.
While Django provides a rich set of i18n tools for use in views and templates,\nit does not restrict the usage to Django-specific code. The Django translation\nmechanisms can be used to translate arbitrary texts to any language that is\nsupported by Django (as long as an appropriate translation catalog exists, of\ncourse). You can load a translation catalog, activate it and translate text to\nlanguage of your choice, but remember to switch back to original language, as\nactivating a translation catalog is done on per-thread basis and such change\nwill affect code running in the same thread.
\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\nCalling this function with the value 'de' will give you "Willkommen",\nregardless of LANGUAGE_CODE and language set by middleware.
Functions of particular interest are\ndjango.utils.translation.get_language() which returns the language used\nin the current thread, django.utils.translation.activate() which\nactivates a translation catalog for the current thread, and\ndjango.utils.translation.check_for_language()\nwhich checks if the given language is supported by Django.
To help write more concise code, there is also a context manager\ndjango.utils.translation.override() that stores the current language on\nenter and restores it on exit. With it, the above example becomes:
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.