It inherits from:class:`IOBase`.

The main difference with:class:`RawIOBase` is that methods:meth:`read`,

:meth:`readinto` and:meth:`write` will try (respectively) to read as much

input as requested or to consume all given output, at the expense of

making perhaps more than one system call.

:meth:`readinto` and:meth:`write` will try (respectively) to read

as much input as requested or to emit all provided data.

In addition,those methods can raise:exc:`BlockingIOError` if the

enough data; unlike their:class:`RawIOBase` counterparts, theywill

never return``None``.

In addition,if the underlying raw stream is in non-blocking mode, when the

with:attr:`BlockingIOError.characters_written` and:meth:`read`will return

data read so far or``None`` if no data is available.

Besides, the:meth:`read` method does not have a default

implementation that defers to:meth:`readinto`.

..method::read(size=-1, /)

Read and return up to *size* bytes. If the argument is omitted, ``None``,

or negative, data is read and returned until EOF is reached. An empty

:class:`bytes` object is returned if the stream is already at EOF.

Read and return up to *size* bytes. If the argument is omitted, ``None``,

or negative read as much as possible.

one rawread will be issued,anda short result does not imply that EOF is

imminent.

:meth:`os.read`and:pep:`475` for more details. Less than size bytes

being returned does not imply that EOF isimminent.

A:exc:`BlockingIOError` is raised if the underlying raw stream is in

non blocking-mode, and has no data available at the moment.

When reading as much as possible the default implementation will use

``raw.readall`` if available (which should implement

:meth:`RawIOBase.readall`), otherwise will read in a loop until read

returns ``None``, an empty:class:`bytes`, or a non-retryable error. For

most streams this is to EOF, but for non-blocking streams more data may

become available.

..note::

When the underlying raw stream is non-blocking, implementations may

either raise:exc:`BlockingIOError` or return ``None`` if no data is

available.:mod:`io` implementations return ``None``.

..method::read1(size=-1, /)

Read and return up to *size* bytes, with at most one call to the

underlying raw stream's:meth:`~RawIOBase.read` (or

:meth:`~RawIOBase.readinto`) method. This can be useful if you are

implementing your own buffering on top of a:class:`BufferedIOBase`

object.

Read and return up to *size* bytes, calling:meth:`~RawIOBase.readinto`

which may retry if:py:const:`~errno.EINTR` is encountered per

:pep:`475`. If *size* is ``-1`` or not provided, the implementation will

choose an arbitrary value for *size*.

..note::

If *size* is ``-1`` (the default), an arbitrary number of bytes are

returned (more than zero unless EOF is reached).

When the underlying raw stream is non-blocking, implementations may

either raise:exc:`BlockingIOError` or return ``None`` if no data is

available.:mod:`io` implementations return ``None``.

..method::readinto(b, /)

..method::peek(size=0, /)

Return bytes from the stream without advancing the position. At most one

single read on the raw stream is done to satisfy thecall. The number of

bytes returned may be less or more than requested.

Return bytes from the stream without advancing the position.The number of

bytes returned may be less or more than requested. If theunderlying raw

stream is non-blocking and the operation would block, returns empty bytes.

..method::read(size=-1, /)

Read and return *size* bytes, or if *size* is not given or negative, until

EOF or if the read call would block in non-blocking mode.

In:class:`BufferedReader` this is the same as:meth:`io.BufferedIOBase.read`

..method::read1(size=-1, /)

Read and return up to *size* bytes with only one call on the raw stream.

If at least one byte is buffered, only buffered bytes are returned.

Otherwise, one raw stream read call is made.

In:class:`BufferedReader` this is the same as:meth:`io.BufferedIOBase.read1`

..versionchanged::3.7

The *size* argument is now optional.

Write the:term:`bytes-like object`, *b*, and return the

number of bytes written. When in non-blocking mode, a

:exc:`BlockingIOError`is raised if the buffer needs to be written out but

the raw stream blocks.

:exc:`BlockingIOError`with:attr:`BlockingIOError.characters_written` set

is raised if the buffer needs to be written out butthe raw stream blocks.

..class::BufferedRandom(raw, buffer_size=DEFAULT_BUFFER_SIZE)