Python 类型 long 与 C“long long”类型

Question

我想将一个值表示为 64 位有符号 long，这样大于 (2**63)-1 的值表示为负数，但是 Python long 具有无限精度。有没有一种“快速”的方法可以让我实现这一目标？

Answer 1

您可以使用 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

如果您确定 signed long long 在目标机器上的宽度为 64 位，那么这实际上仅是一个选项。

编辑：jorendorff的想法 为 64 位数字定义一个类很有吸引力。理想情况下，您希望最大程度地减少显式类创建的数量。

使用c_longlong，你可以做这样的事情（注意：仅限Python 3.x！）：

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

    ...

这样的结果是ll(2 ** 63) - 1 确实是 9223372036854775807。不过，这种构造可能会导致性能下降，因此根据您想要做什么，定义一个像上面这样的类可能不值得。如有疑问，请使用 timeit。

Answer 2

你可以使用 numpy 吗？它有一个 int64 类型，可以完全满足您的需求。

In [1]: import numpy

In [2]: numpy.int64(2**63-1)
Out[2]: 9223372036854775807

In [3]: numpy.int64(2**63-1)+1
Out[3]: -9223372036854775808

与 ctypes 示例不同，它对用户是透明的，并且它是用 C 编写的，因此比在 Python 中滚动您自己的类更快。 Numpy 可能比其他解决方案更大，但如果您正在进行数值分析，您会很高兴拥有它。

Answer 3

最快的事情可能是自己将结果截断为 64 位：

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

您当然可以定义自己的数字类型，每次执行任何类型的算术运算时都会自动执行此操作：

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)

    ...

但这并不是特别“快”实现。

Answer 4

看一下 ctypes 模块，它用于从 python 调用外部 DLL/库。
有一些数据类型对应于C类型，例如

c_longlong 类