python : Cost of forming list with comprehension vs standalone function

Question

在 python 中，使用理解式或使用独立函数制作列表哪个成本更高？

我似乎找不到以前提出相同问题的帖子。虽然其他答案详细介绍了 python 的字节和内部工作原理，这确实很有帮助，但我觉得可视化图表有助于表明存在连续的趋势。

我对 python 的底层工作原理还没有足够的了解，所以这些答案对我来说有点陌生，无法尝试和理解。

Answer 1

我目前是一名计算机科学本科生，我一直对 python 的强大感到惊讶。我最近做了一个小实验来测试通过理解与独立函数形成列表的成本。例如:

def make_list_of_size(n):
    retList = []
    for i in range(n):
        retList.append(0)
    return retList

创建一个大小为 n 且包含零的列表。

众所周知，这个函数的复杂度是O(n)。我想探索以下方面的成长:

def comprehension(n):
    return [0 for i in range(n)]

这构成了相同的列表。

让我们一起探索吧!

这是我用于计时的代码，并记下函数调用的顺序(我首先以哪种方式列出列表)。我首先用独立函数制作了列表，然后用理解来制作。我还没有学会如何关闭这个实验的垃圾收集，因此，当垃圾收集开始时，会产生一些固有的测量误差。

'''
file: listComp.py
purpose: to test the cost of making a list with comprehension
versus a standalone function
'''
import time as T
def get_overhead(n):
    tic = T.time()
    for i in range(n):
        pass
    toc = T.time()
    return toc - tic


def make_list_of_size(n):
    aList = [] #<-- O(1)
    for i in range(n): #<-- O(n)
        aList.append(n) #<-- O(1)
    return aList #<-- O(1)

def comprehension(n):
    return [n for i in range(n)] #<-- O(?)

def do_test(size_i,size_f,niter,file):
    delta = 100
    size = size_i
    while size <= size_f:
        overhead = get_overhead(niter)

        reg_tic = T.time()
        for i in range(niter):
            reg_list = make_list_of_size(size)
        reg_toc = T.time()

        comp_tic = T.time()
        for i in range(niter):
            comp_list = comprehension(size)
        comp_toc = T.time()

        #--------------------

        reg_cost_per_iter = (reg_toc - reg_tic - overhead)/niter
        comp_cost_pet_iter = (comp_toc - comp_tic - overhead)/niter

        file.write(str(size)+","+str(reg_cost_per_iter)+
            ","+str(comp_cost_pet_iter)+"\n")

        print("SIZE: "+str(size)+ " REG_COST = "+str(reg_cost_per_iter)+
            " COMP_COST = "+str(comp_cost_pet_iter))

        if size == 10*delta:
            delta *= 10
        size += delta

def main():
    fname = input()
    file = open(fname,'w')
    do_test(100,1000000,2500,file)
    file.close()

main()

我做了三项测试。其中两个最大列表大小为 100000，第三个最大为 1*10^6

查看图:

Overlay with NO ZOOM

我发现这些结果很有趣。尽管这两种方法都有 O(n) 的大 O 表示法，但就时间而言，对于生成相同列表的理解而言，成本较低。

我有更多信息要分享，包括首先使用理解生成的列表进行的相同测试，然后使用独立函数进行。

我还没有在没有垃圾收集的情况下运行测试。