Ce's diferența dintre lista de metode append () " și " extend()
?
append
adaugă un element la o listă, și "prelungească" concateneaza prima listă cu o altă listă (sau un alt iterable, nu neapărat o listă.)
>>> 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']
ceea Ce este diferența dintre lista de metode de a adăuga și de a extinde?
append
adaugă argumentul său ca un singur element la sfârșitul listei. Lungimea lista de sine va crește cu unul.append
Pe lista de asteptare.append` metoda adaugă un obiect la sfârșitul listei.
my_list.append(object)
Orice obiect este, dacă un număr, un șir, o altă listă, sau altceva, se adaugă pe la sfârșitul lui my_list
ca o singură intrare de pe lista.
>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']
Deci, ține cont de faptul că o listă este un obiect. Dacă adăugați o altă listă pe o listă, prima listă va fi un singur obiect la sfârșitul listei (care nu poate fi ceea ce vrei):
>>> 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.
Pe lista de asteptare.extinde metoda se extinde o listă prin adăugarea de elemente la o iterable:
my_list.extend(iterable)
Deci, cu prelungi, fiecare element al iterable devine adăugat pe listă. De exemplu:
>>> my_list
['foo', 'bar']
>>> another_list = [1, 2, 3]
>>> my_list.extend(another_list)
>>> my_list
['foo', 'bar', 1, 2, 3]
Păstrați în minte că un șir este o iterable, așa că, dacă vă extinde o listă cu un șir,'ll a adăuga fiecare personaj ca ai repeta peste șirul (care nu poate fi ceea ce vrei):
>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']
__add__
(+
) și __iadd__
(+=
)Ambele +
și +=
operatorii sunt definite de "listă". Acestea sunt semantic similare pentru a extinde.
my_list + another_list
creează o a treia listă în memorie, astfel încât vă puteți întoarce rezultatul de ea, dar se impune ca cel de-al doilea iterable fi o listă.
my_list += another_list
modifică lista în-loc (e e in-loc operator, iar listele sunt obiecte mutabile, ca ne-am'am vazut) deci nu crea o listă nouă. De asemenea, funcționează ca se extindă, în care cel de-al doilea iterable poate fi orice fel de iterable.
Don't obține confuz - my_list = my_list + another_list nu este echivalentă cu
+=` - acesta vă oferă un brand nou lista atribuite my_list.
Append a constanta de timp complexitatea, O(1).
Extinderea are complexitatea timp O(k).
Iterarea prin mai multe apeluri la append
adaugă la complexitatea, fiind echivalentă cu cea a extinde și de a extinde's iterație este implementat în C, acesta va fi întotdeauna mai repede dacă intenționați să adăugați elemente succesive de la o iterable pe o listă.
Poate vă întrebați ce este mult mai performant, deoarece append poate fi folosit pentru a ajunge la același rezultat ca și extinde. Următoarele funcții nu același lucru:
def append(alist, iterable):
for item in iterable:
alist.append(item)
def extend(alist, iterable):
alist.extend(iterable)
Deci sa's timp de ele:
import timeit
>>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz")))
2.867846965789795
>>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz")))
0.8060121536254883
Un comentator a spus:
răspuns Perfect, am doar pierdeți momentul de a compara adăugarea doar un element
Face semantic corect lucru. Dacă doriți să adăugați toate elementele într-un iterable, utilizați "prelungească". Daca're doar adăugând un element, utilizați append
.
Ok, deci sa's a crea un experiment pentru a vedea cum funcționează acest lucru în timp:
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
Și vom vedea că ieși din modul nostru de a crea un iterable doar să utilizați extinderea este o (minore) pierdere de timp:
>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295
Am învățat din asta că nu's nimic de câștigat din utilizarea "prelungească" atunci când avem doar o element pentru a adăuga.
De asemenea, aceste timpii nu sunt atât de importante. Sunt doar arată-le să subliniez că, în Python, face semantic corect lucru este să faci lucruri care Chiar Mod™.
L's de conceput că s-ar putea testa timpii pe două comparabile operațiuni și de a lua o ambigue sau invers rezultat. Doar se concentreze pe a face semantic corect lucru.
Vom vedea că "prelungească" este semantic mai clară, și care se poate rula mult mai rapid decât append
, atunci când intenționați să adăugați fiecare element într-o iterable la o listă.
Dacă aveți doar un singur element (nu într-un iterable) pentru a adăuga la listă, utilizați append
.
Adăugați vs Extinde
[![introduceți descrierea imaginii aici][1]][1] --- Cu adăugare puteți adăuga un singur element, care va extinde lista:
>>> a = [1,2]
>>> a.append(3)
>>> a
[1,2,3]
Dacă doriți să se extindă mai mult decât un singur element ar trebui să utilizați extinde, pentru că poți doar să adăugați un elment sau o listă de elemente:
>>> a.append([4,5])
>>> a
>>> [1,2,3,[4,5]]
Astfel încât veți obține o listă imbricată
În schimb, cu prelungi, puteți extinde un singur element astfel de prognoze
>>> a = [1,2]
>>> a.extend([3])
>>> a
[1,2,3]
Sau, altfel, de adăugare, extinde mai multe elemente într-un timp fără cuiburi lista în cel original (care'e motiv de numele extinde)
>>> a.extend([4,5,6])
>>> a
[1,2,3,4,5,6]
>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]
>>> x = [1,2]
>>> x.extend([3])
>>> x
[1,2,3,4]
Adăugarea de mai multe elemente... cu rezultate diferite
Dacă utilizați adăugare pentru mai mult de un element, trebuie să treacă o listă de elemente ca argumente și veți obține o listă IMBRICATĂ!
>>> x = [1,2]
>>> x.append([3,4])
>>> x
[1,2,[3,4]]
Cu extindă, în schimb, trece o listă ca un argument, dar veți obține o listă cu element nou, care nu este imbricat în cel vechi.
>>> z = [1,2]
>>> z.extend([3,4])
>>> z
[1,2,3,4]
Deci, cu mai multe elemente, va folosi extinde pentru a obține o listă cu mai multe elemente. Va folosi append, să nu adăugați mai multe elemente la lista, dar un element care este o listă imbricată după cum puteți vedea în mod clar în producția de cod.
Anii append()
metoda adaugă un singur element la sfârșitul listei.
x = [1, 2, 3]
x.append([4, 5])
x.append('abc')
print(x)
# gives you
[1, 2, 3, [4, 5], 'abc']
De extindere()` metoda are un argument, o listă, și adaugă fiecare dintre elementele de argument pentru a lista inițială. (Listele sunt puse în aplicare cât clase. "Crearea" o listă este instantierea unei clase. Ca atare, o listă a metodelor care operează pe ea.)
x = [1, 2, 3]
x.extend([4, 5])
x.extend('abc')
print(x)
# gives you
[1, 2, 3, 4, 5, 'a', 'b', 'c']
Puteți utiliza "+" pentru returnarea extinde, în loc de a extinde în loc.
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]
În mod similar +=
pentru în loc comportament, dar cu mici diferențe de la append
& se extind
. Una dintre cele mai mari diferențe de +=
de append
și "prelungească" este atunci când este folosit în funcție de domeniile de aplicare, a se vedea acest post pe blog.
append(obiect)
- Actualizează lista prin adăugarea unui obiect la lista.
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]]
extindere(lista)` - în Esență concatenează două liste.
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()
poate fi folosit cu un iterator argument. Aici este un exemplu. Doriți să faceți o listă dintr-o listă de liste de acest fel:
Din
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
vrei
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Puteți utiliza itertools.lanț.from_iterable()
să facă acest lucru. Această metodă's de ieșire este un iterator. Punerea sa în aplicare este echivalent cu
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
Înapoi la exemplul nostru, putem face
import itertools
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
merged = list(itertools.chain.from_iterable(list2d))
și a obține lista de dorit.
Aici este modul în echivalent extend()
poate fi folosit cu un iterator argument:
merged = []
merged.extend(itertools.chain.from_iterable(list2d))
print(merged)
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Acest lucru este echivalent cu a append
și se extind
folosind butonul " + " operator:
>>> 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(): Aceasta este, în principiu folosit în Python pentru a adăuga un element.
Exemplu 1:
>> a = [1, 2, 3, 4]
>> a.append(5)
>> print(a)
>> a = [1, 2, 3, 4, 5]
Exemplu 2:
>> a = [1, 2, 3, 4]
>> a.append([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, [5, 6]]
extend(): în cazul în Care extend(), este folosit pentru a uni două liste sau a introduce mai multe elemente într-o listă.
Exemplu 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]
Exemplu 2:
>> a = [1, 2, 3, 4]
>> a.extend([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, 5, 6]
Append adaugă toate datele dintr-o dată. Toate datele vor fi adăugate la nou create index. Pe de altă parte, "prelungească", după cum sugerează și numele, se extinde actuala gamă.
De exemplu
list1 = [123, 456, 678]
list2 = [111, 222]
Cu append
obținem:
result = [123, 456, 678, [111, 222]]
În timp ce pe "prelungească" vom obține:
result = [123, 456, 678, 111, 222]
Un punct de vedere interesant, care a fost lăsat să se înțeleagă, dar nu a explicat, este că extinderea este mai rapid decât append. Pentru orice buclă a adăuga în interiorul ar trebui să fie considerate a fi înlocuit de lista.extend(processed_elements).
Bear în minte că apprending elemente noi care ar putea duce la realloaction din toata lista la o mai bună locație din memorie. Dacă acest lucru se face de mai multe ori pentru că suntem adăugarea 1 element la un moment dat, performanța generală suferă. În acest sens, lista.extinderea este analog cu "".alăturați-vă(stringlist).
Un dicționar definește cuvintele append
și se extind
ca:
adăugare: adăugați (ceva) la sfârșitul unui document scris.
extinderea: face mai mari. Mări sau pentru a extinde
Cu aceste cunoștințe, acum las's a înțelege
append
și se extind
append
:
se extind
:
append
și se extind
Exemplu
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)
Sper să pot face un supliment util la această întrebare. Dacă lista memorează un anumit tip de obiect, de exemplu "Info", aici este o situație care "prelungească" metoda nu este potrivit: Într-o "pentru" buclă și și generează o "Info" obiect de fiecare dată și cu ajutorul "prelungească" pentru a stoca în lista dvs., acesta va eșua. Excepția este ca mai jos:
TypeError: 'Info' obiectul nu este iterable
Dar, dacă folosiți append
metoda, rezultatul este OK. Pentru că de fiecare dată folosind "prelungească" metoda, se va trata întotdeauna ca o listă sau orice alt tip de colectare, repeta ea, și puneți-l după lista anterioară. Un anumit obiect nu poate fi reiterat, evident.
Pentru a le distinge în mod intuitiv
l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]
L's place " l1 " reproduce un organism în interiorul corpului(imbricate).
# Reset l1 = ['a', 'b', 'c']
l1.extend(l2)
l1
['a', 'b', 'c', 'd', 'e', 'f']
L's place că două persoane separate căsători și de a construi o familie unită.
În afară de asta aș face o exhaustivă cheatsheet de toate lista's metode de referință.
list_methods = {'Add': {'extend', 'append', 'insert'},
'Remove': {'pop', 'remove', 'clear'}
'Sort': {'reverse', 'sort'},
'Search': {'count', 'index'},
'Copy': {'copy'},
}
extindere(L)` se extinde lista prin adăugarea de toate elementele din lista dată "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]
append
"se extinde" listă (în locul) de doar un singur element, singur obiect trecut (ca argument).
"prelungească" "se extinde" listă (în locul) de ca multe elemente cum obiectul a trecut (ca argument) conține.
Acest lucru poate fi ușor confuz pentru str
obiecte.
append
va adăuga un singur șir element la sfârșitul dar
"prelungească" se va adăuga cât mai multe "simplu" 'str' elemente ca lungimea acestui șir.append
va adăuga încă o singur 'list' element la sfârșitul și
"prelungească" se va adăuga cât mai multe 'list' elemente ca lungimea de trecut pe lista.def append_o(a_list, element): a_list.append(element) print('adaugă:', end = ' ') pentru element în a_list: print(obiect, scop = ',') print()
def extend_o(a_list, element): a_list.extend(element) print('extinderea:', end = ' ') pentru element în a_list: print(obiect, scop = ',') 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'])
produce:
append: ab,cd,
extend: ab,c,d,
append: ab,['cd', 'ef'],
extend: ab,cd,ef,
append: ab,['cd'],
extend: ab,cd,
Adăugați și extindă sunt unul dintre mecanismele de extensibilitate în python.
Adăugare: Adaugă un element la sfârșitul listei.
my_list = [1,2,3,4]
Pentru a adăuga un nou element la lista, putem folosi append metoda în felul următor.
my_list.append(5)
Locația implicită că noul element va fi adăugat este întotdeauna în (lungime+1) poziția.
Insert: insert metodă a fost folosită pentru a depăși limitările de adăugare. Cu insert, putem defini în mod explicit poziția exactă vrem element nou să fie introdus.
Metoda descriptor de a introduce(index, object). Este nevoie de două argumente, primul fiind indicele dorim sa inseram elementul nostru și al doilea element în sine.
Example: my_list = [1,2,3,4]
my_list[4, 'a']
my_list
[1,2,3,4,'a']
Extinde: Acest lucru este foarte util atunci când vrem să se alăture două sau mai multe liste într-o singură listă. Fără a extinde, dacă vrem să se alăture două liste, obiectul rezultat va conține o listă de liste.
a = [1,2]
b = [3]
a.append(b)
print (a)
[1,2,[3]]
Dacă vom încerca pentru a accesa elementul de la pos 2, vom obține o listă ([3]), în loc de element. Să se alăture două liste, am'll trebuie să utilizați adăugare.
a = [1,2]
b = [3]
a.extend(b)
print (a)
[1,2,3]
Să se alăture mai multe liste
a = [1]
b = [2]
c = [3]
a.extend(b+c)
print (a)
[1,2,3]