Quelle est la différence entre les méthodes de liste de Python ajoutées et étendues?


3116

Quelle est la différence entre les méthodes de liste append()et extend()?

Réponses:


5256

append: Ajoute un objet à la fin.

x = [1, 2, 3]
x.append([4, 5])
print (x)

vous donne: [1, 2, 3, [4, 5]]


extend: Étend la liste en ajoutant des éléments de l'itérable.

x = [1, 2, 3]
x.extend([4, 5])
print (x)

vous donne: [1, 2, 3, 4, 5]


122
Quelle est la différence entre extendet en utilisant simplement l'opérateur d'addition - dans l'exemple ci - dessus, x = x + [4, 5]?
Rohan

303
En fait, il y a une grande différence - x + [4, 5]vous donne une nouvelle liste affectée à x - x.extend()mute la liste d'origine. J'élabore dans ma réponse ci-dessous.
Aaron Hall

@AaronHall @Rohan mais c'est la même chose que x += [4,5].
Astitva Srivastava

1
@AstitvaSrivastava En fait, je pense que l'extension est plus rapide en termes de bytecode
MilkyWay90

1
Le mot-clé lors de l'utilisation appendest Object . Si vous essayez d'utiliser extendet que vous passez dans un dictionnaire , il ajoutera la clé et non le hachage entier à la fin du tableau.
Anthony

640

appendajoute un élément à une liste et extendconcatène la première liste avec une autre liste (ou un autre itérable, pas nécessairement une liste).

>>> li = ['a', 'b', 'mpilgrim', 'z', 'example']
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']

>>> li.append("new")
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new']

>>> li.append(["new", 2])
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new', ['new', 2]]

>>> li.insert(2, "new")
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', ['new', 2]]

>>> li.extend(["two", "elements"])
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', ['new', 2], 'two', 'elements']

490

Quelle est la différence entre les méthodes de liste ajoutées et étendues?

  • appendajoute son argument en tant qu'élément unique à la fin d'une liste. La longueur de la liste elle-même augmentera d'une unité.
  • extenditère sur son argument en ajoutant chaque élément à la liste, en étendant la liste. La longueur de la liste augmentera d'autant que de nombreux éléments figuraient dans l'argument itérable.

append

La list.appendméthode ajoute un objet à la fin de la liste.

my_list.append(object) 

Quel que soit l'objet, qu'il s'agisse d'un nombre, d'une chaîne, d'une autre liste ou de quelque chose d'autre, il est ajouté à la fin d' my_listune seule entrée de la liste.

>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']

Gardez donc à l'esprit qu'une liste est un objet. Si vous ajoutez une autre liste à une liste, la première liste sera un seul objet à la fin de la liste (qui peut ne pas être ce que vous voulez):

>>> another_list = [1, 2, 3]
>>> my_list.append(another_list)
>>> my_list
['foo', 'bar', 'baz', [1, 2, 3]]
                     #^^^^^^^^^--- single item at the end of the list.

extend

La list.extendméthode étend une liste en ajoutant des éléments à partir d'un itérable:

my_list.extend(iterable)

Ainsi, avec extend, chaque élément de l'itérable est ajouté à la liste. Par exemple:

>>> my_list
['foo', 'bar']
>>> another_list = [1, 2, 3]
>>> my_list.extend(another_list)
>>> my_list
['foo', 'bar', 1, 2, 3]

Gardez à l'esprit qu'une chaîne est un itérable, donc si vous étendez une liste avec une chaîne, vous ajouterez chaque caractère pendant que vous parcourez la chaîne (ce qui peut ne pas être ce que vous voulez):

>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']

Surcharge de l'opérateur, __add__( +) et __iadd__( +=)

Les opérateurs +et +=sont définis pour list. Ils sont sémantiquement similaires à étendre.

my_list + another_list crée une troisième liste en mémoire, vous pouvez donc en renvoyer le résultat, mais il faut que le deuxième itérable soit une liste.

my_list += another_listmodifie la liste en place (il est l'opérateur en place, et les listes sont des objets mutables, comme nous l' avons vu) il ne crée pas une nouvelle liste. Il fonctionne également comme extend, en ce que le deuxième itérable peut être n'importe quel type d'itérable.

Ne vous trompez pas - my_list = my_list + another_listn'est pas équivalent à +=- cela vous donne une toute nouvelle liste affectée à my_list.

Complexité temporelle

Append a une complexité temporelle constante , O (1).

Étendre a une complexité temporelle, O (k).

L'itération à travers les multiples appels à appendajoute à la complexité, ce qui la rend équivalente à celle d'Extend, et puisque l'itération d'Extend est implémentée en C, elle sera toujours plus rapide si vous avez l'intention d'ajouter des éléments successifs d'un itérable à une liste.

Performance

Vous vous demandez peut-être ce qui est plus performant, car ajouter peut être utilisé pour obtenir le même résultat que prolonger. Les fonctions suivantes font la même chose:

def append(alist, iterable):
    for item in iterable:
        alist.append(item)

def extend(alist, iterable):
    alist.extend(iterable)

Alors chronométrons-les:

import timeit

>>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz")))
2.867846965789795
>>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz")))
0.8060121536254883

Répondre à un commentaire sur les horaires

Un intervenant a déclaré:

Réponse parfaite, je manque juste le moment de comparer l'ajout d'un seul élément

Faites la chose sémantiquement correcte. Si vous souhaitez ajouter tous les éléments dans un itérable, utilisez extend. Si vous ajoutez juste un élément, utilisez append.

Ok, créons donc une expérience pour voir comment cela fonctionne dans le temps:

def append_one(a_list, element):
    a_list.append(element)

def extend_one(a_list, element):
    """creating a new list is semantically the most direct
    way to create an iterable to give to extend"""
    a_list.extend([element])

import timeit

Et nous voyons que sortir de notre chemin pour créer un itérable juste pour utiliser extend est une perte de temps (mineure):

>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295

Nous apprenons de cela qu'il n'y a rien à gagner à utiliser extendquand nous n'avons qu'un seul élément à ajouter.

De plus, ces horaires ne sont pas si importants. Je leur montre simplement qu'ils font valoir qu'en Python, faire ce qui est sémantiquement correct, c'est faire les choses de la bonne façon ™.

Il est concevable que vous puissiez tester des synchronisations sur deux opérations comparables et obtenir un résultat ambigu ou inverse. Concentrez-vous simplement sur la chose sémantiquement correcte.

Conclusion

Nous voyons extendest sémantiquement plus claire, et qu'il peut fonctionner beaucoup plus rapidement que append, lorsque vous avez l' intention d'ajouter chaque élément dans un itérables à une liste.

Si vous n'avez qu'un seul élément (pas dans un itérable) à ajouter à la liste, utilisez append.


1
@Aaron Hall Un petit commentaire d'algorithme pour le timing. "extend_one" peut renvoyer une heure "légèrement incorrecte" car la création d'une liste est également impliquée. Il vaut probablement mieux créer les éléments en tant que variables ( ex1 = 0et ex2 = [0]) et transmettre ces variables, si vous voulez être plus strict.
ilias iliadis

19
Réponse parfaite en effet. Qu'en est-il des performances de l1 += l2vs l1.extend(l2)?
Jean-Francois T.

6
@ Jean-FrancoisT .: l1 += l2et l1.extend(l2)finalement exécuter le même code (la list_extendfonction en listobject.c). Les seules différences sont les suivantes: 1. +=réaffecte l1(à lui-même pour lists, mais la réaffectation prend en charge les types immuables qui ne sont pas le même objet après), ce qui le rend illégal si l1est en fait un attribut d'un objet immuable; par exemple t = ([],), t[0] += lstne parviendrait pas, tout t[0].extend(lst)fonctionnerait. 2. l1 += l2utilise des bytecodes dédiés, tout en l1.extend(l2)utilisant la répartition de méthode généralisée; cela fait +=plus vite que extend.
ShadowRanger

3
Le fait de +=devoir réaffecter l1signifie que, dans certains cas, l'expédition plus lente de extendest partiellement ou entièrement compensée par la non-attribution à gauche. Par exemple, si le listest un attribut d'un objet, self.l1 += l2et self.l1.extend(l2)a des performances identiques sur mon installation Python 3.6, tout simplement parce que le fonctionnement réel est plus semblable self.l1 = self.l1.__iadd__(l2), ce qui signifie qu'il doit effectuer une opération modérément chère STORE_ATTRqui self.l1.extend(l2)n'a pas à le faire.
ShadowRanger

2
Comparaison simple dans les tests locaux: pour une variable locale (donc la +=juste utilisation STORE_FAST, qui est super bon marché), où la valeur ajoutée est un existant listavec un élément en elle, avec l'opération répétée 1000 fois, a +=pris environ 33 ns en moyenne , tout en extendprenant 78 ns, une différence de 45 ns. Si l1est un global (nécessite plus cher STORE_GLOBAL), la différence se rétrécit à 17 ns. Si l1est en réalité local.l1(nécessite encore plus cher STORE_ATTR), il n'y a pas de différence significative entre +=et extend(les horaires à peu près identiques; extendparfois gagne).
ShadowRanger

121

appendajoute un seul élément. extendajoute une liste d'éléments.

Notez que si vous passez une liste à ajouter, elle ajoute toujours un élément:

>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]

62

Ajouter vs étendre

entrez la description de l'image ici

Avec append, vous pouvez ajouter un seul élément qui étendra la liste:

>>> a = [1,2]
>>> a.append(3)
>>> a
[1,2,3]

Si vous souhaitez étendre plusieurs éléments, vous devez utiliser extend, car vous ne pouvez ajouter qu'un élément ou une liste d'éléments:

>>> a.append([4,5])
>>> a
>>> [1,2,3,[4,5]]

Pour obtenir une liste imbriquée

Au lieu de cela, avec extend, vous pouvez étendre un seul élément comme celui-ci

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

Ou, différemment, à partir de l'ajout, étendez plus d'éléments en une seule fois sans imbriquer la liste dans l'original (c'est la raison de l'extension du nom)

>>> a.extend([4,5,6])
>>> a
[1,2,3,4,5,6]

Ajout d'un élément avec les deux méthodes

entrez la description de l'image ici

L'ajout et l'extension peuvent ajouter un élément à la fin de la liste, bien que l'ajout soit plus simple.

ajouter 1 élément

>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]

étendre un élément

>>> x = [1,2]
>>> x.extend([3])
>>> x
[1,2,3]

Ajouter plus d'éléments ... avec des résultats différents

Si vous utilisez append pour plus d'un élément, vous devez passer une liste d'éléments comme arguments et vous obtiendrez une liste NESTED!

>>> x = [1,2]
>>> x.append([3,4])
>>> x
[1,2,[3,4]]

Avec extend, à la place, vous passez une liste en argument, mais vous obtiendrez une liste avec le nouvel élément qui n'est pas imbriqué dans l'ancien.

>>> z = [1,2] 
>>> z.extend([3,4])
>>> z
[1,2,3,4]

Ainsi, avec plus d'éléments, vous utiliserez extend pour obtenir une liste avec plus d'éléments. Cependant, l'ajout d'une liste n'ajoutera pas plus d'éléments à la liste, mais un élément qui est une liste imbriquée comme vous pouvez le voir clairement dans la sortie du code.

entrez la description de l'image ici

entrez la description de l'image ici


61

Les deux extraits suivants sont sémantiquement équivalents:

for item in iterator:
    a_list.append(item)

et

a_list.extend(iterator)

Ce dernier peut être plus rapide car la boucle est implémentée en C.


20
L'extension est ~ 4x plus rapide sur ma machine que l'ajout en boucle (16us contre 4us pour 100 boucles de zéros)
Alex L

6
extend()probablement préalloue, alors que append()probablement pas.
Mad Physicist

@MadPhysicist: Par souci d'exhaustivité, il y aurait des moments où extend() il ne serait pas possible de préallouer judicieusement car certains itérables ne sont pas implémentés __len__(), mais comme vous, je serais surpris s'il n'essayait pas. Une partie du gain de performances provient également de la partie itération en C pur plutôt qu'en Python, comme indiqué dans la réponse d'Aaron .
Soren Bjornstad

44

La append()méthode ajoute un seul élément à la fin de la liste.

x = [1, 2, 3]
x.append([4, 5])
x.append('abc')
print(x)
# gives you
[1, 2, 3, [4, 5], 'abc']

La extend()méthode prend un argument, une liste et ajoute chacun des éléments de l'argument à la liste d'origine. (Les listes sont implémentées en tant que classes. La «création» d'une liste instancie vraiment une classe. En tant que telle, une liste a des méthodes qui fonctionnent dessus.)

x = [1, 2, 3]
x.extend([4, 5])
x.extend('abc')
print(x)
# gives you
[1, 2, 3, 4, 5, 'a', 'b', 'c']

De Dive Into Python .


Vous ne pouvez pas étendre avec seulement 6 car ce n'est pas itérable. Et la deuxième sortie de votre exemple est fausse. 'abc' est ajouté en tant qu'élément unique puisque vous l'avez passé en extendtant que liste avec un élément ['abc']: [1, 2, 3, 4, 5, 'abc']. Pour rendre votre sortie exemple correct, modifiez la ligne abc à: x.extend('abc'). Et supprimez-le x.extend(6)ou changez-le en x.extend([6]).
anéroïde

37

Vous pouvez utiliser "+" pour renvoyer extend, au lieu d'étendre en place.

l1=range(10)

l1+[11]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11]

l2=range(10,1,-1)

l1+l2

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2]

De même +=pour le comportement en place, mais avec de légères différences par rapport à append& extend. L' une des plus grandes différences de +=partir appendet extendest quand il est utilisé dans des étendues de fonction, voir ce billet de blog .


L'utilisation du «+» pour renvoyer l'extension a-t-elle un effet sur la complexité temporelle?
franklin

5
@franklin, voir cette réponse pour plus de détails: stackoverflow.com/a/28119966/2230844
denfromufa

1
Je ne vois pas comment cela répond à la question
pppery

22

append(object) - Met à jour la liste en ajoutant un objet à la liste.

x = [20]
# List passed to the append(object) method is treated as a single object.
x.append([21, 22, 23])
# Hence the resultant list length will be 2
print(x)
--> [20, [21, 22, 23]]

extend(list) - Concatène essentiellement deux listes.

x = [20]
# The parameter passed to extend(list) method is treated as a list.
# Eventually it is two lists being concatenated.
x.extend([21, 22, 23])
# Here the resultant list's length is 4
print(x)
[20, 21, 22, 23]

20

extend()peut être utilisé avec un argument itérateur. Voici un exemple. Vous souhaitez faire une liste à partir d'une liste de listes de cette façon:

De

list2d = [[1,2,3],[4,5,6], [7], [8,9]]

tu veux

>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Vous pouvez utiliser itertools.chain.from_iterable()pour ce faire. La sortie de cette méthode est un itérateur. Sa mise en œuvre équivaut à

def from_iterable(iterables):
    # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

Revenons à notre exemple, nous pouvons le faire

import itertools
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
merged = list(itertools.chain.from_iterable(list2d))

et obtenez la liste des personnes recherchées.

Voici comment l'équivalent extend()peut être utilisé avec un argument itérateur:

merged = []
merged.extend(itertools.chain.from_iterable(list2d))
print(merged)
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]

2
Cette réponse ne contraste pas avec l'extension et ne répond donc pas à la question
pppery

19

C'est l'équivalent de appendet en extendutilisant l' +opérateur:

>>> x = [1,2,3]
>>> x
[1, 2, 3]
>>> x = x + [4,5,6] # Extend
>>> x
[1, 2, 3, 4, 5, 6]
>>> x = x + [[7,8]] # Append
>>> x
[1, 2, 3, 4, 5, 6, [7, 8]]

Pourquoi pas = +?! Plus concis
denfromufa

16

append () : Il est essentiellement utilisé en Python pour ajouter un élément.

Exemple 1:

>> a = [1, 2, 3, 4]
>> a.append(5)
>> print(a)
>> a = [1, 2, 3, 4, 5]

Exemple 2:

>> a = [1, 2, 3, 4]
>> a.append([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, [5, 6]]

extend () : où extend (), est utilisé pour fusionner deux listes ou insérer plusieurs éléments dans une liste.

Exemple 1:

>> a = [1, 2, 3, 4]
>> b = [5, 6, 7, 8]
>> a.extend(b)
>> print(a)
>> a = [1, 2, 3, 4, 5, 6, 7, 8]

Exemple 2:

>> a = [1, 2, 3, 4]
>> a.extend([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, 5, 6]

12

Un point intéressant qui a été suggéré, mais non expliqué, est que l'extension est plus rapide que l'ajout. Pour toute boucle qui a ajouté à l'intérieur doit être considérée comme remplacée par list.extend (processor_elements).

Gardez à l'esprit que l'approbation de nouveaux éléments peut entraîner la réallocation de la liste entière à un meilleur emplacement en mémoire. Si cela est fait plusieurs fois parce que nous ajoutons 1 élément à la fois, les performances globales en souffrent. En ce sens, list.extend est analogue à "" .join (stringlist).


12

Append ajoute toutes les données à la fois. Toutes les données seront ajoutées à l'index nouvellement créé. D'autre part, extendcomme son nom l'indique, étend le tableau actuel.

Par exemple

list1 = [123, 456, 678]
list2 = [111, 222]

Avec appendnous obtenons:

result = [123, 456, 678, [111, 222]]

Pendant que extendnous obtenons:

result = [123, 456, 678, 111, 222]

8

Un dictionnaire anglais définit les mots appendet extendcomme:

ajouter : ajouter (quelque chose) à la fin d'un document écrit.
étendre : agrandir. Agrandir ou agrandir


Avec cette connaissance, comprenons maintenant

1) La différence entre appendetextend

append:

  • Ajoute tout objet Python tel quel à la fin de la liste (c'est-à-dire en tant que dernier élément de la liste).
  • La liste résultante peut être imbriquée et contenir des éléments hétérogènes (c.-à-d. Liste, chaîne, tuple, dictionnaire, ensemble, etc.)

extend:

  • Accepte tout itérables comme argument et fait la liste plus .
  • La liste résultante est toujours une liste unidimensionnelle (c'est-à-dire pas d'imbrication) et elle peut contenir des éléments hétérogènes (par exemple des caractères, des entiers, des flottants) à la suite de l'application list(iterable).

2) Similitude entre appendetextend

  • Les deux prennent exactement un argument.
  • Les deux modifient la liste sur place .
  • En conséquence, les deux reviennent None.

Exemple

lis = [1, 2, 3]

# 'extend' is equivalent to this
lis = lis + list(iterable)

# 'append' simply appends its argument as the last element to the list
# as long as the argument is a valid Python object
list.append(object)

5

J'espère pouvoir apporter un complément utile à cette question. Si votre liste stocke un objet de type spécifique, par exemple Info, voici une situation où la extendméthode n'est pas appropriée: dans une forboucle et et en générant un Infoobjet à chaque fois et en l'utilisant extendpour le stocker dans votre liste, il échouera. L'exception est comme ci-dessous:

TypeError: l'objet 'Info' n'est pas itérable

Mais si vous utilisez la appendméthode, le résultat est OK. Parce que chaque fois que vous utilisez la extendméthode, il la traitera toujours comme une liste ou tout autre type de collection, l'itérera et la placera après la liste précédente. Un objet spécifique ne peut pas être itéré, évidemment.


4

Les distinguer intuitivement

l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]

C'est comme l1reproduire un corps à l'intérieur de son corps (imbriqué).

# Reset l1 = ['a', 'b', 'c']
l1.extend(l2)
l1
['a', 'b', 'c', 'd', 'e', 'f']

C'est comme si deux personnes séparées se marient et construisent une famille unie.

En outre, je fais une feuille de triche exhaustive de toutes les méthodes de la liste pour votre référence.

list_methods = {'Add': {'extend', 'append', 'insert'},
                'Remove': {'pop', 'remove', 'clear'}
                'Sort': {'reverse', 'sort'},
                'Search': {'count', 'index'},
                'Copy': {'copy'},
                }

2

extend(L)étend la liste en ajoutant tous les éléments de la liste donnée L.

>>> a
[1, 2, 3]
a.extend([4])  #is eqivalent of a[len(a):] = [4]
>>> a
[1, 2, 3, 4]
a = [1, 2, 3]
>>> a
[1, 2, 3]
>>> a[len(a):] = [4]
>>> a
[1, 2, 3, 4]

0

append"étend" la liste (en place) par un seul élément , l'objet unique transmis (comme argument).

extend"étend" la liste (en place) par autant d'éléments que contient l'objet (comme argument).

Cela peut être légèrement déroutant pour les strobjets.

  1. Si vous passez une chaîne en argument: appendajoutera un seul élément de chaîne à la fin mais extendajoutera autant d'éléments "str" ​​"simples" que la longueur de cette chaîne.
  2. Si vous passez une liste de chaînes comme argument: appendajoutera toujours un seul élément 'liste' à la fin et extendajoutera autant d'éléments 'liste' que la longueur de la liste passée.
def append_o(a_list, element):
    a_list.append(element)
    print('append:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()

def extend_o(a_list, element):
    a_list.extend(element)
    print('extend:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()
append_o(['ab'],'cd')

extend_o(['ab'],'cd')
append_o(['ab'],['cd', 'ef'])
extend_o(['ab'],['cd', 'ef'])
append_o(['ab'],['cd'])
extend_o(['ab'],['cd'])

produit:

append: ab,cd,
extend: ab,c,d,
append: ab,['cd', 'ef'],
extend: ab,cd,ef,
append: ab,['cd'],
extend: ab,cd,

0

Ajouter et étendre sont l'un des mécanismes d'extensibilité en python.

Ajouter: ajoute un élément à la fin de la liste.

my_list = [1,2,3,4]

Pour ajouter un nouvel élément à la liste, nous pouvons utiliser la méthode append de la manière suivante.

my_list.append(5)

L'emplacement par défaut auquel le nouvel élément sera ajouté est toujours en position (longueur + 1).

Insertion: La méthode d'insertion a été utilisée pour surmonter les limitations de l'ajout. Avec insert, nous pouvons définir explicitement la position exacte à laquelle nous voulons que notre nouvel élément soit inséré.

Descripteur de méthode d'insertion (index, objet). Il prend deux arguments, tout d'abord l'indice que nous voulons insérer notre élément et ensuite l'élément lui-même.

Example: my_list = [1,2,3,4]
my_list[4, 'a']
my_list
[1,2,3,4,'a']

Étendre: Ceci est très utile lorsque nous voulons joindre deux ou plusieurs listes en une seule liste. Sans extension, si nous voulons joindre deux listes, l'objet résultant contiendra une liste de listes.

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

Si nous essayons d'accéder à l'élément à la pos 2, nous obtenons une liste ([3]), au lieu de l'élément. Pour rejoindre deux listes, nous devrons utiliser append.

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

Pour rejoindre plusieurs listes

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

2
Pourquoi répondez-vous à une question à laquelle vous avez déjà répondu plusieurs fois? Cette question a 10 ans ...
Mike - SMT
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.