"io" --- ストリームを扱うコアツール
***********************************

**ソースコード:** Lib/io.py

======================================================================


概要
====

"io" モジュールは様々な種類の I/O を扱う Python の主要な機能を提供して
います。 I/O には主に3つの種類があります; *テキスト I/O*, *バイナリ
I/O*, *raw I/O* です。これらは汎用的なカテゴリで、各カテゴリには様々な
ストレージが利用されます。これらのいずれかのカテゴリに属する具象オブジ
ェクトは全て *file object* と呼ばれます。他によく使われる用語として *
ストリーム* と *file-like オブジェクト* があります。

それぞれの具象ストリームオブジェクトは、カテゴリに応じた機能を持ちます
。ストリームは読み込み専用、書き込み専用、読み書き可能のいずかになりま
す。任意のランダムアクセス（前方、後方の任意の場所にシークする）が可能
かもしれませんし、シーケンシャルアクセスしかできないかもしれません（例
えばソケットやパイプなど）。

全てのストリームは、与えられたデータの型に対して厳密です。例えば、バイ
ナリストリームの "write()" メソッドに対して "str" オブジェクトを渡すと
"TypeError" 例外を発生させます。テキストストリームの "write()" メソッ
ドに "bytes" オブジェクトを渡しても同じです。

バージョン 3.3 で変更: 以前 "IOError" を送出していた操作が "OSError"
を送出するようになりました。 "IOError" は今は "OSError" の別名です。


テキスト I/O
------------

テキスト I/O は、 "str" オブジェクトを受け取り、生成します。すなわち、
背後にあるストレージがバイト列 (例えばファイルなど) を格納するときは常
に、透過的にデータのエンコード・デコードを行ない、オプションでプラット
フォーム依存の改行文字変換を行います。

テキストストリームを作る一番簡単な方法は、オプションでエンコーディング
を指定して、 "open()" を利用することです:

   f = open("myfile.txt", "r", encoding="utf-8")

"StringIO" オブジェクトはインメモリーのテキストストリームです:

   f = io.StringIO("some initial text data")

テキストストリームの API は "TextIOBase" のドキュメントで詳しく解説し
ます。


バイナリ I/O
------------

バイナリー I/O (*buffered I/O* とも呼ばれます) は *bytes-like オブジェ
クト* を受け取り "bytes" オブジェクトを生成します。エンコード、デコー
ド、改行文字変換は一切行いません。このカテゴリのストリームは全ての非テ
キストデータや、テキストデータの扱いを手動で管理したい場合に利用するこ
とができます。

バイナリーストリームを生成する一番簡単な方法は、 "open()" の mode 文字
列に "'b'" を指定することです:

   f = open("myfile.jpg", "rb")

"BytesIO" はインメモリーのバイナリストリームです:

   f = io.BytesIO(b"some initial binary data: \x00\x01")

バイナリーストリーム API は "BufferedIOBase" のドキュメントで詳しく解
説します。

他のライブラリモジュールが、別のテキスト・バイナリーストリームを生成す
る方法を提供しています。例えば "socket.socket.makefile()" などです。


Raw I/O
-------

Raw I/O (*unbuffered I/O* とも呼ばれます) は、バイナリーストリームやテ
キストストリームの低水準の部品としてよく利用されます。ユーザーコードで
直接 raw ストリームを扱うべき場面は滅多にありません。とはいえ、バッフ
ァリングを無効にしてファイルをバイナリーモードで開くことで raw ストリ
ームを作ることができます:

   f = open("myfile.jpg", "rb", buffering=0)

raw ストリーム API は "RawIOBase" のドキュメントで詳しく解説します。


高水準のモジュールインターフェイス
==================================

io.DEFAULT_BUFFER_SIZE

   このモジュールの buffered I/O クラスで利用されるデフォルトのバッフ
   ァーサイズを表す整数です。可能であれば、"open()" は file の blksize
   ("os.stat()" で取得される) を利用します。

io.open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

   組み込みの "open()" 関数のエイリアスです。

   引数 "path", "mode", "flags" を指定して 監査イベント "open" を送出
   します。

io.open_code(path)

   "rb" モードでファイルを開きます。この機能はファイルの中身を実行可能
   なコードとして扱いたい場合にのみ使用します。

   >>``<<path``は:class:*str* 型の絶対パスです。

   この関数の振る舞いは、この関数より以前に "PyFile_SetOpenCodeHook()"
   を呼び出すことにより上書きされているかもしれません。しかし、 "path"
   が "str" で絶対パスをあらわすことを前提として、 "open_code(path)"
   は常に "open(path, 'rb')" と同じように振る舞うべきです。振る舞いの
   上書きは、ファイルに対する追加の検証や処理を目的とするべきです。

   バージョン 3.8 で追加.

exception io.BlockingIOError

   互換性のための、組み込みの "BlockingIOError" 例外のエイリアスです。

exception io.UnsupportedOperation

   "OSError" と "ValueError" を継承した例外です。ストリームがサポート
   していない操作を行おうとした時に送出されます。

参考:

  "sys"
     標準 IO ストリームを持っています: "sys.stdin", "sys.stdout",
     "sys.stderr"。


クラス階層
==========

I/O ストリームの実装はクラス階層に分けて整理されています。まずストリー
ムのカテゴリを分類するための *抽象基底クラス* (ABC) があり、続いて標準
のストリーム実装を行う具象クラス群があります。

   注釈:

     抽象基底クラス群は、具象ストリームクラスの実装を助けるために、い
     くつかのデフォルトの実装を提供しています。例えば、
     "BufferedIOBase" は "readinto()" と "readline()" の最適化されてい
     ない実装を提供しています。

I/O 階層の最上位には抽象基底クラスの "IOBase" があります。 "IOBase" で
はストリームに対して基本的なインタフェースを定義しています。 しかしな
がら、ストリームに対する読み込みと書き込みが分離されていないことに注意
してください。 実装においては与えられた操作をサポートしない場合は
"UnsupportedOperation" を送出することが許されています。

"RawIOBase" ABC は "IOBase" を拡張します。このクラスはストリームからの
bytes の読み書きを扱います。 "FileIO" は、 "RawIOBase" を継承してマシ
ンのファイルシステム中のファイルへのインタフェースを提供します。

"BufferedIOBase" ABC は生のバイトストリーム ("RawIOBase") 上にバッファ
処理を追加します。そのサブクラスの "BufferedWriter", "BufferedReader",
"BufferedRWPair" では、 それぞれ読み込み専用、書き込み専用、読み書き可
能なストリームをバッファします。 "BufferedRandom" ではランダムアクセス
ストリームに対してバッファされたインタフェースを提供します。 "BytesIO"
も "BufferedIOBase" のサブクラスで、インメモリのバイト列へのシンプルな
ストリームです。

もう一つの "IOBase" のサブクラスである "TextIOBase" ABC は、 テキスト
を表すバイトストリームを扱い、文字列とのエンコードやデコードといった処
理を行います。 "TextIOWrapper" はその拡張で、バッファ付き raw ストリー
ム ("BufferedIOBase") へのバッファされたテキストインタフェースです。
最後に "StringIO" はテキストに対するインメモリストリームです。

引数名は規約に含まれていません。 そして "open()" の引数だけがキーワー
ド引数として用いられることが意図されています。

次のテーブルは "io" モジュールが提供する ABC の概要です:

+---------------------------+--------------------+--------------------------+----------------------------------------------------+
| ABC                       | 継承元             | スタブメソッド           | Mixin するメソッドとプロパティ                     |
|===========================|====================|==========================|====================================================|
| "IOBase"                  |                    | "fileno", "seek",        | "close", "closed", "__enter__", "__exit__",        |
|                           |                    | "truncate"               | "flush", "isatty", "__iter__", "__next__",         |
|                           |                    |                          | "readable", "readline", "readlines", "seekable",   |
|                           |                    |                          | "tell", "writable", "writelines"                   |
+---------------------------+--------------------+--------------------------+----------------------------------------------------+
| "RawIOBase"               | "IOBase"           | "readinto", "write"      | "IOBase" から継承したメソッド、 "read", "readall"  |
+---------------------------+--------------------+--------------------------+----------------------------------------------------+
| "BufferedIOBase"          | "IOBase"           | "detach", "read",        | "IOBase" から継承したメソッド、 "readinto",        |
|                           |                    | "read1", "write"         | "readinto1"                                        |
+---------------------------+--------------------+--------------------------+----------------------------------------------------+
| "TextIOBase"              | "IOBase"           | "detach", "read",        | "IOBase" から継承したメソッド、 "encoding",        |
|                           |                    | "readline", "write"      | "errors", "newlines"                               |
+---------------------------+--------------------+--------------------------+----------------------------------------------------+


I/O 基底クラス
--------------

class io.IOBase

   すべての I/O クラスの抽象基底クラスです。バイトストリームへの操作を
   行います。パブリックなコンストラクタはありません。

   継承先のクラスが選択的にオーバライドできるように、このクラスは多く
   のメソッドに空の抽象実装をしています。デフォルトの実装では、読み込
   み、書き込み、シークができないファイルを表現します。

   "IOBase" では "read()", "write()" が宣言されていませんが、これはシ
   グナチャが変化するためで、実装やクライアントはこれらのメソッドをイ
   ンタフェースの一部として考えるべきです。 また、実装はサポートしてい
   ない操作を呼び出されたときは "ValueError" (または
   "UnsupportedOperation") を発生させるかもしれません。

   ファイルへのバイナリデータの読み書きに用いられる基本型は "bytes" で
   す。 他の *bytes-like オブジェクト* もメソッドの引数として受け付け
   られます。 テキスト I/O クラスは "str" データを扱います。

   閉じられたストリームに対するメソッド呼び出しは (問い合わせであって
   も) 未定義です。この場合、実装は "ValueError" を送出することがあり
   ます。

   "IOBase" (とそのサブクラス) はイテレータプロトコルをサポートします
   。 "IOBase" オブジェクトをイテレートすると、ストリーム内の行が
   yield されます。ストリーム内の行の定義は、そのストリームが (バイト
   列を yield する) バイナリストリームか (文字列を yield する) テキス
   トストリームかによって、 少し異なります。下の "readline()" を参照し
   てください。

   "IOBase" はコンテキストマネージャでもあります。そのため "with" 構文
   をサポートします。 次の例では、 "with" 構文が終わった後で---たとえ
   例外が発生した場合でも、 *file* は閉じられます。

      with open('spam.txt', 'w') as file:
          file.write('Spam and eggs!')

   "IOBase" は以下のデータ属性とメソッドを提供します:

   close()

      このストリームをフラッシュして閉じます。このメソッドはファイルが
      既に閉じられていた場合は特に何の効果もありません。いったんファイ
      ルが閉じられると、すべてのファイルに対する操作 (例えば読み込みや
      書き込み) で "ValueError" が発生します。

      利便性のためにこのメソッドを複数回呼ぶことは許されています。しか
      し、効果があるのは最初の1回だけです。

   closed

      ストリームが閉じられていた場合 "True" になります。

   fileno()

      ストリームが保持しているファイル記述子 (整数値) が存在する場合は
      それを返します。もし IO オブジェクトがファイル記述子を使っていな
      い場合は "OSError" が発生します。

   flush()

      適用可能であればストリームの書き込みバッファをフラッシュします。
      読み出し専用や非ブロッキングストリームでは何もしません。

   isatty()

      ストリームが対話的であれば (つまりターミナルや tty デバイスにつ
      ながっている場合) "True" を返します。

   readable()

      ストリームが読み込める場合 "True" を返します。 "False" の場合は
      "read()" は "OSError" を発生させます。

   readline(size=-1)

      ストリームから 1 行読み込んで返します。もし *size* が指定された
      場合、最大で *size* バイトが読み込まれます。

      バイナリファイルでは行末文字は常に "b'\n'" となります。テキスト
      ファイルでは、認識される行末文字を選択するために "open()" に対す
      る *newline* 引数が使われます。

   readlines(hint=-1)

      ストリームから行のリストを読み込んで返します。 *hint* を指定する
      ことで、読み込む行数を制御できます。もし読み込んだすべての行のサ
      イズ (バイト数、もしくは文字数) が *hint* の値を超えた場合、読み
      込みをそこで終了します。

      ただし、 "file.readlines()" を呼びださなくても "for line in
      file: ..." のように file オブジェクトを直接イテレートすることが
      できます。

   seek(offset, whence=SEEK_SET)

      ストリーム位置を指定された *offset* バイトに変更します。*offset*
      は *whence* で指定された位置からの相対位置として解釈されます。
      *whence* のデフォルト値は "SEEK_SET" です。 *whence* に指定でき
      る値は:

      * "SEEK_SET" または "0" -- ストリームの先頭 (デフォルト)。
        *offset* は 0 もしくは正の値でなければなりません。

      * "SEEK_CUR" または "1" -- 現在のストリーム位置。 *offset* は負
        の値も可能です。

      * "SEEK_END" または "2" -- ストリームの末尾。 *offset* は通常負
        の値です。

      新しい絶対位置を返します。

      バージョン 3.1 で追加: "SEEK_*" 定数.

      バージョン 3.3 で追加: 一部のオペレーティングシステムは
      "os.SEEK_HOLE" や "os.SEEK_DATA" など、追加の値をサポートするこ
      とがあります。ファイルに対して利用できる値は、そのファイルがテキ
      ストモードで開かれたかバイナリモードで開かれたかに依存します。

   seekable()

      ストリームがランダムアクセスをサポートしている場合、 "True" を返
      します。 "False" の場合、 "seek()"、 "tell()"、 "truncate()" を
      使用すると "OSError" を発生させます。

   tell()

      現在のストリーム位置を返します。

   truncate(size=None)

      ストリームのサイズを、指定された *size* バイト (または *size* が
      指定されていない場合、現在位置) に変更します。現在のストリーム位
      置は変更されません。このサイズ変更により、現在のファイルサイズを
      拡大または縮小させることができます。拡大の場合には、新しいファイ
      ル領域の内容はプラットホームによって異なります (ほとんどのシステ
      ムでは、追加のバイトが 0 で埋められます)。新しいファイルサイズが
      返されます。

      バージョン 3.5 で変更: Windows で、拡大時に追加領域を 0 で埋める
      ようになりました。

   writable()

      ストリームが書き込みをサポートしている場合 "True" を返します。
      "False" の場合は "write()"、 "truncate()" は "OSError" を返しま
      す。

   writelines(lines)

      ストリームに行のリストを書き込みます。行区切り文字は追加されない
      ので、書き込む各行の行末に行区切り文字を含ませるのが一般的です。

   __del__()

      オブジェクトの破壊の用意をします。このメソッドはインスタンスの
      "close()" メソッドを呼びます。 "IOBase" はこのメソッドのデフォル
      トの実装を提供します

class io.RawIOBase

   生のバイナリ I/O への基底クラスです。 "IOBase" を継承しています。パ
   ブリックコンストラクタはありません。

   raw バイナリ I/O は典型的に、下にある OS デバイスや API への低水準
   のアクセスを提供し、高水準の基本要素へとカプセル化しようとはしませ
   ん (これはこのページで後述する Buffered I/O や Text I/O に任せます)
   。

   "IOBase" の属性やメソッドに加えて、 "RawIOBase" は次のメソッドを提
   供します:

   read(size=-1)

      オブジェクトを *size* バイトまで読み込み、それを返します。 簡単
      のため、 *size* が指定されていないか -1 の場合は、 EOF までの全
      てのバイトを返します。 そうでない場合は、システムコール呼び出し
      が一度だけ行われます。 オペレーティングシステムコールから返って
      きたものが *size* バイトより少なければ、 *size* バイトより少ない
      返り値になることがあります。

      *size* が 0 でないのに 0 バイトが返った場合、それはファイルの終
      端を表します。オブジェクトがノンブロッキングモードで、1 バイトも
      読み込めなければ、"None" が返されます。

      デフォルトの実装は "readall()" と "readinto()" に従います。

   readall()

      EOF までストリームからすべてのバイトを読み込みます。必要な場合は
      ストリームに対して複数の呼び出しをします。

   readinto(b)

      あらかじめ確保された書き込み可能な *bytes 類オブジェクト* *b* に
      バイト列を読み込み、読み込んだバイト数を返します。 例えば、 *b*
      は "bytearray" です。 オブジェクトがノンブロッキングモードで、 1
      バイトも読み込めなければ、 "None" が返されます。

   write(b)

      与えられた *bytes-like オブジェクト* *b* を生ストリームに書き込
      み、書き込んだバイト数を返します。これは、根底の生ストリームの性
      質や、特にノンブロッキングである場合に、 *b* のバイト数より小さ
      くなることがあります。生ストリームがブロックされないように設定さ
      れていて、かつ1バイトも即座に書き込むことができなければ、 "None"
      が返されます。このメソッドから返った後で呼び出し元は *b* を解放
      したり変更したりするかもしれないので、実装はメソッド呼び出しの間
      だけ *b* にアクセスすべきです。

class io.BufferedIOBase

   何らかのバッファリングをサポートするバイナリストリームの基底クラス
   です。 "IOBase" を継承します。パブリックなコンストラクタはありませ
   ん。

   "RawIOBase" との主な違いは、メソッド "read()"、 "readinto()" および
   "write()" は 、ことによると複数回のシステムコールを行って、(それぞ
   れ) 要求されただけの入力を読み込もうとしたり与えられた出力の全てを
   消費しようとしたりする点です。

   加えて、元になる生ストリームが非ブロッキングモードでかつ準備ができ
   ていない場合に、これらのメソッドは、 "BlockingIOError" を送出するか
   もしれません。対応する "RawIOBase" バージョンと違って、 "None" を返
   すことはありません。

   さらに、 "read()" メソッドは、 "readinto()" に従うデフォルト実装を
   持ちません。

   通常の "BufferedIOBase" 実装は "RawIOBase" 実装を継承せずに、
   "BufferedWriter" と "BufferedReader" がするようにこれをラップすべき
   です。

   "BufferedIOBase" は "IOBase" からのメソッドと属性に加えて、以下のメ
   ソッドを提供もしくはオーバーライドします:

   raw

      "BufferedIOBase" が扱う根底の生ストリーム ("RawIOBase" インスタ
      ンス) を返します。これは "BufferedIOBase" API には含まれず、よっ
      て実装に含まれないことがあります。

   detach()

      根底の生ストリームをバッファから分離して返します。

      生ストリームが取り外された後、バッファは使用不能状態になります。

      バッファには、 "BytesIO" など、このメソッドで返される単体のスト
      リームという概念を持たないものがあります。これらは
      "UnsupportedOperation" を送出します。

      バージョン 3.1 で追加.

   read(size=-1)

      最大で *size* バイト読み込んで返します。 引数が省略されるか、
      "None" か、または負の値であった場合、 データは EOF に到達するま
      で読み込まれます。 ストリームが既に EOF に到達していた場合は空の
      "bytes" オブジェクトが返されます。

      引数が正で、元になる生ストリームが対話的でなければ、必要なバイト
      数を満たすように複数回の生 read が発行されるかもしれません (先に
      EOF に到達しない限りは)。対話的な場合は、最大で一回の raw read
      しか発行されず、短い結果でも EOF に達したことを意味しません。

      元になる生ストリームがノンブロッキングモードで、呼び出された時点
      でデータを持っていなければ、 "BlockingIOError" が送出されます。

   read1([size])

      根底の raw ストリームの "read()" (または "readinto()" ) メソッド
      を高々 1 回呼び出し、最大で *size* バイト読み込み、返します。こ
      れは、 "BufferedIOBase" オブジェクトの上に独自のバッファリングを
      実装するときに便利です。

      *size* に >>``<<-1``（デフォルト値)を指定すると任意バイト長を返
      します（EOFに到達していなければ返されるバイト数は 0 より大きくな
      ります）

   readinto(b)

      あらかじめ確保された書き込み可能な *bytes 類オブジェクト* *b* に
      バイト列を読み込み、読み込んだバイト数を返します。 例えば、 *b*
      は "bytearray" です。

      "read()" と同様に、下層の raw ストリームが対話的でない限り、複数
      の読み込みは下層の raw ストリームに与えられるかもしれません。

      元になる生ストリームがノンブロッキングモードで、呼び出された時点
      でデータを持っていなければ、 "BlockingIOError" が送出されます。

   readinto1(b)

      根底の raw ストリームの "read()" (または "readinto()") メソッド
      を高々 1 回呼び出し、あらかじめ確保された書き込み可能な *bytes-
      like オブジェクト* *b* にバイト列を読み込みます。読み込んだバイ
      ト数を返します。

      元になる生ストリームがノンブロッキングモードで、呼び出された時点
      でデータを持っていなければ、 "BlockingIOError" が送出されます。

      バージョン 3.5 で追加.

   write(b)

      与えられた *bytes-like オブジェクト* *b* を書き込み、書き込んだ
      バイト数を返します (これは常に *b* のバイト数と等しくなります。
      なぜなら、もし書き込みに失敗した場合は "OSError" が発生するから
      です)。実際の実装に依存して、これらのバイト列は根底のストリーム
      に即座に書き込まれることもあれば、パフォーマンスやレイテンシの関
      係でバッファに保持されることもあります。

      ノンブロッキングモードであるとき、バッファが満杯で根底の生ストリ
      ームが書き込み時点でさらなるデータを受け付けられない場合
      "BlockingIOError" が送出されます。

      このメソッドが戻った後で、呼び出し元は *b* を解放、または変更す
      るかもしれないので、実装はメソッド呼び出しの間だけ *b* にアクセ
      スすべきです。


生ファイルI/O
-------------

class io.FileIO(name, mode='r', closefd=True, opener=None)

   "FileIO" はバイトデータを含む OS レベルのファイルを表します。
   "RawIOBase" インタフェースを (したがって "IOBase" インタフェースも)
   実装しています。

   *name* は、次の 2 つのいずれかです。

   * 開くファイルへのパスを表す文字列または "bytes" オブジェクト。 こ
     の場合、closefd は "True" (デフォルト) でなければなりません。
     "True" でない場合、エラーが送出されます。

   * 結果の "FileIO" オブジェクトがアクセスを与える、既存の OS レベル
     ファイル記述子の数を表す整数。FileIO オブジェクトが閉じられると、
     *closefd* が "False" に設定されていない場合、この fd も閉じられま
     す。

   *mode* は 読み込み（デフォルト）、書き込み、排他的作成、追記に対し
   "'r'" 、 "'w'" 、 "'x'" 、 "'a'" です。ファイルは書き込みや追記で開
   かれたときに存在しない場合作成されます。書き込みのときにファイルの
   内容は破棄されます。作成時に既に存在する場合は "FileExistsError" が
   送出されます。作成のためにファイルを開くのは暗黙的に書き込みなので
   、このモードは "'w'" と同じように振る舞います。読み込みと書き込みを
   同時に許可するにはモードに "'+'" を加えてください。

   このクラスの "read()" (正の引数で呼び出されたとき), "readinto()" お
   よび "write()" メソッドは、単にシステムコールを一度呼び出します。

   呼び出し可能オブジェクトを *opener* として与えることで、カスタムの
   オープナーが使えます。そしてファイルオブジェクトの基底のファイルデ
   ィスクリプタは、*opener* を (*name*, *flags*) で呼び出して得られま
   す。*opener* は開いたファイルディスクリプタを返さなければなりません
   。 ("os.open" を *opener* として渡すと、"None" を渡したのと同様の機
   能になります。)

   新たに作成されたファイルは 継承不可  です。

   *opener* 引数を使う例については "open()" 組み込み関数を参照してくだ
   さい。

   バージョン 3.3 で変更: *opener* 引数が追加されました。"'x'" モード
   が追加されました。

   バージョン 3.4 で変更: ファイルが継承不可になりました。

   "IOBase" と "RawIOBase" の属性やメソッドに加え、"FileIO" は以下のデ
   ータ属性を提供します:

   mode

      コンストラクタに渡されたモードです。

   name

      ファイル名。コンストラクタに名前が渡されなかったときはファイル記
      述子になります。


バッファ付きストリーム
----------------------

バッファ付き I/O ストリームは、I/O デバイスに生 I/O より高レベルなイン
タフェースを提供します。

class io.BytesIO([initial_bytes])

   インメモリの bytes バッファを利用したストリームの実装です。
   "BufferedIOBase" を継承します。バッファは "close()" メソッドが呼び
   出された際に破棄されます。

   省略可能な引数 *initial_bytes* は、初期データを含んだ *bytes-like
   オブジェクト* です。

   "BytesIO" は "BufferedIOBase" または "IOBase" からのメソッドに加え
   て、以下のメソッドを提供もしくはオーバーライドします:

   getbuffer()

      バッファの内容をコピーすることなく、その内容の上に、読み込み及び
      書き込みが可能なビューを返します。また、このビューを変更すると、
      バッファの内容は透過的に更新されます:

         >>> b = io.BytesIO(b"abcdef")
         >>> view = b.getbuffer()
         >>> view[2:4] = b"56"
         >>> b.getvalue()
         b'ab56ef'

      注釈:

        ビューが存在する限り、"BytesIO" オブジェクトはリサイズやクロー
        ズされません。

      バージョン 3.2 で追加.

   getvalue()

      バッファの全内容を含む "bytes" を返します。

   read1([size])

      "BytesIO" においては、このメソッドは "read()" と同じです。

      バージョン 3.7 で変更: *size* 引数が任意になりました。

   readinto1(b)

      "BytesIO" においては、このメソッドは "readinto()" と同じです。

      バージョン 3.5 で追加.

class io.BufferedReader(raw, buffer_size=DEFAULT_BUFFER_SIZE)

   読み込み可能でシーケンシャルな "RawIOBase" オブジェクトへの高水準の
   アクセスを提供するバッファです。 "BufferedIOBase" を継承します。こ
   のオブジェクトからデータを読み込むとき、より大きい量のデータが根底
   の raw ストリームから要求され、内部バッファに保存される場合がありま
   す。バッファされたデータは、その次の読み込み時に直接返されます。

   このコンストラクタは与えられた *raw* ストリームと *buffer_size* に
   対し "BufferedReader" を生成します。 *buffer_size* が省略された場合
   、代わりに "DEFAULT_BUFFER_SIZE" が使われます。

   "BufferedReader" は "BufferedIOBase" または "IOBase" からのメソッド
   に加えて、以下のメソッドを提供もしくはオーバーライドします:

   peek([size])

      位置を進めずにストリームからバイト列を返します。これを果たすため
      に生ストリームに対して行われる read は高々一度だけです。返される
      バイト数は、要求より少ないかもしれませんし、多いかもしれません。

   read([size])

      *size* バイトを読み込んで返します。*size* が与えられないか負の値
      ならば、EOF まで、または非ブロッキングモード中で read 呼び出しが
      ブロックされるまでを返します。

   read1([size])

      raw ストリームに対しただ一度の呼び出しで最大 *size* バイトを読み
      込んで返します。少なくとも 1 バイトがバッファされていれば、バッ
      ファされているバイト列だけが返されます。それ以外の場合は raw ス
      トリームの読み込みが一回呼び出されます。

      バージョン 3.7 で変更: *size* 引数が任意になりました。

class io.BufferedWriter(raw, buffer_size=DEFAULT_BUFFER_SIZE)

   書き込み可能でシーケンシャルな "RawIOBase" オブジェクトへの、高レベ
   ルなアクセスを提供するバッファです。 "BufferedIOBase" を継承します
   。このオブジェクトに書き込むとき、データは通常内部バッファに保持さ
   れます。このバッファは、以下のような種々の状況で根底の "RawIOBase"
   オブジェクトに書き込まれます。

   * 保留中の全データに対してバッファが足りなくなったとき;

   * "flush()" が呼び出されたとき;

   * "seek()" が ("BufferedRandom" オブジェクトに対して) 呼び出された
     とき;

   * "BufferedWriter" オブジェクトが閉じられたり破棄されたりしたとき。

   このコンストラクタは与えられた書き込み可能な *raw* ストリームに対し
   "BufferedWriter" を生成します。 *buffer_size* が省略された場合、
   "DEFAULT_BUFFER_SIZE" がデフォルトになります。

   "BufferedWriter" は "BufferedIOBase" または "IOBase" からのメソッド
   に加えて、以下のメソッドを提供もしくはオーバーライドします:

   flush()

      バッファに保持されたバイト列を生ストリームに強制的に流し込みます
      。生ストリームがブロックした場合 "BlockingIOError" が送出されま
      す。

   write(b)

      *bytes-like オブジェクト* *b* を書き込み、書き込んだバイト数を返
      します。ノンブロッキング時、バッファが書き込まれるべきなのに生ス
      トリームがブロックした場合 "BlockingIOError" が送出されます。

class io.BufferedRandom(raw, buffer_size=DEFAULT_BUFFER_SIZE)

   A buffered interface to random access streams.  It inherits
   "BufferedReader" and "BufferedWriter".

   このコンストラクタは第一引数として与えられるシーク可能な生ストリー
   ムに対し、リーダーおよびライターを作成します。 *buffer_size* が省略
   された場合、 "DEFAULT_BUFFER_SIZE" がデフォルトになります。

   "BufferedRandom" は "BufferedReader" と "BufferedWriter" ができるこ
   とは何でもできる能力があります。さらに "seek()" と "tell()" が実装
   されていることが保証されています。

class io.BufferedRWPair(reader, writer, buffer_size=DEFAULT_BUFFER_SIZE)

   2つの単方向 "RawIOBase" オブジェクト -- 一つは読み込み可能、他方が
   書き込み可能 -- を組み合わせてバッファ付きの双方向 I/O オブジェクト
   にしたものです。 "BufferedIOBase" を継承しています。

   *reader* と *writer* はそれぞれ読み込み可能、書き込み可能な
   "RawIOBase" オブジェクトです。 *buffer_size* が省略された場合
   "DEFAULT_BUFFER_SIZE" がデフォルトになります。

   "BufferedRWPair" は、 "UnsupportedOperation" を送出する "detach()"
   を除く、 "BufferedIOBase" の全てのメソッドを実装します。

   警告:

     "BufferedRWPair" は下層の生ストリームのアクセスを同期しようとはし
     ません。同じオブジェクトをリーダとライタとして渡してはいけません
     。その場合は代わりに "BufferedRandom" を使用してください。


テキスト I/O
------------

class io.TextIOBase

   テキストストリームの基底クラスです。 このクラスはストリーム I/O へ
   の、文字と行に基づいたインタフェースを提供します。 "IOBase" を継承
   します。 パブリックなコンストラクタはありません。

   "IOBase" から継承した属性とメソッドに加えて、 "TextIOBase" は以下の
   データ属性とメソッドを提供しています:

   encoding

      エンコーディング名で、ストリームのバイト列を文字列にデコードする
      とき、また文字列をバイト列にエンコードするときに使われます。

   errors

      このエンコーダやデコーダのエラー設定です。

   newlines

      文字列、文字列のタプル、または "None" で、改行がどのように読み換
      えられるかを指定します。実装や内部コンストラクタのフラグに依って
      、これは利用できないことがあります。

   buffer

      "TextIOBase" が扱う根底のバイナリバッファ ("BufferedIOBase" イン
      スタンス) です。これは "TextIOBase" API には含まれず、よって実装
      に含まれない場合があります。

   detach()

      根底のバイナリバッファを "TextIOBase" から分離して返します。

      根底のバッファが取り外された後、 "TextIOBase" は使用不能状態にな
      ります。

      "TextIOBase" 実装には、 "StringIO" など、根底のバッファという概
      念を持たないものがあります。これらを呼び出すと
      "UnsupportedOperation" を送出します。

      バージョン 3.1 で追加.

   read(size=-1)

      最大 *size* 文字をストリームから読み込み、一つの "str" にして返
      します。 *size* が負の値または "None" ならば、 EOF まで読みます
      。

   readline(size=-1)

      改行または EOF まで読み込み、一つの "str" を返します。ストリーム
      が既に EOF に到達している場合、空文字列が返されます。

      *size* が指定された場合、最大 *size* 文字が読み込まれます。

   seek(offset, whence=SEEK_SET)

      指定された *offset* にストリーム位置を変更します。 挙動は
      *whence* 引数によります。 *whence* のデフォルト値は "SEEK_SET"
      です。:

      * "SEEK_SET" または "0": ストリームの先頭からシークします (デフ
        ォルト)。 *offset* は "TextIOBase.tell()" が返す数か0のどちら
        かでなければなりません。それ以外の *offset* 値は未定義の挙動を
        起こします。

      * "SEEK_CUR" または "1": 現在の位置に "シークします"。 *offset*
        は 0 でなければなりません。つまり何もしません (他の値はサポー
        トされていません)。

      * "SEEK_END" または "2": ストリーム終端へシークします。 *offset*
        は 0 でなければなりません (他の値はサポートされていません)．

      新しい絶対位置を、不透明な数値で返します。

      バージョン 3.1 で追加: "SEEK_*" 定数.

   tell()

      ストリームの現在位置を不透明な数値で返します。この値は根底のバイ
      ナリストレージ内でのバイト数を表すとは限りません。

   write(s)

      文字列 *s* をストリームに書き出し、書き出された文字数を返します
      。

class io.TextIOWrapper(buffer, encoding=None, errors=None, newline=None, line_buffering=False, write_through=False)

   "BufferedIOBase" バイナリストリーム上のバッファ付きテキストストリー
   ム。 "TextIOBase" を継承します。

   *encoding* はストリームがエンコードやデコードされるエンコード名です
   。デフォルトは "locale.getpreferredencoding(False)" です。

   *errors* はオプションの文字列で、エンコードやデコードの際のエラーを
   どのように扱うかを指定します。エンコードエラーがあったときに
   "ValueError" 例外を送出させるには "'strict'" を渡します (デフォルト
   の "None" でも同じです)。エラーを無視させるには "'ignore'" を渡しま
   す。 (エンコーディングエラーを無視するとデータを喪失する可能性があ
   ることに注意してください。) "'replace'" は不正な形式の文字の代わり
   にマーカ (たとえば "'?'") を挿入させます。"'backslashreplace'" を指
   定すると、不正な形式のデータをバックスラッシュ付きのエスケープシー
   ケンスに置換します。書き込み時には "'xmlcharrefreplace'" (適切な
   XML 文字参照に置換) や "'namereplace'" ("\N{...}" エスケープシーケ
   ンスに置換) も使えます。他にも "codecs.register_error()" で登録され
   たエラー処理名が有効です。

   *newline* は行末をどのように処理するかを制御します 。"None", "''",
   "'\n'", "'\r'", "'\r\n'" のいずれかです。これは以下のように動作しま
   す:

   * ストリームからの入力を読み込んでいる時、*newline* が "None" の場
     合、*universal newlines* モードが有効になります。入力中の行は
     "'\n'"、"'\r'"、または "'\r\n'" で終わり、呼び出し元に返される前
     に "'\n'" に変換されます。 "''" の場合、ユニバーサル改行モードは
     有効になりますが、行末は変換されずに呼び出し元に返されます。その
     他の合法な値の場合、入力行は与えられた文字列でのみ終わり、行末は
     変換されずに呼び出し元に返されます。

   * ストリームへの出力の書き込み時、*newline* が "None" の場合、全て
     の "'\n'" 文字はシステムのデフォルトの行セパレータ "os.linesep"
     に変換されます。 *newline* が "''" または "'\n'" の場合は変換され
     ません。*newline* がその他の正当な値の場合、全ての "'\n'" 文字は
     与えられた文字列に変換されます。

   *line_buffering* が "True" の場合、 write への呼び出しが改行文字も
   しくはキャリッジリターンを含んでいれば、暗黙的に "flush()" が呼び出
   されます。

   *write_through* が "True" の場合、"write()" の呼び出しはバッファさ
   れないことが保証されます。 "TextIOWrapper" オブジェクトに書かれた全
   てのデータは直ちに下層のバイナリ *buffer* に処理されます。

   バージョン 3.3 で変更: *write_through* 引数が追加されました。

   バージョン 3.3 で変更: *encoding* の規定値が
   "locale.getpreferredencoding()" から
   "locale.getpreferredencoding(False)" になりました。
   "locale.setlocale()" を用いてロケールのエンコーディングを一時的に変
   更してはいけません。ユーザが望むエンコーディングではなく現在のロケ
   ールのエンコーディングを使用してください。

   "TextIOBase" とその親クラスのメンバーに加えて、"TextIOWrapper" は以
   下のメンバーを提供しています:

   line_buffering

      行バッファリングが有効かどうか。

   write_through

      書き込みが、根柢のバイナリバッファに即座に渡されるかどうか。

      バージョン 3.7 で追加.

   reconfigure(*[, encoding][, errors][, newline][,                      line_buffering][, write_through])

      このテキストストリームを *encoding*, *errors*, *newline*,
      *line_buffering* と *write_through* を新しい設定として再設定しま
      す。

      *encoding* が指定されており、*errors* が指定されていないときに、
      "errors='strict'" が使われている場合を除き、指定されなかったパラ
      メータは現在の設定が保持されます。

      ストリームからすでにデータが読み出されていた場合、encodingと
      newlineは変更できません。一方で、書き込み後にencodingを変更する
      ことはできます。

      このメソッドは、新しい設定を適用するまえにストリームをフラッシュ
      します。

      バージョン 3.7 で追加.

class io.StringIO(initial_value='', newline='\n')

   テキストIO のためのインメモリストリーム。テキストバッファは
   "close()" メソッドが呼び出された際に破棄されます。

   バッファの初期値を *initial_value* で与えることが出来ます。改行変換
   を有効にすると、改行コードは "write()" によってエンコードされます。
   ストリームはバッファの開始位置に配置されます。

   *newline* 引数は "TextIOWrapper" のものと同じように働きます。デフォ
   ルトでは "\n" 文字だけを行末とみなし、また、改行の変換は行いません
   。 *newline* に "None" をセットすると改行コードを全てのプラットフォ
   ームで "\n" で書き込みますが、読み込み時にはそれでもユニバーサル改
   行としてのデコードは実行されます。

   "TextIOBase" およびその親クラスから継承したメソッドに加えて
   "StringIO" は以下のメソッドを提供しています:

   getvalue()

      バッファの全内容を含む "str" を返します。改行コードのデコードは
      "read()" によって行われますが、これによるストリーム位置の変更は
      起こりません。

   使用例:

      import io

      output = io.StringIO()
      output.write('First line.\n')
      print('Second line.', file=output)

      # Retrieve file contents -- this will be
      # 'First line.\nSecond line.\n'
      contents = output.getvalue()

      # Close object and discard memory buffer --
      # .getvalue() will now raise an exception.
      output.close()

class io.IncrementalNewlineDecoder

   改行を *universal newlines* モードにデコードするヘルパーコーデック
   です。 "codecs.IncrementalDecoder" を継承しています。


性能
====

このセクションでは与えられた具体的な I/O 実装の性能について議論します
。


バイナリ I/O
------------

バッファ付き I/O は、ユーザが 1 バイトだけ要求した場合でさえ、データを
大きな塊でのみ読み書きします。これにより、オペレーティングシステムのバ
ッファ無し I/O ルーチンを呼び出して実行する非効率性はすべて隠されます
。その成果は、OS と、実行される I/O の種類によって異なります。例えば、
Linux のような現行の OS では、バッファ無しディスク I/O がバッファ付き
I/O と同じくらい早いことがあります。しかし、どのプラットフォームとデバ
イスにおいても、バッファ付き I/O は最低でも予測可能なパフォーマンスを
提供します。ですから、バイナリデータに対しては、バッファ無し I/O を使
用するより、バッファ付きの I/O を使用するほうが望ましい場合がほとんど
です。


テキスト I/O
------------

(ファイルなどの) バイナリストレージ上のテキスト I/O は、同じストレージ
上のバイナリ I/O より非常に遅いです。なぜならこれには、文字コーデック
を使った Unicode とバイナリデータ間の変換を必要とするからです。これは
大量のテキストデータ、例えば大きなログファイルを扱うときに顕著に成り得
ます。同様に、 "TextIOWrapper.tell()" や "TextIOWrapper.seek()" はどち
らも、使われている復元アルゴリズムのために遅くなります。

しかし "StringIO" は、ネイティブなインメモリ Unicode コンテナで、
"BytesIO" と同程度の速度を示します。


マルチスレッディング
--------------------

(Unix における "read(2)" のような) オペレーティングシステムコールの、
それがラッピングするものがスレッドセーフであるような範囲内では、
"FileIO" オブジェクトもまた、スレッドセーフです。

バイナリバッファ付きオブジェクト ("BufferedReader", "BufferedWriter",
"BufferedRandom" および "BufferedRWPair" のインスタンス) は、その内部
構造をロックを使って保護します。このため、これらを複数のスレッドから同
時に呼び出しても安全です。

"TextIOWrapper" オブジェクトはスレッドセーフではありません。


リエントラント性
----------------

バイナリバッファ付きオブジェクト ("BufferedReader", "BufferedWriter",
"BufferedRandom" および "BufferedRWPair" のインスタンス) は、リエント
ラント (再入可能) ではありません。リエントラントな呼び出しは普通の状況
では起こりませんが、 I/O を "signal" ハンドラで行なっているときに起こ
りえます。スレッドが、すでにアクセスしているバッファ付きオブジェクトに
再び入ろうとすると "RuntimeError" が送出されます。これは、バッファ付き
オブジェクトに複数のスレッドから入ることを禁止するわけではありません。

"open()" 関数は "TextIOWrapper" 内部のバッファ付きオブジェクトをラップ
するため、テキストファイルにも暗黙に拡張されます。これは、標準ストリー
ムを含むので、組み込み関数 "print()" にも同様に影響します。
