Skirtumas tarp sąrašo pridėjimo ir išplėtimo „Python“

Koks skirtumas tarp append() ir extend() sąrašo metodų?

2947
31 окт. Claudiu nustatytas spalio 31 d 2008-10-31 08:55 '08, 08:55, 2008-10-31 08:55
@ 28 atsakymai

append : prideda objektą iki galo.

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

suteikia: [1, 2, 3, [4, 5]]


extend : extend sąrašą įtraukiant elementus iš iterable.

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

suteikia jums: [1, 2, 3, 4, 5]

4423
31 окт. atsakymas, kurį pateikė kender 31 okt. 2008-10-31 09:02 '08 at 9:02 am 2008-10-31 09:02

append įtraukia elementą į sąrašą ir extend pirmąjį sąrašą su kitu sąrašu (arba kitu iterable, nebūtinai sąrašu).

 >>> 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', 2]] >>> 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'] 
border=0

Nuo panardinimo į Python .

556
31 окт. atsakymą pateikė Harley Holcombe spalio 31 d. 2008-10-31 08:57 '08 at 8:57 2008-10-31 08:57

Koks skirtumas tarp sąrašo pridėjimo ir išplėtimo?

  • append prideda savo argumentą kaip atskirą elementą sąrašo pabaigoje. Pats sąrašo ilgis padidės vienu.
  • extend nurodo jo argumentą, pridedant kiekvieną elementą į sąrašą, plečiant sąrašą. Sąrašo ilgis padidės, nesvarbu, kiek elementų yra iteruotame argumente.

append

list.append metodas įtraukia objektą į sąrašo pabaigą.

 my_list.append(object) 

Nepriklausomai nuo objekto, ar tai būtų numeris, eilutė, kitas sąrašas, ar kitas, jis įtraukiamas į mano my_list kaip atskiras įrašas sąraše.

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

Taigi atminkite, kad sąrašas yra objektas. Jei į sąrašą įtraukiate kitą sąrašą, pirmasis sąrašas bus vienas objektas sąrašo pabaigoje (tai gali būti ne tas, ko norite):

 >>> 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.extend metodas išplečia sąrašą įtraukdamas elementus iš pakartotinio:

 my_list.extend(iterable) 

Taigi, plečiant, kiekvienas pakartotinio elemento elementas pridedamas prie sąrašo. Pavyzdžiui:

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

Turėkite omenyje, kad eilutė yra kartotinė, todėl, jei išplėsite sąrašą su eilute, pridedate kiekvieną eilutės iteracijos proceso simbolį (kuris gali neatitikti jūsų noro):

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

Operatoriaus perkrova, __add__ ( + ) ir __iadd__ ( += )

+ Ir += operatoriai yra apibrėžti list . Jie yra semantiškai panašūs į plėtinį.

my_list + another_list sukuria trečiąjį atmintyje esantį sąrašą, kad galėtumėte grąžinti savo rezultatą, tačiau tam reikia antros my_list + another_list .

my_list += another_list pakeičia sąrašą (tai yra operatorius, ir sąrašai, kaip matėme, yra modifikuojami objektai), todėl jis nesukuria naujo sąrašo. Jis taip pat veikia kaip pratęsimas, nes antrasis iteravimas gali būti bet koks kartojimas.

Ne my_list = my_list + another_list - my_list = my_list + another_list nėra lygiavertis += - jis suteikia naują sąrašą, priskirtą mano_listui.

Laiko sudėtingumas

Add turi pastovaus laiko sudėtingumą , O (1).

Pratęsimas turi laikiną sudėtingumą, O (k).

Iteravimas per kelis pridedamus skambučius prideda sudėtingumą, todėl jį prilygsta plėtiniui, ir kadangi pratęsimo iteracija įgyvendinama C, visada bus greičiau, jei ketinate pridėti eilės elementus iš iteracijos į sąrašą.

Našumas

Jums gali būti įdomu, kas yra produktyvesnė, nes priedą galima naudoti norint pasiekti tą patį rezultatą kaip plėtinys. Šios funkcijos atliekamos taip pat:

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

Taigi leiskite jiems laiku

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

Atsižvelgiant į laiko komentarą

Komentatorius sakė:

Puikus atsakymas, aš tiesiog negaliu palyginti laiko pridėti tik vieną elementą.

Atlikite semantiškai teisingą dalyką. Jei norite pridėti visus iteruotus elementus, naudokite extend . Jei paprasčiausiai pridedate vieną elementą, naudokite priedą.

Taigi, sukurkime eksperimentą, kad pamatytume, kaip tai veikia laiku:

 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 

Ir matome, kad būdas, kaip sukurti paprastą paprasto plėtinio naudojimą, yra (nedidelis) laiko švaistymas:

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

Iš to mes sužinosime, kad niekas nepasinaudojo extend kai turime tik vieną elementą.

Be to, šios sąlygos nėra tokios svarbios. Aš tiesiog jiems parodysiu, kad tai pabrėžė, jog Pythone, atlikdamas semantiškai teisingus dalykus, viskas vyksta teisingai.

Gali būti, kad galite išbandyti dviejų panašių operacijų laiką ir gauti dviprasmišką ar atvirkštinį rezultatą. Tiesiog sutelkkite dėmesį į tai, kad atliksite semantiškai teisingą.

Išvada

Mes matome, kad extend semantiškai aiškesnis ir kad jis gali būti įvykdytas daug greičiau nei append , kai ketinate pridėti kiekvieną elementą į sąrašą, kuris bus kartojamas.

Jei turite tik vieną elementą (neįtrauktas į iteraciją), kad pridėtumėte prie sąrašo, naudokite komandą „ append .

333
24 янв. Atsakymą pateikė Aaron Hall 24 d. 2015-01-24 01:44 '15 ne 1:44 2015-01-24 01:44

Ir šiame kontekste taip pat gerai prisiminti, kad stygos taip pat yra pasikartojančios.

 >>> a = [1, 2] >>> a [1, 2] >>> a.extend('hey') >>> a [1, 2, 'h', 'e', 'y'] 
250
04 нояб. Atsakymas pateikiamas tatsujin 04 lapkričio. 2008-11-04 18:19 '08, 18:19, 2008-11-04 18:19

pridedamas vienas elementas. extend prideda elementų sąrašą.

Pastaba: jei pateikiate sąrašą, kurį norite pridėti, jis prideda kitą elementą:

 >>> a = [1, 2, 3] >>> a.append([4, 5, 6]) >>> a [1, 2, 3, [4, 5, 6]] 
105
31 окт. Greg Hewgill atsakymas spalio 31 d 2008-10-31 08:57 '08 at 8:57 2008-10-31 08:57

Šie du fragmentai yra semantiškai ekvivalentiški:

 for item in iterator: a_list.append(item) 

ir

 a_list.extend(iterator) 

Pastarasis gali būti greitesnis, nes ciklas yra įgyvendinamas C.

51
21 авг. atsakymas suteiktas Erikui 21 rug. 2012-08-21 00:11 '12 12:11 am 2012-08-21 00:11

Priedo () metodas į sąrašą įtraukia vieną elementą.

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

Metodas išplėsti () naudoja vieną argumentą, sąrašą ir prideda kiekvieną argumento elementą į pradinį sąrašą. (Sąrašai įgyvendinami kaip klasės. „Sukurti“ sąrašas iš tikrųjų yra klasės egzempliorius, todėl sąraše yra su juo susiję metodai.)

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

Nuo panardinimo į Python .

36
31 окт. CodyChan atsakymas, pateiktas spalio 31 d. 2013-10-31 16:12 '13, 16:12, 2013-10-31 16:12

Galite naudoti „+“, kad sugrįžtumėte, o ne išplėsti vietoje.

 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] 

Panašus į += vietiniam elgesiui, bet su nedideliais skirtumais nuo append ir extend . Vienas iš didžiausių skirtumų += nuo append ir extend yra tada, kai jis naudojamas funkcijų srityje, žr. Šį dienoraščio įrašą .

35
26 авг. atsakymas duotas denfromufa 26 rug . 2013-08-26 14:21 '13, 14:21, 2013-08-26 14:21

Pridėti ir atnaujinti

2019

18 окт. Giovanni Gianni atsakymas 18 okt. 2017-10-18 10:33 '17 10:33 2017-10-18 10:33

append(object) - atnaujina sąrašą įtraukdamas į sąrašą objektą.

 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) - iš esmės sujungia du sąrašus.

 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 length is 4 print(x) [20, 21, 22, 23] 
20
12 мая '13 в 22:51 2013-05-12 22:51 atsakymą įteikė Čaitanja gegužės 13 d. 13 val. 10:51 2013-05-12 22:51

extend() galima naudoti su iteratoriaus argumentu. Čia yra pavyzdys. Jūs norite sudaryti tokių sąrašų sąrašą:

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

norite

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

Tam galite naudoti itertools.chain.from_iterable() . Šis metodas yra iteratorius. Jos įgyvendinimas yra lygiavertis

 def from_iterable(iterables): # chain.from_iterable(['ABC', 'DEF']) --> ABCDEF for it in iterables: for element in it: yield element 

Grįžkime prie mūsų pavyzdžio, mes galime padaryti

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

ir gaukite norimą sąrašą.

Štai kaip lygiavertis extend() gali būti naudojamas su iteratoriaus argumentu:

 merged = [] merged.extend(itertools.chain.from_iterable(list2d)) print(merged) >>> [1, 2, 3, 4, 5, 6, 7, 8, 9] 
19
12 мая '13 в 21:21 2013-05-12 21:21 atsakymas pateikiamas gruodžio 12 d. 13 val. 21:21 2013-05-12 21:21

Tai prilygsta append ir extend naudojant + operatorių:

 >>> 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]] 
17
08 июля '14 в 15:42 2014-07-08 15:42 atsakymas pateikiamas skdev75 liepos 8 d. 14, 15:42 2014-07-08 15:42

pridėti () . Jis daugiausia naudojamas „Python“, kad pridėtų vieną elementą.

1 pavyzdys:

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

2 pavyzdys:

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

išplėsti () : kai plėtinys () naudojamas dviems sąrašams sujungti arba įterpti kelis elementus į vieną sąrašą.

1 pavyzdys:

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

2 pavyzdys:

 >> a = [1, 2, 3, 4] >> a.extend([5, 6]) >> print(a) >> a = [1, 2, 3, 4, 5, 6] 
15
13 июня '16 в 13:17 2016-06-13 13:17 Atsakymą pateikia „Gr8 Adakron“ birželio 16 d. 13:17 2016-06-13 13:17

Įdomus taškas, kuris užsiminė, bet nepaaiškino, yra tai, kad plėtra yra greitesnė nei pridėti. Jei norite, kad bet kokia kilpa, kuri prideda viduje, apsvarstys galimybę pakeisti „list.extend“ (processing_elements).

Atminkite, kad naudojant naujus elementus, visas sąrašas bus perskirstytas geriausioje atminties vietoje. Jei tai daroma kelis kartus, nes vienu metu pridedame 1 elementą, bendras našumas kenčia. Šia prasme list.extend yra panašus į.

12
05 авг. atsakymas duotas bconstanzo 05 rug . 2014-08-05 19:58 '14, 19:58, 2014-08-05 19:58

Pridėti prideda visus duomenis vienu metu. Visi duomenys bus įtraukti į naujai sukurtą indeksą. Kita vertus, extend , kaip rodo pavadinimas, išplečia dabartinę masyvą.

Pavyzdžiui

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

Su append gauname:

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

extend mes gauname:

 result = [123, 456, 678, 111, 222] 
11
16 окт. atsakymą Shiv pateikė spalio 16 d. 2014-10-16 09:49 '14 at 9:49 2014-10-16 09:49

Anglų kalbos žodynas apibrėžia append ir extend kaip:

pridėti : pridėkite (kažką) rašytinio dokumento pabaigoje.
išplėsti : daugiau. Padidinti arba padidinti


Suprasdami šias žinias, suprasime

1) Skirtumas tarp append ir extend

append :

  • Prideda bet kokį Python objektą, kaip jis yra sąrašo pabaigoje (t.y., kaip ir paskutinis sąrašo elementas).
  • Gautas sąrašas gali būti įterptas ir juose gali būti heterogeninių elementų (pvz., Sąrašas, eilutė, eilutė, žodynas, rinkinys ir tt),

extend :

  • Priima bet kokią reikšmę kaip argumentą ir padidina sąrašą.
  • Gautas sąrašas visada yra vienas matmenų sąrašas (t. Y. „Ne lizdavimas“), ir jame gali būti heterogeninių elementų (pavyzdžiui, simboliai, sveikieji skaičiai, plaukiojimas), taikydami list(iterable) .

2) append ir extend panašumas

  • Abu jie turi vieną argumentą.
  • Abu pakeitimai keičiami.
  • Dėl to abi sugrįžta None .

pavyzdys

 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 lis.append(object) 
5
30 дек. atsakymas pateikiamas kmario23 30 dec. 2017-12-30 21:38 '17 21:38 2017-12-30 21:38
 list1 = [1,2,3,4,5] list2 = ["a","b","c","d","e"] 

Pridėkite:

 print list.append(list2) 

: [1,2,3,4,5, ["a", "b", "c", "d", "e"]]

išplėsti:

 print list1.extend(list2) 

: [1,2,3,4,5, "a", "b", "c", "d", "e"]

4
18 сент. Atsakymą pateikė Neeraj Sharma 18 sep. 2014-09-18 22:19 '14, 10:19 val. 2014-09-18 22:19

Tikiuosi, kad galiu padaryti naudingą papildymą šiam klausimui. Jei jūsų sąraše yra tam tikro tipo objektas, pvz., „ Info , tada situacija, kai extend metodas netinka: „ for kilpoje ir kiekvieną kartą, kai jis sukuria „ Info objektą ir naudoja extend kad jį išsaugotų savo sąraše, jis nepavyks. Išimtis yra tokia:

TypeError: „Info“ objekto nėra

Bet jei naudojate append metodą, rezultatas bus gerai. Kadangi kiekvieną kartą naudojant extend metodą, jis visada laikys jį sąrašu ar bet kokiu kitu kolekcijos tipu, pakartokite jį ir padėkite po ankstesnio sąrašo. Akivaizdu, kad konkretus objektas negali būti kartojamas.

4
11 февр. Atsakymas pateikiamas Crabime 11 vasario mėn. 2017-02-11 04:59 '17 ne 4:59 2017-02-11 04:59

Pridėti žodyną į kitą:

 >>>def foo(): dic = {1:'a', 2:'b', 3:'c', 4:'a'} newdic = {5:'v', 1:'aa'} for i in dic.keys(): if not newdic.has_key(dic[i]): newdic[i] = dic[i] print "Appended one:", newdic >>>foo() Appended one: {1: 'a', 2: 'b', 3: 'c', 4: 'a', 5: 'v'} 
4
17 авг. atsakymas pateikiamas Sanyal 17 rug. 2015-08-17 15:02 '15 15:02 2015-08-17 15:02

„Pridėkite“ metodas prideda jo parametrą kaip vieną elementą sąraše, o „išplėsti“ gauna sąrašą ir prideda jo turinį.

Pavyzdžiui

ištiesti

  letters = ['a', 'b'] letters.extend(['c', 'd']) print(letters) # ['a', 'b', 'c', 'd'] 

pridėti

  letters.append(['e', 'f']) print(letters) # ['a', 'b', 'c', 'd', ['e', 'f']] 
3
31 авг. atsakymas pateikiamas Viraj Kaulkar 31 d. 2016-08-31 20:55 '16 at 8:55 pm 2016-08-31 20:55

Skirti juos intuityviai

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

Taip l1 atkuria kūną savo kūno viduje.

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

Tarsi šie du atskiri žmonės susituoktų ir statytų vieną šeimą.

Be to, aš visapusiškai apžvelgiu visus sąrašo metodus.

 list_methods = {'Add': {'extend', 'append', 'insert'}, 'Remove': {'pop', 'remove', 'clear'} 'Sort': {'reverse', 'sort'}, 'Search': {'count', 'index'}, 'Copy': {'copy'}, } 
2
04 дек. Atsakymą pateikė JawSaw, gruodžio 4 d. 2017-12-04 13:17 '17, 13:17 pm 2017-12-04 13:17

Tai padėjo suprasti, kas iš tikrųjų atsitinka, kai naudojate append ir extend

 a = [[1,2,3],[4,5,6]] print(a) >>> [[1, 2, 3], [4, 5, 6]] a.append([6,7,8]) print(a) >>> [[1, 2, 3], [4, 5, 6], [6, 7, 8]] a.extend([0,1,2]) print(a) >>> [[1, 2, 3], [4, 5, 6], [6, 7, 8], 0, 1, 2] a=a+[8,9,10] print(a) >>> [[1, 2, 3], [4, 5, 6], [6, 7, 8], 0, 1, 2, 8, 9, 10] 
0
20 июля '18 в 20:04 2018-07-20 20:04 atsakymą pateikė „ Missnomer“ liepos 20 d., 18 val. 8:04 val. 2018-07-20 20:04

Priedo () metodas prideda jam perduotą argumentą kaip atskirą elementą.

pratęsimas () pasikartos per perduotus argumentus ir išplečia sąrašą, perduodamas pakartotinai kiekvieną elementą, iš esmės jis prideda kelis elementus be pridėto skaičiaus kaip vieno.

 list1 = [1,2,3,4,5] list2 = [6,7,8] list1.append(list2) print(list1) #[1,2,3,4,5,[6,7,8]] list1.extend(list2) print(list1) #[1,2,3,4,5,6,7,8] 
0
21 окт. atsakymas, kurį pateikė PythonLover 21 spalis 2018-10-21 23:34 '18, 11:34 pm 2018-10-21 23:34

išplėsti (L) sąrašą, pridedant visus šio sąrašo elementus 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] 
0
31 авг. atsakymas pateikiamas tessie 31 d. 2016-08-31 21:14 '16 at 21:14 2016-08-31 21:14

Pridėti: įtraukia argumentą kaip atskirą elementą į sąrašo pabaigą.

pavyzdžiui: -

 my_list = ['stack', 'over'] my_list.append('flow') print my_list 

Išeiti:

 ['stack', 'over', 'flow'] 

Pastaba - Jei į sąrašą įtraukiate kitą sąrašą, pirmasis sąrašas bus vienas objektas sąrašo pabaigoje.

pavyzdžiui: -

 my_list = ['stack', 'over', 'flow'] another_list = [1,2,3,4] , my_list.append(another_list) print my_list 

Išėjimas: -

 ['stack', 'over', 'over', [1,2,3,4]] 

extend() : - nurodo jo argumentą ir prideda kiekvieną elementą į sąrašą ir išplečia sąrašą. Sąrašo ilgis padidinamas jo argumentų elementų skaičiumi.

pavyzdžiui: -

 my_list = ['stack', 'over'] another_list = [6, 0, 4, 1] my_list.extend(another_list) print my_list 

Išeiti:

 ['stack', 'over', 6, 0, 4, 1] 

Pastaba - Ši eilutė yra iteratyvi, todėl, jei išplėsite sąrašą su eilute, pridedate kiekvieną simbolį, kai iteruojama virš eilutės.

pavyzdžiui: -

 my_list = ['stack', 'overflow', 6, 0, 4, 1] my_list.extend('hello') print my_list 
0
25 янв. Atsakymas duotas Karthik Sai sausio 25 d 2019-01-25 13:58 '19, 13:58 pm 2019-01-25 13:58

append „išplečia“ sąrašą (vietoje), kai tik vienas elementas perduodamas vienam objektui (kaip argumentas).

extend „išplečia“ sąrašą (vietoje) tiek daug elementų, kaip ir objektas, perduotas (kaip argumentas).

Tai gali būti šiek tiek paini str .

  1. Jei perduodate eilutę kaip argumentą: pridedamas vienas eilutės elementas pabaigoje, bet extend pridės tiek daug „vieno“ „str“ elementų kaip ir šios eilutės ilgis.
  2. Jei perduodate eilutės sąrašą kaip argumentą: priedas vis dar prideda vieną „sąrašo“ elementą iki galo, o extend prideda tiek sąrašo elementų, kaip ir perduoto sąrašo ilgis.
 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']) 

gamina:

 append: ab,cd, extend: ab,c,d, append: ab,['cd', 'ef'], extend: ab,cd,ef, append: ab,['cd'], extend: ab,cd, 
-1
31 марта '18 в 21:46 2018-03-31 21:46 ilias iliadis atsakymas kovo 31 d. 18 val. 9:46 val. 2018-03-31 21:46

Papildymas ir plėtimas yra vienas iš python išplėtimo mechanizmų.

Pridėti: įtraukia elementą į sąrašo pabaigą.

 my_list = [1,2,3,4] 

Norėdami pridėti naują elementą į sąrašą, mes galime naudoti priedų metodą taip.

 my_list.append(5) 

Numatytoji vieta, kuriai bus pridėtas naujas elementas, visada yra padėtyje (ilgis + 1).

Įterpti: įterpimo apribojimai buvo įterpti įterpimo metodą. Naudodami įterpimą, galime aiškiai nustatyti tikslią vietą, į kurią norime įterpti naują elementą.

Rankena įterpti metodą (indeksą, objektą). Tai užtrunka du argumentus, pirmiausia - tai indeksas, kurį norime įterpti į mūsų elementą, o antrasis -.

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

Plėtra: tai labai naudinga, kai norime sujungti du ar daugiau sąrašų į vieną sąrašą. Be išplėtimo, jei norime prisijungti prie dviejų sąrašų, gautame objekte bus sąrašų sąrašas.

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

Jei stengiamės pasiekti elementą, esantį 2 poz., Mes gauname sąrašą ([3]) vietoj elemento. Jei norite prisijungti prie dviejų sąrašų, turėsime naudoti priedą.

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

Jei norite prisijungti prie kelių sąrašų

 a = [1] b = [2] c = [3] a.extend(b+c) print (a) [1,2,3] 
-1
17 июля '18 в 10:19 2018-07-17 10:19 atsakymas duotas vivekui liepos 17 d., 18 val. 10:19 ; 2018-07-17 10:19

Naudokite išplėsti ('object1', 'object2', 'object3'), naudokite priedą ('object').

-2
28 янв. atsakymas pateikiamas panagiwtis koligas 28 sausis 2019-01-28 23:52 '19 , 11:52 pm 2019-01-28 23:52