Python de type long vs C 'long'

Vous pouvez utiliser ctypes.c_longlong:

>>> from ctypes import c_longlong as ll
>>> ll(2 ** 63 - 1)
c_longlong(9223372036854775807L)
>>> ll(2 ** 63)
c_longlong(-9223372036854775808L)
>>> ll(2 ** 63).value
-9223372036854775808L

C'est vraiment seulement une option si vous êtes sûr qu'un signed long long 64 bits de large sur la machine cible(s).

Edit: jorendorff l'idée de de la définition d'une classe pour la version 64 bits est attrayant. Idéalement, vous voulez minimiser le nombre de explicite de la classe créations.

À l'aide de c_longlong, vous pourriez faire quelque chose comme ceci (remarque: Python 3.x seulement!):

from ctypes import c_longlong

class ll(int):
    def __new__(cls, n):
        return int.__new__(cls, c_longlong(n).value)

    def __add__(self, other):
        return ll(super().__add__(other))

    def __radd__(self, other):
        return ll(other.__add__(self))

    def __sub__(self, other):
        return ll(super().__sub__(other))

    def __rsub__(self, other):
        return ll(other.__sub__(self))

    ...

De cette façon, le résultat de ll(2 ** 63) - 1 sera en effet 9223372036854775807. Cette construction peut entraîner une dégradation de la performance, donc en fonction de ce que vous voulez faire exactement, la définition d'une classe, par exemple comme ci-dessus peuvent ne pas être en vaut la peine. En cas de doute, utilisez timeit.

OriginalL'auteur Stephan202

La chose la plus rapide est sans doute pour tronquer le résultat à 64 bits vous-même:

def to_int64(n):
    n = n & ((1 << 64) - 1)
    if n > (1 << 63) - 1:
        n -= 1 << 64
    return n

Bien sûr, vous pouvez définir votre propre type numérique est automatiquement chaque fois que vous faites toute sorte d'opération arithmétique:

class Int64:
    def __init__(self, n):
        if isinstance(n, Int64):
            n = n.val
        self.val = to_int64(n)

    def __add__(self, other):
        return Int64(self.val + other)

    def __radd__(self, other):
        return Int64(other + self.val)

    def __sub__(self, other):
        return Int64(self.val - other)

    ...

mais qui n'est pas particulièrement rapide à mettre en œuvre.

OriginalL'auteur Jason Orendorff