Est-ce que `extend` est plus rapide que` + = `?

Question

En python, nous pouvons concaténer des listes de deux façons:

1. lst.extend (another_lst)
2. LST + = another_lst

Je pensais que extend serait plus rapide que d'utiliser +=, car réutilise la liste au lieu d'en créer une nouvelle en utilisant les deux autres.

Mais quand je le tester avec timeit, il se avère que += est plus rapide,

>>> timeit('l.extend(x)', 'l = range(10); x = range(10)') 
0.16929602623 
>>> timeit('l += x', 'l = range(10); x = range(10)') 
0.15030503273 
>>> timeit('l.extend(x)', 'l = range(500); x = range(100)') 
0.805264949799 
>>> timeit('l += x', 'l = range(500); x = range(100)') 
0.750471830368 

Y at-il quelque chose de mal avec le code que je mets en timeit?

Answer 1

EDIT: J'ai testé la performance et je ne peux pas reproduire les différences à un niveau significatif.

---

est ici le bytecode - grâce à @John Machin pour pointer les incohérences.

>>> import dis 
>>> l = [1,2,3] 
>>> m = [4,5,6] 
>>> def f1(l, m): 
...  l.extend(m) 
... 
>>> def f2(l,m): 
...  l += m 
... 
>>> dis.dis(f1) 
    2   0 LOAD_FAST    0 (l) 
       3 LOAD_ATTR    0 (extend) 
       6 LOAD_FAST    1 (m) 
       9 CALL_FUNCTION   1 
      12 POP_TOP 
      13 LOAD_CONST    0 (None) 
      16 RETURN_VALUE 
>>> dis.dis(f2) 
    2   0 LOAD_FAST    0 (l) 
       3 LOAD_FAST    1 (m) 
       6 INPLACE_ADD 
       7 STORE_FAST    0 (l) 
      10 LOAD_CONST    0 (None) 
      13 RETURN_VALUE 

Notez que extend utilise un CALL_FUNCTION au lieu d'un INPLACE_ADD. Toute différence de performance triviale peut probablement être attribuée à cela.