# 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-04-14 13:19+0200\n" "PO-Revision-Date: 2022-10-18 15:57+0200\n" "Last-Translator: Loc Cosnier \n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n > 1)\n" "X-Generator: Gtranslator 3.38.0\n" #: library/fractions.rst:2 msgid ":mod:`fractions` --- Rational numbers" msgstr ":mod:`fractions` — Nombres rationnels" #: library/fractions.rst:10 msgid "**Source code:** :source:`Lib/fractions.py`" msgstr "**Code source :** :source:`Lib/fractions.py`" #: library/fractions.rst:14 msgid "" "The :mod:`fractions` module provides support for rational number arithmetic." msgstr "" "Le module :mod:`fractions` fournit un support de l'arithmétique des nombres " "rationnels." #: library/fractions.rst:17 msgid "" "A Fraction instance can be constructed from a pair of integers, from another " "rational number, or from a string." msgstr "" "Une instance de *Fraction* peut être construite depuis une paire d'entiers, " "depuis un autre nombre rationnel, ou depuis une chaîne de caractères." #: library/fractions.rst:26 msgid "" "The first version requires that *numerator* and *denominator* are instances " "of :class:`numbers.Rational` and returns a new :class:`Fraction` instance " "with value ``numerator/denominator``. If *denominator* is :const:`0`, it " "raises a :exc:`ZeroDivisionError`. The second version requires that " "*other_fraction* is an instance of :class:`numbers.Rational` and returns a :" "class:`Fraction` instance with the same value. The next two versions accept " "either a :class:`float` or a :class:`decimal.Decimal` instance, and return " "a :class:`Fraction` instance with exactly the same value. Note that due to " "the usual issues with binary floating-point (see :ref:`tut-fp-issues`), the " "argument to ``Fraction(1.1)`` is not exactly equal to 11/10, and so " "``Fraction(1.1)`` does *not* return ``Fraction(11, 10)`` as one might " "expect. (But see the documentation for the :meth:`limit_denominator` method " "below.) The last version of the constructor expects a string or unicode " "instance. The usual form for this instance is::" msgstr "" "La première version demande que *numerator* et *denominator* soient des " "instance de :class:`numbers.Rational` et renvoie une instance de :class:" "`Fraction` valant ``numerator/denominator``. Si *denominator* vaut :const:" "`0`, une :exc:`ZeroDivisionError` est levée. La seconde version demande que " "*other_fraction* soit une instance de :class:`numbers.Rational` et renvoie " "une instance de :class:`Fraction` avec la même valeur. Les deux versions " "suivantes acceptent un :class:`float` ou une instance de :class:`decimal." "Decimal`, et renvoient une instance de :class:`Fraction` avec exactement la " "même valeur. Notez que les problèmes usuels des virgules flottantes " "binaires (voir :ref:`tut-fp-issues`) font que ``Fraction(1.1)`` n'est pas " "exactement égal à 11/10, et donc ``Fraction(1.1)`` ne renvoie *pas* " "``Fraction(11, 10)`` comme on pourrait le penser. (Mais référez-vous à la " "documentation de la méthode :meth:`limit_denominator` ci-dessous.) La " "dernière version du constructeur attend une chaîne de caractères ou Unicode. " "La représentation habituelle de cette forme est ::" #: library/fractions.rst:43 #, fuzzy msgid "" "where the optional ``sign`` may be either '+' or '-' and ``numerator`` and " "``denominator`` (if present) are strings of decimal digits (underscores may " "be used to delimit digits as with integral literals in code). In addition, " "any string that represents a finite value and is accepted by the :class:" "`float` constructor is also accepted by the :class:`Fraction` constructor. " "In either form the input string may also have leading and/or trailing " "whitespace. Here are some examples::" msgstr "" "où le ``sign`` optionnel peut être soit ``+`` soit ``-``, et ``numerator`` " "et ``denominator`` (si présent) sont des chaînes de chiffres décimaux. De " "plus, toute chaîne qui représente une valeur finie et acceptée par le " "constructeur de :class:`float` est aussi acceptée par celui de :class:" "`Fraction`. Dans ces deux formes, la chaîne d'entrée peut aussi contenir " "des espaces en début ou en fin de chaîne. Voici quelques exemples ::" #: library/fractions.rst:78 #, fuzzy msgid "" "The :class:`Fraction` class inherits from the abstract base class :class:" "`numbers.Rational`, and implements all of the methods and operations from " "that class. :class:`Fraction` instances are :term:`hashable`, and should be " "treated as immutable. In addition, :class:`Fraction` has the following " "properties and methods:" msgstr "" "La classe :class:`Fraction` hérite de la classe abstraite :class:`numbers." "Rational`, et implémente toutes les méthodes et opérations de cette classe. " "Les instances de :class:`Fraction` sont hachables, et doivent être traitées " "comme immuables. En plus de cela, :class:`Fraction` possède les propriétés " "et méthodes suivantes :" #: library/fractions.rst:84 msgid "" "The :class:`Fraction` constructor now accepts :class:`float` and :class:" "`decimal.Decimal` instances." msgstr "" "Le constructeur de :class:`Fraction` accepte maintenant des instances de :" "class:`float` et :class:`decimal.Decimal`." #: library/fractions.rst:88 msgid "" "The :func:`math.gcd` function is now used to normalize the *numerator* and " "*denominator*. :func:`math.gcd` always return a :class:`int` type. " "Previously, the GCD type depended on *numerator* and *denominator*." msgstr "" "La fonction :func:`math.gcd` est maintenant utilisée pour normaliser le " "*numerator* et le *denominator*. :func:`math.gcd` renvoie toujours un type :" "class:`int`. Auparavant, le type du PGCD dépendait du *numerator* et du " "*denominator*." #: library/fractions.rst:93 msgid "" "Underscores are now permitted when creating a :class:`Fraction` instance " "from a string, following :PEP:`515` rules." msgstr "" #: library/fractions.rst:97 msgid "" ":class:`Fraction` implements ``__int__`` now to satisfy ``typing." "SupportsInt`` instance checks." msgstr "" #: library/fractions.rst:103 msgid "Numerator of the Fraction in lowest term." msgstr "Numérateur de la fraction irréductible." #: library/fractions.rst:107 msgid "Denominator of the Fraction in lowest term." msgstr "Dénominateur de la fraction irréductible." #: library/fractions.rst:112 msgid "" "Return a tuple of two integers, whose ratio is equal to the Fraction and " "with a positive denominator." msgstr "" "Renvoie un *n*-uplet de deux entiers, dont le quotient est égal à la " "fraction et dont le dénominateur est positif." #: library/fractions.rst:119 msgid "" "Alternative constructor which only accepts instances of :class:`float` or :" "class:`numbers.Integral`. Beware that ``Fraction.from_float(0.3)`` is not " "the same value as ``Fraction(3, 10)``." msgstr "" "Ce constructeur alternatif accepte (uniquement) des nombres à virgule " "flottante, de classe :class:`float`, ou plus généralement des instances de :" "class:`numbers.Integral`. Attention, ``Fraction.from_float(0.3)`` est " "différent de ``Fraction(3, 10)``." #: library/fractions.rst:125 msgid "" "From Python 3.2 onwards, you can also construct a :class:`Fraction` instance " "directly from a :class:`float`." msgstr "" "Depuis Python 3.2, vous pouvez aussi construire une instance de :class:" "`Fraction` directement depuis un :class:`float`." #: library/fractions.rst:131 msgid "" "Alternative constructor which only accepts instances of :class:`decimal." "Decimal` or :class:`numbers.Integral`." msgstr "" "Ce constructeur alternatif accepte (uniquement) les instances de :class:" "`decimal.Decimal` ou :class:`numbers.Integral`." #: library/fractions.rst:136 msgid "" "From Python 3.2 onwards, you can also construct a :class:`Fraction` instance " "directly from a :class:`decimal.Decimal` instance." msgstr "" "Depuis Python 3.2, vous pouvez aussi construire une instance de :class:" "`Fraction` directement depuis une instance de :class:`decimal.Decimal`." #: library/fractions.rst:143 msgid "" "Finds and returns the closest :class:`Fraction` to ``self`` that has " "denominator at most max_denominator. This method is useful for finding " "rational approximations to a given floating-point number:" msgstr "" "Trouve et renvoie la :class:`Fraction` la plus proche de ``self`` qui a au " "plus *max_denominator* comme dénominateur. Cette méthode est utile pour " "trouver des approximations rationnelles de nombres flottants donnés :" #: library/fractions.rst:151 msgid "or for recovering a rational number that's represented as a float:" msgstr "ou pour retrouver un nombre rationnel représenté par un flottant :" #: library/fractions.rst:164 msgid "" "Returns the greatest :class:`int` ``<= self``. This method can also be " "accessed through the :func:`math.floor` function:" msgstr "" "Renvoie le plus grand :class:`int` ``<= self``. Cette méthode peut aussi " "être utilisée à travers la fonction :func:`math.floor` :" #: library/fractions.rst:174 msgid "" "Returns the least :class:`int` ``>= self``. This method can also be " "accessed through the :func:`math.ceil` function." msgstr "" "Renvoie le plus petit :class:`int` ``>= self``. Cette méthode peut aussi " "être utilisée à travers la fonction :func:`math.ceil`." #: library/fractions.rst:181 msgid "" "The first version returns the nearest :class:`int` to ``self``, rounding " "half to even. The second version rounds ``self`` to the nearest multiple of " "``Fraction(1, 10**ndigits)`` (logically, if ``ndigits`` is negative), again " "rounding half toward even. This method can also be accessed through the :" "func:`round` function." msgstr "" "La première version renvoie l':class:`int` le plus proche de ``self``, " "arrondissant les demis au nombre pair le plus proche. La seconde version " "arrondit ``self`` au plus proche multiple de ``Fraction(1, 10**ndigits)`` " "(logiquement, si ``ndigits`` est négatif), arrondissant toujours les demis " "au nombre pair le plus proche. Cette méthode peut aussi être utilisée à via " "la fonction :func:`round`." #: library/fractions.rst:190 msgid "Module :mod:`numbers`" msgstr "Module :mod:`numbers`" #: library/fractions.rst:191 msgid "The abstract base classes making up the numeric tower." msgstr "Les classes abstraites représentant la hiérarchie des nombres." #~ msgid "" #~ "This class method constructs a :class:`Fraction` representing the exact " #~ "value of *dec*, which must be a :class:`decimal.Decimal` instance." #~ msgstr "" #~ "Cette méthode de classe construit un objet :class:`Fraction` représentant " #~ "la valeur exacte de *dec*, qui doit être de type :class:`decimal.Decimal`." #~ msgid "" #~ "Return the greatest common divisor of the integers *a* and *b*. If " #~ "either *a* or *b* is nonzero, then the absolute value of ``gcd(a, b)`` is " #~ "the largest integer that divides both *a* and *b*. ``gcd(a,b)`` has the " #~ "same sign as *b* if *b* is nonzero; otherwise it takes the sign of *a*. " #~ "``gcd(0, 0)`` returns ``0``." #~ msgstr "" #~ "Renvoie le plus grand diviseur commun (PGCD) des entiers *a* et *b*. Si " #~ "*a* et *b* sont tous deux non nuls, alors la valeur absolue de ``gcd(a, " #~ "b)`` est le plus grand entier qui divise à la fois *a* et *b*. ``gcd(a," #~ "b)`` a le même signe que *b* si *b* n'est pas nul ; autrement il prend le " #~ "signe de *a*. ``gcd(0, 0)`` renvoie ``0``." #~ msgid "Use :func:`math.gcd` instead." #~ msgstr "Utilisez plutôt :func:`math.gcd`."