Working on library.po/stdtypes.rst

library.po

@@ -105519,8 +105519,8 @@ msgstr ""
 "Également appelé division entière. La valeur résultante est un nombre "
 "entier, bien que le type du résultat ne soit nécessairement *int*. Le "
 "résultat est toujours arrondi vers moins l'infini : ``1//2`` vaut ``0``, "
-"``(-1)//2`` vaut ``-1``, ``1//(-2)`` vaut ``-1``, et ``(-1)//(-2)`` vaut `` "
-"0``."
+"``(-1)//2`` vaut ``-1``, ``1//(-2)`` vaut ``-1``, et ``(-1)//(-2)`` vaut "
+"``0``."
 
 #: ../../src/Doc/library/stdtypes.rst:329
 msgid ""
@@ -105745,7 +105745,7 @@ msgid ""
 "The int type implements the :class:`numbers.Integral` :term:`abstract base "
 "class`. In addition, it provides a few more methods:"
 msgstr ""
-"Le type int implémente la :term:`abstract base class` class:`numbers."
+"Le type int implémente la :term:`abstract base class` :class:`numbers."
 "Integral`. En outre, il fournit quelques autres méthodes :"
 
 #: ../../src/Doc/library/stdtypes.rst:450
@@ -105780,7 +105780,7 @@ msgid ""
 "raised if the integer is not representable with the given number of bytes."
 msgstr ""
 "L'entier est représenté par *length* octets. Une exception :exc:"
-"`OverflowError`est levée s'il n'est pas possible de représenter l'entier "
+"`OverflowError` est levée s'il n'est pas possible de représenter l'entier "
 "avec le nombre d'octets donnés."
 
 #: ../../src/Doc/library/stdtypes.rst:492
@@ -105793,6 +105793,12 @@ msgid ""
 "byte order of the host system, use :data:`sys.byteorder` as the byte order "
 "value."
 msgstr ""
+"L'argument *byteorder* détermine l'ordre des octets utilisé pour représenter "
+"le nombre entier. Si *byteorder* est ``\"big\"``, l'octet le plus "
+"significatif est au début du tableau d'octets. Si *byteorder* est ``\"little"
+"\"``, l'octet le plus significatif est à la fin du tableau d'octets. Pour "
+"demander l'ordre natif des octets du système hôte, donnez :data:`sys."
+"byteorder` en temps que *byteorder*."
 
 #: ../../src/Doc/library/stdtypes.rst:499
 msgid ""
@@ -105801,16 +105807,22 @@ msgid ""
 "given, an :exc:`OverflowError` is raised. The default value for *signed* is "
 "``False``."
 msgstr ""
+"L'argument *signed* détermine si le complément à deux est utilisé pour "
+"représenter le nombre entier. Si *signed* est ``False`` et qu'un entier "
+"négatifest donné, une exception :exc:`OverflowError` est levée. La valeur "
+"par défaut pour *signed* est ``False``."
 
 #: ../../src/Doc/library/stdtypes.rst:508
 msgid "Return the integer represented by the given array of bytes."
-msgstr ""
+msgstr "Done le nombre entier représenté par le tableau d'octets fourni."
 
 #: ../../src/Doc/library/stdtypes.rst:521
 msgid ""
 "The argument *bytes* must either be a :term:`bytes-like object` or an "
 "iterable producing bytes."
 msgstr ""
+"L'argument *bytes* doit être soit un :term:`bytes-like object` soit un "
+"itérable produisant des *bytes*"
 
 #: ../../src/Doc/library/stdtypes.rst:531
 msgid ""
@@ -105862,10 +105874,10 @@ msgstr ""
 "Deux méthodes prennent en charge la conversion vers et à partir de chaînes "
 "hexadécimales. Étant donné que les *float* de Python sont stockés en interne "
 "sous forme de nombres binaires, la conversion d'un *float* depuis ou vers "
-"une chaine décimale implique généralement une petite erreur d'arrondi. "
-"En revanche, les chaînes hexadécimales permettent de représenter exactement "
-"les nombres à virgule flottante. Cela peut être utile lorsdu débogage, et "
-"dans un travail numérique."
+"une chaine décimale implique généralement une petite erreur d'arrondi. En "
+"revanche, les chaînes hexadécimales permettent de représenter exactement les "
+"nombres à virgule flottante. Cela peut être utile lors du débogage, et dans "
+"un travail numérique."
 
 #: ../../src/Doc/library/stdtypes.rst:571
 msgid ""
@@ -105912,6 +105924,16 @@ msgid ""
 "by C's ``%a`` format character or Java's ``Double.toHexString`` are accepted "
 "by :meth:`float.fromhex`."
 msgstr ""
+"où l'option ``sign`` peut être soit ``+`` soit ``-``, ``integer`` et "
+"``fraction`` sont des chaînes de chiffres hexadécimales, et ``exponent`` est "
+"un entier décimal facultativement signé. La casse n'est pas significative, "
+"et il doit y avoir au moins un chiffre hexadécimal soit le nombre entier "
+"soit dans la fraction. Cette syntaxe est similaire à la syntaxe spécifiée "
+"dans la section 6.4.4.2 de la norme C99, et aussi à la syntaxe utilisée à "
+"partir de Java 1.5. En particulier, la sortie de :meth:`float.hex` est "
+"utilisable comme valeur hexadécimal à virgule flottante littérale en C ou "
+"Java, et des chaînes hexadécimales produites en C via un format ``%a``ou "
+"Java via ``Double.toHexString`` sont acceptées par :meth:`float.fromhex`."
 
 #: ../../src/Doc/library/stdtypes.rst:604
 msgid ""
@@ -105920,16 +105942,22 @@ msgid ""
 "example, the hexadecimal string ``0x3.a7p10`` represents the floating-point "
 "number ``(3 + 10./16 + 7./16**2) * 2.0**10``, or ``3740.0``::"
 msgstr ""
+"Notez que l'exposant est écrit en décimal plutôt qu'en hexadécimal, et qu'il "
+"donne la puissance de 2 par lequel multiplier le coefficient. Par exemple, "
+"la chaîne hexadécimale ``0x3.a7p10`` représente le nombre à virgule "
+"flottante ``(3 + 10./16 + 7./16**2) *2.0**10``, ou ``3740.0`` ::"
 
 #: ../../src/Doc/library/stdtypes.rst:614
 msgid ""
 "Applying the reverse conversion to ``3740.0`` gives a different hexadecimal "
 "string representing the same number::"
 msgstr ""
+"L'application de la conversion inverse à ``3740.0`` donne une chaîne "
+"hexadécimale différente représentant le même nombre ::"
 
 #: ../../src/Doc/library/stdtypes.rst:624
 msgid "Hashing of numeric types"
-msgstr ""
+msgstr "Hachage des types numériques"
 
 #: ../../src/Doc/library/stdtypes.rst:626
 msgid ""
@@ -105946,16 +105974,31 @@ msgid ""
 "is made available to Python as the :attr:`modulus` attribute of :data:`sys."
 "hash_info`."
 msgstr ""
+"Pour deux nombres ``x`` et ``y``, pouvant être de différents types, il est "
+"une requis que ``hash(x) == hash(y)`` lorsque ``x == y`` (voir la "
+"documentation de :meth:`__hash__`). Pour faciliter la mise en œuvre et "
+"l'efficacité à travers une variété de types numériques (y compris :class:"
+"`int`, :class:`float`, :class:`decimal.Decimal` et :class:`fractions."
+"Fraction`) le hachage en Python pour les types numérique estbasé sur une "
+"fonction mathématique unique qui est définie pour tout nombre rationnel, et "
+"donc s'applique à toutes les instances de :class:`int` et :class:`fractions."
+"Fraction`, et toutes les instances finies de :class:`float` et :class:"
+"`decimal.Decimal`. Essentiellement, cette fonction est donnée par la "
+"réduction modulo ``P`` pour un nombre ``P`` premier fixe. La valeur de ``P`` "
+"est disponible comme attribut :attr:`modulus` de :data:`sys.hash_info`."
 
 #: ../../src/Doc/library/stdtypes.rst:641
 msgid ""
 "Currently, the prime used is ``P = 2**31 - 1`` on machines with 32-bit C "
 "longs and ``P = 2**61 - 1`` on machines with 64-bit C longs."
 msgstr ""
+"Actuellement, le premier utilisé est ``P = 2 ** 31 - 1`` sur des machines "
+"dont les *longs* en C sont de 32 bits ``P = 2 ** 61 - 1`` sur des machines "
+"dont les *longs* en C font 64 bits."
 
 #: ../../src/Doc/library/stdtypes.rst:644
 msgid "Here are the rules in detail:"
-msgstr ""
+msgstr "Voici les règles en détail :"
 
 #: ../../src/Doc/library/stdtypes.rst:646
 msgid ""
@@ -105963,6 +106006,9 @@ msgid ""
 "by ``P``, define ``hash(x)`` as ``m * invmod(n, P) % P``, where ``invmod(n, "
 "P)`` gives the inverse of ``n`` modulo ``P``."
 msgstr ""
+"Si ``x = m / n`` est un nombre rationnel non négatif et ``n`` n'est pas "
+"divisible par ``P``, définir ``hash(x)`` comme ``m * invmod(n, P) % P``, "
+"où ``invmod(n, P)`` donne l'inverse de ``n`` modulo ``P``."
 
 #: ../../src/Doc/library/stdtypes.rst:650
 msgid ""
@@ -105971,12 +106017,18 @@ msgid ""
 "above doesn't apply; in this case define ``hash(x)`` to be the constant "
 "value ``sys.hash_info.inf``."
 msgstr ""
+"Si ``x = m / n`` est un nombre rationnel non négatif et ``n`` est divisible "
+"par ``P`` (mais ``m`` ne l'est pas), alors ``n`` n'a pas de modulo inverse "
+"``P`` et la règle ci-dessus ne sont pas applicables; dans ce cas définir "
+"``hash(x)`` comme étant la valeur de la constante ``sys.hash_info.inf``."
 
 #: ../../src/Doc/library/stdtypes.rst:655
 msgid ""
 "If ``x = m / n`` is a negative rational number define ``hash(x)`` as ``-"
 "hash(-x)``.  If the resulting hash is ``-1``, replace it with ``-2``."
 msgstr ""
+"Si ``x = m / n`` est un nombre rationnel négatif définir ``hash(x)`` comme "
+"``-hash(-x)``. Si le résultat est ``-1``, le remplacer par ``-2``."
 
 #: ../../src/Doc/library/stdtypes.rst:659
 msgid ""