I would like to represent a value as a 64bit signed long, such that values larger than (2**63)-1 are represented as negative, however Python long has infinite precision. Is there a 'quick' way for me to achieve this?

解决方案>>> 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

This is really only an option if you know for sure that a signed long long will be 64 bits wide on the target machine(s).

Edit: jorendorff's idea of defining a class for 64 bit numbers is appealing. Ideally you want to minimize the number of explicit class creations.

Using c_longlong, you could do something like this (note: Python 3.x only!):

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))

...

In this way the result of ll(2 ** 63) - 1 will indeed be 9223372036854775807. This construction may result in a performance penalty though, so depending on what you want to do exactly, defining a class such as the above may not be worth it. When in doubt, use timeit.