# SOME DESCRIPTIVE TITLE.
# Copyright (C) 1990-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# tomo, 2018
# 秘湯 <xwhhsprings@gmail.com>, 2015
msgid ""
msgstr ""
"Project-Id-Version: Python 2.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-01-01 01:01+0900\n"
"PO-Revision-Date: 2019-09-01 05:18+0000\n"
"Last-Translator: tomo\n"
"Language-Team: Japanese (http://www.transifex.com/python-doc/python-27/"
"language/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/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 ""
"プログラムから出力を行う方法がいくつかあります。データは人間が読める形で出力"
"することも、将来使うためにファイルに書くこともできます。この章では、こうした"
"幾つかの出力の方法について話します。"

#: ../../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 :keyword:`print` statement.  (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)* と :"
"keyword:`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 two ways to format your "
"output; the first way is to do all the string handling yourself; using "
"string slicing and concatenation operations you can create any layout you "
"can imagine.  The string types have some methods that perform useful "
"operations for padding strings to a given column width; these will be "
"discussed shortly.  The second way is to use the :meth:`str.format` method."
msgstr ""
"出力を書式化する際に、単に値をスペースで区切って出力するよりももっときめ細か"
"な制御をしたいと思うことがあるでしょう。出力を書式化するには二つの方法があり"
"ます。第一の方法は、全ての文字列を自分で処理するというものです。文字列のスラ"
"イスや結合といった操作を使えば、思い通りのレイアウトを作成することができま"
"す。文字列オブジェクトは、文字列を指定されたカラム幅に揃えるための幾つかの便"
"利なメソッドを提供しています。これらのメソッドについてはすぐ後で簡単に説明し"
"ます。もうひとつの方法は :meth:`str.format` メソッドを利用することです。"

#: ../../tutorial/inputoutput.rst:30
msgid ""
"The :mod:`string` module contains a :class:`~string.Template` class which "
"offers yet another way to substitute values into strings."
msgstr ""
":mod:`string` モジュールの :class:`~string.Template` クラスは文字列中の値を置"
"換する別の方法を提供しています。"

#: ../../tutorial/inputoutput.rst:33
msgid ""
"One question remains, of course: how do you convert values to strings? "
"Luckily, Python has ways to convert any value to a string: pass it to the :"
"func:`repr` or :func:`str` functions."
msgstr ""
"もちろん、一つ問題があります。値をどうやって文字列に変換したらいいのでしょう"
"か？幸運なことに、Python には値を文字列に変換する方法があります。値を :func:"
"`repr` か :func:`str` 関数に渡してください。"

#: ../../tutorial/inputoutput.rst:37
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 and floating point numbers, in particular, have "
"two distinct representations."
msgstr ""
":func:`str` 関数は値の人間に読める表現を返すためのもので、 :func:`repr` 関数"
"はインタープリタに読める (あるいは同値となる構文がない場合は必ず :exc:"
"`SyntaxError` になるような) 表現を返すためのものです。人間が読むのに適した特"
"定の表現を持たないオブジェクトにおいては、 :func:`str` は :func:`repr` と同じ"
"値を返します。数値や、リストや辞書を始めとするデータ構造など、多くの値がどち"
"らの関数に対しても同じ表現を返します。一方、文字列と浮動小数点数は、2つの異な"
"る表現を持っています。"

#: ../../tutorial/inputoutput.rst:46
msgid "Some examples::"
msgstr "幾つかの例です::"

#: ../../tutorial/inputoutput.rst:71
msgid "Here are two ways to write a table of squares and cubes::"
msgstr "以下に 2 乗と 3 乗の値からなる表を書く二つの方法を示します::"

#: ../../tutorial/inputoutput.rst:103
msgid ""
"(Note that in the first example, one space between each column was added by "
"the way :keyword:`print` works: by default it adds spaces between its "
"arguments.)"
msgstr ""
"(最初の例で、 :keyword:`print` の動作により各カラムの間にスペースが一個ずつ追"
"加されていることに注意してください。 :keyword:`print` はデフォルトでは引数間"
"に空白を追加します。)"

#: ../../tutorial/inputoutput.rst:106
msgid ""
"This example demonstrates the :meth:`str.rjust` method of string objects, "
"which 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` メソッドの使い方を示しています。 :"
"meth:`str.rjust` は文字列を指定された幅のフィールド内に右詰めで入るように、左"
"に空白を追加します。同様のメソッドとして、 :meth:`str.ljust` と :meth:`str."
"center` があります。これらのメソッドは何か出力を行うわけではなく、ただ新しい"
"文字列を返します。入力文字列が長すぎる場合、文字列を切り詰めることはせず、た"
"だ値をそのまま返します。この仕様のためにカラムのレイアウトが滅茶苦茶になるか"
"もしれませんが、嘘の値が代わりに書き出されるよりはましです。(本当に切り詰めを"
"行いたいのなら、全てのカラムに ``x.ljust(n)[:n]`` のようにスライス表記を加え"
"ることもできます。)"

#: ../../tutorial/inputoutput.rst:116
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:126
msgid "Basic usage of the :meth:`str.format` method looks like this::"
msgstr ":meth:`str.format` メソッドの基本的な使い方は次のようなものです::"

#: ../../tutorial/inputoutput.rst:131
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 refers to the position of the object passed into the :meth:`str."
"format` method. ::"
msgstr ""
"括弧とその中の文字(これをフォーマットフィールドと呼びます)は、 :meth:`str."
"format` メソッドに渡されたオブジェクトに置換されます。括弧の中の数字は :meth:"
"`str.format` メソッドに渡されたオブジェクトの位置を表します。 ::"

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

#: ../../tutorial/inputoutput.rst:154
msgid ""
"``'!s'`` (apply :func:`str`) and ``'!r'`` (apply :func:`repr`) can be used "
"to convert the value before it is formatted. ::"
msgstr ""
":func:`str` を適応する ``'!s'`` や :func:`repr` を適応する ``'!r'`` を使っ"
"て、値をフォーマットする前に変換することができます。 ::"

#: ../../tutorial/inputoutput.rst:163
msgid ""
"An optional ``':'`` and format specifier can follow the field name. This "
"allows greater control over how the value is formatted.  The following "
"example rounds Pi to three places after the decimal."
msgstr ""
"オプションの ``':'`` とフォーマット指定子を、フィールド名の後ろに付けることが"
"できます。フォーマット指定子によって値がどうフォーマットされるかを制御するこ"
"とができます。次の例では、円周率πを、小数点以下3桁でまるめてフォーマットして"
"います。"

#: ../../tutorial/inputoutput.rst:171
msgid ""
"Passing an integer after the ``':'`` will cause that field to be a minimum "
"number of characters wide.  This is useful for making tables pretty. ::"
msgstr ""
"``':'`` の後ろに整数をつけると、そのフィールドの最低の文字幅を指定できます。"
"この機能は綺麗なテーブルを作るのに便利です。 ::"

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

#: ../../tutorial/inputoutput.rst:199
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:202
msgid ""
"For a complete overview of string formatting with :meth:`str.format`, see :"
"ref:`formatstrings`."
msgstr ""
":meth:`str.format` による文字列フォーマットの完全な解説は、 :ref:"
"`formatstrings` を参照してください。"

#: ../../tutorial/inputoutput.rst:207
msgid "Old string formatting"
msgstr "古い文字列フォーマット方法"

#: ../../tutorial/inputoutput.rst:209
msgid ""
"The ``%`` operator can also be used for string formatting. It interprets the "
"left argument much like a :c:func:`sprintf`\\ -style format string to be "
"applied to the right argument, and returns the string resulting from this "
"formatting operation. For example::"
msgstr ""
"``%`` 演算しを使って文字列フォーマットをする方法もあります。これは、演算子の"
"左側の :c:func:`sprintf` スタイルのフォーマット文字列に、演算子の右側の値を適"
"用し、その結果の文字列を返します。例えば::"

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

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

#: ../../tutorial/inputoutput.rst:230
msgid ""
":func:`open` returns a 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:239
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:248
msgid ""
"On Windows, ``'b'`` appended to the mode opens the file in binary mode, so "
"there are also modes like ``'rb'``, ``'wb'``, and ``'r+b'``.  Python on "
"Windows makes a distinction between text and binary files; the end-of-line "
"characters in text files are automatically altered slightly when data is "
"read or written.  This behind-the-scenes modification to file data is fine "
"for ASCII text files, but it'll 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.  On Unix, it doesn't hurt to append a "
"``'b'`` to the mode, so you can use it platform-independently for all binary "
"files."
msgstr ""
"Windows では、 *mode* に ``'b'`` を追加するとファイルをバイナリモードで開きま"
"す。したがって、 ``'rb'``,  ``'wb'``, ``'r+b'`` といったモードがあります。 "
"Windows 上で動くPython はテキストファイルとバイナリファイルを区別しています。"
"テキストファイルでは、読み書きの際に行末文字が自動的に少し変更されます。この"
"舞台裏でのファイルデータ変更は、ASCII でできたテキストファイルでは差し支えな"
"いものですが、 :file:`JPEG` や :file:`EXE` ファイルのようなバイナリデータは破"
"損してしまうことになるでしょう。こうしたファイルを読み書きする際にはバイナリ"
"モードを使うよう十分注意してください。 Unix では、 ``'b'`` を追加しても何も影"
"響がないので、バイナリフォーマットを扱うためのプラットフォーム非依存な方法と"
"して利用できます。"

#: ../../tutorial/inputoutput.rst:262
msgid "Methods of File Objects"
msgstr "ファイルオブジェクトのメソッド"

#: ../../tutorial/inputoutput.rst:264
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:267
msgid ""
"To read a file's contents, call ``f.read(size)``, which reads some quantity "
"of data and returns it as a string.  *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* bytes are read and "
"returned.  If the end of the file has been reached, ``f.read()`` will return "
"an empty string (``\"\"``). ::"
msgstr ""
"ファイルの内容を読み出すには、 ``f.read(size)`` を呼び出します。このメソッド"
"はある量のデータを読み出して、文字列として返します。 *size* は省略可能な数値"
"引数です。 *size* が省略されたり負の数であった場合、ファイルの内容全てを読み"
"出して返します。ただし、ファイルがマシンのメモリの二倍の大きさもある場合には"
"どうなるかわかりません。 *size* が負でない数ならば、最大で *size* バイトを読"
"み出して返します。ファイルの終端にすでに達していた場合、 ``f.read()`` は空の"
"文字列 (``\"\"``) を返します。"

#: ../../tutorial/inputoutput.rst:280
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:294
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:303
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:306
msgid ""
"``f.write(string)`` writes the contents of *string* to the file, returning "
"``None``.   ::"
msgstr ""
"``f.write(string)`` は、 *string* の内容をファイルに書き込み、 ``None`` を返"
"します。 ::"

#: ../../tutorial/inputoutput.rst:311
msgid ""
"To write something other than a string, it needs to be converted to a string "
"first::"
msgstr ""
"文字列以外のものを出力したい場合、まず文字列に変換してやる必要があります::"

#: ../../tutorial/inputoutput.rst:318
msgid ""
"``f.tell()`` returns an integer giving the file object's current position in "
"the file, measured in bytes from the beginning of the file.  To change the "
"file object's position, use ``f.seek(offset, from_what)``.  The position is "
"computed from adding *offset* to a reference point; the reference point is "
"selected by the *from_what* argument.  A *from_what* 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.  *from_what* can be omitted and "
"defaults to 0, using the beginning of the file as the reference point. ::"
msgstr ""
"``f.tell()`` は、ファイルオブジェクトが指しているあるファイル中の位置を示す整"
"数を、ファイルの先頭からのバイト数で図った値で返します。ファイルオブジェクト"
"の位置を変更するには、 ``f.seek(offset,  from_what)`` を使います。ファイル位"
"置は基準点 (reference point) にオフセット値 *offset* を足して計算されます。参"
"照点は *from_what* 引数で選びます。 *from_what* の値が 0 ならばファイルの先頭"
"から測り、 1 ならば現在のファイル位置を使い、2 ならばファイルの終端を参照点と"
"して使います。 *from_what* は省略することができ、デフォルトの値は 0 、すなわ"
"ち参照点としてファイルの先頭を使います::"

#: ../../tutorial/inputoutput.rst:336
msgid ""
"When you're done with a file, call ``f.close()`` to close it and free up any "
"system resources taken up by the open file.  After calling ``f.close()``, "
"attempts to use the file object will automatically fail. ::"
msgstr ""
"ファイルが用済みになったら、 ``f.close()`` を呼び出してファイルを閉じ、ファイ"
"ルを開くために取られていたシステム資源を解放します。 ``f.close()`` を呼び出し"
"た後、そのファイルオブジェクトを使おうとすると自動的に失敗します::"

#: ../../tutorial/inputoutput.rst:346
msgid ""
"It is good practice to use the :keyword:`with` keyword when dealing with "
"file objects.  This has the advantage that the file is properly closed after "
"its suite finishes, even if an exception is raised on the way.  It is also "
"much shorter than writing equivalent :keyword:`try`\\ -\\ :keyword:`finally` "
"blocks::"
msgstr ""
"ファイルオブジェクトを扱うときに :keyword:`with` キーワードを使うのは良い習慣"
"です。 :keyword:`with` を使うと、処理中に例外が発生しても必ず最後にファイルを"
"閉じることができます。同じことを :keyword:`try`-:keyword:`finally` を使って書"
"くよりずっと簡潔に書けます::"

#: ../../tutorial/inputoutput.rst:356
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:364
msgid "Saving structured data with :mod:`json`"
msgstr ":mod:`json` による構造化されたデータの保存"

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

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

#: ../../tutorial/inputoutput.rst:408
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:414
msgid ":mod:`pickle` - the pickle module"
msgstr ":mod:`pickle` - pickle モジュール"

#: ../../tutorial/inputoutput.rst:416
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 データをデシリアライズすると、攻撃者により任意の"
"コードが実行されてしまいます。"