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

append: Sonuna nesne ekler.

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

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

extend: Yinelenebilir öğeden öğeler ekleyerek listeyi genişletir.

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

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

appendlisteye bir öğe ekler ve extendilk listeyi başka bir listeyle (ya da mutlaka bir liste değil başka bir listeyle) birleştirir.

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

Eklenen ve genişletilen liste yöntemleri arasındaki fark nedir?

• appendargümanını listenin sonuna tek bir öğe olarak ekler. Listenin kendisi birer birer artacaktır.
• extendher öğeyi listeye ekleyerek argümanını yineleyerek listeyi genişletir. Listenin uzunluğu artacak, ancak birçok unsur yinelenebilir argümandaydı.

append

list.appendYöntem listesinin sonuna bir nesne ekler.

my_list.append(object) 

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

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

Bu nedenle bir listenin bir nesne olduğunu unutmayın. Listeye başka bir liste eklerseniz, ilk liste listenin sonunda tek bir nesne olacaktır (bu sizin istediğiniz şey olmayabilir):

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

list.extendYöntem, bir iterable öğeleri iliştirerek bir listesini uzanır:

my_list.extend(iterable)

Böylece, genişletilebildiğinde, yinelenebilir öğelerin her bir öğ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 dizeyle bir listeyi genişletirseniz, her karakteri dizenin üzerinde yinelediğinizde eklersiniz (bu istediğiniz şey olmayabilir):

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

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

Hem +ve +=operatörler için tanımlanmıştır list. Anlamsal olarak uzantıya benzerler.

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

my_list += another_listdeğiştirir liste yerinde (o olduğunu yerinde operatörü ve biz gördüğümüz gibi listeler, değişken nesnelerdir) yeni bir liste oluşturmaz böylece. Aynı zamanda uzatmak gibi çalışır, çünkü ikinci yinelenebilir her türlü yinelenebilir olabilir.

Kafanız karışmasın - my_list = my_list + another_listeşdeğer değildir +=- size listeme atanan yepyeni bir liste verir.

Zaman Karmaşıklığı

Apend sabit zaman karmaşıklığına sahiptir , O (1).

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

appendKarmaşıklığa katkıda bulunmak için birden fazla çağrıda yineleme yaparak, genişletmeye eşdeğer hale getirir ve ext'in yinelemesi C'de uygulandığından, yinelenen öğelerden bir listeye ardışık öğeler eklemeyi düşünüyorsanız her zaman daha hızlı olacaktır.

Verim

Neyin daha iyi performans gösterdiğini merak edebilirsiniz, çünkü ek, genişletme ile 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 ayıralım:

import timeit

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

Zamanlamalarla ilgili bir yorumun ele alınması

Bir yorumcu şunları söyledi:

Mükemmel cevap, sadece bir eleman eklemenin zamanlamasını kaçırıyorum

Anlamsal olarak doğru olanı yapın. Tüm öğeleri yinelemeye eklemek istiyorsanız, kullanın extend. Yalnızca bir öğe ekliyorsanız, kullanın append.

Tamam, şimdi bunun nasıl çalıştığını görmek için bir deney 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 uzatmak için bir yinelenebilir yaratma yolumuzdan çıkmanı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

Buradan , eklenecek extendtek bir elementimiz olduğunda kullanmaktan elde edilen hiçbir şey olmadığını öğreniyoruz .

Ayrıca, bu zamanlamalar o kadar önemli değildir. Onlara sadece Python'da anlamsal olarak doğru olanı yapmanın işleri Doğru Yol ™ yapmak olduğunu göstermelerini sağlıyorum.

İki karşılaştırılabilir işlemde zamanlamaları test edebileceğiniz ve belirsiz veya ters bir sonuç alabileceğiniz düşünülebilir. Sadece anlamsal olarak doğru olanı yapmaya odaklanın.

Sonuç

Biz görüyoruz extendçok daha hızlı daha çalışabilir anlamsal nettir ve bu append, bir listeye bir iterable her eleman eklemek niyetinde zaman.

Listeye eklemek için yalnızca tek bir öğeniz (yinelenebilir olmayan bir öğe) varsa kullanın append.

appendtek bir öğe ekler. extendöğelerin bir listesini ekler.

Eklemek için bir liste iletirseniz, listenin yine de bir öğe eklediğini unutmayın:

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

Ekle ve Uzat

Append ile listeyi genişletecek tek bir öğe ekleyebilirsiniz:

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

Birden fazla öğeyi genişletmek istiyorsanız, genişletmeyi kullanmalısınız, çünkü yalnızca bir öğe veya bir öğe listesi ekleyebilirsiniz:

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

Böylece iç içe bir liste elde edersiniz

Bunun yerine genişletme ile, bunun gibi tek bir öğeyi genişletebilirsiniz

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

Ya da, farklı bir şekilde, listeden orijinal listeye yerleştirmeden bir defada daha fazla öğe uzatın (adın genişlemesinin nedeni budur)

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

Her iki yöntemle de bir öğe ekleme

Hem ekleme hem de genişlet, listenin sonuna bir öğe ekleyebilir, ancak ekleme daha basittir.

1 öğe ekle

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

bir elemanı genişlet

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

Daha fazla öğe ekleniyor ... farklı sonuçlarla

Birden çok öğe için append komutunu kullanırsanız, bir öğe listesini bağımsız değişken olarak iletmeniz gerekir ve bir NESTED listesi alırsınız!

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

Bunun yerine, ext ile bir listeyi bağımsız değişken olarak iletirsiniz, ancak yeni öğeyle eskisinde iç içe olmayan bir liste alırsınız.

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

Böylece, daha fazla öğe ile, daha fazla öğe içeren bir liste almak için ext uzantısını kullanırsınız. Bununla birlikte, bir listenin eklenmesi listeye daha fazla öğe eklemez, kodun çıktısında açıkça görebileceğiniz gibi iç içe bir liste olan bir öğe ekler.

Aşağıdaki iki parçacık semantik olarak eşdeğerdir:

for item in iterator:
    a_list.append(item)

ve

a_list.extend(iterator)

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

append()Yöntem 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öntem bir argüman, bir liste alır ve orijinal listeye Tartışmanın öğelerin her ekler. (Listeler sınıflar olarak uygulanır. “Oluşturma” bir liste gerçekten bir sınıfı başlatır. Bu nedenle, listenin ü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']

Gönderen Dive Into the Python .

Uzatmayı döndürmek için yerinde genişletmek yerine "+" 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 append& ile küçük farklılıklar extend. En büyük farklardan biri +=itibaren appendve extendbunun fonksiyon kapsamları kullanıldığında, bunun için bakınız bu blog yazısı .

append(object) - Listeye bir nesne ekleyerek listeyi günceller.

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) - Esasen iki listeyi birleştirir.

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()yineleyici argümanı ile kullanılabilir. İşte bir örnek. Liste listesinden şu şekilde bir liste yapmak istiyorsunuz:

itibaren

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

İstediğiniz

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

Bunu itertools.chain.from_iterable()yapmak için kullanabilirsiniz . Bu yöntemin çıktısı bir yineleyicidir. Uygulanması

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

Örneğimize geri dönebiliriz

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

ve istenen listeyi alın.

extend()Yineleyici bir argümanla eşdeğer olarak nasıl kullanılabilir:

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

Bu, operatöre eşdeğerdir appendve operatörü extendkullanır +:

>>> 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 () : Temel olarak Python'da bir öğe eklemek için kullanılır.

Örnek 1:

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

Örnek 2:

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

expand () : expand (), iki listeyi birleştirmek veya bir listeye birden çok öğe eklemek için kullanılır.

Örnek 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]

Örnek 2:

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

Bahsedilen, ancak açıklanmayan ilginç bir nokta, genişlemenin sonuna göre daha hızlı olmasıdır. İçine eklenen herhangi bir döngü için list.extend (işlenmiş_elemeler) ile değiştirilmelidir.

Yeni öğelerin eklenmesinin tüm listenin bellekte daha iyi bir konuma yeniden değerlendirilmesine neden olabileceğini unutmayın. Bu, bir kerede 1 öğe eklediğimiz için birkaç kez yapılırsa, genel performans düşer. Bu anlamda list.extend, "" .join (dize listesi) ile benzerdir.

Ekle, tüm verileri bir kerede ekler. Verilerin tamamı yeni oluşturulan dizine eklenir. Öte yandan, extendadından da anlaşılacağı gibi, geçerli diziyi genişletir.

Örneğin

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

İle appendbiz olsun:

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

Devam ederken extend:

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

Bir İngiliz sözlük kelimeleri tanımlar appendve extendgibidir:

append : yazılı bir belgenin sonuna (bir şey) ekleyin.
uzatmak . Büyüt veya genişlet

Bu bilgi ile, şimdi anlayalım

1) ve arasındaki farkappendextend

append:

• Herhangi bir Python nesnesini listenin sonuna olduğu gibi ekler (örn. Listedeki son öğe olarak).
• Sonuçta ortaya çıkan liste iç içe olabilir ve heterojen öğeler içerebilir (örn. Liste, dize, grup, sözlük, küme vb.)

extend:

• Herhangi Kabul iterable onun argüman olarak ve liste yapar daha büyük .
• Ortaya çıkan liste her zaman tek boyutlu bir listedir (yani iç içe geçme yok) ve uygulama sonucunda içinde heterojen öğeler (örn. Karakterler, tamsayılar, kayan nokta) içerebilir list(iterable).

2) ve arasındaki benzerlikappendextend

• Her ikisi de tam olarak bir argüman alır.
• Her ikisi de listeyi yerinde değiştirir .
• Sonuç olarak, her ikisi de geri döner None.

Misal

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)

Umarım bu soruya faydalı bir ek yapabilirim. Listeniz belirli bir tür nesnesini saklıyorsa, örneğin Info, extendyöntemin uygun olmadığı bir durum söz konusudur: Bir fordöngüde ve ve Infoher seferinde bir nesne oluşturup extendlistenizde saklamak için kullanıldığında başarısız olur. İstisna aşağıdaki gibidir:

TypeError: 'Info' nesnesi yinelenemez

Ancak appendyöntemi kullanırsanız , sonuç TAMAM. Çünkü extendyöntemi her kullandığında , onu her zaman bir liste veya başka bir koleksiyon türü olarak ele alacak, yineleyecek ve bir önceki listenin arkasına yerleştirecektir. Belli bir nesne açık bir şekilde yinelenemez.

Onları sezgisel olarak ayırt etmek

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

l1Vücudunun içinde (iç içe) bir beden üretmek gibi .

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

Ayrılmış iki kişinin evlenmesi ve birleşik bir aile kurması gibi.

Ayrıca, referans için tüm listenin yöntemlerini kapsamlı bir hile sayfası yapıyorum.

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

extend(L)verilen listedeki tüm öğeleri ekleyerek listeyi genişletir 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]

appendListeyi (yerinde) yalnızca tek bir öğe ile "genişletir", tek nesne geçti (bağımsız değişken olarak).

extendListeyi (yerinde), iletilen nesnenin (bağımsız değişken olarak) içerdiği kadar öğe kadar "genişletir" .

Bu strnesneler için biraz kafa karıştırıcı olabilir .

1. Bir dizeyi bağımsız değişken olarak iletirseniz: appendsonuna tek bir dize öğesi ekler ancak extend ekler, bu dizenin uzunluğu kadar "tek" "str" ​​öğesi ekler.
2. Bir dize listesini bağımsız değişken olarak iletirseniz: appendyine de sonunda tek bir 'liste' öğesi extendeklenir ve iletilen listenin uzunluğu kadar çok sayıda 'liste' öğesi eklenir.

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

üretir:

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

Ekleme ve genişletme, python'daki genişletilebilirlik mekanizmalarından biridir.

Ekle: Listenin sonuna bir öğe ekler.

my_list = [1,2,3,4]

Listeye yeni bir öğe eklemek için append yöntemini aşağıdaki şekilde kullanabiliriz.

my_list.append(5)

Yeni öğenin ekleneceği varsayılan konum her zaman (uzunluk + 1) konumundadır.

Ekleme: Ekleme sınırlamalarının üstesinden gelmek için ekleme yöntemi kullanıldı. Insert ile, yeni öğemizin eklenmesini istediğimiz kesin konumu açıkça tanımlayabiliriz.

Eklemenin yöntem tanımlayıcısı (dizin, nesne). İki argüman alır, birincisi elementimizi eklemek istediğimiz endeks ve ikincisi elementin kendisidir.

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

Uzat: Bu, iki veya daha fazla listeyi tek bir listeye katılmak istediğimizde çok kullanışlıdır. Uzatma olmadan, iki listeye katılmak istiyorsak, ortaya çıkan nesne bir liste listesi içerecektir.

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

Eleman 2'de öğeye erişmeye çalışırsak, eleman yerine bir liste ([3]) alırız. İki listeye katılmak için append kullanmamız gerekecek.

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

Birden çok listeye katılmak için

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