controlflow.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# 秘湯 <xwhhsprings@gmail.com>, 2017
# Inada Naoki <songofacandy@gmail.com>, 2017
# yatszhash, 2017
# Nozomu Kaneko <nozom.kaneko@gmail.com>, 2017
# E. Kawashima, 2017
# Arihiro TAKASE, 2017
# Osamu NAKAMURA, 2017
# kento <k.denjiry@gmail.com>, 2018
# Yuta Kanzawa, 2019
# tomo, 2020
# samuel300z <samuel300z@gmail.com>, 2020
# mollinaca, 2021
# Yusuke Miyazaki <miyazaki.dev@gmail.com>, 2021
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.9\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-06-28 06:43+0000\n"
"PO-Revision-Date: 2017-02-16 23:40+0000\n"
"Last-Translator: Yusuke Miyazaki <miyazaki.dev@gmail.com>, 2021\n"
"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/"
"ja/)\n"
"Language: ja\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../tutorial/controlflow.rst:5
msgid "More Control Flow Tools"
msgstr "その他の制御フローツール"

#: ../../tutorial/controlflow.rst:7
msgid ""
"Besides the :keyword:`while` statement just introduced, Python uses the "
"usual flow control statements known from other languages, with some twists."
msgstr ""
"先ほど説明のあった :keyword:`while` 文に加えて、他の言語での経験から分かるよ"
"うな通常のフロー制御文を少し工夫を効かせて使用します。"

#: ../../tutorial/controlflow.rst:14
msgid ":keyword:`!if` Statements"
msgstr ":keyword:`!if` 文"

#: ../../tutorial/controlflow.rst:16
msgid ""
"Perhaps the most well-known statement type is the :keyword:`if` statement.  "
"For example::"
msgstr "おそらく最もおなじみの文型は :keyword:`if` 文でしょう。例えば::"

#: ../../tutorial/controlflow.rst:33
msgid ""
"There can be zero or more :keyword:`elif` parts, and the :keyword:`else` "
"part is optional.  The keyword ':keyword:`!elif`' is short for 'else if', "
"and is useful to avoid excessive indentation.  An  :keyword:`!if` ... :"
"keyword:`!elif` ... :keyword:`!elif` ... sequence is a substitute for the "
"``switch`` or ``case`` statements found in other languages."
msgstr ""
"ゼロ個以上の :keyword:`elif` 部を使うことができ、 :keyword:`else` 部を付ける"
"こともできます。キーワード ':keyword:`!elif`' は 'else if' を短くしたもので、"
"過剰なインデントを避けるのに役立ちます。一連の :keyword:`!if` ... :keyword:`!"
"elif` ... :keyword:`!elif` ...  は、他の言語における ``switch`` 文や "
"``case`` 文の代用となります。"

#: ../../tutorial/controlflow.rst:43
msgid ":keyword:`!for` Statements"
msgstr ":keyword:`!for` 文"

#: ../../tutorial/controlflow.rst:48
msgid ""
"The :keyword:`for` statement in Python differs a bit from what you may be "
"used to in C or Pascal.  Rather than always iterating over an arithmetic "
"progression of numbers (like in Pascal), or giving the user the ability to "
"define both the iteration step and halting condition (as C), Python's :"
"keyword:`!for` statement iterates over the items of any sequence (a list or "
"a string), in the order that they appear in the sequence.  For example (no "
"pun intended):"
msgstr ""
"Python の :keyword:`for` 文は、読者が C 言語や Pascal 言語で使いなれているか"
"もしれない :keyword:`for` 文とは少し違います。 (Pascal のように) 常に算術型の"
"数列にわたる反復を行ったり、 (C のように) 繰返しステップと停止条件を両方とも"
"ユーザが定義できるようにするのとは違い、Python の :keyword:`!for` 文は、任意"
"のシーケンス型 (リストまたは文字列) にわたって反復を行います。反復の順番は"
"シーケンス中に要素が現れる順番です。例えば:"

#: ../../tutorial/controlflow.rst:69
msgid ""
"Code that modifies a collection while iterating over that same collection "
"can be tricky to get right.  Instead, it is usually more straight-forward to "
"loop over a copy of the collection or to create a new collection::"
msgstr ""
"コレクションオブジェクトの値を反復処理をしているときに、そのコレクションオブ"
"ジェクトを変更するコードは理解するのが面倒になり得ます。\n"
"そうするよりも、コレクションオブジェクトのコピーに対して反復処理をするか、新"
"しいコレクションオブジェクトを作成する方が通常は理解しやすいです::"

#: ../../tutorial/controlflow.rst:88
msgid "The :func:`range` Function"
msgstr ":func:`range` 関数"

#: ../../tutorial/controlflow.rst:90
msgid ""
"If you do need to iterate over a sequence of numbers, the built-in function :"
"func:`range` comes in handy.  It generates arithmetic progressions::"
msgstr ""
"数列にわたって反復を行う必要がある場合、組み込み関数 :func:`range`  が便利で"
"す。この関数は算術型の数列を生成します::"

#: ../../tutorial/controlflow.rst:102
msgid ""
"The given end point is never part of the generated sequence; ``range(10)`` "
"generates 10 values, the legal indices for items of a sequence of length "
"10.  It is possible to let the range start at another number, or to specify "
"a different increment (even negative; sometimes this is called the 'step')::"
msgstr ""
"指定した終端値は生成されるシーケンスには入りません。``range(10)`` は 10 個の"
"値を生成し、長さ 10 のシーケンスにおける各項目のインデクスとなります。range "
"を別の数から開始したり、他の増加量 (負でも; 増加量は時に 'ステップ(step)' と"
"呼ばれることもあります) を指定することもできます::"

#: ../../tutorial/controlflow.rst:116
msgid ""
"To iterate over the indices of a sequence, you can combine :func:`range` "
"and :func:`len` as follows::"
msgstr ""
"あるシーケンスにわたってインデクスで反復を行うには、 :func:`range` と :func:"
"`len` を次のように組み合わせられます::"

#: ../../tutorial/controlflow.rst:129
msgid ""
"In most such cases, however, it is convenient to use the :func:`enumerate` "
"function, see :ref:`tut-loopidioms`."
msgstr ""
"しかし、多くの場合は :func:`enumerate` 関数を使う方が便利です。 :ref:`tut-"
"loopidioms` を参照してください。"

#: ../../tutorial/controlflow.rst:132
msgid "A strange thing happens if you just print a range::"
msgstr "range を直接出力すると変なことになります::"

#: ../../tutorial/controlflow.rst:137
msgid ""
"In many ways the object returned by :func:`range` behaves as if it is a "
"list, but in fact it isn't. It is an object which returns the successive "
"items of the desired sequence when you iterate over it, but it doesn't "
"really make the list, thus saving space."
msgstr ""
":func:`range` が返すオブジェクトは、いろいろな点でリストであるかのように振る"
"舞いますが、本当はリストではありません。これは、イテレートした時に望んだ数列"
"の連続した要素を返すオブジェクトです。しかし実際にリストを作るわけではないの"
"で、スペースの節約になります。"

#: ../../tutorial/controlflow.rst:142
msgid ""
"We say such an object is :term:`iterable`, that is, suitable as a target for "
"functions and constructs that expect something from which they can obtain "
"successive items until the supply is exhausted.  We have seen that the :"
"keyword:`for` statement is such a construct, while an example of a function "
"that takes an iterable is :func:`sum`::"
msgstr ""
"このようなオブジェクトは :term:`イテラブル (iterable)` と呼ばれます。\n"
"これらは関数や構成物のターゲットとして、あるだけの項目を逐次与えるのに適して"
"います。\n"
":keyword:`for` 文がそのような構成物であることはすでに見てきており、イテラブル"
"を受け取る関数の例には :func:`sum` があります::"

#: ../../tutorial/controlflow.rst:151
msgid ""
"Later we will see more functions that return iterables and take iterables as "
"arguments.  In chapter :ref:`tut-structures`, we will discuss in more detail "
"about :func:`list`."
msgstr ""
"この後には、イテラブルを返したりイテラブルを引数で受け取るいくつかの関数が出"
"てきます。 :ref:`tut-structures` では、 :func:`list` についてより詳しく説明し"
"ます。"

#: ../../tutorial/controlflow.rst:158
msgid ""
":keyword:`!break` and :keyword:`!continue` Statements, and :keyword:`!else` "
"Clauses on Loops"
msgstr ""
":keyword:`!break` 文と :keyword:`!continue` 文とループの :keyword:`!else` 節"

#: ../../tutorial/controlflow.rst:160
msgid ""
"The :keyword:`break` statement, like in C, breaks out of the innermost "
"enclosing :keyword:`for` or :keyword:`while` loop."
msgstr ""
":keyword:`break` 文は、C 言語と同じく、最も内側の :keyword:`for` または :"
"keyword:`while` ループを中断します。"

#: ../../tutorial/controlflow.rst:163
msgid ""
"Loop statements may have an :keyword:`!else` clause; it is executed when the "
"loop terminates through exhaustion of the iterable (with :keyword:`for`) or "
"when the condition becomes false (with :keyword:`while`), but not when the "
"loop is terminated by a :keyword:`break` statement.  This is exemplified by "
"the following loop, which searches for prime numbers::"
msgstr ""
"ループ文は :keyword:`!else` 節を持つことができます。これは、 (:keyword:`for` "
"で) イテラブルを使い切ってループが終了したとき、または (:keyword:`while` で) "
"条件が偽になったときに実行されますが、 :keyword:`break` 文でループが終了した"
"ときは実行されません。この動作を、素数を探す下記のループを例にとって示しま"
"す::"

#: ../../tutorial/controlflow.rst:187
msgid ""
"(Yes, this is the correct code.  Look closely: the ``else`` clause belongs "
"to the :keyword:`for` loop, **not** the :keyword:`if` statement.)"
msgstr ""
"(そう、これは正しいコードです。よく見てください: ``else`` 節は :keyword:`if` "
"文 **ではなく** 、 :keyword:`for` ループに属しています。)"

#: ../../tutorial/controlflow.rst:190
msgid ""
"When used with a loop, the ``else`` clause has more in common with the "
"``else`` clause of a :keyword:`try` statement than it does with that of :"
"keyword:`if` statements: a :keyword:`try` statement's ``else`` clause runs "
"when no exception occurs, and a loop's ``else`` clause runs when no "
"``break`` occurs. For more on the :keyword:`!try` statement and exceptions, "
"see :ref:`tut-handling`."
msgstr ""
"ループの ``else`` 句は、 :keyword:`if` 文の ``else`` よりも :keyword:`try` 文"
"の ``else`` に似ています。 :keyword:`try` 文の ``else`` 句は例外が発生しな"
"かった時に実行され、ループの ``else`` 句は ``break`` されなかった場合に実行さ"
"れます。 :keyword:`!try` 文と例外についての詳細は :ref:`tut-handling` を参照"
"してください。"

#: ../../tutorial/controlflow.rst:197
msgid ""
"The :keyword:`continue` statement, also borrowed from C, continues with the "
"next iteration of the loop::"
msgstr ""
":keyword:`continue` 文も C 言語から借りてきたもので、ループの次のイテレーショ"
"ンを実行します::"

#: ../../tutorial/controlflow.rst:218
msgid ":keyword:`!pass` Statements"
msgstr ":keyword:`!pass` 文"

#: ../../tutorial/controlflow.rst:220
msgid ""
"The :keyword:`pass` statement does nothing. It can be used when a statement "
"is required syntactically but the program requires no action. For example::"
msgstr ""
":keyword:`pass` 文は何もしません。 :keyword:`pass` は、文を書くことが構文上要"
"求されているが、プログラム上何の動作もする必要がない時に使われます::"

#: ../../tutorial/controlflow.rst:227
msgid "This is commonly used for creating minimal classes::"
msgstr "これは最小のクラスを作るときによく使われる方法です::"

#: ../../tutorial/controlflow.rst:233
msgid ""
"Another place :keyword:`pass` can be used is as a place-holder for a "
"function or conditional body when you are working on new code, allowing you "
"to keep thinking at a more abstract level.  The :keyword:`!pass` is silently "
"ignored::"
msgstr ""
":keyword:`pass` のもう 1 つの使い道は、新しいコードを書いているときの関数や条"
"件文の仮置きの本体としてです。こうすることで、より抽象的なレベルで考え続けら"
"れます。\n"
":keyword:`!pass` は何事も無く無視されます ::"

#: ../../tutorial/controlflow.rst:244
msgid "Defining Functions"
msgstr "関数を定義する"

#: ../../tutorial/controlflow.rst:246
msgid ""
"We can create a function that writes the Fibonacci series to an arbitrary "
"boundary::"
msgstr ""
"フィボナッチ数列 (Fibonacci series) を任意の上限値まで書き出すような関数を作"
"成できます::"

#: ../../tutorial/controlflow.rst:266
msgid ""
"The keyword :keyword:`def` introduces a function *definition*.  It must be "
"followed by the function name and the parenthesized list of formal "
"parameters. The statements that form the body of the function start at the "
"next line, and must be indented."
msgstr ""
":keyword:`def` は関数の *定義 (definition)* を導くキーワードです。 :keyword:"
"`def` の後には、関数名と仮引数を丸括弧で囲んだリストを続けなければなりませ"
"ん。関数の実体を構成する実行文は次の行から始め、インデントされていなければな"
"りません。"

#: ../../tutorial/controlflow.rst:271
msgid ""
"The first statement of the function body can optionally be a string literal; "
"this string literal is the function's documentation string, or :dfn:"
"`docstring`. (More about docstrings can be found in the section :ref:`tut-"
"docstrings`.) There are tools which use docstrings to automatically produce "
"online or printed documentation, or to let the user interactively browse "
"through code; it's good practice to include docstrings in code that you "
"write, so make a habit of it."
msgstr ""
"関数の本体の記述する文の最初の行は文字列リテラルにすることもできます。その場"
"合、この文字列は関数のドキュメンテーション文字列 (documentation string)、また"
"は :dfn:`docstring` と呼ばれます。 (docstring については :ref:`tut-"
"docstrings` でさらに扱っています。) ドキュメンテーション文字列を使ったツール"
"には、オンライン文書や印刷文書を自動的に生成したり、ユーザが対話的にコードか"
"ら直接閲覧できるようにするものがあります。自分が書くコードにドキュメンテー"
"ション文字列を入れるのはよい習慣です。書く癖をつけてください。"

#: ../../tutorial/controlflow.rst:278
msgid ""
"The *execution* of a function introduces a new symbol table used for the "
"local variables of the function.  More precisely, all variable assignments "
"in a function store the value in the local symbol table; whereas variable "
"references first look in the local symbol table, then in the local symbol "
"tables of enclosing functions, then in the global symbol table, and finally "
"in the table of built-in names. Thus, global variables and variables of "
"enclosing functions cannot be directly assigned a value within a function "
"(unless, for global variables, named in a :keyword:`global` statement, or, "
"for variables of enclosing functions, named in a :keyword:`nonlocal` "
"statement), although they may be referenced."
msgstr ""
"関数を *実行 (execution)* するとき、関数のローカル変数のために使われる新たな"
"シンボルテーブル (symbol table) が用意されます。\n"
"もっと正確にいうと、関数内で変数への代入を行うと、その値はすべてこのローカル"
"なシンボルテーブルに記憶されます。\n"
"一方、変数の参照を行うと、まずローカルなシンボルテーブルが検索され、次にさら"
"に外側の関数のローカルなシンボルテーブルを検索し、その後グローバルなシンボル"
"テーブルを調べ、最後に組み込みの名前テーブルを調べます。\n"
"従って、関数の中では (グローバル変数が :keyword:`global` 文で指定されていた"
"り、外側の関数の変数が :keyword:`nonlocal` 文で指定されていない限り) グローバ"
"ル変数や外側の関数の変数に直接値を代入できませんが、参照することはできます。"

#: ../../tutorial/controlflow.rst:289
msgid ""
"The actual parameters (arguments) to a function call are introduced in the "
"local symbol table of the called function when it is called; thus, arguments "
"are passed using *call by value* (where the *value* is always an object "
"*reference*, not the value of the object). [#]_ When a function calls "
"another function, or calls itself recursively, a new local symbol table is "
"created for that call."
msgstr ""
"関数を呼び出す際の実際の引数 (実引数) は、関数が呼び出されるときに関数のロー"
"カルなシンボルテーブル内に取り込まれます。そうすることで、実引数は *値渡し "
"(call by value)* で関数に渡されることになります (ここでの *値 (value)* とは常"
"にオブジェクトへの *参照(reference)* をいい、オブジェクトの値そのものではあり"
"ません) [#]_。ある関数がほかの関数を呼び出すときや、自身を再帰的に呼び出すと"
"きには、新たな呼び出しのためにローカルなシンボルテーブルが新たに作成されま"
"す。"

#: ../../tutorial/controlflow.rst:296
msgid ""
"A function definition associates the function name with the function object "
"in the current symbol table.  The interpreter recognizes the object pointed "
"to by that name as a user-defined function.  Other names can also point to "
"that same function object and can also be used to access the function::"
msgstr ""
"関数の定義を行うと、関数名は関数オブジェクトとともに現在のシンボルテーブル内"
"に取り入れられます。インタープリタはその名前が指すオブジェクトをユーザ定義関"
"数 (user-defined function) として認識します。他の名前も同じ関数オブジェクトを"
"指すことができ、またその関数にアクセスするために使用することができます::"

#: ../../tutorial/controlflow.rst:307
msgid ""
"Coming from other languages, you might object that ``fib`` is not a function "
"but a procedure since it doesn't return a value.  In fact, even functions "
"without a :keyword:`return` statement do return a value, albeit a rather "
"boring one.  This value is called ``None`` (it's a built-in name).  Writing "
"the value ``None`` is normally suppressed by the interpreter if it would be "
"the only value written. You can see it if you really want to using :func:"
"`print`::"
msgstr ""
"他の言語出身の人からは、 ``fib`` は値を返さないので関数ではなく手続き "
"(procedure) だと異論があるかもしれませんね。技術的に言えば、実際には :"
"keyword:`return` 文を持たない関数もややつまらない値ですが値を返しています。こ"
"の値は ``None`` と呼ばれます (これは組み込みの名前です)。 ``None`` だけを書き"
"出そうとすると、インタプリタは通常出力を抑制します。本当に出力したいのなら、"
"以下のように :func:`print` を使うと見ることができます::"

#: ../../tutorial/controlflow.rst:318
msgid ""
"It is simple to write a function that returns a list of the numbers of the "
"Fibonacci series, instead of printing it::"
msgstr ""
"フィボナッチ数列の数からなるリストを出力する代わりに、値を返すような関数を書"
"くのは簡単です::"

#: ../../tutorial/controlflow.rst:334
msgid "This example, as usual, demonstrates some new Python features:"
msgstr "この例は Python の新しい機能を示しています:"

#: ../../tutorial/controlflow.rst:336
msgid ""
"The :keyword:`return` statement returns with a value from a function. :"
"keyword:`!return` without an expression argument returns ``None``. Falling "
"off the end of a function also returns ``None``."
msgstr ""
":keyword:`return` 文では、関数から一つ値を返します。 :keyword:`!return` の引"
"数となる式がない場合、 ``None`` が返ります。関数が終了したときにも ``None`` "
"が返ります。"

#: ../../tutorial/controlflow.rst:340
msgid ""
"The statement ``result.append(a)`` calls a *method* of the list object "
"``result``.  A method is a function that 'belongs' to an object and is named "
"``obj.methodname``, where ``obj`` is some object (this may be an "
"expression), and ``methodname`` is the name of a method that is defined by "
"the object's type. Different types define different methods.  Methods of "
"different types may have the same name without causing ambiguity.  (It is "
"possible to define your own object types and methods, using *classes*, see :"
"ref:`tut-classes`) The method :meth:`append` shown in the example is defined "
"for list objects; it adds a new element at the end of the list.  In this "
"example it is equivalent to ``result = result + [a]``, but more efficient."
msgstr ""
"文 ``result.append(a)`` では、リストオブジェクト ``result`` の *メソッド "
"(method)* を呼び出しています。メソッドとは、オブジェクトに '属している' 関数"
"のことで、 ``obj`` を何らかのオブジェクト (式であっても構いません)、 "
"``methodname`` をそのオブジェクトで定義されているメソッド名とすると、 ``obj."
"methodname`` と書き表されます。異なる型は異なるメソッドを定義しています。異な"
"る型のメソッドで同じ名前のメソッドを持つことができ、あいまいさを生じることは"
"ありません。 (*クラス (class)* を使うことで、自前のオブジェクト型とメソッドを"
"定義することもできます。 :ref:`tut-classes` 参照) 例で示されているメソッド :"
"meth:`append` は、リストオブジェクトで定義されています; このメソッドはリスト"
"の末尾に新たな要素を追加します。この例での :meth:`append` は ``result = "
"result + [a]`` と等価ですが、より効率的です。"

#: ../../tutorial/controlflow.rst:355
msgid "More on Defining Functions"
msgstr "関数定義についてもう少し"

#: ../../tutorial/controlflow.rst:357
msgid ""
"It is also possible to define functions with a variable number of arguments. "
"There are three forms, which can be combined."
msgstr ""
"可変個の引数を伴う関数を定義することもできます。引数の定義方法には 3 つの形式"
"があり、それらを組み合わせることができます。"

#: ../../tutorial/controlflow.rst:364
msgid "Default Argument Values"
msgstr "デフォルトの引数値"

#: ../../tutorial/controlflow.rst:366
msgid ""
"The most useful form is to specify a default value for one or more "
"arguments. This creates a function that can be called with fewer arguments "
"than it is defined to allow.  For example::"
msgstr ""
"もっとも便利なのは、一つ以上の引数に対してデフォルトの値を指定する形式です。"
"この形式を使うと、定義されている引数より少ない個数の引数で呼び出せる関数を作"
"成します::"

#: ../../tutorial/controlflow.rst:382
msgid "This function can be called in several ways:"
msgstr "この関数はいくつかの方法で呼び出せます:"

#: ../../tutorial/controlflow.rst:384
msgid ""
"giving only the mandatory argument: ``ask_ok('Do you really want to quit?')``"
msgstr "必須の引数のみ与える: ``ask_ok('Do you really want to quit?')``"

#: ../../tutorial/controlflow.rst:386
msgid ""
"giving one of the optional arguments: ``ask_ok('OK to overwrite the file?', "
"2)``"
msgstr ""
"一つのオプション引数を与える: ``ask_ok('OK to overwrite the file?', 2)``"

#: ../../tutorial/controlflow.rst:388
msgid ""
"or even giving all arguments: ``ask_ok('OK to overwrite the file?', 2, 'Come "
"on, only yes or no!')``"
msgstr ""
"全ての引数を与える: ``ask_ok('OK to overwrite the file?', 2, 'Come on, only "
"yes or no!')``"

#: ../../tutorial/controlflow.rst:391
msgid ""
"This example also introduces the :keyword:`in` keyword. This tests whether "
"or not a sequence contains a certain value."
msgstr ""
"この例では :keyword:`in` キーワードが導入されています。このキーワードはシーケ"
"ンスが特定の値を含んでいるかどうか調べるのに使われます。"

#: ../../tutorial/controlflow.rst:394
msgid ""
"The default values are evaluated at the point of function definition in the "
"*defining* scope, so that ::"
msgstr ""
"デフォルト値は、関数が定義された時点で、関数を *定義している* 側のスコープ "
"(scope) で評価されるので ::"

#: ../../tutorial/controlflow.rst:405
msgid "will print ``5``."
msgstr "は ``5`` を出力します。"

#: ../../tutorial/controlflow.rst:407
msgid ""
"**Important warning:**  The default value is evaluated only once. This makes "
"a difference when the default is a mutable object such as a list, "
"dictionary, or instances of most classes.  For example, the following "
"function accumulates the arguments passed to it on subsequent calls::"
msgstr ""
"**重要な警告:**  デフォルト値は 1 度だけしか評価されません。デフォルト値がリ"
"ストや辞書のような変更可能なオブジェクトの時にはその影響がでます。例えば以下"
"の関数は、後に続く関数呼び出しで関数に渡されている引数を累積します::"

#: ../../tutorial/controlflow.rst:420
msgid "This will print ::"
msgstr "このコードは、以下を出力します ::"

#: ../../tutorial/controlflow.rst:426
msgid ""
"If you don't want the default to be shared between subsequent calls, you can "
"write the function like this instead::"
msgstr ""
"後続の関数呼び出しでデフォルト値を共有したくなければ、代わりに以下のように関"
"数を書くことができます::"

#: ../../tutorial/controlflow.rst:439
msgid "Keyword Arguments"
msgstr "キーワード引数"

#: ../../tutorial/controlflow.rst:441
msgid ""
"Functions can also be called using :term:`keyword arguments <keyword "
"argument>` of the form ``kwarg=value``.  For instance, the following "
"function::"
msgstr ""
"関数を ``kwarg=value`` という形式の :term:`キーワード引数 <Keyword "
"argument>` を使って呼び出すこともできます。例えば、以下の関数::"

#: ../../tutorial/controlflow.rst:450
msgid ""
"accepts one required argument (``voltage``) and three optional arguments "
"(``state``, ``action``, and ``type``).  This function can be called in any "
"of the following ways::"
msgstr ""
"は、必須引数 (``voltage``) とオプション引数 (``state``、``action``、"
"``type``) を受け付けます。この関数は以下のいずれかの方法で呼び出せます::"

#: ../../tutorial/controlflow.rst:461
msgid "but all the following calls would be invalid::"
msgstr "が、以下の呼び出しは不適切です::"

#: ../../tutorial/controlflow.rst:468
msgid ""
"In a function call, keyword arguments must follow positional arguments. All "
"the keyword arguments passed must match one of the arguments accepted by the "
"function (e.g. ``actor`` is not a valid argument for the ``parrot`` "
"function), and their order is not important.  This also includes non-"
"optional arguments (e.g. ``parrot(voltage=1000)`` is valid too). No argument "
"may receive a value more than once. Here's an example that fails due to this "
"restriction::"
msgstr ""
"関数の呼び出しにおいて、キーワード引数は位置引数の後でなければなりません。渡"
"されるキーワード引数は全て、関数で受け付けられる引数のいずれかに対応していな"
"ければならず (例えば、``actor`` はこの ``parrot`` 関数の引数として適切ではあ"
"りません)、順序は重要ではありません。これはオプションでない引数でも同様です "
"(例えば、``parrot(voltage=1000)`` も適切です)。いかなる引数も値を複数回は受け"
"取れません。この制限により失敗する例は::"

#: ../../tutorial/controlflow.rst:484
msgid ""
"When a final formal parameter of the form ``**name`` is present, it receives "
"a dictionary (see :ref:`typesmapping`) containing all keyword arguments "
"except for those corresponding to a formal parameter.  This may be combined "
"with a formal parameter of the form ``*name`` (described in the next "
"subsection) which receives a :ref:`tuple <tut-tuples>` containing the "
"positional arguments beyond the formal parameter list.  (``*name`` must "
"occur before ``**name``.) For example, if we define a function like this::"
msgstr ""
"仮引数の最後に ``**name`` の形式のものがあると、それまでの仮引数に対応したも"
"のを除くすべてのキーワード引数が入った辞書 (:ref:`typesmapping` を参照) を受"
"け取ります。\n"
"``**name`` は ``*name`` の形式をとる、仮引数のリストを超えた位置引数の入っ"
"た :ref:`タプル <tut-tuples>` を受け取る引数 (次の小節で述べます) と組み合わ"
"せられます。\n"
"(``*name`` は ``**name`` より前になければなりません)。\n"
"例えば、ある関数の定義を以下のようにすると::"

#: ../../tutorial/controlflow.rst:501
msgid "It could be called like this::"
msgstr "呼び出しは以下のようになり::"

#: ../../tutorial/controlflow.rst:509
msgid "and of course it would print:"
msgstr "もちろん以下のように出力されます:"

#: ../../tutorial/controlflow.rst:522
msgid ""
"Note that the order in which the keyword arguments are printed is guaranteed "
"to match the order in which they were provided in the function call."
msgstr ""
"なお、複数のキーワード引数を与えた場合に、それらが出力される順序は、関数呼び"
"出しで与えられた順序と同じになります。"

#: ../../tutorial/controlflow.rst:526
msgid "Special parameters"
msgstr "特殊なパラメータ"

#: ../../tutorial/controlflow.rst:528
msgid ""
"By default, arguments may be passed to a Python function either by position "
"or explicitly by keyword. For readability and performance, it makes sense to "
"restrict the way arguments can be passed so that a developer need only look "
"at the function definition to determine if items are passed by position, by "
"position or keyword, or by keyword."
msgstr ""
"デフォルトでは、引数は位置またはキーワードによる明示で Python 関数に渡されま"
"す。\n"
"可読性とパフォーマンスのために、その引数が位置、位置またはキーワード、キー"
"ワードのどれで渡されるかを開発者が判定するのに関数定義だけを見ればよいよう"
"に、引数の渡され方を制限することには意味があります。"

#: ../../tutorial/controlflow.rst:534
msgid "A function definition may look like:"
msgstr "関数定義は次のようになります:"

#: ../../tutorial/controlflow.rst:545
msgid ""
"where ``/`` and ``*`` are optional. If used, these symbols indicate the kind "
"of parameter by how the arguments may be passed to the function: positional-"
"only, positional-or-keyword, and keyword-only. Keyword parameters are also "
"referred to as named parameters."
msgstr ""
"ここで、``/`` と ``*`` はオプションです。使用された場合、これらの記号は、引数"
"が関数に渡される方法、すなわち、位置専用、位置またはキーワード、キーワード専"
"用、といった引数の種類を示します。キーワード引数は、名前付き引数とも呼ばれま"
"す。"

#: ../../tutorial/controlflow.rst:552
msgid "Positional-or-Keyword Arguments"
msgstr "位置またはキーワード引数"

#: ../../tutorial/controlflow.rst:554
msgid ""
"If ``/`` and ``*`` are not present in the function definition, arguments may "
"be passed to a function by position or by keyword."
msgstr ""
"関数定義に ``/`` も ``*`` もない場合は、引数は位置またはキーワードで関数に渡"
"されます。"

#: ../../tutorial/controlflow.rst:559
msgid "Positional-Only Parameters"
msgstr "位置専用引数"

#: ../../tutorial/controlflow.rst:561
msgid ""
"Looking at this in a bit more detail, it is possible to mark certain "
"parameters as *positional-only*. If *positional-only*, the parameters' order "
"matters, and the parameters cannot be passed by keyword. Positional-only "
"parameters are placed before a ``/`` (forward-slash). The ``/`` is used to "
"logically separate the positional-only parameters from the rest of the "
"parameters. If there is no ``/`` in the function definition, there are no "
"positional-only parameters."
msgstr ""
"これをもう少し詳しく見てみると、特定の引数を *位置専用* と印を付けられま"
"す。\n"
"*位置専用* の場合、引数の順序が重要であり、キーワードで引数を渡せません。\n"
"位置専用引数は ``/`` （スラッシュ）の前に配置されます。\n"
"``/`` は、位置専用引数を残りの引数から論理的に分離するために使用されます。\n"
"関数定義に ``/`` がない場合、位置専用引数はありません。"

#: ../../tutorial/controlflow.rst:569
msgid ""
"Parameters following the ``/`` may be *positional-or-keyword* or *keyword-"
"only*."
msgstr ""
"``/`` の後の引数は、 *位置またはキーワード* 、もしくは、 *キーワード専用* で"
"す。"

#: ../../tutorial/controlflow.rst:573
msgid "Keyword-Only Arguments"
msgstr "キーワード専用引数"

#: ../../tutorial/controlflow.rst:575
msgid ""
"To mark parameters as *keyword-only*, indicating the parameters must be "
"passed by keyword argument, place an ``*`` in the arguments list just before "
"the first *keyword-only* parameter."
msgstr ""
"引数をキーワード引数で渡す必要があることを示す *キーワード専用* として引数を"
"マークするには、引数リストの最初の *キーワード専用* 引数の直前に  ``*`` を配"
"置します。"

#: ../../tutorial/controlflow.rst:581
msgid "Function Examples"
msgstr "関数の例"

#: ../../tutorial/controlflow.rst:583
msgid ""
"Consider the following example function definitions paying close attention "
"to the markers ``/`` and ``*``::"
msgstr ""
"``/`` および ``*`` といったマーカーに注意を払って、次の関数定義の例を見てくだ"
"さい::"

#: ../../tutorial/controlflow.rst:599
msgid ""
"The first function definition, ``standard_arg``, the most familiar form, "
"places no restrictions on the calling convention and arguments may be passed "
"by position or keyword::"
msgstr ""
"最も馴染みのある形式の最初の関数定義 ``standard_arg``  は、呼び出し規約に制限"
"を設けておらず、引数は位置またはキーワードで渡されます::"

#: ../../tutorial/controlflow.rst:609
msgid ""
"The second function ``pos_only_arg`` is restricted to only use positional "
"parameters as there is a ``/`` in the function definition::"
msgstr ""
"2番目の関数の ``pos_only_arg`` は、 ``/`` が関数定義にあるので、引数は位置専"
"用になります::"

#: ../../tutorial/controlflow.rst:620
msgid ""
"The third function ``kwd_only_args`` only allows keyword arguments as "
"indicated by a ``*`` in the function definition::"
msgstr ""
"3番目の関数 ``kwd_only_args`` は、関数定義に ``*`` があるので、引数はキーワー"
"ド専用になります::"

#: ../../tutorial/controlflow.rst:631
msgid ""
"And the last uses all three calling conventions in the same function "
"definition::"
msgstr ""
"そして最後の関数は3つの引数の種類を一つの関数定義の中で使用しています::"

#: ../../tutorial/controlflow.rst:651
msgid ""
"Finally, consider this function definition which has a potential collision "
"between the positional argument ``name``  and ``**kwds`` which has ``name`` "
"as a key::"
msgstr ""
"最後に、位置引数 ``name`` と ``name`` をキーとして持つ ``**kwds`` の間に潜在"
"的な衝突がある関数定義を考えてみましょう。"

#: ../../tutorial/controlflow.rst:656
msgid ""
"There is no possible call that will make it return ``True`` as the keyword "
"``'name'`` will always bind to the first parameter. For example::"
msgstr ""
"キーワードに ``'name'`` を入れても、先頭の引数と同じになってしまうため、この"
"関数が ``True`` を返すような呼び出しの方法はありません。例えば、次のように"
"なってしまいます::"

#: ../../tutorial/controlflow.rst:665
msgid ""
"But using ``/`` (positional only arguments), it is possible since it allows "
"``name`` as a positional argument and ``'name'`` as a key in the keyword "
"arguments::"
msgstr ""
"しかし位置専用を示す ``/`` を使用すれば可能になります。 ``name`` は位置引数と"
"して、そして ``'name'`` はキーワード引数のキーワードとして認識されるからで"
"す::"

#: ../../tutorial/controlflow.rst:672
msgid ""
"In other words, the names of positional-only parameters can be used in "
"``**kwds`` without ambiguity."
msgstr ""
"言い換えると、位置専用引数であれば、その名前を ``**kwds`` の中で使用しても、"
"曖昧にならないということです。"

#: ../../tutorial/controlflow.rst:677
msgid "Recap"
msgstr "要約"

#: ../../tutorial/controlflow.rst:679
msgid ""
"The use case will determine which parameters to use in the function "
"definition::"
msgstr "使用例で、関数定義でどの種類の引数を使うかべきかがわかると思います::"

#: ../../tutorial/controlflow.rst:683
msgid "As guidance:"
msgstr "ガイドとしては、"

#: ../../tutorial/controlflow.rst:685
msgid ""
"Use positional-only if you want the name of the parameters to not be "
"available to the user. This is useful when parameter names have no real "
"meaning, if you want to enforce the order of the arguments when the function "
"is called or if you need to take some positional parameters and arbitrary "
"keywords."
msgstr ""
"もし引数の名前をユーザーに知らせる必要がないなら、位置専用引数を使用しましょ"
"う。これは引数の名前がユーザーにとって意味がなく、関数が呼ばれたときの引数の"
"順序が問題であり、または、位置引数と任意のキーワードを使用する必要がある場合"
"に便利です。"

#: ../../tutorial/controlflow.rst:690
msgid ""
"Use keyword-only when names have meaning and the function definition is more "
"understandable by being explicit with names or you want to prevent users "
"relying on the position of the argument being passed."
msgstr ""
"引数の名前に意味があり、それにより関数の定義がより明らかになる、または、ユー"
"ザーが引数の順番に縛られることを避けたほうがいいと考えるのなら、キーワード専"
"用引数を使用しましょう。"

#: ../../tutorial/controlflow.rst:693
msgid ""
"For an API, use positional-only to prevent breaking API changes if the "
"parameter's name is modified in the future."
msgstr ""
"APIの場合、将来引数の名前が変更された場合にAPIの変更ができなくなることを防ぐ"
"ために、位置専用引数を使用しましょう。"

#: ../../tutorial/controlflow.rst:699
msgid "Arbitrary Argument Lists"
msgstr "任意引数リスト"

#: ../../tutorial/controlflow.rst:704
msgid ""
"Finally, the least frequently used option is to specify that a function can "
"be called with an arbitrary number of arguments.  These arguments will be "
"wrapped up in a tuple (see :ref:`tut-tuples`).  Before the variable number "
"of arguments, zero or more normal arguments may occur. ::"
msgstr ""
"最後に、最も使うことの少ない選択肢として、関数が任意の個数の引数で呼び出せる"
"よう指定する方法があります。これらの引数はタプル (:ref:`tut-tuples` を参照) "
"に格納されます。可変個の引数の前に、ゼロ個かそれ以上の引数があっても構いませ"
"ん。 ::"

#: ../../tutorial/controlflow.rst:713
msgid ""
"Normally, these ``variadic`` arguments will be last in the list of formal "
"parameters, because they scoop up all remaining input arguments that are "
"passed to the function. Any formal parameters which occur after the "
"``*args`` parameter are 'keyword-only' arguments, meaning that they can only "
"be used as keywords rather than positional arguments. ::"
msgstr ""
"通常このような ``可変`` 引数は、関数に渡される入力引数の残りを全て掬い取るた"
"めに、仮引数リストの最後に置かれます。\n"
"``*args`` 引数の後にある仮引数は 'キーワード専用' 引数で、位置引数ではなく"
"キーワード引数としてのみ使えることを意味します。 ::"

#: ../../tutorial/controlflow.rst:730
msgid "Unpacking Argument Lists"
msgstr "引数リストのアンパック"

#: ../../tutorial/controlflow.rst:732
msgid ""
"The reverse situation occurs when the arguments are already in a list or "
"tuple but need to be unpacked for a function call requiring separate "
"positional arguments.  For instance, the built-in :func:`range` function "
"expects separate *start* and *stop* arguments.  If they are not available "
"separately, write the function call with the  ``*``\\ -operator to unpack "
"the arguments out of a list or tuple::"
msgstr ""
"引数がすでにリストやタプルになっていて、個別な位置引数を要求する関数呼び出し"
"に渡すためにアンパックする必要がある場合には、逆の状況が起こります。例えば、"
"組み込み関数 :func:`range` は引数 *start* と *stop* を別に与える必要がありま"
"す。個別に引数を与えることができない場合、関数呼び出しを ``*`` 演算子を使って"
"書き、リストやタプルから引数をアンパックします::"

#: ../../tutorial/controlflow.rst:748
msgid ""
"In the same fashion, dictionaries can deliver keyword arguments with the "
"``**``\\ -operator::"
msgstr ""
"同じやりかたで、``**`` オペレータを使って辞書でもキーワード引数を渡すことがで"
"きます::"

#: ../../tutorial/controlflow.rst:764
msgid "Lambda Expressions"
msgstr "ラムダ式"

#: ../../tutorial/controlflow.rst:766
msgid ""
"Small anonymous functions can be created with the :keyword:`lambda` keyword. "
"This function returns the sum of its two arguments: ``lambda a, b: a+b``. "
"Lambda functions can be used wherever function objects are required.  They "
"are syntactically restricted to a single expression.  Semantically, they are "
"just syntactic sugar for a normal function definition.  Like nested function "
"definitions, lambda functions can reference variables from the containing "
"scope::"
msgstr ""
"キーワード :keyword:`lambda` を使うと、名前のない小さな関数を生成できます。例"
"えば ``lambda a, b: a+b`` は、二つの引数の和を返す関数です。ラムダ式の関数"
"は、関数オブジェクトが要求されている場所にならどこでも使うことができます。ラ"
"ムダ式は、構文上単一の式に制限されています。意味付け的には、ラムダ形式は単に"
"通常の関数定義に構文的な糖衣をかぶせたものに過ぎません。入れ子構造になった関"
"数定義と同様、ラムダ式もそれを取り囲むスコープから変数を参照することができま"
"す::"

#: ../../tutorial/controlflow.rst:783
msgid ""
"The above example uses a lambda expression to return a function.  Another "
"use is to pass a small function as an argument::"
msgstr ""
"上記の例は、関数を返すところでラムダ式を使っています。もう1つの例では、ちょっ"
"とした関数を引数として渡すのに使っています::"

#: ../../tutorial/controlflow.rst:795
msgid "Documentation Strings"
msgstr "ドキュメンテーション文字列"

#: ../../tutorial/controlflow.rst:802
msgid ""
"Here are some conventions about the content and formatting of documentation "
"strings."
msgstr ""
"ドキュメンテーション文字列については、その内容と書式に関する慣習をいくつか挙"
"げます。"

#: ../../tutorial/controlflow.rst:805
msgid ""
"The first line should always be a short, concise summary of the object's "
"purpose.  For brevity, it should not explicitly state the object's name or "
"type, since these are available by other means (except if the name happens "
"to be a verb describing a function's operation).  This line should begin "
"with a capital letter and end with a period."
msgstr ""
"最初の行は、常に対象物の目的を短く簡潔にまとめたものでなくてはなりません。簡"
"潔に書くために、対象物の名前や型を明示する必要はありません。名前や型は他の方"
"法でも得られるからです (名前がたまたま関数の演算内容を記述する動詞である場合"
"は例外です)。最初の行は大文字で始まり、ピリオドで終わっていなければなりませ"
"ん。"

#: ../../tutorial/controlflow.rst:811
msgid ""
"If there are more lines in the documentation string, the second line should "
"be blank, visually separating the summary from the rest of the description.  "
"The following lines should be one or more paragraphs describing the object's "
"calling conventions, its side effects, etc."
msgstr ""
"ドキュメンテーション文字列中にさらに記述すべき行がある場合、二行目は空行に"
"し、まとめの行と残りの記述部分を視覚的に分離します。つづく行は一つまたはそれ"
"以上の段落で、対象物の呼び出し規約や副作用について記述します。"

#: ../../tutorial/controlflow.rst:816
msgid ""
"The Python parser does not strip indentation from multi-line string literals "
"in Python, so tools that process documentation have to strip indentation if "
"desired.  This is done using the following convention. The first non-blank "
"line *after* the first line of the string determines the amount of "
"indentation for the entire documentation string.  (We can't use the first "
"line since it is generally adjacent to the string's opening quotes so its "
"indentation is not apparent in the string literal.)  Whitespace "
"\"equivalent\" to this indentation is then stripped from the start of all "
"lines of the string.  Lines that are indented less should not occur, but if "
"they occur all their leading whitespace should be stripped.  Equivalence of "
"whitespace should be tested after expansion of tabs (to 8 spaces, normally)."
msgstr ""
"Python のパーザは複数行にわたる Python 文字列リテラルからインデントを剥ぎ取ら"
"ないので、ドキュメントを処理するツールでは必要に応じてインデントを剥ぎ取らな"
"ければなりません。この処理は以下の規約に従って行います。最初の行の *後にある"
"* 空行でない最初の行が、ドキュメント全体のインデントの量を決めます。(最初の行"
"は通常、文字列を開始するクオートに隣り合っているので、インデントが文字列リテ"
"ラル中に現れないためです。) このインデント量と \"等価な\" 空白が、文字列のす"
"べての行頭から剥ぎ取られます。インデントの量が少ない行を書いてはならないので"
"すが、もしそういう行があると、先頭の空白すべてが剥ぎ取られます。インデントの"
"空白の大きさが等しいかどうかは、タブ文字を (通常は 8 文字のスペースとして) 展"
"開した後に調べられます。"

#: ../../tutorial/controlflow.rst:828
msgid "Here is an example of a multi-line docstring::"
msgstr "以下に複数行のドキュメンテーション文字列の例を示します::"

#: ../../tutorial/controlflow.rst:846
msgid "Function Annotations"
msgstr "関数のアノテーション"

#: ../../tutorial/controlflow.rst:854
msgid ""
":ref:`Function annotations <function>` are completely optional metadata "
"information about the types used by user-defined functions (see :pep:`3107` "
"and :pep:`484` for more information)."
msgstr ""
":ref:`関数アノテーション <function>` はユーザ定義関数で使用される型についての"
"完全にオプションなメタデータ情報です (詳細は :pep:`3107` と :pep:`484` を参照"
"してください)。"

#: ../../tutorial/controlflow.rst:858
msgid ""
":term:`Annotations <function annotation>` are stored in the :attr:"
"`__annotations__` attribute of the function as a dictionary and have no "
"effect on any other part of the function.  Parameter annotations are defined "
"by a colon after the parameter name, followed by an expression evaluating to "
"the value of the annotation.  Return annotations are defined by a literal ``-"
">``, followed by an expression, between the parameter list and the colon "
"denoting the end of the :keyword:`def` statement.  The following example has "
"a required argument, an optional argument, and the return value annotated::"
msgstr ""
":term:`アノテーション <function annotation>` は関数の :attr:"
"`__annotations__` 属性に辞書として格納され、関数の他の部分には何も影響を与え"
"ません。パラメータアノテーションは、パラメータ名の後にコロンを続けることに"
"よって定義され、その後にアノテーションの値として評価される式が置かれます。戻"
"り値アノテーションは、パラメータリストと :keyword:`def` 文の終わりを表すコロ"
"ンの間に置かれたリテラル ``->`` によって定義され、その後に式が続きます。次の"
"例は必須の引数とオプション引数、そして戻り値のアノテーションを持っています::"

#: ../../tutorial/controlflow.rst:880
msgid "Intermezzo: Coding Style"
msgstr "間奏曲: コーディングスタイル"

#: ../../tutorial/controlflow.rst:885
msgid ""
"Now that you are about to write longer, more complex pieces of Python, it is "
"a good time to talk about *coding style*.  Most languages can be written (or "
"more concise, *formatted*) in different styles; some are more readable than "
"others. Making it easy for others to read your code is always a good idea, "
"and adopting a nice coding style helps tremendously for that."
msgstr ""
"これからより長くより複雑な Python のコードを書いていくので、そろそろ *コー"
"ディングスタイル* について語っても良い頃です。ほとんどの言語は様々なスタイル"
"で書け (もっと簡潔に言えば *フォーマットでき*)、スタイルによって読み易さが異"
"なります。他人にとって読み易いコードにしようとするのはどんなときでも良い考え"
"であり、良いコーディングスタイルを採用することが非常に強力な助けになります。"

#: ../../tutorial/controlflow.rst:891
msgid ""
"For Python, :pep:`8` has emerged as the style guide that most projects "
"adhere to; it promotes a very readable and eye-pleasing coding style.  Every "
"Python developer should read it at some point; here are the most important "
"points extracted for you:"
msgstr ""
"Python には、ほとんどのプロジェクトが守っているスタイルガイドとして :pep:`8` "
"があります。それは非常に読み易く目に優しいコーディングスタイルを推奨していま"
"す。全ての Python 開発者はある時点でそれを読むべきです。ここに最も重要な点を"
"抜き出しておきます:"

#: ../../tutorial/controlflow.rst:896
msgid "Use 4-space indentation, and no tabs."
msgstr "インデントには空白 4 つを使い、タブは使わないこと。"

#: ../../tutorial/controlflow.rst:898
msgid ""
"4 spaces are a good compromise between small indentation (allows greater "
"nesting depth) and large indentation (easier to read).  Tabs introduce "
"confusion, and are best left out."
msgstr ""
"空白 4 つは (深くネストできる) 小さいインデントと (読み易い) 大きいインデント"
"のちょうど中間に当たります。タブは混乱させるので、使わずにおくのが良いです。"

#: ../../tutorial/controlflow.rst:902
msgid "Wrap lines so that they don't exceed 79 characters."
msgstr "ソースコードの幅が 79 文字を越えないように行を折り返すこと。"

#: ../../tutorial/controlflow.rst:904
msgid ""
"This helps users with small displays and makes it possible to have several "
"code files side-by-side on larger displays."
msgstr ""
"こうすることで小さいディスプレイを使っているユーザも読み易くなり、大きなディ"
"スプレイではソースコードファイルを並べることもできるようになります。"

#: ../../tutorial/controlflow.rst:907
msgid ""
"Use blank lines to separate functions and classes, and larger blocks of code "
"inside functions."
msgstr "関数やクラスや関数内の大きめのコードブロックの区切りに空行を使うこと。"

#: ../../tutorial/controlflow.rst:910
msgid "When possible, put comments on a line of their own."
msgstr "可能なら、コメントは行に独立で書くこと。"

#: ../../tutorial/controlflow.rst:912
msgid "Use docstrings."
msgstr "docstring を使うこと。"

#: ../../tutorial/controlflow.rst:914
msgid ""
"Use spaces around operators and after commas, but not directly inside "
"bracketing constructs: ``a = f(1, 2) + g(3, 4)``."
msgstr ""
"演算子の前後とコンマの後には空白を入れ、括弧類のすぐ内側には空白を入れないこ"
"と: ``a = f(1, 2) + g(3, 4)``。"

#: ../../tutorial/controlflow.rst:917
msgid ""
"Name your classes and functions consistently; the convention is to use "
"``UpperCamelCase`` for classes and ``lowercase_with_underscores`` for "
"functions and methods.  Always use ``self`` as the name for the first method "
"argument (see :ref:`tut-firstclasses` for more on classes and methods)."
msgstr ""
"クラスや関数に一貫性のある名前を付けること。慣習では ``UpperCamelCase`` をク"
"ラス名に使い、 ``lowercase_with_underscores`` を関数名やメソッド名に使いま"
"す。常に ``self`` をメソッドの第 1 引数の名前 (クラスやメソッドについては :"
"ref:`tut-firstclasses` を見よ) として使うこと。"

#: ../../tutorial/controlflow.rst:922
msgid ""
"Don't use fancy encodings if your code is meant to be used in international "
"environments.  Python's default, UTF-8, or even plain ASCII work best in any "
"case."
msgstr ""
"あなたのコードを世界中で使ってもらうつもりなら、風変りなエンコーディングは使"
"わないこと。どんな場合でも、Python のデフォルト UTF-8 またはプレーン ASCII が"
"最も上手くいきます。"

#: ../../tutorial/controlflow.rst:926
msgid ""
"Likewise, don't use non-ASCII characters in identifiers if there is only the "
"slightest chance people speaking a different language will read or maintain "
"the code."
msgstr ""
"同様に、ほんの少しでも他の言語を話す人がコードを読んだりメンテナンスする可能"
"性があるのであれば、非 ASCII 文字も識別子に使うべきではありません。"

#: ../../tutorial/controlflow.rst:932
msgid "Footnotes"
msgstr "脚注"

#: ../../tutorial/controlflow.rst:933
msgid ""
"Actually, *call by object reference* would be a better description, since if "
"a mutable object is passed, the caller will see any changes the callee makes "
"to it (items inserted into a list)."
msgstr ""
"実際には、*オブジェクトへの参照渡し (call by object reference)* と書けばよい"
"のかもしれません。というのは、変更可能なオブジェクトが渡されると、関数の呼び"
"出し側は、呼び出された側の関数がオブジェクトに行ったどんな変更 (例えばリスト"
"に挿入された要素) にも出くわすことになるからです。"