forked from AFPy/python-docs-fr
1447 lines
45 KiB
Plaintext
1447 lines
45 KiB
Plaintext
# Copyright (C) 2001-2018, Python Software Foundation
|
||
# For licence information, see README file.
|
||
#
|
||
msgid ""
|
||
msgstr ""
|
||
"Project-Id-Version: Python 3\n"
|
||
"Report-Msgid-Bugs-To: \n"
|
||
"POT-Creation-Date: 2021-05-19 22:36+0200\n"
|
||
"PO-Revision-Date: 2018-07-03 11:13+0200\n"
|
||
"Last-Translator: Julien Palard <julien@palard.fr>\n"
|
||
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
|
||
"Language: fr\n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
|
||
#: library/io.rst:2
|
||
msgid ":mod:`io` --- Core tools for working with streams"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:15
|
||
#, fuzzy
|
||
msgid "**Source code:** :source:`Lib/io.py`"
|
||
msgstr "**Code source:** :source:`Lib/os.py`"
|
||
|
||
#: library/io.rst:22
|
||
msgid "Overview"
|
||
msgstr "Aperçu"
|
||
|
||
#: library/io.rst:27
|
||
msgid ""
|
||
"The :mod:`io` module provides Python's main facilities for dealing with "
|
||
"various types of I/O. There are three main types of I/O: *text I/O*, "
|
||
"*binary I/O* and *raw I/O*. These are generic categories, and various "
|
||
"backing stores can be used for each of them. A concrete object belonging to "
|
||
"any of these categories is called a :term:`file object`. Other common terms "
|
||
"are *stream* and *file-like object*."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:34
|
||
msgid ""
|
||
"Independent of its category, each concrete stream object will also have "
|
||
"various capabilities: it can be read-only, write-only, or read-write. It can "
|
||
"also allow arbitrary random access (seeking forwards or backwards to any "
|
||
"location), or only sequential access (for example in the case of a socket or "
|
||
"pipe)."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:40
|
||
msgid ""
|
||
"All streams are careful about the type of data you give to them. For "
|
||
"example giving a :class:`str` object to the ``write()`` method of a binary "
|
||
"stream will raise a :exc:`TypeError`. So will giving a :class:`bytes` "
|
||
"object to the ``write()`` method of a text stream."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:45
|
||
msgid ""
|
||
"Operations that used to raise :exc:`IOError` now raise :exc:`OSError`, "
|
||
"since :exc:`IOError` is now an alias of :exc:`OSError`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:771 library/io.rst:1028
|
||
msgid "Text I/O"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:53
|
||
msgid ""
|
||
"Text I/O expects and produces :class:`str` objects. This means that "
|
||
"whenever the 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 "
|
||
"optional translation of platform-specific newline characters."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:58
|
||
msgid ""
|
||
"The easiest way to create a text stream is with :meth:`open()`, optionally "
|
||
"specifying an encoding::"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:63
|
||
msgid ""
|
||
"In-memory text streams are also available as :class:`StringIO` objects::"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:67
|
||
msgid ""
|
||
"The text stream API is described in detail in the documentation of :class:"
|
||
"`TextIOBase`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:1016
|
||
msgid "Binary I/O"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:74
|
||
msgid ""
|
||
"Binary I/O (also called *buffered I/O*) expects :term:`bytes-like objects "
|
||
"<bytes-like object>` and produces :class:`bytes` objects. No encoding, "
|
||
"decoding, or newline translation is performed. This category of streams can "
|
||
"be used for all kinds of non-text data, and also when manual control over "
|
||
"the handling of text data is desired."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:80
|
||
msgid ""
|
||
"The easiest way to create a binary stream is with :meth:`open()` with "
|
||
"``'b'`` in the mode string::"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:85
|
||
msgid ""
|
||
"In-memory binary streams are also available as :class:`BytesIO` objects::"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:89
|
||
msgid ""
|
||
"The binary stream API is described in detail in the docs of :class:"
|
||
"`BufferedIOBase`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:92
|
||
msgid ""
|
||
"Other library modules may provide additional ways to create text or binary "
|
||
"streams. See :meth:`socket.socket.makefile` for example."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:97
|
||
msgid "Raw I/O"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:99
|
||
msgid ""
|
||
"Raw I/O (also called *unbuffered I/O*) is generally used as a low-level "
|
||
"building-block for binary and text streams; it is rarely useful to directly "
|
||
"manipulate a raw stream from user code. Nevertheless, you can create a raw "
|
||
"stream by opening a file in binary mode with buffering disabled::"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:106
|
||
msgid ""
|
||
"The raw stream API is described in detail in the docs of :class:`RawIOBase`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:110
|
||
msgid "High-level Module Interface"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:114
|
||
msgid ""
|
||
"An int containing the default buffer size used by the module's buffered I/O "
|
||
"classes. :func:`open` uses the file's blksize (as obtained by :func:`os."
|
||
"stat`) if possible."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:121
|
||
msgid "This is an alias for the builtin :func:`open` function."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:123
|
||
msgid ""
|
||
"Raises an :ref:`auditing event <auditing>` ``open`` with arguments ``path``, "
|
||
"``mode``, ``flags``."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:125
|
||
msgid ""
|
||
"This function raises an :ref:`auditing event <auditing>` ``open`` with "
|
||
"arguments ``path``, ``mode`` and ``flags``. The ``mode`` and ``flags`` "
|
||
"arguments may have been modified or inferred from the original call."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:132
|
||
msgid ""
|
||
"Opens the provided file with mode ``'rb'``. This function should be used "
|
||
"when the intent is to treat the contents as executable code."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:135
|
||
msgid "``path`` should be a :class:`str` and an absolute path."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:137
|
||
msgid ""
|
||
"The behavior of this function may be overridden by an earlier call to the :c:"
|
||
"func:`PyFile_SetOpenCodeHook`. However, assuming that ``path`` is a :class:"
|
||
"`str` and an absolute path, ``open_code(path)`` should always behave the "
|
||
"same as ``open(path, 'rb')``. Overriding the behavior is intended for "
|
||
"additional validation or preprocessing of the file."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:148
|
||
msgid ""
|
||
"This is a compatibility alias for the builtin :exc:`BlockingIOError` "
|
||
"exception."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:154
|
||
msgid ""
|
||
"An exception inheriting :exc:`OSError` and :exc:`ValueError` that is raised "
|
||
"when an unsupported operation is called on a stream."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:161
|
||
msgid ":mod:`sys`"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:161
|
||
msgid ""
|
||
"contains the standard IO streams: :data:`sys.stdin`, :data:`sys.stdout`, "
|
||
"and :data:`sys.stderr`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:166
|
||
msgid "Class hierarchy"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:168
|
||
msgid ""
|
||
"The implementation of I/O streams is organized as a hierarchy of classes. "
|
||
"First :term:`abstract base classes <abstract base class>` (ABCs), which are "
|
||
"used to specify the various categories of streams, then concrete classes "
|
||
"providing the standard stream implementations."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:175
|
||
msgid ""
|
||
"The abstract base classes also provide default implementations of some "
|
||
"methods in order to help implementation of concrete stream classes. For "
|
||
"example, :class:`BufferedIOBase` provides unoptimized implementations of :"
|
||
"meth:`~IOBase.readinto` and :meth:`~IOBase.readline`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:180
|
||
msgid ""
|
||
"At the top of the I/O hierarchy is the abstract base class :class:`IOBase`. "
|
||
"It defines the basic interface to a stream. Note, however, that there is no "
|
||
"separation between reading and writing to streams; implementations are "
|
||
"allowed to raise :exc:`UnsupportedOperation` if they do not support a given "
|
||
"operation."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:185
|
||
msgid ""
|
||
"The :class:`RawIOBase` ABC extends :class:`IOBase`. It deals with the "
|
||
"reading and writing of bytes to a stream. :class:`FileIO` subclasses :class:"
|
||
"`RawIOBase` to provide an interface to files in the machine's file system."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:189
|
||
msgid ""
|
||
"The :class:`BufferedIOBase` ABC extends :class:`IOBase`. It deals with "
|
||
"buffering on a raw binary stream (:class:`RawIOBase`). Its subclasses, :"
|
||
"class:`BufferedWriter`, :class:`BufferedReader`, and :class:`BufferedRWPair` "
|
||
"buffer raw binary streams that are readable, writable, and both readable and "
|
||
"writable, respectively. :class:`BufferedRandom` provides a buffered "
|
||
"interface to seekable streams. Another :class:`BufferedIOBase` subclass, :"
|
||
"class:`BytesIO`, is a stream of in-memory bytes."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:197
|
||
msgid ""
|
||
"The :class:`TextIOBase` ABC extends :class:`IOBase`. It deals with streams "
|
||
"whose bytes represent text, and handles encoding and decoding to and from "
|
||
"strings. :class:`TextIOWrapper`, which extends :class:`TextIOBase`, is a "
|
||
"buffered text interface to a buffered raw stream (:class:`BufferedIOBase`). "
|
||
"Finally, :class:`StringIO` is an in-memory stream for text."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:203
|
||
msgid ""
|
||
"Argument names are not part of the specification, and only the arguments of :"
|
||
"func:`open` are intended to be used as keyword arguments."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:206
|
||
msgid ""
|
||
"The following table summarizes the ABCs provided by the :mod:`io` module:"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:211
|
||
msgid "ABC"
|
||
msgstr "ABC"
|
||
|
||
#: library/io.rst:211
|
||
msgid "Inherits"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:211
|
||
msgid "Stub Methods"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:211
|
||
msgid "Mixin Methods and Properties"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:218 library/io.rst:222
|
||
msgid ":class:`IOBase`"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:213
|
||
msgid "``fileno``, ``seek``, and ``truncate``"
|
||
msgstr "``fileno``, ``seek``, et ``truncate``"
|
||
|
||
#: library/io.rst:213
|
||
msgid ""
|
||
"``close``, ``closed``, ``__enter__``, ``__exit__``, ``flush``, ``isatty``, "
|
||
"``__iter__``, ``__next__``, ``readable``, ``readline``, ``readlines``, "
|
||
"``seekable``, ``tell``, ``writable``, and ``writelines``"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:218
|
||
msgid ":class:`RawIOBase`"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:218
|
||
msgid "``readinto`` and ``write``"
|
||
msgstr "``readinto`` et ``write``"
|
||
|
||
#: library/io.rst:218
|
||
msgid "Inherited :class:`IOBase` methods, ``read``, and ``readall``"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:220
|
||
msgid ":class:`BufferedIOBase`"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:220
|
||
msgid "``detach``, ``read``, ``read1``, and ``write``"
|
||
msgstr "``detach``, ``read``, ``read1``, et ``write``"
|
||
|
||
#: library/io.rst:220
|
||
msgid "Inherited :class:`IOBase` methods, ``readinto``, and ``readinto1``"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:222
|
||
msgid ":class:`TextIOBase`"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:222
|
||
msgid "``detach``, ``read``, ``readline``, and ``write``"
|
||
msgstr "``detach``, ``read``, ``readline``, et ``write``"
|
||
|
||
#: library/io.rst:222
|
||
msgid ""
|
||
"Inherited :class:`IOBase` methods, ``encoding``, ``errors``, and ``newlines``"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:229
|
||
msgid "I/O Base Classes"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:233
|
||
msgid ""
|
||
"The abstract base class for all I/O classes, acting on streams of bytes. "
|
||
"There is no public constructor."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:236
|
||
msgid ""
|
||
"This class provides empty abstract implementations for many methods that "
|
||
"derived classes can override selectively; the default implementations "
|
||
"represent a file that cannot be read, written or seeked."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:241
|
||
msgid ""
|
||
"Even though :class:`IOBase` does not declare :meth:`read` or :meth:`write` "
|
||
"because their signatures will vary, implementations and clients should "
|
||
"consider those methods part of the interface. Also, implementations may "
|
||
"raise a :exc:`ValueError` (or :exc:`UnsupportedOperation`) when operations "
|
||
"they do not support are called."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:247
|
||
msgid ""
|
||
"The basic type used for binary data read from or written to a file is :class:"
|
||
"`bytes`. Other :term:`bytes-like objects <bytes-like object>` are accepted "
|
||
"as method arguments too. Text I/O classes work with :class:`str` data."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:251
|
||
msgid ""
|
||
"Note that calling any method (even inquiries) on a closed stream is "
|
||
"undefined. Implementations may raise :exc:`ValueError` in this case."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:254
|
||
msgid ""
|
||
":class:`IOBase` (and its subclasses) supports the iterator protocol, meaning "
|
||
"that an :class:`IOBase` object can be iterated over yielding the lines in a "
|
||
"stream. Lines are defined slightly differently depending on whether the "
|
||
"stream is a binary stream (yielding bytes), or a text stream (yielding "
|
||
"character strings). See :meth:`~IOBase.readline` below."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:260
|
||
msgid ""
|
||
":class:`IOBase` is also a context manager and therefore supports the :"
|
||
"keyword:`with` statement. In this example, *file* is closed after the :"
|
||
"keyword:`!with` statement's suite is finished---even if an exception occurs::"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:267
|
||
msgid ":class:`IOBase` provides these data attributes and methods:"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:271
|
||
msgid ""
|
||
"Flush and close this stream. This method has no effect if the file is "
|
||
"already closed. Once the file is closed, any operation on the file (e.g. "
|
||
"reading or writing) will raise a :exc:`ValueError`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:275
|
||
msgid ""
|
||
"As a convenience, it is allowed to call this method more than once; only the "
|
||
"first call, however, will have an effect."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:280
|
||
msgid "``True`` if the stream is closed."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:284
|
||
msgid ""
|
||
"Return the underlying file descriptor (an integer) of the stream if it "
|
||
"exists. An :exc:`OSError` is raised if the IO object does not use a file "
|
||
"descriptor."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:290
|
||
msgid ""
|
||
"Flush the write buffers of the stream if applicable. This does nothing for "
|
||
"read-only and non-blocking streams."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:295
|
||
msgid ""
|
||
"Return ``True`` if the stream is interactive (i.e., connected to a terminal/"
|
||
"tty device)."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:300
|
||
msgid ""
|
||
"Return ``True`` if the stream can be read from. If ``False``, :meth:`read` "
|
||
"will raise :exc:`OSError`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:305
|
||
msgid ""
|
||
"Read and return one line from the stream. If *size* is specified, at most "
|
||
"*size* bytes will be read."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:308
|
||
msgid ""
|
||
"The line terminator is always ``b'\\n'`` for binary files; for text files, "
|
||
"the *newline* argument to :func:`open` can be used to select the line "
|
||
"terminator(s) recognized."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:314
|
||
msgid ""
|
||
"Read and return a list of lines from the stream. *hint* can be specified to "
|
||
"control the number of lines read: no more lines will be read if the total "
|
||
"size (in bytes/characters) of all lines so far exceeds *hint*."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:318
|
||
msgid ""
|
||
"Note that it's already possible to iterate on file objects using ``for line "
|
||
"in file: ...`` without calling ``file.readlines()``."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:323
|
||
msgid ""
|
||
"Change the stream position to the given byte *offset*. *offset* is "
|
||
"interpreted relative to the position indicated by *whence*. The default "
|
||
"value for *whence* is :data:`SEEK_SET`. Values for *whence* are:"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:327
|
||
msgid ""
|
||
":data:`SEEK_SET` or ``0`` -- start of the stream (the default); *offset* "
|
||
"should be zero or positive"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:329
|
||
msgid ""
|
||
":data:`SEEK_CUR` or ``1`` -- current stream position; *offset* may be "
|
||
"negative"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:331
|
||
msgid ""
|
||
":data:`SEEK_END` or ``2`` -- end of the stream; *offset* is usually negative"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:334
|
||
msgid "Return the new absolute position."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:847
|
||
msgid "The ``SEEK_*`` constants."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:339
|
||
msgid ""
|
||
"Some operating systems could support additional values, like :data:`os."
|
||
"SEEK_HOLE` or :data:`os.SEEK_DATA`. The valid values for a file could depend "
|
||
"on it being open in text or binary mode."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:346
|
||
msgid ""
|
||
"Return ``True`` if the stream supports random access. If ``False``, :meth:"
|
||
"`seek`, :meth:`tell` and :meth:`truncate` will raise :exc:`OSError`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:351
|
||
msgid "Return the current stream position."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:355
|
||
msgid ""
|
||
"Resize the stream to the given *size* in bytes (or the current position if "
|
||
"*size* is not specified). The current stream position isn't changed. This "
|
||
"resizing can extend or reduce the current file size. In case of extension, "
|
||
"the contents of the new file area depend on the platform (on most systems, "
|
||
"additional bytes are zero-filled). The new file size is returned."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:362
|
||
msgid "Windows will now zero-fill files when extending."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:367
|
||
msgid ""
|
||
"Return ``True`` if the stream supports writing. If ``False``, :meth:`write` "
|
||
"and :meth:`truncate` will raise :exc:`OSError`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:372
|
||
msgid ""
|
||
"Write a list of lines to the stream. Line separators are not added, so it "
|
||
"is usual for each of the lines provided to have a line separator at the end."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:378
|
||
msgid ""
|
||
"Prepare for object destruction. :class:`IOBase` provides a default "
|
||
"implementation of this method that calls the instance's :meth:`~IOBase."
|
||
"close` method."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:385
|
||
msgid ""
|
||
"Base class for raw binary streams. It inherits :class:`IOBase`. There is "
|
||
"no public constructor."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:388
|
||
msgid ""
|
||
"Raw binary streams typically provide low-level access to an underlying OS "
|
||
"device 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 later in this page)."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:393
|
||
msgid ""
|
||
":class:`RawIOBase` provides these methods in addition to those from :class:"
|
||
"`IOBase`:"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:398
|
||
msgid ""
|
||
"Read up to *size* bytes from the object and return them. As a convenience, "
|
||
"if *size* is unspecified or -1, all bytes until EOF are returned. Otherwise, "
|
||
"only one system call is ever made. Fewer than *size* bytes may be returned "
|
||
"if the operating system call returns fewer than *size* bytes."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:403
|
||
msgid ""
|
||
"If 0 bytes are returned, and *size* was not 0, this indicates end of file. "
|
||
"If the object is in non-blocking mode and no bytes are available, ``None`` "
|
||
"is returned."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:407
|
||
msgid ""
|
||
"The default implementation defers to :meth:`readall` and :meth:`readinto`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:412
|
||
msgid ""
|
||
"Read and return all the bytes from the stream until EOF, using multiple "
|
||
"calls to the stream if necessary."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:417
|
||
msgid ""
|
||
"Read bytes into a pre-allocated, writable :term:`bytes-like object` *b*, and "
|
||
"return the number of bytes read. For example, *b* might be a :class:"
|
||
"`bytearray`. If the object is in non-blocking mode and no bytes are "
|
||
"available, ``None`` is returned."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:425
|
||
msgid ""
|
||
"Write the given :term:`bytes-like object`, *b*, to the underlying raw "
|
||
"stream, and return the number of bytes written. This can be less than the "
|
||
"length of *b* in bytes, depending on specifics of the underlying raw stream, "
|
||
"and especially if it is in non-blocking mode. ``None`` is returned if the "
|
||
"raw stream is set not to block and no single byte could be readily written "
|
||
"to it. The caller may release or mutate *b* after this method returns, so "
|
||
"the implementation should only access *b* during the method call."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:438
|
||
msgid ""
|
||
"Base class for binary streams that support some kind of buffering. It "
|
||
"inherits :class:`IOBase`. There is no public constructor."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:441
|
||
msgid ""
|
||
"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."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:446
|
||
msgid ""
|
||
"In addition, those methods can raise :exc:`BlockingIOError` if the "
|
||
"underlying raw stream is in non-blocking mode and cannot take or give enough "
|
||
"data; unlike their :class:`RawIOBase` counterparts, they will never return "
|
||
"``None``."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:451
|
||
msgid ""
|
||
"Besides, the :meth:`read` method does not have a default implementation that "
|
||
"defers to :meth:`readinto`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:454
|
||
msgid ""
|
||
"A typical :class:`BufferedIOBase` implementation should not inherit from a :"
|
||
"class:`RawIOBase` implementation, but wrap one, like :class:`BufferedWriter` "
|
||
"and :class:`BufferedReader` do."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:458
|
||
msgid ""
|
||
":class:`BufferedIOBase` provides or overrides these data attributes and "
|
||
"methods in addition to those from :class:`IOBase`:"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:463
|
||
msgid ""
|
||
"The underlying raw stream (a :class:`RawIOBase` instance) that :class:"
|
||
"`BufferedIOBase` deals with. This is not part of the :class:"
|
||
"`BufferedIOBase` API and may not exist on some implementations."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:469
|
||
msgid "Separate the underlying raw stream from the buffer and return it."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:471
|
||
msgid ""
|
||
"After the raw stream has been detached, the buffer is in an unusable state."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:474
|
||
msgid ""
|
||
"Some buffers, like :class:`BytesIO`, do not have the concept of a single raw "
|
||
"stream to return from this method. They raise :exc:`UnsupportedOperation`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:482
|
||
msgid ""
|
||
"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."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:486
|
||
msgid ""
|
||
"If the argument is positive, and the underlying raw stream is not "
|
||
"interactive, multiple raw reads may be issued to satisfy the byte count "
|
||
"(unless EOF is reached first). But for interactive raw streams, at most one "
|
||
"raw read will be issued, and a short result does not imply that EOF is "
|
||
"imminent."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:515 library/io.rst:525
|
||
msgid ""
|
||
"A :exc:`BlockingIOError` is raised if the underlying raw stream is in non "
|
||
"blocking-mode, and has no data available at the moment."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:497
|
||
msgid ""
|
||
"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."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:503
|
||
msgid ""
|
||
"If *size* is ``-1`` (the default), an arbitrary number of bytes are returned "
|
||
"(more than zero unless EOF is reached)."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:508
|
||
msgid ""
|
||
"Read bytes into a pre-allocated, writable :term:`bytes-like object` *b* and "
|
||
"return the number of bytes read. For example, *b* might be a :class:"
|
||
"`bytearray`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:512
|
||
msgid ""
|
||
"Like :meth:`read`, multiple reads may be issued to the underlying raw "
|
||
"stream, unless the latter is interactive."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:520
|
||
msgid ""
|
||
"Read bytes into a pre-allocated, writable :term:`bytes-like object` *b*, "
|
||
"using at most one call to the underlying raw stream's :meth:`~RawIOBase."
|
||
"read` (or :meth:`~RawIOBase.readinto`) method. Return the number of bytes "
|
||
"read."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:532
|
||
msgid ""
|
||
"Write the given :term:`bytes-like object`, *b*, and return the number of "
|
||
"bytes written (always equal to the length of *b* in bytes, since if the "
|
||
"write fails an :exc:`OSError` will be raised). Depending on the actual "
|
||
"implementation, these bytes may be readily written to the underlying stream, "
|
||
"or held in a buffer for performance and latency reasons."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:539
|
||
msgid ""
|
||
"When in non-blocking mode, a :exc:`BlockingIOError` is raised if the data "
|
||
"needed to be written to the raw stream but it couldn't accept all the data "
|
||
"without blocking."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:543
|
||
msgid ""
|
||
"The caller may release or mutate *b* after this method returns, so the "
|
||
"implementation should only access *b* during the method call."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:548
|
||
msgid "Raw File I/O"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:552
|
||
msgid ""
|
||
"A raw binary stream representing an OS-level file containing bytes data. It "
|
||
"inherits :class:`RawIOBase`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:555
|
||
msgid "The *name* can be one of two things:"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:557
|
||
msgid ""
|
||
"a character string or :class:`bytes` object representing the path to the "
|
||
"file which will be opened. In this case closefd must be ``True`` (the "
|
||
"default) otherwise an error will be raised."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:560
|
||
msgid ""
|
||
"an integer representing the number of an existing OS-level file descriptor "
|
||
"to which the resulting :class:`FileIO` object will give access. When the "
|
||
"FileIO object is closed this fd will be closed as well, unless *closefd* is "
|
||
"set to ``False``."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:565
|
||
msgid ""
|
||
"The *mode* can be ``'r'``, ``'w'``, ``'x'`` or ``'a'`` for reading "
|
||
"(default), writing, exclusive creation or appending. The file will be "
|
||
"created if it doesn't exist when opened for writing or appending; it will be "
|
||
"truncated when opened for writing. :exc:`FileExistsError` will be raised if "
|
||
"it already exists when opened for creating. Opening a file for creating "
|
||
"implies writing, so this mode behaves in a similar way to ``'w'``. Add a "
|
||
"``'+'`` to the mode to allow simultaneous reading and writing."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:573
|
||
msgid ""
|
||
"The :meth:`read` (when called with a positive argument), :meth:`readinto` "
|
||
"and :meth:`write` methods on this class will only make one system call."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:576
|
||
msgid ""
|
||
"A custom opener can be used by passing a callable as *opener*. The "
|
||
"underlying file descriptor for the file object is then obtained by calling "
|
||
"*opener* with (*name*, *flags*). *opener* must return an open file "
|
||
"descriptor (passing :mod:`os.open` as *opener* results in functionality "
|
||
"similar to passing ``None``)."
|
||
msgstr ""
|
||
"Un *opener* personnalisé peut être utilisé en fournissant un appelable à "
|
||
"*opener*. Le descripteur de fichier de cet objet fichier sera alors obtenu "
|
||
"en appelant *opener* avec (*file*, *flags*). *opener* doit donner un "
|
||
"descripteur de fichier ouvert (fournir :mod:`os.open` en temps qu'*opener* "
|
||
"aura le même effet que donner ``None``)."
|
||
|
||
#: library/io.rst:582
|
||
msgid "The newly created file is :ref:`non-inheritable <fd_inheritance>`."
|
||
msgstr ""
|
||
"Il n'est :ref:`pas possible d'hériter du fichier <fd_inheritance>` "
|
||
"nouvellement créé."
|
||
|
||
#: library/io.rst:584
|
||
msgid ""
|
||
"See the :func:`open` built-in function for examples on using the *opener* "
|
||
"parameter."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:587
|
||
msgid "The *opener* parameter was added. The ``'x'`` mode was added."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:591
|
||
msgid "The file is now non-inheritable."
|
||
msgstr "Il n'est plus possible d'hériter de *file*."
|
||
|
||
#: library/io.rst:594
|
||
msgid ""
|
||
":class:`FileIO` provides these data attributes in addition to those from :"
|
||
"class:`RawIOBase` and :class:`IOBase`:"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:599
|
||
msgid "The mode as given in the constructor."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:603
|
||
msgid ""
|
||
"The file name. This is the file descriptor of the file when no name is "
|
||
"given in the constructor."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:608
|
||
msgid "Buffered Streams"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:610
|
||
msgid ""
|
||
"Buffered I/O streams provide a higher-level interface to an I/O device than "
|
||
"raw I/O does."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:615
|
||
msgid ""
|
||
"A binary stream using an in-memory bytes buffer. It inherits :class:"
|
||
"`BufferedIOBase`. The buffer is discarded when the :meth:`~IOBase.close` "
|
||
"method is called."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:619
|
||
msgid ""
|
||
"The optional argument *initial_bytes* is a :term:`bytes-like object` that "
|
||
"contains initial data."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:622
|
||
msgid ""
|
||
":class:`BytesIO` provides or overrides these methods in addition to those "
|
||
"from :class:`BufferedIOBase` and :class:`IOBase`:"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:627
|
||
msgid ""
|
||
"Return a readable and writable view over the contents of the buffer without "
|
||
"copying them. Also, mutating the view will transparently update the "
|
||
"contents of the buffer::"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:638
|
||
msgid ""
|
||
"As long as the view exists, the :class:`BytesIO` object cannot be resized or "
|
||
"closed."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:645
|
||
msgid "Return :class:`bytes` containing the entire contents of the buffer."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:650
|
||
msgid "In :class:`BytesIO`, this is the same as :meth:`~BufferedIOBase.read`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:695
|
||
msgid "The *size* argument is now optional."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:657
|
||
msgid ""
|
||
"In :class:`BytesIO`, this is the same as :meth:`~BufferedIOBase.readinto`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:663
|
||
msgid ""
|
||
"A buffered binary stream providing higher-level access to a readable, non "
|
||
"seekable :class:`RawIOBase` raw binary stream. It inherits :class:"
|
||
"`BufferedIOBase`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:667
|
||
msgid ""
|
||
"When reading data from this object, a larger amount of data may be requested "
|
||
"from the underlying raw stream, and kept in an internal buffer. The buffered "
|
||
"data can then be returned directly on subsequent reads."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:671
|
||
msgid ""
|
||
"The constructor creates a :class:`BufferedReader` for the given readable "
|
||
"*raw* stream and *buffer_size*. If *buffer_size* is omitted, :data:"
|
||
"`DEFAULT_BUFFER_SIZE` is used."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:675
|
||
msgid ""
|
||
":class:`BufferedReader` provides or overrides these methods in addition to "
|
||
"those from :class:`BufferedIOBase` and :class:`IOBase`:"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:680
|
||
msgid ""
|
||
"Return bytes from the stream without advancing the position. At most one "
|
||
"single read on the raw stream is done to satisfy the call. The number of "
|
||
"bytes returned may be less or more than requested."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:686
|
||
msgid ""
|
||
"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."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:691
|
||
msgid ""
|
||
"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."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:701
|
||
msgid ""
|
||
"A buffered binary stream providing higher-level access to a writeable, non "
|
||
"seekable :class:`RawIOBase` raw binary stream. It inherits :class:"
|
||
"`BufferedIOBase`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:705
|
||
msgid ""
|
||
"When writing to this object, data is normally placed into an internal "
|
||
"buffer. The buffer will be written out to the underlying :class:`RawIOBase` "
|
||
"object under various conditions, including:"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:709
|
||
msgid "when the buffer gets too small for all pending data;"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:710
|
||
msgid "when :meth:`flush()` is called;"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:711
|
||
msgid ""
|
||
"when a :meth:`seek()` is requested (for :class:`BufferedRandom` objects);"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:712
|
||
msgid "when the :class:`BufferedWriter` object is closed or destroyed."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:714
|
||
msgid ""
|
||
"The constructor creates a :class:`BufferedWriter` for the given writeable "
|
||
"*raw* stream. If the *buffer_size* is not given, it defaults to :data:"
|
||
"`DEFAULT_BUFFER_SIZE`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:718
|
||
msgid ""
|
||
":class:`BufferedWriter` provides or overrides these methods in addition to "
|
||
"those from :class:`BufferedIOBase` and :class:`IOBase`:"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:723
|
||
msgid ""
|
||
"Force bytes held in the buffer into the raw stream. A :exc:"
|
||
"`BlockingIOError` should be raised if the raw stream blocks."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:728
|
||
msgid ""
|
||
"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."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:736
|
||
msgid ""
|
||
"A buffered binary stream providing higher-level access to a seekable :class:"
|
||
"`RawIOBase` raw binary stream. It inherits :class:`BufferedReader` and :"
|
||
"class:`BufferedWriter`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:740
|
||
msgid ""
|
||
"The constructor creates a reader and writer for a seekable raw stream, given "
|
||
"in the first argument. If the *buffer_size* is omitted it defaults to :data:"
|
||
"`DEFAULT_BUFFER_SIZE`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:744
|
||
msgid ""
|
||
":class:`BufferedRandom` is capable of anything :class:`BufferedReader` or :"
|
||
"class:`BufferedWriter` can do. In addition, :meth:`seek` and :meth:`tell` "
|
||
"are guaranteed to be implemented."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:751
|
||
msgid ""
|
||
"A buffered binary stream providing higher-level access to two non seekable :"
|
||
"class:`RawIOBase` raw binary streams---one readable, the other writeable. It "
|
||
"inherits :class:`BufferedIOBase`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:755
|
||
msgid ""
|
||
"*reader* and *writer* are :class:`RawIOBase` objects that are readable and "
|
||
"writeable respectively. If the *buffer_size* is omitted it defaults to :"
|
||
"data:`DEFAULT_BUFFER_SIZE`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:759
|
||
msgid ""
|
||
":class:`BufferedRWPair` implements all of :class:`BufferedIOBase`\\'s "
|
||
"methods except for :meth:`~BufferedIOBase.detach`, which raises :exc:"
|
||
"`UnsupportedOperation`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:765
|
||
msgid ""
|
||
":class:`BufferedRWPair` does not attempt to synchronize accesses to its "
|
||
"underlying raw streams. You should not pass it the same object as reader "
|
||
"and writer; use :class:`BufferedRandom` instead."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:775
|
||
msgid ""
|
||
"Base class for text streams. This class provides a character and line based "
|
||
"interface to stream I/O. It inherits :class:`IOBase`. There is no public "
|
||
"constructor."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:779
|
||
msgid ""
|
||
":class:`TextIOBase` provides or overrides these data attributes and methods "
|
||
"in addition to those from :class:`IOBase`:"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:784
|
||
msgid ""
|
||
"The name of the encoding used to decode the stream's bytes into strings, and "
|
||
"to encode strings into bytes."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:789
|
||
msgid "The error setting of the decoder or encoder."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:793
|
||
msgid ""
|
||
"A string, a tuple of strings, or ``None``, indicating the newlines "
|
||
"translated so far. Depending on the implementation and the initial "
|
||
"constructor flags, this may not be available."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:799
|
||
msgid ""
|
||
"The underlying binary buffer (a :class:`BufferedIOBase` instance) that :"
|
||
"class:`TextIOBase` deals with. This is not part of the :class:`TextIOBase` "
|
||
"API and may not exist in some implementations."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:805
|
||
msgid ""
|
||
"Separate the underlying binary buffer from the :class:`TextIOBase` and "
|
||
"return it."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:808
|
||
msgid ""
|
||
"After the underlying buffer has been detached, the :class:`TextIOBase` is in "
|
||
"an unusable state."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:811
|
||
msgid ""
|
||
"Some :class:`TextIOBase` implementations, like :class:`StringIO`, may not "
|
||
"have the concept of an underlying buffer and calling this method will raise :"
|
||
"exc:`UnsupportedOperation`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:819
|
||
msgid ""
|
||
"Read and return at most *size* characters from the stream as a single :class:"
|
||
"`str`. If *size* is negative or ``None``, reads until EOF."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:824
|
||
msgid ""
|
||
"Read until newline or EOF and return a single ``str``. If the stream is "
|
||
"already at EOF, an empty string is returned."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:827
|
||
msgid "If *size* is specified, at most *size* characters will be read."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:831
|
||
msgid ""
|
||
"Change the stream position to the given *offset*. Behaviour depends on the "
|
||
"*whence* parameter. The default value for *whence* is :data:`SEEK_SET`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:835
|
||
msgid ""
|
||
":data:`SEEK_SET` or ``0``: seek from the start of the stream (the default); "
|
||
"*offset* must either be a number returned by :meth:`TextIOBase.tell`, or "
|
||
"zero. Any other *offset* value produces undefined behaviour."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:839
|
||
msgid ""
|
||
":data:`SEEK_CUR` or ``1``: \"seek\" to the current position; *offset* must "
|
||
"be zero, which is a no-operation (all other values are unsupported)."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:842
|
||
msgid ""
|
||
":data:`SEEK_END` or ``2``: seek to the end of the stream; *offset* must be "
|
||
"zero (all other values are unsupported)."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:845
|
||
msgid "Return the new absolute position as an opaque number."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:852
|
||
msgid ""
|
||
"Return the current stream position as an opaque number. The number does not "
|
||
"usually represent a number of bytes in the underlying binary storage."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:858
|
||
msgid ""
|
||
"Write the string *s* to the stream and return the number of characters "
|
||
"written."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:865
|
||
msgid ""
|
||
"A buffered text stream providing higher-level access to a :class:"
|
||
"`BufferedIOBase` buffered binary stream. It inherits :class:`TextIOBase`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:869
|
||
msgid ""
|
||
"*encoding* gives the name of the encoding that the stream will be decoded or "
|
||
"encoded with. It defaults to :func:`locale.getpreferredencoding(False) "
|
||
"<locale.getpreferredencoding>`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:873
|
||
msgid ""
|
||
"*errors* is an optional string that specifies how encoding and decoding "
|
||
"errors are to be handled. Pass ``'strict'`` to raise a :exc:`ValueError` "
|
||
"exception if there is an encoding error (the default of ``None`` has the "
|
||
"same effect), or pass ``'ignore'`` to ignore errors. (Note that ignoring "
|
||
"encoding errors 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 a backslashed "
|
||
"escape sequence. When writing, ``'xmlcharrefreplace'`` (replace with the "
|
||
"appropriate XML character reference) or ``'namereplace'`` (replace with ``"
|
||
"\\N{...}`` escape sequences) can be used. Any other error handling name "
|
||
"that has been registered with :func:`codecs.register_error` is also valid."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:889
|
||
msgid ""
|
||
"*newline* controls how line endings are handled. It can be ``None``, "
|
||
"``''``, ``'\\n'``, ``'\\r'``, and ``'\\r\\n'``. It works as follows:"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:892
|
||
#, fuzzy
|
||
msgid ""
|
||
"When reading input from the stream, if *newline* is ``None``, :term:"
|
||
"`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. If *newline* is ``''``, "
|
||
"universal newlines mode is enabled, but line endings are returned to the "
|
||
"caller untranslated. If *newline* has any of the other legal values, input "
|
||
"lines are only terminated by the given string, and the line ending is "
|
||
"returned to the caller untranslated."
|
||
msgstr ""
|
||
"Lors de la lecture, si *newline* est ``None``, le mode :term:`universal "
|
||
"newlines` est activé. Les lignes lues peuvent terminer par ``'\\n'``, "
|
||
"``'\\r'``, ou ``'\\r\\n'``, qui sont remplacés par ``'\\n'``, avant d'être "
|
||
"données à l'appelant. S'il vaut ``''``, le mode *universal newline* est "
|
||
"activé mais les fin de lignes ne sont pas remplacés. S'il a n'importe quel "
|
||
"autre valeur autorisée, les lignes sont seulement terminées par la chaîne "
|
||
"donnée, qui est rendue tel qu'elle."
|
||
|
||
#: library/io.rst:901
|
||
msgid ""
|
||
"When writing output to the stream, if *newline* is ``None``, any ``'\\n'`` "
|
||
"characters written are translated to the system default line separator, :"
|
||
"data:`os.linesep`. If *newline* is ``''`` or ``'\\n'``, no translation "
|
||
"takes place. If *newline* is any of the other legal values, any ``'\\n'`` "
|
||
"characters written are translated to the given string."
|
||
msgstr ""
|
||
"Lors de l'écriture, si *newline* est ``None``, chaque ``'\\n'`` est remplacé "
|
||
"par le séparateur de lignes par défaut du système :data:`os.linesep`. Si "
|
||
"*newline* est ``*`` ou ``'\\n'`` aucun remplacent n'est effectué. Si "
|
||
"*newline* est un autre caractère valide, chaque ``'\\n'`` sera remplacé par "
|
||
"la chaîne donnée."
|
||
|
||
#: library/io.rst:907
|
||
msgid ""
|
||
"If *line_buffering* is ``True``, :meth:`flush` is implied when a call to "
|
||
"write contains a newline character or a carriage return."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:910
|
||
msgid ""
|
||
"If *write_through* is ``True``, calls to :meth:`write` are guaranteed not to "
|
||
"be buffered: any data written on the :class:`TextIOWrapper` object is "
|
||
"immediately handled to its underlying binary *buffer*."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:914
|
||
msgid "The *write_through* argument has been added."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:917
|
||
msgid ""
|
||
"The default *encoding* is now ``locale.getpreferredencoding(False)`` instead "
|
||
"of ``locale.getpreferredencoding()``. Don't change temporary the locale "
|
||
"encoding using :func:`locale.setlocale`, use the current locale encoding "
|
||
"instead of the user preferred encoding."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:923
|
||
msgid ""
|
||
":class:`TextIOWrapper` provides these data attributes and methods in "
|
||
"addition to those from :class:`TextIOBase` and :class:`IOBase`:"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:928
|
||
msgid "Whether line buffering is enabled."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:932
|
||
msgid "Whether writes are passed immediately to the underlying binary buffer."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:940
|
||
msgid ""
|
||
"Reconfigure this text stream using new settings for *encoding*, *errors*, "
|
||
"*newline*, *line_buffering* and *write_through*."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:943
|
||
msgid ""
|
||
"Parameters not specified keep current settings, except ``errors='strict'`` "
|
||
"is used when *encoding* is specified but *errors* is not specified."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:947
|
||
msgid ""
|
||
"It is not possible to change the encoding or newline if some data has "
|
||
"already been read from the stream. On the other hand, changing encoding "
|
||
"after write is possible."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:951
|
||
msgid ""
|
||
"This method does an implicit stream flush before setting the new parameters."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:959
|
||
msgid ""
|
||
"A text stream using an in-memory text buffer. It inherits :class:"
|
||
"`TextIOBase`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:962
|
||
msgid ""
|
||
"The text buffer is discarded when the :meth:`~IOBase.close` method is called."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:965
|
||
msgid ""
|
||
"The initial value of the buffer can be set by providing *initial_value*. If "
|
||
"newline translation is enabled, newlines will be encoded as if by :meth:"
|
||
"`~TextIOBase.write`. The stream is positioned at the start of the buffer."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:970
|
||
msgid ""
|
||
"The *newline* argument works like that of :class:`TextIOWrapper`, except "
|
||
"that when writing output to the stream, if *newline* is ``None``, newlines "
|
||
"are written as ``\\n`` on all platforms."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:974
|
||
msgid ""
|
||
":class:`StringIO` provides this method in addition to those from :class:"
|
||
"`TextIOBase` and :class:`IOBase`:"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:979
|
||
msgid ""
|
||
"Return a ``str`` containing the entire contents of the buffer. Newlines are "
|
||
"decoded as if by :meth:`~TextIOBase.read`, although the stream position is "
|
||
"not changed."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:983
|
||
msgid "Example usage::"
|
||
msgstr "Exemple d'utilisation ::"
|
||
|
||
#: library/io.rst:1005
|
||
msgid ""
|
||
"A helper codec that decodes newlines for :term:`universal newlines` mode. It "
|
||
"inherits :class:`codecs.IncrementalDecoder`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:1010
|
||
msgid "Performance"
|
||
msgstr "Performances"
|
||
|
||
#: library/io.rst:1012
|
||
msgid ""
|
||
"This section discusses the performance of the provided concrete I/O "
|
||
"implementations."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:1018
|
||
msgid ""
|
||
"By reading and writing only large chunks of data even when the user asks for "
|
||
"a single byte, buffered I/O hides any inefficiency in calling and executing "
|
||
"the operating system's unbuffered I/O routines. The gain depends on the OS "
|
||
"and the kind 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 platform and the backing device. Therefore, it is almost "
|
||
"always preferable to use buffered I/O rather than unbuffered I/O for binary "
|
||
"data."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:1030
|
||
msgid ""
|
||
"Text I/O over a binary storage (such as a file) is significantly slower than "
|
||
"binary I/O over the same storage, because it requires conversions between "
|
||
"unicode and binary data using a character codec. This can become noticeable "
|
||
"handling huge amounts of text data like large log files. Also, :meth:"
|
||
"`TextIOWrapper.tell` and :meth:`TextIOWrapper.seek` are both quite slow due "
|
||
"to the reconstruction algorithm used."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:1037
|
||
msgid ""
|
||
":class:`StringIO`, however, is a native in-memory unicode container and will "
|
||
"exhibit similar speed to :class:`BytesIO`."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:1041
|
||
msgid "Multi-threading"
|
||
msgstr "Fils d'exécution"
|
||
|
||
#: library/io.rst:1043
|
||
msgid ""
|
||
":class:`FileIO` objects are thread-safe to the extent that the operating "
|
||
"system calls (such as ``read(2)`` under Unix) they wrap are thread-safe too."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:1046
|
||
msgid ""
|
||
"Binary buffered objects (instances of :class:`BufferedReader`, :class:"
|
||
"`BufferedWriter`, :class:`BufferedRandom` and :class:`BufferedRWPair`) "
|
||
"protect their internal structures using a lock; it is therefore safe to call "
|
||
"them from multiple threads at once."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:1051
|
||
msgid ":class:`TextIOWrapper` objects are not thread-safe."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:1054
|
||
msgid "Reentrancy"
|
||
msgstr ""
|
||
|
||
#: library/io.rst:1056
|
||
msgid ""
|
||
"Binary buffered objects (instances of :class:`BufferedReader`, :class:"
|
||
"`BufferedWriter`, :class:`BufferedRandom` and :class:`BufferedRWPair`) are "
|
||
"not reentrant. While reentrant calls will not happen in normal situations, "
|
||
"they can arise from doing I/O in a :mod:`signal` handler. If a thread tries "
|
||
"to re-enter a buffered object which it is already accessing, a :exc:"
|
||
"`RuntimeError` is raised. Note this doesn't prohibit a different thread "
|
||
"from entering the buffered object."
|
||
msgstr ""
|
||
|
||
#: library/io.rst:1064
|
||
msgid ""
|
||
"The above implicitly extends to text files, since the :func:`open()` "
|
||
"function will wrap a buffered object inside a :class:`TextIOWrapper`. This "
|
||
"includes standard streams and therefore affects the built-in :func:`print()` "
|
||
"function as well."
|
||
msgstr ""
|