Python 元组分配与列表追加

Question

在考虑运行时 (Big O) 和内存使用时，以下哪一个代码更有效？

代码 1:

a = []

for item in some_data:
   a.append(item.id)
   # some other code

print(a)

案例二：

a = tuple()

for item in some_data:
   a += (item.id,)
   # some other code

print(a)

这里：some_data可以是1个或n个数据。

我的猜测是 代码 2 是高效的，因为它使用更少的内存并且可能从堆栈内存中插入和弹出数据 in/out 以进行赋值操作。

我认为代码 1 效率较低，因为通常会在分配内存时列出，并且在附加数据时，当分配的内存超出时，它必须找到新的内存地址。

顺便说一句，我只是数据结构和算法的初学者，不知道 python 如何管理内存中的变量。

Answer 1

考虑内存使用情况，我会说列表更好。

在线

a += (item.id,)

你基本上做的是a = a + (item.id,)（我在做捷径，但有一些小的区别。）

为此，有 4 个操作：

创建一个元组=>(item.id,)
合并 2 个元组 => a + (item.id,)
- 创建更大的元组
- 在
- 在

创建新对象（此处为元组）花费的时间最多。每次迭代完成 2 次。

另一方面，追加一个列表！= 创建一个新列表。所以在带列表的例子中，没有创建（a = []除外）

考虑执行时间：

In [1]: some_data = list(range(10000))                                                                                                                                                                                 

In [2]: %%timeit
        a = tuple()

        for item in some_data:
            a += (item,)                                                                                                                                                                                             
Out[2]: 151 ms ± 1.49 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)



In [3]: %%timeit
        a = []

        for item in some_data:
            a.append(item)                                                                                                                                                                                            
Out[3]: 406 µs ± 3.39 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)


In [4]: %%timeit
        a = [item for item in some_data]  
                                                                                                                                                                                      
Out[4]: 154 µs ± 392 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

所以列表理解比元组快 1000 倍。

Answer 2

我为基准时间和内存使用编写了简单的脚本。

import time
import functools
from memory_profiler import profile


def timer(func):
    @functools.wraps(func)
    def wrapper_timer(*args, **kwargs):
        start_time = time.perf_counter()

        value = func(*args, **kwargs)

        end_time = time.perf_counter()

        run_time = end_time - start_time

        print(f"Finished {func.__name__!r} in {run_time:.4f} seconds")

        return value

    return wrapper_timer


LOOPS = 100000


@timer
def test_append():
    sample = []
    for i in range(LOOPS):
        sample.append(i)


@timer
def test_tuple():
    sample = tuple()
    for i in range(LOOPS):
        sample += (i, )


@profile(precision=2)
def main():
    test_append()
    test_tuple()


if __name__ == '__main__':
    main()

当LOOPS为100000

Finished 'test_append' in 0.0745 seconds
Finished 'test_tuple' in 22.3031 seconds

Line #    Mem usage    Increment   Line Contents
================================================
73    38.00 MiB    38.00 MiB   @profile(precision=2)
74                             def main():
75    38.96 MiB     0.97 MiB       test_append()
76    39.10 MiB     0.13 MiB       test_tuple()

当LOOPS为1000

Finished 'test_append' in 0.0007 seconds
Finished 'test_tuple' in 0.0019 seconds

Line #    Mem usage    Increment   Line Contents
================================================
73    38.04 MiB    38.04 MiB   @profile(precision=2)
74                             def main():
75    38.04 MiB     0.00 MiB       test_append()
76    38.04 MiB     0.00 MiB       test_tuple()

所以append比tuple快但是占用内存多

Python 元组分配与列表追加

Python tuple assignment vs list appending

python

big-o

memory-management

runtime

data-structures