Python元组分配与列表追加

如何解决Python元组分配与列表追加

在考虑运行时（大O）和内存使用情况时，以下哪个代码效率更高？

代码1：

a = []

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

print(a)

案例2：

a = tuple()

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

print(a)

此处： some_data 可以是1或n个数据。

我的猜测是，代码2 是有效的，因为它使用的内存更少，并且可能在分配操作中从堆栈内存中存入/弹出数据。

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

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

解决方法

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

在线

a += (item.id,)

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

为此，有4个操作：

• 创建元组=> (item.id,)
• 合并2个元组=> a + (item.id,)
  • 创建更大的元组
  • 在内部插入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倍。

,

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

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快，但占用更多内存