controlflow.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2018, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2018-06-30 05:56+0900\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: kento <k.denjiry@gmail.com>, 2018\n"
"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/ja/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ja\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 knows the "
"usual control flow statements known from other languages, with some twists."
msgstr ""
"先ほど紹介した :keyword:`while` 文の他にも、 Python "
"は他の言語でおなじみの制御フロー文を備えていますが、これらには多少ひねりを加えてあります。"

#: ../../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 ""
"If you need to modify the sequence you are iterating over while inside the "
"loop (for example to duplicate selected items), it is recommended that you "
"first make a copy.  Iterating over a sequence does not implicitly make a "
"copy.  The slice notation makes this especially convenient::"
msgstr ""
"ループ内部でイテレートしているシーケンスを修正する必要があれば "
"(例えば選択されたアイテムを複製するために)、最初にコピーを作ることをお勧めします。シーケンスに対するイテレーションは暗黙にコピーを作りません。スライス記法はこれを特に便利にします::"

#: ../../tutorial/controlflow.rst:81
msgid ""
"With ``for w in words:``, the example would attempt to create an infinite "
"list, inserting ``defenestrate`` over and over again."
msgstr ""
"``for w in words:`` を使った場合は、この例は ``defenestrate`` "
"を何度も繰り返し挿入することで、無限リストを作成しようとします。"

#: ../../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 *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 an *iterator*. The function :func:`list` is"
" another; it creates lists from iterables::"
msgstr ""
"このようなオブジェクトは *イテラブル (iterable)* "
"と呼ばれます。これらは関数やコンストラクタのターゲットとして、あるだけの項目を逐次与えるのに適しています。 :keyword:`for` 文がそのような"
" *イテレータ* であることはすでに見てきました。関数 :func:`list` もまた一つの例です。これはイテラブルからリストを生成します::"

#: ../../tutorial/controlflow.rst:152
msgid ""
"Later we will see more functions that return iterables and take iterables as"
" argument."
msgstr "後ほど、イテラブルを返したりイテラブルを引数として取る関数をもっと見ていきます。"

#: ../../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 ``else`` clause; it is executed when the loop "
"terminates through exhaustion of the list (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 ""
"ループ文は ``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 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:217
msgid ":keyword:`pass` Statements"
msgstr ":keyword:`pass` 文"

#: ../../tutorial/controlflow.rst:219
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:226
msgid "This is commonly used for creating minimal classes::"
msgstr "これは最小のクラスを作るときによく使われる方法です::"

#: ../../tutorial/controlflow.rst:232
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つの場所は、新しいコードを書いている時の関数や条件文の中身です。こうすることで、具体的なコードを書かないで抽象的なレベルで考えることができます。"
" :keyword:`pass` は何もすることなく無視されます::"

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

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

#: ../../tutorial/controlflow.rst:265
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:270
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:277
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 cannot be directly "
"assigned a value within a function (unless named in a :keyword:`global` "
"statement), although they may be referenced."
msgstr ""
"関数を *実行 (execution)* するとき、関数のローカル変数のために使われる新たなシンボルテーブル (symbol table) "
"が用意されます。もっと正確にいうと、関数内で変数への代入を行うと、その値はすべてこのローカルなシンボルテーブルに記憶されます。一方、変数の参照を行うと、まずローカルなシンボルテーブルが検索され、次にさらに外側の関数のローカルなシンボルテーブルを検索し、その後グローバルなシンボルテーブルを調べ、最後に組み込みの名前テーブルを調べます。従って、関数の中では、グローバルな変数を参照することはできますが、直接値を代入することは"
" (:keyword:`global` 文で名前を挙げておかない限り)できません。"

#: ../../tutorial/controlflow.rst:286
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, a new local symbol table is created for that call."
msgstr ""
"関数を呼び出す際の実際の引数 (実引数) は、関数が呼び出されるときに関数のローカルなシンボルテーブル内に取り込まれます。そうすることで、引数は "
"*値渡し (call by value)* で関数に渡されることになります (ここでの *値 (value)* とは常にオブジェクトへの "
"*参照(reference)* をいい、オブジェクトの値そのものではありません) "
"[#]_。ある関数がほかの関数を呼び出すときには、新たな呼び出しのためにローカルなシンボルテーブルが新たに作成されます。"

#: ../../tutorial/controlflow.rst:292
msgid ""
"A function definition introduces the function name in the current symbol "
"table. The value of the function name has a type that is recognized by the "
"interpreter as a user-defined function.  This value can be assigned to "
"another name which can then also be used as a function.  This serves as a "
"general renaming mechanism::"
msgstr ""
"関数の定義を行うと、関数名は現在のシンボルテーブル内に取り入れられます。関数名の値は、インタプリタからはユーザ定義関数 (user-defined "
"function) "
"として認識される型を持ちます。この値は別の名前に代入して、後にその名前を関数として使うこともできます。これは一般的な名前変更のメカニズムとして働きます::"

#: ../../tutorial/controlflow.rst:304
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:315
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:331
msgid "This example, as usual, demonstrates some new Python features:"
msgstr "この例は Python の新しい機能を示しています:"

#: ../../tutorial/controlflow.rst:333
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:337
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:352
msgid "More on Defining Functions"
msgstr "関数定義についてもう少し"

#: ../../tutorial/controlflow.rst:354
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:361
msgid "Default Argument Values"
msgstr "デフォルトの引数値"

#: ../../tutorial/controlflow.rst:363
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:379
msgid "This function can be called in several ways:"
msgstr "この関数はいくつかの方法で呼び出せます:"

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

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

#: ../../tutorial/controlflow.rst:404
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:417
msgid "This will print ::"
msgstr "このコードは、以下を出力します ::"

#: ../../tutorial/controlflow.rst:423
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:436
msgid "Keyword Arguments"
msgstr "キーワード引数"

#: ../../tutorial/controlflow.rst:438
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:447
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:458
msgid "but all the following calls would be invalid::"
msgstr "が、以下の呼び出しは不適切です::"

#: ../../tutorial/controlflow.rst:465
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:481
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 tuple 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` を参照) を受け取ります。 ``**name`` は ``*name`` "
"の形式をとる、仮引数のリストを超えた位置引数の入ったタプルを受け取る引数 (次の節で述べます) と組み合わせることができます。 (``*name`` は"
" ``**name`` より前になければなりません)。例えば、ある関数の定義を以下のようにすると::"

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

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

#: ../../tutorial/controlflow.rst:519
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 "Arbitrary Argument Lists"
msgstr "任意引数リスト"

#: ../../tutorial/controlflow.rst:531
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:540
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 ""
"通常このような ``可変`` 引数は、関数に渡される入力引数の残りを全て掬い取るために、仮引数リストの最後に置かれます。``*args`` "
"引数の後にある仮引数は 'キーワード専用' 引数で、位置引数ではなくキーワード引数としてのみ使えます。 ::"

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

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

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

#: ../../tutorial/controlflow.rst:593
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:610
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:622
msgid "Documentation Strings"
msgstr "ドキュメンテーション文字列"

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

#: ../../tutorial/controlflow.rst:632
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:638
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:643
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:655
msgid "Here is an example of a multi-line docstring::"
msgstr "以下に複数行のドキュメンテーション文字列の例を示します::"

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

#: ../../tutorial/controlflow.rst:680
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:684
msgid ""
"Annotations 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 positional argument,"
" a keyword argument, and the return value annotated::"
msgstr ""
"アノテーションは関数の :attr:`__annotations__` "
"属性に辞書として格納され、関数の他の部分には何も影響がありません。パラメータアノテーションは、パラメータ名の後にコロンを続けることによって定義され、その後にアノテーションの値として評価される式が置かれます。戻り値アノテーションは、パラメータリストと"
" :keyword:`def` ステートメントの終わりを表すコロンの間に置かれたリテラル ``->`` "
"によって定義され、その後に式が続きます。次の例は位置引数とキーワード引数、そして戻り値アノテーションを持っています::"

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

#: ../../tutorial/controlflow.rst:711
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:717
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:722
msgid "Use 4-space indentation, and no tabs."
msgstr "インデントには空白 4 つを使い、タブは使わないこと。"

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

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

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

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

#: ../../tutorial/controlflow.rst:740
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:743
msgid ""
"Name your classes and functions consistently; the convention is to use "
"``CamelCase`` for classes and ``lower_case_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 ""
"クラスや関数に一貫性のある名前を付けること。慣習では ``CamelCase`` をクラス名に使い、 "
"``lower_case_with_underscores`` を関数名やメソッド名に使います。常に ``self`` をメソッドの第 1 引数の名前 "
"(クラスやメソッドについては :ref:`tut-firstclasses` を見よ) として使うこと。"

#: ../../tutorial/controlflow.rst:748
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:752
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:758
msgid "Footnotes"
msgstr "脚注"

#: ../../tutorial/controlflow.rst:759
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)* "
"と書けばよいのかもしれません。というのは、変更可能なオブジェクトが渡されると、関数の呼び出し側は、呼び出された側の関数がオブジェクトに行ったどんな変更 "
"(例えばリストに挿入された要素) にも出くわすことになるからです。"