在python中制作包含整数的类列表对象的最快方法

Question

在 python 中创建包含整数/浮点数（非常简单的数据类型）的类列表对象的最快方法是什么？

“类似列表”是什么意思？

这意味着我想要一个支持列表的两个（非常）基本操作的对象：获取某个索引中的对象 (1) 并更改其值 (2)。

在发布此之前我遇到了哪些帖子，为什么他们没有解决我的问题？

我遇到了这两个：[1][2]

他们没有解决我的问题，因为他们的所有解决方案都太慢了：在我的 PC 中 array.array('i',(0,)*10 ** 8) 导致错误（笑）； [0 for _ in range(10**8)] 花了大约 15 秒（哇！）； [0] * 10 ** 8 耗时 2.3 秒； [None] * 10 ** 8 耗时 1.8 秒； （1.8 秒可能会更快...）

我做了什么？

我尝试使用ctypes 模块

from ctypes import c_int
array = (c_int * 10 ** 8)()

上面的代码只用了 0.7 秒……但是有没有办法让它更快？除了速度快之外，它还有一些缺点：

1. 由于它使用 c/c++ 变量的骨架，因此其中的整数将处于“不像 python 那样无限”的整数值范围内
2. 列表中不能有多个数据类型
3. 您必须导入一个模块才能使用它

真的可以按照我的要求去做吗？有没有比使用ctypes 模块更快的方法？如果是这样，请确保您使用的是“内置”/“预安装”模块。

编辑：

为什么我不能简单地安装一些模块，比如 numpy？

我正在使用 python 进行竞争性编程，大多数解释器/评委不允许使用外部库。

我们可以用array.array 存储自定义对象吗？

我可以看到很多答案都使用了array 模块的array 函数。他们都使用'i'来指定我们要存储整数。是否可以创建一个类并创建一个包含它的“array.array”？例如：

class Point:
 def __init__(self, x, y):
  self.x = x
  self.y = y

# make array.array object with all indexes containing a Point with atributes x and y with value 0
# an example with a list of what I want to do is this:
# l = [Point(0, 0) for _ in range(10**3)]

Answer 1

我只会使用支持快速数组操作的numpy 模块。

例如制作一个编号为 0 到 10**8 的数组：

import numpy as np
import time

b = time.time()
a = np.linspace(0, 10**8, 10**8)
c = time.time()
print(c-b)
>>>0.5000154972076416

或者制作一个长度为 10**8 的 0 数组：

b = time.time()
a = np.zeros(shape=(10**8,))
c = time.time()
print(c-b)
>>>0.0

numpy 这么快的主要原因是它是用 C 实现的。

编辑： 如果您只想使用预安装的软件包，可以尝试使用array 软件包：

import array
import time
r = time.time()
a = array.array('i', [0]) * (10**8)
print(time.time()-r)
>>>0.15627217292785645

Answer 2

我想说你可以尝试不同的方法：

1)numpy。它确实是数组的标准。它伴随着每个操作跨越 Python C 边界的成本，但这真的取决于你的任务。

x = numpy.array(10 ** 8)

timeit.timeit('x = numpy.array(10 ** 8)', 'import numpy', number=1)
4.195800283923745e-05

2) 延迟初始化（如 JavaScript 数组）。

class LazyArray:
    def __init__(self, size):
        self.storage = {}
        self.size = size

    def check(self, i):
        if i < 0 or i >= self.size:
            raise RuntimeError() 

    def __getitem__(self, i):
        self.check(i)
        return self.storage.get(i, 0)

    def __setitem__(self, i, value):
        self.check(i)
        self.storage[i] = value

x = LazyArray(10 ** 8)
x[10]
>> 0
x[10] = 5
x[10]
>> 0

Answer 3

array.array('i',(0,) * 10**8) 导致错误（大声笑）

你没有指定你得到了什么错误 - 这对我有用，虽然它不是很快，因为它构建了一个中间元组并立即丢弃它。使用 Python 的内置类型，array.array 可能会产生最佳性能，前提是您避免使用元组：

a = array.array('i', (0,)) * 10**8

上面的代码只用了 0.7 秒……但是有没有办法让它更快？

如果您不被允许创建或导入 C 扩展，那将很难击败 array.array。在我几年前的机器上，以上需要 0.6 秒。您可以通过增加初始数组的大小来进一步优化它。例如，这会产生相同的结果，但速度几乎快 3 倍 (!)：

# 0.22 s
a = array.array('i', (0,) * 10) * 10**7

在我的机器上，以下版本效果最好：

# 0.19 s
a = array.array('i', (0,) * 100) * 10**6

进一步增加初始数组大小无济于事，并且很快就会开始降低性能。

为了提高效率，请考虑替代方法，例如惰性列表或为您的用例量身定制的完全不同的数据结构。考虑到竞争的背景，这可能就是真正想要的。

但请注意，每种解决方案都会有不同的权衡取舍。例如，@KonstantinNikitin 提供的惰性数组将非常有效地构造，但其在纯 Python 中实现的 __getitem__ 和 __setitem__ 将比 list 或 array.array 慢几个数量级.哪个更适合您归结为您的程序中哪些操作更频繁，这取决于您自己找出答案。

Answer 4

如果你真的只想要这两个属性：

获取某个索引中的对象 (1) 并更改其值 (2)

那么你可以使用collections.defaultdict:

import collections
my_list = collections.defaultdict(lambda: 0)

相当快（~0.4 μs）：

$ python3 -m timeit -s 'import collections' 'collections.defaultdict(lambda: 0)' 
1000000 loops, best of 3: 0.417 usec per loop

但是，实际使用它可能会比其他答案中建议的任何类型慢很多。

Answer 5

对于只需要 0 到 255 之间的整数的情况，bytearray 对象的创建速度非常快：

>>> timeit.timeit('bytearray(100000)', number=1000)
0.005567271093696036
>>> timeit.timeit('array.array("B", [0])*100000', 'import array', number=1000)
0.36631167401839093
>>> timeit.timeit('array.array("i", [0])*100000', 'import array', number=1000)
0.56494557472422

与array.array 不同，这会直接将分配归零，而不是从用零初始化的对象复制。