Django プロジェクトを翻訳可能にするためには、Python コードやテンプレートに、多少のフックを加筆しなければなりません。このフックは 翻訳文字列 と呼ばれます。翻訳文字列は Django に「このテキストに対する翻訳が有効な場合、このテキストはエンドユーザの言語に翻訳すべきだ」ということを通知します。翻訳可能な文字列をマークすることは開発者の責任です。システムが翻訳できるのは指定された文字列だけなのです。
\nDjango は、翻訳文字列を メッセージファイル に抽出するユーティリティを提供します。このファイルがあるため、翻訳者が対象の言語において翻訳文字列に対応する文字列を用意することが簡単になります。翻訳者がメッセージファイルの中身を書き終わったら、それをコンパイルしなければなりません。このプロセスは GNU gettext ツー ルキットに依存しています。
\nこれが済めば、 Django はユーザの言語設定に従って、オンザフライでアプリケーションを利用可能な言語に翻訳するようになります。
\nDjango の国際化フックはデフォルトで有効になっており、これは、フレームワークの特定の箇所で i18n に関する小さなオーバーヘッドが発生することを意味します。国際化を使わない場合は、 USE_I18N = False を設定ファイルに記述してください。そうすれば Django は国際化の部品を読み込まないようにして多少の最適化をします。
翻訳対象の文字列を関数 ugettext() で指定します。タイプ数を減らすため、ugettext() を _ という別名で import するのが慣習的なやり方です。
この例では、"Welcome to my site." というテキストが翻訳文字列としてマークされています:
from django.utils.translation import ugettext as _\nfrom django.http import HttpResponse\n\ndef my_view(request):\n output = _("Welcome to my site.")\n return HttpResponse(output)\nもちろん、別名を付けなくても同じコードを書くことができます。次の例は、上の例とまったく同一です:
\nfrom django.utils.translation import ugettext\nfrom django.http import HttpResponse\n\ndef my_view(request):\n output = ugettext("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 の節で説明します。)
_() や ugettext() に渡す文字列には、Pyton の標準の名前付き補完構文によるプレースホルダを使えます。例えば:
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 Nobember, 26." に対して、スペイン語では "Hoy es 26 de Noviembre." となるように、月と日のプレースホルダの位置を入れ替えることができます。
この理由から、引数が複数ある場合には、固定引数を使った補完 (%s や %d) ではなく、名前付きの補完 (%(day)s) を使ってください。固定引数による補完を使った場合、プレースホルダを正しい順番で翻訳できない場合があります。
翻訳可能な文字列についてのヒントを翻訳者に示したい場合、文字列の直前の行で Translators キーワードでプレフィックスされたコメントを追加できます。例えば:
def my_view(request):\n # Translators: This message appears on the home page only\n output = ugettext("Welcome to my site.")\nコメントは、後に記述された翻訳可能な文章に関連付けられた、結果の .po ファイル内に表示され、ほとんどの翻訳ツールで表示されます。
これはテンプレート内でも動作します。詳しくは Comments for translators in templates を参照してください。
\n翻訳しない文字列としてマークするためには、django.utils.translation.ugettext_noop() を使ってください。文字列は、変数より後で翻訳されます。
ソース言語内に保持すべき構成文字列がある場合、これを使ってください。これは、システムやユーザー (たとえばデータベース内の文字列) を介して交換される一方で、最後の時点 (たとえばユーザに文字列が表示されるとき) で翻訳される必要があるからです。
\n複数形のメッセージを指定するには、関数 django.utils.translation.ungettext() を使ってください。
ungettext は 3 つの引数を取ります: 単数形の文字列、複数形の文字列、オブジェクトの数です。
この関数は、Django アプリケーションを数と 複数形 の複雑さが英語で 2 より大きい (その値にかかわらず、単数には 'object'、そして count が 1 ではない全ての場合に 'objects' となります。) 言語にローカル化させる必要がある場合に役立ちます。
For example:
\nfrom django.utils.translation import ungettext\nfrom django.http import HttpResponse\n\ndef hello_world(request, count):\n page = ungettext(\n 'there is %(count)d object',\n 'there are %(count)d objects',\n count) % {\n 'count': count,\n }\n return HttpResponse(page)\nこの例では、オブジェクトの数値は count 変数として翻訳言語に渡されます。
複数形は、複雑で言語によって異なる動作をすることに注意してください。count と 1 の比較は正しいルールではないことがあります。以下のコードは洗練されて見えますが、いくつかの言語に対しては誤った結果を生み出します:
from django.utils.translation import ungettext\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 = ungettext(\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 = ungettext(\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 行に出現します)、これらそれぞれに対して翻訳者が異なる翻訳ができるようにします。
For example:
\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 ""\n文脈マーカーは、trans and blocktrans テンプレートタグによってもサポートされています。
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 ugettext_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 ugettext_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 ugettext_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?')\nugettext_lazy() 呼び出しの結果は、他の Django コード内で unicode 文字列 (str オブジェクト) を使うときはいつでも使うことができますが、気まぐれな Python コードでうまく動作しないかもしれません。例えば、requests ライブラリが ugettext_lazy オブジェクトを処理しないので、以下は動作しません:
body = ugettext_lazy("I \\u2764 Django") # (unicode :heart:)\nrequests.post('https://example.com/send', data={'body': body})\nugettext_lazy() オブジェクトを非 Django コードに渡す前にテキスト文字列にキャストすることで、この問題を防ぐことができます:
requests.post('https://example.com/send', data={'body': str(body)})\nPython 2 では str の代わりに unicode を使ってください。もしくは、six.text_type が Python 2 と 3 をサポートします。
If you try to use a ugettext_lazy() result where a bytestring (a\nbytes object) is expected, things won't work as expected since a\nugettext_lazy() object doesn't know how to convert itself to a bytestring.\nYou can't use a unicode string inside a bytestring, either, so this is\nconsistent with normal Python behavior. For example, putting a unicode proxy\ninto a unicode string is fine:
"Hello %s" % ugettext_lazy("people")\nBut you can't insert a unicode object into a bytestring and nor can you insert\na unicode proxy there:
\nb"Hello %s" % ugettext_lazy("people")\nIf you ever see output that looks like "hello\n<django.utils.functional...>", you have tried to insert the result of\nugettext_lazy() into a bytestring. That's a bug in your code.
If you don't like the long ugettext_lazy name, you can just alias it as\n_ (underscore), like so:
from django.db import models\nfrom django.utils.translation import ugettext_lazy as _\n\nclass MyThing(models.Model):\n name = models.CharField(help_text=_('This is the help text'))\nUsing ugettext_lazy() and ungettext_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 ([u]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.utils.translation import ungettext_lazy\n\nclass MyForm(forms.Form):\n error_message = ungettext_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})\nIf the string contains exactly one unnamed placeholder, you can interpolate\ndirectly with the number argument:
class MyForm(forms.Form):\n error_message = ungettext_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#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 ugettext_lazy\n...\nname = ugettext_lazy('John Lennon')\ninstrument = ugettext_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 import six # Python 3 compatibility\nfrom django.utils.functional import lazy\nfrom django.utils.safestring import mark_safe\nfrom django.utils.translation import ugettext_lazy as _\n\nmark_safe_lazy = lazy(mark_safe, six.text_type)\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 している場合であっても、翻訳を使用する全てのテンプレートでロードする必要があります。
trans テンプレートタグLink to this heading#{% trans %} テンプレートタグは、(シングルクオートやダブルクオートで囲まれた) 定数文字列 や変数コンテンツを翻訳します:
<title>{% trans "This is the title." %}</title>\n<title>{% trans myvar %}</title>\nnoop オプションが存在する場合、変数はそのままですが翻訳の対象外となります。将来的に翻訳を必要とするコンテンツを "もみ消している" ときに役立ちます:
<title>{% trans "myvar" noop %}</title>\n内部的には、インラインの翻訳は ugettext() 呼び出しを使っています。
テンプレート var (上記の 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 キーワードを使う 文脈マーカー もサポートしています:
{% 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 タグ内に容れることはできません。
If resolving one of the block arguments fails, blocktrans will fall back to\nthe 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 {% blocktrans %} and\n{% endblocktrans %} tags.
実装例:
\n{% blocktrans count counter=list|length %}\nThere is only one {{ name }} object.\n{% plural %}\nThere are {{ counter }} {{ name }} objects.\n{% endblocktrans %}\nA more complex example:
\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 %}\nWhen you use both the pluralization feature and bind values to local variables\nin addition to the counter value, keep in mind that the blocktrans\nconstruct is internally converted to an ungettext call. This means the\nsame notes regarding ungettext variables\napply.
Reverse URL lookups cannot be carried out within the blocktrans and should\nbe retrieved (and stored) beforehand:
{% 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 }}">\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{% blocktrans %} also supports contextual\nmarkers using the context keyword:
{% blocktrans with name=user.username context "greeting" %}Hi {{ name }}{% endblocktrans %}\nAnother feature {% blocktrans %} supports is the trimmed option. This\noption will remove newline characters from the beginning and the end of the\ncontent of the {% blocktrans %} tag, replace any whitespace at the beginning\nand end of a line and merge all lines into one using a space character to\nseparate them. This is quite useful for indenting the content of a {%\nblocktrans %} tag without having the indentation characters end up in the\ncorresponding entry in the PO file, which makes the translation process easier.
For instance, the following {% blocktrans %} tag:
{% blocktrans trimmed %}\n First sentence.\n Second paragraph.\n{% endblocktrans %}\nwill result in the entry "First sentence. Second paragraph." in the PO file,\ncompared to "\\n First sentence.\\n Second sentence.\\n", if the trimmed\noption 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{% trans "View" %}\n\n{% comment %}Translators: Short intro blurb{% endcomment %}\n<p>{% blocktrans %}A multiline translatable\nliteral.{% endblocktrans %}</p>\nor with the {# ... #} one-line comment constructs:
{# 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 %}\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>{% 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 %}\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#A view that produces a JavaScript code library with functions that mimic\nthe gettext interface, plus an array of translation strings.
属性
\nビューの出力に追加する文字列を含む翻訳ドメインです。デフォルトは 'djangojs' です。
インストールされたアプリケーション間の application names のリストです。これらのアプリケーションは locale ディレクトリを含んでいる必要があります。これらのカタログに加えて (常に含まれている) LOCALE_PATHS`内で見つかった全てのカタログは、1 つのカタログに統合されます。デフォルトは ``None` で、全ての INSTALLED_APPS からの利用可能な翻訳は JavaScript の出力に渡されることを意味します。
デフォルト値を使った例:
\nfrom django.views.i18n import JavaScriptCatalog\n\nurlpatterns = [\n url(r'^jsi18n/$', JavaScriptCatalog.as_view(), name='javascript-catalog'),\n]\n独自のパッケージを使った例:
\nurlpatterns = [\n url(r'^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 url(r'^jsi18n/$', JavaScriptCatalog.as_view(), name='javascript-catalog'),\n)\n翻訳の優先事項は、packages 引数内で現れるパッケージに最初に現れるものより高い優先順位を付けることです。これは、同じ利他ラルに対して翻訳がクラッシュする場合に備えて重要です。
サイト上で複数の JavaScriptCatalog ビューを使っていてそのうちのいくつかが同じ文字列を定義している場合、最後にロードされたカタログ内の文字列が優先されます。
javascript_catalog ビューLink to this heading#The main solution to these problems is the\ndjango.views.i18n.javascript_catalog() view, which sends out a JavaScript\ncode library with functions that mimic the gettext interface, plus an array\nof translation strings. Those translation strings are taken from applications or\nDjango core, according to what you specify in either the info_dict or the\nURL. Paths listed in LOCALE_PATHS are also included.
You hook it up like this:
\nfrom django.views.i18n import javascript_catalog\n\njs_info_dict = {\n 'packages': ('your.app.package',),\n}\n\nurlpatterns = [\n url(r'^jsi18n/$', javascript_catalog, js_info_dict, name='javascript-catalog'),\n]\nEach string in packages should be in Python dotted-package syntax (the\nsame format as the strings in INSTALLED_APPS) and should refer to a\npackage that contains a locale directory. If you specify multiple packages,\nall those catalogs are merged into one catalog. This is useful if you have\nJavaScript that uses strings from different applications.
The precedence of translations is such that the packages appearing later in the\npackages argument have higher precedence than the ones appearing at the\nbeginning, this is important in the case of clashing translations for the same\nliteral.
By default, the view uses the djangojs gettext domain. This can be\nchanged by altering the domain argument.
You can make the view dynamic by putting the packages into the URL pattern:
\nurlpatterns = [\n url(r'^jsi18n/(?P<packages>\\S+?)/$', javascript_catalog, name='javascript-catalog'),\n]\nWith this, you specify the packages as a list of package names delimited by '+'\nsigns in the URL. This is especially useful if your pages use code from\ndifferent apps and this changes often and you don't want to pull in one big\ncatalog file. As a security measure, these values can only be either\ndjango.conf or any package from the INSTALLED_APPS setting.
You can also split the catalogs in multiple URLs and load them as you need in\nyour sites:
\njs_info_dict_app = {\n 'packages': ('your.app.package',),\n}\n\njs_info_dict_other_app = {\n 'packages': ('your.other.app.package',),\n}\n\nurlpatterns = [\n url(r'^jsi18n/app/$', javascript_catalog, js_info_dict_app),\n url(r'^jsi18n/other_app/$', javascript_catalog, js_info_dict_other_app),\n]\nIf you use more than one javascript_catalog on a site and some of them\ndefine the same strings, the strings in the catalog that was loaded last take\nprecedence.
The JavaScript translations found in the paths listed in the\nLOCALE_PATHS setting are also always included. To keep consistency\nwith the translations lookup order algorithm used for Python and templates, the\ndirectories listed in LOCALE_PATHS have the highest precedence with\nthe ones appearing first having higher precedence than the ones appearing\nlater.
カタログを使うには、以下のように動的に生成されたスクリプトを参照してください:
\n<script type="text/javascript" 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 関数は単語やフレーズを複数形にするインターフェースを提供します:
var object_count = 1 // or 0, or 2, or 3, ...\ns = ngettext('literal for the singular case',\n 'literal for the plural case', object_count);\ninterpolateLink to this heading#interpolate 関数は表示形式の文字列の動的な記入をサポートします。補完シンタックスは Python を模しているので、interpolate 関数は位置および名前付きの補完の両方をサポートします。
位置による補完: obj は、表示されるのと同じ順番で要素の値が一致する fmt プレースホルダ内で連続的に補完される JavaScript Array オブジェクトを含んでいます。例えば:
fmts = ngettext('There is %s object. Remaining: %s',\n 'There are %s objects. Remaining: %s', 11);\ns = interpolate(fmts, [11, 20]);\n// s is 'There are 11 objects. Remaining: 20'\n名前付きの補完: このモードは named パラメータを true として渡すことで選択されます。obj は JavaScript オブジェクトや結合配列を含みます。例えば:
d = {\n count: 10,\n total: 50\n};\n\nfmts = ngettext('Total: %(total)s, there is %(count)s object',\n'there are %(count)s of a total of %(total)s objects', d.count);\ns = interpolate(fmts, d, 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}\njson_catalog ビューLink to this heading#In order to use another client-side library to handle translations, you may\nwant to take advantage of the json_catalog() view. It's similar to\njavascript_catalog() but returns a JSON response.
The JSON object contains i18n formatting settings (those available for\nget_format), a plural rule (as a plural part of a GNU gettext\nPlural-Forms expression), and translation strings. The translation strings\nare taken from applications or Django's own translations, according to what is\nspecified either via urlpatterns arguments or as request parameters. Paths\nlisted in LOCALE_PATHS are also included.
The view is hooked up to your application and configured in the same fashion as\njavascript_catalog() (namely, the domain and\npackages arguments behave identically):
from django.views.i18n import json_catalog\n\njs_info_dict = {\n 'packages': ('your.app.package',),\n}\n\nurlpatterns = [\n url(r'^jsoni18n/$', json_catalog, js_info_dict),\n]\nレスポンスの形式は以下の通りです:
\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 url(r'^jsi18n/$',\n cache_page(86400, key_prefix='js18n-%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 url(r'^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 パターンのルートに言語のプレフィックスを追加します。
URL パターン自体を django.utils.translation.ugettext_lazy() 関数を通じて翻訳可能にする。
この関数は、ルートの URLconf で使うことができ、Django は自動的に現在アクティブな言語のコードを i18n_patterns() で定義された全ての URL パターンの先頭に追加します。
prefix_default_language を False にセットすると、デフォルト言語 (LANGUAGE_CODE) からプレフィックスを除去します。これは、現在の URL を変更しないよう既存のサイトに翻訳を追加するとき、役に立ちます。
URL パターンの例:
\nfrom django.conf.urls import include, url\nfrom django.conf.urls.i18n import i18n_patterns\n\nfrom about import views as about_views\nfrom news import views as news_views\nfrom sitemap.views import sitemap\n\nurlpatterns = [\n url(r'^sitemap\\.xml$', sitemap, name='sitemap-xml'),\n]\n\nnews_patterns = ([\n url(r'^$', news_views.index, name='index'),\n url(r'^category/(?P<slug>[\\w-]+)/$', news_views.category, name='category'),\n url(r'^(?P<slug>[\\w-]+)/$', news_views.details, name='detail'),\n], 'news')\n\nurlpatterns += i18n_patterns(\n url(r'^about/$', about_views.main, name='about'),\n url(r'^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 パターンは、ugettext_lazy() 関数を使って、翻訳可能にマークすることもできます。例えば:
from django.conf.urls import include, url\nfrom django.conf.urls.i18n import i18n_patterns\nfrom django.utils.translation import ugettext_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 url(r'^sitemap\\.xml$', sitemap, name='sitemap-xml'),\n]\n\nnews_patterns = ([\n url(r'^$', news_views.index, name='index'),\n url(_(r'^category/(?P<slug>[\\w-]+)/$'), news_views.category, name='category'),\n url(r'^(?P<slug>[\\w-]+)/$', news_views.details, name='detail'),\n], 'news')\n\nurlpatterns += i18n_patterns(\n url(_(r'^about/$'), about_views.main, name='about'),\n url(_(r'^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{% 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 などです。
スクリプトは、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\n.po ファイルのフォーマットは明快です。各 .po ファイルは、翻訳保守者の連絡先情報などのわずかなメタデータを含みますが、大部分は メッセージ のリストです -- 特定の言語に対する、翻訳文字列と実際の翻訳済みテキストの単純なマッピングです。
例えば以下のように、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\nugettext() がパーセント文字を伴う文字列内で python-format を誤って見つけてしまうLink to this heading#パーセント文字の後にスペースが続く場合や 文字列転換タイプ (例 _("10% 利率")) のようないくつかのケースでは、ugettext() は 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 ugettext 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\nこれは、ドイツ語に対して JavaScript 用のメッセージファイルを作成ないし更新します。メッセージファイルの更新後、通常の Django フィあると同様の方法で django-admin compilemessages を実行してください。
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 just involves editing existing\nfiles of this type, but if you want to create your own message files, or want to\ntest 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(Command, self).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(Command, self).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:
\nurl(r'^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\nsaves the language choice in the user's session. Otherwise, it saves the\nlanguage choice in a cookie that is by default named django_language.\n(The name can be changed through 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:
For AJAX requests, the fallback will be performed only if the next\nparameter was set. Otherwise a 204 status code (No Content) will be returned.
For non-AJAX requests, the fallback will always be performed.
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.
明示的に、現在のセッションに対して、アクティブな言語をセットしたくなるかもしれません。例えば、他のシステムを活用すれば、ユーザの言語設定を取得できます。django.utils.translation.activate() はすでに紹介済みですね。これは現在のスレッドに対してのみ適用されます。セッション全体を通して恒久的に言語設定を保持したい場合は、セッション内の LANGUAGE_SESSION_KEY を修正してください。
from django.utils import translation\nuser_language = 'fr'\ntranslation.activate(user_language)\nrequest.session[translation.LANGUAGE_SESSION_KEY] = user_language\n通常、両方を使う必要があるでしょう: django.utils.translation.activate() はこのスレッドに対して言語を変更します。そして、セッションを変更するとこの設定が将来のリクエストに恒久的に反映されます。
セッションを使用していない場合は、言語はクッキー内に保存されます。名前は LANGUAGE_COOKIE_NAME の中で設定します。例えば:
from django.utils import translation\nfrom django import http\nfrom django.conf import settings\nuser_language = 'fr'\ntranslation.activate(user_language)\nresponse = http.HttpResponse(...)\nresponse.set_cookie(settings.LANGUAGE_COOKIE_NAME, user_language)\nWhile 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.
\nFor example:
\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.ugettext('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.ugettext('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 just want to use the\ntranslations that come with Django -- you'll just need to activate translation\nfor your 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 the LANGUAGE_SESSION_KEY\nkey in the current user's session.
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.
Notes:
\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).
\nIf you define a custom LANGUAGES setting, as explained in the\nprevious bullet, you can mark the language names as translation strings\n-- but use ugettext_lazy() instead of\nugettext() to avoid a circular import.
以下はサンプルの設定ファイルです:
\nfrom django.utils.translation import ugettext_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 a simple 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.
This way, you can write applications that include their own translations, and\nyou can override base translations in your project. Or, you can just build\na big project 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\nSpanish as the default language and original strings written in Russian will\nfallback to Russian, not to Spanish.