Python List - Skapa, komma åt, skiva, lägga till eller ta bort element

python list create

Prova Vårt Instrument För Att Eliminera Problem

Välj Operativsystemet Välj Ett Projektprogram (Valfritt)

Beskriv Ditt Problem

I denna Python List-handledning kommer vi att undersöka sätt att skapa, komma åt, skära, lägga till / ta bort element till Python-listor som utan tvekan är en av de mest användbara datatyperna:

Python innehåller fyra insamlingsdatatyper som nämns nedan:

Lista
Uppsättning
Ordbok
Tuple

I denna handledning kommer vi att diskutera i detalj om List och dess olika funktioner. I Python är listan en datastruktur eller den är precis som en matris som används för att lagra flera data samtidigt.

=> Utforska Python Training Series här

Om du har erfarenhet av andra programmeringsspråk som Java, C, C ++ etc kommer du att känna till begreppet arrays. Listan är nästan densamma som matriser.

Vad du kommer att lära dig:

Vad är Python-listor

I Python är en lista en data typ , som lagrar en samling olika objekt (objekt) inom en hakparentes (()). Varje objekt i en lista separeras med ett komma (,) med det första objektet vid index 0.

Notera :Framåt kommer alla exemplen i denna handledning att köras direkt från ett Python-skal, om inte annat anges.

Nedan följer ett exempel på en lista med 5 artiklar.

>>> l = ('what','who','where','when','how') >>>l ('what','who','where','when','how')

I exemplet ovan kan vi se att listan har Strängföremål som objekt, och varje objekt separeras med ett komma.

Egenskaper för Python List

Innan vi tittar på hur vi kan manipulera objekt i en lista, låt oss titta på några av de egenskaper som gör Python-listor favoriserade.

Python-listor är behållarsekvenser

Till skillnad från platta sekvenser ( sträng , array.array , minnesvy , etc) som bara kan innehålla objekt av en typ, en lista är a behållarsekvens som kan innehålla föremål av en typ liksom av olika typer.

Exempel med objekt av en typ

Låt oss öppna vårt pythonskal och definiera en lista med siffror.

>>> numbers = ('one','two','three','four','five') >>> numbers ('one','two','three','four','five')

Exemplet ovan visar en lista med objekt av samma typ, i detta fall av typen sträng (str) .

Exempel med föremål av olika slag

Låt oss öppna vårt Python-skal och definiera en annan version av en lista med siffror.

>>> numbers = ('one',2,3,'four',5.0) >>> numbers ('one',2,3,'four',5.0)

Exemplet ovan visar en lista med artiklar av olika slag. Typerna är sträng , heltal, och flyta .

// a sketch showing the list of items and their types as annotation

Python-listan kan också innehålla alla objekt som funktioner , klasser , moduler , listor , tuples, och mycket mera.

Öppna en redigerare och klistra in koden nedan:

def test(): '''This is a function''' print('This is a test') if __name__ == '__main__': print(test) # return instance object of function 'test' instance = type(test) print(instance) # create a list of colors colors = ('red','blue','green') print(colors) # create a list holding all the various data types defined above, including boolean. my_list = (test, instance, colors, False) print(my_list)

Produktion

Python-listor är behållarsekvenser

Python-listor är ordnade sekvenser

En Python-lista är en ordnad samling objekt. Positionen för varje artikel i en lista är mycket viktig. Faktum är att två listor med samma objekt inte är desamma om ordningen i vilken artiklarna är placerade inte är densamma.

>>> ('a','b','c','d') == ('a','c','b','d') False

Denna egenskap hos Python-listan gör det möjligt att komma åt dess objekt genom index och skivning (mer om detta senare).

Python-listor är förändrade sekvenser

Python-listor är mutabla. Men vad är ett föränderligt objekt? Det är helt enkelt ett objekt som kan modifieras efter det att det har skapats. Exempel av andra muterbara sekvenser är ordbok , array.array , collection.deque .

Varför förändras? Sekvenser som listor används för komplexa operationer, så det är vettigt att de ska kunna förändra , växa , krympa , uppdatering osv . Detta är bara möjligt med mutabilitet. Mutabilitet gör det också möjligt för oss att ändra listor på plats (mer om detta).

Låt oss verifiera förändringarna i en lista med exemplet nedan.

Öppna bara en redigerare och klistra in koden:

def veryfiy_mutability(): # create a list l = (9,0,4,3,5) print('Display before modifying') print('List: {}
Id: {}'.format(l,id(l))) # modify the list by replacing the item at # index 3 to the item -2. l(3) = -2 print('Display after modifying') print('List: {}
Id: {}'.format(l,id(l))) if __name__ == '__main__': veryfiy_mutability()

Produktion

Python-listor är förändrade sekvenser

Från ovanstående utdata märker vi att listan före och efter modifiering är annorlunda. Men den Id värdet är detsamma. De Id värdet här representerar objektets adress i minnet - som erhålls med Python id () .

Detta säger oss att även om listinnehållet har ändrats är det fortfarande samma objekt. Därför uppfyller detta vår definition: ” Det är helt enkelt ett objekt som kan modifieras efter det att det har skapats '

Notera :I exemplet ovan använde vi indexering (mer om detta) för att ändra listan.

Manipulera Python-listor

Med Python-listor är himlen vår gräns. Det finns otaliga saker vi kan göra med listor som lägger till , Tar bort , indexering , skivning , kontroll för medlemskap , och mycket mer. Dessutom har Python inbyggda funktioner som hjälper till att göra manipuleringslistor mer spännande.

I det här avsnittet kommer vi att titta på några vanliga listoperationer.

Skapa en lista

För att skapa en lista lägger du helt enkelt ett antal objekt eller uttryck i en hakparentes åtskilda av kommatecken.

(expression1, expression2,...,expresionN) >>> l = (4,3,5,9+3,False) >>> l (4, 3, 5, 12, False)

Python har också ett inbyggt objekt som heter lista () som kan användas för att skapa listor.

list( sequence ) >>> l = list() # create an empty list >>> l ()

Pytonorm lista () kan ta in sekvenstyper och konvertera dem till listor. Detta är det typiska sättet att konvertera en tuple till en lista.

>>> t = (4,3,5) # tuple >>>l = list(t) # convert into list (4,3,5)

I exemplet ovan använde vi datatypen Tuple . Det liknar en lista men till skillnad från listor är den oföränderlig och dess artiklar är inom parentes.

Ett annat sätt med vilket vi kan skapa en lista är med lista förståelser som har följande syntax.

(expression for item in sequence) >>> (i**2 for i in range(4)) (0, 1, 4, 9)

Det är värt att notera att Python-listor skickas genom referens. Det betyder att tilldela en lista ger dess minnesplatsidentitet. Det misstag som många nybörjare gör är att skapa listor på detta sätt.

>>> l1 = l2 = (4,3) # wrong way to create separate list objects >>> l1 (4,3) >>> l2 (4,3)

Här kanske vi tror att vi har skapat två olika listor, men verkligen har vi just skapat en. Låt oss demonstrera detta genom att ändra en av variablerna.

>>> l1(0) = 0 >>> l1 (0,3) >>> l2 (0,3)

Vi märker att ändring av en variabel ändrar den andra. Detta beror på att båda variablerna l1 och l2 har samma minnesplatsidentitet, så att de båda pekar på samma objekt.

Lägga till objekt i en lista

Python har många sätt att lägga till element i sin lista. Det vanligaste sättet är att använda bifoga() metod. De andra sätten är att använda förlänga() metod. Indexering och skivning (mer om dessa senare) används mer sannolikt för att ersätta objekt i en lista.

# 1) Använda append () -metoden

Denna metod tar in ett enda objekt och lägger till det i slutet av listan. Den returnerar inte en ny lista utan ändrar bara listan på plats (tack vare dess förändring).

>>>l = list() # create empty list >>> l () >>> l.append(4) # add an integer >>> l (4) >>> l.append((0,1)) # add a list >>> l (4, (0, 1)) >>> l.append(4 >> l (4, (0, 1), True) >>> l.append(x for x in range(3)) # add result of a tuple comprehension >>> l (4, (0, 1), True, )

Få saker att notera från exemplet ovan:

Objekt här kan vara uttryck, datatyper, sekvenser och många fler.
De bifoga() metoden har en tidskomplexitet på (0) 1. Det betyder att det är konstant.

# 2) Använd utvidgningsmetoden ()

Denna metod tar upp en iterabel som argument och lägger till alla objekt från den till slutet av listan. Denna metod används oftast när vi vill lägga till enskilda objekt i en sekvens i en lista

I grund och botten är förlänga() metoden går igenom argumentet och lägger till varje objekt i listan. Precis som metoden append () returnerar den inte en ny lista utan ändrar listan på plats.

>>> l1 = (3,2,5) # create a list of items >>> l1 (3, 2, 5) >>> l2 = (0,0,-1) # create a second list of items >>> l2 (0, 0, -1) >>> str = 'hello' # create a string(iterable) >>> str 'hello' >>> l1.extend(l2) # append all items from l2 to l1 >>> l1 (3, 2, 5, 0, 0, -1) >>> l1.extend(str) # append all items from str to l1 >>> l1 (3, 2, 5, 0, 0, -1, 'h', 'e', 'l', 'l', 'o')

Få saker att notera från ovanstående exempel:

En sträng är iterabel, så vår förlänga() metoden kommer att iterera över dess karaktärer.
De förlänga() metoden har en tidskomplexitet av (0) K där K är längden på dess argument.

Åtkomst till objekt från en lista

Indexering och skivning är de vanligaste sätten som används för att komma åt listor. Vi kan också komma åt objekt i en lista med slingor som för loop .

# 1) Indexering

En Python-lista använder nollbaserad numrering systemet. Det betyder att alla dess objekt identifieras unikt med ett indexnummer från 0 till n-1 där n är listans längd.

Tänk på listan nedan:

>>> colors = ('red','blue','green','yellow','black') # create list >>> colors ('red','blue','green','yellow','black') >>> len(colors) # get list length 5

Tabellen nedan visar deras respektive index i nollbaserad numrering av en lista.

Artikel	netto	blå	grön	gul	svart
pop ()	För att ta bort / ta bort elementet från det sista i en lista.
Index	0	1	två	3	4

Från tabellen ovan ser vi att det första objektet ('rött') är i indexpositionen 0 och det sista objektet ('svart') är i indexposition 4 (n-1) där n = 5 (längden på objektet färger).

Som vi såg i det karakteristiska avsnittet ovan är Python-listor ordnade sekvenser. Detta gör det möjligt för oss att använda indexering för att komma åt och manipulera dess objekt enkelt.

Låt oss använda indexering för att komma åt objekt på vissa index för det färgobjekt som skapats ovan.

>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0) # access item at index 0 'red' >>> colors(4) # access item at index 4 'black' >>> colors(9) # access item at index 9 Traceback (most recent call last): File '', line 1, in IndexError: list index out of range

Notera :Det sista uttalandet ovan försöker komma åt ett objekt i indexposition 9 från ett listaobjekt med längd 5. I Python-listan kommer åtkomst till ett objekt i ett index som inte finns att höja Indexfel undantag.

Ett viktigt begrepp med indexering är att vi kan använda negativ indexering, dvs. vi kan komma åt objekt i en lista på ett omvänd sätt som börjar vid -1 för det sista objektet och slutar vid -n för det sista objektet där n är listobjektets längd.

I ovanstående tabell, om vi använder negativ indexering, kommer det att se ut som visas nedan:

Artikel	netto	blå	grön	gul	svart
Index	-5	-4	-3	-två	-1

Låt oss använda negativ indexering för att komma åt vissa objekt i det färgobjekt som skapats ovan.

>>> colors # original list ('red','blue','green','yellow','black') >>> colors(-1) # access item and index -1(first item counting backward) 'black' >>> colors(-3) # access item at index -3(third item counting backward) 'green' >>> colors(-5) # access item at index -5 (last item counting backward) 'red'

# 2) Skivning

Till skillnad från indexering som bara returnerar ett objekt, skivning å andra sidan kan returnera en rad artiklar.

Den har följande syntax:

L(n:m)

När n är indexnumret där segmentet börjar (standard 0), och m är det exklusiva indexnumret där segmentet slutar (standard är längd-1). De är åtskilda av ett kolon (:)

Tänk på exemplet nedan som använder skivning för att komma åt objekt vid vissa index för det färgobjekt som skapats ovan.

>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0:2) # get first two items ('red', 'blue') >>> colors(1:4) # get items at index 1,2 and 3 ('blue', 'green', 'yellow') >>> colors(2:len(colors) # get items from index 2 to the last item ('green', 'yellow', 'black') >>> colors(3:4) # get one item at index 3. Same as colors(3) ('yellow') >>>

I syntaxen L (n: m) är n som standard 0 och m är listans längd. Så, in exempel 1 och 3 ovan kunde vi utelämna n och m som färger (: 2) respektive färger (2:). Eller (:) som i detta fall returnerar en grunt kopia av hela listobjektet.

Vi kan också använda negativa indexnummer medan vi skär listor. Detta används vanligtvis när vi vill komma åt listan på ett omvänd sätt.

>>> colors # original list ('red','blue','green','yellow','black') >>> colors(-3:-2) ('green') >>> colors(-2:) ('yellow', 'black')

Det finns också en tredje parameter som skivningsstöd kallas steg (s). Den definierar hur många objekt som ska flyttas fram efter att det första objektet har hämtats från listan. Den är som standard 1.

L(n:m:s)

Med samma färglista som definierats ovan, låt oss använda segmentets tredje parameter för att flytta två steg.

>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0:3:2) ('red', 'green')

# 3) Använda öglor

Slingor används oftast för att komma åt objekt i en lista för att manipulera objekten. Så om vi vill hantera objekt i en lista kan vi använda för loop för att komma åt föremålen och överföra dem för att användas.

Säg, vi vill räkna antalet bokstäver för varje artikel. Vi kan använda för loop för att åstadkomma det.

Öppna en redaktör och klistra in koden nedan:

def count_letters(l): count = {} # define a dict to hold our count for i in l: # loop through the list count(i) = len(i) # for each item, compute its length and store it in the dict return count # return the count if __name__ == '__main__': colors = ('red', 'blue', 'green', 'yellow', 'black') print(count_letters(colors))

Produktion

Använda öglor

För att avsluta det här avsnittet, låt oss titta på två coola saker som kan göras med skivning.

Gör en grunt kopia av en lista

Det är det grundläggande sättet att använda kopiera() metod för listobjektet eller den inbyggda funktionen kopia. kopia . Detta kan dock uppnås genom skivning.

>>> colors # original list ('red','blue','green','yellow','black') >>> colors_copy = colors(:) # make a shallow copy >>> colors_copy ('red', 'blue', 'green', 'yellow', 'black') >>> colors_copy(0) = 0 # modify item at index 0 by changing its value to 0 >>> colors_copy # the copied version now has 0 at index 0 (0, 'blue', 'green', 'yellow', 'black') >>> colors # the original version is unchanged ('red', 'blue', 'green', 'yellow', 'black') >>>

Omvänd en lista

Det grundläggande sättet är att använda omvänd metod för listobjektet eller den inbyggda funktionen omvänd () . Detta kan dock uppnås genom skivning.

>>> colors # original list object ('red', 'blue', 'green', 'yellow', 'black') >>> colors(::-1) # returns a reversed shallow copy of the the original list ('black', 'yellow', 'green', 'blue', 'red') >>>

Ta bort objekt från en lista

Eftersom vi kan lägga till så många objekt i en lista kan de också tas bort från en lista. De tre sätten på vilka objekt kan tas bort är:

# 1) Använda del-uttalandet

Den har följande syntax:

del target_list

Mållistan ( mållista ) kan vara hela listan (om du vill radera listan) eller ett objekt eller objekt i en lista (i det här fallet använder du indexering eller skärning).

Tänk på exemplet nedan .

Säg, vi vill ta bort några objekt från färglistan som skapats ovan.

>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> del c_copy(0) # delete item at index 0 >>> c_copy ('blue', 'green', 'yellow', 'black') >>> del c_copy(0:2) # delete items at index 0 and 1(slicing) >>> c_copy ('yellow', 'black') >>> del c_copy(:) # delete all items in a list. Same as ‘c_copy.clear()’ () >>> del c_copy # delete the list object >>> c_copy # access object that doesn't exist Traceback (most recent call last): File '', line 1, in NameError: name 'c_copy' is not defined >>>

Notera :Del-uttalandet raderas på plats d.v.s. kommer det att ändra det ursprungliga listobjektet istället för att returnera ett nytt listobjekt.

# 2) Använda listan. Ta bort (x)

Det tar bort det första objektet från listan vars värde är lika med x . Det höjer en ValueError om det inte finns något sådant.

Denna metod används mest för att ta bort objekt från en lista med namn, till skillnad från del-uttalandet som använder indexering och skivning.

>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # create shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy.remove('blue') # remove first item with name 'blue' >>> c_copy ('red', 'green', 'yellow', 'black') >>> c_copy.remove('blue') # try to remove item that doesn't exist Traceback (most recent call last): File '', line 1, in ValueError: list.remove(x): x not in list >>>

Notera :Listobjektet ta bort() metoden raderas på plats d.v.s. kommer det att ändra det ursprungliga listobjektet istället för att returnera ett nytt listobjekt.

# 3) Använda list.pop ((i))

Det tar bort och returnerar objektet på den angivna positionen i ett listobjekt. Om inget i (index) tillhandahålls tas det sista objektet i listan bort och returneras.

Notera :Fyrkanten runt i ovan betyder inte en lista över i, utan det betyder att jag är valfri.

>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy.pop(3) # pop out the item at index 3 'yellow' >>> c_copy ('red', 'blue', 'green', 'black') >>> c_copy.pop() # pop out the last item in the list 'black' >>> c_copy ('red', 'blue', 'green') >>>

Notera: Listan. pop ((i)) metoden raderas på plats d.v.s. kommer det att ändra det ursprungliga listobjektet istället för att returnera ett nytt listobjekt. Det returnerar också objektet som tagits bort från listan

Ersätta objekt från en lista

Att byta ut saker är ganska enkelt. I ett av ovanstående avsnitt såg vi indexering och skivning. Dessa kan användas för att komma åt och ta bort objekt från en lista.

# 1) Byt ut med indexering

L(index) = value

>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy(0) = 'brown' # replace item at index 0 with 'brown' >>> c_copy ('brown', 'blue', 'green', 'yellow', 'black') >>>

# 2) Ersätt med skivning

L(n:m) = value

Notera : Värde borde vara en iterabel , eller annars Skrivfel undantag kommer att tas upp.

>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy(0:2) = ('brown') # replace items at index 0 and 1 with 'brown' >>> c_copy ('brown', 'green', 'yellow', 'black') >>> c_copy(1:3) = ('white','purple') # replace items at index 1 and 2 with 'white' and 'purple' >>> c_copy ('brown', 'white', 'purple', 'black') >>> c_copy(1:4) = ('white','purple') # replace items at index 1,2 and 3 with 'white' and 'purple'. Here we replace 3 items with 2 items >>> c_copy ('brown', 'white', 'purple') >>>

Vanliga frågor

F # 1) Vad är en lista med listor i Python?

Svar: En lista med listor i Python är en lista som innehåller listor som sitt objekt.

Till exempel

(('a','b'),('c','d'))

Det kan också kallas a kapslad lista .

F # 2) Hur förklarar du en lista i Python?

Svar: I Python kan en lista deklareras på två sätt. Antingen med hjälp av den inbyggda funktionen lista() eller genom att använda parentesnotationen (). lista() tar in en iterabel och () tar in objekt av vilken typ som helst åtskilda med ett komma.

(pytyon)>>> list('hello') # a string is iterable ('h', 'e', 'l', 'l', 'o') >>> (3,4,5,23) # numbers are separated by comma (3, 4, 5, 23) >>> (/python)

F # 3) Kan du lägga en lista i en lista Python?

Svar: Ja, vi kan lägga en lista i en lista. I själva verket är en lista en behållarsekvens som tar in objekt av vilken datatyp som helst.

F # 4) Vad gör lista () i Python?

Svar: lista ( ) är en inbyggd funktion i Python som skapar ett listobjekt. Det tar in en iterabel som argument.

>>> list((3,2,4)) # The iterable object here is a tuple. (3, 2, 4) >>>

F # 5) Kan en Python-lista innehålla olika typer?

Svar: En lista är en containersekvens som tar in objekt av alla datatyper ( lista , tupel , heltal , flyta , strängar , etc)

Mer om listor i Python

Vad är datastruktur?

Datorer används för att lagra ett stort antal data eller för att bearbeta ett stort antal data med hög hastighet och noggrannhet. Därför är det bäst att lagra data permanent för snabb åtkomst.

Medan databehandling sker, bör det ske inom kortast möjliga tid utan att förlora noggrannheten. Vi använder datastrukturen för att hantera data på ett organiserat sätt och lagra data i minnet för bearbetning.

Eftersom Python är ett högt och tolkat programmeringsspråk är det mycket viktigt att använda datastrukturen i Python.

Vad är Lista?

En lista är en datastruktur som används för att lagra flera data samtidigt.

De data som lagras i en lista är homogena och som i sin tur gör den till den mest kraftfulla funktionen i listan i Python. Vi kan lagra flera data av olika datatyper som sträng, heltal och objekt i en enda lista.

Listan kan ändras i Python, så data kan ändras när som helst även efter skapandet. Listor är mycket kraftfulla för att implementera stackar och köer i Python.

Som diskuterats tidigare, listar lagringsdata i en ordnad sekvens och data som lagras i en lista nås med hjälp av deras index, och för listan kommer indexet alltid att starta från noll. Varje element har en specifik plats i listan och alla dessa data nås med hjälp av ett index.

I listan kan vi lagra samma värde flera gånger och varje data kommer att betraktas som ett separat och unikt element. Listor är bäst att lagra data och upprepa dem vid ett senare tillfälle.

Skapa en lista

Data i en lista lagras med kommaseparerade och omges av en hakparentes (()). Objekt i listan behöver inte vara av samma typ.

Syntax: List = (item1, item2, item3)

Exempel 1:

List = ( )

Exempel 2:

List = (2, 5, 6.7)

Exempel 3:

List = (2, 5, 6.7, ‘Hi’)

Exempel 4:

List = (‘Hi’, ‘Python’, ‘Hello’)

I exemplen ovan kan vi observera att vi har lagrat objekt av olika datatyper med kommaseparerade, 2 och 5 är av typen Heltal, 6.7 är av typen float och 'Hi' är av typen String, alla dessa artiklar är inneslutna i en och det gör det till en lista.

Vi kan också förklara en tom lista. Vi kan också deklarera listan i en annan lista, och vi kallar detta som en kapslad lista.

Exempel 5:

List = (‘Hi’, (2, 4, 5), (‘Hello’))

I exemplet ovan kan du observera att en lista har förklarats i en annan lista.

Åtkomst till värden i listan

Det finns olika sätt genom vilka vi kan komma åt de objekt som finns i listan i Python.

Med hjälp av indexet kan vi komma åt elementen i listan. Index börjar från 0 och indexet ska alltid vara ett heltal. Om vi använder ett annat index än heltal som float, kommer det att resultera i TypeError.

Exempel 1:

List = (2, 5, 6.7, ‘Hi’) print(“List is:”, List)

Produktion:

Listan är: (2, 5, 6.7, 'Hej')

Åtkomstvärden i listan_exempel_1

Produktion:

mata in utdatafiler c ++

Accessing_values_in_list_example_1_output

I exemplet ovan skriver vi direkt ut listan med utskriftsfunktionen, vi kommer inte åt det enskilda elementet från listan.

Låt oss komma åt det enskilda elementet från listan.

Exempel: 2

List = (2, 5, 6.7, ‘Hi’) print(“Second element of the list is:”, List(1))

Produktion:

Andra elementet i listan är: 5

Accessing_values_in_list_example_2

Produktion:

Accessing_values_in_list_example_2_output

I exemplet ovan kan du observera att vi skriver ut det andra elementet i listan som är 5, men du kan få en fråga om varför i utskriftsuttrycket vi skriver ut List (1)? Det beror på att indexet börjar från noll, varför List (1) hänvisar till det andra elementet i listan.

Exempel: 3

List = (2, 5, 6.7, ‘Hi’) print(“First element in the List is: ”, List(0)) print(“Last element in the List is: ”, List(3))

Produktion:

Första elementet i listan är: 2
Det sista elementet i listan är: Hej

Åtkomst_värden_i_lista_exempel_3

Produktion:

Accessing_values_in_list_example_3_output

Exempel: 4

List = (‘Hi’, (2, 4, 5)) print(“First element of the list is: ”, List(0)(1)) print(“Elements present inside another list is: ”, List(1)(2))

Produktion:

Första elementet i listan är: i
Element som finns i en annan lista är: 5

Accessing_values_in_list_example_4

Produktion:

Accessing_values_in_list_example_4_output

I ovanstående program, om du observerar noggrant, kan du se att vi kommer åt elementen från den kapslade listan.

Internt lagras data i ett matrisformat enligt nedan:

Hej

2 4 5

Därför, när vi försöker komma åt Lista (0) (1) kommer den att peka på 1^strad och 2^ndkolumn, därmed blir data ”i”.

På samma sätt, när vi försöker komma åt Lista (1) (2) kommer den att peka på 2^ndrad och 3^rdkolumn, därmed kommer data att vara 5.

Negativ indexering

Vi kan också komma åt data med ett negativt index. Ett negativt index börjar alltid från -1 och -1 hänvisar till det sista elementet och -2 hänvisar till den sista sekunden och så vidare.

Exempel: 1

List = (2, 5, 7, 3) print(“Last element in the list is: ”, List(-1))

Produktion:

Sista elementet i listan är: 3

Negativ_indexing_exempel_1.1

Produktion:

Negativ_indexing_exempel_1_utgång1

Exempel: 2

List = (2, 5, 7, 3) print(“Second element in the list is: ”, List(-3))

Produktion:

Andra elementet i listan är: 5

Negativ_indexing_exempel_2.1

Produktion:

Negativ_indexing_exempel_2_output1

Skivning av listan

Med hjälp av skivaoperatören (:) kan vi komma åt en rad element från listan

Exempel: 1

List = (1, 2, 3, 4, 5, 6, 7) print(“Elements from 2nd to 5th is: ”, List(1:5)) print(“Elements beginning to 2rd is: ”, List(:-3)) print(“Elements 4th to end is: ”, List(3:)) print(“Elements from start to end is: “, List(:))

Produktion:

Element från 2: a till 5: e är: (2, 3, 4, 5)
Element som börjar till 2: a är: (1, 2, 3, 4)
Element 4: e till slut är: (4, 5, 6, 7)
Element från början till slut är: (1, 2, 3, 4, 5, 6, 7)

Skivlista_exempel_1.1

Produktion:

Skivlista_exempel_1_utgång1

Vi kan också komma åt de element som finns i listan med hjälp av for loop.

Exempel: 2

List = (1, 2, 3, 4, 5, 6, 7) forele in List: print(ele)

Produktion:

1
två
3
4
5
6
7

Skivlista_exempel_2

Produktion:

Skivlista_exempel_2_utgång1

Kom ihåg indexeringsformatet nedan:

H	ÄR	L	L	ELLER	5	7	9	4
0	1	två	3	4	5	6	7	8
-9	-8	-7	-6	-5	-4	-3	-två	-1

Som diskuterats tidigare är Lista i python muterbar, vilket innebär att elementen kan ändras även om det är ett heltal eller en sträng eller någon datatyp.

Vi kan uppdatera listan med uppdragsoperatören.

Exempel: 3

List = (2, 4, 6, 9) #updating the first element List(0) = 7 print(“Updated list is: ”, List)

Produktion:

Uppdaterad lista är: (7, 4, 6, 9)

Skivlista_exempel_3.1

Produktion:

Skivlista_exempel_3_output1

I exemplet ovan uppdaterar vi det första elementet i listan '2' med ett nytt element '7'.

Exempel: 4

List = (2, 5, 1, 3, 6, 9, 7) #updating one or more elements of the list at once List(2:6) = (2, 4, 9, 0) print(“Updated List is: ”, List)

Produktion:

Uppdaterad lista är: (2, 5, 2, 4, 9, 0, 7)

I exemplet ovan uppdaterar vi listan med data i listan.

Skivlista_exempel_4.1

Produktion:

Skivlista_exempel_4_utgång1

Lägga till element i listan

Det finns flera sätt på vilka vi kan lägga till element i listan, och python har en inbyggd funktion som heter append ().

Med hjälp av append () kan vi bara lägga till ett element i listan. Om du vill lägga till flera element i listan måste vi använda för loop . append () - funktionen lägger alltid till elementet i slutet av listan, append () - funktionen tar bara ett argument.

Om du vill lägga till element på en viss position behöver du bara använda metoden insert (). infoga () tar två argument, dvs position och värde, position hänvisar till indexet, där elementen måste läggas till och värde hänvisar till det element som ska läggas till i listan.

Det finns ytterligare en metod som heter expand (), med vilken vi kan lägga till element i listan. expand () -metoden används för att lägga till en lista med element i listan. På samma sätt som metoden append () och metod för att utvidga () kommer den också att lägga till element i slutet av listan.

Exempel: 1

List = (“Hello”, “Good Morning”) print(“List before appending values is: “, List) List.append(“Python”) List.append(“Hi”) print(“List after appending values is: ”, List)

Produktion:

Listan före tilläggsvärden är: (“Hej”, “God morgon”)
Listan efter tillagda värden är: (“Hej”, “God morgon”, “Python”, “Hej”)

I ovanstående exempel lägger vi till 'Python' och 'Hi' värden i slutet av listan.

append () i python

Produktion:

append () i Python Output

Exempel: 2

List = (“Hello”, “Good Morning”) print(“List before appending values is: “, List) print(“Length of the list before appending is: “, len(List)) List.append(“Python”) List.append(“Hi”) print(“List after appending values is: ”, List) print(“Length of the list after appending is: “, len(List))

Produktion:

Listan före tilläggsvärden är: (“Hej”, “God morgon”)
Listans längd innan den läggs till är: 2
Listan efter tillagda värden är: (“Hej”, “God morgon”, “Python”, “Hej”)
Listans längd efter tillägg är: 4

Vi kan hitta längden på listan med funktionen len (), som visas i exemplet ovan.

Lägger till_element_till_listan_exempel_2

Produktion:

Lägger till_element_till_listan_exempel_2_utgång

Vi kan också lägga till flera värden i listan med hjälp av for loop.

Exempel: 3

List = (7, 9, 8) print(“List before adding elements is: “, List) print(“Length of List before adding elements is: “, len(List)) for i in range(2, 6): List.append(i) print(“List after adding elements is: “, List) print(“Length of List after adding elements is: “, len(List))

Produktion:

Listan innan element läggs till är: (7, 9, 8)
Listans längd innan element läggs till är: 3
Listan efter att ha lagt till element är: (7, 9, 8, 2, 3, 4, 5)
Listans längd efter att ha lagt till element är: 7

Lägger till_element_till_listan_exempel_3

Produktion:

Lägga till_element_till_listan_exempel_3_utgång1

Vad händer om vi lägger till en lista med en lista till en lista? Låt oss se det i exemplet nedan.

Exempel: 4

List1 = (“Hi”, “Python”) List2 = (1, 5, 7, 2) List1.append(List2) print(“List1 after appending List2 is: “, List1)

Produktion:

List1 efter att ha lagt till List2 är: (“Hej”, “Python”, (1, 5, 7, 2))

Om du märker i exemplet ovan, när vi lägger till List2 till List1, blir List1 en kapslad lista.

Lägger till_element_till_listan_exempel_4

Produktion:

Lägger till_element_till_listan_exempel_4_output

Om du inte vill göra listan som en kapslad lista efter att du har lagt till listan är det bättre att använda utvidgningsmetoden ().

Exempel: 5

List1 = (“Hi”, “Python”) List2 = (1, 5, 7, 2) List1.extend(List2) print(“List1 after appending List2 is: “, List1)

Produktion:

List1 efter att ha lagt till List2 är: (“Hej”, “Python”, 1, 5, 7, 2)

När vi använder utvidga () -metoden kommer elementen i List1 att utökas med elementen i List2. Kom ihåg att den inte kommer att bifoga listan när vi använder metoden ().

Lägger till_element_till_listan_exempel_5

Produktion:

Lägger till_element_till_listan_exempel_5_output

När du utökar en lista med en sträng, kommer den att lägga till varje tecken i strängen i listan, eftersom en sträng är iterabel.

Exempel: 6

List = (1, 5, 7, 2) List.extend(“Python”) print(“List after extending the String is: “, List)

Produktion:

Lista efter att strängen har förlängts är: (1, 5, 7, 2, 'P', 'y', 't', 'h', 'o', 'n')

Lägger till_element_till_listan_exempel_6

Produktion:

Lägger till_element_till_listan_exempel_6_utgång

List append () vs expand ()

Låt oss titta på några exempel för att utvidga () och lägga till ().

Exempel: 1

def my_fun(): List1 = (“Hi”, 1, “Hello”, 2, 5) print(“The elements of List is: “, List) List.append(“Python”) print(“List after appending the String is: “, List) List.append((“one”, “two”, 3)) print(“List after appending the list is: “, List) List2 = (“Apple”, “Orange”, 2, 8) List1.extend(List2) print(“List1 after extending the List2 is: “, List1) if __name__ == “__main__”: my_fun()

Produktion:

Elementen i Listan är: (“Hej”, 1, “Hej”, 2, 5)
Listan efter att ha lagt till strängen är: (“Hej”, 1, “Hej”, 2, 5, “Python”)
Listan efter att ha lagt till listan är: (“Hej”, 1, “Hej”, 2, 5, “Python”, (“en”, “två”, 3))
List1 efter att List2 har förlängts är: (“Hej”, 1, “Hej”, 2, 5, “Python”, (“en”, “två”, 3), “Äpple”, “Orange”, 2, 8)

List_append_vs_extend_example_1.1

Produktion:

List_append_vs_extend_example_3_output1

Exempel: 2

List = (“Apple”, “Orange”, “Mango”, “Strawberry”) print(“List before inserting is: “, List) List.insert(2, “Watermelon”) print(“List after inserting is: “, List)

Produktion:

Listan innan infogning är: (“Apple”, “Orange”, “Mango”, “Strawberry”)
Lista efter infogning är: (“Apple”, “Orange”, “Vattenmelon”, “Mango”, “Strawberry”)

List_append_vs_extend_example_2.1

Produktion

List_append_vs_extend_example_2_output1

Som vi diskuterade tidigare används metoden insert () för att infoga värden i ett specifikt index i listan.

Exempel: 3

List1 = (2, 4, 6, 8) print(“List after adding the elements is: “, List1 + (1, 3, 5, 7)) print(“After adding same elements repeatedly is: “, (“Hi”) *5)

Produktion:

Listan efter att elementen har lagts till är: (2, 4, 6, 8, 1, 3, 5, 7)
Efter att ha lagt till samma element upprepade gånger är: ('Hej', 'Hej', 'Hej', 'Hej', 'Hej')

List_append_vs_extend_example_3.1

Produktion:

List_append_vs_extend_example_3_output1

Ta bort eller ta bort element från en lista

Vi kan också ta bort eller ta bort element från listan med del och ta bort () uttalanden.

autentisering krävs användarnamn och lösenordsrouter

Låt oss se i exemplet nedan.

Exempel: 1

List = (1, 2, 3, 4, 5, 6, 7, 8, 9) print(“List before deleting 3rd element is: ”, List) del List(3) print(“List after deleting 3rd element is: ”, List) del List(1:3) print(“List after deleting multiple elements is: “, List)

Produktion:

Listan innan det tredje elementet tas bort är: (1, 2, 3, 4, 5, 6, 7, 8, 9)
Listan efter radering av det tredje elementet är: (1, 2, 3, 5, 6, 7, 8, 9)
Listan efter att flera element har tagits bort är: (1, 5, 6, 7, 8, 9)

I exemplet ovan kan du observera att vi har använt del-uttalande för att ta bort ett element eller flera uttalanden från listan.

Ta bort_eller_removing_element_från_the_list_exempel_11

Produktion:

Ta bort_eller_removing_element_from_the_list_example_1_output1

Nu ser vi om metoden remove ().

Exempel: 2

List = (1, 2, 3, 4, 5, 6, 7) print(“List before removing a element is: “, List) List.remove(3) print(“List after removing a element is: “, List) List.pop() print(“List after poping the element is: “, List)

Produktion:

Listan innan ett element tas bort är: (1, 2, 3, 4, 5, 6, 7)
Listan efter att ett element har tagits bort är: (1, 2, 4, 5, 6, 7)
Listan efter att elementet har poppat är: (1, 2, 4, 5, 6)

I exemplet ovan kan du observera att vi tar bort ett element från listan med metoden remove (). Metoden pop () används för att ta bort / ta bort det sista elementet från listan.

Ta bort_eller_removing_element_from_the_list_example_2.1

Produktion:

Ta bort_eller_removing_element_från_the_list_example_2_output1

Listmetoder

Metoder	Beskrivning
klar()	Ta bort alla element från listan.
bifoga()	För att lägga till element i slutet av listan.
Föra in()	För att infoga element i ett specifikt index i listan.
förlänga()	För att lägga till en lista med element i slutet av listan.
räkna()	För att returnera antalet element med ett specifikt värde.
index()	För att returnera index för det första elementet.
omvänd()	För att vända en befintlig lista.
ta bort()	Ta bort elementen från listan.

Slutsats

I den här handledningen tittade vi på några egenskaper hos Python Lists tillsammans med de olika sätten att manipulera en lista som skapa en lista , åtkomst till objekt från en lista och ersätta objekt från en lista.

Denna handledning på Python-listan kan avslutas med följande pekare:

List är en av datatyperna i Python, som också kallas datastruktur.
Listan används för att lagra ett stort antal värden för alla datatyper i en enda variabel, vilket i sin tur hjälper till att komma åt enkelt.
Index för lista börjar alltid från noll som de andra programmeringsspråken.
Om du arbetar på listan måste du komma ihåg alla vanliga inbyggda funktioner i den.

=> Besök här för att lära dig Python From Scratch

Python List - Skapa, komma åt, skiva, lägga till eller ta bort element

Vad är Python-listor

Egenskaper för Python List

Python-listor är behållarsekvenser

Python-listor är ordnade sekvenser

Python-listor är förändrade sekvenser

Manipulera Python-listor

Skapa en lista

Lägga till objekt i en lista

Åtkomst till objekt från en lista

Gör en grunt kopia av en lista

Omvänd en lista

Ta bort objekt från en lista

Ersätta objekt från en lista

Vanliga frågor

Mer om listor i Python

Vad är datastruktur?

Vad är Lista?

Skapa en lista

Åtkomst till värden i listan

Negativ indexering

Skivning av listan

Lägga till element i listan

List append () vs expand ()

Ta bort eller ta bort element från en lista

Listmetoder

Slutsats

Rekommenderad läsning