From 66309f9360bc4f58f5002fc2a779bf0b7576180b Mon Sep 17 00:00:00 2001 From: "houedji.espoir" Date: Tue, 14 Nov 2023 22:57:31 +0100 Subject: [PATCH] =?UTF-8?q?traduction=20compl=C3=A9t=C3=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- library/io.po | 1487 +------------------------------------------------ 1 file changed, 3 insertions(+), 1484 deletions(-) diff --git a/library/io.po b/library/io.po index 51315fa3..2a12e8bc 100644 --- a/library/io.po +++ b/library/io.po @@ -6,7 +6,7 @@ msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-07-23 14:38+0200\n" -"PO-Revision-Date: 2023-11-14 22:29+0100\n" +"PO-Revision-Date: 2023-11-14 22:46+0100\n" "Last-Translator: Houedji Espoir \n" "Language-Team: FRENCH \n" "Language: fr\n" @@ -77,6 +77,8 @@ msgid "" "The easiest way to create a text stream is with :meth:`open()`, optionally " "specifying an encoding::" msgstr "" +"Le moyen le plus simple de créer un flux de texte est d'utiliser la méthode :" +"meth:`open()` en spécifiant éventuellement un encodage ::" #: library/io.rst:63 msgid "" @@ -116,1486 +118,3 @@ msgstr "" 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:112 -msgid "Text Encoding" -msgstr "Encodage de texte" - -#: library/io.rst:114 -msgid "" -"The default encoding of :class:`TextIOWrapper` and :func:`open` is locale-" -"specific (:func:`locale.getencoding`)." -msgstr "" - -#: library/io.rst:117 -msgid "" -"However, many developers forget to specify the encoding when opening text " -"files encoded in UTF-8 (e.g. JSON, TOML, Markdown, etc...) since most Unix " -"platforms use UTF-8 locale by default. This causes bugs because the locale " -"encoding is not UTF-8 for most Windows users. For example::" -msgstr "" - -#: library/io.rst:126 -msgid "" -"Accordingly, it is highly recommended that you specify the encoding " -"explicitly when opening text files. If you want to use UTF-8, pass " -"``encoding=\"utf-8\"``. To use the current locale encoding, " -"``encoding=\"locale\"`` is supported since Python 3.10." -msgstr "" - -#: library/io.rst:135 -msgid ":ref:`utf8-mode`" -msgstr "" - -#: library/io.rst:134 -msgid "" -"Python UTF-8 Mode can be used to change the default encoding to UTF-8 from " -"locale-specific encoding." -msgstr "" -"Le mode UTF-8 de Python peut être utilisé pour changer l'encodage par défaut " -"en UTF-8 à partir d'un encodage local spécifique." - -#: library/io.rst:137 -msgid ":pep:`686`" -msgstr "" - -#: library/io.rst:138 -msgid "Python 3.15 will make :ref:`utf8-mode` default." -msgstr "" - -#: library/io.rst:143 -msgid "Opt-in EncodingWarning" -msgstr "" - -#: library/io.rst:145 -msgid "See :pep:`597` for more details." -msgstr "" - -#: library/io.rst:148 -msgid "" -"To find where the default locale encoding is used, you can enable the ``-X " -"warn_default_encoding`` command line option or set the :envvar:" -"`PYTHONWARNDEFAULTENCODING` environment variable, which will emit an :exc:" -"`EncodingWarning` when the default encoding is used." -msgstr "" - -#: library/io.rst:153 -msgid "" -"If you are providing an API that uses :func:`open` or :class:`TextIOWrapper` " -"and passes ``encoding=None`` as a parameter, you can use :func:" -"`text_encoding` so that callers of the API will emit an :exc:" -"`EncodingWarning` if they don't pass an ``encoding``. However, please " -"consider using UTF-8 by default (i.e. ``encoding=\"utf-8\"``) for new APIs." -msgstr "" - -#: library/io.rst:162 -msgid "High-level Module Interface" -msgstr "Interface du module de haut niveau" - -#: library/io.rst:166 -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:173 -msgid "This is an alias for the builtin :func:`open` function." -msgstr "" - -#: library/io.rst:175 -msgid "" -"Raises an :ref:`auditing event ` ``open`` with arguments ``path``, " -"``mode``, ``flags``." -msgstr "" - -#: library/io.rst:177 -msgid "" -"This function raises an :ref:`auditing event ` ``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:184 -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:187 -msgid "``path`` should be a :class:`str` and an absolute path." -msgstr "" - -#: library/io.rst:189 -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:200 -msgid "" -"This is a helper function for callables that use :func:`open` or :class:" -"`TextIOWrapper` and have an ``encoding=None`` parameter." -msgstr "" - -#: library/io.rst:203 -msgid "" -"This function returns *encoding* if it is not ``None``. Otherwise, it " -"returns ``\"locale\"`` or ``\"utf-8\"`` depending on :ref:`UTF-8 Mode `." -msgstr "" - -#: library/io.rst:207 -msgid "" -"This function emits an :class:`EncodingWarning` if :data:`sys.flags." -"warn_default_encoding ` is true and *encoding* is ``None``. " -"*stacklevel* specifies where the warning is emitted. For example::" -msgstr "" - -#: library/io.rst:217 -msgid "" -"In this example, an :class:`EncodingWarning` is emitted for the caller of " -"``read_text()``." -msgstr "" - -#: library/io.rst:220 -msgid "See :ref:`io-text-encoding` for more information." -msgstr "" - -#: library/io.rst:224 -msgid "" -":func:`text_encoding` returns \"utf-8\" when UTF-8 mode is enabled and " -"*encoding* is ``None``." -msgstr "" - -#: library/io.rst:231 -msgid "" -"This is a compatibility alias for the builtin :exc:`BlockingIOError` " -"exception." -msgstr "" - -#: library/io.rst:237 -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:244 -msgid ":mod:`sys`" -msgstr ":mod:`sys`" - -#: library/io.rst:244 -msgid "" -"contains the standard IO streams: :data:`sys.stdin`, :data:`sys.stdout`, " -"and :data:`sys.stderr`." -msgstr "" - -#: library/io.rst:249 -msgid "Class hierarchy" -msgstr "" - -#: library/io.rst:251 -msgid "" -"The implementation of I/O streams is organized as a hierarchy of classes. " -"First :term:`abstract base classes ` (ABCs), which are " -"used to specify the various categories of streams, then concrete classes " -"providing the standard stream implementations." -msgstr "" - -#: library/io.rst:258 -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:263 -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:268 -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:272 -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 writable, readable, 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:280 -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:286 -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:289 -msgid "" -"The following table summarizes the ABCs provided by the :mod:`io` module:" -msgstr "" - -#: library/io.rst:294 -msgid "ABC" -msgstr "ABC" - -#: library/io.rst:294 -msgid "Inherits" -msgstr "" - -#: library/io.rst:294 -msgid "Stub Methods" -msgstr "" - -#: library/io.rst:294 -msgid "Mixin Methods and Properties" -msgstr "Méthodes et propriétés de Mixin" - -#: library/io.rst:301 library/io.rst:305 -msgid ":class:`IOBase`" -msgstr ":class:`IOBase`" - -#: library/io.rst:296 -msgid "``fileno``, ``seek``, and ``truncate``" -msgstr "``fileno``, ``seek``, et ``truncate``" - -#: library/io.rst:296 -msgid "" -"``close``, ``closed``, ``__enter__``, ``__exit__``, ``flush``, ``isatty``, " -"``__iter__``, ``__next__``, ``readable``, ``readline``, ``readlines``, " -"``seekable``, ``tell``, ``writable``, and ``writelines``" -msgstr "" - -#: library/io.rst:301 -msgid ":class:`RawIOBase`" -msgstr ":class:`RawIOBase`" - -#: library/io.rst:301 -msgid "``readinto`` and ``write``" -msgstr "``readinto`` et ``write``" - -#: library/io.rst:301 -msgid "Inherited :class:`IOBase` methods, ``read``, and ``readall``" -msgstr "" - -#: library/io.rst:303 -msgid ":class:`BufferedIOBase`" -msgstr ":class:`BufferedIOBase`" - -#: library/io.rst:303 -msgid "``detach``, ``read``, ``read1``, and ``write``" -msgstr "``detach``, ``read``, ``read1``, et ``write``" - -#: library/io.rst:303 -msgid "Inherited :class:`IOBase` methods, ``readinto``, and ``readinto1``" -msgstr "" - -#: library/io.rst:305 -msgid ":class:`TextIOBase`" -msgstr ":class:`TextIOBase`" - -#: library/io.rst:305 -msgid "``detach``, ``read``, ``readline``, and ``write``" -msgstr "``detach``, ``read``, ``readline``, et ``write``" - -#: library/io.rst:305 -msgid "" -"Inherited :class:`IOBase` methods, ``encoding``, ``errors``, and ``newlines``" -msgstr "" - -#: library/io.rst:312 -msgid "I/O Base Classes" -msgstr "" - -#: library/io.rst:316 -msgid "The abstract base class for all I/O classes." -msgstr "" - -#: library/io.rst:318 -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:323 -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:329 -msgid "" -"The basic type used for binary data read from or written to a file is :class:" -"`bytes`. Other :term:`bytes-like objects ` are accepted " -"as method arguments too. Text I/O classes work with :class:`str` data." -msgstr "" - -#: library/io.rst:333 -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:336 -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:342 -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:349 -msgid ":class:`IOBase` provides these data attributes and methods:" -msgstr "" - -#: library/io.rst:353 -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:357 -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:362 -msgid "``True`` if the stream is closed." -msgstr "" - -#: library/io.rst:366 -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:372 -msgid "" -"Flush the write buffers of the stream if applicable. This does nothing for " -"read-only and non-blocking streams." -msgstr "" - -#: library/io.rst:377 -msgid "" -"Return ``True`` if the stream is interactive (i.e., connected to a terminal/" -"tty device)." -msgstr "" - -#: library/io.rst:382 -msgid "" -"Return ``True`` if the stream can be read from. If ``False``, :meth:`read` " -"will raise :exc:`OSError`." -msgstr "" - -#: library/io.rst:387 -msgid "" -"Read and return one line from the stream. If *size* is specified, at most " -"*size* bytes will be read." -msgstr "" - -#: library/io.rst:390 -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:396 -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:400 -msgid "" -"*hint* values of ``0`` or less, as well as ``None``, are treated as no hint." -msgstr "" - -#: library/io.rst:403 -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:408 -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:412 -msgid "" -":data:`SEEK_SET` or ``0`` -- start of the stream (the default); *offset* " -"should be zero or positive" -msgstr "" - -#: library/io.rst:414 -msgid "" -":data:`SEEK_CUR` or ``1`` -- current stream position; *offset* may be " -"negative" -msgstr "" - -#: library/io.rst:416 -msgid "" -":data:`SEEK_END` or ``2`` -- end of the stream; *offset* is usually negative" -msgstr "" - -#: library/io.rst:419 -msgid "Return the new absolute position." -msgstr "" - -#: library/io.rst:930 -msgid "The ``SEEK_*`` constants." -msgstr "" - -#: library/io.rst:424 -msgid "" -"Some operating systems could support additional values, like :const:`os." -"SEEK_HOLE` or :const:`os.SEEK_DATA`. The valid values for a file could " -"depend on it being open in text or binary mode." -msgstr "" - -#: library/io.rst:431 -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:436 -msgid "Return the current stream position." -msgstr "" - -#: library/io.rst:440 -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:447 -msgid "Windows will now zero-fill files when extending." -msgstr "" - -#: library/io.rst:452 -msgid "" -"Return ``True`` if the stream supports writing. If ``False``, :meth:`write` " -"and :meth:`truncate` will raise :exc:`OSError`." -msgstr "" - -#: library/io.rst:457 -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:463 -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:470 -msgid "Base class for raw binary streams. It inherits :class:`IOBase`." -msgstr "" - -#: library/io.rst:472 -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:477 -msgid "" -":class:`RawIOBase` provides these methods in addition to those from :class:" -"`IOBase`:" -msgstr "" - -#: library/io.rst:482 -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:487 -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:491 -msgid "" -"The default implementation defers to :meth:`readall` and :meth:`readinto`." -msgstr "" - -#: library/io.rst:496 -msgid "" -"Read and return all the bytes from the stream until EOF, using multiple " -"calls to the stream if necessary." -msgstr "" - -#: library/io.rst:501 -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:509 -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:522 -msgid "" -"Base class for binary streams that support some kind of buffering. It " -"inherits :class:`IOBase`." -msgstr "" - -#: library/io.rst:525 -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:530 -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:535 -msgid "" -"Besides, the :meth:`read` method does not have a default implementation that " -"defers to :meth:`readinto`." -msgstr "" - -#: library/io.rst:538 -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:542 -msgid "" -":class:`BufferedIOBase` provides or overrides these data attributes and " -"methods in addition to those from :class:`IOBase`:" -msgstr "" -":class:`BufferedIOBase` fournit ou surchage ces attributs et méthodes en " -"plus de ceux de :class:`IOBase`:" - -#: library/io.rst:547 -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:553 -msgid "Separate the underlying raw stream from the buffer and return it." -msgstr "" - -#: library/io.rst:555 -msgid "" -"After the raw stream has been detached, the buffer is in an unusable state." -msgstr "" - -#: library/io.rst:558 -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:566 -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:570 -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:599 library/io.rst:609 -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:581 -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:587 -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:592 -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:596 -msgid "" -"Like :meth:`read`, multiple reads may be issued to the underlying raw " -"stream, unless the latter is interactive." -msgstr "" - -#: library/io.rst:604 -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:616 -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:623 -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:627 -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:632 -msgid "Raw File I/O" -msgstr "" - -#: library/io.rst:636 -msgid "" -"A raw binary stream representing an OS-level file containing bytes data. It " -"inherits :class:`RawIOBase`." -msgstr "" - -#: library/io.rst:639 -msgid "The *name* can be one of two things:" -msgstr "" - -#: library/io.rst:641 -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:644 -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:649 -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:657 -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:660 -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:666 -msgid "The newly created file is :ref:`non-inheritable `." -msgstr "" -"Il n'est :ref:`pas possible d'hériter du fichier ` " -"nouvellement créé." - -#: library/io.rst:668 -msgid "" -"See the :func:`open` built-in function for examples on using the *opener* " -"parameter." -msgstr "" - -#: library/io.rst:671 -msgid "The *opener* parameter was added. The ``'x'`` mode was added." -msgstr "" - -#: library/io.rst:675 -msgid "The file is now non-inheritable." -msgstr "Il n'est plus possible d'hériter de *file*." - -#: library/io.rst:678 -msgid "" -":class:`FileIO` provides these data attributes in addition to those from :" -"class:`RawIOBase` and :class:`IOBase`:" -msgstr "" - -#: library/io.rst:683 -msgid "The mode as given in the constructor." -msgstr "" - -#: library/io.rst:687 -msgid "" -"The file name. This is the file descriptor of the file when no name is " -"given in the constructor." -msgstr "" -"Le nom du fichier. C'est le descripteur du fichier lorsqu'aucun nom n'est " -"donné dans le constructeur." - -#: library/io.rst:692 -msgid "Buffered Streams" -msgstr "" - -#: library/io.rst:694 -msgid "" -"Buffered I/O streams provide a higher-level interface to an I/O device than " -"raw I/O does." -msgstr "" - -#: library/io.rst:699 -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:703 -msgid "" -"The optional argument *initial_bytes* is a :term:`bytes-like object` that " -"contains initial data." -msgstr "" - -#: library/io.rst:706 -msgid "" -":class:`BytesIO` provides or overrides these methods in addition to those " -"from :class:`BufferedIOBase` and :class:`IOBase`:" -msgstr "" - -#: library/io.rst:711 -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:722 -msgid "" -"As long as the view exists, the :class:`BytesIO` object cannot be resized or " -"closed." -msgstr "" - -#: library/io.rst:729 -msgid "Return :class:`bytes` containing the entire contents of the buffer." -msgstr "" - -#: library/io.rst:734 -msgid "In :class:`BytesIO`, this is the same as :meth:`~BufferedIOBase.read`." -msgstr "" - -#: library/io.rst:779 -msgid "The *size* argument is now optional." -msgstr "" - -#: library/io.rst:741 -msgid "" -"In :class:`BytesIO`, this is the same as :meth:`~BufferedIOBase.readinto`." -msgstr "" - -#: library/io.rst:747 -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:751 -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:755 -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:759 -msgid "" -":class:`BufferedReader` provides or overrides these methods in addition to " -"those from :class:`BufferedIOBase` and :class:`IOBase`:" -msgstr "" - -#: library/io.rst:764 -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:770 -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:775 -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:785 -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:789 -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:793 -msgid "when the buffer gets too small for all pending data;" -msgstr "" - -#: library/io.rst:794 -msgid "when :meth:`flush()` is called;" -msgstr "" - -#: library/io.rst:795 -msgid "" -"when a :meth:`seek()` is requested (for :class:`BufferedRandom` objects);" -msgstr "" - -#: library/io.rst:796 -msgid "when the :class:`BufferedWriter` object is closed or destroyed." -msgstr "" - -#: library/io.rst:798 -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:802 -msgid "" -":class:`BufferedWriter` provides or overrides these methods in addition to " -"those from :class:`BufferedIOBase` and :class:`IOBase`:" -msgstr "" - -#: library/io.rst:807 -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:812 -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:820 -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:824 -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:828 -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:835 -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:839 -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:843 -msgid "" -":class:`BufferedRWPair` implements all of :class:`BufferedIOBase`\\'s " -"methods except for :meth:`~BufferedIOBase.detach`, which raises :exc:" -"`UnsupportedOperation`." -msgstr "" - -#: library/io.rst:849 -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:859 -msgid "" -"Base class for text streams. This class provides a character and line based " -"interface to stream I/O. It inherits :class:`IOBase`." -msgstr "" - -#: library/io.rst:862 -msgid "" -":class:`TextIOBase` provides or overrides these data attributes and methods " -"in addition to those from :class:`IOBase`:" -msgstr "" - -#: library/io.rst:867 -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:872 -msgid "The error setting of the decoder or encoder." -msgstr "" - -#: library/io.rst:876 -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:882 -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:888 -msgid "" -"Separate the underlying binary buffer from the :class:`TextIOBase` and " -"return it." -msgstr "" - -#: library/io.rst:891 -msgid "" -"After the underlying buffer has been detached, the :class:`TextIOBase` is in " -"an unusable state." -msgstr "" - -#: library/io.rst:894 -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:902 -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:907 -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:910 -msgid "If *size* is specified, at most *size* characters will be read." -msgstr "" - -#: library/io.rst:914 -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:918 -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:922 -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:925 -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:928 -msgid "Return the new absolute position as an opaque number." -msgstr "" - -#: library/io.rst:935 -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:941 -msgid "" -"Write the string *s* to the stream and return the number of characters " -"written." -msgstr "" - -#: library/io.rst:948 -msgid "" -"A buffered text stream providing higher-level access to a :class:" -"`BufferedIOBase` buffered binary stream. It inherits :class:`TextIOBase`." -msgstr "" - -#: library/io.rst:952 -msgid "" -"*encoding* gives the name of the encoding that the stream will be decoded or " -"encoded with. It defaults to :func:`locale.getencoding()`. " -"``encoding=\"locale\"`` can be used to specify the current locale's encoding " -"explicitly. See :ref:`io-text-encoding` for more information." -msgstr "" - -#: library/io.rst:957 -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:973 -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:976 -#, 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:985 -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:991 -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:994 -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:998 -msgid "The *write_through* argument has been added." -msgstr "" - -#: library/io.rst:1001 -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:1007 -msgid "" -"The *encoding* argument now supports the ``\"locale\"`` dummy encoding name." -msgstr "" - -#: library/io.rst:1010 -msgid "" -":class:`TextIOWrapper` provides these data attributes and methods in " -"addition to those from :class:`TextIOBase` and :class:`IOBase`:" -msgstr "" - -#: library/io.rst:1015 -msgid "Whether line buffering is enabled." -msgstr "" - -#: library/io.rst:1019 -msgid "Whether writes are passed immediately to the underlying binary buffer." -msgstr "" - -#: library/io.rst:1027 -msgid "" -"Reconfigure this text stream using new settings for *encoding*, *errors*, " -"*newline*, *line_buffering* and *write_through*." -msgstr "" - -#: library/io.rst:1030 -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:1034 -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 "" -"Il n'est pas possible de modifier l'encodage ou une nouvelle ligne si des " -"données ont déjà été lues à partir du flux. En revanche, il est possible de " -"modifier l'encodage après l'écriture." - -#: library/io.rst:1038 -msgid "" -"This method does an implicit stream flush before setting the new parameters." -msgstr "" - -#: library/io.rst:1043 -msgid "The method supports ``encoding=\"locale\"`` option." -msgstr "" - -#: library/io.rst:1049 -msgid "" -"A text stream using an in-memory text buffer. It inherits :class:" -"`TextIOBase`." -msgstr "" - -#: library/io.rst:1052 -msgid "" -"The text buffer is discarded when the :meth:`~IOBase.close` method is called." -msgstr "" - -#: library/io.rst:1055 -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 " -"which emulates opening an existing file in a ``w+`` mode, making it ready " -"for an immediate write from the beginning or for a write that would " -"overwrite the initial value. To emulate opening a file in an ``a+`` mode " -"ready for appending, use ``f.seek(0, io.SEEK_END)`` to reposition the stream " -"at the end of the buffer." -msgstr "" - -#: library/io.rst:1064 -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:1068 -msgid "" -":class:`StringIO` provides this method in addition to those from :class:" -"`TextIOBase` and :class:`IOBase`:" -msgstr "" - -#: library/io.rst:1073 -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:1077 -msgid "Example usage::" -msgstr "Exemple d'utilisation ::" - -#: library/io.rst:1099 -msgid "" -"A helper codec that decodes newlines for :term:`universal newlines` mode. It " -"inherits :class:`codecs.IncrementalDecoder`." -msgstr "" - -#: library/io.rst:1104 -msgid "Performance" -msgstr "Performances" - -#: library/io.rst:1106 -msgid "" -"This section discusses the performance of the provided concrete I/O " -"implementations." -msgstr "" - -#: library/io.rst:1112 -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:1124 -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:1131 -msgid "" -":class:`StringIO`, however, is a native in-memory unicode container and will " -"exhibit similar speed to :class:`BytesIO`." -msgstr "" - -#: library/io.rst:1135 -msgid "Multi-threading" -msgstr "Fils d'exécution" - -#: library/io.rst:1137 -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:1140 -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:1145 -msgid ":class:`TextIOWrapper` objects are not thread-safe." -msgstr "" -"les objets :class:`TextIOWrapper` ne sont pas compatible avec les programmes " -"à fils d'exécution multiples." - -#: library/io.rst:1148 -msgid "Reentrancy" -msgstr "Réentrance" - -#: library/io.rst:1150 -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:1158 -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 "" - -#: library/io.rst:24 -msgid "file object" -msgstr "objet fichier" - -#: library/io.rst:24 -msgid "io module" -msgstr "" - -#: library/io.rst:1094 -msgid "universal newlines" -msgstr "" - -#: library/io.rst:970 -msgid "io.TextIOWrapper class" -msgstr "" - -#: library/io.rst:1094 -msgid "io.IncrementalNewlineDecoder class" -msgstr ""