Vraag Verschil tussen append-versus-uitbreidingslijstmethoden in Python


Wat is het verschil tussen de lijstmethoden append() en extend()?


2682
2017-10-31 05:55


oorsprong


antwoorden:


append: Voegt het object aan het einde toe.

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

geeft jou: [1, 2, 3, [4, 5]]


extend: Breidt de lijst uit door elementen uit de iterabele toe te voegen.

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

geeft jou: [1, 2, 3, 4, 5]


4073
2017-10-31 06:02



append voegt een element toe aan een lijst, en extend voegt de eerste lijst samen met een andere lijst (of een andere iterabele, niet noodzakelijk een lijst.)

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

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

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

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

Van Duik in Python.


525
2017-10-31 05:57



Wat is het verschil tussen de lijstmethoden toevoegen en verlengen?

  • append voegt zijn argument toe als een enkel element aan het einde van een lijst. De lengte van de lijst zelf zal met één toenemen.
  • extend itereert over het argument om elk element aan de lijst toe te voegen en breidt de lijst uit. De lengte van de lijst zal toenemen met hoe veel elementen ook in het iterabele argument waren.

append

De list.append methode voegt een object toe aan het einde van de lijst.

my_list.append(object) 

Wat het object ook is, of het nu een nummer, een tekenreeks, een andere lijst of iets anders is, het wordt toegevoegd aan het einde van my_list als een enkele vermelding op de lijst.

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

Houd er dus rekening mee dat een lijst een object is. Als u een andere lijst aan een lijst toevoegt, zal de eerste lijst één enkel object zijn aan het einde van de lijst (wat misschien niet is wat u wilt):

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

extend

De list.extend methode breidt een lijst uit door elementen van een iterabele toe te voegen:

my_list.extend(iterable)

Dus met extend wordt elk element van de iterabele toegevoegd aan de lijst. Bijvoorbeeld:

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

Houd er rekening mee dat een tekenreeks een iterabele waarde is, dus als u een lijst met een tekenreeks uitbreidt, voegt u elk teken toe terwijl u de tekenreeks itereert (wat mogelijk niet is wat u zoekt):

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

Operator overbelasting, __add__, (+) en __iadd__ (+=)

Beide + en += operators worden gedefinieerd voor list. Ze lijken semantisch op uitbreiding.

my_list + another_list maakt een derde lijst in het geheugen, zodat u het resultaat ervan kunt retourneren, maar het vereist dat de tweede iterabele een lijst is.

my_list += another_list wijzigt de lijst op zijn plaats (it is de in-place-operator en lijsten zijn veranderbare objecten, zoals we hebben gezien), zodat er geen nieuwe lijst wordt gemaakt. Het werkt ook als verlengen, in die zin dat de tweede iterable elke soort van iterable kan zijn.

Raak niet in de war - my_list = my_list + another_list is niet gelijk aan += - het geeft je een geheel nieuwe lijst toegewezen aan mijn_lijst.

Tijd complexiteit

Append heeft constante tijd complexiteit, O (1).

Verlengen heeft tijdcomplexiteit, O (k).

Itereren via de meerdere oproepen naar append voegt toe aan de complexiteit, waardoor het gelijkwaardig is aan dat van uitbreiden, en aangezien de iteratie van verlenging in C is geïmplementeerd, zal het altijd sneller zijn als je van plan bent opeenvolgende items van een iterabele op een lijst toe te voegen.

Prestatie

Je kunt je afvragen wat meer presteert, omdat append gebruikt kan worden om hetzelfde resultaat te bereiken als verlengen. De volgende functies doen hetzelfde:

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

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

Dus laten we hen tijd:

import timeit

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

Een opmerking over de timing behandelen

Een commenter zei:

Perfect antwoord, ik mis gewoon de timing van het vergelijken van het toevoegen van slechts één element

Doe het semantisch correcte ding. Als u alle elementen in een iterabele wilt toevoegen, gebruikt u extend. Gebruik als u slechts één element toevoegt append.

Ok, dus laten we een experiment maken om te kijken hoe dit in de tijd werkt:

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

En we zien dat ons uiterste best doen om een ​​iterable te maken om gebruik te maken van extend, een (kleine) verspilling van tijd is:

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

We leren hiervan dat er niets is gewonnen van het gebruik ervan extend wanneer we alleen hebben een element om toe te voegen.

Ook zijn deze tijdstippen niet zo belangrijk. Ik laat ze gewoon zien dat het erop aan komt dat, in Python, het semantisch correcte doen de dingen doet Rechts Manier.

Het is denkbaar dat u de timing van twee vergelijkbare bewerkingen zou testen en een dubbelzinnig of omgekeerd resultaat zou krijgen. Concentreer u gewoon op het semantisch correcte doen.

Conclusie

We zien dat extend is semantisch duidelijker, en dat het veel sneller kan werken dan append, wanneer u elk element in een iterabele aan een lijst wilt toevoegen. 

Als u slechts één element (niet in een iterabele vorm) hebt om aan de lijst toe te voegen, gebruikt u append.


265
2018-01-23 22:44



append voegt een enkel element toe. extend voegt een lijst met elementen toe.

Houd er rekening mee dat als u een lijst doorgeeft om toe te voegen, deze nog steeds één element toevoegt:

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

92
2017-10-31 05:57



De volgende twee fragmenten zijn semantisch equivalent:

for item in iterator:
    a_list.append(item)

en

a_list.extend(iterator)

Dit laatste kan sneller zijn omdat de lus wordt geïmplementeerd in C.


42
2017-08-20 21:11



U kunt "+" gebruiken voor het retourneren van verlengen, in plaats van uit te breiden.

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]

evenzo += voor op zijn plaats gedrag, maar met kleine verschillen van append & extend. Een van de grootste verschillen van += van append en extend is wanneer het wordt gebruikt in functiebereiken, zie deze blog post.


29
2017-08-26 11:21



De methode append () voegt één item toe aan het einde van de lijst.

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

De methode extend () neemt één argument, een lijst en voegt elk van de items van het argument toe aan de oorspronkelijke lijst. (Lijsten worden geïmplementeerd als klassen.) "Het maken van" een lijst is echt een instantie van een klasse maken. Daarom heeft een lijst methoden die erop werken. "

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

Van Duik in Python.


29
2017-10-31 13:12



 Voeg toe vs. Extend

enter image description here

Met append kunt u een enkel element toevoegen dat de lijst zal uitbreiden:

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

Als u meer dan één element wilt uitbreiden, moet u extend gebruiken, omdat u slechts één element of één elementlijst kunt toevoegen:

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

Zodat u een geneste lijst krijgt

In plaats daarvan kunt u met een uitbreiding een enkel element als dit uitbreiden

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

Of, anders dan toevoegen, meer elementen in één keer uitbreiden zonder de lijst te nestelen in de originele (dat is de reden van de naamuitbreiding)

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

 Eén element toevoegen met beide methoden

enter image description here

 voeg 1 element toe

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

 een element uitbreiden

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

 Meer elementen toevoegen ... met verschillende resultaten

Als u append voor meer dan één element gebruikt, moet u een lijst met elementen als argumenten doorgeven en krijgt u een lijst met NIETS!

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

Met extend geef je in plaats daarvan een lijst door als argument, maar je krijgt een lijst met het nieuwe element die niet in de oude is genest.

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

Dus, met meer elementen, zult u extend gebruiken om een ​​lijst met meer items te krijgen. U gebruikt append om niet meer elementen aan de lijst toe te voegen, maar één element dat een geneste lijst is zoals u duidelijk kunt zien in de uitvoer van de code.

enter image description here

enter image description here


17
2017-10-18 07:33



append(object) - Werkt de lijst bij door een object aan de lijst toe te voegen.

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) - Essentieel concateneert twee lijsten.

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]

16
2018-05-12 19:51