introduction.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# python-doc bot, 2025
# Takanori Suzuki <takanori@takanory.net>, 2026
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-10-01 19:07+0000\n"
"PO-Revision-Date: 2025-09-16 00:02+0000\n"
"Last-Translator: Takanori Suzuki <takanori@takanory.net>, 2026\n"
"Language-Team: Japanese (https://app.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/introduction.rst:5
msgid "An Informal Introduction to Python"
msgstr "形式ばらない Python の紹介"

#: ../../tutorial/introduction.rst:7
msgid ""
"In the following examples, input and output are distinguished by the "
"presence or absence of prompts (:term:`>>>` and :term:`...`): to repeat the "
"example, you must type everything after the prompt, when the prompt appears; "
"lines that do not begin with a prompt are output from the interpreter. Note "
"that a secondary prompt on a line by itself in an example means you must "
"type a blank line; this is used to end a multi-line command."
msgstr ""
"以下の例ではプロンプト (:term:`>>>` と :term:`...`) の有無で入力と出力を区別"
"します。例を試すには、プロンプトが表示されているときに例のプロンプトより後ろ"
"の内容をすべて入力してください。プロンプトで始まらない行はインタープリタの出"
"力です。例の中で二次プロンプトだけがある行は、空行を入力することを意味しま"
"す。この空行で複数行にわたるコマンドの入力を終えます。"

#: ../../tutorial/introduction.rst:16
msgid ""
"You can use the \"Copy\" button (it appears in the upper-right corner when "
"hovering over or tapping a code example), which strips prompts and omits "
"output, to copy and paste the input lines into your interpreter."
msgstr ""
"コード例にマウスポインタを重ねるかタップすると、右上に「Copy」ボタンが表示さ"
"れます。このボタンを使うとプロンプトと出力を除いた入力行だけをコピーし、イン"
"タープリタに貼り付けられます。"

#: ../../tutorial/introduction.rst:22
msgid ""
"Many of the examples in this manual, even those entered at the interactive "
"prompt, include comments.  Comments in Python start with the hash character, "
"``#``, and extend to the end of the physical line.  A comment may appear at "
"the start of a line or following whitespace or code, but not within a string "
"literal.  A hash character within a string literal is just a hash character. "
"Since comments are to clarify code and are not interpreted by Python, they "
"may be omitted when typing in examples."
msgstr ""
"対話プロンプトで入力する例も含め、このマニュアルの多くの例にはコメントが付い"
"ています。Python のコメントはハッシュ文字 ``#`` で始まり、物理行の末尾まで続"
"きます。コメントは行の先頭や空白・コードの後に書けますが、文字列リテラルの中"
"には書けません。文字列リテラル内のハッシュ文字は単なるハッシュ文字です。コメ"
"ントはコードをわかりやすくするためのもので、Python は解釈しません。そのため、"
"例を入力するときには省略できます。"

#: ../../tutorial/introduction.rst:30
msgid "Some examples::"
msgstr "いくつかの例です::"

#: ../../tutorial/introduction.rst:32
msgid ""
"# this is the first comment\n"
"spam = 1  # and this is the second comment\n"
"          # ... and now a third!\n"
"text = \"# This is not a comment because it's inside quotes.\""
msgstr ""
"# これは最初のコメント\n"
"spam = 1  # そしてこれは2つめのコメント\n"
"          # ...そして3つめ!\n"
"text = \"# これはクォーテーションの間なのでコメントではない。\""

#: ../../tutorial/introduction.rst:41
msgid "Using Python as a Calculator"
msgstr "Python を電卓として使う"

#: ../../tutorial/introduction.rst:43
msgid ""
"Let's try some simple Python commands.  Start the interpreter and wait for "
"the primary prompt, ``>>>``.  (It shouldn't take long.)"
msgstr ""
"簡単な Python コマンドをいくつか試してみましょう。インタープリタを起動し、一"
"次プロンプト ``>>>`` が表示されるのを待ちます。(すぐに表示されるはずです。)"

#: ../../tutorial/introduction.rst:50
msgid "Numbers"
msgstr "数"

#: ../../tutorial/introduction.rst:52
msgid ""
"The interpreter acts as a simple calculator: you can type an expression into "
"it and it will write the value.  Expression syntax is straightforward: the "
"operators ``+``, ``-``, ``*`` and ``/`` can be used to perform arithmetic; "
"parentheses (``()``) can be used for grouping. For example::"
msgstr ""
"インタープリタは簡単な電卓のように動作し、式を入力するとその値を表示します。"
"式の構文は単純です。演算子 ``+`` 、 ``-`` 、 ``*`` 、 ``/`` で算術演算を行"
"い、丸括弧 (``()``) で式をまとめられます。例えば次のように使います::"

#: ../../tutorial/introduction.rst:58
msgid ""
">>> 2 + 2\n"
"4\n"
">>> 50 - 5*6\n"
"20\n"
">>> (50 - 5*6) / 4\n"
"5.0\n"
">>> 8 / 5  # division always returns a floating-point number\n"
"1.6"
msgstr ""
">>> 2 + 2\n"
"4\n"
">>> 50 - 5*6\n"
"20\n"
">>> (50 - 5*6) / 4\n"
"5.0\n"
">>> 8 / 5  # 除算は常に浮動小数点数を返す\n"
"1.6"

#: ../../tutorial/introduction.rst:67
msgid ""
"The integer numbers (e.g. ``2``, ``4``, ``20``) have type :class:`int`, the "
"ones with a fractional part (e.g. ``5.0``, ``1.6``) have "
"type :class:`float`.  We will see more about numeric types later in the "
"tutorial."
msgstr ""
"整数 (例えば ``2`` 、 ``4`` 、 ``20``) は :class:`int` 型で、小数部を持つ数 "
"(例えば ``5.0`` 、 ``1.6``) は :class:`float` 型です。数値型についてはこの"
"チュートリアルの後の節で詳しく説明します。"

#: ../../tutorial/introduction.rst:71
msgid ""
"Division (``/``) always returns a float.  To do :term:`floor division` and "
"get an integer result you can use the ``//`` operator; to calculate the "
"remainder you can use ``%``::"
msgstr ""
"除算 (``/``) は常に浮動小数点数を返します。 :term:`切り捨て除算 <floor "
"division>` で整数の結果を得るには ``//`` 演算子を使います。剰余は ``%`` で求"
"められます::"

#: ../../tutorial/introduction.rst:75
msgid ""
">>> 17 / 3  # classic division returns a float\n"
"5.666666666666667\n"
">>>\n"
">>> 17 // 3  # floor division discards the fractional part\n"
"5\n"
">>> 17 % 3  # the % operator returns the remainder of the division\n"
"2\n"
">>> 5 * 3 + 2  # floored quotient * divisor + remainder\n"
"17"
msgstr ""
">>> 17 / 3  # 除算は浮動小数点数を返す\n"
"5.666666666666667\n"
">>>\n"
">>> 17 // 3  # 切り捨て除算は小数部を切り捨てる\n"
"5\n"
">>> 17 % 3  # % 演算子は剰余を返す\n"
"2\n"
">>> 5 * 3 + 2  # 切り捨てられた商 * 除数 + 剰余\n"
"17"

#: ../../tutorial/introduction.rst:85
msgid ""
"With Python, it is possible to use the ``**`` operator to calculate powers "
"[#]_::"
msgstr "Python では ``**`` 演算子で冪乗を計算できます [#]_::"

#: ../../tutorial/introduction.rst:87
msgid ""
">>> 5 ** 2  # 5 squared\n"
"25\n"
">>> 2 ** 7  # 2 to the power of 7\n"
"128"
msgstr ""
">>> 5 ** 2  # 5の2乗\n"
"25\n"
">>> 2 ** 7  # 2の7乗\n"
"128"

#: ../../tutorial/introduction.rst:92
msgid ""
"The equal sign (``=``) is used to assign a value to a variable. Afterwards, "
"no result is displayed before the next interactive prompt::"
msgstr ""
"等号 (``=``) は変数に値を代入するときに使います。代入後は結果を表示せずに次の"
"対話プロンプトに進みます::"

#: ../../tutorial/introduction.rst:95
msgid ""
">>> width = 20\n"
">>> height = 5 * 9\n"
">>> width * height\n"
"900"
msgstr ""
">>> width = 20\n"
">>> height = 5 * 9\n"
">>> width * height\n"
"900"

#: ../../tutorial/introduction.rst:100
msgid ""
"If a variable is not \"defined\" (assigned a value), trying to use it will "
"give you an error::"
msgstr ""
"「定義」されていない (値が代入されていない) 変数を使おうとするとエラーになり"
"ます::"

#: ../../tutorial/introduction.rst:103
msgid ""
">>> n  # try to access an undefined variable\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"NameError: name 'n' is not defined"
msgstr ""
">>> n  # 未定義の変数にアクセスする\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"NameError: name 'n' is not defined"

#: ../../tutorial/introduction.rst:108
msgid ""
"There is full support for floating point; operators with mixed type operands "
"convert the integer operand to floating point::"
msgstr ""
"浮動小数点数も全面的にサポートしています。整数と浮動小数点数が混在する演算で"
"は、演算子が整数のオペランドを浮動小数点数に変換します::"

#: ../../tutorial/introduction.rst:111
msgid ""
">>> 4 * 3.75 - 1\n"
"14.0"
msgstr ""
">>> 4 * 3.75 - 1\n"
"14.0"

#: ../../tutorial/introduction.rst:114
msgid ""
"In interactive mode, the last printed expression is assigned to the variable "
"``_``.  This means that when you are using Python as a desk calculator, it "
"is somewhat easier to continue calculations, for example::"
msgstr ""
"対話モードでは最後に表示された式の値が変数 ``_`` に代入されます。この変数を使"
"うと、Python を電卓として使うときに続きの計算が少し楽になります。例えば次のよ"
"うに使います::"

#: ../../tutorial/introduction.rst:118
msgid ""
">>> tax = 12.5 / 100\n"
">>> price = 100.50\n"
">>> price * tax\n"
"12.5625\n"
">>> price + _\n"
"113.0625\n"
">>> round(_, 2)\n"
"113.06"
msgstr ""
">>> tax = 12.5 / 100\n"
">>> price = 100.50\n"
">>> price * tax\n"
"12.5625\n"
">>> price + _\n"
"113.0625\n"
">>> round(_, 2)\n"
"113.06"

#: ../../tutorial/introduction.rst:127
msgid ""
"This variable should be treated as read-only by the user.  Don't explicitly "
"assign a value to it --- you would create an independent local variable with "
"the same name masking the built-in variable with its magic behavior."
msgstr ""
"この変数は読み取り専用として扱い、明示的に値を代入しないでください。代入する"
"と同じ名前の別のローカル変数が作られ、特別な動作をする組み込み変数が隠されて"
"しまいます。"

#: ../../tutorial/introduction.rst:131
msgid ""
"In addition to :class:`int` and :class:`float`, Python supports other types "
"of numbers, such as :class:`~decimal.Decimal` "
"and :class:`~fractions.Fraction`. Python also has built-in support "
"for :ref:`complex numbers <typesnumeric>`, and uses the ``j`` or ``J`` "
"suffix to indicate the imaginary part (e.g. ``3+5j``)."
msgstr ""
"Python は :class:`int` と :class:`float` のほか"
"に、 :class:`~decimal.Decimal` や :class:`~fractions.Fraction` などの数値型も"
"サポートしています。 :ref:`複素数 <typesnumeric>` も組み込みでサポートしてお"
"り、接尾辞 ``j`` または ``J`` で虚部を表します (例: ``3+5j``)。"

#: ../../tutorial/introduction.rst:141
msgid "Text"
msgstr "テキスト"

#: ../../tutorial/introduction.rst:143
msgid ""
"Python can manipulate text (represented by type :class:`str`, so-called "
"\"strings\") as well as numbers.  This includes characters \"``!``\", words "
"\"``rabbit``\", names \"``Paris``\", sentences \"``Got your back.``\", etc. "
"\"``Yay! :)``\". They can be enclosed in single quotes (``'...'``) or double "
"quotes (``\"...\"``) with the same result [#]_."
msgstr ""
"Python は数値だけでなくテキストも扱えます。テキストは :class:`str` 型で表さ"
"れ、一般に「文字列」と呼ばれます。 \"``!``\" のような文字、 \"``rabbit``\" の"
"ような単語、 \"``Paris``\" のような名前、 \"``Got your back.``\" や "
"\"``Yay! :)``\" のような文や表現などです。文字列はシングルクォート "
"(``'...'``) またはダブルクォート (``\"...\"``) で囲み、どちらを使っても同じ結"
"果になります [#]_ 。"

#: ../../tutorial/introduction.rst:149
msgid ""
">>> 'spam eggs'  # single quotes\n"
"'spam eggs'\n"
">>> \"Paris rabbit got your back :)! Yay!\"  # double quotes\n"
"'Paris rabbit got your back :)! Yay!'\n"
">>> '1975'  # digits and numerals enclosed in quotes are also strings\n"
"'1975'"
msgstr ""
">>> 'spam eggs'  # シングルクォート\n"
"'spam eggs'\n"
">>> \"Paris rabbit got your back :)! Yay!\"  # ダブルクォート\n"
"'Paris rabbit got your back :)! Yay!'\n"
">>> '1975'  # クォートに囲まれた数字も文字列\n"
"'1975'"

#: ../../tutorial/introduction.rst:158
msgid ""
"To quote a quote, we need to \"escape\" it, by preceding it with ``\\``. "
"Alternatively, we can use the other type of quotation marks::"
msgstr ""
"文字列を囲むクォートと同じクォートを文字列の中に書くには、直前に ``\\`` を付"
"けて「エスケープ」します。別の種類のクォートで文字列を囲む方法もあります::"

#: ../../tutorial/introduction.rst:161
msgid ""
">>> 'doesn\\'t'  # use \\' to escape the single quote...\n"
"\"doesn't\"\n"
">>> \"doesn't\"  # ...or use double quotes instead\n"
"\"doesn't\"\n"
">>> '\"Yes,\" they said.'\n"
"'\"Yes,\" they said.'\n"
">>> \"\\\"Yes,\\\" they said.\"\n"
"'\"Yes,\" they said.'\n"
">>> '\"Isn\\'t,\" they said.'\n"
"'\"Isn\\'t,\" they said.'"
msgstr ""
">>> 'doesn\\'t'  #  \\' を使用してシングルクォートをエスケープする\n"
"\"doesn't\"\n"
">>> \"doesn't\"  # または代わりにダブルクォートを使用する\n"
"\"doesn't\"\n"
">>> '\"Yes,\" they said.'\n"
"'\"Yes,\" they said.'\n"
">>> \"\\\"Yes,\\\" they said.\"\n"
"'\"Yes,\" they said.'\n"
">>> '\"Isn\\'t,\" they said.'\n"
"'\"Isn\\'t,\" they said.'"

#: ../../tutorial/introduction.rst:172
msgid ""
"In the Python shell, the string definition and output string can look "
"different.  The :func:`print` function produces a more readable output, by "
"omitting the enclosing quotes and by printing escaped and special "
"characters::"
msgstr ""
"Python シェルでは文字列を定義するときと出力するときで見た目が異なることがあり"
"ます。 :func:`print` 関数は文字列を囲むクォートを省き、エスケープされた文字や"
"特殊文字を表示して読みやすく出力します::"

#: ../../tutorial/introduction.rst:176
msgid ""
">>> s = 'First line.\\nSecond line.'  # \\n means newline\n"
">>> s  # without print(), special characters are included in the string\n"
"'First line.\\nSecond line.'\n"
">>> print(s)  # with print(), special characters are interpreted, so \\n "
"produces new line\n"
"First line.\n"
"Second line."
msgstr ""
">>> s = 'First line.\\nSecond line.'  # \\n は改行を意味する\n"
">>> s  # print() を使用しない場合、特殊文字が文字列に含まれる\n"
"'First line.\\nSecond line.'\n"
">>> print(s)  # print() では特殊文字は解釈されるため、\\n は改行となる\n"
"First line.\n"
"Second line."

#: ../../tutorial/introduction.rst:183
msgid ""
"If you don't want characters prefaced by ``\\`` to be interpreted as special "
"characters, you can use *raw strings* by adding an ``r`` before the first "
"quote::"
msgstr ""
"``\\`` に続く文字を特殊文字として解釈させたくない場合は、最初のクォートの前"
"に ``r`` を付けて *raw string* (生の文字列) にできます::"

#: ../../tutorial/introduction.rst:187
msgid ""
">>> print('C:\\this\\name')  # here \\t means tab, \\n means newline\n"
"C:      his\n"
"ame\n"
">>> print(r'C:\\this\\name')  # note the r before the quote\n"
"C:\\this\\name"
msgstr ""
">>> print('C:\\this\\name')  # ここでは \\t はタブ、\\n は改行を表す\n"
"C:      his\n"
"ame\n"
">>> print(r'C:\\this\\name')  # クォートの前の r に注目\n"
"C:\\this\\name"

#: ../../tutorial/introduction.rst:193
msgid ""
"There is one subtle aspect to raw strings: a raw string may not end in an "
"odd number of ``\\`` characters; see :ref:`the FAQ entry <faq-programming-"
"raw-string-backslash>` for more information and workarounds."
msgstr ""
"raw string には注意点が1つあります。末尾に奇数個の ``\\`` を連続して置くこと"
"はできません。詳しい説明と回避方法は :ref:`FAQ の該当項目 <faq-programming-"
"raw-string-backslash>` を参照してください。"

#: ../../tutorial/introduction.rst:198
msgid ""
"String literals can span multiple lines.  One way is using triple-quotes: "
"``\"\"\"...\"\"\"`` or ``'''...'''``.  End-of-line characters are "
"automatically included in the string, but it's possible to prevent this by "
"adding a ``\\`` at the end of the line.  In the following example, the "
"initial newline is not included::"
msgstr ""
"文字列リテラルは複数行にまたがって書けます。1つの方法は三重引用符 "
"(``\"\"\"...\"\"\"`` や ``'''...'''``) を使うことです。改行文字は自動的に文字"
"列に含まれますが、行末に ``\\`` を付けると改行文字を含めずに済みます。次の例"
"では最初の改行は含まれません::"

#: ../../tutorial/introduction.rst:204
msgid ""
">>> print(\"\"\"\\\n"
"... Usage: thingy [OPTIONS]\n"
"...      -h                        Display this usage message\n"
"...      -H hostname               Hostname to connect to\n"
"... \"\"\")\n"
"Usage: thingy [OPTIONS]\n"
"     -h                        Display this usage message\n"
"     -H hostname               Hostname to connect to\n"
"\n"
">>>"
msgstr ""
">>> print(\"\"\"\\\n"
"... Usage: thingy [OPTIONS]\n"
"...      -h                        Display this usage message\n"
"...      -H hostname               Hostname to connect to\n"
"... \"\"\")\n"
"Usage: thingy [OPTIONS]\n"
"     -h                        Display this usage message\n"
"     -H hostname               Hostname to connect to\n"
"\n"
">>>"

#: ../../tutorial/introduction.rst:215
msgid ""
"Strings can be concatenated (glued together) with the ``+`` operator, and "
"repeated with ``*``::"
msgstr "文字列は ``+`` 演算子で連結し、 ``*`` 演算子で繰り返せます::"

#: ../../tutorial/introduction.rst:218
msgid ""
">>> # 3 times 'un', followed by 'ium'\n"
">>> 3 * 'un' + 'ium'\n"
"'unununium'"
msgstr ""
">>> # 'un' を3回繰り返し、その後に 'ium'\n"
">>> 3 * 'un' + 'ium'\n"
"'unununium'"

#: ../../tutorial/introduction.rst:222
msgid ""
"Two or more *string literals* (i.e. the ones enclosed between quotes) next "
"to each other are automatically concatenated. ::"
msgstr ""
"2つ以上の *文字列リテラル* (クォートで囲んだもの) を隣り合わせに書くと、自動"
"的に連結されます::"

#: ../../tutorial/introduction.rst:225
msgid ""
">>> 'Py' 'thon'\n"
"'Python'"
msgstr ""
">>> 'Py' 'thon'\n"
"'Python'"

#: ../../tutorial/introduction.rst:228
msgid ""
"This feature is particularly useful when you want to break long strings::"
msgstr "この機能は長い文字列を複数行に分けて書きたいときに特に便利です::"

#: ../../tutorial/introduction.rst:230
msgid ""
">>> text = ('Put several strings within parentheses '\n"
"...         'to have them joined together.')\n"
">>> text\n"
"'Put several strings within parentheses to have them joined together.'"
msgstr ""
">>> text = ('複数の文字列を丸括弧で囲むと'\n"
"...         '連結される。')\n"
">>> text\n"
"'複数の文字列を丸括弧で囲むと連結される。'"

msgid ""
"This only works with two literals though, not with variables or expressions::"
msgstr ""
"ただし、この方法で連結できるのはリテラルどうしだけです。\n"
"変数や式には使えません。 ::"

#: ../../tutorial/introduction.rst:237
msgid ""
">>> prefix = 'Py'\n"
">>> prefix 'thon'  # can't concatenate a variable and a string literal\n"
"  File \"<stdin>\", line 1\n"
"    prefix 'thon'\n"
"           ^^^^^^\n"
"SyntaxError: invalid syntax\n"
">>> ('un' * 3) 'ium'\n"
"  File \"<stdin>\", line 1\n"
"    ('un' * 3) 'ium'\n"
"               ^^^^^\n"
"SyntaxError: invalid syntax"
msgstr ""
">>> prefix = 'Py'\n"
">>> prefix 'thon'  # 変数と文字列リテラルは連結できない\n"
"  File \"<stdin>\", line 1\n"
"    prefix 'thon'\n"
"           ^^^^^^\n"
"SyntaxError: invalid syntax\n"
">>> ('un' * 3) 'ium'\n"
"  File \"<stdin>\", line 1\n"
"    ('un' * 3) 'ium'\n"
"               ^^^^^\n"
"SyntaxError: invalid syntax"

#: ../../tutorial/introduction.rst:249
msgid ""
"If you want to concatenate variables or a variable and a literal, use ``+``::"
msgstr "変数どうしや変数とリテラルを連結するには ``+`` を使います::"

#: ../../tutorial/introduction.rst:251
msgid ""
">>> prefix + 'thon'\n"
"'Python'"
msgstr ""
">>> prefix + 'thon'\n"
"'Python'"

#: ../../tutorial/introduction.rst:254
msgid ""
"Strings can be *indexed* (subscripted), with the first character having "
"index 0. There is no separate character type; a character is simply a string "
"of size one::"
msgstr ""
"文字列では *インデックス* (添字) を指定して文字を取得できます。最初の文字のイ"
"ンデックスは 0 です。文字専用の型はなく、1文字も長さ1の文字列として扱います::"

#: ../../tutorial/introduction.rst:258
msgid ""
">>> word = 'Python'\n"
">>> word[0]  # character in position 0\n"
"'P'\n"
">>> word[5]  # character in position 5\n"
"'n'"
msgstr ""
">>> word = 'Python'\n"
">>> word[0]  # 0番目の文字\n"
"'P'\n"
">>> word[5]  # 5番目の文字\n"
"'n'"

#: ../../tutorial/introduction.rst:264
msgid ""
"Indices may also be negative numbers, to start counting from the right::"
msgstr "インデックスに負の数を指定すると、右から数えて文字を取得できます::"

#: ../../tutorial/introduction.rst:266
msgid ""
">>> word[-1]  # last character\n"
"'n'\n"
">>> word[-2]  # second-last character\n"
"'o'\n"
">>> word[-6]\n"
"'P'"
msgstr ""
">>> word[-1]  # 最後の文字\n"
"'n'\n"
">>> word[-2]  # 後ろから2番目の文字\n"
"'o'\n"
">>> word[-6]\n"
"'P'"

#: ../../tutorial/introduction.rst:273
msgid "Note that since -0 is the same as 0, negative indices start from -1."
msgstr "-0 は 0 と区別できないので、負のインデックスは -1 から始まります。"

#: ../../tutorial/introduction.rst:275
msgid ""
"In addition to indexing, *slicing* is also supported.  While indexing is "
"used to obtain individual characters, *slicing* allows you to obtain a "
"substring::"
msgstr ""
"インデックス指定に加えて *スライス* も使えます。インデックス指定では個々の文"
"字を取得し、 *スライス* では部分文字列を取得できます::"

#: ../../tutorial/introduction.rst:278
msgid ""
">>> word[0:2]  # characters from position 0 (included) to 2 (excluded)\n"
"'Py'\n"
">>> word[2:5]  # characters from position 2 (included) to 5 (excluded)\n"
"'tho'"
msgstr ""
">>> word[0:2]  # 0番目(含む)から2番目(含めない)までの文字\n"
"'Py'\n"
">>> word[2:5]  #  2番目(含む)から5番目(含めない)までの文字\n"
"'tho'"

#: ../../tutorial/introduction.rst:283
msgid ""
"Slice indices have useful defaults; an omitted first index defaults to zero, "
"an omitted second index defaults to the size of the string being sliced. ::"
msgstr ""
"スライスのインデックスには便利なデフォルト値があります。最初のインデックスを"
"省略すると 0 になり、2つ目を省略すると対象の文字列の長さになります::"

#: ../../tutorial/introduction.rst:286
msgid ""
">>> word[:2]   # character from the beginning to position 2 (excluded)\n"
"'Py'\n"
">>> word[4:]   # characters from position 4 (included) to the end\n"
"'on'\n"
">>> word[-2:]  # characters from the second-last (included) to the end\n"
"'on'"
msgstr ""
">>> word[:2]   # 最初から2番目(含めない)までの文字\n"
"'Py'\n"
">>> word[4:]   # 4番目(含む)から最後までの文字\n"
"'on'\n"
">>> word[-2:]  # 後ろから2番目(含む)から最後までの文字\n"
"'on'"

#: ../../tutorial/introduction.rst:293
msgid ""
"Note how the start is always included, and the end always excluded.  This "
"makes sure that ``s[:i] + s[i:]`` is always equal to ``s``::"
msgstr ""
"開始位置の文字は常に含まれ、終了位置の文字は常に含まれません。このため "
"``s[:i] + s[i:]`` は常に ``s`` と等しくなります::"

#: ../../tutorial/introduction.rst:296
msgid ""
">>> word[:2] + word[2:]\n"
"'Python'\n"
">>> word[:4] + word[4:]\n"
"'Python'"
msgstr ""
">>> word[:2] + word[2:]\n"
"'Python'\n"
">>> word[:4] + word[4:]\n"
"'Python'"

#: ../../tutorial/introduction.rst:301
msgid ""
"One way to remember how slices work is to think of the indices as pointing "
"*between* characters, with the left edge of the first character numbered 0. "
"Then the right edge of the last character of a string of *n* characters has "
"index *n*, for example::"
msgstr ""
"スライスの仕組みを覚えるには、インデックスが文字と文字の *間* を指し、最初の"
"文字の左端を 0 と考えるとよいでしょう。すると、長さ *n* の文字列では最後の文"
"字の右端のインデックスが *n* になります。例えば次のようになります::"

#: ../../tutorial/introduction.rst:306
msgid ""
" +---+---+---+---+---+---+\n"
" | P | y | t | h | o | n |\n"
" +---+---+---+---+---+---+\n"
" 0   1   2   3   4   5   6\n"
"-6  -5  -4  -3  -2  -1"
msgstr ""
" +---+---+---+---+---+---+\n"
" | P | y | t | h | o | n |\n"
" +---+---+---+---+---+---+\n"
" 0   1   2   3   4   5   6\n"
"-6  -5  -4  -3  -2  -1"

#: ../../tutorial/introduction.rst:312
msgid ""
"The first row of numbers gives the position of the indices 0...6 in the "
"string; the second row gives the corresponding negative indices. The slice "
"from *i* to *j* consists of all characters between the edges labeled *i* and "
"*j*, respectively."
msgstr ""
"数字の1行目は文字列内のインデックス 0 から 6 の位置を示し、2行目は対応する負"
"のインデックスを示しています。*i* から *j* までのスライスには、*i* と *j* の"
"印を付けた境界の間にあるすべての文字が含まれます。"

#: ../../tutorial/introduction.rst:317
msgid ""
"For non-negative indices, the length of a slice is the difference of the "
"indices, if both are within bounds.  For example, the length of "
"``word[1:3]`` is 2."
msgstr ""
"両端のインデックスが非負で文字列の範囲内にある場合、スライスの長さは2つのイン"
"デックスの差になります。例えば ``word[1:3]`` の長さは 2 です。"

#: ../../tutorial/introduction.rst:321
msgid "Attempting to use an index that is too large will result in an error::"
msgstr "大き過ぎるインデックスを使おうとするとエラーが発生します::"

#: ../../tutorial/introduction.rst:323
msgid ""
">>> word[42]  # the word only has 6 characters\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"IndexError: string index out of range"
msgstr ""
">>> word[42]  # 文字列は6文字しかない\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"IndexError: string index out of range"

#: ../../tutorial/introduction.rst:328
msgid ""
"However, out of range slice indexes are handled gracefully when used for "
"slicing::"
msgstr "一方、スライスではインデックスが範囲外でもエラーになりません::"

#: ../../tutorial/introduction.rst:331
msgid ""
">>> word[4:42]\n"
"'on'\n"
">>> word[42:]\n"
"''"
msgstr ""
">>> word[4:42]\n"
"'on'\n"
">>> word[42:]\n"
"''"

#: ../../tutorial/introduction.rst:336
msgid ""
"Python strings cannot be changed --- they are :term:`immutable`. Therefore, "
"assigning to an indexed position in the string results in an error::"
msgstr ""
"Python の文字列は :term:`不変 <immutable>` で、内容を変更できません。そのた"
"め、文字列のインデックスで指定した位置に代入するとエラーになります::"

#: ../../tutorial/introduction.rst:339
msgid ""
">>> word[0] = 'J'\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: 'str' object does not support item assignment\n"
">>> word[2:] = 'py'\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: 'str' object does not support item assignment"
msgstr ""
">>> word[0] = 'J'\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: 'str' object does not support item assignment\n"
">>> word[2:] = 'py'\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: 'str' object does not support item assignment"

#: ../../tutorial/introduction.rst:348
msgid "If you need a different string, you should create a new one::"
msgstr "別の文字列が必要な場合は新しく作成します::"

#: ../../tutorial/introduction.rst:350
msgid ""
">>> 'J' + word[1:]\n"
"'Jython'\n"
">>> word[:2] + 'py'\n"
"'Pypy'"
msgstr ""
">>> 'J' + word[1:]\n"
"'Jython'\n"
">>> word[:2] + 'py'\n"
"'Pypy'"

#: ../../tutorial/introduction.rst:355
msgid "The built-in function :func:`len` returns the length of a string::"
msgstr "組み込み関数 :func:`len` は文字列の長さを返します::"

#: ../../tutorial/introduction.rst:357
msgid ""
">>> s = 'supercalifragilisticexpialidocious'\n"
">>> len(s)\n"
"34"
msgstr ""
">>> s = 'supercalifragilisticexpialidocious'\n"
">>> len(s)\n"
"34"

#: ../../tutorial/introduction.rst:364
msgid ":ref:`textseq`"
msgstr ":ref:`textseq`"

#: ../../tutorial/introduction.rst:365
msgid ""
"Strings are examples of *sequence types*, and support the common operations "
"supported by such types."
msgstr ""
"文字列は *シーケンス型* の一種で、シーケンス型に共通する操作を使えます。"

#: ../../tutorial/introduction.rst:368
msgid ":ref:`string-methods`"
msgstr ":ref:`string-methods`"

#: ../../tutorial/introduction.rst:369
msgid ""
"Strings support a large number of methods for basic transformations and "
"searching."
msgstr "文字列には基本的な変換や検索を行うためのメソッドが数多くあります。"

#: ../../tutorial/introduction.rst:372
msgid ":ref:`f-strings`"
msgstr ":ref:`f-strings`"

#: ../../tutorial/introduction.rst:373
msgid "String literals that have embedded expressions."
msgstr "式の埋め込みをサポートした文字列リテラル"

#: ../../tutorial/introduction.rst:375
msgid ":ref:`formatstrings`"
msgstr ":ref:`formatstrings`"

#: ../../tutorial/introduction.rst:376
msgid "Information about string formatting with :meth:`str.format`."
msgstr ""
":meth:`str.format` を使った文字列のフォーマットについて説明しています。"

#: ../../tutorial/introduction.rst:378
msgid ":ref:`old-string-formatting`"
msgstr ":ref:`old-string-formatting`"

#: ../../tutorial/introduction.rst:379
msgid ""
"The old formatting operations invoked when strings are the left operand of "
"the ``%`` operator are described in more detail here."
msgstr ""
"文字列を ``%`` 演算子の左オペランドに指定して行う従来のフォーマット操作につい"
"て、詳しく説明しています。"

#: ../../tutorial/introduction.rst:386
msgid "Lists"
msgstr "リスト型 (list)"

#: ../../tutorial/introduction.rst:388
msgid ""
"Python knows a number of *compound* data types, used to group together other "
"values.  The most versatile is the *list*, which can be written as a list of "
"comma-separated values (items) between square brackets.  Lists might contain "
"items of different types, but usually the items all have the same type. ::"
msgstr ""
"Pythonは多くの *複合 (compound)* データ型を備えており、複数の値をまとめるのに"
"使われます。最も汎用性が高いのは *リスト (list)* で、コンマ区切りの値 (要素) "
"の並びを角括弧で囲んだものとして書き表されます。リストは異なる型の要素を含む"
"こともありますが、通常は同じ型の要素のみを持ちます。 ::"

#: ../../tutorial/introduction.rst:393
msgid ""
">>> squares = [1, 4, 9, 16, 25]\n"
">>> squares\n"
"[1, 4, 9, 16, 25]"
msgstr ""
">>> squares = [1, 4, 9, 16, 25]\n"
">>> squares\n"
"[1, 4, 9, 16, 25]"

#: ../../tutorial/introduction.rst:397
msgid ""
"Like strings (and all other built-in :term:`sequence` types), lists can be "
"indexed and sliced::"
msgstr ""
"文字列 (や他の全ての組み込みの :term:`シーケンス <sequence>` 型) のように、リ"
"ストはインデックスやスライスができます::"

#: ../../tutorial/introduction.rst:400
msgid ""
">>> squares[0]  # indexing returns the item\n"
"1\n"
">>> squares[-1]\n"
"25\n"
">>> squares[-3:]  # slicing returns a new list\n"
"[9, 16, 25]"
msgstr ""
">>> squares[0]  # インデックス指定は要素を返す\n"
"1\n"
">>> squares[-1]\n"
"25\n"
">>> squares[-3:]  # スライスは新しいリストを返す\n"
"[9, 16, 25]"

#: ../../tutorial/introduction.rst:407
msgid "Lists also support operations like concatenation::"
msgstr "リストは、リストの連結などもサポートしています::"

#: ../../tutorial/introduction.rst:409
msgid ""
">>> squares + [36, 49, 64, 81, 100]\n"
"[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"
msgstr ""
">>> squares + [36, 49, 64, 81, 100]\n"
"[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"

#: ../../tutorial/introduction.rst:412
msgid ""
"Unlike strings, which are :term:`immutable`, lists are a :term:`mutable` "
"type, i.e. it is possible to change their content::"
msgstr ""
":term:`不変 <immutable>` な文字列とは違って、リストは :term:`可変 <mutable>` "
"型ですので、内容を変更できます::"

#: ../../tutorial/introduction.rst:415
msgid ""
">>> cubes = [1, 8, 27, 65, 125]  # something's wrong here\n"
">>> 4 ** 3  # the cube of 4 is 64, not 65!\n"
"64\n"
">>> cubes[3] = 64  # replace the wrong value\n"
">>> cubes\n"
"[1, 8, 27, 64, 125]"
msgstr ""
">>> cubes = [1, 8, 27, 65, 125]  # 何かがおかしい\n"
">>> 4 ** 3  # 4の3乗は65ではなく64!\n"
"64\n"
">>> cubes[3] = 64  # 誤った値を置き換える\n"
">>> cubes\n"
"[1, 8, 27, 64, 125]"

#: ../../tutorial/introduction.rst:422
msgid ""
"You can also add new items at the end of the list, by using "
"the :meth:`list.append` *method* (we will see more about methods later)::"
msgstr ""
":meth:`list.append` *メソッド* を使って、リストの末尾に新しい要素を追加できま"
"す (メソッドについては後で詳しく見ていきます)::"

#: ../../tutorial/introduction.rst:425
msgid ""
">>> cubes.append(216)  # add the cube of 6\n"
">>> cubes.append(7 ** 3)  # and the cube of 7\n"
">>> cubes\n"
"[1, 8, 27, 64, 125, 216, 343]"
msgstr ""
">>> cubes.append(216)  # 6の3乗を追加\n"
">>> cubes.append(7 ** 3)  # 7の3乗を追加\n"
">>> cubes\n"
"[1, 8, 27, 64, 125, 216, 343]"

#: ../../tutorial/introduction.rst:430
msgid ""
"Simple assignment in Python never copies data. When you assign a list to a "
"variable, the variable refers to the *existing list*. Any changes you make "
"to the list through one variable will be seen through all other variables "
"that refer to it.::"
msgstr ""
"単純な代入ではPythonは決してデータをコピーしません。リストを変数に代入する"
"と、その変数は *既存のリスト* を参照します。ある変数を通してリストに任意の変"
"更を行うと、同じリストを参照している他のすべての変数からもその変更を確認でき"
"ます。::"

#: ../../tutorial/introduction.rst:435
msgid ""
">>> rgb = [\"Red\", \"Green\", \"Blue\"]\n"
">>> rgba = rgb\n"
">>> id(rgb) == id(rgba)  # they reference the same object\n"
"True\n"
">>> rgba.append(\"Alph\")\n"
">>> rgb\n"
"[\"Red\", \"Green\", \"Blue\", \"Alph\"]"
msgstr ""
">>> rgb = [\"Red\", \"Green\", \"Blue\"]\n"
">>> rgba = rgb\n"
">>> id(rgb) == id(rgba)  # 同じオブジェクトを参照している\n"
"True\n"
">>> rgba.append(\"Alph\")\n"
">>> rgb\n"
"[\"Red\", \"Green\", \"Blue\", \"Alph\"]"

#: ../../tutorial/introduction.rst:443
msgid ""
"All slice operations return a new list containing the requested elements.  "
"This means that the following slice returns a :ref:`shallow copy "
"<shallow_vs_deep_copy>` of the list::"
msgstr ""
"全てのスライス操作は、指定された要素を含む新しいリストを返します。例えば、次"
"のスライスは、リストの :ref:`浅いコピー <shallow_vs_deep_copy>` を返しま"
"す。::"

#: ../../tutorial/introduction.rst:447
msgid ""
">>> correct_rgba = rgba[:]\n"
">>> correct_rgba[-1] = \"Alpha\"\n"
">>> correct_rgba\n"
"[\"Red\", \"Green\", \"Blue\", \"Alpha\"]\n"
">>> rgba\n"
"[\"Red\", \"Green\", \"Blue\", \"Alph\"]"
msgstr ""
">>> correct_rgba = rgba[:]\n"
">>> correct_rgba[-1] = \"Alpha\"\n"
">>> correct_rgba\n"
"[\"Red\", \"Green\", \"Blue\", \"Alpha\"]\n"
">>> rgba\n"
"[\"Red\", \"Green\", \"Blue\", \"Alph\"]"

#: ../../tutorial/introduction.rst:454
msgid ""
"Assignment to slices is also possible, and this can even change the size of "
"the list or clear it entirely::"
msgstr ""
"スライスには、代入もできます。スライスの代入で、リストのサイズを変更したり、"
"全てを削除したりもできます::"

#: ../../tutorial/introduction.rst:457
msgid ""
">>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
">>> letters\n"
"['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
">>> # replace some values\n"
">>> letters[2:5] = ['C', 'D', 'E']\n"
">>> letters\n"
"['a', 'b', 'C', 'D', 'E', 'f', 'g']\n"
">>> # now remove them\n"
">>> letters[2:5] = []\n"
">>> letters\n"
"['a', 'b', 'f', 'g']\n"
">>> # clear the list by replacing all the elements with an empty list\n"
">>> letters[:] = []\n"
">>> letters\n"
"[]"
msgstr ""
">>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
">>> letters\n"
"['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
">>> # 一部の値を置き換える\n"
">>> letters[2:5] = ['C', 'D', 'E']\n"
">>> letters\n"
"['a', 'b', 'C', 'D', 'E', 'f', 'g']\n"
">>> # 一部の値を削除する\n"
">>> letters[2:5] = []\n"
">>> letters\n"
"['a', 'b', 'f', 'g']\n"
">>> # 要素全体を空のリストに置き換えてリストをクリアする\n"
">>> letters[:] = []\n"
">>> letters\n"
"[]"

#: ../../tutorial/introduction.rst:473
msgid "The built-in function :func:`len` also applies to lists::"
msgstr "組込み関数 :func:`len` はリストにも使えます::"

#: ../../tutorial/introduction.rst:475
msgid ""
">>> letters = ['a', 'b', 'c', 'd']\n"
">>> len(letters)\n"
"4"
msgstr ""
">>> letters = ['a', 'b', 'c', 'd']\n"
">>> len(letters)\n"
"4"

#: ../../tutorial/introduction.rst:479
msgid ""
"It is possible to nest lists (create lists containing other lists), for "
"example::"
msgstr "リストを入れ子 (ほかのリストを含むリストを造る) にできます。例えば::"

#: ../../tutorial/introduction.rst:482
msgid ""
">>> a = ['a', 'b', 'c']\n"
">>> n = [1, 2, 3]\n"
">>> x = [a, n]\n"
">>> x\n"
"[['a', 'b', 'c'], [1, 2, 3]]\n"
">>> x[0]\n"
"['a', 'b', 'c']\n"
">>> x[0][1]\n"
"'b'"
msgstr ""
">>> a = ['a', 'b', 'c']\n"
">>> n = [1, 2, 3]\n"
">>> x = [a, n]\n"
">>> x\n"
"[['a', 'b', 'c'], [1, 2, 3]]\n"
">>> x[0]\n"
"['a', 'b', 'c']\n"
">>> x[0][1]\n"
"'b'"

#: ../../tutorial/introduction.rst:495
msgid "First Steps Towards Programming"
msgstr "プログラミングへの第一歩"

#: ../../tutorial/introduction.rst:497
msgid ""
"Of course, we can use Python for more complicated tasks than adding two and "
"two together.  For instance, we can write an initial sub-sequence of the "
"`Fibonacci series <https://en.wikipedia.org/wiki/Fibonacci_sequence>`_ as "
"follows::"
msgstr ""
"もちろん、2 たす 2 よりももっと複雑な課題にも Python を使えます。\n"
"例えば、`フィボナッチ数列 <https://en.wikipedia.org/wiki/"
"Fibonacci_sequence>`_ の先頭の部分列は次のように書けます::"

#: ../../tutorial/introduction.rst:502
msgid ""
">>> # Fibonacci series:\n"
">>> # the sum of two elements defines the next\n"
">>> a, b = 0, 1\n"
">>> while a < 10:\n"
"...     print(a)\n"
"...     a, b = b, a+b\n"
"...\n"
"0\n"
"1\n"
"1\n"
"2\n"
"3\n"
"5\n"
"8"
msgstr ""
">>> # フィボナッチ数列:\n"
">>> # 2つの要素の和で次の値を定義する\n"
">>> a, b = 0, 1\n"
">>> while a < 10:\n"
"...     print(a)\n"
"...     a, b = b, a+b\n"
"...\n"
"0\n"
"1\n"
"1\n"
"2\n"
"3\n"
"5\n"
"8"

#: ../../tutorial/introduction.rst:517
msgid "This example introduces several new features."
msgstr "上の例では、いくつか新しい機能を使用しています。"

#: ../../tutorial/introduction.rst:519
msgid ""
"The first line contains a *multiple assignment*: the variables ``a`` and "
"``b`` simultaneously get the new values 0 and 1.  On the last line this is "
"used again, demonstrating that the expressions on the right-hand side are "
"all evaluated first before any of the assignments take place.  The right-"
"hand side expressions are evaluated  from the left to the right."
msgstr ""
"最初の行には *複数同時の代入 (multiple assignment)* が入っています: 変数 "
"``a`` と ``b`` は、それぞれ同時に新しい値 0 と 1 になっています。この代入は、"
"最後の行でも使われています。代入文では、まず右辺の式がすべて評価され、次に代"
"入が行われます。右辺の式は、左から右へと順番に評価されます。"

#: ../../tutorial/introduction.rst:525
msgid ""
"The :keyword:`while` loop executes as long as the condition (here: ``a < "
"10``) remains true.  In Python, like in C, any non-zero integer value is "
"true; zero is false.  The condition may also be a string or list value, in "
"fact any sequence; anything with a non-zero length is true, empty sequences "
"are false.  The test used in the example is a simple comparison.  The "
"standard comparison operators are written the same as in C: ``<`` (less "
"than), ``>`` (greater than), ``==`` (equal to), ``<=`` (less than or equal "
"to), ``>=`` (greater than or equal to) and ``!=`` (not equal to)."
msgstr ""
":keyword:`while` は、条件 (ここでは ``a < 10``) が真である限り実行を繰り返し "
"(ループし) ます。Python では、C 言語と同様に、ゼロでない整数値は真となり、ゼ"
"ロは偽です。条件式には、文字列値やリスト値なども使えます。それ以外のシーケン"
"スも、条件式として使用できます。長さが 1 以上のシーケンスは真で、空のシーケン"
"スは偽になります。サンプルで使われている条件テストはシンプルな比較です。標準"
"的な比較演算子は C 言語と同様です: すなわち、 ``<`` (より小さい)、 ``>`` (よ"
"り大きい)、 ``==`` (等しい)、 ``<=`` (より小さいか等しい)、 ``>=`` (より大き"
"いか等しい)、および ``!=`` (等しくない)、です。"

#: ../../tutorial/introduction.rst:534
msgid ""
"The *body* of the loop is *indented*: indentation is Python's way of "
"grouping statements.  At the interactive prompt, you have to type a tab or "
"space(s) for each indented line.  In practice you will prepare more "
"complicated input for Python with a text editor; all decent text editors "
"have an auto-indent facility.  When a compound statement is entered "
"interactively, it must be followed by a blank line to indicate completion "
"(since the parser cannot guess when you have typed the last line).  Note "
"that each line within a basic block must be indented by the same amount."
msgstr ""
"ループの *本体 (body)* は、 *インデント (indent, 字下げ)*  されています: イン"
"デントは Python において、文をグループにまとめる方法です。対話的プロンプトで"
"は、インデントされた各行を入力するにはタブや (複数個の) スペースを使わなけれ"
"ばなりません。実用的には、もっと複雑な処理を入力する場合はテキストエディタを"
"使うことになるでしょう。 ほとんどのテキストエディタは、自動インデント機能を"
"持っています。複合文を対話的に入力するときには、入力完了のしるしとして最後に"
"空行を入力します。パーザには最後の行の入力が終わったかどうかを判断できないた"
"めです。基本的なブロック内では、全ての行は同じだけインデントされていなければ"
"ならないので注意してください。"

#: ../../tutorial/introduction.rst:543
msgid ""
"The :func:`print` function writes the value of the argument(s) it is given. "
"It differs from just writing the expression you want to write (as we did "
"earlier in the calculator examples) in the way it handles multiple "
"arguments, floating-point quantities, and strings.  Strings are printed "
"without quotes, and a space is inserted between items, so you can format "
"things nicely, like this::"
msgstr ""
":func:`print` 関数は、与えられた引数の値を書き出します。これは (前に電卓の例"
"でやったような) 単に出力したい式を書くのとは、複数の引数や浮動小数点量や文字"
"列に対する扱い方が違います。 ``print()`` 関数では、文字列は引用符無しで出力さ"
"れ、要素の間に空白が挿入されて、このように出力の書式が整えられます::"

#: ../../tutorial/introduction.rst:550
msgid ""
">>> i = 256*256\n"
">>> print('The value of i is', i)\n"
"The value of i is 65536"
msgstr ""
">>> i = 256*256\n"
">>> print('The value of i is', i)\n"
"The value of i is 65536"

#: ../../tutorial/introduction.rst:554
msgid ""
"The keyword argument *end* can be used to avoid the newline after the "
"output, or end the output with a different string::"
msgstr ""
"キーワード引数 *end* を使うと、出力の末尾に改行文字を出力しないようにしたり、"
"別の文字列を末尾に出力したりできます::"

#: ../../tutorial/introduction.rst:557
msgid ""
">>> a, b = 0, 1\n"
">>> while a < 1000:\n"
"...     print(a, end=',')\n"
"...     a, b = b, a+b\n"
"...\n"
"0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,"
msgstr ""
">>> a, b = 0, 1\n"
">>> while a < 1000:\n"
"...     print(a, end=',')\n"
"...     a, b = b, a+b\n"
"...\n"
"0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,"

#: ../../tutorial/introduction.rst:566
msgid "Footnotes"
msgstr "脚注"

#: ../../tutorial/introduction.rst:567
msgid ""
"Since ``**`` has higher precedence than ``-``, ``-3**2`` will be interpreted "
"as ``-(3**2)`` and thus result in ``-9``.  To avoid this and get ``9``, you "
"can use ``(-3)**2``."
msgstr ""
"``**`` は ``-`` より優先順位が高いので、``-3**2`` は ``-(3**2)`` と解釈され、"
"計算結果は ``-9`` になります。これを避けて ``9`` を得たければ、``(-3)**2`` と"
"書きます。"

#: ../../tutorial/introduction.rst:571
msgid ""
"Unlike other languages, special characters such as ``\\n`` have the same "
"meaning with both single (``'...'``) and double (``\"...\"``) quotes. The "
"only difference between the two is that within single quotes you don't need "
"to escape ``\"`` (but you have to escape ``\\'``) and vice versa."
msgstr ""
"他の言語と違って、``\\n`` のような特殊文字は、単引用符 (``'...'``) と二重引用"
"符 (``\"...\"``) で同じ意味を持ちます。両者の唯一の違いは、単引用符で囲われた"
"箇所では ``\"`` をエスケープする必要がない (ただし ``\\'`` はエスケープする必"
"要がある) ことで、逆もまた同様です。"

#: ../../tutorial/introduction.rst:20
msgid "# (hash)"
msgstr "# (hash)"

#: ../../tutorial/introduction.rst:20
msgid "comment"
msgstr "コメント"