Soru Python'da append ve extend liste yöntemleri arasındaki fark


Liste yöntemleri arasındaki fark nedir append() ve extend()?


2690
2017-10-31 05:55


Menşei




Cevaplar:


append: Sonunda nesneyi ekler.

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

sana verir: [1, 2, 3, [4, 5]]


extend: Yinelenen öğeler ekleyerek listeyi genişletir.

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

sana verir: [1, 2, 3, 4, 5]


4090
2017-10-31 06:02



Arasındaki fark nedir extend ve sadece yukarıdaki işleçte - ekleme operatörünü kullanarak x = x + [4, 5]? - Rohan
Aslında bir büyük fark - x + [4, 5] x'e atanan yeni bir liste verir - x.extend() Orijinal listeyi değiştirir. Buradaki cevabımı aşağıda detaylandırıyorum. - Aaron Hall♦


append listeye bir eleman ekler ve extend İlk listeyi başka bir listeyle birleştirir (veya başka bir yinelenebilir, mutlaka bir liste değildir.)

>>> 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']

itibaren Python'a dalın.


525
2017-10-31 05:57





Liste yöntemleri arasındaki fark nedir?

  • append argümanını listenin sonuna tek bir eleman olarak ekler. Listenin kendi uzunluğu bir artar.
  • extend listeyi genişleterek her öğeyi listeye ekleyerek argümanını yineler. Listenin uzunluğu, birçok elemanın yinelenen argümanında olmasına rağmen artacaktır.

append

list.append yöntem listenin sonuna bir nesne ekler.

my_list.append(object) 

Nesne ne olursa olsun, sayı, dizgi, başka bir liste veya başka bir şey olsun, sonuna eklenir. my_list Listede tek bir giriş olarak.

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

Yani bir liste bir nesne olduğunu unutmayın. Bir listeye başka bir liste eklerseniz, ilk liste, listenin sonunda tek bir nesne olacaktır (istediğiniz gibi olmayabilir):

>>> 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

list.extend yöntem yinelenen öğeler ekleyerek bir liste genişletir:

my_list.extend(iterable)

Uzatmak gerekirse, yinelenebilirliğin her öğesi listeye eklenir. Örneğin:

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

Bir dizenin yinelenebilir olduğunu unutmayın, bu nedenle bir dizeyi bir dizeyle genişletirseniz, her karakteri, dizenin üzerinde yinelediğiniz gibi eklersiniz (istediğiniz gibi olmayabilir):

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

Operatör Aşırı Yüklemesi, __add__, (+) ve __iadd__ (+=)

Her ikisi de + ve += operatörler için tanımlanmıştır list. Uzatmak için semantik olarak benzerler.

my_list + another_list bellekte üçüncü bir liste oluşturur, böylece sonucunu döndürebilirsiniz, ancak ikinci yinelenebilir listenin bir liste olmasını gerektirir.

my_list += another_list listeyi yerinde değiştirir olduğu yerinde operatör ve listeler, gördüğümüz gibi değişebilir nesnelerdir, bu yüzden yeni bir liste oluşturmaz. Aynı zamanda uzatma gibi çalışır, çünkü ikinci yinelenebilir her çeşit yinelenebilir olabilir.

Kafan almayın - my_list = my_list + another_list eşdeğer değildir += - my_list'e atanan yepyeni bir liste veriyor.

Zaman karmaşıklığı

Ekle sürekli zaman karmaşıklığıO (1).

Uzatmanın zaman karmaşıklığı vardır, O (k).

Birden fazla çağrı ile yineleme append karmaşıklığı arttırır, onu genişletir, ve uzatmanın yinelemesi C olarak uygulandığından, yinelenen öğeleri bir listeye eklemek isteyip istemediğinizden daha hızlı olacaktır.

performans

Daha fazla performansın ne olduğunu merak edebilirsiniz, çünkü eki uzatmakla aynı sonucu elde etmek için kullanılabilir. Aşağıdaki işlevler aynı şeyi yapar:

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

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

Öyleyse onlara zaman verelim:

import timeit

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

Zamanlamalarla ilgili bir yorumu adresleme

Bir yorumcu şunları söyledi:

Mükemmel cevap, sadece bir eleman ekleyerek karşılaştırmanın zamanlamasını özledim

Anlamsal olarak doğru olanı yapın. Tüm öğeleri yinelenebilir bir şekilde eklemek istiyorsanız, extend. Sadece bir öğe ekliyorsanız kullanın append.

Tamam, bunun zaman içinde nasıl çalıştığını görmek için bir deneme oluşturalım:

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

Ve sadece kullanım süresinin uzaması için yolumuzdan çıkmanın zamanın (küçük) bir zaman kaybı olduğunu görüyoruz:

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

Bundan öğrendik ki, kullanımdan kazanılan bir şey yok. extend sadece sahip olduğumuz zaman bir eklemek için öğe.

Ayrıca, bu zamanlamalar o kadar önemli değil. Ben sadece Python'da, semantik olarak doğru olan şeyi yapan şeylerin Sağ Yolu.

İki karşılaştırılabilir operasyonda zamanlamaları test edebileceğiniz ve belirsiz veya ters bir sonuç alacağınız düşünülebilir. Sadece semantik olarak doğru şeyi yapmaya odaklanın.

Sonuç

Bunu görüyoruz extend anlamsal olarak daha nettir ve daha hızlı çalışabilir append, her öğeyi yinelenebilir bir listeye eklemek istediğinizde. 

Listeye eklemek için yalnızca tek bir öğeniz varsa (yinelenemez durumda değil) append.


268
2018-01-23 22:44



Mükemmel cevap, sadece bir eleman ekleyerek karşılaştırmanın zamanlamasını özledim - David Sánchez
@Aaron Hall Zamanlama için algoritmada küçük bir yorum. "extend_one" bir listenin oluşturulmasından dolayı "biraz yanlış" zaman verebilir. Muhtemelen daha iyisi, öğeleri değişkenler olarak yaratmaktır.ex1 = 0 ve ex2 = [0]) ve daha katı olmak istiyorsanız, bu değişkenleri iletin. - ilias iliadis
Gerçekten mükemmel cevap. Performanstan ne haber l1 += l2 vs l1.extend(l2)? - Jean-Francois T.


append tek bir öğe ekler. extend öğelerin listesini ekler.

Eklemek için bir liste iletirseniz, hala bir öğe ekler unutmayın:

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

92
2017-10-31 05:57





Aşağıdaki iki snippet semantik olarak eşdeğerdir:

for item in iterator:
    a_list.append(item)

ve

a_list.extend(iterator)

İkincisi, döngü C'de uygulandığında daha hızlı olabilir.


42
2017-08-20 21:11



Uzatma, makinemde bir döngüde eklemeye kıyasla ~ 4x daha hızlıdır (sıfırlar 100 döngü için 16us vs 4us) - Alex L
extend() büyük ihtimalle preallocates append() Muhtemelen yok. - Mad Physicist


Uzatmak yerine uzatmak için "+" yı kullanabilirsiniz.

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]

benzer şekilde += yerinde davranış için, ancak küçük farklılıklar ile append & extend. En büyük farklılıklardan biri += itibaren append ve extend işlev kapsamlarında kullanıldığında, bkz. bu blog yazısı.


29
2017-08-26 11:21



Uzatmak için '+' kullanıldığında zaman karmaşıklığı üzerinde herhangi bir etkisi var mı? - franklin
@franklin, ayrıntılar için bu cevabı bakın: stackoverflow.com/a/28119966/2230844 - denfromufa
Bunun nasıl cevap verdiğini anlamıyorum - ppperry


Append () yöntemi, listenin sonuna tek bir öğe ekler.

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

Extend () yöntemi bir argüman, bir liste alır ve argüman öğelerinin her birini orijinal listeye ekler. (Listeler sınıflar olarak uygulanır. Bir liste oluşturmak "gerçekten bir sınıf oluşturmaktır. Bunun gibi, bir listede üzerinde çalışan yöntemler vardır.)

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

itibaren Python'a Dalış.


29
2017-10-31 13:12



Yinelenmediği için sadece 6 ile uzayamazsınız. Ve örneğindeki ikinci çıktı yanlış. 'abc' ifadesini, bunu ilettiğinizden beri tek bir öğe olarak eklenir extend tek elemanlı bir liste olarak ['abc']: [1, 2, 3, 4, 5, 'abc']. Örnek çıktınızı doğru yapmak için abc satırını şu şekilde değiştirin: x.extend('abc'). Ve kaldır x.extend(6) ya da x.extend([6]). - aneroid