Python列表理解非常昂贵

我试图找到列表理解的效率，但它看起来比正常的函数操作更昂贵。有人能解释一下吗

def squares(values):
    lst = []
    for x in range(values):
        lst.append(x*x)
    return lst

def main():
    t = timeit.Timer(stmt="lst = [x*x for x in range(10)]")
    print t.timeit()
    t = timeit.Timer(stmt="squares",setup="from __main__ import squares")
    print t.timeit()

    lst = [x*x for x in range(10)]
    print lst
    print squares(10)



----Output:---
2.4147507644
0.0284455255965
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

对于相同的输出，与列表理解相比，normal函数的计算时间非常短

我认为列表理解更有效。

您从未调用

squares

函数，因此它什么都不做

事实上，列表理解速度更快：

>>> import timeit
>>> def squares(values):
...     lst = []
...     for x in range(values):
...         lst.append(x*x)
...     return lst
... 
>>> def squares_comp(values):
...     return [x*x for x in range(values)]
... 
>>> timeit.timeit('f(10)', 'from __main__ import squares as f')
3.9415171146392822
>>> timeit.timeit('f(10)', 'from __main__ import squares_comp as f')
2.3243820667266846

如果使用

dis

模块查看每个函数的字节码，您可以看到原因：

>>> import dis
>>> dis.dis(squares)
  2           0 BUILD_LIST               0
              3 STORE_FAST               1 (lst)

  3           6 SETUP_LOOP              37 (to 46)
              9 LOAD_GLOBAL              0 (range)
             12 LOAD_FAST                0 (values)
             15 CALL_FUNCTION            1
             18 GET_ITER            
        >>   19 FOR_ITER                23 (to 45)
             22 STORE_FAST               2 (x)

  4          25 LOAD_FAST                1 (lst)
             28 LOAD_ATTR                1 (append)
             31 LOAD_FAST                2 (x)
             34 LOAD_FAST                2 (x)
             37 BINARY_MULTIPLY     
             38 CALL_FUNCTION            1
             41 POP_TOP             
             42 JUMP_ABSOLUTE           19
        >>   45 POP_BLOCK           

  5     >>   46 LOAD_FAST                1 (lst)
             49 RETURN_VALUE        
>>> dis.dis(squares_comp)
  2           0 BUILD_LIST               0
              3 LOAD_GLOBAL              0 (range)
              6 LOAD_FAST                0 (values)
              9 CALL_FUNCTION            1
             12 GET_ITER            
        >>   13 FOR_ITER                16 (to 32)
             16 STORE_FAST               1 (x)
             19 LOAD_FAST                1 (x)
             22 LOAD_FAST                1 (x)
             25 BINARY_MULTIPLY     
             26 LIST_APPEND              2
             29 JUMP_ABSOLUTE           13
        >>   32 RETURN_VALUE        

squares

函数在每次迭代中查找列表的

.append（）

方法，并调用它。

.append（）

函数必须在每次调用列表时将其增加一个元素

---

另一方面，列表理解不一定要做那项工作。相反，python使用

LIST\u APPEND

字节码，它使用C API将新元素追加到列表中，而无需执行查找和python对函数的调用。

@SamueleMattiuzzo I删除了我的代码（没有必要重复相同的内容），所以，在这一点上投票吧。@SamueleMattiuzzo-现在不难选择：-）AFAIK列表理解更快，因为操作是在parallel@toutpt：你从哪里得到这个主意的？它不会并行执行任何操作。@JonClements:使用

def squares\u映射（值）：\n values=range（values）\n返回映射（operator.mul，values，values）\n

它在2.5397000312805176上具有竞争力。列表比较仍然获胜。下面的答案解释了你的结果-但值得注意的是列表比较快的原因-循环是在较低的级别执行的，这意味着它可以更有效地完成。@Lattyware:不，循环实际上不是区别；非comp版本中的

.append（）

调用决定了速度。在循环中，每次都需要查找和调用它，并且每次都会为该元素增加列表。公司只需一次就可以建立这个名单。