# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
# Translators:
# tomo, 2021
# Yusuke Miyazaki <miyazaki.dev@gmail.com>, 2021
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.10\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-06-29 12:56+0000\n"
"PO-Revision-Date: 2021-06-28 01:50+0000\n"
"Last-Translator: Yusuke Miyazaki <miyazaki.dev@gmail.com>, 2021\n"
"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/ja/)\n"
"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:`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:`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: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."
msgstr ""
"文字列の :meth:`str.format` メソッドは、もう少し手間がかかります。\n"
"ここでも ``{`` と ``}`` を使って変数に代入する場所の印を付けて、細かいフォーマットの指示を出せますが、フォーマットされる対象の情報を与える必要があります。"

#: ../../tutorial/inputoutput.rst:50
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:55
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:59
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:68
msgid "Some examples::"
msgstr "いくつかの例です::"

#: ../../tutorial/inputoutput.rst:91
msgid ""
"The :mod:`string` module contains a :class:`~string.Template` class that "
"offers yet another way to substitute values into strings, using placeholders"
" like ``$x`` and replacing them with values from a dictionary, but offers "
"much less control of the formatting."
msgstr ""
":mod:`string` モジュールの :class:`~string.Template` クラスも、文字列中の値を置換する別の方法を提供しています。"
" ``$x`` のようなプレースホルダーを使い、その箇所と辞書にある値を置き換えますが、使えるフォーマット方式はとても少ないです。"

#: ../../tutorial/inputoutput.rst:100
msgid "Formatted String Literals"
msgstr "フォーマット済み文字列リテラル"

#: ../../tutorial/inputoutput.rst:102
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:107
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:115
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:126
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:136
msgid ""
"For a reference on these format specifications, see the reference guide for "
"the :ref:`formatspec`."
msgstr "これらのフォーマット仕様の参考資料として、 :ref:`formatspec` のガイドを参照してください。"

#: ../../tutorial/inputoutput.rst:142
msgid "The String format() Method"
msgstr "文字列の format() メソッド"

#: ../../tutorial/inputoutput.rst:144
msgid "Basic usage of the :meth:`str.format` method looks like this::"
msgstr ":meth:`str.format` メソッドの基本的な使い方は次のようなものです::"

#: ../../tutorial/inputoutput.rst:149
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:159
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:166
msgid "Positional and keyword arguments can be arbitrarily combined::"
msgstr "順序引数とキーワード引数を組み合わせて使うこともできます::"

#: ../../tutorial/inputoutput.rst:172
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:182
msgid ""
"This could also be done by passing the table as keyword arguments with the "
"'**' notation. ::"
msgstr "table を '**' 記法を使ってキーワード引数として渡す方法もあります。 ::"

#: ../../tutorial/inputoutput.rst:189
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:192
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:209
msgid ""
"For a complete overview of string formatting with :meth:`str.format`, see "
":ref:`formatstrings`."
msgstr ":meth:`str.format` による文字列書式設定の完全な解説は、 :ref:`formatstrings` を参照してください。"

#: ../../tutorial/inputoutput.rst:214
msgid "Manual String Formatting"
msgstr "文字列の手作業でのフォーマット"

#: ../../tutorial/inputoutput.rst:216
msgid "Here's the same table of squares and cubes, formatted manually::"
msgstr "次は 2 乗と 3 乗の値からなる同じ表を手作業でフォーマットしたものです::"

#: ../../tutorial/inputoutput.rst:234
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:237
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:246
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:258
msgid "Old string formatting"
msgstr "古い文字列書式設定方法"

#: ../../tutorial/inputoutput.rst:260
msgid ""
"The % operator (modulo) can also be used for string formatting. Given "
"``'string' % values``, instances of ``%`` in ``string`` are replaced with "
"zero or more elements of ``values``. This operation is commonly known as "
"string interpolation. For example::"
msgstr ""
"% 演算子 (剰余) は文字列のフォーマットでも使えます。\n"
"``'string' % values`` という文字列が与えられた場合、``string`` の中の ``%`` 部分はゼロあるいは ``values`` の余りの要素に置換えられます。\n"
"この操作は文字列補間として知られています。\n"
"例えば::"

#: ../../tutorial/inputoutput.rst:269
msgid ""
"More information can be found in the :ref:`old-string-formatting` section."
msgstr "より詳しい情報は :ref:`old-string-formatting` にあります。"

#: ../../tutorial/inputoutput.rst:275
msgid "Reading and Writing Files"
msgstr "ファイルを読み書きする"

#: ../../tutorial/inputoutput.rst:281
msgid ""
":func:`open` returns a :term:`file object`, and is most commonly used with "
"two arguments: ``open(filename, mode)``."
msgstr ""
":func:`open` は :term:`file object` を返します。大抵、 ``open(filename, mode)`` "
"のように二つの引数を伴って呼び出されます。"

#: ../../tutorial/inputoutput.rst:293
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:302
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`). ``'b'`` appended to the mode opens the file in "
":dfn:`binary mode`: now the data is read and written in the form of bytes "
"objects.  This mode should be used for all files that don't contain text."
msgstr ""
"通常、ファイルはテキストモード (:dfn:`text mode`) "
"で開かれ、特定のエンコーディングでエンコードされたファイルに対して文字列を読み書きします。エンコーディングが指定されなければ、デフォルトはプラットフォーム依存です"
" (:func:`open` を参照してください) 。モードに ``'b'`` をつけるとファイルをバイナリモード (:dfn:`binary "
"mode`) で開き、 byte オブジェクトを読み書きします。テキストファイル以外のすべてのファイルはバイナリモードを利用するべきです。"

#: ../../tutorial/inputoutput.rst:309
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:317
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:330
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:335
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:343
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:357
msgid "Methods of File Objects"
msgstr "ファイルオブジェクトのメソッド"

#: ../../tutorial/inputoutput.rst:359
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:362
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:376
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:390
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:399
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:402
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:408
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:416
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:420
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:439
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* 値は未定義の振る舞いを引き起こします。"

#: ../../tutorial/inputoutput.rst:445
msgid ""
"File objects have some additional methods, such as :meth:`~file.isatty` and "
":meth:`~file.truncate` which are less frequently used; consult the Library "
"Reference for a complete guide to file objects."
msgstr ""
"ファイルオブジェクトには、他にも :meth:`~file.isatty` や :meth:`~file.truncate` "
"といった、あまり使われないメソッドがあります。ファイルオブジェクトについての完全なガイドは、ライブラリリファレンスを参照してください。"

#: ../../tutorial/inputoutput.rst:453
msgid "Saving structured data with :mod:`json`"
msgstr ":mod:`json` による構造化されたデータの保存"

#: ../../tutorial/inputoutput.rst:457
msgid ""
"Strings can easily be written to and read from a file.  Numbers take a bit "
"more effort, since the :meth:`read` method only returns strings, which will "
"have to be passed to a function like :func:`int`, which takes a string like "
"``'123'`` and returns its numeric value 123.  When you want to save more "
"complex data types like nested lists and dictionaries, parsing and "
"serializing by hand becomes complicated."
msgstr ""
"文字列は簡単にファイルに書き込んだり、ファイルから読み込んだりすることができます。数値の場合には少し努力が必要です。というのも、:meth:`read`"
" メソッドは文字列しか返さないため、:func:`int` のような関数にその文字列を渡して、たとえば文字列 ``'123'`` のような文字列を、数値"
" 123 "
"に変換しなくてはならないからです。もっと複雑なデータ型、例えば入れ子になったリストや辞書の場合、手作業でのパースやシリアライズは困難になります。"

#: ../../tutorial/inputoutput.rst:464
msgid ""
"Rather than having users constantly writing and debugging code to save "
"complicated data types to files, Python allows you to use the popular data "
"interchange format called `JSON (JavaScript Object Notation) "
"<http://json.org>`_.  The standard module called :mod:`json` can take Python"
" data hierarchies, and convert them to string representations; this process "
"is called :dfn:`serializing`.  Reconstructing the data from the string "
"representation is called :dfn:`deserializing`.  Between serializing and "
"deserializing, the string representing the object may have been stored in a "
"file or data, or sent over a network connection to some distant machine."
msgstr ""
"ユーザが毎回コードを書いたりデバッグしたりして複雑なデータ型をファイルに保存するかわりに、Python では一般的なデータ交換形式である `JSON "
"(JavaScript Object Notation) <http://json.org>`_ を使うことができます。この標準モジュール "
":mod:`json` は、Python のデータ 階層を取り、文字列表現に変換します。この処理は :dfn:`シリアライズ "
"(serializing)` と呼ばれます。文字列表現からデータを再構築することは、:dfn:`デシリアライズ (deserializing)` "
"と呼ばれます。シリアライズされてからデシリアライズされるまでの間に、オブジェクトの文字列表現はファイルやデータの形で保存したり、ネットワークを通じて離れたマシンに送ったりすることができます。"

#: ../../tutorial/inputoutput.rst:475
msgid ""
"The JSON format is commonly used by modern applications to allow for data "
"exchange.  Many programmers are already familiar with it, which makes it a "
"good choice for interoperability."
msgstr ""
"JSON 形式は現代的なアプリケーションでデータをやりとりする際によく使われます。多くのプログラマーが既に JSON に詳しいため、JSON "
"はデータの相互交換をする場合の良い選択肢です。"

#: ../../tutorial/inputoutput.rst:479
msgid ""
"If you have an object ``x``, you can view its JSON string representation "
"with a simple line of code::"
msgstr "オブジェクト ``x`` があり、その JSON 形式の文字列表現を見るには、単純な1行のコードを書くだけです::"

#: ../../tutorial/inputoutput.rst:487
msgid ""
"Another variant of the :func:`~json.dumps` function, called "
":func:`~json.dump`, simply serializes the object to a :term:`text file`.  So"
" if ``f`` is a :term:`text file` object opened for writing, we can do this::"
msgstr ""
":func:`~json.dumps` に似た関数に、:func:`~json.dump` があり、こちらは単純にオブジェクトを :term:`text"
" file` にシリアライズします。``f`` が書き込み用に開かれた :term:`text file` だとすると、次のように書くことができます::"

#: ../../tutorial/inputoutput.rst:493
msgid ""
"To decode the object again, if ``f`` is a :term:`text file` object which has"
" been opened for reading::"
msgstr "逆にデシリアライズするには、``f`` が読み込み用に開かれた :term:`text file` だとすると、次のようになります::"

#: ../../tutorial/inputoutput.rst:498
msgid ""
"This simple serialization technique can handle lists and dictionaries, but "
"serializing arbitrary class instances in JSON requires a bit of extra "
"effort. The reference for the :mod:`json` module contains an explanation of "
"this."
msgstr ""
"このような単純なシリアライズをする手法は、リストや辞書を扱うことはできますが、任意のクラス・インスタンスを JSON "
"にシリアライズするにはもう少し努力しなくてはなりません。:mod:`json` モジュールのリファレンスにこれについての解説があります。"

#: ../../tutorial/inputoutput.rst:504
msgid ":mod:`pickle` - the pickle module"
msgstr ":mod:`pickle` - pickle モジュール"

#: ../../tutorial/inputoutput.rst:506
msgid ""
"Contrary to :ref:`JSON <tut-json>`, *pickle* is a protocol which allows the "
"serialization of arbitrarily complex Python objects.  As such, it is "
"specific to Python and cannot be used to communicate with applications "
"written in other languages.  It is also insecure by default: deserializing "
"pickle data coming from an untrusted source can execute arbitrary code, if "
"the data was crafted by a skilled attacker."
msgstr ""
":ref:`JSON <tut-json>` とは対照的に、 *pickle* は任意の複雑な Python "
"オブジェクトをシリアライズ可能なプロトコルです。しかし、Python "
"に特有のプロトコルで、他の言語で記述されたアプリケーションと通信するのには使えません。さらに、デフォルトでは安全でなく、信頼できない送信元から送られてきた、スキルのある攻撃者によって生成された"
" pickle データをデシリアライズすると、攻撃者により任意のコードが実行されてしまいます。"