as *converter*.
``s*`` (:class:`str`, :class:`bytes`, :class:`bytearray` or buffer compatible object) [Py_buffer]
- This format accepts Unicode objects as well as objects supporting the
- buffer protocol.
+ This format accepts Unicode objects as well as :term:`bytes-like object`\ s.
It fills a :c:type:`Py_buffer` structure provided by the caller.
In this case the resulting C string may contain embedded NUL bytes.
Unicode objects are converted to C strings using ``'utf-8'`` encoding.
contain embedded NUL bytes; if it does, a :exc:`TypeError`
exception is raised.
-``y*`` (:class:`bytes`, :class:`bytearray` or buffer compatible object) [Py_buffer]
- This variant on ``s*`` doesn't accept Unicode objects, only objects
- supporting the buffer protocol. **This is the recommended way to accept
+``y*`` (:class:`bytes`, :class:`bytearray` or :term:`bytes-like object`) [Py_buffer]
+ This variant on ``s*`` doesn't accept Unicode objects, only
+ :term:`bytes-like object`\ s. **This is the recommended way to accept
binary data.**
``y#`` (:class:`bytes`) [const char \*, int]
- This variant on ``s#`` doesn't accept Unicode objects, only bytes-like
- objects.
+ This variant on ``s#`` doesn't accept Unicode objects, only :term:`bytes-like
+ object`\ s.
``S`` (:class:`bytes`) [PyBytesObject \*]
Requires that the Python object is a :class:`bytes` object, without
.. c:function:: PyObject* PyByteArray_FromObject(PyObject *o)
Return a new bytearray object from any object, *o*, that implements the
- buffer protocol.
+ :ref:`buffer protocol <bufferobjects>`.
.. XXX expand about the buffer protocol, at least somewhere
.. class:: array(typecode[, initializer])
A new array whose items are restricted by *typecode*, and initialized
- from the optional *initializer* value, which must be a list, object
- supporting the buffer interface, or iterable over elements of the
+ from the optional *initializer* value, which must be a list, a
+ :term:`bytes-like object`, or iterable over elements of the
appropriate type.
If given a list or string, the initializer is passed to the new array's
concatenation, and multiplication. When using slice assignment, the assigned
value must be an array object with the same type code; in all other cases,
:exc:`TypeError` is raised. Array objects also implement the buffer interface,
-and may be used wherever buffer objects are supported.
+and may be used wherever :term:`bytes-like object`\ s are supported.
The following data items and methods are also supported:
.. note::
``a2b_*`` functions accept Unicode strings containing only ASCII characters.
- Other functions only accept bytes and bytes-compatible objects (such as
- bytearray objects and other objects implementing the buffer API).
+ Other functions only accept :term:`bytes-like object`\ s (such as
+ :class:`bytes`, :class:`bytearray` and other objects that support the buffer
+ protocol).
.. versionchanged:: 3.3
ASCII-only unicode strings are now accepted by the ``a2b_*`` functions.
There is one constructor method named for each type of :dfn:`hash`. All return
a hash object with the same simple interface. For example: use :func:`sha1` to
-create a SHA1 hash object. You can now feed this object with objects conforming
-to the buffer interface (normally :class:`bytes` objects) using the
-:meth:`update` method. At any point you can ask it for the :dfn:`digest` of the
+create a SHA1 hash object. You can now feed this object with :term:`bytes-like
+object`\ s (normally :class:`bytes`) using the :meth:`update` method.
+At any point you can ask it for the :dfn:`digest` of the
concatenation of the data fed to it so far using the :meth:`digest` or
:meth:`hexdigest` methods.
timing analysis by avoiding content-based short circuiting behaviour,
making it appropriate for cryptography. *a* and *b* must both be of the
same type: either :class:`str` (ASCII only, as e.g. returned by
- :meth:`HMAC.hexdigest`), or any type that supports the buffer protocol
- (e.g. :class:`bytes`).
+ :meth:`HMAC.hexdigest`), or a :term:`bytes-like object`.
.. note::
.. method:: send_bytes(buffer[, offset[, size]])
- Send byte data from an object supporting the buffer interface as a
- complete message.
+ Send byte data from a :term:`bytes-like object` as a complete message.
If *offset* is given then data is read from that position in *buffer*. If
*size* is given then that many bytes will be read from buffer. Very large
:exc:`EOFError` if there is nothing left to receive and the other end was
closed.
- *buffer* must be an object satisfying the writable buffer interface. If
+ *buffer* must be a writable :term:`bytes-like object`. If
*offset* is given then the message will be written into the buffer from
that position. Offset must be a non-negative integer less than the
length of *buffer* (in bytes).
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
- The argument *bytes* must either support the buffer protocol or be an
- iterable producing bytes. :class:`bytes` and :class:`bytearray` are
- examples of built-in objects that support the buffer protocol.
+ The argument *bytes* must either be a :term:`bytes-like object` or an
+ iterable producing bytes.
The *byteorder* argument determines the byte order used to represent the
integer. If *byteorder* is ``"big"``, the most significant byte is at the
single: bytes; str (built-in class)
If at least one of *encoding* or *errors* is given, *object* should be a
- :class:`bytes` or :class:`bytearray` object, or more generally any object
- that supports the :ref:`buffer protocol <bufferobjects>`. In this case, if
- *object* is a :class:`bytes` (or :class:`bytearray`) object, then
- ``str(bytes, encoding, errors)`` is equivalent to
+ :term:`bytes-like object` (e.g. :class:`bytes` or :class:`bytearray`). In
+ this case, if *object* is a :class:`bytes` (or :class:`bytearray`) object,
+ then ``str(bytes, encoding, errors)`` is equivalent to
:meth:`bytes.decode(encoding, errors) <bytes.decode>`. Otherwise, the bytes
object underlying the buffer object is obtained before calling
:meth:`bytes.decode`. See :ref:`binaryseq` and
projects / thirdparty / Python / cpython.git / commitdiff
