"``(-1)//2`` vaut ``-1``, ``1//(-2)`` vaut ``-1``, et ``(-1)//(-2)`` vaut "

"``0``."

"Le type int implémente la :term:`abstract base class` :class:`numbers."

"`OverflowError` est levée s'il n'est pas possible de représenter l'entier "

"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*."

"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``."

msgstr "Done le nombre entier représenté par le tableau d'octets fourni."

"L'argument *bytes* doit être soit un :term:`bytes-like object` soit un "

"itérable produisant des *bytes*"

"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."

"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`."

"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`` ::"

"L'application de la conversion inverse à ``3740.0`` donne une chaîne "

"hexadécimale différente représentant le même nombre ::"

msgstr "Hachage des types numériques"

"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`."

"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."

msgstr "Voici les règles en détail :"

"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``."

"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``."

"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``."