From e895e6b69141da6f3c3b240b0fc34d59da600498 Mon Sep 17 00:00:00 2001 From: Zepmanbc Date: Thu, 30 May 2019 23:31:16 +0200 Subject: [PATCH] Traduction de library/numbers.po (#716) --- library/numbers.po | 93 ++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 81 insertions(+), 12 deletions(-) diff --git a/library/numbers.po b/library/numbers.po index 7fa9da8c..9efd2cc2 100644 --- a/library/numbers.po +++ b/library/numbers.po @@ -3,11 +3,10 @@ # msgid "" msgstr "" -"Project-Id-Version: Python 3.6\n" +"Project-Id-Version: Python 3.7\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2017-04-02 22:11+0200\n" -"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" -"Last-Translator: FULL NAME \n" +"PO-Revision-Date: 2019-05-09 22:14+0200\n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" @@ -16,11 +15,11 @@ msgstr "" #: ../Doc/library/numbers.rst:2 msgid ":mod:`numbers` --- Numeric abstract base classes" -msgstr "" +msgstr ":mod:`numbers` --- Classes de base abstraites numériques" #: ../Doc/library/numbers.rst:7 msgid "**Source code:** :source:`Lib/numbers.py`" -msgstr "" +msgstr "**Code source:** :source:`Lib/numbers.py`" #: ../Doc/library/numbers.rst:11 msgid "" @@ -29,16 +28,23 @@ msgid "" "more operations. None of the types defined in this module can be " "instantiated." msgstr "" +"Le module :mod:`numbers` (:pep:`3141`) définit une hiérarchie de :term:" +"`classes de base abstraites` numériques qui définissent " +"progressivement plus d'opérations. Aucun des types définis dans ce module ne " +"peut être instancié." #: ../Doc/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)``." #: ../Doc/library/numbers.rst:23 msgid "The numeric tower" -msgstr "" +msgstr "La tour numérique" #: ../Doc/library/numbers.rst:27 msgid "" @@ -48,26 +54,35 @@ msgid "" "``, ``*``, ``/``, :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." #: ../Doc/library/numbers.rst:35 msgid "Abstract. Retrieves the real component of this number." -msgstr "" +msgstr "Abstrait. Récupère la partie réelle de ce nombre." #: ../Doc/library/numbers.rst:39 msgid "Abstract. Retrieves the imaginary component of this number." -msgstr "" +msgstr "Résumé. Retrouve la partie imaginaire de ce nombre." #: ../Doc/library/numbers.rst:43 msgid "" "Abstract. Returns the complex conjugate. For example, ``(1+3j).conjugate() " "== (1-3j)``." msgstr "" +"Résumé. Renvoie le complexe conjugué. Par exemple, ``(1+3j).conjugate() == " +"(1-3j)``." #: ../Doc/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`." #: ../Doc/library/numbers.rst:51 msgid "" @@ -75,12 +90,17 @@ msgid "" "func:`round`, :func:`math.floor`, :func:`math.ceil`, :func:`divmod`, ``//``, " "``%``, ``<``, ``<=``, ``>``, and ``>=``." msgstr "" +"En bref, celles-ci sont: une conversion à :class:`float`, :func:`math." +"trunc`, :func:`round`, :func:`math.floor`, :func:`math.ceil`, :func:" +"`divmod`, ``//``, ``%``, ``<``, ``<=``, ``>``, et ``>=``." #: ../Doc/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`." #: ../Doc/library/numbers.rst:61 msgid "" @@ -88,6 +108,10 @@ msgid "" "`~Rational.denominator` properties, which should be in lowest terms. With " "these, it provides a default for :func:`float`." msgstr "" +"Sous-classe :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`." #: ../Doc/library/numbers.rst:68 ../Doc/library/numbers.rst:72 msgid "Abstract." @@ -100,10 +124,15 @@ msgid "" "`~Rational.denominator`. Adds abstract methods for ``**`` and bit-string " "operations: ``<<``, ``>>``, ``&``, ``^``, ``|``, ``~``." msgstr "" +"Sous-classe :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: ``<<``, ``>>``, ``&``, " +"``^``, ``|``, ``~``." #: ../Doc/library/numbers.rst:84 msgid "Notes for type implementors" -msgstr "" +msgstr "Notes pour implémenter des types" #: ../Doc/library/numbers.rst:86 msgid "" @@ -112,10 +141,15 @@ msgid "" "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 ::" #: ../Doc/library/numbers.rst:105 msgid "Adding More Numeric ABCs" -msgstr "" +msgstr "Ajouter plus d'ABC numériques" #: ../Doc/library/numbers.rst:107 msgid "" @@ -123,10 +157,14 @@ msgid "" "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 ::" #: ../Doc/library/numbers.rst:119 msgid "Implementing the arithmetic operations" -msgstr "" +msgstr "Implémentation des opérations arithmétiques" #: ../Doc/library/numbers.rst:121 msgid "" @@ -136,6 +174,12 @@ msgid "" "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::" #: ../Doc/library/numbers.rst:152 msgid "" @@ -145,10 +189,16 @@ msgid "" "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``:" #: ../Doc/library/numbers.rst:159 msgid "If ``A`` defines an :meth:`__add__` which accepts ``b``, all is well." -msgstr "" +msgstr "Si ``A`` définit une :meth:`__add__` qui accepte ``b``, tout va bien." #: ../Doc/library/numbers.rst:161 msgid "" @@ -158,18 +208,27 @@ msgid "" "`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.)" #: ../Doc/library/numbers.rst:167 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." #: ../Doc/library/numbers.rst:169 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." #: ../Doc/library/numbers.rst:172 msgid "" @@ -177,6 +236,9 @@ msgid "" "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`." #: ../Doc/library/numbers.rst:177 msgid "" @@ -184,6 +246,9 @@ msgid "" "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``." #: ../Doc/library/numbers.rst:182 msgid "" @@ -192,3 +257,7 @@ msgid "" "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 ::"