python-docs-fr/library/fractions.po

# 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 <loc.cosnier@pm.me>\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"
"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`."