forked from AFPy/python-docs-fr
279 lines
12 KiB
Plaintext
279 lines
12 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: 2023-01-15 22:33+0100\n"
|
||
"PO-Revision-Date: 2021-12-16 17:25+0100\n"
|
||
"Last-Translator: Julien Palard <julien@palard.fr>\n"
|
||
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
|
||
"Language: fr\n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
|
||
#: library/numbers.rst:2
|
||
msgid ":mod:`numbers` --- Numeric abstract base classes"
|
||
msgstr ":mod:`numbers` — Classes de base abstraites numériques"
|
||
|
||
#: library/numbers.rst:7
|
||
msgid "**Source code:** :source:`Lib/numbers.py`"
|
||
msgstr "**Code source :** :source:`Lib/numbers.py`"
|
||
|
||
#: library/numbers.rst:11
|
||
#, fuzzy
|
||
msgid ""
|
||
"The :mod:`numbers` module (:pep:`3141`) defines a hierarchy of numeric :term:"
|
||
"`abstract base classes <abstract base class>` which progressively define "
|
||
"more operations. None of the types defined in this module are intended to "
|
||
"be instantiated."
|
||
msgstr ""
|
||
"Le module :mod:`numbers` (:pep:`3141`) définit une hiérarchie de :term:"
|
||
"`classes de base abstraites<abstract base class>` numériques qui définissent "
|
||
"progressivement plus d'opérations. Aucun des types définis dans ce module ne "
|
||
"peut être instancié."
|
||
|
||
#: library/numbers.rst:18
|
||
msgid ""
|
||
"The root of the numeric hierarchy. If you just want to check if an argument "
|
||
"*x* is a number, without caring what kind, use ``isinstance(x, Number)``."
|
||
msgstr ""
|
||
"La base de la hiérarchie numérique. Si vous voulez juste vérifier qu'un "
|
||
"argument *x* est un nombre, peu importe le type, utilisez ``isinstance(x, "
|
||
"Number)``."
|
||
|
||
#: library/numbers.rst:23
|
||
msgid "The numeric tower"
|
||
msgstr "La tour numérique"
|
||
|
||
#: library/numbers.rst:27
|
||
#, fuzzy
|
||
msgid ""
|
||
"Subclasses of this type describe complex numbers and include the operations "
|
||
"that work on the built-in :class:`complex` type. These are: conversions to :"
|
||
"class:`complex` and :class:`bool`, :attr:`.real`, :attr:`.imag`, ``+``, ``-"
|
||
"``, ``*``, ``/``, ``**``, :func:`abs`, :meth:`conjugate`, ``==``, and ``!"
|
||
"=``. All except ``-`` and ``!=`` are abstract."
|
||
msgstr ""
|
||
"Les sous-classes de ce type décrivent des nombres complexes et incluent les "
|
||
"opérations qui fonctionnent sur le type natif :class:`complex`. Ce sont : "
|
||
"les conversions vers :class:`complex` et :class:`bool`, :attr:`.real`, :attr:"
|
||
"`.imag`, ``+``, ``-``, ``*``, ``/``, :func:`abs`, :meth:`conjugate`, ``==`` "
|
||
"et ``!=``. Toutes sauf ``-`` et ``!=`` sont abstraites."
|
||
|
||
#: library/numbers.rst:35
|
||
msgid "Abstract. Retrieves the real component of this number."
|
||
msgstr "Abstrait. Récupère la partie réelle de ce nombre."
|
||
|
||
#: library/numbers.rst:39
|
||
msgid "Abstract. Retrieves the imaginary component of this number."
|
||
msgstr "Abstrait. Retrouve la partie imaginaire de ce nombre."
|
||
|
||
#: library/numbers.rst:43
|
||
msgid ""
|
||
"Abstract. Returns the complex conjugate. For example, ``(1+3j).conjugate() "
|
||
"== (1-3j)``."
|
||
msgstr ""
|
||
"Abstrait. Renvoie le complexe conjugué. Par exemple, ``(1+3j).conjugate() == "
|
||
"(1-3j)``."
|
||
|
||
#: library/numbers.rst:48
|
||
msgid ""
|
||
"To :class:`Complex`, :class:`Real` adds the operations that work on real "
|
||
"numbers."
|
||
msgstr ""
|
||
":class:`Real` ajoute les opérations qui fonctionnent sur les nombres réels "
|
||
"à :class:`Complex`."
|
||
|
||
#: library/numbers.rst:51
|
||
msgid ""
|
||
"In short, those are: a conversion to :class:`float`, :func:`math.trunc`, :"
|
||
"func:`round`, :func:`math.floor`, :func:`math.ceil`, :func:`divmod`, ``//``, "
|
||
"``%``, ``<``, ``<=``, ``>``, and ``>=``."
|
||
msgstr ""
|
||
"En bref, celles-ci sont : une conversion vers :class:`float`, :func:`math."
|
||
"trunc`, :func:`round`, :func:`math.floor`, :func:`math.ceil`, :func:"
|
||
"`divmod`, ``//``, ``%``, ``<``, ``<=``, ``>`` et ``>=``."
|
||
|
||
#: library/numbers.rst:55
|
||
msgid ""
|
||
"Real also provides defaults for :func:`complex`, :attr:`~Complex.real`, :"
|
||
"attr:`~Complex.imag`, and :meth:`~Complex.conjugate`."
|
||
msgstr ""
|
||
"*Real* fournit également des valeurs par défaut pour :func:`complex`, :attr:"
|
||
"`~Complex.real`, :attr:`~Complex.imag` et :meth:`~Complex.conjugate`."
|
||
|
||
#: library/numbers.rst:61
|
||
#, fuzzy
|
||
msgid ""
|
||
"Subtypes :class:`Real` and adds :attr:`~Rational.numerator` and :attr:"
|
||
"`~Rational.denominator` properties. It also provides a default for :func:"
|
||
"`float`."
|
||
msgstr ""
|
||
"Dérive :class:`Real` et ajoute les propriétés :attr:`~Rational.numerator` "
|
||
"et :attr:`~Rational.denominator` qui doivent être les plus petits possible. "
|
||
"Avec celles-ci, il fournit une valeur par défaut pour :func:`float`."
|
||
|
||
#: library/numbers.rst:65
|
||
#, fuzzy
|
||
msgid ""
|
||
"The :attr:`~Rational.numerator` and :attr:`~Rational.denominator` values "
|
||
"should be instances of :class:`Integral` and should be in lowest terms with :"
|
||
"attr:`~Rational.denominator` positive."
|
||
msgstr ""
|
||
"Dérive :class:`Real` et ajoute les propriétés :attr:`~Rational.numerator` "
|
||
"et :attr:`~Rational.denominator` qui doivent être les plus petits possible. "
|
||
"Avec celles-ci, il fournit une valeur par défaut pour :func:`float`."
|
||
|
||
#: library/numbers.rst:75
|
||
msgid "Abstract."
|
||
msgstr "Abstrait."
|
||
|
||
#: library/numbers.rst:80
|
||
#, fuzzy
|
||
msgid ""
|
||
"Subtypes :class:`Rational` and adds a conversion to :class:`int`. Provides "
|
||
"defaults for :func:`float`, :attr:`~Rational.numerator`, and :attr:"
|
||
"`~Rational.denominator`. Adds abstract methods for :func:`pow` with modulus "
|
||
"and bit-string operations: ``<<``, ``>>``, ``&``, ``^``, ``|``, ``~``."
|
||
msgstr ""
|
||
"Dérive :class:`Rational` et ajoute une conversion en :class:`int`. Fournit "
|
||
"des valeurs par défaut pour :func:`float`, :attr:`~Rational.numerator` et :"
|
||
"attr:`~Rational.denominator`. Ajoute des méthodes abstraites pour ``**`` et "
|
||
"les opérations au niveau des bits: ``<<``, ``>>``, ``&``, ``^``, ``|``, "
|
||
"``~``."
|
||
|
||
#: library/numbers.rst:88
|
||
msgid "Notes for type implementors"
|
||
msgstr "Notes pour implémenter des types"
|
||
|
||
#: library/numbers.rst:90
|
||
msgid ""
|
||
"Implementors should be careful to make equal numbers equal and hash them to "
|
||
"the same values. This may be subtle if there are two different extensions of "
|
||
"the real numbers. For example, :class:`fractions.Fraction` implements :func:"
|
||
"`hash` as follows::"
|
||
msgstr ""
|
||
"Les développeurs doivent veiller à ce que des nombres égaux soient bien "
|
||
"égaux lors de comparaisons et à ce qu'ils soient hachés aux mêmes valeurs. "
|
||
"Cela peut être subtil s'il y a deux dérivations différentes des nombres "
|
||
"réels. Par exemple, :class:`fractions.Fraction` implémente :func:`hash` "
|
||
"comme suit ::"
|
||
|
||
#: library/numbers.rst:109
|
||
msgid "Adding More Numeric ABCs"
|
||
msgstr "Ajouter plus d'ABC numériques"
|
||
|
||
#: library/numbers.rst:111
|
||
msgid ""
|
||
"There are, of course, more possible ABCs for numbers, and this would be a "
|
||
"poor hierarchy if it precluded the possibility of adding those. You can add "
|
||
"``MyFoo`` between :class:`Complex` and :class:`Real` with::"
|
||
msgstr ""
|
||
"Il est bien entendu possible de créer davantage d’ABC pour les nombres et "
|
||
"cette hiérarchie serait médiocre si elle excluait la possibilité d'en "
|
||
"ajouter. Vous pouvez ajouter ``MyFoo`` entre :class:`Complex` et :class:"
|
||
"`Real` ainsi ::"
|
||
|
||
#: library/numbers.rst:123
|
||
msgid "Implementing the arithmetic operations"
|
||
msgstr "Implémentation des opérations arithmétiques"
|
||
|
||
#: library/numbers.rst:125
|
||
msgid ""
|
||
"We want to implement the arithmetic operations so that mixed-mode operations "
|
||
"either call an implementation whose author knew about the types of both "
|
||
"arguments, or convert both to the nearest built in type and do the operation "
|
||
"there. For subtypes of :class:`Integral`, this means that :meth:`__add__` "
|
||
"and :meth:`__radd__` should be defined as::"
|
||
msgstr ""
|
||
"Nous voulons implémenter les opérations arithmétiques de sorte que les "
|
||
"opérations en mode mixte appellent une implémentation dont l'auteur connaît "
|
||
"les types des deux arguments, ou convertissent chacun dans le type natif le "
|
||
"plus proche et effectuent l'opération sur ces types. Pour les sous-types de :"
|
||
"class:`Integral`, cela signifie que :meth:`__add__` et :meth:`__radd__` "
|
||
"devraient être définis comme suit ::"
|
||
|
||
#: library/numbers.rst:156
|
||
msgid ""
|
||
"There are 5 different cases for a mixed-type operation on subclasses of :"
|
||
"class:`Complex`. I'll refer to all of the above code that doesn't refer to "
|
||
"``MyIntegral`` and ``OtherTypeIKnowAbout`` as \"boilerplate\". ``a`` will be "
|
||
"an instance of ``A``, which is a subtype of :class:`Complex` (``a : A <: "
|
||
"Complex``), and ``b : B <: Complex``. I'll consider ``a + b``:"
|
||
msgstr ""
|
||
"Il existe 5 cas différents pour une opération de type mixte sur des sous-"
|
||
"classes de :class:`Complex`. Nous nous référerons à tout le code ci-dessus "
|
||
"qui ne se réfère pas à ``MyIntegral`` et ``OtherTypeIKnowAbout`` comme "
|
||
"\"expression générique\". ``a`` est une instance de ``A``, qui est un sous-"
|
||
"type de :class:`Complex` (``a : A <: Complex``) et ``b : B <: Complex``. "
|
||
"Considérons ``a + b`` :"
|
||
|
||
#: library/numbers.rst:163
|
||
msgid "If ``A`` defines an :meth:`__add__` which accepts ``b``, all is well."
|
||
msgstr "Si ``A`` définit une :meth:`__add__` qui accepte ``b``, tout va bien."
|
||
|
||
#: library/numbers.rst:165
|
||
msgid ""
|
||
"If ``A`` falls back to the boilerplate code, and it were to return a value "
|
||
"from :meth:`__add__`, we'd miss the possibility that ``B`` defines a more "
|
||
"intelligent :meth:`__radd__`, so the boilerplate should return :const:"
|
||
"`NotImplemented` from :meth:`__add__`. (Or ``A`` may not implement :meth:"
|
||
"`__add__` at all.)"
|
||
msgstr ""
|
||
"Si ``A`` fait appel au code générique et que celui-ci renvoie une valeur de :"
|
||
"meth:`__add__`, nous manquons la possibilité que ``B`` définisse une :meth:"
|
||
"`__radd__` plus intelligent, donc le code générique devrait retourner :const:"
|
||
"`NotImplemented` dans :meth:`__add__` (ou alors ``A`` ne doit pas "
|
||
"implémenter :meth:`__add__` du tout.)"
|
||
|
||
#: library/numbers.rst:171
|
||
msgid ""
|
||
"Then ``B``'s :meth:`__radd__` gets a chance. If it accepts ``a``, all is "
|
||
"well."
|
||
msgstr ""
|
||
"Alors :meth:`__radd__` de ``B`` a une chance. si elle accepte ``a``, tout va "
|
||
"bien."
|
||
|
||
#: library/numbers.rst:173
|
||
msgid ""
|
||
"If it falls back to the boilerplate, there are no more possible methods to "
|
||
"try, so this is where the default implementation should live."
|
||
msgstr ""
|
||
"Si elle fait appel au code générique, il n'y a plus de méthode possible à "
|
||
"essayer, c'est donc ici que l'implémentation par défaut intervient."
|
||
|
||
#: library/numbers.rst:176
|
||
msgid ""
|
||
"If ``B <: A``, Python tries ``B.__radd__`` before ``A.__add__``. This is ok, "
|
||
"because it was implemented with knowledge of ``A``, so it can handle those "
|
||
"instances before delegating to :class:`Complex`."
|
||
msgstr ""
|
||
"Si ``B < : A``, Python essaie ``B.__radd__`` avant ``A.__add__``. C'est "
|
||
"valable parce qu'elle est implémentée avec la connaissance de ``A``, donc "
|
||
"elle peut gérer ces instances avant de déléguer à :class:`Complex`."
|
||
|
||
#: library/numbers.rst:181
|
||
msgid ""
|
||
"If ``A <: Complex`` and ``B <: Real`` without sharing any other knowledge, "
|
||
"then the appropriate shared operation is the one involving the built in :"
|
||
"class:`complex`, and both :meth:`__radd__` s land there, so ``a+b == b+a``."
|
||
msgstr ""
|
||
"Si ``A <: Complex`` et ``B <: Real`` sans autre information, alors "
|
||
"l'opération commune appropriée est celle impliquant :class:`complex` et les "
|
||
"deux :meth:`__radd__` atterrissent à cet endroit, donc ``a+b == b+a``."
|
||
|
||
#: library/numbers.rst:186
|
||
msgid ""
|
||
"Because most of the operations on any given type will be very similar, it "
|
||
"can be useful to define a helper function which generates the forward and "
|
||
"reverse instances of any given operator. For example, :class:`fractions."
|
||
"Fraction` uses::"
|
||
msgstr ""
|
||
"Comme la plupart des opérations sur un type donné seront très similaires, il "
|
||
"peut être utile de définir une fonction accessoire qui génère les instances "
|
||
"résultantes et inverses d'un opérateur donné. Par exemple, :class:`fractions."
|
||
"Fraction` utilise ::"
|