Concaténation de deux listes - différence entre '+=' et extend()

Question

J'ai vu qu'il y avait en fait deux façons (peut-être plus) de concaténer des listes en Python :

L'une des solutions consiste à utiliser la fonction extend() méthode :

a = [1, 2]
b = [2, 3]
b.extend(a)

l'autre pour utiliser l'opérateur plus (+) :

b += a

Maintenant je me demande : laquelle de ces deux options est la façon "pythonique" de faire de la concaténation de listes et y a-t-il une différence entre les deux ? (J'ai consulté le tutoriel officiel de Python mais je n'ai rien trouvé à ce sujet).

Answer 1

La seule différence au niveau du bytecode est que l'élément .extend implique un appel de fonction, ce qui est légèrement plus coûteux en Python que l'appel de fonction. INPLACE_ADD .

Il n'y a pas lieu de s'inquiéter, sauf si vous effectuez cette opération des milliards de fois. Il est toutefois probable que le goulot d'étranglement se situe à un autre endroit.

Answer 2

Vous ne pouvez pas utiliser += pour une variable non locale (variable qui n'est pas locale pour la fonction et qui n'est pas non plus globale).

def main():
    l = [1, 2, 3]

    def foo():
        l.extend([4])

    def boo():
        l += [5]

    foo()
    print l
    boo()  # this will fail

main()

C'est parce que pour étendre Dans ce cas, le compilateur chargera la variable l en utilisant LOAD_DEREF mais pour +=, il utilisera LOAD_FAST - et vous obtenez *UnboundLocalError: local variable 'l' referenced before assignment*

Answer 3

Vous pouvez enchaîner des appels de fonction, mais vous ne pouvez pas += un appel de fonction directement :

class A:
    def __init__(self):
        self.listFoo = [1, 2]
        self.listBar = [3, 4]

    def get_list(self, which):
        if which == "Foo":
            return self.listFoo
        return self.listBar

a = A()
other_list = [5, 6]

a.get_list("Foo").extend(other_list)
a.get_list("Foo") += other_list  #SyntaxError: can't assign to function call

Answer 4

Selon la Le zen de Python :

La simplicité est préférable à la complexité.

b += a est plus simple que b.extend(a) .

Les modules intégrés sont tellement optimisés qu'il n'y a pas de réelle différence de performance.

Answer 5

Je dirais qu'il y a quelques différences avec numpy (je viens de voir que la question portait sur la concaténation de deux listes, et non sur un tableau numpy, mais comme cela peut être un problème pour un débutant comme moi, j'espère que cela pourra aider quelqu'un qui cherche la solution à ce post), par ex.

import numpy as np
a = np.zeros((4,4,4))
b = []
b += a

il renverra l'erreur

ValueError : les opérandes ne peuvent pas être diffusés ensemble avec des formes (0,) (4,4,4)

b.extend(a) fonctionne parfaitement