# 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 <[email protected]>, 2025

# Inada Naoki <[email protected]>, 2026

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.14\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-04-07 15:02+0000\n"

"PO-Revision-Date: 2025-09-16 00:02+0000\n"

"Last-Translator: Inada Naoki <[email protected]>, 2026\n"

"Language-Team: Japanese (https://app.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/inputoutput.rst:5

msgid "Input and Output"

msgstr "入力と出力"

#: ../../tutorial/inputoutput.rst:7

msgid ""

"There are several ways to present the output of a program; data can be "

"printed in a human-readable form, or written to a file for future use. This "

"chapter will discuss some of the possibilities."

msgstr ""

"プログラムの出力方法にはいくつかの種類があります。\n"

"データを人間が読める形で出力することもあれば、将来使うためにファイルに書くこ"

"ともあります。\n"

"この章では、こうした幾つかの出力の方法について話します。"

#: ../../tutorial/inputoutput.rst:15

msgid "Fancier Output Formatting"

msgstr "出力を見やすくフォーマットする"

#: ../../tutorial/inputoutput.rst:17

msgid ""

"So far we've encountered two ways of writing values: *expression statements* "

"and the :func:`print` function. (A third way is using the :meth:`~io."

"TextIOBase.write` method of file objects; the standard output file can be "

"referenced as ``sys.stdout``. See the Library Reference for more information "

"on this.)"

msgstr ""

"これまでに、値を出力する二つの方法: *式文 (expression statement)* と :func:"

"`print` 関数が出てきました。 (第三はファイルオブジェクトの :meth:`~io."

"TextIOBase.write` メソッドを使う方法です。標準出力を表すファイルは ``sys."

"stdout`` で参照できます。詳細はライブラリリファレンスを参照してください。)"

#: ../../tutorial/inputoutput.rst:22

msgid ""

"Often you'll want more control over the formatting of your output than "

"simply printing space-separated values. There are several ways to format "

"output."

msgstr ""

"単に空白区切りで値を並べただけの出力よりも、フォーマットを制御したいと思うこ"

"とはよくあることでしょう。\n"

"出力をフォーマットする方法はいくつかあります。"

#: ../../tutorial/inputoutput.rst:25

msgid ""

"To use :ref:`formatted string literals <tut-f-strings>`, begin a string with "

"``f`` or ``F`` before the opening quotation mark or triple quotation mark. "

"Inside this string, you can write a Python expression between ``{`` and ``}"

"`` characters that can refer to variables or literal values."

msgstr ""

":ref:`フォーマット済み文字列リテラル <tut-f-strings>` を使うには、開き引用符"

"や三重の開き引用符の前に ``f`` あるいは ``F`` を付けて文字列を始めます。\n"

"この文字列の内側では、文字 ``{`` と文字 ``}`` の間に Python の式が書け、その"

"式から変数やリテラル値が参照できます。"

#: ../../tutorial/inputoutput.rst:32

msgid ""

">>> year = 2016\n"

">>> event = 'Referendum'\n"

">>> f'Results of the {year} {event}'\n"

"'Results of the 2016 Referendum'"

msgstr ""

">>> year = 2016\n"

">>> event = '国民投票'\n"

">>> f'{year}年の{event}の結果'\n"

"'2016年の国民投票の結果'"

#: ../../tutorial/inputoutput.rst:37

msgid ""

"The :meth:`str.format` method of strings requires more manual effort. "

"You'll still use ``{`` and ``}`` to mark where a variable will be "

"substituted and can provide detailed formatting directives, but you'll also "

"need to provide the information to be formatted. In the following code block "

"there are two examples of how to format variables:"

msgstr ""

"文字列の :meth:`str.format` メソッドは、もう少し手間がかかります。\n"

"ここでも ``{`` と ``}`` を使って変数に代入する場所の印を付けて、細かいフォー"

"マットの指示を出せますが、フォーマットされる対象の情報を与える必要がありま"

"す。次のコードには、変数をフォーマットする方法の例が二つあります:"

#: ../../tutorial/inputoutput.rst:46

msgid ""

">>> yes_votes = 42_572_654\n"

">>> total_votes = 85_705_149\n"

">>> percentage = yes_votes / total_votes\n"

">>> '{:-9} YES votes {:2.2%}'.format(yes_votes, percentage)\n"

"' 42572654 YES votes 49.67%'"

msgstr ""

">>> yes_votes = 42_572_654\n"

">>> total_votes = 85_705_149\n"

">>> percentage = yes_votes / total_votes\n"

">>> '{:-9} 賛成票 {:2.2%}'.format(yes_votes, percentage)\n"

"' 42572654 賛成票 49.67%'"

#: ../../tutorial/inputoutput.rst:52

msgid ""

"Notice how the ``yes_votes`` are padded with spaces and a negative sign only "

"for negative numbers. The example also prints ``percentage`` multiplied by "

"100, with 2 decimal places and followed by a percent sign (see :ref:"

"`formatspec` for details)."

msgstr ""

"``yes_votes`` が、スペースと、負数の場合は負符号で埋められていることに注意し"

"てください。この例では、100を掛けた ``percentage`` を、パーセント記号付きで小"

"数点以下2桁で表示することも行っています。 (詳細は、 :ref:`formatspec` を参照"

"してください。)"

#: ../../tutorial/inputoutput.rst:57

msgid ""

"Finally, you can do all the string handling yourself by using string slicing "

"and concatenation operations to create any layout you can imagine. The "

"string type has some methods that perform useful operations for padding "

"strings to a given column width."

msgstr ""

"最後に、文字列のスライス操作や結合操作を使い、全ての文字列を自分で処理し、思"

"い通りのレイアウトを作成できます。\n"

"文字列型には、文字列の間隔を調整して指定されたカラム幅に揃えるのに便利な操作"

"を行うメソッドがいくつかあります。"

#: ../../tutorial/inputoutput.rst:62

msgid ""

"When you don't need fancy output but just want a quick display of some "

"variables for debugging purposes, you can convert any value to a string with "

"the :func:`repr` or :func:`str` functions."

msgstr ""

"凝った出力である必要は無いけれど、デバッグ目的で変数をすばやく表示したいとき"

"は、 :func:`repr` 関数か :func:`str` 関数でどんな値も文字列に変換できます。"

#: ../../tutorial/inputoutput.rst:66

msgid ""

"The :func:`str` function is meant to return representations of values which "

"are fairly human-readable, while :func:`repr` is meant to generate "

"representations which can be read by the interpreter (or will force a :exc:"

"`SyntaxError` if there is no equivalent syntax). For objects which don't "

"have a particular representation for human consumption, :func:`str` will "

"return the same value as :func:`repr`. Many values, such as numbers or "

"structures like lists and dictionaries, have the same representation using "

"either function. Strings, in particular, have two distinct representations."

msgstr ""

":func:`str` 関数は値の人間に読める表現を返すためのもので、 :func:`repr` 関数"

"はインタープリタに読める (あるいは同値となる構文がない場合は必ず :exc:"

"`SyntaxError` になるような) 表現を返すためのものです。人間が読むのに適した特"

"定の表現を持たないオブジェクトにおいては、 :func:`str` は :func:`repr` と同じ"

"値を返します。数値や、リストや辞書を始めとするデータ構造など、多くの値がどち"

"らの関数に対しても同じ表現を返します。一方、文字列は、2つの異なる表現を持って"

"います。"

#: ../../tutorial/inputoutput.rst:75

msgid "Some examples::"

msgstr "いくつかの例です::"

#: ../../tutorial/inputoutput.rst:77

msgid ""

">>> s = 'Hello, world.'\n"

">>> str(s)\n"

"'Hello, world.'\n"

">>> repr(s)\n"

"\"'Hello, world.'\"\n"

">>> str(1/7)\n"

"'0.14285714285714285'\n"

">>> x = 10 * 3.25\n"

">>> y = 200 * 200\n"

">>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'\n"

">>> print(s)\n"

"The value of x is 32.5, and y is 40000...\n"

">>> # The repr() of a string adds string quotes and backslashes:\n"

">>> hello = 'hello, world\\n'\n"

">>> hellos = repr(hello)\n"

">>> print(hellos)\n"

"'hello, world\\n'\n"

">>> # The argument to repr() may be any Python object:\n"

">>> repr((x, y, ('spam', 'eggs')))\n"

"\"(32.5, 40000, ('spam', 'eggs'))\""

msgstr ""

">>> s = 'Hello, world.'\n"

">>> str(s)\n"

"'Hello, world.'\n"

">>> repr(s)\n"

"\"'Hello, world.'\"\n"

">>> str(1/7)\n"

"'0.14285714285714285'\n"

">>> x = 10 * 3.25\n"

">>> y = 200 * 200\n"

">>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'\n"

">>> print(s)\n"

"The value of x is 32.5, and y is 40000...\n"

">>> # 文字列に repr() を使うとクォートとバックスラッシュが追加される:\n"

">>> hello = 'hello, world\\n'\n"

">>> hellos = repr(hello)\n"

">>> print(hellos)\n"

"'hello, world\\n'\n"

">>> # repr() の引数はどんな Python オブジェクトでも可:\n"

">>> repr((x, y, ('spam', 'eggs')))\n"

"\"(32.5, 40000, ('spam', 'eggs'))\""

#: ../../tutorial/inputoutput.rst:98

msgid ""

"The :mod:`string` module contains support for a simple templating approach "

"based upon regular expressions, via :class:`string.Template`. This offers "

"yet another way to substitute values into strings, using placeholders like "

"``$x`` and replacing them with values from a dictionary. This syntax is easy "

"to use, although it offers much less control for formatting."

msgstr ""

#: ../../tutorial/inputoutput.rst:115

msgid "Formatted String Literals"

msgstr "フォーマット済み文字列リテラル"

#: ../../tutorial/inputoutput.rst:117

msgid ""

":ref:`Formatted string literals <f-strings>` (also called f-strings for "

"short) let you include the value of Python expressions inside a string by "

"prefixing the string with ``f`` or ``F`` and writing expressions as "

"``{expression}``."

msgstr ""

":ref:`フォーマット済み文字リテラル <f-strings>` (短くして f-string とも呼びま"

"す) では、文字列の頭に ``f`` か ``F`` を付け、式を ``{expression}`` と書くこ"

"とで、 Python の式の値を文字列の中に入れ込めます。"

#: ../../tutorial/inputoutput.rst:122

msgid ""

"An optional format specifier can follow the expression. This allows greater "

"control over how the value is formatted. The following example rounds pi to "

"three places after the decimal::"

msgstr ""

"オプションのフォーマット指定子を式の後ろに付けられます。\n"

"このフォーマット指定子によって値のフォーマット方式を制御できます。\n"

"次の例では、円周率πを小数点以下3桁に丸めてフォーマットしています::"

#: ../../tutorial/inputoutput.rst:126

msgid ""

">>> import math\n"

">>> print(f'The value of pi is approximately {math.pi:.3f}.')\n"

"The value of pi is approximately 3.142."

msgstr ""

">>> import math\n"

">>> print(f'πの値はだいたい {math.pi:.3f} です。')\n"

"πの値はだいたい 3.142 です。"

#: ../../tutorial/inputoutput.rst:130

msgid ""

"Passing an integer after the ``':'`` will cause that field to be a minimum "

"number of characters wide. This is useful for making columns line up. ::"

msgstr ""

"``':'`` の後ろに整数をつけると、そのフィールドの最小の文字幅を指定できま"

"す。\n"

"この機能は縦を揃えるのに便利です。 ::"

#: ../../tutorial/inputoutput.rst:133

msgid ""

">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}\n"

">>> for name, phone in table.items():\n"

"... print(f'{name:10} ==> {phone:10d}')\n"

"...\n"

"Sjoerd ==> 4127\n"

"Jack ==> 4098\n"

"Dcab ==> 7678"

msgstr ""

">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}\n"

">>> for name, phone in table.items():\n"

"... print(f'{name:10} ==> {phone:10d}')\n"

"...\n"

"Sjoerd ==> 4127\n"

"Jack ==> 4098\n"

"Dcab ==> 7678"

#: ../../tutorial/inputoutput.rst:141

msgid ""

"Other modifiers can be used to convert the value before it is formatted. ``'!"

"a'`` applies :func:`ascii`, ``'!s'`` applies :func:`str`, and ``'!r'`` "

"applies :func:`repr`::"

msgstr ""

"他の修飾子は、フォーマットする前に値を変換するのに使えます。\n"

"``'!a'`` は :func:`ascii` を、 ``'!s'`` は :func:`str` を、 ``'!r'`` は :"

"func:`repr` を適用します::"

#: ../../tutorial/inputoutput.rst:145

msgid ""

">>> animals = 'eels'\n"

">>> print(f'My hovercraft is full of {animals}.')\n"

"My hovercraft is full of eels.\n"

">>> print(f'My hovercraft is full of {animals!r}.')\n"

"My hovercraft is full of 'eels'."

msgstr ""

">>> animals = 'ウナギ'\n"

">>> print(f'私のホバークラフトは {animals} でいっぱいです。')\n"

"私のホバークラフトは ウナギ でいっぱいです。\n"

">>> print(f'私のホバークラフトは {animals!r} でいっぱいです。')\n"

"私のホバークラフトは 'ウナギ' でいっぱいです。"

#: ../../tutorial/inputoutput.rst:151

msgid ""

"The ``=`` specifier can be used to expand an expression to the text of the "

"expression, an equal sign, then the representation of the evaluated "

"expression:"

msgstr ""

"``=`` 指定子を使用すると式を展開して、式、イコール記、式を評価した文字列表"

"現、の形式で表示されます。"

#: ../../tutorial/inputoutput.rst:160

msgid ""

"See :ref:`self-documenting expressions <bpo-36817-whatsnew>` for more "

"information on the ``=`` specifier. For a reference on these format "

"specifications, see the reference guide for the :ref:`formatspec`."

msgstr ""

"``=`` 指定子の詳細については :ref:`self-documenting expressions <bpo-36817-"

"whatsnew>` を参照してください。 フォーマットについての仕様は :ref:"

"`formatspec` のリファレンスガイドを参照してください。"

#: ../../tutorial/inputoutput.rst:167

msgid "The String format() Method"

msgstr "文字列の format() メソッド"

#: ../../tutorial/inputoutput.rst:169

msgid "Basic usage of the :meth:`str.format` method looks like this::"

msgstr ":meth:`str.format` メソッドの基本的な使い方は次のようなものです::"

#: ../../tutorial/inputoutput.rst:171

msgid ""

">>> print('We are the {} who say \"{}!\"'.format('knights', 'Ni'))\n"

"We are the knights who say \"Ni!\""

msgstr ""

">>> print('We are the {} who say \"{}!\"'.format('knights', 'Ni'))\n"

"We are the knights who say \"Ni!\""

#: ../../tutorial/inputoutput.rst:174

msgid ""

"The brackets and characters within them (called format fields) are replaced "

"with the objects passed into the :meth:`str.format` method. A number in the "

"brackets can be used to refer to the position of the object passed into the :"

"meth:`str.format` method. ::"

msgstr ""

"括弧とその中の文字(これをフォーマットフィールドと呼びます)は、 :meth:`str."

"format` メソッドに渡されたオブジェクトに置換されます。括弧の中の数字は :meth:"

"`str.format` メソッドに渡されたオブジェクトの位置を表すのに使えます。 ::"

#: ../../tutorial/inputoutput.rst:179

msgid ""

">>> print('{0} and {1}'.format('spam', 'eggs'))\n"

"spam and eggs\n"

">>> print('{1} and {0}'.format('spam', 'eggs'))\n"

"eggs and spam"

msgstr ""

">>> print('{0} and {1}'.format('spam', 'eggs'))\n"

"spam and eggs\n"

">>> print('{1} and {0}'.format('spam', 'eggs'))\n"

"eggs and spam"

#: ../../tutorial/inputoutput.rst:184

msgid ""

"If keyword arguments are used in the :meth:`str.format` method, their values "

"are referred to by using the name of the argument. ::"

msgstr ""

":meth:`str.format` メソッドにキーワード引数が渡された場合、その値はキーワード"

"引数の名前によって参照されます。 ::"

#: ../../tutorial/inputoutput.rst:187

msgid ""

">>> print('This {food} is {adjective}.'.format(\n"

"... food='spam', adjective='absolutely horrible'))\n"

"This spam is absolutely horrible."

msgstr ""

">>> print('This {food} is {adjective}.'.format(\n"

"... food='spam', adjective='absolutely horrible'))\n"

"This spam is absolutely horrible."

#: ../../tutorial/inputoutput.rst:191

msgid "Positional and keyword arguments can be arbitrarily combined::"

msgstr "順序引数とキーワード引数を組み合わせて使うこともできます::"

#: ../../tutorial/inputoutput.rst:193

msgid ""

">>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',\n"

"... other='Georg'))\n"

"The story of Bill, Manfred, and Georg."

msgstr ""

">>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',\n"

"... other='Georg'))\n"

"The story of Bill, Manfred, and Georg."

#: ../../tutorial/inputoutput.rst:197

msgid ""

"If you have a really long format string that you don't want to split up, it "

"would be nice if you could reference the variables to be formatted by name "

"instead of by position. This can be done by simply passing the dict and "

"using square brackets ``'[]'`` to access the keys. ::"

msgstr ""

"もしも長い書式文字列があり、それを分割したくない場合には、変数を引数の位置で"

"はなく変数の名前で参照できるとよいでしょう。これは、辞書を引数に渡して、角括"

"弧 ``'[]'`` を使って辞書のキーを参照することで可能です。 ::"

#: ../../tutorial/inputoutput.rst:202

msgid ""

">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"

">>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '\n"

"... 'Dcab: {0[Dcab]:d}'.format(table))\n"

"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"

msgstr ""

">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"

">>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '\n"

"... 'Dcab: {0[Dcab]:d}'.format(table))\n"

"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"

#: ../../tutorial/inputoutput.rst:207

msgid ""

"This could also be done by passing the ``table`` dictionary as keyword "

"arguments with the ``**`` notation. ::"

msgstr ""

"辞書 ``table`` を ``**`` 記法を使ってキーワード引数として渡す方法もありま"

"す。 ::"

#: ../../tutorial/inputoutput.rst:210

msgid ""

">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"

">>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'."

"format(**table))\n"

"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"

msgstr ""

">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"

">>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'."

"format(**table))\n"

"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"

#: ../../tutorial/inputoutput.rst:214

msgid ""

"This is particularly useful in combination with the built-in function :func:"

"`vars`, which returns a dictionary containing all local variables::"

msgstr ""

"全てのローカルな変数が入った辞書を返す組み込み関数 :func:`vars` と組み合わせ"

"ると特に便利です。"

#: ../../tutorial/inputoutput.rst:217

msgid ""

">>> table = {k: str(v) for k, v in vars().items()}\n"

">>> message = \" \".join([f'{k}: ' + '{' + k +'};' for k in table.keys()])\n"

">>> print(message.format(**table))\n"

"__name__: __main__; __doc__: None; __package__: None; __loader__: ..."

msgstr ""

">>> table = {k: str(v) for k, v in vars().items()}\n"

">>> message = \" \".join([f'{k}: ' + '{' + k +'};' for k in table.keys()])\n"

">>> print(message.format(**table))\n"

"__name__: __main__; __doc__: None; __package__: None; __loader__: ..."

#: ../../tutorial/inputoutput.rst:222

msgid ""

"As an example, the following lines produce a tidily aligned set of columns "

"giving integers and their squares and cubes::"

msgstr ""

"例として、下のコード行は与えられた整数とその2乗と3乗がきちんと揃った列を生成"

"します::"

#: ../../tutorial/inputoutput.rst:225

msgid ""

">>> for x in range(1, 11):\n"

"... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))\n"

"...\n"

" 1 1 1\n"

" 2 4 8\n"

" 3 9 27\n"

" 4 16 64\n"

" 5 25 125\n"

" 6 36 216\n"

" 7 49 343\n"

" 8 64 512\n"

" 9 81 729\n"

"10 100 1000"

msgstr ""

">>> for x in range(1, 11):\n"

"... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))\n"

"...\n"

" 1 1 1\n"

" 2 4 8\n"

" 3 9 27\n"

" 4 16 64\n"

" 5 25 125\n"

" 6 36 216\n"

" 7 49 343\n"

" 8 64 512\n"

" 9 81 729\n"

"10 100 1000"

#: ../../tutorial/inputoutput.rst:239

msgid ""

"For a complete overview of string formatting with :meth:`str.format`, see :"

"ref:`formatstrings`."

msgstr ""

":meth:`str.format` による文字列書式設定の完全な解説は、 :ref:`formatstrings` "

"を参照してください。"

#: ../../tutorial/inputoutput.rst:244

msgid "Manual String Formatting"

msgstr "文字列の手作業でのフォーマット"

#: ../../tutorial/inputoutput.rst:246

msgid "Here's the same table of squares and cubes, formatted manually::"

msgstr "次は 2 乗と 3 乗の値からなる同じ表を手作業でフォーマットしたものです::"

#: ../../tutorial/inputoutput.rst:248

msgid ""

">>> for x in range(1, 11):\n"

"... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')\n"

"... # Note use of 'end' on previous line\n"

"... print(repr(x*x*x).rjust(4))\n"

"...\n"

" 1 1 1\n"

" 2 4 8\n"

" 3 9 27\n"

" 4 16 64\n"

" 5 25 125\n"

" 6 36 216\n"

" 7 49 343\n"

" 8 64 512\n"

" 9 81 729\n"

"10 100 1000"

msgstr ""

">>> for x in range(1, 11):\n"

"... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')\n"

"... # 上の行で end を使用していることに注意\n"

"... print(repr(x*x*x).rjust(4))\n"

"...\n"

" 1 1 1\n"

" 2 4 8\n"

" 3 9 27\n"

" 4 16 64\n"

" 5 25 125\n"

" 6 36 216\n"

" 7 49 343\n"

" 8 64 512\n"

" 9 81 729\n"

"10 100 1000"

#: ../../tutorial/inputoutput.rst:264

msgid ""

"(Note that the one space between each column was added by the way :func:"

"`print` works: it always adds spaces between its arguments.)"

msgstr ""

"(各カラムの間のスペース一個分は :func:`print` の動作で追加されていることに注"

"意してください。 :func:`print` は常に引数間に空白を追加します。)"

#: ../../tutorial/inputoutput.rst:267

msgid ""

"The :meth:`str.rjust` method of string objects right-justifies a string in a "

"field of a given width by padding it with spaces on the left. There are "

"similar methods :meth:`str.ljust` and :meth:`str.center`. These methods do "

"not write anything, they just return a new string. If the input string is "

"too long, they don't truncate it, but return it unchanged; this will mess up "

"your column lay-out but that's usually better than the alternative, which "

"would be lying about a value. (If you really want truncation you can always "

"add a slice operation, as in ``x.ljust(n)[:n]``.)"

msgstr ""

"文字列オブジェクトの :meth:`str.rjust` メソッドは、指定された幅のフィールド内"

"に文字列が右寄せで入るように左側に空白を追加します。\n"

"同様のメソッドとして、 :meth:`str.ljust` と :meth:`str.center` があります。\n"

"これらのメソッドは何か出力を行うわけではなく、ただ新しい文字列を返します。\n"

"入力文字列が長すぎる場合、文字列を切り詰めることはせず、値をそのまま返しま"

"す。この仕様のためにカラムのレイアウトが滅茶苦茶になるかもしれませんが、嘘の"

"値が代わりに書き出されるよりはましです。\n"

"(本当に切り詰めを行いたいのなら、全てのカラムに ``x.ljust(n)[:n]`` のようにス"

"ライス表記を加えることもできます。)"

#: ../../tutorial/inputoutput.rst:276

msgid ""

"There is another method, :meth:`str.zfill`, which pads a numeric string on "

"the left with zeros. It understands about plus and minus signs::"

msgstr ""

"もう一つのメソッド、 :meth:`str.zfill` は、数値文字列の左側をゼロ詰めします。"

"このメソッドは正と負の符号を正しく扱います::"

#: ../../tutorial/inputoutput.rst:279

msgid ""

">>> '12'.zfill(5)\n"

"'00012'\n"

">>> '-3.14'.zfill(7)\n"

"'-003.14'\n"

">>> '3.14159265359'.zfill(5)\n"

"'3.14159265359'"

msgstr ""

">>> '12'.zfill(5)\n"

"'00012'\n"

">>> '-3.14'.zfill(7)\n"

"'-003.14'\n"

">>> '3.14159265359'.zfill(5)\n"

"'3.14159265359'"

#: ../../tutorial/inputoutput.rst:288

msgid "Old string formatting"

msgstr "古い文字列書式設定方法"

#: ../../tutorial/inputoutput.rst:290

msgid ""

"The % operator (modulo) can also be used for string formatting. Given "

"``format % values`` (where *format* is a string), ``%`` conversion "

"specifications in *format* are replaced with zero or more elements of "

"*values*. This operation is commonly known as string interpolation. For "

"example::"

msgstr ""

"% 演算子 (剰余) は文字列のフォーマットでも使えます。 ``format % values`` "

"(*format* は文字列) という文字列が与えられた場合、 *format* 中の ``%`` 変換指"

"定はゼロあるいは *values* の余りの要素に置換えられます。この操作は文字列補間"

"として知られています。例えば::"

#: ../../tutorial/inputoutput.rst:297

msgid ""

">>> import math\n"

">>> print('The value of pi is approximately %5.3f.' % math.pi)\n"

"The value of pi is approximately 3.142."

msgstr ""

">>> import math\n"

">>> print('πの値はだいたい %5.3f です。' % math.pi)\n"

"πの値はだいたい 3.142 です。"

#: ../../tutorial/inputoutput.rst:301

msgid ""

"More information can be found in the :ref:`old-string-formatting` section."

msgstr "より詳しい情報は :ref:`old-string-formatting` にあります。"

#: ../../tutorial/inputoutput.rst:307

msgid "Reading and Writing Files"

msgstr "ファイルを読み書きする"

#: ../../tutorial/inputoutput.rst:313

msgid ""

":func:`open` returns a :term:`file object`, and is most commonly used with "

"two positional arguments and one keyword argument: ``open(filename, mode, "

"encoding=None)``"

msgstr ""

":func:`open` は :term:`file object` を返します。大抵、 ``open(filename, "

"mode, encoding=None)`` のように2つの位置引数と1つのキーワード引数を伴って呼び"

"出されます。"

#: ../../tutorial/inputoutput.rst:319

msgid ">>> f = open('workfile', 'w', encoding=\"utf-8\")"

msgstr ">>> f = open('workfile', 'w', encoding=\"utf-8\")"

#: ../../tutorial/inputoutput.rst:326

msgid ""

"The first argument is a string containing the filename. The second argument "

"is another string containing a few characters describing the way in which "

"the file will be used. *mode* can be ``'r'`` when the file will only be "

"read, ``'w'`` for only writing (an existing file with the same name will be "

"erased), and ``'a'`` opens the file for appending; any data written to the "

"file is automatically added to the end. ``'r+'`` opens the file for both "

"reading and writing. The *mode* argument is optional; ``'r'`` will be "

"assumed if it's omitted."

msgstr ""

"最初の引数はファイル名の入った文字列です。二つめの引数も文字列で、ファイルを"

"どのように使うかを示す数個の文字が入っています。 *mode* は、ファイルが読み出"

"し専用なら ``'r'`` 、書き込み専用 (同名の既存のファイルがあれば消去されます) "

"なら ``'w'`` とします。 ``'a'`` はファイルを追記用に開きます。ファイルに書き"

"込まれた内容は自動的にファイルの終端に追加されます。 ``'r+'`` はファイルを読"

"み書き両用に開きます。 *mode* 引数は省略可能で、省略された場合には ``'r'`` で"

"あると仮定します。"

#: ../../tutorial/inputoutput.rst:335

msgid ""

"Normally, files are opened in :dfn:`text mode`, that means, you read and "

"write strings from and to the file, which are encoded in a specific "

"*encoding*. If *encoding* is not specified, the default is platform "

"dependent (see :func:`open`). Because UTF-8 is the modern de-facto standard, "

"``encoding=\"utf-8\"`` is recommended unless you know that you need to use a "

"different encoding. Appending a ``'b'`` to the mode opens the file in :dfn:"

"`binary mode`. Binary mode data is read and written as :class:`bytes` "

"objects. You can not specify *encoding* when opening file in binary mode."

msgstr ""

"通常、ファイルはテキストモード (:dfn:`text mode`) で開かれ、特定の *エンコー"

"ディング* でエンコードされたファイルに対して文字列を読み書きします。*エンコー"

"ディング* が指定されなければ、デフォルトはプラットフォーム依存です(:func:"

"`open` を参照してください)。UTF-8は現在の事実上の標準のため、異なるエンコー"

"ディングを指定したい場合以外は ``encoding=\"utf-8\"`` の指定がおすすめです。"

"モードに ``'b'`` をつけるとファイルを :dfn:`binary mode` で開きます。バイナ"

"リーモードでのデータは :class:`bytes` オブジェクトで読み書きします。ファイル"

"をバイナリーモードで開くときは *エンコーディング* は指定できません。"

#: ../../tutorial/inputoutput.rst:345

msgid ""

"In text mode, the default when reading is to convert platform-specific line "

"endings (``\\n`` on Unix, ``\\r\\n`` on Windows) to just ``\\n``. When "

"writing in text mode, the default is to convert occurrences of ``\\n`` back "

"to platform-specific line endings. This behind-the-scenes modification to "

"file data is fine for text files, but will corrupt binary data like that in :"

"file:`JPEG` or :file:`EXE` files. Be very careful to use binary mode when "

"reading and writing such files."

msgstr ""

"テキストモードの読み取りでは、プラットフォーム固有の行末記号 (Unix では "

"``\\n`` 、Windows では ``\\r\\n``) をただの ``\\n`` に変換するのがデフォルト"

"の動作です。テキストモードの書き込みでは、 ``\\n`` が出てくる箇所をプラット"

"フォーム固有の行末記号に戻すのがデフォルトの動作です。この裏で行われるファイ"

"ルデータの変換はテキストファイルには上手く働きますが、 :file:`JPEG` ファイル"

"や :file:`EXE` ファイルのようなバイナリデータを破壊する恐れがあります。そのよ"

"うなファイルを読み書きする場合には注意して、バイナリモードを使うようにしてく"

"ださい。"

#: ../../tutorial/inputoutput.rst:353

msgid ""

"It is good practice to use the :keyword:`with` keyword when dealing with "

"file objects. The advantage is that the file is properly closed after its "

"suite finishes, even if an exception is raised at some point. Using :"

"keyword:`!with` is also much shorter than writing equivalent :keyword:"

"`try`\\ -\\ :keyword:`finally` blocks::"

msgstr ""

"ファイルオブジェクトを扱うときに :keyword:`with` キーワードを使うのは良い習慣"

"です。\n"

"その利点は、処理中に例外が発生しても必ず最後にファイルをちゃんと閉じることで"

"す。\n"

":keyword:`!with` を使うと、同じことを :keyword:`try`\\ -\\ :keyword:"

"`finally` ブロックを使って書くよりずっと簡潔に書けます::"

#: ../../tutorial/inputoutput.rst:359

msgid ""

">>> with open('workfile', encoding=\"utf-8\") as f:\n"

"... read_data = f.read()\n"

"\n"

">>> # We can check that the file has been automatically closed.\n"

">>> f.closed\n"

"True"

msgstr ""

">>> with open('workfile', encoding=\"utf-8\") as f:\n"

"... read_data = f.read()\n"

"\n"

">>> # ファイルが自動でクローズされたことが確認できる\n"

">>> f.closed\n"

"True"

#: ../../tutorial/inputoutput.rst:366

msgid ""

"If you're not using the :keyword:`with` keyword, then you should call ``f."

"close()`` to close the file and immediately free up any system resources "

"used by it."

msgstr ""

"もし :keyword:`with` キーワードを使用しない場合は、ファイルを閉じ、このファイ"

"ルのために利用されたシステムのリソースを直ちに解放するために ``f.close()`` を"

"呼び出してください。"

#: ../../tutorial/inputoutput.rst:371

msgid ""

"Calling ``f.write()`` without using the :keyword:`!with` keyword or calling "

"``f.close()`` **might** result in the arguments of ``f.write()`` not being "

"completely written to the disk, even if the program exits successfully."

msgstr ""

"``f.write()`` を :keyword:`!with` キーワードや ``f.close()`` を使わずに呼び出"

"した場合、プログラムが正常に終了した場合でも、 ``f.write()`` の実引数がディス"

"クに完全に **書き込まれないことがあります** 。"

#: ../../tutorial/inputoutput.rst:379

msgid ""

"After a file object is closed, either by a :keyword:`with` statement or by "

"calling ``f.close()``, attempts to use the file object will automatically "

"fail. ::"

msgstr ""

":keyword:`with` 文や ``f.close()`` の呼び出しによって閉じられた後にファイルオ"

"ブジェクトを使おうとするとそこで処理が失敗します。::"

#: ../../tutorial/inputoutput.rst:383

msgid ""

">>> f.close()\n"

">>> f.read()\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"ValueError: I/O operation on closed file."

msgstr ""

">>> f.close()\n"

">>> f.read()\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"ValueError: I/O operation on closed file."

#: ../../tutorial/inputoutput.rst:393

msgid "Methods of File Objects"

msgstr "ファイルオブジェクトのメソッド"

#: ../../tutorial/inputoutput.rst:395

msgid ""

"The rest of the examples in this section will assume that a file object "

"called ``f`` has already been created."

msgstr ""

"この節の以降の例は、 ``f`` というファイルオブジェクトが既に生成されているもの"

"と仮定します。"

#: ../../tutorial/inputoutput.rst:398

msgid ""

"To read a file's contents, call ``f.read(size)``, which reads some quantity "

"of data and returns it as a string (in text mode) or bytes object (in binary "

"mode). *size* is an optional numeric argument. When *size* is omitted or "

"negative, the entire contents of the file will be read and returned; it's "

"your problem if the file is twice as large as your machine's memory. "

"Otherwise, at most *size* characters (in text mode) or *size* bytes (in "

"binary mode) are read and returned. If the end of the file has been reached, "

"``f.read()`` will return an empty string (``''``). ::"

msgstr ""

"ファイルの内容を読み出すには、 ``f.read(size)`` を呼び出します。このメソッド"

"はある量のデータを読み出して、文字列 (テキストモードの場合) か bytes オブジェ"

"クト (バイナリーモードの場合) として返します。 *size* はオプションの数値引数"

"です。 *size* が省略されたり負の数であった場合、ファイルの内容全てを読み出し"

"て返します。ただし、ファイルがマシンのメモリの二倍の大きさもある場合にはどう"

"なるかわかりません。 *size* が負でない数ならば、最大で (テキストモードの場"

"合) *size* 文字、(バイナリモードの場合) *size* バイトを読み出して返します。"

"ファイルの終端にすでに達していた場合、 ``f.read()`` は空の文字列 (``''``) を"

"返します。 ::"

#: ../../tutorial/inputoutput.rst:407

msgid ""

">>> f.read()\n"

"'This is the entire file.\\n'\n"

">>> f.read()\n"

"''"

msgstr ""

">>> f.read()\n"

"'これがファイル全体です。\\n'\n"

">>> f.read()\n"

"''"

#: ../../tutorial/inputoutput.rst:412

msgid ""

"``f.readline()`` reads a single line from the file; a newline character "

"(``\\n``) is left at the end of the string, and is only omitted on the last "

"line of the file if the file doesn't end in a newline. This makes the "

"return value unambiguous; if ``f.readline()`` returns an empty string, the "

"end of the file has been reached, while a blank line is represented by "

"``'\\n'``, a string containing only a single newline. ::"

msgstr ""

"``f.readline()`` はファイルから 1 行だけを読み取ります。改行文字 (``\\n``) は"

"読み出された文字列の終端に残ります。改行が省略されるのは、ファイルが改行で終"

"わっていない場合の最終行のみです。これは、戻り値があいまいでないようにするた"

"めです; ``f.readline()`` が空の文字列を返したら、ファイルの終端に達したことが"

"分かります。一方、空行は ``'\\n'``、すなわち改行 1 文字だけからなる文字列で表"

"現されます。 ::"

#: ../../tutorial/inputoutput.rst:419

msgid ""

">>> f.readline()\n"

"'This is the first line of the file.\\n'\n"

">>> f.readline()\n"

"'Second line of the file\\n'\n"

">>> f.readline()\n"

"''"

msgstr ""

">>> f.readline()\n"

"'これがファイルの最初の行です。\\n'\n"

">>> f.readline()\n"

"'ファイルの2行目です。\\n'\n"

">>> f.readline()\n"

"''"

#: ../../tutorial/inputoutput.rst:426

msgid ""

"For reading lines from a file, you can loop over the file object. This is "

"memory efficient, fast, and leads to simple code::"

msgstr ""

"ファイルから複数行を読み取るには、ファイルオブジェクトに対してループを書く方"

"法があります。この方法はメモリを効率的に使え、高速で、簡潔なコードになりま"

"す::"

#: ../../tutorial/inputoutput.rst:429

msgid ""

">>> for line in f:\n"

"... print(line, end='')\n"

"...\n"

"This is the first line of the file.\n"

"Second line of the file"

msgstr ""

">>> for line in f:\n"

"... print(line, end='')\n"

"...\n"

"これがファイルの最初の行です。\n"

"ファイルの2行目です。"

#: ../../tutorial/inputoutput.rst:435

msgid ""

"If you want to read all the lines of a file in a list you can also use "

"``list(f)`` or ``f.readlines()``."

msgstr ""

"ファイルのすべての行をリスト形式で読み取りたいなら、``list(f)`` や ``f."

"readlines()`` を使うこともできます。"

#: ../../tutorial/inputoutput.rst:438

msgid ""

"``f.write(string)`` writes the contents of *string* to the file, returning "

"the number of characters written. ::"

msgstr ""

"``f.write(string)`` は、*string* の内容をファイルに書き込み、書き込まれた文字"

"数を返します。 ::"

#: ../../tutorial/inputoutput.rst:441

msgid ""

">>> f.write('This is a test\\n')\n"

"15"

msgstr ""

">>> f.write('This is a test\\n')\n"

"15"

#: ../../tutorial/inputoutput.rst:444

msgid ""

"Other types of objects need to be converted -- either to a string (in text "

"mode) or a bytes object (in binary mode) -- before writing them::"

msgstr ""

"オブジェクトの他の型は、書き込む前に変換しなければなりません -- 文字列 (テキ"

"ストモード) と bytes オブジェクト (バイナリーモード) のいずれかです::"

#: ../../tutorial/inputoutput.rst:447

msgid ""

">>> value = ('the answer', 42)\n"

">>> s = str(value) # convert the tuple to string\n"

">>> f.write(s)\n"

"18"

msgstr ""

">>> value = ('the answer', 42)\n"

">>> s = str(value) # タプルを文字列に変換\n"

">>> f.write(s)\n"

"18"

#: ../../tutorial/inputoutput.rst:452

msgid ""

"``f.tell()`` returns an integer giving the file object's current position in "

"the file represented as number of bytes from the beginning of the file when "

"in binary mode and an opaque number when in text mode."

msgstr ""

"``f.tell()`` は、ファイルオブジェクトのファイル中における現在の位置を示す整数"

"を返します。ファイル中の現在の位置は、バイナリモードではファイルの先頭からの"

"バイト数で、テキストモードでは不明瞭な値で表されます。"

#: ../../tutorial/inputoutput.rst:456

msgid ""

"To change the file object's position, use ``f.seek(offset, whence)``. The "

"position is computed from adding *offset* to a reference point; the "

"reference point is selected by the *whence* argument. A *whence* value of 0 "

"measures from the beginning of the file, 1 uses the current file position, "

"and 2 uses the end of the file as the reference point. *whence* can be "

"omitted and defaults to 0, using the beginning of the file as the reference "

"point. ::"

msgstr ""

"ファイルオブジェクトの位置を変更するには、``f.seek(offset, whence)`` を使いま"

"す。ファイル位置は基準点 (reference point) にオフセット値 *offset* を足して計"

"算されます。参照点は *whence* 引数で選びます。*whence* の値が 0 ならばファイ"

"ルの 先頭から測り、1 ならば現在のファイル位置を使い、2 ならばファイルの終端を"

"参照点として使います。*whence* は省略することができ、デフォルトの値は 0、すな"

"わち参照点としてファイルの先頭を使います。 ::"

#: ../../tutorial/inputoutput.rst:463

msgid ""

">>> f = open('workfile', 'rb+')\n"

">>> f.write(b'0123456789abcdef')\n"

"16\n"

">>> f.seek(5) # Go to the 6th byte in the file\n"

"5\n"

">>> f.read(1)\n"

"b'5'\n"

">>> f.seek(-3, 2) # Go to the 3rd byte before the end\n"

"13\n"

">>> f.read(1)\n"

"b'd'"

msgstr ""

">>> f = open('workfile', 'rb+')\n"

">>> f.write(b'0123456789abcdef')\n"

"16\n"

">>> f.seek(5) # ファイル内の6番目のバイトまで移動\n"

"5\n"

">>> f.read(1)\n"

"b'5'\n"

">>> f.seek(-3, 2) # 末尾から３番目のバイトに移動\n"

"13\n"

">>> f.read(1)\n"

"b'd'"

#: ../../tutorial/inputoutput.rst:475

msgid ""

"In text files (those opened without a ``b`` in the mode string), only seeks "

"relative to the beginning of the file are allowed (the exception being "

"seeking to the very file end with ``seek(0, 2)``) and the only valid "

"*offset* values are those returned from the ``f.tell()``, or zero. Any other "

"*offset* value produces undefined behaviour."

msgstr ""

"テキストファイル (mode 文字列に ``b`` を付けなかった場合) では、ファイルの先"

"頭からの相対位置に対するシークだけが許可されています (例外として、``seek(0, "

"2)`` でファイルの末尾へのシークは可能です)。また、唯一の有効な *offset* 値は "

"``f.tell()`` から返された値か、0 のいずれかです。それ以外の *offset* 値は未定"

"義の振る舞いを引き起こします。"