Python-liste - Opprett, tilgang, del opp, legg til eller slett elementer

python list create

Prøv Instrumentet Vårt For Å Eliminere Problemer

Velg Operativsystemet Velg Et Projeksjonsprogram (Valgfritt)

Beskriv Problemet Ditt

I denne Python List-opplæringen vil vi utforske måter å opprette, få tilgang til, skive, legge til / slette elementer til Python-lister som uten tvil er en av de mest nyttige datatypene:

Python inkluderer 4 datatyper for samlingen som nevnt nedenfor:

Liste
Sett
Ordbok
Tuple

I denne opplæringen vil vi diskutere i detalj om List og dens forskjellige operasjoner. I Python er listen en datastruktur, eller den er akkurat som en matrise som brukes til å lagre flere data samtidig.

=> Utforsk Python Training Series her

Hvis du har erfaring med andre programmeringsspråk som Java, C, C ++ etc, vil du være kjent med begrepet arrays. Liste er nesten det samme som matriser.

Hva du vil lære:

Hva er Python-lister

I Python er en liste a data-type , som lagrer en samling av forskjellige objekter (gjenstander) innenfor en firkantet parentes (()). Hvert element i en liste er atskilt med et komma (,) med det første elementet i indeks 0.

Merk :Fremover vil alle eksemplene i denne opplæringen kjøre direkte fra et Python-skall, med mindre annet er oppgitt.

Nedenfor er et eksempel på en liste med 5 artikler.

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

I eksemplet ovenfor kan vi se at listen har Streng objekter som elementer, og hvert element er atskilt med et komma.

Kjennetegn på Python List

Før vi ser på hvordan vi kan manipulere elementer i en liste, la oss se på noen av egenskapene som gjør Python-lister favoriserte.

Python-lister er containersekvenser

I motsetning til flate sekvenser ( streng , array.array , minnesyn osv.) som bare kan inneholde elementer av en type, en liste er en container sekvens som kan inneholde gjenstander av en type så vel som av forskjellige typer.

Eksempel med gjenstander av en type

La oss åpne vårt pythonskall og definere en liste med tall.

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

Eksemplet ovenfor viser en liste over elementer av samme type, i dette tilfellet av typen streng (str) .

Eksempel med varer av forskjellige typer

La oss åpne Python-skallet vårt og definere en annen versjon av en liste med tall.

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

Eksemplet ovenfor viser en liste over elementer av forskjellige typer. Typene er streng , heltall, og flyte .

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

Python-listen kan også inneholde alle objekter som funksjoner , klasser , moduler , lister , tupler, og mye mer.

Åpne en editor og lim inn koden nedenfor:

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)

Produksjon

Python-lister er containersekvenser

Python-lister er ordnede sekvenser

En Python-liste er en ordnet samling av objekter. Plasseringen til hvert element i en liste er veldig viktig. Faktisk er to lister med de samme elementene ikke de samme hvis rekkefølgen varene er plassert i ikke er den samme.

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

Denne egenskapen til Python-listen gjør det mulig å få tilgang til elementene sine ved å indeksere og kutte dem (mer om dette senere).

Python-lister er mutable sekvenser

Python-lister er mutable. Men hva er et foranderlig objekt? Det er ganske enkelt et objekt som kan endres etter at det er opprettet. Eksempler av andre mutable sekvenser er ordbok , array.array , collection.deque .

Hvorfor foranderlig? Sekvenser som lister brukes til komplekse operasjoner, så det er fornuftig at de skal kunne endring , vokse , krympe , oppdatering osv . Dette er bare mulig med mutabilitet. Mutabilitet gjør det også mulig for oss å endre lister på plass (mer om dette).

La oss kontrollere mutabiliteten til en liste med eksemplet nedenfor.

Bare åpne en redaktør og lim inn 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()

Produksjon

Python-lister er mutable sekvenser

Fra ovennevnte utdata merker vi at listen før og etter endring er forskjellig. Imidlertid, den Id verdien er den samme. De Id verdien representerer her objektets adresse i minnet - som er oppnådd med Python id () .

Dette forteller oss at selv om listeinnholdet er endret, er det fortsatt det samme objektet. Derfor tilfredsstiller dette vår definisjon: “ Det er ganske enkelt et objekt som kan endres etter at det er opprettet '

Merk :I eksemplet ovenfor brukte vi indeksering (mer om dette) for å endre listen.

Manipulere Python-lister

Med Python-lister er himmelen vår grense. Det er utallige ting vi kan gjøre med lister som legge til , sletter , indeksering , skjæring , sjekke for medlemskap , og mye mer. Python har også innebygde funksjoner som bidrar til å gjøre manipuleringslister mer spennende.

I denne delen vil vi se på noen ofte brukte listeoperasjoner.

Opprette en liste

For å lage en liste legger du ganske enkelt et antall elementer eller uttrykk i en hakeparentes atskilt med komma.

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

Python har også et innebygd objekt som heter liste () som kan brukes til å lage lister.

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

Python liste () kan ta inn sekvenstyper og konvertere dem til lister. Dette er den typiske måten å konvertere en tuple til en liste.

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

I eksemplet ovenfor brukte vi datatypen Tuple . Det ligner på en liste, men i motsetning til lister er det uforanderlig og elementene er omsluttet av parentes.

Et annet middel som vi kan lage en liste på er å bruke listeforståelser som har følgende syntaks.

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

Det er verdt å merke seg at Python-lister sendes som referanse. Betydning, tildeling av en liste vil gi identiteten til minneplasseringen. Feilen mange nybegynnere gjør er å lage lister på denne måten.

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

Her kan vi tro at vi har opprettet to forskjellige lister, men virkelig har vi nettopp opprettet en. La oss demonstrere dette ved å endre en av variablene.

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

Vi merker at endring av den ene variabelen endrer den andre. Dette er fordi begge variablene l1 og l2 har samme minneplasseringsidentitet, slik at de begge peker på det samme objektet.

Legge til elementer i en liste

Python har mange måter å legge til elementer på listen sin. Den vanligste måten er å bruke legg til () metode. De andre måtene er å bruke forlenge() metode. Indeksering og skjæring (mer om disse senere) brukes mer sannsynlig til å erstatte elementer i en liste.

# 1) Bruk append () -metoden

Denne metoden tar inn et enkelt element og legger det til på slutten av listen. Den returnerer ikke en ny liste, men bare endrer listen på plass (takket være dens mutabilitet).

>>>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å ting å merke seg fra eksemplet ovenfor:

Elementene her kan være uttrykk, datatyper, sekvenser og mange flere.
De legg til () metoden har en tidskompleksitet på (0) 1. Det betyr at det er konstant.

# 2) Bruk utvidelsesmetoden ()

Denne metoden tar opp en iterabel som argument og legger til alle elementene fra den til slutten av listen. Denne metoden brukes for det meste når vi vil legge til individuelle elementer i en sekvens i en liste

I utgangspunktet er den forlenge() metoden gjentas over argumentet og legger hvert element til listen. Akkurat som metoden (), returnerer den ikke en ny liste, men endrer listen på plass.

>>> 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å ting å merke seg fra eksemplet ovenfor:

En streng er iterabel, så vår forlenge() metoden vil iterere over tegnene.
De forlenge() metoden har en tidskompleksitet på (0) K hvor K er lengden på argumentet.

Få tilgang til elementer fra en liste

Indeksering og skjæring er de vanligste virkemidlene som brukes for å få tilgang til lister. Vi kan også få tilgang til elementer i en liste med løkker som for løkke .

# 1) Indeksering

En Python-liste bruker nullbasert nummerering system. Betydning, alle elementene er unikt identifisert med et indeksnummer som starter fra 0 til n-1 der n er lengden på listen.

Tenk på listen nedenfor:

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

Tabellen nedenfor viser deres respektive indekser i nullbasert nummerering av en liste.

Punkt	nett	blå	grønn	gul	svart
pop ()	For å slette / fjerne elementet fra det siste i en liste.
Indeks	0	1	to	3	4

Fra tabellen ovenfor ser vi at det første elementet ('rødt') er i indeksposisjonen 0 og det siste elementet ('svart') er i indeksposisjonen 4 (n-1) hvor n = 5 (lengden på objektet farger).

Som vi så i den karakteristiske delen ovenfor, er Python-lister ordnet sekvenser. Dette lar oss bruke indeksering for å få tilgang til og manipulere elementet enkelt.

La oss bruke indeksering for å få tilgang til elementer på bestemte indekser av fargerobjektet opprettet ovenfor.

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

Merk :Den siste setningen ovenfor prøver å få tilgang til et element i indeksposisjon 9 fra et listeobjekt med lengde 5. I Python-listen vil tilgang til et element i en indeks som ikke eksisterer øke IndexError unntak.

Et viktig begrep med indeksering er at vi kan bruke negativ indeksering, dvs. at vi kan få tilgang til elementene i en liste på en omvendt måte som starter ved -1 for det siste elementet og slutter ved -n for det siste elementet der n er lengden på listeobjektet.

I tabellen ovenfor, hvis vi bruker negativ indeksering, vil den se ut som vist nedenfor:

Punkt	nett	blå	grønn	gul	svart
Indeks	-5	-4	-3	-to	-1

La oss bruke negativ indeksering for å få tilgang til noen elementer av fargeobjektet opprettet ovenfor.

>>> 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) Skjæring

I motsetning til indeksering som bare returnerer ett element, skjæring på den annen side kan returnere en rekke varer.

Den har følgende syntaks:

L(n:m)

Når n er indeksnummeret hvor segmentet starter (standard er 0), og m er det eksklusive indeksnummeret der segmentet slutter (standard lengde-1). De er atskilt med et kolon (:)

Tenk på eksemplet nedenfor som bruker kutting for å få tilgang til elementer på bestemte indekser av fargerobjektet opprettet ovenfor.

>>> 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 syntaksen L (n: m) er n som standard 0, og m er standard lengden på listen. Så, i eksempler 1 og 3 ovenfor kunne vi utelate n og m som henholdsvis farger (: 2) og farger (2:). Eller (:) som i dette tilfellet returnerer en grunne kopi av hele listeobjektet.

Vi kan også bruke negative indeksnummer når vi kutter lister. Dette brukes vanligvis når vi ønsker å få tilgang til listen på en omvendt måte.

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

Det er også en tredje parameter som kutting støtter steg (s). Den definerer hvor mange elementer som skal flyttes etter at det første elementet er hentet fra listen. Den er som standard 1.

L(n:m:s)

Ved å bruke den samme fargelisten som definert ovenfor, la oss bruke snittets tredje parameter for å flytte to trinn.

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

# 3) Bruke løkker

Sløyfer brukes mest for å få tilgang til elementer i en liste for å manipulere elementene. Så hvis vi vil operere elementene på en liste, kan vi bruke for løkke for å få tilgang til varene og overføre dem for å bli operert.

Si, vi vil telle antall bokstaver for hvert element. Vi kan bruke for løkke for å oppnå det.

Åpne en editor og lim inn koden nedenfor:

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

Produksjon

Bruke løkker

For å avslutte denne delen, la oss se på to kule ting som kan gjøres med kutting.

Lag en grunne kopi av en liste

Det er den grunnleggende måten å bruke kopiere() metode for listeobjektet eller den innebygde funksjonen kopi. kopi . Dette kan imidlertid oppnås ved å kutte.

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

Snu en liste

Den grunnleggende måten er å bruke omvendt metode for listeobjektet eller den innebygde funksjonen omvendt () . Dette kan imidlertid oppnås ved å kutte.

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

Fjerne elementer fra en liste

Siden vi kan legge til så mange elementer i en liste, kan de også fjernes fra en liste. De tre måtene elementene kan fjernes på er:

# 1) Bruke del-setningen

Den har følgende syntaks:

del target_list

Mållisten ( målliste ) kan være hele listen (i tilfelle du vil slette listen) eller et element eller elementer i en liste (i dette tilfellet bruker du indeksering eller kutting).

Tenk på eksemplet nedenfor .

Si, vi vil slette noen elementer fra fargelisten opprettet ovenfor.

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

Merk :Del-utsagnet slettes på plass dvs. , vil den endre det opprinnelige listeobjektet i stedet for å returnere et nytt listeobjekt.

# 2) Bruk listen. Fjern (x)

Det fjerner det første elementet fra listen hvis verdi er lik x . Det reiser en ValueError hvis det ikke er noe slikt element.

Denne metoden brukes hovedsakelig for å fjerne elementer fra en liste etter navn, i motsetning til del-setningen som bruker indeksering og kutting.

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

Merk :Listeobjektet ta vekk() metoden slettes på plass dvs. , vil den endre det opprinnelige listeobjektet i stedet for å returnere et nytt listeobjekt.

# 3) Bruke list.pop ((i))

Den fjerner og returnerer elementet på den gitte posisjonen i et listeobjekt. Hvis ingen i (indeks) er gitt, fjerner den og returnerer det siste elementet i listen.

Merk :Firkantet parentes rundt i over betyr ikke en liste over i, men det betyr at jeg er valgfri.

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

Merk: Listen. pop ((i)) metoden slettes på plass dvs. , vil den endre det opprinnelige listeobjektet i stedet for å returnere et nytt listeobjekt. Det returnerer også elementet som er fjernet fra listen

Bytte ut elementer fra en liste

Å bytte ut ting er ganske enkelt. I en av avsnittene ovenfor så vi indeksering og kutting. Disse kan brukes til å få tilgang til og fjerne elementer fra en liste.

# 1) Erstatt ved hjelp av indeksering

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) Skifte ut med kutting

L(n:m) = value

Merk : Verdi burde være en iterabel , ellers Type Feil unntak vil bli hevet.

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

ofte stilte spørsmål

Q # 1) Hva er en liste over lister i Python?

Svar: En liste over lister i Python er en liste som inneholder lister som element.

For eksempel

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

Det kan også omtales som en nestet liste .

Spørsmål 2) Hvordan erklærer du en liste i Python?

Svar: I Python kan en liste deklareres på to måter. Enten ved å bruke den innebygde funksjonen liste() eller ved å bruke brakettnotasjonen (). liste() tar inn en iterabel og () tar inn elementer av hvilken som helst type atskilt med 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)

Q # 3) Kan du sette en liste i en liste Python?

Svar: Ja, vi kan sette en liste inne i en liste. Faktisk er en liste en containersekvens som tar inn elementer av hvilken som helst datatype.

Q # 4) Hva gjør liste () i Python?

Svar: liste ( ) er en innebygd funksjon i Python som oppretter et listeobjekt. Det tar inn en iterabel som argument.

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

Q # 5) Kan en Python-liste inneholde forskjellige typer?

Svar: En liste er en containersekvens som tar inn elementer av alle datatyper ( liste , tuple , heltall , flyte , strenger , etc)

Mer om lister i Python

Hva er datastruktur?

Datamaskiner brukes til å lagre et stort antall data eller til å behandle et stort antall data med høy hastighet og nøyaktighet. Derfor er det best å lagre data permanent for rask tilgang.

Mens databehandling skjer, bør det skje på kortest mulig tid uten å miste nøyaktighet. Vi bruker datastrukturen til å håndtere data på en organisert måte og lagre data i minnet for behandling.

Siden Python er et høyt nivå og tolket programmeringsspråk, er det veldig viktig å benytte seg av datastrukturen i Python.

Hva er List?

En liste er en datastruktur som brukes til å lagre flere data samtidig.

Dataene som er lagret i en liste er homogene, og som igjen gjør den til den kraftigste funksjonen i listen i Python. Vi kan også lagre flere data av forskjellige datatyper som streng, helheter og objekter i en enkelt liste.

List kan endres i Python, og data kan dermed endres når som helst, selv etter opprettelsen. Lister er veldig kraftige for å implementere stabler og køer i Python.

Som diskutert tidligere, blir listen lagret data i en ordnet sekvens, og data som er lagret i en liste er tilgjengelig ved hjelp av indeksen, og for listen vil indeksen alltid starte fra null. Hvert element har et bestemt sted i listen, og alle disse dataene er tilgjengelige ved hjelp av en indeks.

I listen kan vi lagre den samme verdien flere ganger, og hver data vil bli betraktet som et eget og unikt element. Lister er best å lagre data og gjentas over dem på et senere tidspunkt.

Opprette en liste

Data i en liste lagres med kommaadskilt og lukkes i en firkantet parentes (()). Varene i listen trenger ikke å være av samme type.

Syntax: List = (item1, item2, item3)

Eksempel 1:

List = ( )

Eksempel 2:

List = (2, 5, 6.7)

Eksempel 3:

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

Eksempel 4:

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

I eksemplene ovenfor kan vi observere at vi har lagret elementer av forskjellige datatyper med komma atskilt, 2 og 5 er av typen Heltall, 6.7 er av typen float og 'Hi' er av typen String, alle disse elementene er lukket listen, og det gjør det til en liste.

Vi kan også erklære en tom liste. Vi kan også erklære listen i en annen liste, og vi kaller dette som en nestet liste.

Eksempel 5:

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

I eksemplet ovenfor kan du observere at en liste er deklarert i en annen liste.

Få tilgang til verdier i listen

Det er forskjellige måter vi kan få tilgang til elementene som er tilstede i listen i Python.

Ved hjelp av indeksen kan vi få tilgang til elementene i listen. Indeks starter fra 0 og indeksen skal alltid være et heltall. Hvis vi bruker en annen indeks enn heltall som float, vil det resultere i TypeError.

Eksempel 1:

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

Produksjon:

Listen er: (2, 5, 6.7, ‘Hei’)

Åpne_verdier_i_liste_eksempel_1

Produksjon:

hvordan du fjerner noe fra en array-java

Accessing_values_in_list_example_1_output

I eksemplet ovenfor skriver vi direkte ut listen ved hjelp av utskriftsfunksjonen, vi får ikke tilgang til det enkelte elementet fra listen.

La oss få tilgang til det enkelte elementet fra listen.

Eksempel: 2

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

Produksjon:

Andre element i listen er: 5

Åpne_verdier_i_liste_eksempel_2

Produksjon:

Accessing_values_in_list_example_2_output

I eksemplet ovenfor kan du observere at vi skriver ut det andre elementet i listen som er 5, men du kan få et spørsmål om hvorfor i utskriftsuttalelsen vi skriver ut Liste (1)? Det er fordi indeksen starter fra null, derav Liste (1) refererer til det andre elementet i listen.

Eksempel: 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))

Produksjon:

Første element i listen er: 2
Siste element i listen er: Hei

Åpne_verdier_i_liste_eksempel_3

Produksjon:

Accessing_values_in_list_example_3_output

Eksempel: 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))

Produksjon:

Første element i listen er: i
Elementene som finnes i en annen liste er: 5

Åpne_verdier_i_liste_eksempel_4

Produksjon:

Accessing_values_in_list_example_4_output

Hvis du observerer nøye i programmet ovenfor, kan du se at vi får tilgang til elementene fra den nestede listen.

Internt lagres dataene i et matriseformat som vist nedenfor:

Hei

2 4 5

Derfor, når vi prøver å få tilgang til Liste (0) (1), vil den peke på 1^St.rad og 2^ndkolonnen, og dermed vil data være 'i'.

På samme måte, når vi prøver å få tilgang til Liste (1) (2), vil den peke på 2^ndrad og 3^rdkolonnen, og dermed vil data være 5.

Negativ indeksering

Vi kan også få tilgang til data ved hjelp av en negativ indeks. En negativ indeks vil alltid starte fra -1 og -1 refererer til det siste elementet og -2 refererer til siste sekund element og så videre.

Eksempel: 1

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

Produksjon:

Siste element i listen er: 3

Negativ_indeksering_eksempel_1.1

Produksjon:

Negativ_indeksering_eksempel_1_utgang1

Eksempel: 2

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

Produksjon:

Andre element i listen er: 5

Negativ_indeksering_eksempel_2.1

Produksjon:

Negativ_indeksering_eksempel_2_utgang1

Skjæring av listen

Ved hjelp av skiveoperatøren (:) kan vi få tilgang til en rekke elementer fra listen

Eksempel: 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(:))

Produksjon:

Element fra 2. til 5. er: (2, 3, 4, 5)
Elementer som begynner til 2. er: (1, 2, 3, 4)
Elementer 4. til slutt er: (4, 5, 6, 7)
Elementer fra start til slutt er: (1, 2, 3, 4, 5, 6, 7)

Slicing_list_example_1.1

Produksjon:

Slicing_list_example_1_output1

Vi kan også få tilgang til elementene som er tilstede i listen ved hjelp av for loop.

Eksempel: 2

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

Produksjon:

1
to
3
4
5
6
7

Slicing_list_example_2

Produksjon:

Slicing_list_example_2_output1

Husk indekseringsformatet nedenfor:

H	ER	L	L	ELLER	5	7	9	4
0	1	to	3	4	5	6	7	8
-9	-8	-7	-6	-5	-4	-3	-to	-1

Som diskutert tidligere er List in python mutable, noe som betyr at elementene kan endres selv om det er et heltall eller en streng eller en hvilken som helst datatype.

Vi kan oppdatere listen ved hjelp av oppdragsoperatøren.

Eksempel: 3

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

Produksjon:

Oppdatert liste er: (7, 4, 6, 9)

Slicing_list_example_3.1

Produksjon:

Slicing_list_example_3_output1

I eksemplet ovenfor oppdaterer vi det første elementet i listen '2' med et nytt element '7'.

Eksempel: 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)

Produksjon:

Oppdatert liste er: (2, 5, 2, 4, 9, 0, 7)

I eksemplet ovenfor oppdaterer vi listen over data til listen.

Slicing_list_example_4.1

Produksjon:

Slicing_list_example_4_output1

Legge til elementer på listen

Det er flere måter vi kan legge til elementer i listen, og python har en innebygd funksjon kalt append ().

Ved hjelp av append () kan vi bare legge til ett element i listen. Hvis du vil legge til flere elementer i listen, må vi bruke for løkke . append () -funksjonen legger alltid til elementet på slutten av listen, append () -funksjonen tar bare ett argument.

Hvis du vil legge til elementer på en bestemt posisjon, trenger du bare å bruke metoden insert (). insert () tar to argumenter, dvs. posisjon og verdi, posisjon refererer til indeksen, der elementene må legges til og verdi refererer til elementet som skal legges til listen.

Det er en annen metode som kalles utvid (), ved hjelp av hvilken vi kan legge til elementer i listen. utvid () -metoden brukes til å legge til en liste over elementer i listen. I likhet med append () metode og utvid () metode, vil den også legge til elementer på slutten av listen.

Eksempel: 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)

Produksjon:

Listen før verdiene som legges til er: (“Hei”, “God morgen”)
Liste etter tilførte verdier er: (“Hallo”, “God morgen”, “Python”, “Hei”)

I eksemplet ovenfor legger vi til 'Python' og 'Hi' verdier til slutten av listen.

legg til () i python

Produksjon:

append () i Python Output

Eksempel: 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))

Produksjon:

Listen før verdiene som legges til er: (“Hei”, “God morgen”)
Lengden på listen før vedlegg er: 2
Liste etter tilførte verdier er: (“Hallo”, “God morgen”, “Python”, “Hei”)
Lengden på listen etter tillegg er: 4

Vi kan finne lengden på listen ved hjelp av len () -funksjonen, som vist i eksemplet ovenfor.

Legger til_element_til_listen_eksempel_2

Produksjon:

Legger til_element_til_listen_eksempel_2_utgang

Vi kan også legge til flere verdier i listen ved hjelp av for loop.

Eksempel: 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))

Produksjon:

Liste før du legger til elementer er: (7, 9, 8)
Lengden på listen før du legger til elementer er: 3
Liste etter å ha lagt til elementer er: (7, 9, 8, 2, 3, 4, 5)
Lengden på listen etter at du har lagt til elementer er: 7

Legger til_element_til_listen_eksempel_3

Produksjon:

Legger til_element_til_listen_eksempel_3_utgang1

Hva skjer hvis vi legger til en liste over en liste? La oss se det i eksemplet nedenfor.

Eksempel: 4

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

Produksjon:

List1 etter å ha lagt til List2 er: (“Hei”, “Python”, (1, 5, 7, 2))

Hvis du merker i eksemplet ovenfor, når vi legger List2 til List1, blir List1 en nestet liste.

Legger til_element_til_listen_eksempel_4

Produksjon:

Legger til_element_til_listen_eksempel_4_utgang

Hvis du ikke vil lage listen som en nestet liste etter at du har lagt til listen, er det bedre å bruke utvidelsesmetoden ().

Eksempel: 5

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

Produksjon:

List1 etter å ha lagt til List2 er: (“Hei”, “Python”, 1, 5, 7, 2)

Når vi bruker utvid () -metoden, utvides elementene i Liste1 med elementene i Liste2. Husk at den ikke vil legge til listen når vi bruker utvidelsesmetoden ().

Legger til_element_til_listen_eksempel_5

Produksjon:

Legger til_element_til_listen_eksempel_5_utgang

Når du utvider en liste med en streng, vil den legge til hvert tegn i strengen til listen, ettersom en streng er iterabel.

Eksempel: 6

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

Produksjon:

Liste etter utvidelse av strengen er: (1, 5, 7, 2, ‘P’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n ')

Legger til_element_til_listen_eksempel_6

Produksjon:

Legger til_element_til_listen_eksempel_6_utgang

Liste vedlegg () mot utvidelse ()

La oss ta en titt på noen eksempler for utvidelse () og vedlegg ().

Eksempel: 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()

Produksjon:

Elementene i List er: (“Hei”, 1, “Hei”, 2, 5)
Liste etter å ha lagt til strengen er: (“Hei”, 1, “Hei”, 2, 5, “Python”)
Liste etter at listen er lagt til er: (“Hei”, 1, “Hei”, 2, 5, “Python”, (“en”, “to”, 3))
List1 etter utvidelse av List2 er: (“Hei”, 1, “Hei”, 2, 5, “Python”, (“en”, “to”, 3), “Apple”, “Oransje”, 2, 8)

List_append_vs_extend_example_1.1

Produksjon:

List_append_vs_extend_example_3_output1

Eksempel: 2

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

Produksjon:

Listen før innsetting er: (“Apple”, “Orange”, “Mango”, “Strawberry”)
Liste etter innsetting er: ('Apple', 'Orange', 'Watermelon', 'Mango', 'Strawberry')

List_append_vs_extend_example_2.1

Produksjon

List_append_vs_extend_example_2_output1

Som vi diskuterte tidligere, brukes metoden insert () for å sette inn verdier i en bestemt indeks på listen.

Eksempel: 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)

Produksjon:

Liste etter at elementene er lagt til er: (2, 4, 6, 8, 1, 3, 5, 7)
Etter å ha lagt til de samme elementene gjentatte ganger er: ('Hei', 'Hei', 'Hei', 'Hei', 'Hei')

List_append_vs_extend_example_3.1

Produksjon:

List_append_vs_extend_example_3_output1

Slette eller fjerne elementer fra en liste

Vi kan også slette eller fjerne elementer fra listen ved å bruke del og fjerne () uttalelser.

c # objektorienterte programmeringskonsepter

La oss se i eksemplet nedenfor.

Eksempel: 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)

Produksjon:

Listen før du sletter det tredje elementet er: (1, 2, 3, 4, 5, 6, 7, 8, 9)
Liste etter sletting av tredje element er: (1, 2, 3, 5, 6, 7, 8, 9)
Liste etter å ha slettet flere elementer er: (1, 5, 6, 7, 8, 9)

I eksemplet ovenfor kan du se at vi har brukt del-setningen for å slette et element eller flere utsagn fra listen.

Slette_eller_fjerne_element_fra_listen_eksempel_11

Produksjon:

Slette_eller_fjerne_element_fra_listen_eksempel_1_utgang1

Nå vil vi se om remove () -metoden.

Eksempel: 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)

Produksjon:

Liste før du fjerner et element er: (1, 2, 3, 4, 5, 6, 7)
Liste etter fjerning av et element er: (1, 2, 4, 5, 6, 7)
Lista etter at du har poppet elementet er: (1, 2, 4, 5, 6)

I eksemplet ovenfor kan du se at vi fjerner et element fra listen ved hjelp av remove () -metoden. Pop () -metoden brukes til å fjerne / slette det siste elementet fra listen.

Slette_eller_fjerne_element_fra_listen_eksempel_2.1

Produksjon:

Slette_eller_fjerne_element_fra_listen_eksempel_2_utgang1

Liste Metoder

Metoder	Beskrivelse
klar()	For å fjerne alle elementene fra listen.
legg til ()	For å legge til element på slutten av listen.
sett inn()	For å sette inn element i en bestemt indeks på listen.
forlenge()	For å legge til en liste over elementer på slutten av listen.
telle()	Å returnere antall elementer med en spesifikk verdi.
indeks ()	Å returnere indeksen til det første elementet.
omvendt()	Å reversere en eksisterende liste.
ta vekk()	For å fjerne elementene fra listen.

Konklusjon

I denne opplæringen så vi på noen kjennetegn ved Python Lists sammen med de forskjellige måtene å manipulere en liste som lage en liste , få tilgang til elementer fra en liste , og erstatte elementer fra en liste.

Denne opplæringen på Python-listen kan avsluttes med følgende pekere:

List er en av datatypene i Python, som også kalles datastruktur.
List brukes til å lagre et stort antall verdier av alle datatyper i en enkelt variabel, noe som igjen hjelper å få tilgang til enkelt.
Indeks for liste starter alltid fra null som de andre programmeringsspråkene.
Hvis du jobber med listen, må du huske alle de vanlige innebygde funksjonene til den.

=> Besøk her for å lære Python fra grunnen

Python-liste - Opprett, tilgang, del opp, legg til eller slett elementer

Hva er Python-lister

Kjennetegn på Python List

Python-lister er containersekvenser

Python-lister er ordnede sekvenser

Python-lister er mutable sekvenser

Manipulere Python-lister

Opprette en liste

Legge til elementer i en liste

Få tilgang til elementer fra en liste

Lag en grunne kopi av en liste

Snu en liste

Fjerne elementer fra en liste

Bytte ut elementer fra en liste

ofte stilte spørsmål

Mer om lister i Python

Hva er datastruktur?

Hva er List?

Opprette en liste

Få tilgang til verdier i listen

Negativ indeksering

Skjæring av listen

Legge til elementer på listen

Liste vedlegg () mot utvidelse ()

Slette eller fjerne elementer fra en liste

Liste Metoder

Konklusjon

Anbefalt lesing