Text I/O¶

Text I/O expects and producesstr objects. This means that wheneverthe backing store is natively made of bytes (such as in the case of a file),encoding and decoding of data is made transparently as well as optionaltranslation of platform-specific newline characters.

The easiest way to create a text stream is withopen(), optionallyspecifying an encoding:

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

In-memory text streams are also available asStringIO objects:

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

The text stream API is described in detail in the documentation ofTextIOBase.

Binary I/O¶

Binary I/O (also calledbuffered I/O) expectsbytes-like objects and producesbytesobjects. No encoding, decoding, or newline translation is performed. Thiscategory of streams can be used for all kinds of non-text data, and also whenmanual control over the handling of text data is desired.

The easiest way to create a binary stream is withopen() with'b' inthe mode string:

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

In-memory binary streams are also available asBytesIO objects:

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

The binary stream API is described in detail in the docs ofBufferedIOBase.

Other library modules may provide additional ways to create text or binarystreams. Seesocket.socket.makefile() for example.

Raw I/O¶

Raw I/O (also calledunbuffered I/O) is generally used as a low-levelbuilding-block for binary and text streams; it is rarely useful to directlymanipulate a raw stream from user code. Nevertheless, you can create a rawstream by opening a file in binary mode with buffering disabled:

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

The raw stream API is described in detail in the docs ofRawIOBase.

Opt-in EncodingWarning¶

To find where the default locale encoding is used, you can enablethe-Xwarn_default_encoding command line option or set thePYTHONWARNDEFAULTENCODING environment variable, which willemit anEncodingWarning when the default encoding is used.

If you are providing an API that usesopen() orTextIOWrapper and passesencoding=None as a parameter, youcan usetext_encoding() so that callers of the API will emit anEncodingWarning if they don’t pass anencoding. However,please consider using UTF-8 by default (i.e.encoding="utf-8") fornew APIs.

I/O Base Classes¶

classio.IOBase¶

The abstract base class for all I/O classes.

This class provides empty abstract implementations for many methodsthat derived classes can override selectively; the defaultimplementations represent a file that cannot be read, written orseeked.

Even thoughIOBase does not declareread()orwrite() because their signatures will vary, implementations andclients should consider those methods part of the interface. Also,implementations may raise aValueError (orUnsupportedOperation)when operations they do not support are called.

The basic type used for binary data read from or written to a file isbytes. Otherbytes-like objects areaccepted as method arguments too. Text I/O classes work withstr data.

Note that calling any method (even inquiries) on a closed stream isundefined. Implementations may raiseValueError in this case.

IOBase (and its subclasses) supports the iterator protocol, meaningthat anIOBase object can be iterated over yielding the lines in astream. Lines are defined slightly differently depending on whether thestream is a binary stream (yielding bytes), or a text stream (yieldingcharacter strings). Seereadline() below.

IOBase is also a context manager and therefore supports thewith statement. In this example,file is closed after thewith statement’s suite is finished—even if an exception occurs:

withopen('spam.txt','w')asfile:file.write('Spam and eggs!')

IOBase provides these data attributes and methods:

close()¶

Flush and close this stream. This method has no effect if the file isalready closed. Once the file is closed, any operation on the file(e.g. reading or writing) will raise aValueError.

As a convenience, it is allowed to call this method more than once;only the first call, however, will have an effect.

closed¶

True if the stream is closed.

fileno()¶

Return the underlying file descriptor (an integer) of the stream if itexists. AnOSError is raised if the IO object does not use a filedescriptor.

flush()¶

Flush the write buffers of the stream if applicable. This does nothingfor read-only and non-blocking streams.

isatty()¶

ReturnTrue if the stream is interactive (i.e., connected toa terminal/tty device).

readable()¶

ReturnTrue if the stream can be read from.IfFalse,read() will raiseOSError.

readline(size=-1,/)¶

Read and return one line from the stream. Ifsize is specified, atmostsize bytes will be read.

The line terminator is alwaysb'\n' for binary files; for text files,thenewline argument toopen() can be used to select the lineterminator(s) recognized.

readlines(hint=-1,/)¶

Read and return a list of lines from the stream.hint can be specifiedto control the number of lines read: no more lines will be read if thetotal size (in bytes/characters) of all lines so far exceedshint.

hint values of0 or less, as well asNone, are treated as nohint.

Note that it’s already possible to iterate on file objects usingforlineinfile:... without callingfile.readlines().

seek(offset,whence=os.SEEK_SET,/)¶

Change the stream position to the given byteoffset,interpreted relative to the position indicated bywhence,and return the new absolute position.Values forwhence are:

• os.SEEK_SET or0 – start of the stream (the default);offset should be zero or positive

• os.SEEK_CUR or1 – current stream position;offset may be negative

• os.SEEK_END or2 – end of the stream;offset is usually negative

Added in version 3.1:TheSEEK_* constants.

Added in version 3.3:Some operating systems could support additional values, likeos.SEEK_HOLE oros.SEEK_DATA. The valid valuesfor a file could depend on it being open in text or binary mode.

seekable()¶

ReturnTrue if the stream supports random access. IfFalse,seek(),tell() andtruncate() will raiseOSError.

tell()¶

Return the current stream position.

truncate(size=None,/)¶

Resize the stream to the givensize in bytes (or the current positionifsize is not specified). The current stream position isn’t changed.This resizing can extend or reduce the current file size. In case ofextension, the contents of the new file area depend on the platform(on most systems, additional bytes are zero-filled). The new file sizeis returned.

Changed in version 3.5:Windows will now zero-fill files when extending.

writable()¶

ReturnTrue if the stream supports writing. IfFalse,write() andtruncate() will raiseOSError.

writelines(lines,/)¶

Write a list of lines to the stream. Line separators are not added, so itis usual for each of the lines provided to have a line separator at theend.

__del__()¶

Prepare for object destruction.IOBase provides a defaultimplementation of this method that calls the instance’sclose() method.

classio.RawIOBase¶

Base class for raw binary streams. It inherits fromIOBase.

Raw binary streams typically provide low-level access to an underlying OSdevice or API, and do not try to encapsulate it in high-level primitives(this functionality is done at a higher-level in buffered binary streams and text streams, described laterin this page).

RawIOBase provides these methods in addition to those fromIOBase:

read(size=-1,/)¶

Read up tosize bytes from the object and return them. As a convenience,ifsize is unspecified or -1, all bytes until EOF are returned.Otherwise, only one system call is ever made. Fewer thansize bytes maybe returned if the operating system call returns fewer thansize bytes.

If 0 bytes are returned, andsize was not 0, this indicates end of file.If the object is in non-blocking mode and no bytes are available,None is returned.

The default implementation defers toreadall() andreadinto().

readall()¶

Read and return all the bytes from the stream until EOF, using multiplecalls to the stream if necessary.

readinto(b,/)¶

Read bytes into a pre-allocated, writablebytes-like objectb, and return thenumber of bytes read. For example,b might be abytearray.If the object is in non-blocking mode and no bytesare available,None is returned.

write(b,/)¶

Write the givenbytes-like object,b, to theunderlying raw stream, and return the number ofbytes written. This can be less than the length ofb inbytes, depending on specifics of the underlying rawstream, and especially if it is in non-blocking mode.None isreturned if the raw stream is set not to block and no single byte couldbe readily written to it. The caller may release or mutateb afterthis method returns, so the implementation should only accessbduring the method call.

classio.BufferedIOBase¶

Base class for binary streams that support some kind of buffering.It inherits fromIOBase.

The main difference withRawIOBase is that methodsread(),readinto() andwrite() will try (respectively) to readas much input as requested or to emit all provided data.

In addition, if the underlying raw stream is in non-blocking mode, when thesystem returns would blockwrite() will raiseBlockingIOErrorwithBlockingIOError.characters_written andread() will returndata read so far orNone if no data is available.

Besides, theread() method does not have a defaultimplementation that defers toreadinto().

A typicalBufferedIOBase implementation should not inherit from aRawIOBase implementation, but wrap one, likeBufferedWriter andBufferedReader do.

BufferedIOBase provides or overrides these data attributes andmethods in addition to those fromIOBase:

raw¶

The underlying raw stream (aRawIOBase instance) thatBufferedIOBase deals with. This is not part of theBufferedIOBase API and may not exist on some implementations.

detach()¶

Separate the underlying raw stream from the buffer and return it.

After the raw stream has been detached, the buffer is in an unusablestate.

Some buffers, likeBytesIO, do not have the concept of a singleraw stream to return from this method. They raiseUnsupportedOperation.

Added in version 3.1.

read(size=-1,/)¶

Read and return up tosize bytes. If the argument is omitted,None,or negative read as much as possible.

Fewer bytes may be returned than requested. An emptybytes objectis returned if the stream is already at EOF. More than one read may bemade and calls may be retried if specific errors are encountered, seeos.read() andPEP 475 for more details. Less than size bytesbeing returned does not imply that EOF is imminent.

When reading as much as possible the default implementation will useraw.readall if available (which should implementRawIOBase.readall()), otherwise will read in a loop until readreturnsNone, an emptybytes, or a non-retryable error. Formost streams this is to EOF, but for non-blocking streams more data maybecome available.

Note

When the underlying raw stream is non-blocking, implementations mayeither raiseBlockingIOError or returnNone if no data isavailable.io implementations returnNone.

read1(size=-1,/)¶

Read and return up tosize bytes, callingreadinto()which may retry ifEINTR is encountered perPEP 475. Ifsize is-1 or not provided, the implementation willchoose an arbitrary value forsize.

Note

When the underlying raw stream is non-blocking, implementations mayeither raiseBlockingIOError or returnNone if no data isavailable.io implementations returnNone.

readinto(b,/)¶

Read bytes into a pre-allocated, writablebytes-like objectb and return the number of bytes read.For example,b might be abytearray.

Likeread(), multiple reads may be issued to the underlying rawstream, unless the latter is interactive.

ABlockingIOError is raised if the underlying raw stream is in nonblocking-mode, and has no data available at the moment.

readinto1(b,/)¶

Read bytes into a pre-allocated, writablebytes-like objectb, using at most one call tothe underlying raw stream’sread() (orreadinto()) method. Return the number of bytes read.

ABlockingIOError is raised if the underlying raw stream is in nonblocking-mode, and has no data available at the moment.

Added in version 3.5.

write(b,/)¶

Write the givenbytes-like object,b, and return the numberof bytes written (always equal to the length ofb in bytes, since ifthe write fails anOSError will be raised). Depending on theactual implementation, these bytes may be readily written to theunderlying stream, or held in a buffer for performance and latencyreasons.

When in non-blocking mode, aBlockingIOError is raised if thedata needed to be written to the raw stream but it couldn’t acceptall the data without blocking.

The caller may release or mutateb after this method returns,so the implementation should only accessb during the method call.

Raw File I/O¶

classio.FileIO(name,mode='r',closefd=True,opener=None)¶

A raw binary stream representing an OS-level file containing bytes data. Itinherits fromRawIOBase.

Thename can be one of two things:

• a character string orbytes object representing the path to thefile which will be opened. In this case closefd must beTrue (the default)otherwise an error will be raised.

• an integer representing the number of an existing OS-level file descriptorto which the resultingFileIO object will give access. When theFileIO object is closed this fd will be closed as well, unlessclosefdis set toFalse.

Themode can be'r','w','x' or'a' for reading(default), writing, exclusive creation or appending. The file will becreated if it doesn’t exist when opened for writing or appending; it will betruncated when opened for writing.FileExistsError will be raised ifit already exists when opened for creating. Opening a file for creatingimplies writing, so this mode behaves in a similar way to'w'. Add a'+' to the mode to allow simultaneous reading and writing.

Theread() (when called with a positive argument),readinto() andwrite() methods on thisclass will only make one system call.

A custom opener can be used by passing a callable asopener. The underlyingfile descriptor for the file object is then obtained by callingopener with(name,flags).opener must return an open file descriptor (passingos.open asopener results in functionality similar to passingNone).

The newly created file isnon-inheritable.

See theopen() built-in function for examples on using theopenerparameter.

Changed in version 3.3:Theopener parameter was added.The'x' mode was added.

Changed in version 3.4:The file is now non-inheritable.

FileIO provides these data attributes in addition to those fromRawIOBase andIOBase:

mode¶

The mode as given in the constructor.

name¶

The file name. This is the file descriptor of the file when no name isgiven in the constructor.

Buffered Streams¶

Buffered I/O streams provide a higher-level interface to an I/O devicethan raw I/O does.

classio.BytesIO(initial_bytes=b'')¶

A binary stream using an in-memory bytes buffer. It inherits fromBufferedIOBase. The buffer is discarded when theclose() method is called.

The optional argumentinitial_bytes is abytes-like object thatcontains initial data.

BytesIO provides or overrides these methods in addition to thosefromBufferedIOBase andIOBase:

getbuffer()¶

Return a readable and writable view over the contents of the bufferwithout copying them. Also, mutating the view will transparentlyupdate the contents of the buffer:

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

Note

As long as the view exists, theBytesIO object cannot beresized or closed.

Added in version 3.2.

getvalue()¶

Returnbytes containing the entire contents of the buffer.

read1(size=-1,/)¶

InBytesIO, this is the same asread().

Changed in version 3.7:Thesize argument is now optional.

readinto1(b,/)¶

InBytesIO, this is the same asreadinto().

Added in version 3.5.

classio.BufferedReader(raw,buffer_size=DEFAULT_BUFFER_SIZE)¶

A buffered binary stream providing higher-level access to a readable, nonseekableRawIOBase raw binary stream. It inherits fromBufferedIOBase.

When reading data from this object, a larger amount of data may berequested from the underlying raw stream, and kept in an internal buffer.The buffered data can then be returned directly on subsequent reads.

The constructor creates aBufferedReader for the given readableraw stream andbuffer_size. Ifbuffer_size is omitted,DEFAULT_BUFFER_SIZE is used.

BufferedReader provides or overrides these methods in addition tothose fromBufferedIOBase andIOBase:

peek(size=0,/)¶

Return bytes from the stream without advancing the position. The number ofbytes returned may be less or more than requested. If the underlying rawstream is non-blocking and the operation would block, returns empty bytes.

read(size=-1,/)¶

InBufferedReader this is the same asio.BufferedIOBase.read()

read1(size=-1,/)¶

InBufferedReader this is the same asio.BufferedIOBase.read1()

Changed in version 3.7:Thesize argument is now optional.

classio.BufferedWriter(raw,buffer_size=DEFAULT_BUFFER_SIZE)¶

A buffered binary stream providing higher-level access to a writeable, nonseekableRawIOBase raw binary stream. It inherits fromBufferedIOBase.

When writing to this object, data is normally placed into an internalbuffer. The buffer will be written out to the underlyingRawIOBaseobject under various conditions, including:

• when the buffer gets too small for all pending data;

• whenflush() is called;

• when aseek() is requested (forBufferedRandom objects);

• when theBufferedWriter object is closed or destroyed.

The constructor creates aBufferedWriter for the given writeableraw stream. If thebuffer_size is not given, it defaults toDEFAULT_BUFFER_SIZE.

BufferedWriter provides or overrides these methods in addition tothose fromBufferedIOBase andIOBase:

flush()¶

Force bytes held in the buffer into the raw stream. ABlockingIOError should be raised if the raw stream blocks.

write(b,/)¶

Write thebytes-like object,b, and return thenumber of bytes written. When in non-blocking mode, aBlockingIOError withBlockingIOError.characters_written setis raised if the buffer needs to be written out but the raw stream blocks.

classio.BufferedRandom(raw,buffer_size=DEFAULT_BUFFER_SIZE)¶

A buffered binary stream providing higher-level access to a seekableRawIOBase raw binary stream. It inherits fromBufferedReaderandBufferedWriter.

The constructor creates a reader and writer for a seekable raw stream, givenin the first argument. If thebuffer_size is omitted it defaults toDEFAULT_BUFFER_SIZE.

BufferedRandom is capable of anythingBufferedReader orBufferedWriter can do. In addition,seek() andtell() are guaranteed to be implemented.

classio.BufferedRWPair(reader,writer,buffer_size=DEFAULT_BUFFER_SIZE,/)¶

A buffered binary stream providing higher-level access to two non seekableRawIOBase raw binary streams—one readable, the other writeable.It inherits fromBufferedIOBase.

reader andwriter areRawIOBase objects that are readable andwriteable respectively. If thebuffer_size is omitted it defaults toDEFAULT_BUFFER_SIZE.

BufferedRWPair implements all ofBufferedIOBase's methodsexcept fordetach(), which raisesUnsupportedOperation.

Warning

BufferedRWPair does not attempt to synchronize accesses toits underlying raw streams. You should not pass it the same objectas reader and writer; useBufferedRandom instead.

Text I/O¶

classio.TextIOBase¶

Base class for text streams. This class provides a character and line basedinterface to stream I/O. It inherits fromIOBase.

TextIOBase provides or overrides these data attributes andmethods in addition to those fromIOBase:

encoding¶

The name of the encoding used to decode the stream’s bytes intostrings, and to encode strings into bytes.

errors¶

The error setting of the decoder or encoder.

newlines¶

A string, a tuple of strings, orNone, indicating the newlinestranslated so far. Depending on the implementation and the initialconstructor flags, this may not be available.

buffer¶

The underlying binary buffer (aBufferedIOBaseorRawIOBase instance) thatTextIOBase deals with.This is not part of theTextIOBase API and may not existin some implementations.

detach()¶

Separate the underlying binary buffer from theTextIOBase andreturn it.

After the underlying buffer has been detached, theTextIOBase isin an unusable state.

SomeTextIOBase implementations, likeStringIO, may nothave the concept of an underlying buffer and calling this method willraiseUnsupportedOperation.

Added in version 3.1.

read(size=-1,/)¶

Read and return at mostsize characters from the stream as a singlestr. Ifsize is negative orNone, reads until EOF.

readline(size=-1,/)¶

Read until newline or EOF and return a singlestr. If the stream isalready at EOF, an empty string is returned.

Ifsize is specified, at mostsize characters will be read.

seek(offset,whence=SEEK_SET,/)¶

Change the stream position to the givenoffset. Behaviour depends onthewhence parameter. The default value forwhence isSEEK_SET.

• SEEK_SET or0: seek from the start of the stream(the default);offset must either be a number returned byTextIOBase.tell(), or zero. Any otheroffset valueproduces undefined behaviour.

• SEEK_CUR or1: “seek” to the current position;offset must be zero, which is a no-operation (all other valuesare unsupported).

• SEEK_END or2: seek to the end of the stream;offset must be zero (all other values are unsupported).

Return the new absolute position as an opaque number.

Added in version 3.1:TheSEEK_* constants.

tell()¶

Return the current stream position as an opaque number. The numberdoes not usually represent a number of bytes in the underlyingbinary storage.

write(s,/)¶

Write the strings to the stream and return the number of characterswritten.

classio.TextIOWrapper(buffer,encoding=None,errors=None,newline=None,line_buffering=False,write_through=False)¶

A buffered text stream providing higher-level access to aBufferedIOBase buffered binary stream. It inherits fromTextIOBase.

encoding gives the name of the encoding that the stream will be decoded orencoded with. InUTF-8 Mode, this defaults to UTF-8.Otherwise, it defaults tolocale.getencoding().encoding="locale" can be used to specify the current locale’s encodingexplicitly. SeeText Encoding for more information.

errors is an optional string that specifies how encoding and decodingerrors are to be handled. Pass'strict' to raise aValueErrorexception if there is an encoding error (the default ofNone has the sameeffect), or pass'ignore' to ignore errors. (Note that ignoring encodingerrors can lead to data loss.)'replace' causes a replacement marker(such as'?') to be inserted where there is malformed data.'backslashreplace' causes malformed data to be replaced by abackslashed escape sequence. When writing,'xmlcharrefreplace'(replace with the appropriate XML character reference) or'namereplace'(replace with\N{...} escape sequences) can be used. Any other errorhandling name that has been registered withcodecs.register_error() is also valid.

newline controls how line endings are handled. It can beNone,'','\n','\r', and'\r\n'. It works as follows:

• When reading input from the stream, ifnewline isNone,universal newlines mode is enabled. Lines in the input can end in'\n','\r', or'\r\n', and these are translated into'\n'before being returned to the caller. Ifnewline is'', universalnewlines mode is enabled, but line endings are returned to the calleruntranslated. Ifnewline has any of the other legal values, input linesare only terminated by the given string, and the line ending is returned tothe caller untranslated.

• When writing output to the stream, ifnewline isNone, any'\n'characters written are translated to the system default line separator,os.linesep. Ifnewline is'' or'\n', no translationtakes place. Ifnewline is any of the other legal values, any'\n'characters written are translated to the given string.

Ifline_buffering isTrue,flush() is implied when a call towrite contains a newline character or a carriage return.

Ifwrite_through isTrue, calls towrite() are guaranteednot to be buffered: any data written on theTextIOWrapperobject is immediately handled to its underlying binarybuffer.

Changed in version 3.3:Thewrite_through argument has been added.

Changed in version 3.3:The defaultencoding is nowlocale.getpreferredencoding(False)instead oflocale.getpreferredencoding(). Don’t change temporary thelocale encoding usinglocale.setlocale(), use the current localeencoding instead of the user preferred encoding.

Changed in version 3.10:Theencoding argument now supports the"locale" dummy encoding name.

TextIOWrapper provides these data attributes and methods inaddition to those fromTextIOBase andIOBase:

line_buffering¶

Whether line buffering is enabled.

write_through¶

Whether writes are passed immediately to the underlying binarybuffer.

Added in version 3.7.

reconfigure(*,encoding=None,errors=None,newline=None,line_buffering=None,write_through=None)¶

Reconfigure this text stream using new settings forencoding,errors,newline,line_buffering andwrite_through.

Parameters not specified keep current settings, excepterrors='strict' is used whenencoding is specified buterrors is not specified.

It is not possible to change the encoding or newline if some datahas already been read from the stream. On the other hand, changingencoding after write is possible.

This method does an implicit stream flush before setting thenew parameters.

Added in version 3.7.

Changed in version 3.11:The method supportsencoding="locale" option.

seek(cookie,whence=os.SEEK_SET,/)¶

Set the stream position.Return the new stream position as anint.

Four operations are supported,given by the following argument combinations:

• seek(0,SEEK_SET): Rewind to the start of the stream.

• seek(cookie,SEEK_SET): Restore a previous position;cookiemust be a number returned bytell().

• seek(0,SEEK_END): Fast-forward to the end of the stream.

• seek(0,SEEK_CUR): Leave the current stream position unchanged.

Any other argument combinations are invalid,and may raise exceptions.

See also

os.SEEK_SET,os.SEEK_CUR, andos.SEEK_END.

tell()¶

Return the stream position as an opaque number.The return value oftell() can be given as input toseek(),to restore a previous stream position.

classio.StringIO(initial_value='',newline='\n')¶

A text stream using an in-memory text buffer. It inherits fromTextIOBase.

The text buffer is discarded when theclose() method iscalled.

The initial value of the buffer can be set by providinginitial_value.If newline translation is enabled, newlines will be encoded as if bywrite(). The stream is positioned at the start of thebuffer which emulates opening an existing file in aw+ mode, making itready for an immediate write from the beginning or for a write thatwould overwrite the initial value. To emulate opening a file in ana+mode ready for appending, usef.seek(0,io.SEEK_END) to reposition thestream at the end of the buffer.

Thenewline argument works like that ofTextIOWrapper,except that when writing output to the stream, ifnewline isNone,newlines are written as\n on all platforms.

StringIO provides this method in addition to those fromTextIOBase andIOBase:

getvalue()¶

Return astr containing the entire contents of the buffer.Newlines are decoded as if byread(), althoughthe stream position is not changed.

Example usage:

importiooutput=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()

classio.IncrementalNewlineDecoder¶

A helper codec that decodes newlines foruniversal newlines mode.It inherits fromcodecs.IncrementalDecoder.

Binary I/O¶

By reading and writing only large chunks of data even when the user asks for asingle byte, buffered I/O hides any inefficiency in calling and executing theoperating system’s unbuffered I/O routines. The gain depends on the OS and thekind of I/O which is performed. For example, on some modern OSes such as Linux,unbuffered disk I/O can be as fast as buffered I/O. The bottom line, however,is that buffered I/O offers predictable performance regardless of the platformand the backing device. Therefore, it is almost always preferable to usebuffered I/O rather than unbuffered I/O for binary data.

Text I/O¶

Text I/O over a binary storage (such as a file) is significantly slower thanbinary I/O over the same storage, because it requires conversions betweenunicode and binary data using a character codec. This can become noticeablehandling huge amounts of text data like large log files. Also,tell() andseek() are both quite slowdue to the reconstruction algorithm used.

StringIO, however, is a native in-memory unicode container and willexhibit similar speed toBytesIO.

Multi-threading¶

FileIO objects are thread-safe to the extent that the operating systemcalls (such asread(2) under Unix) they wrap are thread-safe too.

Binary buffered objects (instances ofBufferedReader,BufferedWriter,BufferedRandom andBufferedRWPair)protect their internal structures using a lock; it is therefore safe to callthem from multiple threads at once.

TextIOWrapper objects are not thread-safe.

Reentrancy¶

Binary buffered objects (instances ofBufferedReader,BufferedWriter,BufferedRandom andBufferedRWPair)are not reentrant. While reentrant calls will not happen in normal situations,they can arise from doing I/O in asignal handler. If a thread tries tore-enter a buffered object which it is already accessing, aRuntimeErroris raised. Note this doesn’t prohibit a different thread from entering thebuffered object.

The above implicitly extends to text files, since theopen() functionwill wrap a buffered object inside aTextIOWrapper. This includesstandard streams and therefore affects the built-inprint() function aswell.