有哪些示例 python 片段可以很容易地在不改變邏輯的情況下運行得更快？

Question

所以，昨天我學到了很難的方法：

s = []
for i in range(n):
    s.append('a')
"".join(s)

在速度方面與下面有很大的不同（盡管兩者具有相同的“時間復雜度”）

'a' * n 

原因幾乎是不言自明的：前者調用（相對）太多的匯編調用。

>>> import dis
>>> def f(c,n):
...     return c*n
... 
>>> def f2(c,n):
...     l = []
...     for i in range(n):
...             l.append(c)
... 
>>> dis.dis(f)
  2           0 LOAD_FAST                0 (c)
              2 LOAD_FAST                1 (n)
              4 BINARY_MULTIPLY
              6 RETURN_VALUE
>>> dis.dis(f2)
  2           0 BUILD_LIST               0
              2 STORE_FAST               2 (l)

  3           4 SETUP_LOOP              26 (to 32)
              6 LOAD_GLOBAL              0 (range)
              8 LOAD_FAST                1 (n)
             10 CALL_FUNCTION            1
             12 GET_ITER
        >>   14 FOR_ITER                14 (to 30)
             16 STORE_FAST               3 (i)

  4          18 LOAD_FAST                2 (l)
             20 LOAD_METHOD              1 (append)
             22 LOAD_FAST                0 (c)
             24 CALL_METHOD              1
             26 POP_TOP
             28 JUMP_ABSOLUTE           14
        >>   30 POP_BLOCK
        >>   32 LOAD_CONST               0 (None)
             34 RETURN_VALUE

我的問題是：還有哪些此類代碼的其他示例，其中兩個具有相同時間復雜度的片段以非常不同的速度運行？

（我道歉並理解這是否有點離題。只是我現在失去了一份工作面試，不知道上面的瑣事。我不能再發生這樣的事情，這就是我發這篇文章的原因，部分出於沮喪）