forked from AFPy/python-docs-fr
304 lines
14 KiB
Plaintext
304 lines
14 KiB
Plaintext
# SOME DESCRIPTIVE TITLE.
|
||
# Copyright (C) 2001-2016, Python Software Foundation
|
||
# This file is distributed under the same license as the Python package.
|
||
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
||
#
|
||
#, fuzzy
|
||
msgid ""
|
||
msgstr ""
|
||
"Project-Id-Version: Python 3.5\n"
|
||
"Report-Msgid-Bugs-To: \n"
|
||
"POT-Creation-Date: 2016-10-30 10:42+0100\n"
|
||
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
|
||
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
|
||
"Language-Team: LANGUAGE <LL@li.org>\n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
|
||
#: ../Doc/library/queue.rst:2
|
||
msgid ":mod:`queue` --- A synchronized queue class"
|
||
msgstr ":mod:`queue` --- File synchronisée"
|
||
|
||
#: ../Doc/library/queue.rst:7
|
||
msgid "**Source code:** :source:`Lib/queue.py`"
|
||
msgstr "**Code source :** :source:`Lib/queue.py`"
|
||
|
||
#: ../Doc/library/queue.rst:11
|
||
msgid ""
|
||
"The :mod:`queue` module implements multi-producer, multi-consumer queues. It "
|
||
"is especially useful in threaded programming when information must be "
|
||
"exchanged safely between multiple threads. The :class:`Queue` class in this "
|
||
"module implements all the required locking semantics. It depends on the "
|
||
"availability of thread support in Python; see the :mod:`threading` module."
|
||
msgstr ""
|
||
"Le module :mod:`queue` implémente des files multi-productrices et multi-"
|
||
"consommatrices. C'est particulièrement utile en programmation *multi-"
|
||
"thread*, lorsque les informations doivent être échangées sans risques entre "
|
||
"plusieurs *threads*. La classe :class:`Queue` de ce module implémente tout "
|
||
"le verrouillage nécessaire. Cela dépend de la disponibilité du support des "
|
||
"fils d'exécution en Python; voir le module :mod:`threading`."
|
||
|
||
#: ../Doc/library/queue.rst:18
|
||
msgid ""
|
||
"The module implements three types of queue, which differ only in the order "
|
||
"in which the entries are retrieved. In a FIFO queue, the first tasks added "
|
||
"are the first retrieved. In a LIFO queue, the most recently added entry is "
|
||
"the first retrieved (operating like a stack). With a priority queue, the "
|
||
"entries are kept sorted (using the :mod:`heapq` module) and the lowest "
|
||
"valued entry is retrieved first."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/queue.rst:25
|
||
msgid ""
|
||
"Internally, the module uses locks to temporarily block competing threads; "
|
||
"however, it is not designed to handle reentrancy within a thread."
|
||
msgstr ""
|
||
"En interne, le module utilise des verrous pour bloquer temporairement des "
|
||
"fils d'exécution concurrents. Cependant, il n'a pas été conçu pour être "
|
||
"réentrant au sein d'un fil d'exécution."
|
||
|
||
#: ../Doc/library/queue.rst:28
|
||
msgid "The :mod:`queue` module defines the following classes and exceptions:"
|
||
msgstr ""
|
||
"Le module :mod:`queue` définit les classes et les exceptions suivantes :"
|
||
|
||
#: ../Doc/library/queue.rst:32
|
||
msgid ""
|
||
"Constructor for a FIFO queue. *maxsize* is an integer that sets the "
|
||
"upperbound limit on the number of items that can be placed in the queue. "
|
||
"Insertion will block once this size has been reached, until queue items are "
|
||
"consumed. If *maxsize* is less than or equal to zero, the queue size is "
|
||
"infinite."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/queue.rst:39
|
||
msgid ""
|
||
"Constructor for a LIFO queue. *maxsize* is an integer that sets the "
|
||
"upperbound limit on the number of items that can be placed in the queue. "
|
||
"Insertion will block once this size has been reached, until queue items are "
|
||
"consumed. If *maxsize* is less than or equal to zero, the queue size is "
|
||
"infinite."
|
||
msgstr ""
|
||
|
||
#: ../Doc/library/queue.rst:47
|
||
msgid ""
|
||
"Constructor for a priority queue. *maxsize* is an integer that sets the "
|
||
"upperbound limit on the number of items that can be placed in the queue. "
|
||
"Insertion will block once this size has been reached, until queue items are "
|
||
"consumed. If *maxsize* is less than or equal to zero, the queue size is "
|
||
"infinite."
|
||
msgstr ""
|
||
"Constructeur pour une file de priorité. *maxsize* est un entier définissant "
|
||
"le nombre maximal d'éléments pouvant être mis dans la file. L'insertion sera "
|
||
"bloquée lorsque cette borne supérieure sera atteinte, jusqu'à ce que des "
|
||
"éléments soient consommés. Si *maxsize* est inférieur ou égal à 0, la taille "
|
||
"de la file sera infinie."
|
||
|
||
#: ../Doc/library/queue.rst:52
|
||
msgid ""
|
||
"The lowest valued entries are retrieved first (the lowest valued entry is "
|
||
"the one returned by ``sorted(list(entries))[0]``). A typical pattern for "
|
||
"entries is a tuple in the form: ``(priority_number, data)``."
|
||
msgstr ""
|
||
"Les éléments de valeurs les plus faibles sont extraits en premier (l'élément "
|
||
"de valeur la plus faible est celui renvoyé par ``sorted(list(entries))"
|
||
"[0]``). Un cas typique est d'utiliser des tuple de la forme : "
|
||
"``(priority_number, data)``."
|
||
|
||
#: ../Doc/library/queue.rst:59
|
||
msgid ""
|
||
"Exception raised when non-blocking :meth:`~Queue.get` (or :meth:`~Queue."
|
||
"get_nowait`) is called on a :class:`Queue` object which is empty."
|
||
msgstr ""
|
||
"Exception levée lorsque la méthode non bloquante :meth:`~Queue.get` (ou :"
|
||
"meth:`~Queue.get_nowait`) est appelée sur l'objet :class:`Queue` vide."
|
||
|
||
#: ../Doc/library/queue.rst:66
|
||
msgid ""
|
||
"Exception raised when non-blocking :meth:`~Queue.put` (or :meth:`~Queue."
|
||
"put_nowait`) is called on a :class:`Queue` object which is full."
|
||
msgstr ""
|
||
"Exception levée lorsque la méthode non bloquante :meth:`~Queue.put` (ou :"
|
||
"meth:`~Queue.put_nowait`) est appelée sur un objet :class:`Queue` plein."
|
||
|
||
#: ../Doc/library/queue.rst:74
|
||
msgid "Queue Objects"
|
||
msgstr "Objets ``Queue``"
|
||
|
||
#: ../Doc/library/queue.rst:76
|
||
msgid ""
|
||
"Queue objects (:class:`Queue`, :class:`LifoQueue`, or :class:"
|
||
"`PriorityQueue`) provide the public methods described below."
|
||
msgstr ""
|
||
"Les objets *Queue* (:class:`Queue`, :class:`LifoQueue` ou :class:"
|
||
"`PriorityQueue`) fournissent les méthodes publiques décrites ci-dessous."
|
||
|
||
#: ../Doc/library/queue.rst:82
|
||
msgid ""
|
||
"Return the approximate size of the queue. Note, qsize() > 0 doesn't "
|
||
"guarantee that a subsequent get() will not block, nor will qsize() < maxsize "
|
||
"guarantee that put() will not block."
|
||
msgstr ""
|
||
"Renvoie la taille approximative de la file. Notez que ``qsize() > 0`` ne "
|
||
"garantit pas qu'un ``get()`` ultérieur ne sera pas bloquant et que ``qsize() "
|
||
"< maxsize`` ne garantit pas non plus qu'un ``put()`` ne sera pas bloquant."
|
||
|
||
#: ../Doc/library/queue.rst:89
|
||
msgid ""
|
||
"Return ``True`` if the queue is empty, ``False`` otherwise. If empty() "
|
||
"returns ``True`` it doesn't guarantee that a subsequent call to put() will "
|
||
"not block. Similarly, if empty() returns ``False`` it doesn't guarantee "
|
||
"that a subsequent call to get() will not block."
|
||
msgstr ""
|
||
"Renvoie ``True`` si la file est vide, ``False`` sinon. Si ``empty()`` "
|
||
"renvoie ``True``, cela ne garantit pas qu'un appel ultérieur à ``put()`` ne "
|
||
"sera pas bloquant. Similairement, si ``empty()`` renvoie ``False``, cela ne "
|
||
"garantit pas qu'un appel ultérieur à ``get()`` ne sera pas bloquant."
|
||
|
||
#: ../Doc/library/queue.rst:97
|
||
msgid ""
|
||
"Return ``True`` if the queue is full, ``False`` otherwise. If full() "
|
||
"returns ``True`` it doesn't guarantee that a subsequent call to get() will "
|
||
"not block. Similarly, if full() returns ``False`` it doesn't guarantee that "
|
||
"a subsequent call to put() will not block."
|
||
msgstr ""
|
||
"Renvoie ``True`` si la file est pleine, ``False`` sinon. Si ``full()`` "
|
||
"renvoie``True``, cela ne garantit pas qu'un appel ultérieur à ``get()`` ne "
|
||
"sera pas bloquant. Similairement, si ``full()`` retourne ``False``, cela ne "
|
||
"garantit pas qu'un appel ultérieur à ``put()`` ne sera pas bloquant."
|
||
|
||
#: ../Doc/library/queue.rst:105
|
||
msgid ""
|
||
"Put *item* into the queue. If optional args *block* is true and *timeout* is "
|
||
"``None`` (the default), block if necessary until a free slot is available. "
|
||
"If *timeout* is a positive number, it blocks at most *timeout* seconds and "
|
||
"raises the :exc:`Full` exception if no free slot was available within that "
|
||
"time. Otherwise (*block* is false), put an item on the queue if a free slot "
|
||
"is immediately available, else raise the :exc:`Full` exception (*timeout* is "
|
||
"ignored in that case)."
|
||
msgstr ""
|
||
"Met *item* dans la file. Si les arguments optionnels *block* et *timeout* "
|
||
"sont respectivement ``True`` et ``None`` (les valeurs par défaut), la "
|
||
"méthode bloque si nécessaire jusqu'à ce qu'un emplacement libre soit "
|
||
"disponible. Si *timeout* est un nombre positif, elle bloque au plus "
|
||
"*timeout* secondes et lève l'exception :exc:`Full` s'il n'y avait pas "
|
||
"d'emplacement libre pendant cette période de temps. Sinon (*block* est "
|
||
"``False``), elle met un élément dans la file s'il y a un emplacement libre "
|
||
"immédiatement disponible. Si ce n'est pas le cas, elle lève l'exception :exc:"
|
||
"`Full` (*timeout* est ignoré dans ce cas)."
|
||
|
||
#: ../Doc/library/queue.rst:116
|
||
msgid "Equivalent to ``put(item, False)``."
|
||
msgstr "Équivalent à ``put(item, False)``."
|
||
|
||
#: ../Doc/library/queue.rst:121
|
||
msgid ""
|
||
"Remove and return an item from the queue. If optional args *block* is true "
|
||
"and *timeout* is ``None`` (the default), block if necessary until an item is "
|
||
"available. If *timeout* is a positive number, it blocks at most *timeout* "
|
||
"seconds and raises the :exc:`Empty` exception if no item was available "
|
||
"within that time. Otherwise (*block* is false), return an item if one is "
|
||
"immediately available, else raise the :exc:`Empty` exception (*timeout* is "
|
||
"ignored in that case)."
|
||
msgstr ""
|
||
"Retire et renvoie un élément de la file. Si les arguments optionnels *block* "
|
||
"et *timeout* valent respectivement ``True`` et ``None`` (les valeurs par "
|
||
"défaut), la méthode bloque si nécessaire jusqu'à ce qu'un élément soit "
|
||
"disponible. Si *timeout* est un entier positif, elle bloque au plus "
|
||
"*timeout* secondes et lève l'exception :exc:`Empty` s'il n'y avait pas "
|
||
"d'élément disponible pendant cette période de temps. Sinon (*block* vaut "
|
||
"``False``), elle renvoie un élément s'il y en a un immédiatement disponible. "
|
||
"Si ce n'est pas le cas, elle lève l'exception :exc:`Empty` (*timeout* est "
|
||
"ignoré dans ce cas)."
|
||
|
||
#: ../Doc/library/queue.rst:131
|
||
msgid "Equivalent to ``get(False)``."
|
||
msgstr "Équivalent à ``get(False)``."
|
||
|
||
#: ../Doc/library/queue.rst:133
|
||
msgid ""
|
||
"Two methods are offered to support tracking whether enqueued tasks have been "
|
||
"fully processed by daemon consumer threads."
|
||
msgstr ""
|
||
"Deux méthodes sont proposées afin de savoir si les tâches mises dans la file "
|
||
"ont été entièrement traitées par les fils d'exécution consommateurs du démon."
|
||
|
||
#: ../Doc/library/queue.rst:139
|
||
msgid ""
|
||
"Indicate that a formerly enqueued task is complete. Used by queue consumer "
|
||
"threads. For each :meth:`get` used to fetch a task, a subsequent call to :"
|
||
"meth:`task_done` tells the queue that the processing on the task is complete."
|
||
msgstr ""
|
||
"Indique qu'une tâche précédemment mise dans la file est terminée. Utilisé "
|
||
"par les fils d'exécution consommateurs de la file. Pour chaque appel à :meth:"
|
||
"`get` effectué afin de récupérer une tâche, un appel ultérieur à :meth:"
|
||
"`task_done` informe la file que le traitement de la tâche est terminé."
|
||
|
||
#: ../Doc/library/queue.rst:143
|
||
msgid ""
|
||
"If a :meth:`join` is currently blocking, it will resume when all items have "
|
||
"been processed (meaning that a :meth:`task_done` call was received for every "
|
||
"item that had been :meth:`put` into the queue)."
|
||
msgstr ""
|
||
"Si un :meth:`join` est actuellement bloquant, on reprendra lorsque tous les "
|
||
"éléments auront été traités (ce qui signifie qu'un appel à :meth:`task_done` "
|
||
"a été effectué pour chaque élément qui a été :meth:`put` dans la file)."
|
||
|
||
#: ../Doc/library/queue.rst:147
|
||
msgid ""
|
||
"Raises a :exc:`ValueError` if called more times than there were items placed "
|
||
"in the queue."
|
||
msgstr ""
|
||
"Lève une exception :exc:`ValueError` si appelée plus de fois qu'il y avait "
|
||
"d'éléments dans la file."
|
||
|
||
#: ../Doc/library/queue.rst:153
|
||
msgid "Blocks until all items in the queue have been gotten and processed."
|
||
msgstr ""
|
||
"Bloque jusqu'à ce que tous les éléments de la file aient été obtenus et "
|
||
"traités."
|
||
|
||
#: ../Doc/library/queue.rst:155
|
||
msgid ""
|
||
"The count of unfinished tasks goes up whenever an item is added to the "
|
||
"queue. The count goes down whenever a consumer thread calls :meth:"
|
||
"`task_done` to indicate that the item was retrieved and all work on it is "
|
||
"complete. When the count of unfinished tasks drops to zero, :meth:`join` "
|
||
"unblocks."
|
||
msgstr ""
|
||
"Le nombre de tâches inachevées augmente chaque fois qu'un élément est ajouté "
|
||
"à la file. Ce nombre diminue chaque fois qu'un fil d'exécution consommateur "
|
||
"appelle :meth:`task_done` pour indiquer que l'élément a été extrait et que "
|
||
"tout le travail à effectuer dessus est terminé. Lorsque le nombre de tâches "
|
||
"non terminées devient nul, :meth:`join` débloque."
|
||
|
||
#: ../Doc/library/queue.rst:161
|
||
msgid "Example of how to wait for enqueued tasks to be completed::"
|
||
msgstr ""
|
||
"Exemple montrant comment attendre que les tâches mises dans la file soient "
|
||
"terminées ::"
|
||
|
||
#: ../Doc/library/queue.rst:195
|
||
msgid "Class :class:`multiprocessing.Queue`"
|
||
msgstr "Classe :class:`multiprocessing.Queue`"
|
||
|
||
#: ../Doc/library/queue.rst:194
|
||
msgid ""
|
||
"A queue class for use in a multi-processing (rather than multi-threading) "
|
||
"context."
|
||
msgstr ""
|
||
"Une file à utiliser dans un contexte multi-processus (plutôt que *multi-"
|
||
"thread*)."
|
||
|
||
#: ../Doc/library/queue.rst:197
|
||
msgid ""
|
||
":class:`collections.deque` is an alternative implementation of unbounded "
|
||
"queues with fast atomic :meth:`~collections.deque.append` and :meth:"
|
||
"`~collections.deque.popleft` operations that do not require locking."
|
||
msgstr ""
|
||
":class:`collections.deque` est une implémentation alternative de file non "
|
||
"bornée avec des méthodes :meth:`~collections.deque.append` et :meth:"
|
||
"`~collections.deque.popleft` rapides et atomiques ne nécessitant pas de "
|
||
"verrouillage."
|