有哪些示例 python 片段可以很容易地在不改变逻辑的情况下运行得更快？

Question

So, yesterday I learned the hard way that:

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

is vastly, VASTLY different from the below, in terms of speed (despite both having the same "time complexity")

'a' * n 

The reason is almost self-explanatory: the former invokes (relatively) way too many assembly calls.

>>> 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

My question is: what are some other examples of such kinds of code, where two snippets, both having the same time complexity, run with very different speeds?

(I apologize and understand if this is a bit off-topic. It's just that I've now lost a job interview not knowing the piece of trivia above. I cannot afford things like this to happen again, which is why I made this post, partly out of frustration)