Python类型为long而C类型为long

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?

我想将一个值表示为64位有符号的长，这样大于(2**63)-1的值就表示为负，但是Python long具有无限的精度。有什么“快速”的方法可以让我做到这一点吗?

4 个解决方案

#1

You could use ctypes.c_longlong:

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

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

这实际上只是一个选项，如果您确定一个带符号的长长长在目标机器上将是64位宽。

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.

编辑:jorendorff为64位数字定义类的想法很有吸引力。理想情况下，您希望最小化显式类创建的数量。

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

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

    ...

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.

这样，ll(2 ** 63) - 1的结果确实是9223372036854775807。但是，这种构造可能会导致性能损失，因此根据您想要确切地做什么，定义一个类(如上面所示)可能不值得。当你不确定的时候，用时间。

#2

Can you use numpy? It has an int64 type that does exactly what you want.

你可以用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

It's transparent to users, unlike the ctypes example, and it's coded in C so it'll be faster than rolling your own class in Python. Numpy may be bigger than the other solutions, but if you're doing numerical analysis, you will appreciate having it.

它对用户是透明的，不像ctypes示例，它是用C编写的，所以它比在Python中滚动自己的类要快。Numpy可能比其他解要大，但是如果你做数值分析，你会喜欢它。

#3

The quickest thing is probably to truncate the result to 64 bits yourself:

最快的方法可能是将结果截断为64位:

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

You can of course define your own numeric type that automatically does this every time you do any sort of arithmetic operation:

当然，你可以定义你自己的数字类型，每次你做任何算术运算时，它都会自动完成:

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)

    ...

but that is not particularly "quick" to implement.

但实施起来并不特别“迅速”。

#4

Have a look at the ctypes module, it is used to call foreign DLLs/libraries from python. There a some data types that correspond to C types, for example

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

class c_longlong

类c_longlong

#1