Réponses:
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]
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.
x += [4,5]
.
append
est Object . Si vous essayez d'utiliser extend
et que vous passez dans un dictionnaire , il ajoutera la clé et non le hachage entier à la fin du tableau.
append
ajoute un élément à une liste et extend
concatè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']
Quelle est la différence entre les méthodes de liste ajoutées et étendues?
append
ajoute 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é.extend
itè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.append
mé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_list
une 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.extend
mé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']
__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_list
modifie 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_list
n'est pas équivalent à +=
- cela vous donne une toute nouvelle liste affectée à my_list.
Append a une complexité temporelle constante , O (1).
Étendre a une complexité temporelle, O (k).
L'itération à travers les multiples appels à append
ajoute à 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.
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
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 extend
quand 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.
Nous voyons extend
est 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
.
ex1 = 0
et ex2 = [0]
) et transmettre ces variables, si vous voulez être plus strict.
l1 += l2
vs l1.extend(l2)
?
l1 += l2
et l1.extend(l2)
finalement exécuter le même code (la list_extend
fonction en listobject.c
). Les seules différences sont les suivantes: 1. +=
réaffecte l1
(à lui-même pour list
s, 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 l1
est en fait un attribut d'un objet immuable; par exemple t = ([],)
, t[0] += lst
ne parviendrait pas, tout t[0].extend(lst)
fonctionnerait. 2. l1 += l2
utilise 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
.
+=
devoir réaffecter l1
signifie que, dans certains cas, l'expédition plus lente de extend
est partiellement ou entièrement compensée par la non-attribution à gauche. Par exemple, si le list
est un attribut d'un objet, self.l1 += l2
et 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_ATTR
qui self.l1.extend(l2)
n'a pas à le faire.
+=
juste utilisation STORE_FAST
, qui est super bon marché), où la valeur ajoutée est un existant list
avec un élément en elle, avec l'opération répétée 1000 fois, a +=
pris environ 33 ns en moyenne , tout en extend
prenant 78 ns, une différence de 45 ns. Si l1
est un global (nécessite plus cher STORE_GLOBAL
), la différence se rétrécit à 17 ns. Si l1
est 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; extend
parfois gagne).
append
ajoute un seul élément. extend
ajoute 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]]
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]
L'ajout et l'extension peuvent ajouter un élément à la fin de la liste, bien que l'ajout soit plus simple.
>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]
>>> x = [1,2]
>>> x.extend([3])
>>> x
[1,2,3]
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.
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.
extend()
probablement préalloue, alors que append()
probablement pas.
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 .
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 .
extend
tant 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])
.
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 append
et extend
est quand il est utilisé dans des étendues de fonction, voir ce billet de blog .
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]
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]
C'est l'équivalent de append
et en extend
utilisant 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]]
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]
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).
Append ajoute toutes les données à la fois. Toutes les données seront ajoutées à l'index nouvellement créé. D'autre part, extend
comme son nom l'indique, étend le tableau actuel.
Par exemple
list1 = [123, 456, 678]
list2 = [111, 222]
Avec append
nous obtenons:
result = [123, 456, 678, [111, 222]]
Pendant que extend
nous obtenons:
result = [123, 456, 678, 111, 222]
Un dictionnaire anglais définit les mots append
et extend
comme:
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 append
etextend
append
:
extend
:
list(iterable)
.2) Similitude entre append
etextend
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)
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 extend
méthode n'est pas appropriée: dans une for
boucle et et en générant un Info
objet à chaque fois et en l'utilisant extend
pour 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 append
méthode, le résultat est OK. Parce que chaque fois que vous utilisez la extend
mé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.
Les distinguer intuitivement
l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]
C'est comme l1
reproduire 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'},
}
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 str
objets.
append
ajoutera un seul élément de chaîne à la fin mais
extend
ajoutera autant d'éléments "str" "simples" que la longueur de cette chaîne.append
ajoutera toujours un seul élément 'liste' à la fin et
extend
ajoutera 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,
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]
extend
et en utilisant simplement l'opérateur d'addition - dans l'exemple ci - dessus,x = x + [4, 5]
?