forked from AFPy/python-docs-fr
2700 lines
115 KiB
Plaintext
2700 lines
115 KiB
Plaintext
# Copyright (C) 2001-2018, Python Software Foundation
|
||
# For licence information, see README file.
|
||
#
|
||
msgid ""
|
||
msgstr ""
|
||
"Project-Id-Version: Python 3\n"
|
||
"Report-Msgid-Bugs-To: \n"
|
||
"POT-Creation-Date: 2020-08-24 09:01+0200\n"
|
||
"PO-Revision-Date: 2020-08-19 23:06+0200\n"
|
||
"Last-Translator: Antoine Wecxsteen\n"
|
||
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
|
||
"Language: fr\n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
"X-Generator: Poedit 2.3\n"
|
||
|
||
#: glossary.rst:5
|
||
msgid "Glossary"
|
||
msgstr "Glossaire"
|
||
|
||
#: glossary.rst:10
|
||
msgid "``>>>``"
|
||
msgstr "``>>>``"
|
||
|
||
#: 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 ""
|
||
"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."
|
||
|
||
#: glossary.rst:14
|
||
msgid "``...``"
|
||
msgstr "``...``"
|
||
|
||
#: glossary.rst:16
|
||
msgid "Can refer to:"
|
||
msgstr "Peut faire référence à :"
|
||
|
||
#: glossary.rst:18
|
||
msgid ""
|
||
"The default Python prompt of the interactive shell when entering the code "
|
||
"for an indented code block, when within a pair of matching left and right "
|
||
"delimiters (parentheses, square brackets, curly braces or triple quotes), or "
|
||
"after specifying a decorator."
|
||
msgstr ""
|
||
"L'invite de commande utilisée par défaut dans l'interpréteur interactif "
|
||
"lorsqu'on entre un bloc de code indenté, dans des délimiteurs fonctionnant "
|
||
"par paires (parenthèses, crochets, accolades, triple guillemets), ou après "
|
||
"un avoir spécifié un décorateur."
|
||
|
||
#: glossary.rst:23
|
||
msgid "The :const:`Ellipsis` built-in constant."
|
||
msgstr "La constante :const:`Ellipsis`."
|
||
|
||
#: glossary.rst:24
|
||
msgid "2to3"
|
||
msgstr "*2to3*"
|
||
|
||
#: glossary.rst:26
|
||
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 ""
|
||
"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."
|
||
|
||
#: glossary.rst:30
|
||
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 ""
|
||
"*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`."
|
||
|
||
#: glossary.rst:33
|
||
msgid "abstract base class"
|
||
msgstr "classe de base abstraite"
|
||
|
||
#: glossary.rst:35
|
||
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 ""
|
||
"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 subtilement fausses (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 du système d'importation (dans le module :mod:"
|
||
"`importlib.abc`). Vous pouvez créer vos propres ABC avec le module :mod:"
|
||
"`abc`."
|
||
|
||
#: glossary.rst:46
|
||
msgid "annotation"
|
||
msgstr "annotation"
|
||
|
||
#: glossary.rst:48
|
||
msgid ""
|
||
"A label associated with a variable, a class attribute or a function "
|
||
"parameter or return value, used by convention as a :term:`type hint`."
|
||
msgstr ""
|
||
"Étiquette associée à une variable, un attribut de classe, un paramètre de "
|
||
"fonction ou une valeur de retour. Elle est utilisée par convention comme :"
|
||
"term:`type hint`."
|
||
|
||
#: glossary.rst:52
|
||
msgid ""
|
||
"Annotations of local variables cannot be accessed at runtime, but "
|
||
"annotations of global variables, class attributes, and functions are stored "
|
||
"in the :attr:`__annotations__` special attribute of modules, classes, and "
|
||
"functions, respectively."
|
||
msgstr ""
|
||
"Les annotations de variables locales ne sont pas accessibles au moment de "
|
||
"l'exécution, mais les annotations de variables globales, d'attributs de "
|
||
"classe et de fonctions sont stockées dans l'attribut spécial :attr:"
|
||
"`__annotations__` des modules, classes et fonctions, respectivement."
|
||
|
||
#: glossary.rst:58
|
||
msgid ""
|
||
"See :term:`variable annotation`, :term:`function annotation`, :pep:`484` "
|
||
"and :pep:`526`, which describe this functionality."
|
||
msgstr ""
|
||
"Voir :term:`variable annotation`, :term:`function annotation`, :pep:`484` "
|
||
"et :pep:`526`, qui décrivent cette fonctionnalité."
|
||
|
||
#: glossary.rst:60
|
||
msgid "argument"
|
||
msgstr "argument"
|
||
|
||
#: glossary.rst:62
|
||
msgid ""
|
||
"A value passed to a :term:`function` (or :term:`method`) when calling the "
|
||
"function. There are two kinds of argument:"
|
||
msgstr ""
|
||
"Valeur, donnée à une :term:`fonction` ou à une :term:`méthode` lors de son "
|
||
"appel. Il existe deux types d'arguments :"
|
||
|
||
#: glossary.rst:65
|
||
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 ""
|
||
":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 ::"
|
||
|
||
#: glossary.rst:73
|
||
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 ""
|
||
":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 ::"
|
||
|
||
#: glossary.rst:82
|
||
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 ""
|
||
"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 "
|
||
"cette 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."
|
||
|
||
#: glossary.rst:87
|
||
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 ""
|
||
"Voir aussi :term:`parameter` dans le glossaire, la question :ref:`Différence "
|
||
"entre argument et paramètre <faq-argument-vs-parameter>` de la FAQ et la :"
|
||
"pep:`362`."
|
||
|
||
#: glossary.rst:90
|
||
msgid "asynchronous context manager"
|
||
msgstr "gestionnaire de contexte asynchrone"
|
||
|
||
#: glossary.rst:92
|
||
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 ""
|
||
"(*asynchronous context manager* en anglais) Objet contrôlant l'environnement "
|
||
"à l'intérieur d'une instruction :keyword:`with` en définissant les méthodes :"
|
||
"meth:`__aenter__` et :meth:`__aexit__`. A été Introduit par la :pep:`492`."
|
||
|
||
#: glossary.rst:95
|
||
msgid "asynchronous generator"
|
||
msgstr "générateur asynchrone"
|
||
|
||
#: glossary.rst:97
|
||
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 ""
|
||
"Fonction qui renvoie un :term:`asynchronous generator iterator`. Cela "
|
||
"ressemble à une coroutine définie par :keyword:`async def`, sauf qu'elle "
|
||
"contient une ou des expressions :keyword:`yield` produisant ainsi uns série "
|
||
"de valeurs utilisables dans une boucle :keyword:`async for`."
|
||
|
||
#: glossary.rst:102
|
||
msgid ""
|
||
"Usually refers to an 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 ""
|
||
"Générateur asynchrone fait généralement référence à une fonction, mais peut "
|
||
"faire référence à un *itérateur de générateur asynchrone* dans certains "
|
||
"contextes. Dans les cas où le sens voulu n'est pas clair, utiliser "
|
||
"l'ensemble des termes lève l’ambiguïté."
|
||
|
||
#: glossary.rst:106
|
||
msgid ""
|
||
"An asynchronous generator function may contain :keyword:`await` expressions "
|
||
"as well as :keyword:`async for`, and :keyword:`async with` statements."
|
||
msgstr ""
|
||
"Un générateur asynchrone peut contenir des expressions :keyword:`await` "
|
||
"ainsi que des instructions :keyword:`async for`, et :keyword:`async with`."
|
||
|
||
#: glossary.rst:109
|
||
msgid "asynchronous generator iterator"
|
||
msgstr "itérateur de générateur asynchrone"
|
||
|
||
#: glossary.rst:111
|
||
msgid "An object created by a :term:`asynchronous generator` function."
|
||
msgstr "Objet créé par une fonction :term:`asynchronous generator`."
|
||
|
||
#: glossary.rst:113
|
||
msgid ""
|
||
"This is an :term:`asynchronous iterator` which when called using the :meth:"
|
||
"`__anext__` method returns an awaitable object which will execute the body "
|
||
"of the asynchronous generator function until the next :keyword:`yield` "
|
||
"expression."
|
||
msgstr ""
|
||
"C'est un :term:`asynchronous iterator` qui, lorsqu'il est appelé via la "
|
||
"méthode :meth:`__anext__` renvoie un objet *awaitable* qui exécute le corps "
|
||
"de la fonction du générateur asynchrone jusqu'au prochain :keyword:`yield`."
|
||
|
||
#: glossary.rst:118
|
||
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, en gardant en "
|
||
"mémoire l'endroit et l'état de l'exécution (ce qui inclut les variables "
|
||
"locales et les *try* en cours). Lorsque l'exécution de l'itérateur de "
|
||
"générateur asynchrone reprend avec un nouvel *awaitable* renvoyé par :meth:"
|
||
"`__anext__`, elle repart de là où elle s'était arrêtée. Voir la :pep:`492` "
|
||
"et la :pep:`525`."
|
||
|
||
#: glossary.rst:123
|
||
msgid "asynchronous iterable"
|
||
msgstr "itérable asynchrone"
|
||
|
||
#: glossary.rst:125
|
||
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 ""
|
||
"Objet qui peut être utilisé dans une instruction :keyword:`async for`. Sa "
|
||
"méthode :meth:`__aiter__` doit renvoyer un :term:`asynchronous iterator`. A "
|
||
"été introduit par la :pep:`492`."
|
||
|
||
#: glossary.rst:128
|
||
msgid "asynchronous iterator"
|
||
msgstr "itérateur asynchrone"
|
||
|
||
#: glossary.rst:130
|
||
msgid ""
|
||
"An object that implements the :meth:`__aiter__` and :meth:`__anext__` "
|
||
"methods. ``__anext__`` must return an :term:`awaitable` object. :keyword:"
|
||
"`async for` resolves the awaitables returned by an asynchronous iterator's :"
|
||
"meth:`__anext__` method until it raises a :exc:`StopAsyncIteration` "
|
||
"exception. Introduced by :pep:`492`."
|
||
msgstr ""
|
||
"Objet qui implémente les méthodes :meth:`__aiter__` et :meth:`__anext__`. "
|
||
"``__anext__`` doit renvoyer un objet :term:`awaitable`. Tant que la méthode :"
|
||
"meth:`__anext__` produit des objets *awaitable*, le :keyword:`async for` "
|
||
"appelant les consomme. L'itérateur asynchrone lève une exception :exc:"
|
||
"`StopAsyncIteration` pour signifier la fin de l'itération. A été introduit "
|
||
"par la :pep:`492`."
|
||
|
||
#: glossary.rst:135
|
||
msgid "attribute"
|
||
msgstr "attribut"
|
||
|
||
#: glossary.rst:137
|
||
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 ""
|
||
"Valeur associée à un objet et désignée par son nom via une notation "
|
||
"utilisant des points. Par exemple, si un objet *o* possède un attribut *a*, "
|
||
"il sera référencé par *o.a*."
|
||
|
||
#: glossary.rst:140
|
||
msgid "awaitable"
|
||
msgstr "*awaitable*"
|
||
|
||
#: glossary.rst:142
|
||
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 ""
|
||
"Objet pouvant être utilisé dans une expression :keyword:`await`. Ce peut "
|
||
"être une :term:`coroutine` ou un objet avec une méthode :meth:`__await__`. "
|
||
"Voir aussi la :pep:`492`."
|
||
|
||
#: glossary.rst:145
|
||
msgid "BDFL"
|
||
msgstr "*BDFL*"
|
||
|
||
#: glossary.rst:147
|
||
msgid ""
|
||
"Benevolent Dictator For Life, a.k.a. `Guido van Rossum <https://gvanrossum."
|
||
"github.io/>`_, Python's creator."
|
||
msgstr ""
|
||
"Dictateur bienveillant à vie (*Benevolent Dictator For Life* en anglais). "
|
||
"Pseudonyme de `Guido van Rossum <https://gvanrossum.github.io/>`_, le "
|
||
"créateur de Python."
|
||
|
||
#: glossary.rst:149
|
||
msgid "binary file"
|
||
msgstr "fichier binaire"
|
||
|
||
#: glossary.rst:151
|
||
msgid ""
|
||
"A :term:`file object` able to read and write :term:`bytes-like objects "
|
||
"<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`."
|
||
msgstr ""
|
||
"Un :term:`file object` capable de lire et d'écrire des :term:`bytes-like "
|
||
"objects <bytes-like object>`. Des fichiers binaires sont, par exemple, les "
|
||
"fichiers ouverts en mode binaire (``'rb'``, ``'wb'``, ou ``'rb+'``), :data:"
|
||
"`sys.stdin.buffer`, :data:`sys.stdout.buffer`, les instances de :class:`io."
|
||
"BytesIO` ou de :class:`gzip.GzipFile`."
|
||
|
||
#: glossary.rst:158
|
||
msgid ""
|
||
"See also :term:`text file` for a file object able to read and write :class:"
|
||
"`str` objects."
|
||
msgstr ""
|
||
"Consultez :term:`fichier texte`, un objet fichier capable de lire et "
|
||
"d'écrire des objets :class:`str`."
|
||
|
||
#: glossary.rst:160
|
||
msgid "bytes-like object"
|
||
msgstr "objet octet-compatible"
|
||
|
||
#: glossary.rst:162
|
||
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 ""
|
||
"Un objet gérant les :ref:`bufferobjects` et pouvant exporter un tampon "
|
||
"(*buffer* en anglais) C-:term:`contiguous`. Cela inclut 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 sauvegarde dans un fichier binaire ou l'envoi sur le réseau."
|
||
|
||
#: glossary.rst:169
|
||
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 ""
|
||
"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` ou une :class:`memoryview` "
|
||
"d'un :class:`bytearray` en font partie. 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` ou :class:"
|
||
"`memoryview` d'un objet :class:`byte`."
|
||
|
||
#: glossary.rst:177
|
||
msgid "bytecode"
|
||
msgstr "code intermédiaire (*bytecode*)"
|
||
|
||
#: glossary.rst:179
|
||
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 "
|
||
"``.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."
|
||
msgstr ""
|
||
"Le code source, en Python, est compilé en un code intermédiaire (*bytecode* "
|
||
"en anglais), la représentation interne à CPython d'un programme Python. Le "
|
||
"code intermédiaire est mis en cache dans un fichier ``.pyc`` de manière à ce "
|
||
"qu'une seconde exécution soit plus rapide (la compilation en code "
|
||
"intermédiaire a déjà été faite). 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 code intermédiaire. Notez que le code "
|
||
"intermédiaire n'a pas vocation à fonctionner sur différentes machines "
|
||
"virtuelles Python ou à être stable entre différentes versions de Python."
|
||
|
||
#: glossary.rst:189
|
||
msgid ""
|
||
"A list of bytecode instructions can be found in the documentation for :ref:"
|
||
"`the dis module <bytecodes>`."
|
||
msgstr ""
|
||
"La documentation du :ref:`module dis <bytecodes>` fournit une liste des "
|
||
"instructions du code intermédiaire."
|
||
|
||
#: glossary.rst:191
|
||
msgid "callback"
|
||
msgstr "fonction de rappel"
|
||
|
||
#: glossary.rst:193
|
||
msgid ""
|
||
"A subroutine function which is passed as an argument to be executed at some "
|
||
"point in the future."
|
||
msgstr "Une sous-fonction passée en argument pour être exécutée plus tard."
|
||
|
||
#: glossary.rst:195
|
||
msgid "class"
|
||
msgstr "classe"
|
||
|
||
#: glossary.rst:197
|
||
msgid ""
|
||
"A template for creating user-defined objects. Class definitions normally "
|
||
"contain method definitions which operate on instances of the class."
|
||
msgstr ""
|
||
"Modèle pour créer des objets définis par l'utilisateur. Une définition de "
|
||
"classe (*class*) contient normalement des définitions de méthodes qui "
|
||
"agissent sur les instances de la classe."
|
||
|
||
#: glossary.rst:200
|
||
msgid "class variable"
|
||
msgstr "variable de classe"
|
||
|
||
#: glossary.rst:202
|
||
msgid ""
|
||
"A variable defined in a class and intended to be modified only at class "
|
||
"level (i.e., not in an instance of the class)."
|
||
msgstr ""
|
||
"Une variable définie dans une classe et destinée à être modifiée uniquement "
|
||
"au niveau de la classe (c'est-à-dire, pas dans une instance de la classe)."
|
||
|
||
#: glossary.rst:204
|
||
msgid "coercion"
|
||
msgstr "coercition"
|
||
|
||
#: glossary.rst:206
|
||
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 :exc:`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 ""
|
||
"Conversion implicite d'une instance d'un type vers un autre lors d'une "
|
||
"opération dont les deux opérandes doivent être de même type. Par exemple "
|
||
"``int(3.15)`` convertit explicitement le nombre à virgule flottante en "
|
||
"nombre entier ``3``. Mais dans l'opération ``3 + 4.5``, les deux opérandes "
|
||
"sont d'un type différent (un entier et un nombre à virgule flottante), alors "
|
||
"qu'ils doivent avoir le même type pour être additionnés (sinon une "
|
||
"exception :exc:`TypeError` serait levée). Sans coercition, tous les "
|
||
"opérandes, même de types compatibles, devraient être convertis (on parle "
|
||
"aussi de *cast*) explicitement par le développeur, par exemple : ``float(3) "
|
||
"+ 4.5`` au lieu du simple ``3 + 4.5``."
|
||
|
||
#: glossary.rst:214
|
||
msgid "complex number"
|
||
msgstr "nombre complexe"
|
||
|
||
#: glossary.rst:216
|
||
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 ""
|
||
"Extension des nombres réels familiers, dans laquelle tous les nombres sont "
|
||
"exprimés sous la forme d'une somme d'une partie réelle et d'une partie "
|
||
"imaginaire. Les nombres imaginaires sont les nombres réels multipliés par "
|
||
"l'unité imaginaire (la racine carrée de ``-1``, souvent écrite ``i`` en "
|
||
"mathématiques ou ``j`` par les ingénieurs). Python comprend 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 de :mod:`math`, utilisez :mod:`cmath`. "
|
||
"Les nombres complexes sont un concept assez avancé en mathématiques. Si vous "
|
||
"ne connaissez pas ce concept, vous pouvez tranquillement les ignorer."
|
||
|
||
#: glossary.rst:226
|
||
msgid "context manager"
|
||
msgstr "gestionnaire de contexte"
|
||
|
||
#: glossary.rst:228
|
||
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 ""
|
||
"Objet contrôlant l'environnement à l'intérieur d'un bloc :keyword:`with` en "
|
||
"définissant les méthodes :meth:`__enter__` et :meth:`__exit__`. Consultez "
|
||
"la :pep:`343`."
|
||
|
||
#: glossary.rst:231
|
||
msgid "context variable"
|
||
msgstr "variable de contexte"
|
||
|
||
#: glossary.rst:233
|
||
msgid ""
|
||
"A variable which can have different values depending on its context. This is "
|
||
"similar to Thread-Local Storage in which each execution thread may have a "
|
||
"different value for a variable. However, with context variables, there may "
|
||
"be several contexts in one execution thread and the main usage for context "
|
||
"variables is to keep track of variables in concurrent asynchronous tasks. "
|
||
"See :mod:`contextvars`."
|
||
msgstr ""
|
||
"Une variable qui peut avoir des valeurs différentes en fonction de son "
|
||
"contexte. Cela est similaire au stockage par fil d’exécution (*Thread Local "
|
||
"Storage* en anglais) dans lequel chaque fil d’exécution peut avoir une "
|
||
"valeur différente pour une variable. Toutefois, avec les variables de "
|
||
"contexte, il peut y avoir plusieurs contextes dans un fil d’exécution et "
|
||
"l’utilisation principale pour les variables de contexte est de garder une "
|
||
"trace des variables dans les tâches asynchrones concourantes. Voir :mod:"
|
||
"`contextvars`."
|
||
|
||
#: glossary.rst:240
|
||
msgid "contiguous"
|
||
msgstr "contigu"
|
||
|
||
#: glossary.rst:244
|
||
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 ""
|
||
"Un tampon (*buffer* en anglais) est considéré comme contigu s’il est soit *C-"
|
||
"contigu* soit *Fortran-contigu*. Les tampons 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, en 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. À l'inverse, dans les tableaux Fortran-contigu, c’est "
|
||
"le premier indice qui doit varier le plus rapidement."
|
||
|
||
#: glossary.rst:252
|
||
msgid "coroutine"
|
||
msgstr "coroutine"
|
||
|
||
#: glossary.rst:254
|
||
msgid ""
|
||
"Coroutines are 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 ""
|
||
"Les coroutines sont une forme généralisée des fonctions. On entre dans une "
|
||
"fonction en un point et on en sort en un autre point. On peut entrer, sortir "
|
||
"et reprendre l'exécution d'une coroutine en plusieurs points. Elles peuvent "
|
||
"être implémentées en utilisant l'instruction :keyword:`async def`. Voir "
|
||
"aussi la :pep:`492`."
|
||
|
||
#: glossary.rst:259
|
||
msgid "coroutine function"
|
||
msgstr "fonction coroutine"
|
||
|
||
#: glossary.rst:261
|
||
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 ""
|
||
"Fonction qui renvoie un objet :term:`coroutine`. Une fonction coroutine peut "
|
||
"être définie par l'instruction :keyword:`async def` et peut contenir les "
|
||
"mots clés :keyword:`await`, :keyword:`async for` ainsi que :keyword:`async "
|
||
"with`. A été introduit par la :pep:`492`."
|
||
|
||
#: glossary.rst:266
|
||
msgid "CPython"
|
||
msgstr "CPython"
|
||
|
||
#: glossary.rst:268
|
||
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 ""
|
||
"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*."
|
||
|
||
#: glossary.rst:272
|
||
msgid "decorator"
|
||
msgstr "décorateur"
|
||
|
||
#: glossary.rst:274
|
||
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 ""
|
||
"Fonction dont la valeur de retour est une autre fonction. Un décorateur est "
|
||
"habituellement utilisé pour transformer une fonction via la syntaxe "
|
||
"``@wrapper``, dont les exemples typiques sont : :func:`classmethod` et :func:"
|
||
"`staticmethod`."
|
||
|
||
#: glossary.rst:278
|
||
msgid ""
|
||
"The decorator syntax is merely syntactic sugar, the following two function "
|
||
"definitions are semantically equivalent::"
|
||
msgstr ""
|
||
"La syntaxe des décorateurs est simplement du sucre syntaxique, les "
|
||
"définitions des deux fonctions suivantes sont sémantiquement équivalentes ::"
|
||
|
||
#: glossary.rst:289
|
||
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 ""
|
||
"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."
|
||
|
||
#: glossary.rst:292
|
||
msgid "descriptor"
|
||
msgstr "descripteur"
|
||
|
||
#: glossary.rst:294
|
||
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 ""
|
||
"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. Normalement, lorsque vous écrivez *a.b* pour obtenir, affecter ou "
|
||
"effacer un attribut, Python recherche l'objet nommé *b* dans le dictionnaire "
|
||
"de la classe de *a*. Mais si *b* est un descripteur, c'est la méthode de ce "
|
||
"descripteur qui est alors appelée. Comprendre les descripteurs est requis "
|
||
"pour avoir 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 classes, méthodes statiques et les références aux "
|
||
"classes parentes."
|
||
|
||
#: glossary.rst:304
|
||
msgid ""
|
||
"For more information about descriptors' methods, see :ref:`descriptors`."
|
||
msgstr ""
|
||
"Pour plus d'informations sur les méthodes des descripteurs, consultez :ref:"
|
||
"`descriptors`."
|
||
|
||
#: glossary.rst:305
|
||
msgid "dictionary"
|
||
msgstr "dictionnaire"
|
||
|
||
#: glossary.rst:307
|
||
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 ""
|
||
"Structure de donnée associant des clés à des valeurs. Les clés peuvent être "
|
||
"n'importe quel objet possédant les méthodes :meth:`__hash__` et :meth:"
|
||
"`__eq__`. En Perl, les dictionnaires sont appelés \"*hash*\"."
|
||
|
||
#: glossary.rst:310
|
||
msgid "dictionary view"
|
||
msgstr "vue de dictionnaire"
|
||
|
||
#: glossary.rst:312
|
||
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 ""
|
||
"Objets retournés par les méthodes :meth:`dict.keys`, :meth:`dict.values` et :"
|
||
"meth:`dict.items`. Ils fournissent des vues dynamiques des entrées du "
|
||
"dictionnaire, ce qui signifie que lorsque le dictionnaire change, la vue "
|
||
"change. Pour transformer une vue en vraie liste, utilisez "
|
||
"``list(dictview)``. Voir :ref:`dict-views`."
|
||
|
||
#: glossary.rst:318
|
||
msgid "docstring"
|
||
msgstr "*docstring* (chaîne de documentation)"
|
||
|
||
#: glossary.rst:320
|
||
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 ""
|
||
"Première chaîne littérale qui apparaît dans l'expression d'une classe, "
|
||
"fonction, ou module. Bien qu'ignorée à l'exécution, elle est reconnue par le "
|
||
"compilateur et placée dans l'attribut :attr:`__doc__` de la classe, de la "
|
||
"fonction ou du module. Comme cette chaîne est disponible par introspection, "
|
||
"c'est l'endroit idéal pour documenter l'objet."
|
||
|
||
#: glossary.rst:326
|
||
msgid "duck-typing"
|
||
msgstr "*duck-typing*"
|
||
|
||
#: glossary.rst:328
|
||
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 ""
|
||
"Style de programmation qui ne prend pas en compte le type d'un objet pour "
|
||
"déterminer s'il respecte une interface, mais qui appelle simplement la "
|
||
"méthode ou l'attribut (*Si ça a un bec et que ça cancane, ça doit être un "
|
||
"canard*, *duck* signifie canard en anglais). En se concentrant sur les "
|
||
"interfaces plutôt que les types, du code bien construit améliore sa "
|
||
"flexibilité en autorisant des substitutions polymorphiques. Le *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`."
|
||
|
||
#: glossary.rst:337
|
||
msgid "EAFP"
|
||
msgstr "EAFP"
|
||
|
||
#: glossary.rst:339
|
||
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 ""
|
||
"Il est plus simple de demander pardon que demander la permission (*Easier to "
|
||
"Ask for Forgiveness than Permission* en anglais). Ce style de développement "
|
||
"Python fait l'hypothèse que le code est valide et traite les exceptions si "
|
||
"cette hypothèse s'avère fausse. Ce style, propre et efficace, est "
|
||
"caractérisé par la présence de beaucoup de mots clés :keyword:`try` et :"
|
||
"keyword:`except`. Cette technique de programmation contraste avec le style :"
|
||
"term:`LBYL` utilisé couramment dans les langages tels que C."
|
||
|
||
#: glossary.rst:345
|
||
msgid "expression"
|
||
msgstr "expression"
|
||
|
||
#: glossary.rst:347
|
||
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:`while`. Assignments are also statements, not "
|
||
"expressions."
|
||
msgstr ""
|
||
"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. On trouve également des :term:"
|
||
"`instructions <statement>` qui ne peuvent pas être utilisées comme "
|
||
"expressions, tel que :keyword:`while`. Les affectations sont également des "
|
||
"instructions et non des expressions."
|
||
|
||
#: glossary.rst:354
|
||
msgid "extension module"
|
||
msgstr "module d'extension"
|
||
|
||
#: glossary.rst:356
|
||
msgid ""
|
||
"A module written in C or C++, using Python's C API to interact with the core "
|
||
"and with user code."
|
||
msgstr ""
|
||
"Module écrit en C ou C++, utilisant l'API C de Python pour interagir avec "
|
||
"Python et le code de l'utilisateur."
|
||
|
||
#: glossary.rst:358
|
||
msgid "f-string"
|
||
msgstr "f-string"
|
||
|
||
#: glossary.rst:360
|
||
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 ""
|
||
"Chaîne littérale préfixée de ``'f'`` ou ``'F'``. Les \"f-strings\" sont un "
|
||
"raccourci pour :ref:`formatted string literals <f-strings>`. Voir la :pep:"
|
||
"`498`."
|
||
|
||
#: glossary.rst:363
|
||
msgid "file object"
|
||
msgstr "objet fichier"
|
||
|
||
#: glossary.rst:365
|
||
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 ""
|
||
"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 "
|
||
"il a été créé, un objet fichier peut interfacer l'accès à 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, un connecteur "
|
||
"réseau…). Les objets fichiers sont aussi appelés :dfn:`file-like-objects` "
|
||
"ou :dfn:`streams`."
|
||
|
||
#: glossary.rst:373
|
||
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 ""
|
||
"Il existe en réalité trois catégories de fichiers objets : les :term:"
|
||
"`fichiers binaires <fichier binaire>` bruts, les :term:`fichiers binaires "
|
||
"<fichier binaire>` avec tampon (*buffer*) et les :term:`fichiers textes "
|
||
"<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`."
|
||
|
||
#: glossary.rst:378
|
||
msgid "file-like object"
|
||
msgstr "objet fichier-compatible"
|
||
|
||
#: glossary.rst:380
|
||
msgid "A synonym for :term:`file object`."
|
||
msgstr "Synonyme de :term:`objet fichier`."
|
||
|
||
#: glossary.rst:381
|
||
msgid "finder"
|
||
msgstr "chercheur"
|
||
|
||
#: glossary.rst:383
|
||
msgid ""
|
||
"An object that tries to find the :term:`loader` for a module that is being "
|
||
"imported."
|
||
msgstr ""
|
||
"Objet qui essaie de trouver un :term:`chargeur <loader>` pour le module en "
|
||
"cours d'importation."
|
||
|
||
#: glossary.rst:386
|
||
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 ""
|
||
"Depuis Python 3.3, il existe deux types de chercheurs : les :term:"
|
||
"`chercheurs dans les méta-chemins <meta path finder>` à utiliser avec :data:"
|
||
"`sys.meta_path` ; les :term:`chercheurs d'entrée dans path <path entry "
|
||
"finder>` à utiliser avec :data:`sys.path_hooks`."
|
||
|
||
#: glossary.rst:390
|
||
msgid "See :pep:`302`, :pep:`420` and :pep:`451` for much more detail."
|
||
msgstr "Voir les :pep:`302`, :pep:`420` et :pep:`451` pour plus de détails."
|
||
|
||
#: glossary.rst:391
|
||
msgid "floor division"
|
||
msgstr "division entière"
|
||
|
||
#: glossary.rst:393
|
||
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 ""
|
||
"Division mathématique arrondissant à l'entier inférieur. 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 à l'entier inférieur. Voir la :pep:"
|
||
"`328`."
|
||
|
||
#: glossary.rst:398
|
||
msgid "function"
|
||
msgstr "fonction"
|
||
|
||
#: glossary.rst:400
|
||
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 ""
|
||
"Suite d'instructions qui renvoie une valeur à son appelant. On peut 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`."
|
||
|
||
#: glossary.rst:404
|
||
msgid "function annotation"
|
||
msgstr "annotation de fonction"
|
||
|
||
#: glossary.rst:406
|
||
msgid "An :term:`annotation` of a function parameter or return value."
|
||
msgstr ":term:`annotation` d'un paramètre de fonction ou valeur de retour."
|
||
|
||
#: glossary.rst:408
|
||
msgid ""
|
||
"Function annotations are usually used for :term:`type hints <type hint>`: "
|
||
"for example, this function is expected to take two :class:`int` arguments "
|
||
"and is also expected to have an :class:`int` return value::"
|
||
msgstr ""
|
||
"Les annotations de fonctions sont généralement utilisées pour des :term:"
|
||
"`indications de types <type hint>` : par exemple, cette fonction devrait "
|
||
"prendre deux arguments :class:`int` et devrait également avoir une valeur de "
|
||
"retour de type :class:`int` ::"
|
||
|
||
#: glossary.rst:416
|
||
msgid "Function annotation syntax is explained in section :ref:`function`."
|
||
msgstr ""
|
||
"L'annotation syntaxique de la fonction est expliquée dans la section :ref:"
|
||
"`function`."
|
||
|
||
#: glossary.rst:418
|
||
msgid ""
|
||
"See :term:`variable annotation` and :pep:`484`, which describe this "
|
||
"functionality."
|
||
msgstr ""
|
||
"Voir :term:`variable annotation` et :pep:`484`, qui décrivent cette "
|
||
"fonctionnalité."
|
||
|
||
#: glossary.rst:420
|
||
msgid "__future__"
|
||
msgstr "__future__"
|
||
|
||
#: glossary.rst:422
|
||
msgid ""
|
||
"A pseudo-module which programmers can use to enable new language features "
|
||
"which are not compatible with the current interpreter."
|
||
msgstr ""
|
||
"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é."
|
||
|
||
#: glossary.rst:425
|
||
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 ""
|
||
"En important le module :mod:`__future__` et en affichant ses variables, vous "
|
||
"pouvez voir à quel moment une nouvelle fonctionnalité a été rajoutée dans le "
|
||
"langage et quand elle devient le comportement par défaut ::"
|
||
|
||
#: glossary.rst:432
|
||
msgid "garbage collection"
|
||
msgstr "ramasse-miettes"
|
||
|
||
#: glossary.rst:434
|
||
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. The garbage collector "
|
||
"can be controlled using the :mod:`gc` module."
|
||
msgstr ""
|
||
"(*garbage collection* en anglais) 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. Le ramasse-miettes peut être contrôlé "
|
||
"en utilisant le module :mod:`gc`."
|
||
|
||
#: glossary.rst:440
|
||
msgid "generator"
|
||
msgstr "générateur"
|
||
|
||
#: glossary.rst:442
|
||
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 ""
|
||
"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` produisant une série de valeurs utilisable dans "
|
||
"une boucle *for* ou récupérées une à une via la fonction :func:`next`."
|
||
|
||
#: glossary.rst:447
|
||
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 ""
|
||
"Fait généralement référence à une fonction générateur mais peut faire "
|
||
"référence à 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 lève "
|
||
"l’ambigüité."
|
||
|
||
#: glossary.rst:450
|
||
msgid "generator iterator"
|
||
msgstr "itérateur de générateur"
|
||
|
||
#: glossary.rst:452
|
||
msgid "An object created by a :term:`generator` function."
|
||
msgstr "Objet créé par une fonction :term:`générateur`."
|
||
|
||
#: glossary.rst:454
|
||
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 ""
|
||
"Chaque :keyword:`yield` suspend temporairement l'exécution, en se rappelant "
|
||
"l'endroit et l'état de l'exécution (y compris les variables locales et les "
|
||
"*try* en cours). Lorsque l'itérateur de générateur reprend, il repart là où "
|
||
"il en était (contrairement à une fonction qui prendrait un nouveau départ à "
|
||
"chaque invocation)."
|
||
|
||
#: glossary.rst:461
|
||
msgid "generator expression"
|
||
msgstr "expression génératrice"
|
||
|
||
#: glossary.rst:463
|
||
msgid ""
|
||
"An expression that returns an iterator. It looks like a normal expression "
|
||
"followed by a :keyword:`!for` clause defining a loop variable, range, and an "
|
||
"optional :keyword:`!if` clause. The combined expression generates values "
|
||
"for an enclosing function::"
|
||
msgstr ""
|
||
"Expression qui donne un itérateur. Elle ressemble à une expression normale, "
|
||
"suivie d'une clause :keyword:`!for` définissant une variable de boucle, un "
|
||
"intervalle et une clause :keyword:`!if` optionnelle. Toute cette expression "
|
||
"génère des valeurs pour la fonction qui l'entoure ::"
|
||
|
||
#: glossary.rst:470
|
||
msgid "generic function"
|
||
msgstr "fonction générique"
|
||
|
||
#: glossary.rst:472
|
||
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 ""
|
||
"Fonction composée de plusieurs fonctions implémentant les mêmes opérations "
|
||
"pour différents types. L'implémentation à utiliser est déterminée lors de "
|
||
"l'appel par l'algorithme de répartition."
|
||
|
||
#: glossary.rst:476
|
||
msgid ""
|
||
"See also the :term:`single dispatch` glossary entry, the :func:`functools."
|
||
"singledispatch` decorator, and :pep:`443`."
|
||
msgstr ""
|
||
"Voir aussi :term:`single dispatch`, le décorateur :func:`functools."
|
||
"singledispatch` et la :pep:`443`."
|
||
|
||
#: glossary.rst:479
|
||
msgid "GIL"
|
||
msgstr "GIL"
|
||
|
||
#: glossary.rst:481
|
||
msgid "See :term:`global interpreter lock`."
|
||
msgstr "Voir :term:`global interpreter lock`."
|
||
|
||
#: glossary.rst:482
|
||
msgid "global interpreter lock"
|
||
msgstr "verrou global de l'interpréteur"
|
||
|
||
#: glossary.rst:484
|
||
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 ""
|
||
"(*global interpreter lock* en anglais) Mécanisme utilisé par l'interpréteur :"
|
||
"term:`CPython` pour s'assurer qu'un seul fil d'exécution (*thread* en "
|
||
"anglais) n'exécute le :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é contre "
|
||
"les accès concourants. Verrouiller l'interpréteur entier rend plus facile "
|
||
"l'implémentation de multiples fils d'exécution (*multi-thread* en anglais), "
|
||
"au détriment malheureusement de beaucoup du parallélisme possible sur les "
|
||
"machines ayant plusieurs processeurs."
|
||
|
||
#: glossary.rst:493
|
||
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 ""
|
||
"Cependant, certains modules d'extension, standards ou non, sont conçus de "
|
||
"manière à libérer le GIL lorsqu'ils effectuent des tâches lourdes tel que la "
|
||
"compression ou le hachage. De la même manière, le GIL est toujours libéré "
|
||
"lors des entrées / sorties."
|
||
|
||
#: glossary.rst:498
|
||
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 ""
|
||
"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 leurs "
|
||
"mauvaises performances dans le cas d'un processeur unique. Il est admis que "
|
||
"corriger ce problème de performance induit mènerait à une implémentation "
|
||
"beaucoup plus compliquée et donc plus coûteuse à maintenir."
|
||
|
||
#: glossary.rst:504
|
||
msgid "hash-based pyc"
|
||
msgstr "*pyc* utilisant le hachage"
|
||
|
||
#: glossary.rst:506
|
||
msgid ""
|
||
"A bytecode cache file that uses the hash rather than the last-modified time "
|
||
"of the corresponding source file to determine its validity. See :ref:`pyc-"
|
||
"invalidation`."
|
||
msgstr ""
|
||
"Un fichier de cache de code intermédiaire (*bytecode* en anglais) qui "
|
||
"utilise le hachage plutôt que l'heure de dernière modification du fichier "
|
||
"source correspondant pour déterminer sa validité. Voir :ref:`pyc-"
|
||
"invalidation`."
|
||
|
||
#: glossary.rst:509
|
||
msgid "hashable"
|
||
msgstr "hachable"
|
||
|
||
#: glossary.rst:511
|
||
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 ""
|
||
"Un objet est *hachable* s'il a une empreinte (*hash*) qui ne change jamais "
|
||
"(il doit donc implémenter une méthode :meth:`__hash__`) et s'il peut être "
|
||
"comparé à d'autres objets (avec la méthode :meth:`__eq__`). Les objets "
|
||
"hachables dont la comparaison par ``__eq__`` est vraie doivent avoir la même "
|
||
"empreinte."
|
||
|
||
#: glossary.rst:516
|
||
msgid ""
|
||
"Hashability makes an object usable as a dictionary key and a set member, "
|
||
"because these data structures use the hash value internally."
|
||
msgstr ""
|
||
"La hachabilité permet à un objet d'être utilisé comme clé de dictionnaire ou "
|
||
"en tant que membre d'un ensemble (type *set*), car ces structures de données "
|
||
"utilisent ce *hash*."
|
||
|
||
#: glossary.rst:519
|
||
msgid ""
|
||
"Most of Python's immutable built-in objects are hashable; mutable containers "
|
||
"(such as lists or dictionaries) are not; immutable containers (such as "
|
||
"tuples and frozensets) are only hashable if their elements are hashable. "
|
||
"Objects which are instances of user-defined classes are hashable by "
|
||
"default. They all compare unequal (except with themselves), and their hash "
|
||
"value is derived from their :func:`id`."
|
||
msgstr ""
|
||
"La plupart des types immuables natifs de Python sont hachables, mais les "
|
||
"conteneurs muables (comme les listes ou les dictionnaires) ne le sont pas ; "
|
||
"les conteneurs immuables (comme les n-uplets ou les ensembles figés) ne sont "
|
||
"hachables que si leurs éléments sont hachables. 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 valeur de hachage "
|
||
"est calculée à partir de leur :func:`id`."
|
||
|
||
#: glossary.rst:526
|
||
msgid "IDLE"
|
||
msgstr "IDLE"
|
||
|
||
#: glossary.rst:528
|
||
msgid ""
|
||
"An Integrated Development Environment for Python. IDLE is a basic editor "
|
||
"and interpreter environment which ships with the standard distribution of "
|
||
"Python."
|
||
msgstr ""
|
||
"Environnement de développement intégré pour Python. IDLE est un éditeur "
|
||
"basique et un interpréteur livré avec la distribution standard de Python."
|
||
|
||
#: glossary.rst:531
|
||
msgid "immutable"
|
||
msgstr "immuable"
|
||
|
||
#: glossary.rst:533
|
||
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 ""
|
||
"Objet dont la valeur ne change pas. Les nombres, les chaînes et les n-uplets "
|
||
"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 "
|
||
"quand une valeur de *hash* constante est requise, typiquement en clé de "
|
||
"dictionnaire."
|
||
|
||
#: glossary.rst:538
|
||
msgid "import path"
|
||
msgstr "chemin des importations"
|
||
|
||
#: glossary.rst:540
|
||
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 ""
|
||
"Liste de :term:`entrées <path entry>` dans lesquelles le :term:`chercheur "
|
||
"basé sur les chemins <path based finder>` cherche les modules à importer. "
|
||
"Typiquement, lors d'une importation, cette liste vient de :data:`sys.path` ; "
|
||
"pour les sous-paquets, elle peut aussi venir de l'attribut ``__path__`` du "
|
||
"paquet parent."
|
||
|
||
#: glossary.rst:545
|
||
msgid "importing"
|
||
msgstr "importer"
|
||
|
||
#: glossary.rst:547
|
||
msgid ""
|
||
"The process by which Python code in one module is made available to Python "
|
||
"code in another module."
|
||
msgstr "Processus rendant le code Python d'un module disponible dans un autre."
|
||
|
||
#: glossary.rst:549
|
||
msgid "importer"
|
||
msgstr "importateur"
|
||
|
||
#: glossary.rst:551
|
||
msgid ""
|
||
"An object that both finds and loads a module; both a :term:`finder` and :"
|
||
"term:`loader` object."
|
||
msgstr ""
|
||
"Objet qui trouve et charge un module, en même temps un :term:`chercheur "
|
||
"<finder>` et un :term:`chargeur <loader>`."
|
||
|
||
#: glossary.rst:553
|
||
msgid "interactive"
|
||
msgstr "interactif"
|
||
|
||
#: glossary.rst:555
|
||
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 ""
|
||
"Python a un interpréteur interactif, ce qui signifie que vous pouvez écrire "
|
||
"des expressions et des instructions à l'invite de l'interpréteur. "
|
||
"L'interpréteur Python va les exécuter immédiatement et vous en présenter le "
|
||
"résultat. Démarrez juste ``python`` (probablement depuis le menu principal "
|
||
"de votre ordinateur). C'est un moyen puissant pour tester de nouvelles idées "
|
||
"ou étudier de nouveaux modules (souvenez-vous de ``help(x)``)."
|
||
|
||
#: glossary.rst:561
|
||
msgid "interpreted"
|
||
msgstr "interprété"
|
||
|
||
#: glossary.rst:563
|
||
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 ""
|
||
"Python est un langage interprété, en opposition aux langages compilés, bien "
|
||
"que la frontière soit floue en raison de la présence d'un compilateur en "
|
||
"code intermédiaire. 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és ont généralement un cycle de "
|
||
"développement / débogage plus court que les langages compilés. Cependant, "
|
||
"ils s'exécutent généralement plus lentement. Voir aussi :term:`interactif`."
|
||
|
||
#: glossary.rst:570
|
||
msgid "interpreter shutdown"
|
||
msgstr "arrêt de l'interpréteur"
|
||
|
||
#: glossary.rst:572
|
||
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 ""
|
||
"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 des exceptions puisque les "
|
||
"ressources auxquelles il fait appel sont susceptibles de ne plus "
|
||
"fonctionner, (typiquement les modules des bibliothèques ou le mécanisme de "
|
||
"*warning*)."
|
||
|
||
#: glossary.rst:581
|
||
msgid ""
|
||
"The main reason for interpreter shutdown is that the ``__main__`` module or "
|
||
"the script being run has finished executing."
|
||
msgstr ""
|
||
"La principale raison d'arrêt de l'interpréteur est que le module "
|
||
"``__main__`` ou le script en cours d'exécution a terminé de s'exécuter."
|
||
|
||
#: glossary.rst:583
|
||
msgid "iterable"
|
||
msgstr "itérable"
|
||
|
||
#: glossary.rst:585
|
||
#, fuzzy
|
||
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__` method or with a :meth:`__getitem__` method that implements :"
|
||
"term:`Sequence <sequence>` semantics."
|
||
msgstr ""
|
||
"Objet capable de renvoyer ses éléments un à un. Par exemple, tous les types "
|
||
"séquence (comme :class:`list`, :class:`str`, et :class:`tuple`), quelques "
|
||
"autres types comme :class:`dict`, :term:`objets fichiers <objet fichier>` ou "
|
||
"tout objet d'une classe ayant une méthode :meth:`__iter__` ou :meth:"
|
||
"`__getitem__` qui implémente la sémantique d'une :term:`Sequence`."
|
||
|
||
#: glossary.rst:592
|
||
msgid ""
|
||
"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 ""
|
||
"Les itérables peuvent être utilisés dans des boucles :keyword:`for` et à "
|
||
"beaucoup d'autres endroits où une séquence est requise (:func:`zip`, :func:"
|
||
"`map`…). Lorsqu'un itérable est passé comme argument à la fonction native :"
|
||
"func:`iter`, celle-ci fournit en retour un itérateur sur cet itérable. Cet "
|
||
"itérateur n'est valable que pour une seule 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 soi-même des objets itérateurs. "
|
||
"L'instruction ``for`` le fait 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`."
|
||
|
||
#: glossary.rst:602
|
||
msgid "iterator"
|
||
msgstr "itérateur"
|
||
|
||
#: glossary.rst:604
|
||
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 ""
|
||
"Objet représentant un flux de donnée. Des appels successifs à la méthode :"
|
||
"meth:`~iterator.__next__` de l'itérateur (ou le passer à la fonction native :"
|
||
"func:`next`) donne successivement les objets du flux. Lorsque plus aucune "
|
||
"donnée n'est disponible, une exception :exc:`StopIteration` est levée. À ce "
|
||
"point, l'itérateur est épuisé et tous les appels suivants à sa méthode :meth:"
|
||
"`__next__` lèveront encore une exception :exc:`StopIteration`. Les "
|
||
"itérateurs doivent avoir une méthode :meth:`__iter__` qui renvoie l'objet "
|
||
"itérateur lui-même, de façon à ce 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 est un code qui tente plusieurs "
|
||
"itérations complètes. Un objet conteneur, (tel que :class:`list`) produit un "
|
||
"nouvel itérateur neuf à chaque fois qu'il est passé à la fonction :func:"
|
||
"`iter` ou s'il est utilisé dans une boucle :keyword:`for`. Faire ceci sur un "
|
||
"itérateur donnerait simplement le même objet itérateur épuisé utilisé dans "
|
||
"son itération précédente, le faisant ressembler à un conteneur vide."
|
||
|
||
#: glossary.rst:619
|
||
msgid "More information can be found in :ref:`typeiter`."
|
||
msgstr "Vous trouverez davantage d'informations dans :ref:`typeiter`."
|
||
|
||
#: glossary.rst:620
|
||
msgid "key function"
|
||
msgstr "fonction clé"
|
||
|
||
#: glossary.rst:622
|
||
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 ""
|
||
"Une fonction clé est un objet appelable qui renvoie une valeur à fins de tri "
|
||
"ou de classement. Par exemple, la fonction :func:`locale.strxfrm` est "
|
||
"utilisée pour générer une clé de classement prenant en compte les "
|
||
"conventions de classement spécifiques aux paramètres régionaux courants."
|
||
|
||
#: glossary.rst:627
|
||
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 ""
|
||
"Plusieurs outils dans Python acceptent des fonctions clés pour déterminer "
|
||
"comment les éléments sont classés ou groupés. On peut citer les fonctions :"
|
||
"func:`min`, :func:`max`, :func:`sorted`, :meth:`list.sort`, :func:`heapq."
|
||
"merge`, :func:`heapq.nsmallest`, :func:`heapq.nlargest` et :func:`itertools."
|
||
"groupby`."
|
||
|
||
#: glossary.rst:633
|
||
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 ""
|
||
"Il existe plusieurs moyens de créer une fonction clé. Par exemple, la "
|
||
"méthode :meth:`str.lower` peut servir de fonction clé pour effectuer des "
|
||
"recherches insensibles à la casse. Aussi, il est possible de créer des "
|
||
"fonctions clés avec des expressions :keyword:`lambda`, comme ``lambda r: "
|
||
"(r[0], r[2])``. Vous noterez que le module :mod:`operator` propose des "
|
||
"constructeurs de fonctions clefs : :func:`~operator.attrgetter`, :func:"
|
||
"`~operator.itemgetter` et :func:`~operator.methodcaller`. Voir :ref:`Comment "
|
||
"Trier <sortinghowto>` pour des exemples de création et d'utilisation de "
|
||
"fonctions clefs."
|
||
|
||
#: glossary.rst:641
|
||
msgid "keyword argument"
|
||
msgstr "argument nommé"
|
||
|
||
#: glossary.rst:643 glossary.rst:920
|
||
msgid "See :term:`argument`."
|
||
msgstr "Voir :term:`argument`."
|
||
|
||
#: glossary.rst:644
|
||
msgid "lambda"
|
||
msgstr "lambda"
|
||
|
||
#: glossary.rst:646
|
||
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 [parameters]: expression``"
|
||
msgstr ""
|
||
"Fonction anonyme sous la forme d'une :term:`expression` et ne contenant "
|
||
"qu'une seule expression, exécutée lorsque la fonction est appelée. La "
|
||
"syntaxe pour créer des fonctions lambda est : ``lambda [parameters]: "
|
||
"expression``"
|
||
|
||
#: glossary.rst:649
|
||
msgid "LBYL"
|
||
msgstr "LBYL"
|
||
|
||
#: glossary.rst:651
|
||
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 ""
|
||
"Regarde avant de sauter, (*Look before you leap* en anglais). 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`."
|
||
|
||
#: glossary.rst:656
|
||
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 ""
|
||
"Dans un environnement avec plusieurs fils d'exécution (*multi-threaded* en "
|
||
"anglais), le style *LBYL* peut engendrer un séquencement critique (*race "
|
||
"condition* en anglais) entre le \"regarde\" et le \"sauter\". Par exemple, "
|
||
"le code ``if key in mapping: return mapping[key]`` peut échouer si un autre "
|
||
"fil d'exécution supprime la clé *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."
|
||
|
||
#: glossary.rst:661
|
||
msgid "list"
|
||
msgstr "*list*"
|
||
|
||
#: glossary.rst:663
|
||
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 is "
|
||
"O(1)."
|
||
msgstr ""
|
||
"Un type natif de :term:`sequence` dans Python. En dépit de son nom, une "
|
||
"``list`` ressemble plus à un tableau (*array* dans la plupart des langages) "
|
||
"qu'à une liste chaînée puisque les accès se font en O(1)."
|
||
|
||
#: glossary.rst:666
|
||
msgid "list comprehension"
|
||
msgstr "liste en compréhension (ou liste en intension)"
|
||
|
||
#: glossary.rst:668
|
||
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 ""
|
||
"Écriture concise pour manipuler tout ou partie des éléments d'une séquence "
|
||
"et renvoyer une liste contenant les résultats. ``result = ['{:#04x}'."
|
||
"format(x) for x in range(256) if x % 2 == 0]`` génère la liste composée des "
|
||
"nombres pairs de 0 à 255 écrits sous formes de chaînes de caractères et en "
|
||
"hexadécimal (``0x…``). La clause :keyword:`if` est optionnelle. Si elle est "
|
||
"omise, tous les éléments du ``range(256)`` seront utilisés."
|
||
|
||
#: glossary.rst:674
|
||
msgid "loader"
|
||
msgstr "chargeur"
|
||
|
||
#: glossary.rst:676
|
||
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 ""
|
||
"Objet qui charge un module. Il doit définir une méthode nommée :meth:"
|
||
"`load_module`. Un chargeur est typiquement donné par un :term:`chercheur "
|
||
"<finder>`. Voir la :pep:`302` pour plus de détails et :class:`importlib.ABC."
|
||
"Loader` pour sa :term:`classe de base abstraite`."
|
||
|
||
#: glossary.rst:680
|
||
msgid "magic method"
|
||
msgstr "méthode magique"
|
||
|
||
#: glossary.rst:684
|
||
msgid "An informal synonym for :term:`special method`."
|
||
msgstr "Un synonyme informel de :term:`special method`."
|
||
|
||
#: glossary.rst:685
|
||
msgid "mapping"
|
||
msgstr "tableau de correspondances"
|
||
|
||
#: glossary.rst:687
|
||
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 ""
|
||
"(*mapping* en anglais) Conteneur permettant de rechercher des éléments à "
|
||
"partir de clés et implémentant les méthodes spécifiées dans les :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 tableaux de correspondances : :class:"
|
||
"`dict`, :class:`collections.defaultdict`, :class:`collections.OrderedDict` "
|
||
"et :class:`collections.Counter`."
|
||
|
||
#: glossary.rst:693
|
||
msgid "meta path finder"
|
||
msgstr "chercheur dans les méta-chemins"
|
||
|
||
#: glossary.rst:695
|
||
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 ""
|
||
"Un :term:`chercheur <finder>` renvoyé par une recherche dans :data:`sys."
|
||
"meta_path`. Les chercheurs dans les méta-chemins ressemblent, mais sont "
|
||
"différents des :term:`chercheurs d'entrée dans path <path entry finder>`."
|
||
|
||
#: glossary.rst:699
|
||
msgid ""
|
||
"See :class:`importlib.abc.MetaPathFinder` for the methods that meta path "
|
||
"finders implement."
|
||
msgstr ""
|
||
"Voir :class:`importlib.abc.MetaPathFinder` pour les méthodes que les "
|
||
"chercheurs dans les méta-chemins doivent implémenter."
|
||
|
||
#: glossary.rst:701
|
||
msgid "metaclass"
|
||
msgstr "métaclasse"
|
||
|
||
#: glossary.rst:703
|
||
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 ""
|
||
"Classe d'une classe. Les définitions de classe créent un nom pour la classe, "
|
||
"un dictionnaire de classe et une liste de classes parentes. 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. La particularité de Python est la possibilité de créer des "
|
||
"métaclasses personnalisées. La plupart des utilisateurs n'auront jamais "
|
||
"besoin de cet outil, mais lorsque le besoin survient, les métaclasses "
|
||
"offrent des solutions élégantes et puissantes. Elles sont utilisées pour "
|
||
"journaliser les accès à des propriétés, rendre sûrs les environnements "
|
||
"*multi-threads*, suivre la création d'objets, implémenter des singletons et "
|
||
"bien d'autres tâches."
|
||
|
||
#: glossary.rst:713
|
||
msgid "More information can be found in :ref:`metaclasses`."
|
||
msgstr "Plus d'informations sont disponibles dans : :ref:`metaclasses`."
|
||
|
||
#: glossary.rst:714
|
||
msgid "method"
|
||
msgstr "méthode"
|
||
|
||
#: glossary.rst:716
|
||
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 ""
|
||
"Fonction définie à l'intérieur d'une classe. Lorsqu'elle est appelée comme "
|
||
"un attribut d'une instance de cette classe, la méthode reçoit l'instance en "
|
||
"premier :term:`argument` (qui, par convention, est habituellement nommé "
|
||
"``self``). Voir :term:`function` et :term:`nested scope`."
|
||
|
||
#: glossary.rst:720
|
||
msgid "method resolution order"
|
||
msgstr "ordre de résolution des méthodes"
|
||
|
||
#: glossary.rst:722
|
||
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 ""
|
||
"L'ordre de résolution des méthodes (*MRO* pour *Method Resolution Order* en "
|
||
"anglais) est, lors de la recherche d'un attribut dans les classes parentes, "
|
||
"la façon dont l'interpréteur Python classe ces 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."
|
||
|
||
#: glossary.rst:726
|
||
msgid "module"
|
||
msgstr "module"
|
||
|
||
#: glossary.rst:728
|
||
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 ""
|
||
"Objet utilisé pour organiser une portion unitaire de code en Python. Les "
|
||
"modules ont un espace de nommage et peuvent contenir n'importe quels objets "
|
||
"Python. Charger des modules est appelé :term:`importer <importing>`."
|
||
|
||
#: glossary.rst:732
|
||
msgid "See also :term:`package`."
|
||
msgstr "Voir aussi :term:`paquet`."
|
||
|
||
#: glossary.rst:733
|
||
msgid "module spec"
|
||
msgstr "spécificateur de module"
|
||
|
||
#: glossary.rst:735
|
||
msgid ""
|
||
"A namespace containing the import-related information used to load a module. "
|
||
"An instance of :class:`importlib.machinery.ModuleSpec`."
|
||
msgstr ""
|
||
"Espace de nommage contenant les informations, relatives à l'importation, "
|
||
"utilisées pour charger un module. C'est une instance de la classe :class:"
|
||
"`importlib.machinery.ModuleSpec`."
|
||
|
||
#: glossary.rst:737
|
||
msgid "MRO"
|
||
msgstr "MRO"
|
||
|
||
#: glossary.rst:739
|
||
msgid "See :term:`method resolution order`."
|
||
msgstr "Voir :term:`ordre de résolution des méthodes`."
|
||
|
||
#: glossary.rst:740
|
||
msgid "mutable"
|
||
msgstr "muable"
|
||
|
||
#: glossary.rst:742
|
||
msgid ""
|
||
"Mutable objects can change their value but keep their :func:`id`. See also :"
|
||
"term:`immutable`."
|
||
msgstr ""
|
||
"Un objet muable peut changer de valeur tout en gardant le même :func:`id`. "
|
||
"Voir aussi :term:`immuable`."
|
||
|
||
#: glossary.rst:744
|
||
msgid "named tuple"
|
||
msgstr "n-uplet nommé"
|
||
|
||
#: glossary.rst:746
|
||
msgid ""
|
||
"The term \"named tuple\" applies to any type or class that inherits from "
|
||
"tuple and whose indexable elements are also accessible using named "
|
||
"attributes. The type or class may have other features as well."
|
||
msgstr ""
|
||
"Le terme \"n-uplet nommé\" s'applique à tous les types ou classes qui "
|
||
"héritent de la classe ``tuple`` et dont les éléments indexables sont aussi "
|
||
"accessibles en utilisant des attributs nommés. Les types et classes peuvent "
|
||
"avoir aussi d'autres caractéristiques."
|
||
|
||
#: glossary.rst:750
|
||
msgid ""
|
||
"Several built-in types are named tuples, including the values returned by :"
|
||
"func:`time.localtime` and :func:`os.stat`. Another example is :data:`sys."
|
||
"float_info`::"
|
||
msgstr ""
|
||
"Plusieurs types natifs sont appelés n-uplets, y compris les valeurs "
|
||
"retournées par :func:`time.localtime` et :func:`os.stat`. Un autre exemple "
|
||
"est :data:`sys.float_info` ::"
|
||
|
||
#: glossary.rst:761
|
||
msgid ""
|
||
"Some named tuples are built-in types (such as the above examples). "
|
||
"Alternatively, a named tuple can be created from a regular class definition "
|
||
"that inherits from :class:`tuple` and that defines named fields. Such a "
|
||
"class can be written by hand or it can be created with the factory function :"
|
||
"func:`collections.namedtuple`. The latter technique also adds some extra "
|
||
"methods that may not be found in hand-written or built-in named tuples."
|
||
msgstr ""
|
||
"Certains *n-uplets nommés* sont des types natifs (comme les exemples ci-"
|
||
"dessus). Sinon, un *n-uplet nommé* peut être créé à partir d'une définition "
|
||
"de classe habituelle qui hérite de :class:`tuple` et qui définit les champs "
|
||
"nommés. Une telle classe peut être écrite à la main ou être créée avec la "
|
||
"fonction :func:`collections.namedtuple`. Cette dernière méthode ajoute des "
|
||
"méthodes supplémentaires qui ne seront pas trouvées dans celles écrites à la "
|
||
"main ni dans les n-uplets nommés natifs."
|
||
|
||
#: glossary.rst:768
|
||
msgid "namespace"
|
||
msgstr "espace de nommage"
|
||
|
||
#: glossary.rst:770
|
||
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 ""
|
||
"L'endroit où une variable est stockée. Les espaces de nommage sont "
|
||
"implémentés avec des dictionnaires. Il existe des espaces de nommage "
|
||
"globaux, natifs ou imbriqués dans les objets (dans les méthodes). Les "
|
||
"espaces de nommage favorisent la modularité car ils permettent 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 nommage aident aussi à la lisibilité et la maintenabilité en rendant "
|
||
"clair quel module implémente une fonction. Par exemple, écrire :func:`random."
|
||
"seed` ou :func:`itertools.islice` affiche clairement que ces fonctions sont "
|
||
"implémentées respectivement dans les modules :mod:`random` et :mod:"
|
||
"`itertools`."
|
||
|
||
#: glossary.rst:780
|
||
msgid "namespace package"
|
||
msgstr "paquet-espace de nommage"
|
||
|
||
#: glossary.rst:782
|
||
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 ""
|
||
"Un :term:`paquet` tel que défini dans la :pep:`421` qui ne sert qu'à "
|
||
"contenir des sous-paquets. Les paquets-espace de nommage 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``."
|
||
|
||
#: glossary.rst:787
|
||
msgid "See also :term:`module`."
|
||
msgstr "Voir aussi :term:`module`."
|
||
|
||
#: glossary.rst:788
|
||
msgid "nested scope"
|
||
msgstr "portée imbriquée"
|
||
|
||
#: glossary.rst:790
|
||
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 ""
|
||
"Possibilité de faire référence à une variable déclarée dans une définition "
|
||
"englobante. Typiquement, une fonction définie à l'intérieur d'une autre "
|
||
"fonction a accès aux variables de cette dernière. 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 "
|
||
"nommage le plus proche. Tout comme les variables globales qui sont stockés "
|
||
"dans l'espace de nommage global, le mot clef :keyword:`nonlocal` permet "
|
||
"d'écrire dans l'espace de nommage dans lequel est déclarée la variable."
|
||
|
||
#: glossary.rst:797
|
||
msgid "new-style class"
|
||
msgstr "nouvelle classe"
|
||
|
||
#: glossary.rst:799
|
||
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 ""
|
||
"Ancien nom pour l'implémentation actuelle des classes, pour tous les objets. "
|
||
"Dans les anciennes versions de Python, seules les nouvelles classes "
|
||
"pouvaient utiliser les nouvelles fonctionnalités telles que :attr:`~object."
|
||
"__slots__`, les descripteurs, les propriétés, :meth:`__getattribute__`, les "
|
||
"méthodes de classe et les méthodes statiques."
|
||
|
||
#: glossary.rst:803
|
||
msgid "object"
|
||
msgstr "objet"
|
||
|
||
#: glossary.rst:805
|
||
msgid ""
|
||
"Any data with state (attributes or value) and defined behavior (methods). "
|
||
"Also the ultimate base class of any :term:`new-style class`."
|
||
msgstr ""
|
||
"N'importe quelle donnée comportant des états (sous forme d'attributs ou "
|
||
"d'une valeur) et un comportement (des méthodes). C'est aussi (``object``) "
|
||
"l'ancêtre commun à absolument toutes les :term:`nouvelles classes <new-style "
|
||
"class>`."
|
||
|
||
#: glossary.rst:808
|
||
msgid "package"
|
||
msgstr "paquet"
|
||
|
||
#: glossary.rst:810
|
||
msgid ""
|
||
"A Python :term:`module` which can contain submodules or recursively, "
|
||
"subpackages. Technically, a package is a Python module with an ``__path__`` "
|
||
"attribute."
|
||
msgstr ""
|
||
":term:`module` Python qui peut contenir des sous-modules ou des sous-"
|
||
"paquets. Techniquement, un paquet est un module qui possède un attribut "
|
||
"``__path__``."
|
||
|
||
#: glossary.rst:814
|
||
msgid "See also :term:`regular package` and :term:`namespace package`."
|
||
msgstr "Voir aussi :term:`paquet classique` et :term:`namespace package`."
|
||
|
||
#: glossary.rst:815
|
||
msgid "parameter"
|
||
msgstr "paramètre"
|
||
|
||
#: glossary.rst:817
|
||
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 ""
|
||
"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 sortes de paramètres :"
|
||
|
||
#: glossary.rst:821
|
||
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 ""
|
||
":dfn:`positional-or-keyword` : l'argument peut être passé soit par sa :term:"
|
||
"`position <argument>`, soit en tant que :term:`argument nommé <argument>`. "
|
||
"C'est le type de paramètre par défaut. Par exemple, *foo* et *bar* dans "
|
||
"l'exemple suivant ::"
|
||
|
||
#: glossary.rst:830
|
||
msgid ""
|
||
":dfn:`positional-only`: specifies an argument that can be supplied only by "
|
||
"position. Positional-only parameters can be defined by including a ``/`` "
|
||
"character in the parameter list of the function definition after them, for "
|
||
"example *posonly1* and *posonly2* in the following::"
|
||
msgstr ""
|
||
":dfn:`positional-only` : définit un argument qui ne peut être fourni que par "
|
||
"position. Les paramètres *positional-only* peuvent être définis en insérant "
|
||
"un caractère \"/\" dans la liste de paramètres de la définition de fonction "
|
||
"après eux. Par exemple : *posonly1* et *posonly2* dans le code suivant ::"
|
||
|
||
#: glossary.rst:839
|
||
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 ""
|
||
":dfn:`keyword-only` : l'argument ne peut être fourni que nommé. Les "
|
||
"paramètres *keyword-only* peuvent être définis en utilisant un seul "
|
||
"paramètre *var-positional*, ou en ajoutant une étoile (``*``) seule dans la "
|
||
"liste des paramètres avant eux. Par exemple, *kw_only1* et *kw_only2* dans "
|
||
"le code suivant ::"
|
||
|
||
#: glossary.rst:847
|
||
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 ""
|
||
":dfn:`var-positional` : une séquence d'arguments positionnels peut être "
|
||
"fournie (en plus de tous les arguments positionnels déjà acceptés par "
|
||
"d'autres paramètres). Un tel paramètre peut être défini en préfixant son nom "
|
||
"par une ``*``. Par exemple *args* ci-après ::"
|
||
|
||
#: glossary.rst:855
|
||
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 ""
|
||
":dfn:`var-keyword` : une quantité arbitraire d'arguments peut être passée, "
|
||
"chacun étant nommé (en plus de tous les arguments nommés déjà acceptés par "
|
||
"d'autres paramètres). Un tel paramètre est défini en préfixant le nom du "
|
||
"paramètre par ``**``. Par exemple, *kwargs* ci-dessus."
|
||
|
||
#: glossary.rst:861
|
||
msgid ""
|
||
"Parameters can specify both optional and required arguments, as well as "
|
||
"default values for some optional arguments."
|
||
msgstr ""
|
||
"Les paramètres peuvent spécifier des arguments obligatoires ou optionnels, "
|
||
"ainsi que des valeurs par défaut pour les arguments optionnels."
|
||
|
||
#: glossary.rst:864
|
||
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 ""
|
||
"Voir aussi :term:`argument` dans le glossaire, la question sur :ref:`la "
|
||
"différence entre les arguments et les paramètres <faq-argument-vs-"
|
||
"parameter>` dans la FAQ, la classe :class:`inspect.Parameter`, la section :"
|
||
"ref:`function` et la :pep:`362`."
|
||
|
||
#: glossary.rst:868
|
||
msgid "path entry"
|
||
msgstr "entrée de chemin"
|
||
|
||
#: glossary.rst:870
|
||
msgid ""
|
||
"A single location on the :term:`import path` which the :term:`path based "
|
||
"finder` consults to find modules for importing."
|
||
msgstr ""
|
||
"Emplacement dans le :term:`chemin des importations <import path>` (*import "
|
||
"path* en anglais, d'où le *path*) que le :term:`chercheur basé sur les "
|
||
"chemins <path based finder>` consulte pour trouver des modules à importer."
|
||
|
||
#: glossary.rst:872
|
||
msgid "path entry finder"
|
||
msgstr "chercheur de chemins"
|
||
|
||
#: glossary.rst:874
|
||
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 ""
|
||
":term:`chercheur <finder>` renvoyé par un appelable sur un :data:`sys."
|
||
"path_hooks` (c'est-à-dire un :term:`point d'entrée pour la recherche dans "
|
||
"path <path entry hook>`) qui sait où trouver des modules lorsqu'on lui donne "
|
||
"une :term:`entrée de path <path entry>`."
|
||
|
||
#: glossary.rst:878
|
||
msgid ""
|
||
"See :class:`importlib.abc.PathEntryFinder` for the methods that path entry "
|
||
"finders implement."
|
||
msgstr ""
|
||
"Voir :class:`importlib.abc.PathEntryFinder` pour les méthodes qu'un "
|
||
"chercheur d'entrée dans *path* doit implémenter."
|
||
|
||
#: glossary.rst:880
|
||
msgid "path entry hook"
|
||
msgstr "point d'entrée pour la recherche dans *path*"
|
||
|
||
#: glossary.rst:882
|
||
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 ""
|
||
"Appelable dans la liste :data:`sys.path_hook` qui donne un :term:`chercheur "
|
||
"d'entrée dans path <path entry finder>` s'il sait où trouver des modules "
|
||
"pour une :term:`entrée dans path <path entry>` donnée."
|
||
|
||
#: glossary.rst:885
|
||
msgid "path based finder"
|
||
msgstr "chercheur basé sur les chemins"
|
||
|
||
#: glossary.rst:887
|
||
msgid ""
|
||
"One of the default :term:`meta path finders <meta path finder>` which "
|
||
"searches an :term:`import path` for modules."
|
||
msgstr ""
|
||
"L'un des :term:`chercheurs dans les méta-chemins <meta path finder>` par "
|
||
"défaut qui cherche des modules dans un :term:`chemin des importations "
|
||
"<import path>`."
|
||
|
||
#: glossary.rst:889
|
||
msgid "path-like object"
|
||
msgstr "objet simili-chemin"
|
||
|
||
#: glossary.rst:891
|
||
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 ""
|
||
"Objet représentant un chemin du système de fichiers. Un objet simili-chemin "
|
||
"est un objet :class:`str` ou un objet :class:`bytes` représentant un chemin "
|
||
"ou un objet implémentant le protocole :class:`os.PathLike`. Un objet qui "
|
||
"accepte le protocole :class:`os.PathLike` peut être converti en un chemin :"
|
||
"class:`str` ou :class:`bytes` du système de fichiers en appelant 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. A été Introduit par la :pep:`519`."
|
||
|
||
#: glossary.rst:899
|
||
msgid "PEP"
|
||
msgstr "PEP"
|
||
|
||
#: glossary.rst:901
|
||
msgid ""
|
||
"Python Enhancement Proposal. A PEP is a design document providing "
|
||
"information to the Python community, or describing a new feature for Python "
|
||
"or its processes or environment. PEPs should provide a concise technical "
|
||
"specification and a rationale for proposed features."
|
||
msgstr ""
|
||
"*Python Enhancement Proposal* (Proposition d'amélioration Python). Un PEP "
|
||
"est un document de conception fournissant des informations à la communauté "
|
||
"Python ou décrivant une nouvelle fonctionnalité pour Python, ses processus "
|
||
"ou son environnement. Les PEP doivent fournir une spécification technique "
|
||
"concise et une justification des fonctionnalités proposées."
|
||
|
||
#: glossary.rst:907
|
||
msgid ""
|
||
"PEPs are intended to be the primary mechanisms for proposing major new "
|
||
"features, for collecting community input on an issue, and for documenting "
|
||
"the design decisions that have gone into Python. The PEP author is "
|
||
"responsible for building consensus within the community and documenting "
|
||
"dissenting opinions."
|
||
msgstr ""
|
||
"Les PEPs sont censés être les principaux mécanismes pour proposer de "
|
||
"nouvelles fonctionnalités majeures, pour recueillir les commentaires de la "
|
||
"communauté sur une question et pour documenter les décisions de conception "
|
||
"qui sont intégrées en Python. L’auteur du PEP est responsable de "
|
||
"l’établissement d’un consensus au sein de la communauté et de documenter les "
|
||
"opinions contradictoires."
|
||
|
||
#: glossary.rst:913
|
||
msgid "See :pep:`1`."
|
||
msgstr "Voir :pep:`1`."
|
||
|
||
#: glossary.rst:914
|
||
msgid "portion"
|
||
msgstr "portion"
|
||
|
||
#: glossary.rst:916
|
||
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 ""
|
||
"Jeu de fichiers dans un seul dossier (pouvant être stocké sous forme de "
|
||
"fichier zip) qui contribue à l'espace de nommage d'un paquet, tel que défini "
|
||
"dans la :pep:`420`."
|
||
|
||
#: glossary.rst:918
|
||
msgid "positional argument"
|
||
msgstr "argument positionnel"
|
||
|
||
#: glossary.rst:921
|
||
msgid "provisional API"
|
||
msgstr "API provisoire"
|
||
|
||
#: glossary.rst:923
|
||
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 ""
|
||
"Une API provisoire est une API qui n'offre aucune garantie de "
|
||
"rétrocompatibilité (la bibliothèque standard exige la rétrocompatibilité). "
|
||
"Bien que des changements majeurs d'une telle interface ne soient pas "
|
||
"attendus, tant qu'elle est étiquetée provisoire, des changements cassant la "
|
||
"rétrocompatibilité (y compris sa suppression complète) peuvent survenir si "
|
||
"les développeurs principaux le jugent nécessaire. Ces modifications ne "
|
||
"surviendront que si de sérieux problèmes sont découverts et qu'ils n'avaient "
|
||
"pas été identifiés avant l'ajout de l'API."
|
||
|
||
#: glossary.rst:932
|
||
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 ""
|
||
"Même pour les API provisoires, les changements cassant la rétrocompatibilité "
|
||
"sont considérés comme des \"solutions de dernier recours\". Tout ce qui est "
|
||
"possible sera fait pour tenter de résoudre les problèmes en conservant la "
|
||
"rétrocompatibilité."
|
||
|
||
#: glossary.rst:936
|
||
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 ""
|
||
"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."
|
||
|
||
#: glossary.rst:939
|
||
msgid "provisional package"
|
||
msgstr "paquet provisoire"
|
||
|
||
#: glossary.rst:941
|
||
msgid "See :term:`provisional API`."
|
||
msgstr "Voir :term:`provisional API`."
|
||
|
||
#: glossary.rst:942
|
||
msgid "Python 3000"
|
||
msgstr "Python 3000"
|
||
|
||
#: glossary.rst:944
|
||
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 ""
|
||
"Surnom donné à la série des Python 3.x (très vieux surnom donné à l'époque "
|
||
"où Python 3 représentait un futur lointain). Aussi abrégé *Py3k*."
|
||
|
||
#: glossary.rst:947
|
||
msgid "Pythonic"
|
||
msgstr "*Pythonique*"
|
||
|
||
#: glossary.rst:949
|
||
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 ""
|
||
"Idée, ou bout de code, qui colle aux idiomes de Python plutôt qu'aux "
|
||
"concepts communs rencontrés dans d'autres langages. Par exemple, il est "
|
||
"idiomatique en Python de parcourir les éléments d'un itérable en utilisant :"
|
||
"keyword:`for`. Beaucoup d'autres langages n'ont pas cette possibilité, donc "
|
||
"les gens qui ne sont pas habitués à Python utilisent parfois un compteur "
|
||
"numérique à la place ::"
|
||
|
||
#: glossary.rst:959
|
||
msgid "As opposed to the cleaner, Pythonic method::"
|
||
msgstr ""
|
||
"Plutôt qu'utiliser la méthode, plus propre et élégante, donc *Pythonique* ::"
|
||
|
||
#: glossary.rst:963
|
||
msgid "qualified name"
|
||
msgstr "nom qualifié"
|
||
|
||
#: glossary.rst:965
|
||
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 ""
|
||
"Nom, comprenant des points, montrant le \"chemin\" de l'espace de nommage "
|
||
"global d'un module vers une classe, 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 ::"
|
||
|
||
#: glossary.rst:982
|
||
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 ""
|
||
"Lorsqu'il est utilisé pour nommer des modules, le *nom qualifié complet* "
|
||
"(*fully qualified name - FQN* en anglais) signifie le chemin complet (séparé "
|
||
"par des points) vers le module, incluant tous les paquets parents. Par "
|
||
"exemple : ``email.mime.text`` ::"
|
||
|
||
#: glossary.rst:989
|
||
msgid "reference count"
|
||
msgstr "nombre de références"
|
||
|
||
#: glossary.rst:991
|
||
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 ""
|
||
"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 clé de "
|
||
"l'implémentation :term:`CPython`. Le module :mod:`sys` définit une fonction :"
|
||
"func:`~sys.getrefcount` que les développeurs peuvent utiliser pour obtenir "
|
||
"le nombre de références à un objet donné."
|
||
|
||
#: glossary.rst:997
|
||
msgid "regular package"
|
||
msgstr "paquet classique"
|
||
|
||
#: glossary.rst:999
|
||
msgid ""
|
||
"A traditional :term:`package`, such as a directory containing an ``__init__."
|
||
"py`` file."
|
||
msgstr ""
|
||
":term:`paquet` traditionnel, tel qu'un dossier contenant un fichier "
|
||
"``__init__.py``."
|
||
|
||
#: glossary.rst:1002
|
||
msgid "See also :term:`namespace package`."
|
||
msgstr "Voir aussi :term:`paquet-espace de nommage <namespace package>`."
|
||
|
||
#: glossary.rst:1003
|
||
msgid "__slots__"
|
||
msgstr "``__slots__``"
|
||
|
||
#: glossary.rst:1005
|
||
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 ""
|
||
"Déclaration dans une classe qui économise de la mémoire en pré-allouant de "
|
||
"l'espace pour les attributs des instances et qui élimine le dictionnaire "
|
||
"(des attributs) des instances. Bien que populaire, cette technique est "
|
||
"difficile à maîtriser et devrait être réservée à de rares cas où un grand "
|
||
"nombre d'instances dans une application devient un sujet critique pour la "
|
||
"mémoire."
|
||
|
||
#: glossary.rst:1010
|
||
msgid "sequence"
|
||
msgstr "séquence"
|
||
|
||
#: glossary.rst:1012
|
||
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 ""
|
||
":term:`itérable` qui offre un accès efficace à ses éléments par un indice "
|
||
"sous forme de nombre entier via la méthode spéciale :meth:`__getitem__` et "
|
||
"qui définit une méthode :meth:`__len__` donnant sa taille. Voici quelques "
|
||
"séquences natives : :class:`list`, :class:`str`, :class:`tuple`, et :class:"
|
||
"`bytes`. Notez que :class:`dict` possède 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 clé "
|
||
"arbitraire :term:`immuable` plutôt qu'un nombre entier."
|
||
|
||
#: glossary.rst:1021
|
||
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 ""
|
||
"La classe abstraite de base :class:`collections.abc.Sequence` définit 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`."
|
||
|
||
#: glossary.rst:1028
|
||
msgid "single dispatch"
|
||
msgstr "distribution simple"
|
||
|
||
#: glossary.rst:1030
|
||
msgid ""
|
||
"A form of :term:`generic function` dispatch where the implementation is "
|
||
"chosen based on the type of a single argument."
|
||
msgstr ""
|
||
"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."
|
||
|
||
#: glossary.rst:1032
|
||
msgid "slice"
|
||
msgstr "tranche"
|
||
|
||
#: glossary.rst:1034
|
||
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 ""
|
||
"(*slice* en anglais), 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, comme dans "
|
||
"``variable_name[1:3:5]``. Cette notation utilise des objets :class:`slice` "
|
||
"en interne."
|
||
|
||
#: glossary.rst:1038
|
||
msgid "special method"
|
||
msgstr "méthode spéciale"
|
||
|
||
#: glossary.rst:1042
|
||
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 ""
|
||
"(*special method* en anglais) Méthode appelée implicitement par Python pour "
|
||
"exécuter une opération sur un type, comme 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`."
|
||
|
||
#: glossary.rst:1046
|
||
msgid "statement"
|
||
msgstr "instruction"
|
||
|
||
#: glossary.rst:1048
|
||
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 ""
|
||
"Une instruction (*statement* en anglais) est un composant d'un \"bloc\" de "
|
||
"code. Une instruction est soit une :term:`expression`, soit une ou plusieurs "
|
||
"constructions basées sur un mot-clé, comme :keyword:`if`, :keyword:`while` "
|
||
"ou :keyword:`for`."
|
||
|
||
#: glossary.rst:1051
|
||
msgid "text encoding"
|
||
msgstr "encodage de texte"
|
||
|
||
#: glossary.rst:1053
|
||
msgid "A codec which encodes Unicode strings to bytes."
|
||
msgstr ""
|
||
"Codec (codeur-décodeur) qui convertit des chaînes de caractères Unicode en "
|
||
"octets (classe *bytes*)."
|
||
|
||
#: glossary.rst:1054
|
||
msgid "text file"
|
||
msgstr "fichier texte"
|
||
|
||
#: glossary.rst:1056
|
||
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:"
|
||
"`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`."
|
||
msgstr ""
|
||
":term:`file object` capable de lire et d'écrire des objets :class:`str`. "
|
||
"Souvent, un fichier texte (*text file* en anglais) accède en fait à un flux "
|
||
"de donnée en octets et gère l':term:`text encoding` automatiquement. Des "
|
||
"exemples de fichiers textes sont les fichiers ouverts en mode texte (``'r'`` "
|
||
"ou ``'w'``), :data:`sys.stdin`, :data:`sys.stdout` et les instances de :"
|
||
"class:`io.StringIO`."
|
||
|
||
#: glossary.rst:1063
|
||
msgid ""
|
||
"See also :term:`binary file` for a file object able to read and write :term:"
|
||
"`bytes-like objects <bytes-like object>`."
|
||
msgstr ""
|
||
"Voir aussi :term:`binary file` pour un objet fichier capable de lire et "
|
||
"d'écrire :term:`bytes-like objects <bytes-like object>`."
|
||
|
||
#: glossary.rst:1065
|
||
msgid "triple-quoted string"
|
||
msgstr "chaîne entre triple guillemets"
|
||
|
||
#: glossary.rst:1067
|
||
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 ""
|
||
"Chaîne qui est délimitée par trois guillemets simples (``'``) ou trois "
|
||
"guillemets doubles (``\"``). Bien qu'elle ne fournisse aucune fonctionnalité "
|
||
"qui ne soit pas disponible avec une chaîne entre guillemets, elle est utile "
|
||
"pour de nombreuses raisons. Elle vous autorise à insérer des guillemets "
|
||
"simples et doubles dans une chaîne sans avoir à les protéger et elle peut "
|
||
"s'étendre sur plusieurs lignes sans avoir à terminer chaque ligne par un ``"
|
||
"\\``. Elle est ainsi particulièrement utile pour les chaînes de "
|
||
"documentation (*docstrings*)."
|
||
|
||
#: glossary.rst:1074
|
||
msgid "type"
|
||
msgstr "type"
|
||
|
||
#: glossary.rst:1076
|
||
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 ""
|
||
"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)``."
|
||
|
||
#: glossary.rst:1080
|
||
msgid "type alias"
|
||
msgstr "alias de type"
|
||
|
||
#: glossary.rst:1082
|
||
msgid "A synonym for a type, created by assigning the type to an identifier."
|
||
msgstr "Synonyme d'un type, créé en affectant le type à un identifiant."
|
||
|
||
#: glossary.rst:1084
|
||
msgid ""
|
||
"Type aliases are useful for simplifying :term:`type hints <type hint>`. For "
|
||
"example::"
|
||
msgstr ""
|
||
"Les alias de types sont utiles pour simplifier les :term:`indications de "
|
||
"types <type hint>`. Par exemple ::"
|
||
|
||
#: glossary.rst:1093
|
||
msgid "could be made more readable like this::"
|
||
msgstr "pourrait être rendu plus lisible comme ceci ::"
|
||
|
||
#: glossary.rst:1102 glossary.rst:1116
|
||
msgid "See :mod:`typing` and :pep:`484`, which describe this functionality."
|
||
msgstr "Voir :mod:`typing` et :pep:`484`, qui décrivent cette fonctionnalité."
|
||
|
||
#: glossary.rst:1103
|
||
msgid "type hint"
|
||
msgstr "indication de type"
|
||
|
||
#: glossary.rst:1105
|
||
msgid ""
|
||
"An :term:`annotation` that specifies the expected type for a variable, a "
|
||
"class attribute, or a function parameter or return value."
|
||
msgstr ""
|
||
"Le :term:`annotation` qui spécifie le type attendu pour une variable, un "
|
||
"attribut de classe, un paramètre de fonction ou une valeur de retour."
|
||
|
||
#: glossary.rst:1108
|
||
msgid ""
|
||
"Type hints are optional and are not enforced by Python but they are useful "
|
||
"to static type analysis tools, and aid IDEs with code completion and "
|
||
"refactoring."
|
||
msgstr ""
|
||
"Les indications de type sont facultatives et ne sont pas indispensables à "
|
||
"l'interpréteur Python, mais elles sont utiles aux outils d'analyse de type "
|
||
"statique et aident les IDE à compléter et à réusiner (*code refactoring* en "
|
||
"anglais) le code."
|
||
|
||
#: glossary.rst:1112
|
||
msgid ""
|
||
"Type hints of global variables, class attributes, and functions, but not "
|
||
"local variables, can be accessed using :func:`typing.get_type_hints`."
|
||
msgstr ""
|
||
"Les indicateurs de type de variables globales, d'attributs de classe et de "
|
||
"fonctions, mais pas de variables locales, peuvent être consultés en "
|
||
"utilisant :func:`typing.get_type_hints`."
|
||
|
||
#: glossary.rst:1117
|
||
msgid "universal newlines"
|
||
msgstr "retours à la ligne universels"
|
||
|
||
#: glossary.rst:1119
|
||
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 ""
|
||
"Une manière d'interpréter des flux de texte dans lesquels sont reconnues "
|
||
"toutes les fins de ligne suivantes : 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."
|
||
|
||
#: glossary.rst:1124
|
||
msgid "variable annotation"
|
||
msgstr "annotation de variable"
|
||
|
||
#: glossary.rst:1126
|
||
msgid "An :term:`annotation` of a variable or a class attribute."
|
||
msgstr ":term:`annotation` d'une variable ou d'un attribut de classe."
|
||
|
||
#: glossary.rst:1128
|
||
msgid ""
|
||
"When annotating a variable or a class attribute, assignment is optional::"
|
||
msgstr ""
|
||
"Lorsque vous annotez une variable ou un attribut de classe, l'affectation "
|
||
"est facultative ::"
|
||
|
||
#: glossary.rst:1133
|
||
msgid ""
|
||
"Variable annotations are usually used for :term:`type hints <type hint>`: "
|
||
"for example this variable is expected to take :class:`int` values::"
|
||
msgstr ""
|
||
"Les annotations de variables sont généralement utilisées pour des :term:"
|
||
"`indications de types <type hint>` : par exemple, cette variable devrait "
|
||
"prendre des valeurs de type :class:`int` ::"
|
||
|
||
#: glossary.rst:1139
|
||
msgid "Variable annotation syntax is explained in section :ref:`annassign`."
|
||
msgstr ""
|
||
"La syntaxe d'annotation de la variable est expliquée dans la section :ref:"
|
||
"`annassign`."
|
||
|
||
#: glossary.rst:1141
|
||
msgid ""
|
||
"See :term:`function annotation`, :pep:`484` and :pep:`526`, which describe "
|
||
"this functionality."
|
||
msgstr ""
|
||
"Reportez-vous à :term:`function annotation`, à la :pep:`484` et à la :pep:"
|
||
"`526` qui décrivent cette fonctionnalité."
|
||
|
||
#: glossary.rst:1143
|
||
msgid "virtual environment"
|
||
msgstr "environnement virtuel"
|
||
|
||
#: glossary.rst:1145
|
||
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 ""
|
||
"Environnement d'exécution isolé (en mode coopératif) 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."
|
||
|
||
#: glossary.rst:1150
|
||
msgid "See also :mod:`venv`."
|
||
msgstr "Voir aussi :mod:`venv`."
|
||
|
||
#: glossary.rst:1151
|
||
msgid "virtual machine"
|
||
msgstr "machine virtuelle"
|
||
|
||
#: glossary.rst:1153
|
||
msgid ""
|
||
"A computer defined entirely in software. Python's virtual machine executes "
|
||
"the :term:`bytecode` emitted by the bytecode compiler."
|
||
msgstr ""
|
||
"Ordinateur défini entièrement par du logiciel. La machine virtuelle "
|
||
"(*virtual machine*) de Python exécute le :term:`bytecode` produit par le "
|
||
"compilateur de *bytecode*."
|
||
|
||
#: glossary.rst:1155
|
||
msgid "Zen of Python"
|
||
msgstr "Le zen de Python"
|
||
|
||
#: glossary.rst:1157
|
||
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 ""
|
||
"Liste de principes et de préceptes utiles pour comprendre et utiliser le "
|
||
"langage. Cette liste peut être obtenue en tapant \"``import this``\" dans "
|
||
"une invite Python interactive."
|