An optional pointer to the instance print function.
The print function is only called when the instance is printed to a *real* file;
- when it is printed to a pseudo-file (like a :class:`StringIO` instance), the
+ when it is printed to a pseudo-file (like a :class:`io.StringIO` instance), the
instance's :c:member:`~PyTypeObject.tp_repr` or :c:member:`~PyTypeObject.tp_str` function is called to convert it to
a string. These are also called when the type's :c:member:`~PyTypeObject.tp_print` field is
*NULL*. A type should never implement :c:member:`~PyTypeObject.tp_print` in a way that produces
value.
The new class instance is based on *fileobj*, which can be a regular file, a
- :class:`StringIO` object, or any other object which simulates a file. It
+ :class:`io.BytesIO` object, or any other object which simulates a file. It
defaults to ``None``, in which case *filename* is opened to provide a file
object.
In Babyl mailboxes, the headers of a message are not stored contiguously
with the body of the message. To generate a file-like representation, the
- headers and body are copied together into a :class:`StringIO` instance
- (from the :mod:`StringIO` module), which has an API identical to that of a
+ headers and body are copied together into a :class:`io.BytesIO` instance,
+ which has an API identical to that of a
file. As a result, the file-like object is truly independent of the
underlying mailbox but does not save memory compared to a string
representation.
causes the file to roll over to an on-disk file regardless of its size.
The returned object is a file-like object whose :attr:`_file` attribute
- is either a :class:`BytesIO` or :class:`StringIO` object (depending on
+ is either a :class:`io.BytesIO` or :class:`io.StringIO` object (depending on
whether binary or text *mode* was specified) or a true file
object, depending on whether :func:`rollover` has been called. This
file-like object can be used in a :keyword:`with` statement, just like
...
TypeError: 'NonCallableMock' object is not callable
-Another use case might be to replace an object with a `StringIO` instance:
+Another use case might be to replace an object with a `io.StringIO` instance:
- >>> from StringIO import StringIO
+ >>> from io import StringIO
>>> def foo():
... print 'Something'
...
.. function:: parseString(string, parser=None)
Return a :class:`Document` that represents the *string*. This method creates a
- :class:`StringIO` object for the string and passes that on to :func:`parse`.
+ :class:`io.StringIO` object for the string and passes that on to :func:`parse`.
Both functions return a :class:`Document` object representing the content of the
document.