2016-10-17 19:42:06 +00:00
|
|
|
|
# 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.
|
|
|
|
|
#
|
|
|
|
|
msgid ""
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Project-Id-Version: Python 3.6\n"
|
|
|
|
|
"Report-Msgid-Bugs-To: \n"
|
2017-08-09 22:23:54 +00:00
|
|
|
|
"POT-Creation-Date: 2017-08-10 00:49+0200\n"
|
2017-10-27 15:42:48 +00:00
|
|
|
|
"PO-Revision-Date: 2017-10-27 17:26+0200\n"
|
2017-05-27 17:46:38 +00:00
|
|
|
|
"Last-Translator: Julien Palard <julien@palard.fr>\n"
|
|
|
|
|
"Language-Team: \n"
|
2017-05-15 21:58:44 +00:00
|
|
|
|
"Language: fr\n"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
"MIME-Version: 1.0\n"
|
|
|
|
|
"Content-Type: text/plain; charset=UTF-8\n"
|
|
|
|
|
"Content-Transfer-Encoding: 8bit\n"
|
2017-09-22 09:08:03 +00:00
|
|
|
|
"X-Generator: Poedit 2.0.4\n"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:5
|
|
|
|
|
msgid "Glossary"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Glossaire"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:10
|
2017-05-27 17:46:38 +00:00
|
|
|
|
msgid "``>>>``"
|
2017-05-28 15:52:50 +00:00
|
|
|
|
msgstr "``>>>``"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:12
|
|
|
|
|
msgid ""
|
|
|
|
|
"The default Python prompt of the interactive shell. Often seen for code "
|
|
|
|
|
"examples which can be executed interactively in the interpreter."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"L'invite de commande utilisée par défaut dans l'interpréteur interactif. On "
|
|
|
|
|
"la voit souvent dans des exemples de code qui peuvent être exécutés "
|
|
|
|
|
"interactivement dans l'interpréteur."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:14
|
2017-05-27 17:46:38 +00:00
|
|
|
|
msgid "``...``"
|
2017-05-28 15:52:50 +00:00
|
|
|
|
msgstr "``...``"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:16
|
|
|
|
|
msgid ""
|
|
|
|
|
"The default Python prompt of the interactive shell when entering code for an "
|
|
|
|
|
"indented code block or within a pair of matching left and right delimiters "
|
|
|
|
|
"(parentheses, square brackets or curly braces)."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"L'invite de commande utilisée par défaut dans l'interpréteur interactif "
|
|
|
|
|
"lorsqu'on entre un bloc de code indenté ou entre deux délimiteurs "
|
|
|
|
|
"(parenthèses, crochets ou accolades)."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:19
|
|
|
|
|
msgid "2to3"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "3to3"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:21
|
|
|
|
|
msgid ""
|
|
|
|
|
"A tool that tries to convert Python 2.x code to Python 3.x code by handling "
|
|
|
|
|
"most of the incompatibilities which can be detected by parsing the source "
|
|
|
|
|
"and traversing the parse tree."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un outil qui essaie de convertir du code pour Python 2.x en code pour Python "
|
|
|
|
|
"3.x en gérant la plupart des incompatibilités qui peuvent être détectées en "
|
|
|
|
|
"analysant la source et parcourant son arbre syntaxique."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:25
|
|
|
|
|
msgid ""
|
|
|
|
|
"2to3 is available in the standard library as :mod:`lib2to3`; a standalone "
|
|
|
|
|
"entry point is provided as :file:`Tools/scripts/2to3`. See :ref:`2to3-"
|
|
|
|
|
"reference`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"2to3 est disponible dans la bibliothèque standard sous le nom de :mod:"
|
|
|
|
|
"`lib2to3`; un point d’entrée indépendant est fourni via :file:`Tools/"
|
|
|
|
|
"scripts/2to3`. Cf. :ref:`2to3-reference`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:28
|
|
|
|
|
msgid "abstract base class"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "classe de base abstraite"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:30
|
|
|
|
|
msgid ""
|
|
|
|
|
"Abstract base classes complement :term:`duck-typing` by providing a way to "
|
|
|
|
|
"define interfaces when other techniques like :func:`hasattr` would be clumsy "
|
|
|
|
|
"or subtly wrong (for example with :ref:`magic methods <special-lookup>`). "
|
|
|
|
|
"ABCs introduce virtual subclasses, which are classes that don't inherit from "
|
|
|
|
|
"a class but are still recognized by :func:`isinstance` and :func:"
|
|
|
|
|
"`issubclass`; see the :mod:`abc` module documentation. Python comes with "
|
|
|
|
|
"many built-in ABCs for data structures (in the :mod:`collections.abc` "
|
|
|
|
|
"module), numbers (in the :mod:`numbers` module), streams (in the :mod:`io` "
|
|
|
|
|
"module), import finders and loaders (in the :mod:`importlib.abc` module). "
|
|
|
|
|
"You can create your own ABCs with the :mod:`abc` module."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Les classes de base abstraites (ABC, suivant l'abréviation anglaise "
|
|
|
|
|
"*Abstract Base Class*) complètent le :term:`duck-typing` en fournissant un "
|
|
|
|
|
"moyen de définir des interfaces pour les cas où d'autres techniques comme :"
|
|
|
|
|
"func:`hasattr` seraient inélégantes, ou subitement fausse (par exemple avec "
|
|
|
|
|
"les :ref:`méthodes magiques <special-lookup>`). Les ABC introduisent des "
|
|
|
|
|
"sous-classes virtuelles, qui n'héritent pas d'une classe mais qui sont quand "
|
|
|
|
|
"même reconnues par :func:`isinstance` ou :func:`issubclass` (Voir la "
|
|
|
|
|
"documentation du module :mod:`abc`). Python contient de nombreuses ABC pour "
|
|
|
|
|
"les structures de données (dans le module :mod:`collections.abc`), les "
|
|
|
|
|
"nombres (dans le module :mod:`numbers`), les flux (dans le module :mod:"
|
|
|
|
|
"`io`), et les chercheurs / chargeurs d'import (dans le module :mod:"
|
|
|
|
|
"`importlib.abc`). Vous pouvez créer vos propres ABC avec le module :mod:"
|
|
|
|
|
"`abc`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:41
|
|
|
|
|
msgid "argument"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "argument"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:43
|
|
|
|
|
msgid ""
|
|
|
|
|
"A value passed to a :term:`function` (or :term:`method`) when calling the "
|
|
|
|
|
"function. There are two kinds of argument:"
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une valeur, donnée à une :term:`fonction` ou à une :term:`méthode` lors de "
|
|
|
|
|
"son appel. Il existe deux types d'arguments :"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:46
|
|
|
|
|
msgid ""
|
|
|
|
|
":dfn:`keyword argument`: an argument preceded by an identifier (e.g. "
|
|
|
|
|
"``name=``) in a function call or passed as a value in a dictionary preceded "
|
|
|
|
|
"by ``**``. For example, ``3`` and ``5`` are both keyword arguments in the "
|
|
|
|
|
"following calls to :func:`complex`::"
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
":dfn:`argument nommé`: un argument précédé d'un identifiant (comme "
|
|
|
|
|
"``name=``) ou un dictionnaire précédé de ``**``, lors d'un appel de "
|
|
|
|
|
"fonction. Par exemple, ``3`` et ``5`` sont tous les deux des arguments "
|
|
|
|
|
"nommés dans l'appel à :func:`complex` ici : ::"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:54
|
|
|
|
|
msgid ""
|
|
|
|
|
":dfn:`positional argument`: an argument that is not a keyword argument. "
|
|
|
|
|
"Positional arguments can appear at the beginning of an argument list and/or "
|
|
|
|
|
"be passed as elements of an :term:`iterable` preceded by ``*``. For example, "
|
|
|
|
|
"``3`` and ``5`` are both positional arguments in the following calls::"
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
":dfn:`argument positionnel` : Un argument qui n'est pas nommé. Les arguments "
|
|
|
|
|
"positionnels apparaissent au début de la liste des arguments, ou donnés sous "
|
|
|
|
|
"forme d'un :term:`itérable` précédé par ``*``. Par exemple, ``3`` et ``5`` "
|
|
|
|
|
"sont tous les deux des arguments positionnels dans les appels suivants : ::"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:63
|
|
|
|
|
msgid ""
|
|
|
|
|
"Arguments are assigned to the named local variables in a function body. See "
|
|
|
|
|
"the :ref:`calls` section for the rules governing this assignment. "
|
|
|
|
|
"Syntactically, any expression can be used to represent an argument; the "
|
|
|
|
|
"evaluated value is assigned to the local variable."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Les arguments se retrouvent dans le corps de la fonction appelée parmi les "
|
|
|
|
|
"variables locales. Voir la section :ref:`calls` à propos des règles dictant "
|
|
|
|
|
"cet affectation. Syntaxiquement, toute expression est acceptée comme "
|
|
|
|
|
"argument, et c'est la valeur résultante de l'expression qui sera affectée à "
|
|
|
|
|
"la variable locale."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:68
|
|
|
|
|
msgid ""
|
|
|
|
|
"See also the :term:`parameter` glossary entry, the FAQ question on :ref:`the "
|
|
|
|
|
"difference between arguments and parameters <faq-argument-vs-parameter>`, "
|
|
|
|
|
"and :pep:`362`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Voir aussi :term:`parameter` dans le glossaire, la FAQ a aussi une question "
|
|
|
|
|
"à propos de :ref:`la différence entre argument et paramètre <faq-argument-vs-"
|
|
|
|
|
"parameter>` et la :pep:`362`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:71
|
|
|
|
|
msgid "asynchronous context manager"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "gestionnaire de contexte asynchrone"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:73
|
|
|
|
|
msgid ""
|
|
|
|
|
"An object which controls the environment seen in an :keyword:`async with` "
|
|
|
|
|
"statement by defining :meth:`__aenter__` and :meth:`__aexit__` methods. "
|
|
|
|
|
"Introduced by :pep:`492`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"(*asynchronous context manager*) Un objet contrôlant l'environnement à "
|
|
|
|
|
"l'intérieur d'une instruction :keyword:`with` en définissant les méthodes :"
|
|
|
|
|
"meth:`__aenter__` et :meth:`__aexit__`. Introduit dans la :pep:`492`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:76
|
2017-04-02 20:14:06 +00:00
|
|
|
|
msgid "asynchronous generator"
|
2017-05-15 21:58:44 +00:00
|
|
|
|
msgstr "générateur asynchrone"
|
2017-04-02 20:14:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:78
|
|
|
|
|
msgid ""
|
|
|
|
|
"A function which returns an :term:`asynchronous generator iterator`. It "
|
|
|
|
|
"looks like a coroutine function defined with :keyword:`async def` except "
|
|
|
|
|
"that it contains :keyword:`yield` expressions for producing a series of "
|
|
|
|
|
"values usable in an :keyword:`async for` loop."
|
|
|
|
|
msgstr ""
|
2017-05-15 21:58:44 +00:00
|
|
|
|
"Une fonction qui renvoie un :term:`asynchronous generator iterator`. Cela "
|
|
|
|
|
"ressemble à une coroutine définie par :keyword:`async def` mais contenant "
|
|
|
|
|
"une ou des expressions :keyword:`yield` produisant ainsi uns série de "
|
|
|
|
|
"valeurs utilisables dans une boucle :keyword:`async for`."
|
2017-04-02 20:14:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:83
|
|
|
|
|
msgid ""
|
|
|
|
|
"Usually refers to a asynchronous generator function, but may refer to an "
|
|
|
|
|
"*asynchronous generator iterator* in some contexts. In cases where the "
|
|
|
|
|
"intended meaning isn't clear, using the full terms avoids ambiguity."
|
|
|
|
|
msgstr ""
|
2017-05-15 21:58:44 +00:00
|
|
|
|
"Fait généralement allusion à une fonction générateur asynchrone, mais peut "
|
|
|
|
|
"faire allusion à un *itérateur de générateur asynchrone* dans certains "
|
|
|
|
|
"contextes. Dans les cas où le sens voulu n'est pas clair, utiliser les "
|
|
|
|
|
"termes complets évite l'ambiguité."
|
2017-04-02 20:14:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:87
|
|
|
|
|
msgid ""
|
|
|
|
|
"An asynchronous generator function may contain :keyword:`await` expressions "
|
|
|
|
|
"as well as :keyword:`async for`, and :keyword:`async with` statements."
|
|
|
|
|
msgstr ""
|
2017-05-15 21:58:44 +00:00
|
|
|
|
"Un générateur asynchrone peut contenir des expressions :keyword:`await` "
|
|
|
|
|
"ainsi que des instructions :keyword:`async for`, et :keyword:`async with`."
|
2017-04-02 20:14:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:90
|
|
|
|
|
msgid "asynchronous generator iterator"
|
2017-05-15 21:58:44 +00:00
|
|
|
|
msgstr "itérateur de générateur asynchrone"
|
2017-04-02 20:14:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:92
|
|
|
|
|
msgid "An object created by a :term:`asynchronous generator` function."
|
2017-05-15 21:58:44 +00:00
|
|
|
|
msgstr "Un objet crée par une fonction :term:`asynchronous generator`."
|
2017-04-02 20:14:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:94
|
|
|
|
|
msgid ""
|
|
|
|
|
"This is an :term:`asynchronous iterator` which when called using the :meth:"
|
|
|
|
|
"`__anext__` method returns an awaitable object which will execute that the "
|
|
|
|
|
"body of the asynchronous generator function until the next :keyword:`yield` "
|
|
|
|
|
"expression."
|
|
|
|
|
msgstr ""
|
2017-05-15 21:58:44 +00:00
|
|
|
|
"C'est un :term:`asynchronous iterator` qui, lorsqu'il est appelé via la "
|
|
|
|
|
"méthode :meth:`__anext__` renvoie un objet *awaitable* qui exécutera le "
|
|
|
|
|
"corps de la fonction du générateur asynchrone jusqu'au prochain :keyword:"
|
|
|
|
|
"`yield`."
|
2017-04-02 20:14:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:99
|
|
|
|
|
msgid ""
|
|
|
|
|
"Each :keyword:`yield` temporarily suspends processing, remembering the "
|
|
|
|
|
"location execution state (including local variables and pending try-"
|
|
|
|
|
"statements). When the *asynchronous generator iterator* effectively resumes "
|
|
|
|
|
"with another awaitable returned by :meth:`__anext__`, it picks-up where it "
|
|
|
|
|
"left-off. See :pep:`492` and :pep:`525`."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Chaque :keyword:`yield` suspend temporairement l'exécution, se rappelant de "
|
|
|
|
|
"l'endroit et de l'état de l'exécution (incluant les variables locales et les "
|
2017-05-15 21:58:44 +00:00
|
|
|
|
"*try* en cours). Lorsque l'itérateur de générateur asynchrone reprend avec "
|
|
|
|
|
"un nouvel *awaitable* renvoyé par :meth:`__anext__`, il repart de là où il "
|
|
|
|
|
"en était. Voir :pep:`492` et :pep:`525`."
|
2017-04-02 20:14:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:104
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "asynchronous iterable"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "itérable asynchrone"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:106
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An object, that can be used in an :keyword:`async for` statement. Must "
|
|
|
|
|
"return an :term:`asynchronous iterator` from its :meth:`__aiter__` method. "
|
|
|
|
|
"Introduced by :pep:`492`."
|
|
|
|
|
msgstr ""
|
2016-10-21 12:43:16 +00:00
|
|
|
|
"Un objet qui peut être utilisé dans une instruction :keyword:`async for`. Sa "
|
2017-09-22 09:08:03 +00:00
|
|
|
|
"méthode :meth:`__aiter__` doit renvoyer un :term:`asynchronous iterator`. "
|
2016-10-21 12:43:16 +00:00
|
|
|
|
"Introduit dans la :pep:`492`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:109
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "asynchronous iterator"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "itérateur asynchrone"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:111
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An object that implements :meth:`__aiter__` and :meth:`__anext__` methods. "
|
|
|
|
|
"``__anext__`` must return an :term:`awaitable` object. :keyword:`async for` "
|
|
|
|
|
"resolves awaitable returned from asynchronous iterator's :meth:`__anext__` "
|
|
|
|
|
"method until it raises :exc:`StopAsyncIteration` exception. Introduced by :"
|
|
|
|
|
"pep:`492`."
|
|
|
|
|
msgstr ""
|
2016-10-21 12:43:16 +00:00
|
|
|
|
"Un objet qui implémente les méthodes :meth:`__aiter__` et :meth:`__anext__`. "
|
2017-09-22 09:08:03 +00:00
|
|
|
|
"``__anext__`` doit renvoyer un objet :term:`awaitable`. :keyword:`async for` "
|
|
|
|
|
"résoud le awaitable renvoyé par la méthode :meth:`__anext__` de l'itérateur "
|
|
|
|
|
"asynchrone jusqu'à ce qu'il lève une exception :exc:`StopAsyncIteration`. "
|
|
|
|
|
"Introduit dans la :pep:`492`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:116
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "attribute"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "attribut"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:118
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A value associated with an object which is referenced by name using dotted "
|
|
|
|
|
"expressions. For example, if an object *o* has an attribute *a* it would be "
|
|
|
|
|
"referenced as *o.a*."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une valeur associée à un objet et désignée par son nom via une notation "
|
|
|
|
|
"utilisant des points. Par exemple, si un objet *o* a un attribut *a*, il "
|
|
|
|
|
"sera référencé par *o.a*."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:121
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "awaitable"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "awaitable"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:123
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An object that can be used in an :keyword:`await` expression. Can be a :"
|
|
|
|
|
"term:`coroutine` or an object with an :meth:`__await__` method. See also :"
|
|
|
|
|
"pep:`492`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un objet pouvant être utilisé dans une expression :keyword:`await`. Peut "
|
|
|
|
|
"être une :term:`coroutine` ou un objet avec une méthode :meth:`__await__`. "
|
|
|
|
|
"Voir aussi :pep:`492`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:126
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "BDFL"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "BDFL"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:128
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Benevolent Dictator For Life, a.k.a. `Guido van Rossum <https://www.python."
|
|
|
|
|
"org/~guido/>`_, Python's creator."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Bienveillant dictateur à vie (de *Benevolent Dictator For Life*), alias "
|
|
|
|
|
"`Guido van Rossum <https://www.python.org/~guido/>`_, le créateur de Python."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:130
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "binary file"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "fichier binaire"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:132
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A :term:`file object` able to read and write :term:`bytes-like objects "
|
2017-04-02 20:14:06 +00:00
|
|
|
|
"<bytes-like object>`. Examples of binary files are files opened in binary "
|
|
|
|
|
"mode (``'rb'``, ``'wb'`` or ``'rb+'``), :data:`sys.stdin.buffer`, :data:`sys."
|
|
|
|
|
"stdout.buffer`, and instances of :class:`io.BytesIO` and :class:`gzip."
|
|
|
|
|
"GzipFile`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgstr ""
|
2017-05-15 21:58:44 +00:00
|
|
|
|
"Un :term:`file object` capable de lire et d'écrire des :term:`bytes-like "
|
|
|
|
|
"objects <bytes-like object>`. Voici quelques exemples de fichiers binaires "
|
|
|
|
|
"ouverts en mode binaire (``'rb'``, ``'wb'``, ou ``'rb+'``), :data:`sys.stdin."
|
|
|
|
|
"buffer`, :data:`sys.stdout.buffer`, les instances de :class:`io.BytesIO`, et "
|
|
|
|
|
"de :class:`gzip.GzipFile`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:140
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "A :term:`text file` reads and writes :class:`str` objects."
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Un :term:`fichier texte` lis et écris des objets :class:`str`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:141
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "bytes-like object"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Objet bytes-compatible"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:143
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An object that supports the :ref:`bufferobjects` and can export a C-:term:"
|
|
|
|
|
"`contiguous` buffer. This includes all :class:`bytes`, :class:`bytearray`, "
|
|
|
|
|
"and :class:`array.array` objects, as well as many common :class:`memoryview` "
|
|
|
|
|
"objects. Bytes-like objects can be used for various operations that work "
|
|
|
|
|
"with binary data; these include compression, saving to a binary file, and "
|
|
|
|
|
"sending over a socket."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un objet gèrant les :ref:`bufferobjects` et peut exporter un buffer C-:term:"
|
|
|
|
|
"`contiguous`. Cela inclu les objets :class:`bytes`, :class:`bytearray`, et :"
|
|
|
|
|
"class:`array.array`, ainsi que beaucoup d'objets :class:`memoryview`. Les "
|
|
|
|
|
"objets bytes-compatibles peuvent être utilisés pour diverses opérations sur "
|
|
|
|
|
"des données binaires, comme la compression, la sauvegard dans un fichier "
|
|
|
|
|
"binaire, ou l'envoi sur une socket."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:150
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Some operations need the binary data to be mutable. The documentation often "
|
|
|
|
|
"refers to these as \"read-write bytes-like objects\". Example mutable "
|
|
|
|
|
"buffer objects include :class:`bytearray` and a :class:`memoryview` of a :"
|
|
|
|
|
"class:`bytearray`. Other operations require the binary data to be stored in "
|
|
|
|
|
"immutable objects (\"read-only bytes-like objects\"); examples of these "
|
|
|
|
|
"include :class:`bytes` and a :class:`memoryview` of a :class:`bytes` object."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Certaines opérations nécessitent de travailler sur des données binaires "
|
|
|
|
|
"variables. La documentation parle de ceux-ci comme des \"read-write bytes-"
|
|
|
|
|
"like objects\". Par exemple, :class:`bytearray`, et une :class:`memoryview` "
|
|
|
|
|
"d'un :class:`bytearray` en sont. D'autres opérations nécessitent de "
|
|
|
|
|
"travailler sur des données binaires stockées dans des objets immuables (*"
|
|
|
|
|
"\"read-only bytes-like objects\"*), par exemples :class:`bytes` et :class:"
|
|
|
|
|
"`memoryview` d'un objet :class:`byte`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:158
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "bytecode"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "bytecode"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:160
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Python source code is compiled into bytecode, the internal representation of "
|
|
|
|
|
"a Python program in the CPython interpreter. The bytecode is also cached in "
|
2017-04-02 20:14:06 +00:00
|
|
|
|
"``.pyc`` files so that executing the same file is faster the second time "
|
|
|
|
|
"(recompilation from source to bytecode can be avoided). This \"intermediate "
|
|
|
|
|
"language\" is said to run on a :term:`virtual machine` that executes the "
|
|
|
|
|
"machine code corresponding to each bytecode. Do note that bytecodes are not "
|
|
|
|
|
"expected to work between different Python virtual machines, nor to be stable "
|
|
|
|
|
"between Python releases."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Le code source, en Python, est compilé en un bytecode, la représentation "
|
|
|
|
|
"interne à CPython d'un programme Python. Le bytecode est stocké dans un "
|
2017-05-15 21:58:44 +00:00
|
|
|
|
"fichier nommé ``.pyc`` de manière à ce qu'une seconde exécution soit plus "
|
|
|
|
|
"rapide (en évitant ainsi de recommencer la compilation en bytecode). On dit "
|
|
|
|
|
"que ce *langage intermédiaire* est exécuté sur une :term:`virtual machine` "
|
|
|
|
|
"qui exécute des instructions machine pour chaque instruction du bytecode. "
|
|
|
|
|
"Notez que le bytecode n'a pas vocation à fonctionner entre différentes "
|
|
|
|
|
"machines virtuelle Python, encore moins entre différentes version de Python."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:170
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A list of bytecode instructions can be found in the documentation for :ref:"
|
|
|
|
|
"`the dis module <bytecodes>`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une liste des instructions du bytecode se trouve dans la documentation du :"
|
|
|
|
|
"ref:`module dis <bytecodes>`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:172
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "class"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "classe"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:174
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A template for creating user-defined objects. Class definitions normally "
|
|
|
|
|
"contain method definitions which operate on instances of the class."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un modèle pour créer des objets définis par l'utilisateur. Les définitions "
|
|
|
|
|
"de classes (*class*) contiennent normalement des définitions de méthodes qui "
|
|
|
|
|
"agissent sur les instances de classe."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:177
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "coercion"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "coercition"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:179
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The implicit conversion of an instance of one type to another during an "
|
|
|
|
|
"operation which involves two arguments of the same type. For example, "
|
|
|
|
|
"``int(3.15)`` converts the floating point number to the integer ``3``, but "
|
|
|
|
|
"in ``3+4.5``, each argument is of a different type (one int, one float), and "
|
|
|
|
|
"both must be converted to the same type before they can be added or it will "
|
|
|
|
|
"raise a ``TypeError``. Without coercion, all arguments of even compatible "
|
|
|
|
|
"types would have to be normalized to the same value by the programmer, e.g., "
|
|
|
|
|
"``float(3)+4.5`` rather than just ``3+4.5``."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"La conversion implicite d'une instance d'un type vers un autre lors d'une "
|
|
|
|
|
"opération impliquant deux opérandes de même type. Par exemple ``int(3.15)`` "
|
|
|
|
|
"convertis explicitement le nombre à virgule flottante en nombre entier (ici, "
|
|
|
|
|
"``3``), mais dans l'opération ``3 + 4.5``, les deux opérandes ont un type "
|
|
|
|
|
"différent, alors qu'elles doivent avoir le même type pour être additionnées, "
|
|
|
|
|
"sans quoi une exception ``TypeError`` serait levée. Sans coercition, toutes "
|
|
|
|
|
"les opérandes, même de types compatibles, devraient être converties (on "
|
|
|
|
|
"parle aussi de *cast*) explicitement par le développeur, par exemple : "
|
|
|
|
|
"``float(3) + 4.5`` au lieu du simple ``3 + 4.5``."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:187
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "complex number"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "nombre complexe"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:189
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An extension of the familiar real number system in which all numbers are "
|
|
|
|
|
"expressed as a sum of a real part and an imaginary part. Imaginary numbers "
|
|
|
|
|
"are real multiples of the imaginary unit (the square root of ``-1``), often "
|
|
|
|
|
"written ``i`` in mathematics or ``j`` in engineering. Python has built-in "
|
|
|
|
|
"support for complex numbers, which are written with this latter notation; "
|
|
|
|
|
"the imaginary part is written with a ``j`` suffix, e.g., ``3+1j``. To get "
|
|
|
|
|
"access to complex equivalents of the :mod:`math` module, use :mod:`cmath`. "
|
|
|
|
|
"Use of complex numbers is a fairly advanced mathematical feature. If you're "
|
|
|
|
|
"not aware of a need for them, it's almost certain you can safely ignore them."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une extension du système numéral réel familier dans laquelle tous les "
|
|
|
|
|
"nombres sont exprimés sous la forme d'une somme d'un réel et d'un "
|
|
|
|
|
"imaginaire. Les nombres imaginaures sont de réels multiples d'une unité "
|
|
|
|
|
"imaginaire (la racine carrée de ``-1``), souvent écrite ``i`` en "
|
|
|
|
|
"mathématiques ou ``j`` en ingénierie. Python supporte nativement les nombres "
|
|
|
|
|
"complexes, écrits avec cette dernière notation; la partie imaginaire est "
|
|
|
|
|
"écrite avec un suffixe ``j``, exemple, ``3+1j``. Pour utiliser les "
|
|
|
|
|
"équivalents complexes à :mod:`math`, utilisez :mod:`cmath`. L'utilisation "
|
|
|
|
|
"des nombres complexes est une caractéristiques des mathématiques avancées. "
|
|
|
|
|
"Si vous n'en avez pas l'utilité, vous pouvez les ignorer en toute "
|
|
|
|
|
"tranquilité."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:199
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "context manager"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "gestionnaire de contexte"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:201
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An object which controls the environment seen in a :keyword:`with` statement "
|
|
|
|
|
"by defining :meth:`__enter__` and :meth:`__exit__` methods. See :pep:`343`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un objet contrôlant l'environnement a l'intérieur d'une instruction :keyword:"
|
|
|
|
|
"`with` en définissant les méthodes :meth:`__enter__` et :meth:`__exit__`. "
|
|
|
|
|
"Consultez la :pep:`343`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:204
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "contiguous"
|
2016-10-21 12:43:16 +00:00
|
|
|
|
msgstr "contigu"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:208
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A buffer is considered contiguous exactly if it is either *C-contiguous* or "
|
|
|
|
|
"*Fortran contiguous*. Zero-dimensional buffers are C and Fortran "
|
|
|
|
|
"contiguous. In one-dimensional arrays, the items must be laid out in memory "
|
|
|
|
|
"next to each other, in order of increasing indexes starting from zero. In "
|
|
|
|
|
"multidimensional C-contiguous arrays, the last index varies the fastest when "
|
|
|
|
|
"visiting items in order of memory address. However, in Fortran contiguous "
|
|
|
|
|
"arrays, the first index varies the fastest."
|
|
|
|
|
msgstr ""
|
2016-10-21 12:43:16 +00:00
|
|
|
|
"Un buffer est considéré contigu s’il est soit *C-contigu* soit *Fortran-"
|
|
|
|
|
"contigu*. Les tableaux de dimension zéro sont C-contigus et Fortran-"
|
|
|
|
|
"contigus. Pour un tableau à une dimension, ses éléments doivent être placés "
|
|
|
|
|
"en mémoire l’un à côté de l’autre, dans l’ordre croissant de leur indice, "
|
|
|
|
|
"commençant à zéro. Pour qu’un tableau multidimensionnel soit C-contigu, le "
|
|
|
|
|
"dernier indice doit être celui qui varie le plus rapidement lors du parcours "
|
|
|
|
|
"de ses éléments dans l’ordre de leur adresse mémoire. A l'inverse, dans les "
|
|
|
|
|
"tableaux Fortran-contigu, c’est le premier indice qui doit varier le plus "
|
|
|
|
|
"rapidement."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:216
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "coroutine"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "coroutine"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:218
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Coroutines is a more generalized form of subroutines. Subroutines are "
|
|
|
|
|
"entered at one point and exited at another point. Coroutines can be "
|
|
|
|
|
"entered, exited, and resumed at many different points. They can be "
|
|
|
|
|
"implemented with the :keyword:`async def` statement. See also :pep:`492`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Les coroutines sont une forme généralisées des fonctions. Les fonctions sont "
|
|
|
|
|
"accédées en un point et sortent en un point. Les coroutines peuvent être "
|
|
|
|
|
"accédées, quittées, reprises en plusieurs points. Elles peuvent être "
|
|
|
|
|
"implémentées via l'instruction :keyword:`async def`. Voir aussi :pep:`492`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:223
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "coroutine function"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "fonction coroutine"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:225
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A function which returns a :term:`coroutine` object. A coroutine function "
|
|
|
|
|
"may be defined with the :keyword:`async def` statement, and may contain :"
|
|
|
|
|
"keyword:`await`, :keyword:`async for`, and :keyword:`async with` keywords. "
|
|
|
|
|
"These were introduced by :pep:`492`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une fonction qui donne un objet :term:`coroutine`. Une fonction coroutine "
|
|
|
|
|
"peut être définie par l'instruction :keyword:`async def`, et peuvent "
|
|
|
|
|
"contenir les mots clefs :keyword:`await`, :keyword:`async for`, et :keyword:"
|
|
|
|
|
"`async with`. Elles sont introduites par la :pep:`492`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:230
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "CPython"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "CPython"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:232
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The canonical implementation of the Python programming language, as "
|
|
|
|
|
"distributed on `python.org <https://www.python.org>`_. The term \"CPython\" "
|
|
|
|
|
"is used when necessary to distinguish this implementation from others such "
|
|
|
|
|
"as Jython or IronPython."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"L'implémentation canonique du langage de programmation Python, tel que "
|
|
|
|
|
"distribué sur `python.org <https://www.python.org>`_. Le terme \"CPython\" "
|
|
|
|
|
"est utilisé dans certains contextes lorsqu'il est nécessaire de distinguer "
|
|
|
|
|
"cette implémentation des autres comme Jython ou IronPython."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:236
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "decorator"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "décorateur"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:238
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A function returning another function, usually applied as a function "
|
|
|
|
|
"transformation using the ``@wrapper`` syntax. Common examples for "
|
|
|
|
|
"decorators are :func:`classmethod` and :func:`staticmethod`."
|
|
|
|
|
msgstr ""
|
2017-09-22 09:08:03 +00:00
|
|
|
|
"Une fonction renvoyant une autre fonction, utilisé habituellement dans une "
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"transformation de fonction via la syntaxe ``@wrapper``. Les exemples "
|
|
|
|
|
"habituels pour les décorateurs (*decorators*) sont :func:`classmethod` et :"
|
|
|
|
|
"func:`staticmethod`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:242
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The decorator syntax is merely syntactic sugar, the following two function "
|
|
|
|
|
"definitions are semantically equivalent::"
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"La syntaxe des décorateurs est simplement du sucre syntaxique, les "
|
|
|
|
|
"définitions des deux fonctions suivantes sont sémantiquement équivalentes :"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:253
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The same concept exists for classes, but is less commonly used there. See "
|
|
|
|
|
"the documentation for :ref:`function definitions <function>` and :ref:`class "
|
|
|
|
|
"definitions <class>` for more about decorators."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Quoique moins fréquemment utilisé, le même concept existe pour les classes. "
|
|
|
|
|
"Consultez la documentation :ref:`définitions de fonctions <function>` et :"
|
|
|
|
|
"ref:`définitions de classes <class>` pour en savoir plus sur les décorateurs."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:256
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "descriptor"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "descripteur"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:258
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Any object which defines the methods :meth:`__get__`, :meth:`__set__`, or :"
|
|
|
|
|
"meth:`__delete__`. When a class attribute is a descriptor, its special "
|
|
|
|
|
"binding behavior is triggered upon attribute lookup. Normally, using *a.b* "
|
|
|
|
|
"to get, set or delete an attribute looks up the object named *b* in the "
|
|
|
|
|
"class dictionary for *a*, but if *b* is a descriptor, the respective "
|
|
|
|
|
"descriptor method gets called. Understanding descriptors is a key to a deep "
|
|
|
|
|
"understanding of Python because they are the basis for many features "
|
|
|
|
|
"including functions, methods, properties, class methods, static methods, and "
|
|
|
|
|
"reference to super classes."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"N'importe quel objet définissant les méthodes :meth:`__get__`, :meth:"
|
|
|
|
|
"`__set__`, ou :meth:`__delete__`. Lorsque l'attribut d'une classe est un "
|
|
|
|
|
"descripteur, son comportement spécial est déclenché lors de la recherche des "
|
|
|
|
|
"attributs. En utilisant *a.b* pour obtenir, affecter, ou effacer un "
|
|
|
|
|
"attribut, il recherche l'objet nommé *b* dans la dictionnaire de la classe "
|
|
|
|
|
"pour *a*, mais si *b* est un descripteur, la méthode de ce descripteur est "
|
|
|
|
|
"alors appelée. Comprendre les descripteurs est la clé d'une compréhension "
|
|
|
|
|
"approfondie de Python, ils sont la base de nombre de ses caractéristiques "
|
|
|
|
|
"notamment les fonctions, méthodes, propriétés, méthodes de classe, méthodes "
|
|
|
|
|
"statiques, et les références aux classes mères."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:268
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"For more information about descriptors' methods, see :ref:`descriptors`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Pour plus d'informations sur les méthodes des descripteurs, consultez :ref:"
|
|
|
|
|
"`descriptors`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:269
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "dictionary"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "dictionnaire"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:271
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An associative array, where arbitrary keys are mapped to values. The keys "
|
|
|
|
|
"can be any object with :meth:`__hash__` and :meth:`__eq__` methods. Called a "
|
|
|
|
|
"hash in Perl."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une structure de donnée associant des clefs et des valeurs. Les clefs "
|
|
|
|
|
"peuvent être n'importe quel objet comportant les méthodes :meth:`__hash__` "
|
|
|
|
|
"et :meth:`__eq__`. Elle s'appelle \"*hash*\" en Perl."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:274
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "dictionary view"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "vue de dictionnaire"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:276
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The objects returned from :meth:`dict.keys`, :meth:`dict.values`, and :meth:"
|
|
|
|
|
"`dict.items` are called dictionary views. They provide a dynamic view on the "
|
|
|
|
|
"dictionary’s entries, which means that when the dictionary changes, the view "
|
|
|
|
|
"reflects these changes. To force the dictionary view to become a full list "
|
|
|
|
|
"use ``list(dictview)``. See :ref:`dict-views`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Les objets donnés par les méthodes :meth:`dict.keys`, :meth:`dict.values`, "
|
|
|
|
|
"et :meth:`dict.items` sont des vues de dictionnaire. Ce sont des vues, "
|
|
|
|
|
"dynamiques, des entrées du dictionnaire, ce qui signifie que lorsque le "
|
|
|
|
|
"dictionnaire change, la vue change. Pour transformer une vue en vrai liste, "
|
|
|
|
|
"utilisez ``list(dictview)``. Voir :ref:`dict-views`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:282
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "docstring"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "docstring"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:284
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A string literal which appears as the first expression in a class, function "
|
|
|
|
|
"or module. While ignored when the suite is executed, it is recognized by "
|
|
|
|
|
"the compiler and put into the :attr:`__doc__` attribute of the enclosing "
|
|
|
|
|
"class, function or module. Since it is available via introspection, it is "
|
|
|
|
|
"the canonical place for documentation of the object."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une chaîne littérale étant la première expression d'une classe, fonction, ou "
|
|
|
|
|
"module. Bien qu'ignoré à l'exécution, elles sont reconnues par le "
|
|
|
|
|
"compilateur, et placées dans l'attribut :attr:`__doc__` de sa classe, "
|
|
|
|
|
"fonction, ou module respectif. Puisque cette chaîne est disponible par "
|
|
|
|
|
"introspection, c'est l'endroit idéal pour documenter l'objet."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:290
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "duck-typing"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "duck-typing"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:292
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A programming style which does not look at an object's type to determine if "
|
|
|
|
|
"it has the right interface; instead, the method or attribute is simply "
|
|
|
|
|
"called or used (\"If it looks like a duck and quacks like a duck, it must be "
|
|
|
|
|
"a duck.\") By emphasizing interfaces rather than specific types, well-"
|
|
|
|
|
"designed code improves its flexibility by allowing polymorphic "
|
|
|
|
|
"substitution. Duck-typing avoids tests using :func:`type` or :func:"
|
|
|
|
|
"`isinstance`. (Note, however, that duck-typing can be complemented with :"
|
|
|
|
|
"term:`abstract base classes <abstract base class>`.) Instead, it typically "
|
|
|
|
|
"employs :func:`hasattr` tests or :term:`EAFP` programming."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un style de programmation qui ne prend pas en compte le type d'un objet pour "
|
|
|
|
|
"déterminer s'il respecte une interface, mais qui qui appelle simplement la "
|
|
|
|
|
"méthode ou l'attribut (*Si ça a un bec et que ça cancane, c'est un canard*). "
|
|
|
|
|
"En se concentrant sur les interfaces plutôt que les types, du code bien "
|
|
|
|
|
"construit améliore sa flexibilité en autorisant des substitutions "
|
|
|
|
|
"polymorphiques. Un code orienté *duck-typing* évite de vérifier les types "
|
|
|
|
|
"via :func:`type` ou :func:`isinstance`, (notez cependant que le duck-typing "
|
|
|
|
|
"peut travailler de pair avec les :term:`classes de base abstraites <classe "
|
|
|
|
|
"de base abstraite>`.) À la place, le *duck-typing* utilise plutôt :func:"
|
|
|
|
|
"`hasattr` ou la programmation :term:`EAFP`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:301
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "EAFP"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "EAFP"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:303
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Easier to ask for forgiveness than permission. This common Python coding "
|
|
|
|
|
"style assumes the existence of valid keys or attributes and catches "
|
|
|
|
|
"exceptions if the assumption proves false. This clean and fast style is "
|
|
|
|
|
"characterized by the presence of many :keyword:`try` and :keyword:`except` "
|
|
|
|
|
"statements. The technique contrasts with the :term:`LBYL` style common to "
|
|
|
|
|
"many other languages such as C."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Il est plus simple de demander pardon que demander la permission (*Easier to "
|
|
|
|
|
"Ask for Forgiveness than Permission*). Ce style de développement Python fait "
|
|
|
|
|
"l'hypothèse que le code est valide, et attrape les exceptions si cette "
|
|
|
|
|
"hypothèse s'avèrait fausse. Ce style, propre et efficace, est caractérisé "
|
|
|
|
|
"par la présence de beaucoup de mot clé :keyword:`try` et :keyword:`except`. "
|
|
|
|
|
"Cette technique de programmation contraste avec le style :term:`LBYL` "
|
|
|
|
|
"présent couramment dans des langages tel que C."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:309
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "expression"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "expression"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:311
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A piece of syntax which can be evaluated to some value. In other words, an "
|
|
|
|
|
"expression is an accumulation of expression elements like literals, names, "
|
|
|
|
|
"attribute access, operators or function calls which all return a value. In "
|
|
|
|
|
"contrast to many other languages, not all language constructs are "
|
|
|
|
|
"expressions. There are also :term:`statement`\\s which cannot be used as "
|
|
|
|
|
"expressions, such as :keyword:`if`. Assignments are also statements, not "
|
|
|
|
|
"expressions."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une suite logique de termes et chiffres conformes à la syntaxe Python dont "
|
|
|
|
|
"l'évaluation fournit une valeur. En d'autres termes, une expression est une "
|
|
|
|
|
"suite d'éléments tels que des noms, opérateurs, littéraux, accès "
|
|
|
|
|
"d'attributs, méthodes ou fonctions qui aboutissent à une valeur. "
|
|
|
|
|
"Contrairement à beaucoup d'autres langages, les différentes constructions du "
|
|
|
|
|
"langage ne sont pas toutes des expressions. Il y a également des :term:"
|
|
|
|
|
"`instructions <statement>` qui ne peuvent pas être utilisées comme "
|
|
|
|
|
"expressions, tel que :keyword:`if`. Les affectations sont également des "
|
|
|
|
|
"instructions et non des expressions."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:318
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "extension module"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "module d'extension"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:320
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A module written in C or C++, using Python's C API to interact with the core "
|
|
|
|
|
"and with user code."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un module écrit en C ou C++, utilisant l'API C de Python pour interagir avec "
|
|
|
|
|
"Python et le code de l'utilisateur."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:322
|
|
|
|
|
msgid "f-string"
|
2017-05-15 21:58:44 +00:00
|
|
|
|
msgstr "f-string"
|
2017-04-02 20:14:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:324
|
|
|
|
|
msgid ""
|
|
|
|
|
"String literals prefixed with ``'f'`` or ``'F'`` are commonly called \"f-"
|
|
|
|
|
"strings\" which is short for :ref:`formatted string literals <f-strings>`. "
|
|
|
|
|
"See also :pep:`498`."
|
|
|
|
|
msgstr ""
|
2017-05-15 21:58:44 +00:00
|
|
|
|
"Les chaînes littérales préfixées de ``'f'`` ou ``'F'`` sont communément "
|
|
|
|
|
"appelées \"f-strings\", le raccourci pour :ref:`formatted string literals <f-"
|
|
|
|
|
"strings>`. Voir la :pep:`498`."
|
2017-04-02 20:14:06 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/glossary.rst:327
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "file object"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "objet fichier"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:329
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An object exposing a file-oriented API (with methods such as :meth:`read()` "
|
|
|
|
|
"or :meth:`write()`) to an underlying resource. Depending on the way it was "
|
|
|
|
|
"created, a file object can mediate access to a real on-disk file or to "
|
|
|
|
|
"another type of storage or communication device (for example standard input/"
|
|
|
|
|
"output, in-memory buffers, sockets, pipes, etc.). File objects are also "
|
|
|
|
|
"called :dfn:`file-like objects` or :dfn:`streams`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un objet exposant une ressource via une API orientée fichier (avec les "
|
|
|
|
|
"méthodes :meth:`read()` ou :meth:`write()`). En fonction de la manière dont "
|
|
|
|
|
"ils ont été créés, les objets fichiers peuvent exposer un fichier sur le "
|
|
|
|
|
"disque, ou un autre type de stockage ou de communication (typiquement "
|
|
|
|
|
"l'entrée standard, la sortie standard, un tampon en mémoire, des "
|
|
|
|
|
"sockets, ...). Les objets fichiers sont aussi appelés :dfn:`file-like-"
|
|
|
|
|
"objects` ou :dfn:`streams`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:337
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"There are actually three categories of file objects: raw :term:`binary files "
|
|
|
|
|
"<binary file>`, buffered :term:`binary files <binary file>` and :term:`text "
|
|
|
|
|
"files <text file>`. Their interfaces are defined in the :mod:`io` module. "
|
|
|
|
|
"The canonical way to create a file object is by using the :func:`open` "
|
|
|
|
|
"function."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Il existe en réalité trois catégories de fichiers objets : les :term:"
|
|
|
|
|
"`fichiers binaires <fichier binaire>` bruts, les :term:`fichiers binaire "
|
|
|
|
|
"<fichier binaire>` bufferisés, et les :term:`fichiers texte <fichier "
|
|
|
|
|
"texte>`. Leurs interfaces sont définies dans le module :mod:`io`. Le moyen "
|
|
|
|
|
"le plus simple et direct de créer un objet fichier est d'utiliser la "
|
|
|
|
|
"fonction :func:`open`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:342
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "file-like object"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "objet fichier-compatible"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:344
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "A synonym for :term:`file object`."
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Un synonyme de :term:`objet fichier`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:345
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "finder"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "finder"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:347
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An object that tries to find the :term:`loader` for a module that is being "
|
|
|
|
|
"imported."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un objet qui essaye de trouver un :term:`loader` pour le module étant "
|
|
|
|
|
"importé."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:350
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Since Python 3.3, there are two types of finder: :term:`meta path finders "
|
|
|
|
|
"<meta path finder>` for use with :data:`sys.meta_path`, and :term:`path "
|
|
|
|
|
"entry finders <path entry finder>` for use with :data:`sys.path_hooks`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Depuis Python 3.3, il existe deux types de *finder*: :term:`meta path "
|
|
|
|
|
"finders <meta path finder>` à utiliser avec :data:`sys.meta_path`, et :term:"
|
|
|
|
|
"`path entry finders <path entry finder>` à utiliser avec :data:`sys."
|
|
|
|
|
"path_hooks`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:354
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "See :pep:`302`, :pep:`420` and :pep:`451` for much more detail."
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Voir :pep:`302`, :pep:`420` et :pep:`451` pour plus de détails."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:355
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "floor division"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "division entière"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:357
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Mathematical division that rounds down to nearest integer. The floor "
|
|
|
|
|
"division operator is ``//``. For example, the expression ``11 // 4`` "
|
|
|
|
|
"evaluates to ``2`` in contrast to the ``2.75`` returned by float true "
|
|
|
|
|
"division. Note that ``(-11) // 4`` is ``-3`` because that is ``-2.75`` "
|
|
|
|
|
"rounded *downward*. See :pep:`238`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Division mathématique arrondissant à l'entier le plus petit. L'opérateur de "
|
|
|
|
|
"la division entière est ``//``. Par exemple l'expression ``11 // 4`` vaut "
|
|
|
|
|
"``2``, contrairement à ``11 / 4`` qui vaut ``2.75``. Notez que ``(-11) // "
|
|
|
|
|
"4`` vaut ``-3`` car l'arrondi se fait par le bas. Voir la :pep:`328`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:362
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "function"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "fonction"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:364
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A series of statements which returns some value to a caller. It can also be "
|
|
|
|
|
"passed zero or more :term:`arguments <argument>` which may be used in the "
|
|
|
|
|
"execution of the body. See also :term:`parameter`, :term:`method`, and the :"
|
|
|
|
|
"ref:`function` section."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une suite d'instructions qui renvoient une valeur à celui qui l'appelle. On "
|
|
|
|
|
"peut aussi lui passer des :term:`arguments <argument>` qui pourront être "
|
|
|
|
|
"utilisés dans le corps de la fonction. Voir aussi :term:`paramètre`, :term:"
|
|
|
|
|
"`méthode`, et :ref:`function`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:368
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "function annotation"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "annotation de fonction"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:370
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An arbitrary metadata value associated with a function parameter or return "
|
|
|
|
|
"value. Its syntax is explained in section :ref:`function`. Annotations may "
|
|
|
|
|
"be accessed via the :attr:`__annotations__` special attribute of a function "
|
|
|
|
|
"object."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une métadonnée quelconque, associée au paramètre d'une fonction ou sa valeur "
|
|
|
|
|
"de retour. Sa syntaxe est documentée dans la section :ref:`function`. Les "
|
|
|
|
|
"annotations sont accessibles via l'attribut spécial :attr:`__annotations__` "
|
|
|
|
|
"d'une fonction."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:375
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Python itself does not assign any particular meaning to function "
|
|
|
|
|
"annotations. They are intended to be interpreted by third-party libraries or "
|
|
|
|
|
"tools. See :pep:`3107`, which describes some of their potential uses."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Python ne prend pas en compte les annotations. Leur but est d'être "
|
|
|
|
|
"interprétées par d'autres bibliothèques ou outils. Voir la :pep:`3207`, qui "
|
|
|
|
|
"décrit certains usages."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:378
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "__future__"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "__future__"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:380
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A pseudo-module which programmers can use to enable new language features "
|
|
|
|
|
"which are not compatible with the current interpreter."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un pseudo-module que les développeurs peuvent utiliser pour activer de "
|
|
|
|
|
"nouvelles fonctionnalités du langage qui ne sont pas compatibles avec "
|
|
|
|
|
"l'interpréteur utilisé."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:383
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"By importing the :mod:`__future__` module and evaluating its variables, you "
|
|
|
|
|
"can see when a new feature was first added to the language and when it "
|
|
|
|
|
"becomes the default::"
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"En important le module :mod:`__future__` et en affichant ses variables, vous "
|
|
|
|
|
"pouvez voir quand une nouvelle fonctionnalité à été rajoutée dans le "
|
|
|
|
|
"langage, et quand elle devient le comportement par défaut : ::"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:390
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "garbage collection"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "ramasse-miettes"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:392
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The process of freeing memory when it is not used anymore. Python performs "
|
|
|
|
|
"garbage collection via reference counting and a cyclic garbage collector "
|
|
|
|
|
"that is able to detect and break reference cycles."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"(*garbage collection*) Le mécanisme permettant de libérer de la mémoire "
|
|
|
|
|
"lorsqu'elle n'est plus utilisée. Python utilise un ramasse-miettes par "
|
|
|
|
|
"comptage de référence, et un ramasse-miettes cyclique capable de détecter et "
|
|
|
|
|
"casser les références circulaires."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:397
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "generator"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "générateur"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:399
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A function which returns a :term:`generator iterator`. It looks like a "
|
|
|
|
|
"normal function except that it contains :keyword:`yield` expressions for "
|
|
|
|
|
"producing a series of values usable in a for-loop or that can be retrieved "
|
|
|
|
|
"one at a time with the :func:`next` function."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une fonction qui renvoie un :term:`itérateur de générateur`. Cela ressemble "
|
|
|
|
|
"à une fonction normale, en dehors du fait qu'elle contient une ou des "
|
|
|
|
|
"expressions :keyword:`yield` pruduisant une série de valeurs utilisable dans "
|
|
|
|
|
"une boucle *for*, ou récupérées une à une via la fonction :func:`next`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:404
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Usually refers to a generator function, but may refer to a *generator "
|
|
|
|
|
"iterator* in some contexts. In cases where the intended meaning isn't "
|
|
|
|
|
"clear, using the full terms avoids ambiguity."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Fait généralement allusion à une fonction générateur, mais peut faire "
|
|
|
|
|
"allusion à un *itérateur de générateur* dans certains contextes. Dans les "
|
|
|
|
|
"cas où le sens voulu n'est pas clair, utiliser les termes complets évite "
|
|
|
|
|
"l'ambiguité."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:407
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "generator iterator"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "itérateur de générateur"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:409
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "An object created by a :term:`generator` function."
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Un objet crée par une fonction :term:`générateur`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:411
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Each :keyword:`yield` temporarily suspends processing, remembering the "
|
|
|
|
|
"location execution state (including local variables and pending try-"
|
|
|
|
|
"statements). When the *generator iterator* resumes, it picks-up where it "
|
|
|
|
|
"left-off (in contrast to functions which start fresh on every invocation)."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Chaque :keyword:`yield` suspend temporairement l'exécution, se rappelant de "
|
|
|
|
|
"l'endroit et de l'état de l'exécution (incluant les variables locales et les "
|
|
|
|
|
"*try* en cours). Lorsque l'itérateur de générateur reprend, il reprend où il "
|
|
|
|
|
"en était (contrairement à une fonction qui prendrait un nouveau départ à "
|
|
|
|
|
"chaque invocation)."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:418
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "generator expression"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "expression génératrice"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:420
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An expression that returns an iterator. It looks like a normal expression "
|
|
|
|
|
"followed by a :keyword:`for` expression defining a loop variable, range, and "
|
|
|
|
|
"an optional :keyword:`if` expression. The combined expression generates "
|
|
|
|
|
"values for an enclosing function::"
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une expression qui donne un itérateur. Cela ressemble à une expression "
|
|
|
|
|
"normale, suivie d'une expression :keyword:`for` définissant une variable de "
|
|
|
|
|
"boucle, d'un range, et d'une expression, optionnelle, :keyword:`if`. Cette "
|
|
|
|
|
"expression combinée génère des valeurs pour la fonction qui l'entoure : ::"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:427
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "generic function"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "fonction générique"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:429
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A function composed of multiple functions implementing the same operation "
|
|
|
|
|
"for different types. Which implementation should be used during a call is "
|
|
|
|
|
"determined by the dispatch algorithm."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une fonction composée de plusieurs fonctions implémentant les mêmes "
|
|
|
|
|
"opérations pour différents types. L'implémentation à utiliser est déterminé "
|
|
|
|
|
"lors de l'appel est déterminée par un algorithme de répartition."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:433
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"See also the :term:`single dispatch` glossary entry, the :func:`functools."
|
|
|
|
|
"singledispatch` decorator, and :pep:`443`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Voir aussi :term:`single dispatch`, le décorateur :func:`functools."
|
|
|
|
|
"singledispatch`, et la :pep:`443`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:436
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "GIL"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "GIL"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:438
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "See :term:`global interpreter lock`."
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Voir :term:`global interpreter lock`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:439
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "global interpreter lock"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "verrou global de l'interpréteur"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:441
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The mechanism used by the :term:`CPython` interpreter to assure that only "
|
|
|
|
|
"one thread executes Python :term:`bytecode` at a time. This simplifies the "
|
|
|
|
|
"CPython implementation by making the object model (including critical built-"
|
|
|
|
|
"in types such as :class:`dict`) implicitly safe against concurrent access. "
|
|
|
|
|
"Locking the entire interpreter makes it easier for the interpreter to be "
|
|
|
|
|
"multi-threaded, at the expense of much of the parallelism afforded by multi-"
|
|
|
|
|
"processor machines."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Le mécanisme utilisé par l'interpréteur :term:`CPython` pour s'assurer qu'un "
|
|
|
|
|
"seul thread n'execute du :term:`bytecode` à la fois. Cela simplifie "
|
|
|
|
|
"l'implémentation de CPython en rendant le modèle objet (incluant des parties "
|
|
|
|
|
"critiques comme la classe native :class:`dict`) implicitement protégé des "
|
|
|
|
|
"accès concourants. Vérouiller l'interpréteur entier le rend plus facile à "
|
|
|
|
|
"rendre multi-thread, en perdant malheureusement la majorité du parallélisme "
|
|
|
|
|
"possible sur les machines ayant plusieurs processeurs."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:450
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"However, some extension modules, either standard or third-party, are "
|
|
|
|
|
"designed so as to release the GIL when doing computationally-intensive tasks "
|
|
|
|
|
"such as compression or hashing. Also, the GIL is always released when doing "
|
|
|
|
|
"I/O."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Cependant, certains modules d'extension, standards ou non, sont construits "
|
|
|
|
|
"de manière à libérer le GIL lorsqu'ils effectuent des tâches lourdes tel que "
|
|
|
|
|
"la compression ou le hachage. Aussi, le GIL est toujours libéré lors des "
|
|
|
|
|
"lectures et écritures."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:455
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Past efforts to create a \"free-threaded\" interpreter (one which locks "
|
|
|
|
|
"shared data at a much finer granularity) have not been successful because "
|
|
|
|
|
"performance suffered in the common single-processor case. It is believed "
|
|
|
|
|
"that overcoming this performance issue would make the implementation much "
|
|
|
|
|
"more complicated and therefore costlier to maintain."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Les tentatives précédentes d'implémenter un interpréteur Python avec une "
|
|
|
|
|
"granularité de verrouillage plus fine ont toutes échouées, à cause de leur "
|
|
|
|
|
"performances sur un seul processeur. Il est admis que corriger c'est "
|
|
|
|
|
"problèmes de performance induits mènerai vers une implémentation compliquée "
|
|
|
|
|
"et donc plus coûteuse à maintenir."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:460
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "hashable"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "hachable"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:462
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An object is *hashable* if it has a hash value which never changes during "
|
|
|
|
|
"its lifetime (it needs a :meth:`__hash__` method), and can be compared to "
|
|
|
|
|
"other objects (it needs an :meth:`__eq__` method). Hashable objects which "
|
|
|
|
|
"compare equal must have the same hash value."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un objet est *hachable* s'il a une empreinte (*hash*) qui ne change jamais. "
|
|
|
|
|
"(et il a besoin d'une méthode :meth:`__hash__`) et peut être comparé à "
|
|
|
|
|
"d'autres objets (avec la méthode :meth:`__eq__`). Les objets hachables dont "
|
|
|
|
|
"``__eq__`` dit être équivalents, ont aussi la même empreinte."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:467
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Hashability makes an object usable as a dictionary key and a set member, "
|
|
|
|
|
"because these data structures use the hash value internally."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"La hachabilité permet à un objet d'être utilisé comme clef de dictionnaire, "
|
|
|
|
|
"ou en temps que membre d'un *set*, car ces structures de données utilisent "
|
|
|
|
|
"ce *hash*."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:470
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
2017-04-02 20:14:06 +00:00
|
|
|
|
"All of Python's immutable built-in objects are hashable; mutable containers "
|
|
|
|
|
"(such as lists or dictionaries) are not. Objects which are instances of "
|
|
|
|
|
"user-defined classes are hashable by default. They all compare unequal "
|
2016-10-17 19:42:06 +00:00
|
|
|
|
"(except with themselves), and their hash value is derived from their :func:"
|
|
|
|
|
"`id`."
|
|
|
|
|
msgstr ""
|
2017-05-15 21:58:44 +00:00
|
|
|
|
"Tous les types immuables natifs de Python sont hachables, mais les "
|
2017-10-27 15:42:48 +00:00
|
|
|
|
"conteneurs muables (comme les listes ou les dictionnaires) ne le sont pas. "
|
2017-05-15 21:58:44 +00:00
|
|
|
|
"Toutes les instances de classes définies par les utilisateurs sont hachables "
|
|
|
|
|
"par défaut. Elles sont toutes considérées différentes (sauf avec elles-"
|
|
|
|
|
"mêmes), et leur clef de hachage est tiré de leur :func:`id`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:475
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "IDLE"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "IDLE"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:477
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An Integrated Development Environment for Python. IDLE is a basic editor "
|
|
|
|
|
"and interpreter environment which ships with the standard distribution of "
|
|
|
|
|
"Python."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un environnement de développement intégré pour Python. IDLE est un éditeur "
|
|
|
|
|
"et interpréteur basique livré avec la distribution standard de Python."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:480
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "immutable"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "immuable"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:482
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An object with a fixed value. Immutable objects include numbers, strings "
|
|
|
|
|
"and tuples. Such an object cannot be altered. A new object has to be "
|
|
|
|
|
"created if a different value has to be stored. They play an important role "
|
|
|
|
|
"in places where a constant hash value is needed, for example as a key in a "
|
|
|
|
|
"dictionary."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un objet dont la valeur ne change pas. Les nombres, les chaînes et les "
|
|
|
|
|
"tuples sont immuables. Ils ne peuvent être modifiés. Un nouvel objet doit "
|
|
|
|
|
"être créé si une valeur différente doit être stockée. Ils jouent un rôle "
|
|
|
|
|
"important aux endroits où une valeur de *hash* constante est requise, "
|
|
|
|
|
"typiquement en clef de dictionnaire."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:487
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "import path"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "chemin d'import"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:489
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A list of locations (or :term:`path entries <path entry>`) that are searched "
|
|
|
|
|
"by the :term:`path based finder` for modules to import. During import, this "
|
|
|
|
|
"list of locations usually comes from :data:`sys.path`, but for subpackages "
|
|
|
|
|
"it may also come from the parent package's ``__path__`` attribute."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une liste de :term:`chemins <chemin>` dans lesquels le :term:`path based "
|
|
|
|
|
"finder` cherche les modules à importer. Typiquement lors d'un import cette "
|
|
|
|
|
"liste vient de :data:`sys.path`, mais pour les sous paquets, elle peut aussi "
|
|
|
|
|
"venir de l'attribut ``__path__`` du paquet parent."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:494
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "importing"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "importer"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:496
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The process by which Python code in one module is made available to Python "
|
|
|
|
|
"code in another module."
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Le processus rendant le code d'un module disponible dans un autre."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:498
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "importer"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "importateur"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:500
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An object that both finds and loads a module; both a :term:`finder` and :"
|
|
|
|
|
"term:`loader` object."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un objet qui trouve et charge un module, en même temps un :term:`finder` et "
|
|
|
|
|
"un :term:`loader`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:502
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "interactive"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "interactif"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:504
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Python has an interactive interpreter which means you can enter statements "
|
|
|
|
|
"and expressions at the interpreter prompt, immediately execute them and see "
|
|
|
|
|
"their results. Just launch ``python`` with no arguments (possibly by "
|
|
|
|
|
"selecting it from your computer's main menu). It is a very powerful way to "
|
|
|
|
|
"test out new ideas or inspect modules and packages (remember ``help(x)``)."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Python a un interpréteur interactif, ce qui signifie que vous pouvez écrire "
|
|
|
|
|
"des expressions et instructions à l'invite de l'interpréteur, qui va les "
|
|
|
|
|
"exécuter immédiatement, et vous en présenter le résultat. Démarrez juste "
|
|
|
|
|
"``python`` (probablement depuis un menu de votre ordinateur). C'est un moyen "
|
|
|
|
|
"puissant pour tester de nouvelles idées ou étudier de nouveaux modules "
|
|
|
|
|
"(souvenez vous de ``help(x)``)."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:510
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "interpreted"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "interprété"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:512
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Python is an interpreted language, as opposed to a compiled one, though the "
|
|
|
|
|
"distinction can be blurry because of the presence of the bytecode compiler. "
|
|
|
|
|
"This means that source files can be run directly without explicitly creating "
|
|
|
|
|
"an executable which is then run. Interpreted languages typically have a "
|
|
|
|
|
"shorter development/debug cycle than compiled ones, though their programs "
|
|
|
|
|
"generally also run more slowly. See also :term:`interactive`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Python est un langage interprété, en opposition aux langages compilés, bien "
|
|
|
|
|
"que la frontière soit floue du à la présence d'un compilateur en bytecode. "
|
|
|
|
|
"Cela signifie que les fichiers sources peuvent être exécutés directement, "
|
|
|
|
|
"sans avoir à compiler un fichier exécutable intermédiaire. Les langages "
|
|
|
|
|
"interprétées ont généralement un cycle de développement / débug plus rapide, "
|
|
|
|
|
"et ils s'exécutent généralement plus lentement. Voir aussi :term:"
|
|
|
|
|
"`interactif`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:519
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "interpreter shutdown"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "arrêt de l'interpréteur"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:521
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"When asked to shut down, the Python interpreter enters a special phase where "
|
|
|
|
|
"it gradually releases all allocated resources, such as modules and various "
|
|
|
|
|
"critical internal structures. It also makes several calls to the :term:"
|
|
|
|
|
"`garbage collector <garbage collection>`. This can trigger the execution of "
|
|
|
|
|
"code in user-defined destructors or weakref callbacks. Code executed during "
|
|
|
|
|
"the shutdown phase can encounter various exceptions as the resources it "
|
|
|
|
|
"relies on may not function anymore (common examples are library modules or "
|
|
|
|
|
"the warnings machinery)."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Lorsqu'on lui demande de s'arrêter, l'interpréteur Python entre dans une "
|
|
|
|
|
"phase spéciale où il libère graduellement les ressources allouées, comme les "
|
|
|
|
|
"modules ou quelques structures de données internes. Il fait aussi quelques "
|
|
|
|
|
"appels au :term:`ramasse-miettes`. Cela peut déclencher l'exécution de code "
|
|
|
|
|
"dans des destructeurs ou des fonctions de rappels de *weakrefs*. Le code "
|
|
|
|
|
"exécuté lors de l'arrêt peut rencontrer quelques exception puisque les "
|
|
|
|
|
"ressources sur lesquels il pourrait s'appuyer pourraient ne plus "
|
|
|
|
|
"fonctionner, (typiquement les modules de la bibliothèque ou le mécanisme de "
|
|
|
|
|
"*warning*)."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:530
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The main reason for interpreter shutdown is that the ``__main__`` module or "
|
|
|
|
|
"the script being run has finished executing."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"La principale raison qu'a l'interpréteur de s'arrêter est lorsque le module "
|
|
|
|
|
"``__main__`` ou le script en cours d'exécution à terminé de s'exécuter."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:532
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "iterable"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "itérable"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:534
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An object capable of returning its members one at a time. Examples of "
|
|
|
|
|
"iterables include all sequence types (such as :class:`list`, :class:`str`, "
|
|
|
|
|
"and :class:`tuple`) and some non-sequence types like :class:`dict`, :term:"
|
|
|
|
|
"`file objects <file object>`, and objects of any classes you define with an :"
|
|
|
|
|
"meth:`__iter__` or :meth:`__getitem__` method. Iterables can be used in a :"
|
|
|
|
|
"keyword:`for` loop and in many other places where a sequence is needed (:"
|
|
|
|
|
"func:`zip`, :func:`map`, ...). When an iterable object is passed as an "
|
|
|
|
|
"argument to the built-in function :func:`iter`, it returns an iterator for "
|
|
|
|
|
"the object. This iterator is good for one pass over the set of values. "
|
|
|
|
|
"When using iterables, it is usually not necessary to call :func:`iter` or "
|
|
|
|
|
"deal with iterator objects yourself. The ``for`` statement does that "
|
|
|
|
|
"automatically for you, creating a temporary unnamed variable to hold the "
|
|
|
|
|
"iterator for the duration of the loop. See also :term:`iterator`, :term:"
|
|
|
|
|
"`sequence`, and :term:`generator`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un objet capable de donner ses éléments un à un. Pour lister quelques "
|
|
|
|
|
"exemples d'itérables, on pourrait lister tout les types séquence (comme :"
|
|
|
|
|
"class:`list`, :class:`str`, et :class:`tuple`), et quelques autres comme :"
|
|
|
|
|
"class:`dict`, :term:`objets fichiers <objet fichier>`, ou tout objet de "
|
|
|
|
|
"toute classe ayant une méthode :meth:`__iter__` ou :meth:`__getitem__`. Les "
|
|
|
|
|
"itérables peuvent être utilisés dans des boucles :keyword:`for` ou tout "
|
|
|
|
|
"autre endroit où une séquence est requise (:func:`zip`, :func:`map`, ...). "
|
|
|
|
|
"Lorsqu'un itérable est passé comme argument à la fonction native :func:"
|
|
|
|
|
"`iter`, elle donnera un itérateur de cet itérable. Cet itérateur n'est "
|
|
|
|
|
"valable que pour une passe sur le jeu de valeurs. Lors de l'utilisation "
|
|
|
|
|
"d'itérables, il n'est habituellement pas nécessaire d'appeler :func:`iter` "
|
|
|
|
|
"ou de s'occuper d'objet itérateurs. L'instruction ``for`` fait ça "
|
|
|
|
|
"automatiquement pour vous, créant une variable temporaire anonyme pour "
|
|
|
|
|
"garder l'itérateur durant la boucle. Voir aussi :term:`itérateur`, :term:"
|
|
|
|
|
"`séquence`, et :term:`générateur`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:548
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "iterator"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "itérateur"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:550
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An object representing a stream of data. Repeated calls to the iterator's :"
|
|
|
|
|
"meth:`~iterator.__next__` method (or passing it to the built-in function :"
|
|
|
|
|
"func:`next`) return successive items in the stream. When no more data are "
|
|
|
|
|
"available a :exc:`StopIteration` exception is raised instead. At this "
|
|
|
|
|
"point, the iterator object is exhausted and any further calls to its :meth:"
|
|
|
|
|
"`__next__` method just raise :exc:`StopIteration` again. Iterators are "
|
|
|
|
|
"required to have an :meth:`__iter__` method that returns the iterator object "
|
|
|
|
|
"itself so every iterator is also iterable and may be used in most places "
|
|
|
|
|
"where other iterables are accepted. One notable exception is code which "
|
|
|
|
|
"attempts multiple iteration passes. A container object (such as a :class:"
|
|
|
|
|
"`list`) produces a fresh new iterator each time you pass it to the :func:"
|
|
|
|
|
"`iter` function or use it in a :keyword:`for` loop. Attempting this with an "
|
|
|
|
|
"iterator will just return the same exhausted iterator object used in the "
|
|
|
|
|
"previous iteration pass, making it appear like an empty container."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un objet représentant un flux de donnée. Des appels successifs à la méthode :"
|
|
|
|
|
"meth:`~iterator.__next__` de l'itérateur (ou le donner à la fonction native :"
|
|
|
|
|
"func:`next`) donne successivement les objets du flux. Lorsque plus aucune "
|
|
|
|
|
"donnée n'est disponible, une exception :exc:`StopIteration` est lancée. À ce "
|
|
|
|
|
"point, l'itérateur est épuisé et tous les appels suivants à sa méthode :meth:"
|
|
|
|
|
"`__next__` lanceront encore une exception :exc:`StopIteration`. Les "
|
|
|
|
|
"itérateurs doivent avoir une méthode :meth:`__iter__` qui renvoie l'objet "
|
|
|
|
|
"itérateur lui même, tel que chaque itérateur soit aussi itérable et puisse "
|
|
|
|
|
"être utilisé dans la plupart des endroits où d'autres itérables sont "
|
|
|
|
|
"attendus. Une exception notable serait un code qui tenterai plusieurs "
|
|
|
|
|
"itérations complètes. Un objet conteneur, (tel que :class:`list`) produit un "
|
|
|
|
|
"nouvel itérateur neuf à chaque fois qu'il est donné à la fonction :func:"
|
|
|
|
|
"`iter` où qu'il est utilisé dans une boucle :keyword:`for`. Faire ceci sur "
|
|
|
|
|
"un itérateur donnerai simplement le même objet itérateur épuisé utilisé dans "
|
|
|
|
|
"son itération précédente, le faisant ressembler à un conteneur vide."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:565
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "More information can be found in :ref:`typeiter`."
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Plus d'informations ici : :ref:`typeiter`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:566
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "key function"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "fonction clef"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:568
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A key function or collation function is a callable that returns a value used "
|
|
|
|
|
"for sorting or ordering. For example, :func:`locale.strxfrm` is used to "
|
|
|
|
|
"produce a sort key that is aware of locale specific sort conventions."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une fonction clef, est un objet appelable qui renvoie une valeur utilisée "
|
|
|
|
|
"pour trier ou organiser. Par exemple la fonction :func:`local.strxfrm` sert "
|
|
|
|
|
"à produire une fonction clef de tri prennant en compte les conventions de "
|
|
|
|
|
"tri spécifiques aux paramètres régionaux courants."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:573
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A number of tools in Python accept key functions to control how elements are "
|
|
|
|
|
"ordered or grouped. They include :func:`min`, :func:`max`, :func:`sorted`, :"
|
|
|
|
|
"meth:`list.sort`, :func:`heapq.merge`, :func:`heapq.nsmallest`, :func:`heapq."
|
|
|
|
|
"nlargest`, and :func:`itertools.groupby`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Plusieurs outils dans Python acceptent des fonctions clef pour maîtriser "
|
|
|
|
|
"comment les éléments dont triés ou groupés. Typiquement les fonctions :func:"
|
|
|
|
|
"`min`, :func:`max`, :func:`sorted`, :meth:`list.sort`, :func:`heapq.merge`, :"
|
|
|
|
|
"func:`heapq.nsmallest`, :func:`heapq.nlargest`, et :func:`itertools.groupby`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:579
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"There are several ways to create a key function. For example. the :meth:"
|
|
|
|
|
"`str.lower` method can serve as a key function for case insensitive sorts. "
|
|
|
|
|
"Alternatively, a key function can be built from a :keyword:`lambda` "
|
|
|
|
|
"expression such as ``lambda r: (r[0], r[2])``. Also, the :mod:`operator` "
|
|
|
|
|
"module provides three key function constructors: :func:`~operator."
|
|
|
|
|
"attrgetter`, :func:`~operator.itemgetter`, and :func:`~operator."
|
|
|
|
|
"methodcaller`. See the :ref:`Sorting HOW TO <sortinghowto>` for examples of "
|
|
|
|
|
"how to create and use key functions."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Il existe plusieurs moyens de créer une fonction clef. Par exemple, la "
|
|
|
|
|
"méthode :meth:`str.lower` peut servir en fonction clef pour effectuer des "
|
|
|
|
|
"recherches insensibles à la casse. Aussi, il est possible de créer des "
|
|
|
|
|
"fonctions clef avec des expressions :keyword:`lambda`, comme ``lambda r: "
|
|
|
|
|
"(r[0], r[2])``. Finalement le module :mod:`operator` fournit des "
|
|
|
|
|
"constructeurs de fonctions clef : :func:`~operator.attrgetter`, :func:"
|
|
|
|
|
"`~operator.itemgetter`, et :func:`~operator.methodcaller`. Voir :ref:"
|
|
|
|
|
"`Comment Trier <sortinghowto>` pour avoir des exemple de création et "
|
|
|
|
|
"d'utilisation de fonctions clés."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:587
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "keyword argument"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "argument nommé"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:589 ../Doc/glossary.rst:833
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "See :term:`argument`."
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Voir :term:`argument`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:590
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "lambda"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "lambda"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:592
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An anonymous inline function consisting of a single :term:`expression` which "
|
|
|
|
|
"is evaluated when the function is called. The syntax to create a lambda "
|
|
|
|
|
"function is ``lambda [arguments]: expression``"
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une fonction anonyme sous forme d'une :term:`expression`, et ne contenant "
|
|
|
|
|
"qu'une expression, exécutée lorsqu'elle est appelée. La syntaxe pour créer "
|
|
|
|
|
"des fonctions lambda est: ``lambda [arguments]: expression``"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:595
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "LBYL"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "LBYL"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:597
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Look before you leap. This coding style explicitly tests for pre-conditions "
|
|
|
|
|
"before making calls or lookups. This style contrasts with the :term:`EAFP` "
|
|
|
|
|
"approach and is characterized by the presence of many :keyword:`if` "
|
|
|
|
|
"statements."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Regarde devant avant de tomber, (*Look before you leap*). Ce style de "
|
|
|
|
|
"programmation consiste à vérifier des conditions avant d'effectuer des "
|
|
|
|
|
"appels ou des accès. Ce style contraste avec le style :term:`EAFP` et se "
|
|
|
|
|
"caractérise par la présence de beaucoup d'instructions :keyword:`if`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:602
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"In a multi-threaded environment, the LBYL approach can risk introducing a "
|
|
|
|
|
"race condition between \"the looking\" and \"the leaping\". For example, "
|
|
|
|
|
"the code, ``if key in mapping: return mapping[key]`` can fail if another "
|
|
|
|
|
"thread removes *key* from *mapping* after the test, but before the lookup. "
|
|
|
|
|
"This issue can be solved with locks or by using the EAFP approach."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Dans un environnement multi-thread, le style *LBYL* peut engendrer une "
|
|
|
|
|
"séquence critique (*race condition*) entre \"regarder\" et \"tomber\". Par "
|
|
|
|
|
"exemple, le code ``if key in mapping: return mapping[key]`` peut échouer si "
|
|
|
|
|
"un autre thread supprime la clef *key* du *mapping* après le test mais avant "
|
|
|
|
|
"l'accès. Ce problème peut être résolu avec des verrous (*locks*) ou avec "
|
|
|
|
|
"l'approche EAFP."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:607
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "list"
|
2017-09-12 12:04:46 +00:00
|
|
|
|
msgstr "*list*"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:609
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A built-in Python :term:`sequence`. Despite its name it is more akin to an "
|
|
|
|
|
"array in other languages than to a linked list since access to elements are "
|
|
|
|
|
"O(1)."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un type natif de :term:`sequence` dans Python. En dépit de son nom, une "
|
|
|
|
|
"``list`` ressemble plus à un *array* qu'à une liste chaînée puisque les "
|
|
|
|
|
"accès se font en O(1)."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:612
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "list comprehension"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "liste en compréhension"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:614
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A compact way to process all or part of the elements in a sequence and "
|
|
|
|
|
"return a list with the results. ``result = ['{:#04x}'.format(x) for x in "
|
|
|
|
|
"range(256) if x % 2 == 0]`` generates a list of strings containing even hex "
|
|
|
|
|
"numbers (0x..) in the range from 0 to 255. The :keyword:`if` clause is "
|
|
|
|
|
"optional. If omitted, all elements in ``range(256)`` are processed."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un moyen compacte de manipuler tous ou partie des éléments d'une séquence "
|
|
|
|
|
"renvoyant une liste avec les résultats. ``result = ['{:#04x}'.format(x) for "
|
|
|
|
|
"x in range(256) if x % 2 == 0]`` génère une liste de chaînes de caractères "
|
|
|
|
|
"contenant les nombres paires sous forme hexadécimale (0x...) de 0 à 255. La "
|
|
|
|
|
"clause :keyword:`if` est optionnelle. Si elle est omise, tous les éléments "
|
|
|
|
|
"du ``range(256)`` seront utilisés."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:620
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "loader"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "loader"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:622
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An object that loads a module. It must define a method named :meth:"
|
|
|
|
|
"`load_module`. A loader is typically returned by a :term:`finder`. See :pep:"
|
|
|
|
|
"`302` for details and :class:`importlib.abc.Loader` for an :term:`abstract "
|
|
|
|
|
"base class`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un objet qui charge un module. Il doit définir une méthode nommée :meth:"
|
|
|
|
|
"`load_module`. Un *loader* est typiquement donné par un :term:`finder`. "
|
|
|
|
|
"Voir :pep:`302` pour les détails et :class:`importlib.ABC.Loader` pour sa :"
|
|
|
|
|
"term:`classe de base abstraite`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:626
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "mapping"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "mapping"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:628
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A container object that supports arbitrary key lookups and implements the "
|
|
|
|
|
"methods specified in the :class:`~collections.abc.Mapping` or :class:"
|
|
|
|
|
"`~collections.abc.MutableMapping` :ref:`abstract base classes <collections-"
|
|
|
|
|
"abstract-base-classes>`. Examples include :class:`dict`, :class:"
|
|
|
|
|
"`collections.defaultdict`, :class:`collections.OrderedDict` and :class:"
|
|
|
|
|
"`collections.Counter`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un conteneur acceptant de rechercher des éléments par clef et implémente les "
|
|
|
|
|
"méthodes des :ref:`classes de base abstraites <collections-abstract-base-"
|
|
|
|
|
"classes>` :class:`collections.abc.Mapping` ou :class:`collections.abc."
|
|
|
|
|
"MutableMapping`. Les classes suivantes sont des exemples de mapping: :class:"
|
|
|
|
|
"`dict`, :class:`collections.defaultdict`, :class:`collections.OrderedDict`, "
|
|
|
|
|
"et :class:`collections.Counter`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:634
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "meta path finder"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "meta path finder"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:636
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A :term:`finder` returned by a search of :data:`sys.meta_path`. Meta path "
|
|
|
|
|
"finders are related to, but different from :term:`path entry finders <path "
|
|
|
|
|
"entry finder>`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un :term:`finder` donné par une recherche dans :data:`sys.meta_path`. Les "
|
|
|
|
|
"*meta path finders* ressemblent, mais sont différents de :term:`path entry "
|
|
|
|
|
"finders <path entry finder>`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:640
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"See :class:`importlib.abc.MetaPathFinder` for the methods that meta path "
|
|
|
|
|
"finders implement."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Voir :class:`importlib.abc.MetaPathFinder` pour les méthodes que les *meta "
|
|
|
|
|
"path finders* doivent implémenter."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:642
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "metaclass"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "metaclasse"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:644
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The class of a class. Class definitions create a class name, a class "
|
|
|
|
|
"dictionary, and a list of base classes. The metaclass is responsible for "
|
|
|
|
|
"taking those three arguments and creating the class. Most object oriented "
|
|
|
|
|
"programming languages provide a default implementation. What makes Python "
|
|
|
|
|
"special is that it is possible to create custom metaclasses. Most users "
|
|
|
|
|
"never need this tool, but when the need arises, metaclasses can provide "
|
|
|
|
|
"powerful, elegant solutions. They have been used for logging attribute "
|
|
|
|
|
"access, adding thread-safety, tracking object creation, implementing "
|
|
|
|
|
"singletons, and many other tasks."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"La classe d'une classe. Les définitions de classe créent un nom pour la "
|
|
|
|
|
"classe, un dictionnaire et une liste de classes patentes. La métaclasse a "
|
|
|
|
|
"pour rôle de réunir ces trois paramètres pour construire la classe. La "
|
|
|
|
|
"plupart des langages orientés objet fournissent une implémentation par "
|
|
|
|
|
"défaut. Ce qui rend Python spécial, c'est de proposer de créer des "
|
|
|
|
|
"métaclasses personnalisées. La plupart des utilisateurs n'ont pas besoin de "
|
|
|
|
|
"cet outil, mais lorsque le besoin survient, les métaclasses sont souvent des "
|
|
|
|
|
"solutions élégantes, puissantes, et utiles. Elles ont été utilisées pour "
|
|
|
|
|
"journaliser les accès à des propriétés, rendre un objet sûr pour une "
|
|
|
|
|
"utilisation en environnement multi-thread, suivre la création d'objets, "
|
|
|
|
|
"implémenter des singleton, et bien d'autres tâches."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:654
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "More information can be found in :ref:`metaclasses`."
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Plus d'informations à ce sujet : :ref:`metaclasses`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:655
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "method"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "méthode"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:657
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A function which is defined inside a class body. If called as an attribute "
|
|
|
|
|
"of an instance of that class, the method will get the instance object as its "
|
|
|
|
|
"first :term:`argument` (which is usually called ``self``). See :term:"
|
|
|
|
|
"`function` and :term:`nested scope`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une fonction définie dans une classe. Lorsqu'elle est appelée comme un "
|
|
|
|
|
"attribut d'une instance, la méthode reçoit l'instance en premier :term:"
|
|
|
|
|
"`argument` (qui par convention est nommé ``self``). Voir :term:`function` "
|
|
|
|
|
"et :term:`nested scope`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:661
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "method resolution order"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "ordre de résolution des méthodes"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:663
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Method Resolution Order is the order in which base classes are searched for "
|
|
|
|
|
"a member during lookup. See `The Python 2.3 Method Resolution Order <https://"
|
|
|
|
|
"www.python.org/download/releases/2.3/mro/>`_ for details of the algorithm "
|
|
|
|
|
"used by the Python interpreter since the 2.3 release."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"L'ordre de résolution des méthodes (*MRO* de *Method Resolution Order*) est "
|
|
|
|
|
"l'ordre par lequel les membres sont recherchées dans les classes parentes. "
|
|
|
|
|
"Voir `The Python 2.3 Method Resolution Order <https://www.python.org/"
|
|
|
|
|
"download/releases/2.3/mro/>`_ pour plus de détails sur l'algorithme utilisé "
|
|
|
|
|
"par l'interpréteur Python depuis la version 2.3."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:667
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "module"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "module"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:669
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An object that serves as an organizational unit of Python code. Modules "
|
|
|
|
|
"have a namespace containing arbitrary Python objects. Modules are loaded "
|
|
|
|
|
"into Python by the process of :term:`importing`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"L'unité élémentaire de l'organisation du code en Python. Les modules ont un "
|
|
|
|
|
"espace de noms pouvant contenir n'importe quel objet Python. Charger des "
|
|
|
|
|
"modules est appelé :term:`importer`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:673
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "See also :term:`package`."
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Voir aussi :term:`paquet`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:674
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "module spec"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "module spec"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:676
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A namespace containing the import-related information used to load a module. "
|
|
|
|
|
"An instance of :class:`importlib.machinery.ModuleSpec`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un espace de nom contenant les informations, relatives à l'import, utilisés "
|
|
|
|
|
"pour charger un module. C'est une instance de la classe :class:`importlib."
|
|
|
|
|
"machinery.ModuleSpec`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:678
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "MRO"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "MRO"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:680
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "See :term:`method resolution order`."
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Voir :term:`ordre de résolution des méthodes`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:681
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "mutable"
|
2017-10-27 15:42:48 +00:00
|
|
|
|
msgstr "muable"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:683
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Mutable objects can change their value but keep their :func:`id`. See also :"
|
|
|
|
|
"term:`immutable`."
|
|
|
|
|
msgstr ""
|
2017-10-27 15:42:48 +00:00
|
|
|
|
"Un objet muable peut changer de valeur tout en gardant le même :func:`id`. "
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Voir aussi :term:`immuable`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:685
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "named tuple"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "named tuple"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:687
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Any tuple-like class whose indexable elements are also accessible using "
|
|
|
|
|
"named attributes (for example, :func:`time.localtime` returns a tuple-like "
|
|
|
|
|
"object where the *year* is accessible either with an index such as ``t[0]`` "
|
|
|
|
|
"or with a named attribute like ``t.tm_year``)."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une classe qui, comme *tuple* a ses éléments accessibles par leur indice, "
|
|
|
|
|
"mais en plus accessibles par leur nom (par exemple, :func:`time.localtime` "
|
|
|
|
|
"donne un objet ressemblant à un *tuple*, dont *year* est accessible par son "
|
|
|
|
|
"indice : ``t[0]`` ou par son nom : ``t.tm_year``)."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:692
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A named tuple can be a built-in type such as :class:`time.struct_time`, or "
|
|
|
|
|
"it can be created with a regular class definition. A full featured named "
|
|
|
|
|
"tuple can also be created with the factory function :func:`collections."
|
|
|
|
|
"namedtuple`. The latter approach automatically provides extra features such "
|
|
|
|
|
"as a self-documenting representation like ``Employee(name='jones', "
|
|
|
|
|
"title='programmer')``."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un *named tuple* peut être un type natif tel que :class:`time.struct_time` "
|
|
|
|
|
"ou il peut être construit comme une simple classe. Un *named tuple* complet "
|
|
|
|
|
"peut aussi être créé via la fonction :func:`collections.namedtuple`. Cette "
|
|
|
|
|
"dernière approche fournit automatiquement des fonctionnalités "
|
|
|
|
|
"supplémentaires, tel qu'une représentation lisible comme "
|
|
|
|
|
"``Employee(name='jones', title='programmer')``."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:698
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "namespace"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "espace de nom"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:700
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The place where a variable is stored. Namespaces are implemented as "
|
|
|
|
|
"dictionaries. There are the local, global and built-in namespaces as well "
|
|
|
|
|
"as nested namespaces in objects (in methods). Namespaces support modularity "
|
|
|
|
|
"by preventing naming conflicts. For instance, the functions :func:`builtins."
|
|
|
|
|
"open <.open>` and :func:`os.open` are distinguished by their namespaces. "
|
|
|
|
|
"Namespaces also aid readability and maintainability by making it clear which "
|
|
|
|
|
"module implements a function. For instance, writing :func:`random.seed` or :"
|
|
|
|
|
"func:`itertools.islice` makes it clear that those functions are implemented "
|
|
|
|
|
"by the :mod:`random` and :mod:`itertools` modules, respectively."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"L'endroit où une variable est stockée. Les espaces de noms sont en fait des "
|
|
|
|
|
"dictionnaires. Il existe des espaces de noms globaux, natifs, ou imbriqués "
|
|
|
|
|
"dans les objets (dans les méthodes). Les espaces de noms sont modulaires "
|
|
|
|
|
"afin d'éviter les conflits de noms. Par exemple, les fonctions :func:"
|
|
|
|
|
"`builtins.open <.open>` et :func:`os.open` sont différenciées par leurs "
|
|
|
|
|
"espaces de nom. Les espaces de noms aident aussi à la lisibilité et "
|
|
|
|
|
"maintenabilité en rendant clair quel module implémente une fonction. Par "
|
|
|
|
|
"exemple, écrire :func:`random.seed` ou :func:`itertools.islice` rend clair "
|
|
|
|
|
"que ces fonctions sont implémentées respectivement dans les modules :mod:"
|
|
|
|
|
"`random` et :mod:`itertools`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:710
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "namespace package"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "paquet espace de nom"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:712
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A :pep:`420` :term:`package` which serves only as a container for "
|
|
|
|
|
"subpackages. Namespace packages may have no physical representation, and "
|
|
|
|
|
"specifically are not like a :term:`regular package` because they have no "
|
|
|
|
|
"``__init__.py`` file."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un :term:`paquet` tel que défini dans la :pep:`421` qui ne sert qu'à "
|
|
|
|
|
"contenir des sous paquets. Les paquets-espace de nom peuvent n'avoir aucune "
|
|
|
|
|
"représentation physique, et plus spécifiquement ne sont pas comme un :term:"
|
|
|
|
|
"`paquet classique` puisqu'ils n'ont pas de fichier ``__init__.py``."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:717
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "See also :term:`module`."
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Voir aussi :term:`module`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:718
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "nested scope"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "portée imbriquée"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:720
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The ability to refer to a variable in an enclosing definition. For "
|
|
|
|
|
"instance, a function defined inside another function can refer to variables "
|
|
|
|
|
"in the outer function. Note that nested scopes by default work only for "
|
|
|
|
|
"reference and not for assignment. Local variables both read and write in "
|
|
|
|
|
"the innermost scope. Likewise, global variables read and write to the "
|
|
|
|
|
"global namespace. The :keyword:`nonlocal` allows writing to outer scopes."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"La possibilité de toucher une variable déclarée dans une définition "
|
|
|
|
|
"englobante. Typiquement, une fonction définie à l'intérieur d'une autre "
|
|
|
|
|
"fonction aura accès aux variables de cette autre fonction. Souvenez-vous "
|
|
|
|
|
"cependant que cela ne fonctionne que pour accéder à des variables, pas pour "
|
|
|
|
|
"les assigner. Les variables locales sont lues et assignées dans l'espace de "
|
|
|
|
|
"nom le plus proche. Tout comme les variables globales qui sont stockés sur "
|
|
|
|
|
"l'espace de noms global, le mot clef :keyword:`nonlocal` permet d'écrire "
|
|
|
|
|
"dans l'espace de nom dans lequel est déclaré la variable."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:727
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "new-style class"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "nouvelle classe"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:729
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Old name for the flavor of classes now used for all class objects. In "
|
|
|
|
|
"earlier Python versions, only new-style classes could use Python's newer, "
|
|
|
|
|
"versatile features like :attr:`~object.__slots__`, descriptors, properties, :"
|
|
|
|
|
"meth:`__getattribute__`, class methods, and static methods."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Ancien nom pour l'implémentation actuelle des classes, pour tous les objets. "
|
|
|
|
|
"Dans les anciennes versions de Python, seulement les nouvelles classes "
|
|
|
|
|
"pouvaient utiliser les nouvelles fonctionnalités tel que :attr:`~object."
|
|
|
|
|
"__slots__`, les descripteurs, les propriétés, :meth:`__getattribute__`, les "
|
|
|
|
|
"méthodes de classe, et les méthodes statiques."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:733
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "object"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "objet"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:735
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Any data with state (attributes or value) and defined behavior (methods). "
|
|
|
|
|
"Also the ultimate base class of any :term:`new-style class`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"N'importe quelle donnée comportant des états sous forme d'attributs ou de "
|
|
|
|
|
"valeurs, et un comportement (des méthodes). C'est aussi (``object``) "
|
|
|
|
|
"l'ancêtre commun à absolument toutes les :term:`nouvelles classes <new-style "
|
|
|
|
|
"class>`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:738
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "package"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "paquet"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:740
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A Python :term:`module` which can contain submodules or recursively, "
|
|
|
|
|
"subpackages. Technically, a package is a Python module with an ``__path__`` "
|
|
|
|
|
"attribute."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un :term:`module` qui peut contenir des sous modules ou des sous paquets. "
|
|
|
|
|
"Techniquement, un paquet est un module qui a un attribut ``__path__``."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:744
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "See also :term:`regular package` and :term:`namespace package`."
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Voir aussi :term:`paquet classique` et :term:`paquet espace de nom`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:745
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "parameter"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "paramètre"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:747
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A named entity in a :term:`function` (or method) definition that specifies "
|
|
|
|
|
"an :term:`argument` (or in some cases, arguments) that the function can "
|
|
|
|
|
"accept. There are five kinds of parameter:"
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une entité nommée, dans la définition d'une :term:`fonction` (ou méthode, "
|
|
|
|
|
"décrivant un :term:`argument` (ou dans certains cas des arguments) que la "
|
|
|
|
|
"fonction accepte. Il existe cinq sorte de paramètres :"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:751
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
":dfn:`positional-or-keyword`: specifies an argument that can be passed "
|
|
|
|
|
"either :term:`positionally <argument>` or as a :term:`keyword argument "
|
|
|
|
|
"<argument>`. This is the default kind of parameter, for example *foo* and "
|
|
|
|
|
"*bar* in the following::"
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
":dfn:`positional-or-keyword`: dit d'un argument qui peut être passé soit par "
|
|
|
|
|
"sa :term:`position <argument>` soit en temps que :term:`paramètre nommé "
|
|
|
|
|
"<argument>`. C'est le type de paramètre par défaut, par exemple, *foo* et "
|
|
|
|
|
"*bar* dans l'exemple suivant : ::"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:760
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
":dfn:`positional-only`: specifies an argument that can be supplied only by "
|
|
|
|
|
"position. Python has no syntax for defining positional-only parameters. "
|
|
|
|
|
"However, some built-in functions have positional-only parameters (e.g. :func:"
|
|
|
|
|
"`abs`)."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
":dfn:`positional-only`: un argument qui ne peut être donné que par sa "
|
|
|
|
|
"position. Python n'a pas de syntaxe pour déclarer de tels paramètre, "
|
|
|
|
|
"cependant des fonctions natives, comme :func:`abs` en utilisent."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:767
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
":dfn:`keyword-only`: specifies an argument that can be supplied only by "
|
|
|
|
|
"keyword. Keyword-only parameters can be defined by including a single var-"
|
|
|
|
|
"positional parameter or bare ``*`` in the parameter list of the function "
|
|
|
|
|
"definition before them, for example *kw_only1* and *kw_only2* in the "
|
|
|
|
|
"following::"
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
":dfn:`keyword-only`: définit un argument qui ne peut être fournit que par "
|
|
|
|
|
"nom. Les paramètres *keyword-only* peuvent être définis en utilisant un seul "
|
|
|
|
|
"paramètre *var-positional*, ou en ajoutant une étoire (*) seule dans la "
|
|
|
|
|
"liste des paramètres avant avant eux. Comme kw_only1 et kw_only2 ici : ::"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:775
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
":dfn:`var-positional`: specifies that an arbitrary sequence of positional "
|
|
|
|
|
"arguments can be provided (in addition to any positional arguments already "
|
|
|
|
|
"accepted by other parameters). Such a parameter can be defined by "
|
|
|
|
|
"prepending the parameter name with ``*``, for example *args* in the "
|
|
|
|
|
"following::"
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
":dfn:`var-positional`: spécifie qu'une séquence d'arguments positionels peut "
|
|
|
|
|
"être fourni (en plus de tous les arguments positionels déjà acceptés par "
|
|
|
|
|
"d'autres paramètres). Un tel paramètre peut être définit en préfixant son "
|
|
|
|
|
"nom par une ``*``, par exemple *args* ici : ::"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:783
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
":dfn:`var-keyword`: specifies that arbitrarily many keyword arguments can be "
|
|
|
|
|
"provided (in addition to any keyword arguments already accepted by other "
|
|
|
|
|
"parameters). Such a parameter can be defined by prepending the parameter "
|
|
|
|
|
"name with ``**``, for example *kwargs* in the example above."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
":dfn:`var-keyword`: spécifie qu'une quantité arbitraire d'arguments peuvent "
|
|
|
|
|
"être passés par nom (en plus de tous les arguments nommés déjà acceptés par "
|
|
|
|
|
"d'autres paramètres). Un tel paramètre est définit en préfixant le nom du "
|
|
|
|
|
"paramètre par ``**``, par exemple, *kwargs* ci-dessus."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:789
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Parameters can specify both optional and required arguments, as well as "
|
|
|
|
|
"default values for some optional arguments."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Les paramètres peuvent décrire aussi bien des paramètres optionnels ou "
|
|
|
|
|
"obligatoires, aussi que des valeurs par défaut pour les paramètres "
|
|
|
|
|
"optionnels."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:792
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"See also the :term:`argument` glossary entry, the FAQ question on :ref:`the "
|
|
|
|
|
"difference between arguments and parameters <faq-argument-vs-parameter>`, "
|
|
|
|
|
"the :class:`inspect.Parameter` class, the :ref:`function` section, and :pep:"
|
|
|
|
|
"`362`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Voir aussi :term:`argument` dans le glossaire, la question sur :ref:`la "
|
|
|
|
|
"différence entre les arguments et les paramètre <faq-argument-vs-parameter>` "
|
|
|
|
|
"dans la FAQ, la classe :class:`inspect.Parameter`, la section :ref:"
|
|
|
|
|
"`function`, et la :pep:`362`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:796
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "path entry"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "chemin"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:798
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A single location on the :term:`import path` which the :term:`path based "
|
|
|
|
|
"finder` consults to find modules for importing."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un seul emplacement dans l':term:`import path` que le :term:`path based "
|
|
|
|
|
"finder` consulte pour trouver des modules à importer."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:800
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "path entry finder"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "path entry finder"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:802
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A :term:`finder` returned by a callable on :data:`sys.path_hooks` (i.e. a :"
|
|
|
|
|
"term:`path entry hook`) which knows how to locate modules given a :term:"
|
|
|
|
|
"`path entry`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un :term:`finder` donné par un appelable sur un :data:`sys.path_hooks` (çàd "
|
|
|
|
|
"un :term:`path entry hook`) qui sait où trouver des modules lorsqu'on lui "
|
|
|
|
|
"donne un :term:`path entry`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:806
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"See :class:`importlib.abc.PathEntryFinder` for the methods that path entry "
|
|
|
|
|
"finders implement."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Voir :class:`importlib.abc.PathEntryFinder` pour les méthodes qu'un *path "
|
|
|
|
|
"entry finder* doit implémenter."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:808
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "path entry hook"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "path entry hook"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:810
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A callable on the :data:`sys.path_hook` list which returns a :term:`path "
|
|
|
|
|
"entry finder` if it knows how to find modules on a specific :term:`path "
|
|
|
|
|
"entry`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un appelable dans la liste :data:`sys.path_hook` qui donne un :term:`path "
|
|
|
|
|
"entry finder` s'il sait où trouver des modules pour un :term:`path entry` "
|
|
|
|
|
"donné."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:813
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "path based finder"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "path based finder"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:815
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"One of the default :term:`meta path finders <meta path finder>` which "
|
|
|
|
|
"searches an :term:`import path` for modules."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"L'un des :term:`meta path finders <meta path finder>` par défaut qui cherche "
|
|
|
|
|
"des modules dans un :term:`import path`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:817
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "path-like object"
|
2016-10-21 12:43:16 +00:00
|
|
|
|
msgstr "objet simili-chemin"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:819
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An object representing a file system path. A path-like object is either a :"
|
|
|
|
|
"class:`str` or :class:`bytes` object representing a path, or an object "
|
|
|
|
|
"implementing the :class:`os.PathLike` protocol. An object that supports the :"
|
|
|
|
|
"class:`os.PathLike` protocol can be converted to a :class:`str` or :class:"
|
|
|
|
|
"`bytes` file system path by calling the :func:`os.fspath` function; :func:"
|
|
|
|
|
"`os.fsdecode` and :func:`os.fsencode` can be used to guarantee a :class:"
|
|
|
|
|
"`str` or :class:`bytes` result instead, respectively. Introduced by :pep:"
|
|
|
|
|
"`519`."
|
|
|
|
|
msgstr ""
|
2016-10-21 12:43:16 +00:00
|
|
|
|
"Un objet représentant un chemin du système de fichiers. Un objet simili-"
|
|
|
|
|
"chemin est soit un objet :class:`str` ou un objet :class:`bytes` "
|
|
|
|
|
"représentant un chemin, ou un objet implémentant le protocol :class:`os."
|
|
|
|
|
"PathLike`. Un objet qui supporte le protocol :class:`os.PathLike` peut être "
|
|
|
|
|
"converti en un chemin :class:`str` ou :class:`bytes` du système de fichier "
|
|
|
|
|
"en appellant la fonction :func:`os.fspath`. :func:`os.fsdecode` et :func:`os."
|
|
|
|
|
"fsencode` peuvent être utilisées, respectivement, pour garantir un résultat "
|
|
|
|
|
"de type :class:`str` ou :class:`bytes` à la place. Introduit dans la :pep:"
|
|
|
|
|
"`519`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:827
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "portion"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "portion"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:829
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A set of files in a single directory (possibly stored in a zip file) that "
|
|
|
|
|
"contribute to a namespace package, as defined in :pep:`420`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un jeu de fichiers dans un seul dossier (pouvant être stockés sous forme de "
|
|
|
|
|
"fichier zip) qui contribuent à l'espace de nom d'un paquet, tel que définit "
|
|
|
|
|
"dans la :pep:`420`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:831
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "positional argument"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "augment positionnel"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:834
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "provisional API"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "API provisoire"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:836
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A provisional API is one which has been deliberately excluded from the "
|
|
|
|
|
"standard library's backwards compatibility guarantees. While major changes "
|
|
|
|
|
"to such interfaces are not expected, as long as they are marked provisional, "
|
|
|
|
|
"backwards incompatible changes (up to and including removal of the "
|
|
|
|
|
"interface) may occur if deemed necessary by core developers. Such changes "
|
|
|
|
|
"will not be made gratuitously -- they will occur only if serious fundamental "
|
|
|
|
|
"flaws are uncovered that were missed prior to the inclusion of the API."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une API provisoire est une API délibérément exclue des garanties de "
|
|
|
|
|
"rétrocompatibilité de la bibliothèque standard. Bien que des changements "
|
|
|
|
|
"majeurs de telles interfaces ne sont pas attendus, tant qu'elles sont "
|
|
|
|
|
"marquées provisoires, des changement cassant la rétrocompatibilité (jusqu'à "
|
|
|
|
|
"sa suppression complète) peuvent survenir s'ils semblent nécessaires. Ces "
|
|
|
|
|
"modifications ne seront pas effectuées gratuitement, ils ne surviendront "
|
|
|
|
|
"seulement si de sérieux problèmes sont découvert, qui n'avaient pas étés "
|
|
|
|
|
"repérés avant l'ajout de l'API."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:845
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Even for provisional APIs, backwards incompatible changes are seen as a "
|
|
|
|
|
"\"solution of last resort\" - every attempt will still be made to find a "
|
|
|
|
|
"backwards compatible resolution to any identified problems."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Même pour les API provisoires, les changement cassant la rétrocompatibilité "
|
|
|
|
|
"sont des \"solutions de dernier recours\", tout ce qui est possible sera "
|
|
|
|
|
"fait pour tenter de résoudre les problème en conservant la "
|
|
|
|
|
"rétrocompatibilité."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:849
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"This process allows the standard library to continue to evolve over time, "
|
|
|
|
|
"without locking in problematic design errors for extended periods of time. "
|
|
|
|
|
"See :pep:`411` for more details."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Ce processus permet à la bibliothèque standard de continuer à évoluer avec "
|
|
|
|
|
"le temps, sans se bloquer longtemps sur des erreurs d'architecture. Voir la :"
|
|
|
|
|
"pep:`411` pour plus de détails."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:852
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "provisional package"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "paquet provisoire"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:854
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "See :term:`provisional API`."
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Voir :term:`provisional API`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:855
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "Python 3000"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Python 3000"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:857
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Nickname for the Python 3.x release line (coined long ago when the release "
|
|
|
|
|
"of version 3 was something in the distant future.) This is also abbreviated "
|
|
|
|
|
"\"Py3k\"."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Surnom de la série des Python 3.x (très vieux surnom donné à l'époque pour "
|
|
|
|
|
"Python 3 n'était qu'un futur lointain). Aussi abrégé \"Py3k\"."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:860
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "Pythonic"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Pythonique"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:862
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An idea or piece of code which closely follows the most common idioms of the "
|
|
|
|
|
"Python language, rather than implementing code using concepts common to "
|
|
|
|
|
"other languages. For example, a common idiom in Python is to loop over all "
|
|
|
|
|
"elements of an iterable using a :keyword:`for` statement. Many other "
|
|
|
|
|
"languages don't have this type of construct, so people unfamiliar with "
|
|
|
|
|
"Python sometimes use a numerical counter instead::"
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une idée, ou un bout de code, qui suit de près la philosophie de Python, "
|
|
|
|
|
"parfois en opposition avec les concepts rencontrés dans d'autres langages. "
|
|
|
|
|
"Typiquement, la coutume en Python est de parcourir les éléments d'un "
|
|
|
|
|
"itérable en utilisant :keyword:`for`. Beaucoup de langages n'ont pas cette "
|
|
|
|
|
"possibilité, donc les gens qui ne sont pas habitués à Python pourraient "
|
|
|
|
|
"parfois utiliser un compteur à la place : ::"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:872
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "As opposed to the cleaner, Pythonic method::"
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Plutôt qu'utiliser la méthode, plus propre et élégante, donc Pythonique : ::"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:876
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "qualified name"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "nom qualifié"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:878
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A dotted name showing the \"path\" from a module's global scope to a class, "
|
|
|
|
|
"function or method defined in that module, as defined in :pep:`3155`. For "
|
|
|
|
|
"top-level functions and classes, the qualified name is the same as the "
|
|
|
|
|
"object's name::"
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un nom, comprenant des points, montrant le \"chemin\" de l'espace de nom "
|
|
|
|
|
"globale d'un module à une class, fonction, ou méthode définie dans ce "
|
|
|
|
|
"module, tel que défini dans la :pep:`3155`. Pour les fonctions et classes de "
|
|
|
|
|
"premier niveau, le nom qualifié est le même que le nom de l'objet : ::"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:895
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"When used to refer to modules, the *fully qualified name* means the entire "
|
|
|
|
|
"dotted path to the module, including any parent packages, e.g. ``email.mime."
|
|
|
|
|
"text``::"
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Lorsqu'il est utilisé pour nommer des modules, le *nom qualifié complet* "
|
|
|
|
|
"signifie le chemin complet (séparé par des points) vers le module, incluant "
|
|
|
|
|
"tous les paquet parents, typiquement: ``email.mime.text`` ::"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:902
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "reference count"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "nombre de références"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:904
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The number of references to an object. When the reference count of an "
|
|
|
|
|
"object drops to zero, it is deallocated. Reference counting is generally "
|
|
|
|
|
"not visible to Python code, but it is a key element of the :term:`CPython` "
|
|
|
|
|
"implementation. The :mod:`sys` module defines a :func:`~sys.getrefcount` "
|
|
|
|
|
"function that programmers can call to return the reference count for a "
|
|
|
|
|
"particular object."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Le nombre de références à un objet. Lorsque le nombre de références à un "
|
|
|
|
|
"objet descend à zéro, l'objet est désalloué. Le comptage de référence n'est "
|
|
|
|
|
"généralement pas visible dans le code Python, mais c'est un élément clef de "
|
|
|
|
|
"l'implémentation :term:`CPython`. Le module :mod:`sys` défini une fonction :"
|
|
|
|
|
"func:`~sys.getrefcount` que les développeurs peuvent utiliser pour obtenir "
|
|
|
|
|
"le nombre de référence d'un objet donné."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:910
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "regular package"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "paquet classique"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:912
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A traditional :term:`package`, such as a directory containing an ``__init__."
|
|
|
|
|
"py`` file."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un :term:`paquet` traditionnel, tel qu'un dossier contenant un fichier "
|
|
|
|
|
"``__init__.py``."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:915
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "See also :term:`namespace package`."
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Voir aussi :term:`paquet espace de nom`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:916
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "__slots__"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "__slots__"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:918
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A declaration inside a class that saves memory by pre-declaring space for "
|
|
|
|
|
"instance attributes and eliminating instance dictionaries. Though popular, "
|
|
|
|
|
"the technique is somewhat tricky to get right and is best reserved for rare "
|
|
|
|
|
"cases where there are large numbers of instances in a memory-critical "
|
|
|
|
|
"application."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une déclaration dans une classe qui économise de la mémoire en pré-allouant "
|
|
|
|
|
"de l'espace pour les instances des attributs, et le dictionnaire des "
|
|
|
|
|
"instances. Bien que populaire, cette technique est difficile à maîtriser et "
|
|
|
|
|
"devrait être réservée à de rares cas avec un grand nombre d'instances dans "
|
|
|
|
|
"une application où la mémoire est un sujet critique."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:923
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "sequence"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "séquence"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:925
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An :term:`iterable` which supports efficient element access using integer "
|
|
|
|
|
"indices via the :meth:`__getitem__` special method and defines a :meth:"
|
|
|
|
|
"`__len__` method that returns the length of the sequence. Some built-in "
|
|
|
|
|
"sequence types are :class:`list`, :class:`str`, :class:`tuple`, and :class:"
|
|
|
|
|
"`bytes`. Note that :class:`dict` also supports :meth:`__getitem__` and :meth:"
|
|
|
|
|
"`__len__`, but is considered a mapping rather than a sequence because the "
|
|
|
|
|
"lookups use arbitrary :term:`immutable` keys rather than integers."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un :term:`itérable` qui gère l'accès efficient à ses éléments par un indice "
|
|
|
|
|
"sous forme de nombre entier via la méthode spéciale :meth:`__getitem__` et "
|
|
|
|
|
"qui défini une méthode :meth:`__len__` qui donne sa taille. Voici quelques "
|
|
|
|
|
"séquences natives : :class:`list`, :class:`str`, :class:`tuple`, et :class:"
|
|
|
|
|
"`bytes`. Notez que :class:`dict` a aussi une méthode :meth:`__getitem__` et "
|
|
|
|
|
"une méthode :meth:`__len__`, mais il est considéré comme un *mapping* plutôt "
|
|
|
|
|
"qu'une séquence, car ses accès se font par une clef arbitraire :term:"
|
|
|
|
|
"`immuable` plutôt qu'un nombre entier."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:934
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The :class:`collections.abc.Sequence` abstract base class defines a much "
|
|
|
|
|
"richer interface that goes beyond just :meth:`__getitem__` and :meth:"
|
|
|
|
|
"`__len__`, adding :meth:`count`, :meth:`index`, :meth:`__contains__`, and :"
|
|
|
|
|
"meth:`__reversed__`. Types that implement this expanded interface can be "
|
|
|
|
|
"registered explicitly using :func:`~abc.register`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"La class abstraite de base :class:`collections.abc.Sequence` défini une "
|
|
|
|
|
"interface plus riche qui va au delà des simples :meth:`__getitem__` et :meth:"
|
|
|
|
|
"`__len__`, en ajoutant :meth:`count`, :meth:`index`, :meth:`__contains__`, "
|
|
|
|
|
"et :meth:`__reversed__`. Les types qui implémentent cette interface étendue "
|
|
|
|
|
"peuvent s'enregistrer explicitement en utilisant :func:`~abc.register`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:941
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "single dispatch"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "distribution simple"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:943
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A form of :term:`generic function` dispatch where the implementation is "
|
|
|
|
|
"chosen based on the type of a single argument."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une forme de distribution, comme les :term:`fonction génériques <fonction "
|
|
|
|
|
"générique>`, où l'implémentation est choisie en fonction du type d'un seul "
|
|
|
|
|
"argument."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:945
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "slice"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "tranche"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:947
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"An object usually containing a portion of a :term:`sequence`. A slice is "
|
|
|
|
|
"created using the subscript notation, ``[]`` with colons between numbers "
|
|
|
|
|
"when several are given, such as in ``variable_name[1:3:5]``. The bracket "
|
|
|
|
|
"(subscript) notation uses :class:`slice` objects internally."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"*slice*, un objet contenant habituellement une portion de :term:`séquence`. "
|
|
|
|
|
"Une tranche est crée en utilisant la notation ``[]`` avec des ``:`` entre "
|
|
|
|
|
"les nombres lorsque plusieurs sont fournis, tel que dans "
|
|
|
|
|
"``variable_name[1:3:5]``. Cette notation utilise des objets :class:`slice` "
|
|
|
|
|
"en interne."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:951
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "special method"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "méthode spéciale"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:953
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A method that is called implicitly by Python to execute a certain operation "
|
|
|
|
|
"on a type, such as addition. Such methods have names starting and ending "
|
|
|
|
|
"with double underscores. Special methods are documented in :ref:"
|
|
|
|
|
"`specialnames`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"*special method*: Une méthode appelée implicitement par Python pour exécuter "
|
|
|
|
|
"une opération sur un type, tel qu'une addition. De telles méthodes ont des "
|
|
|
|
|
"noms commençant et terminant par des doubles tirets bas. Les méthodes "
|
|
|
|
|
"spéciales sont documentées dans :ref:`specialnames`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:957
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "statement"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "instruction"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:959
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A statement is part of a suite (a \"block\" of code). A statement is either "
|
|
|
|
|
"an :term:`expression` or one of several constructs with a keyword, such as :"
|
|
|
|
|
"keyword:`if`, :keyword:`while` or :keyword:`for`."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une instruction (*statement*) fait partie d'une suite, (un \"bloc\" de "
|
|
|
|
|
"code). Une instruction est soit une :term:`expression` soit une ou plusieurs "
|
|
|
|
|
"constructions basées sur un mot-clef, tel qu'un :keyword:`if`, :keyword:"
|
|
|
|
|
"`while`, ou :keyword:`for`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:962
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "struct sequence"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "struct sequence"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:964
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A tuple with named elements. Struct sequences expose an interface similar "
|
|
|
|
|
"to :term:`named tuple` in that elements can either be accessed either by "
|
|
|
|
|
"index or as an attribute. However, they do not have any of the named tuple "
|
|
|
|
|
"methods like :meth:`~collections.somenamedtuple._make` or :meth:"
|
|
|
|
|
"`~collections.somenamedtuple._asdict`. Examples of struct sequences include :"
|
|
|
|
|
"data:`sys.float_info` and the return value of :func:`os.stat`."
|
|
|
|
|
msgstr ""
|
2017-09-22 14:07:50 +00:00
|
|
|
|
"Un n-uplet (*tuple*) dont les éléments sont nommés. Les *struct sequences* "
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"exposent une interface similaires au :term:`named tuple` par le fait que "
|
|
|
|
|
"leurs éléments peuvent être accédés par nom d'attribut ou par indice. "
|
|
|
|
|
"Cependant, elles n'ont aucune des méthodes du *named tuple*, comme :meth:"
|
|
|
|
|
"`collections.somenamedtuple._make` ou :meth:`~collections.somenamedtuple."
|
|
|
|
|
"_asdict`. Par exemple :data:`sys.float_info`, ou les valeurs données par :"
|
|
|
|
|
"func:`os.stat` sont des *struct sequence*."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:970
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "text encoding"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "encodage de texte"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:972
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "A codec which encodes Unicode strings to bytes."
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Un codec qui convertit des chaînes de caractères Unicode en octets."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:973
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "text file"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "fichier texte"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:975
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A :term:`file object` able to read and write :class:`str` objects. Often, a "
|
|
|
|
|
"text file actually accesses a byte-oriented datastream and handles the :term:"
|
2017-04-02 20:14:06 +00:00
|
|
|
|
"`text encoding` automatically. Examples of text files are files opened in "
|
|
|
|
|
"text mode (``'r'`` or ``'w'``), :data:`sys.stdin`, :data:`sys.stdout`, and "
|
|
|
|
|
"instances of :class:`io.StringIO`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgstr ""
|
2017-05-15 21:58:44 +00:00
|
|
|
|
"Un :term:`file object` capable de lire et d'écrire des objets :class:`str`. "
|
|
|
|
|
"Souvent, un fichier texte (*text file*) accède en fait à un flux de donnée "
|
|
|
|
|
"en octets, et gère l':term:`text encoding` automatiquement. Quelques "
|
|
|
|
|
"fichiers texte ouverts en mode texte (``'r'`` ou ``'w'``), :data:`sys."
|
|
|
|
|
"stdin`, :data:`sys.stdout`, et les instances de :class:`io.StringIO`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:983
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "A :term:`binary file` reads and write :class:`bytes` objects."
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Un :term:`fichier binaire` lit et écrit des objets :class:`bytes`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:984
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "triple-quoted string"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "chaîne entre triple guillemets"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:986
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A string which is bound by three instances of either a quotation mark (\") "
|
|
|
|
|
"or an apostrophe ('). While they don't provide any functionality not "
|
|
|
|
|
"available with single-quoted strings, they are useful for a number of "
|
|
|
|
|
"reasons. They allow you to include unescaped single and double quotes "
|
|
|
|
|
"within a string and they can span multiple lines without the use of the "
|
|
|
|
|
"continuation character, making them especially useful when writing "
|
|
|
|
|
"docstrings."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une chaîne qui est assembée par trois guillemets simples (``'``) ou trois "
|
|
|
|
|
"guillemets doubles (``\"``). Bien qu'elles ne fournissent aucune "
|
|
|
|
|
"fonctionalité qui ne serait pas disponnible avec les chaînes entre "
|
|
|
|
|
"guillemets, elles sont utiles pour moultes raisons. Elles vous autorisent à "
|
|
|
|
|
"insérer des guillemets simples et doubles dans une chaîne sans avoir à les "
|
|
|
|
|
"protéger, et elles peuvent s'étendre sur plusieurs lignes sans avoir à les "
|
|
|
|
|
"terminer par un ``\\``, les rendant ainsi particulièrement utile pour les "
|
|
|
|
|
"chaînes de documentation (*docstrings*)."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:993
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "type"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "type"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:995
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The type of a Python object determines what kind of object it is; every "
|
|
|
|
|
"object has a type. An object's type is accessible as its :attr:`~instance."
|
|
|
|
|
"__class__` attribute or can be retrieved with ``type(obj)``."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Le type d'un objet Python détermine quel genre d'objet c'est. Tous les "
|
|
|
|
|
"objets ont un type. Le type d'un objet peut être obtenu via son attribut :"
|
|
|
|
|
"attr:`~instance.__class__` ou via ``type(obj)``."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:999
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "universal newlines"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "retours à la ligne universels"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:1001
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A manner of interpreting text streams in which all of the following are "
|
|
|
|
|
"recognized as ending a line: the Unix end-of-line convention ``'\\n'``, the "
|
|
|
|
|
"Windows convention ``'\\r\\n'``, and the old Macintosh convention "
|
|
|
|
|
"``'\\r'``. See :pep:`278` and :pep:`3116`, as well as :func:`bytes."
|
|
|
|
|
"splitlines` for an additional use."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Une manière d'interpréter des flux de texte dans lesquels toutes les fin de "
|
|
|
|
|
"lignes suivantes sont reconnues: la convention Unix ``'\\n'``, la convention "
|
|
|
|
|
"Windows ``'\\r\\n'``, et l'ancienne convention Macintosh ``'\\r'``. Voir la :"
|
|
|
|
|
"pep:`278` et la :pep:`3116`, ainsi que la fonction :func:`bytes.splitlines` "
|
|
|
|
|
"pour d'autres usages."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:1006
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "variable annotation"
|
2016-10-21 12:43:16 +00:00
|
|
|
|
msgstr "annotation de variable"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:1008
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A type metadata value associated with a module global variable or a class "
|
|
|
|
|
"attribute. Its syntax is explained in section :ref:`annassign`. Annotations "
|
|
|
|
|
"are stored in the :attr:`__annotations__` special attribute of a class or "
|
|
|
|
|
"module object and can be accessed using :func:`typing.get_type_hints`."
|
|
|
|
|
msgstr ""
|
2016-10-21 12:43:16 +00:00
|
|
|
|
"Un type de métadonnées associée à une variable globale de module ou a un "
|
|
|
|
|
"attribut de classe. Sa syntaxe est expliquée dans la section :ref:"
|
|
|
|
|
"`annassign`. Les annotations sont stockées dans un attribut :attr:"
|
|
|
|
|
"`__annotations__` spécial de classe ou de module et est accessible en "
|
|
|
|
|
"utilisant :func:`typing.get_type_hints`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:1014
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Python itself does not assign any particular meaning to variable "
|
|
|
|
|
"annotations. They are intended to be interpreted by third-party libraries or "
|
|
|
|
|
"type checking tools. See :pep:`526`, :pep:`484` which describe some of their "
|
|
|
|
|
"potential uses."
|
|
|
|
|
msgstr ""
|
2016-10-21 12:43:16 +00:00
|
|
|
|
"Python lui-même n'attache aucune signification particulière aux annotations "
|
|
|
|
|
"de variables. Elles sont destinées à être interprétées par des bibliothèques "
|
|
|
|
|
"tierces ou des outils de contrôle de type. Voir :pep:`526` et :pep:`484` qui "
|
|
|
|
|
"décrivent certaines de leurs utilisations potentielles."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:1018
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "virtual environment"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "environnement virtuel"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:1020
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A cooperatively isolated runtime environment that allows Python users and "
|
|
|
|
|
"applications to install and upgrade Python distribution packages without "
|
|
|
|
|
"interfering with the behaviour of other Python applications running on the "
|
|
|
|
|
"same system."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un environnement isolé, coopérant à son isolement à l'execution, qui permet "
|
|
|
|
|
"aux utilisateurs de Python et aux applications d'installer et de mettre à "
|
|
|
|
|
"jour des paquets sans interférer avec d'autres applications Python "
|
|
|
|
|
"fonctionnant sur le même système."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:1025
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "See also :mod:`venv`."
|
2016-10-21 12:43:16 +00:00
|
|
|
|
msgstr "Voir aussi :mod:`venv`."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:1026
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "virtual machine"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "machine virtuelle"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:1028
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"A computer defined entirely in software. Python's virtual machine executes "
|
|
|
|
|
"the :term:`bytecode` emitted by the bytecode compiler."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Un ordinateur défini entièrement par du logiciel. La machine virtuelle "
|
|
|
|
|
"(*virtual machine*) de Python exécute le :term:`bytecode` donné par le "
|
|
|
|
|
"compilateur de *bytecode*."
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:1030
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid "Zen of Python"
|
2016-10-17 19:46:02 +00:00
|
|
|
|
msgstr "Le Zen de Python"
|
2016-10-17 19:42:06 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/glossary.rst:1032
|
2016-10-17 19:42:06 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Listing of Python design principles and philosophies that are helpful in "
|
|
|
|
|
"understanding and using the language. The listing can be found by typing "
|
|
|
|
|
"\"``import this``\" at the interactive prompt."
|
|
|
|
|
msgstr ""
|
2016-10-17 19:46:02 +00:00
|
|
|
|
"Liste de principes et de philosophies utiles pour comprendre et utiliser le "
|
|
|
|
|
"langage. Cette liste peut être obtenue en tapant \"``import this``\" dans "
|
|
|
|
|
"une invite Python interactive."
|
2017-04-02 20:14:06 +00:00
|
|
|
|
|
2017-05-27 17:46:38 +00:00
|
|
|
|
#~ msgid ">>>"
|
|
|
|
|
#~ msgstr ">>>"
|
|
|
|
|
|
|
|
|
|
#~ msgid "..."
|
|
|
|
|
#~ msgstr "..."
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#~ msgid ""
|
|
|
|
|
#~ "A :term:`file object` able to read and write :term:`bytes-like objects "
|
|
|
|
|
#~ "<bytes-like object>`."
|
|
|
|
|
#~ msgstr ""
|
|
|
|
|
#~ "Un :term:`objet fichier` capable de lire et d'écrire :term:`des objets "
|
|
|
|
|
#~ "bytes-compatibles <bytes-like object>`."
|