python list create
I denne Python List-tutorial lærer vi måder at oprette, få adgang til, udskære, tilføje / slette elementer til Python-lister, der uden tvivl er en af de mest nyttige datatyper:
Python inkluderer 4 indsamlingsdatatyper som nævnt nedenfor:
- Liste
- Sæt
- Ordbog
- Tuple
I denne vejledning vil vi diskutere detaljeret om List og dens forskellige operationer. I Python er listen en datastruktur, eller det er ligesom et array, der bruges til at gemme flere data på én gang.
=> Udforsk Python Training Series her
Hvis du har erfaring med andre programmeringssprog som Java, C, C ++ osv., Vil du være bekendt med begrebet arrays. Listen er næsten den samme som arrays.
Hvad du lærer:
- Hvad er Python-lister
- Mere om lister i Python
- Konklusion
Hvad er Python-lister
I Python er en liste en datatype , der gemmer en samling af forskellige objekter (genstande) inden for en firkantet parentes (()). Hvert element på en liste er adskilt med et komma (,) med det første element i indeks 0.
Bemærk :Fremadrettet kører alle eksemplerne i denne vejledning direkte fra en Python-skal, medmindre andet er angivet.
Nedenfor er et eksempel på en liste med 5 emner.
>>> l = ('what','who','where','when','how') >>>l ('what','who','where','when','how')
I ovenstående eksempel kan vi se, at listen har Streng objekter som emner, og hvert emne er adskilt med et komma.
Karakteristik af Python List
Før vi ser på, hvordan vi kan manipulere elementer på en liste, skal vi se på nogle af de egenskaber, der gør Python-lister favoriserede.
Python-lister er containersekvenser
I modsætning til flade sekvenser ( snor , array.array , hukommelsesvisning osv.), der kun kan indeholde emner af en type, en liste er en container sekvens der kan indeholde genstande af en type såvel som af forskellige typer.
Eksempel med varer af en type
Lad os åbne vores pythonskal og definere en liste med tal.
>>> numbers = ('one','two','three','four','five') >>> numbers ('one','two','three','four','five')
Eksemplet ovenfor viser en liste over emner af samme type, i dette tilfælde af typen streng (str) .
Eksempel med emner af forskellige typer
Lad os åbne vores Python-skal og definere en anden version af en liste over numre.
>>> numbers = ('one',2,3,'four',5.0) >>> numbers ('one',2,3,'four',5.0)
Eksemplet ovenfor viser en liste over emner af forskellige typer. Typerne er snor , heltal, og flyde .
// a sketch showing the list of items and their types as annotation
Python-listen kan også indeholde alle objekter som f.eks funktioner , klasser , moduler , lister , tupler, og meget mere.
Åbn en editor og indsæt nedenstående kode:
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-lister er ordnede sekvenser
En Python-liste er en ordnet samling af objekter. Positionen for hvert element på en liste er meget vigtig. Faktisk er to lister med de samme varer ikke de samme, hvis rækkefølgen, som varerne er placeret i, ikke er den samme.
>>> ('a','b','c','d') == ('a','c','b','d') False
Denne egenskab ved Python-listen gør det muligt at få adgang til dens emner ved indeks og udskæring (mere om dette senere).
Python-lister er mutable sekvenser
Python-lister er mutable. Men hvad er et foranderligt objekt? Det er simpelthen et objekt, der kan ændres, når det er oprettet. Eksempler af andre mutable sekvenser er ordbog , array.array , collection.deque .
Hvorfor mutable? Sekvenser som lister bruges til komplekse operationer, så det giver mening, at de skal være i stand til det lave om , dyrke , krympe , opdatering osv . Dette er kun muligt med mutabilitet. Mutabilitet giver os også mulighed for at ændre lister på plads (mere om dette).
Lad os kontrollere mutationerne af en liste med nedenstående eksempel.
Bare åbn en editor og indsæt 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
Fra ovenstående output bemærker vi, at listen før og efter ændring er forskellig. Men den Id værdien er den samme. Det Id værdi repræsenterer her objektets adresse i hukommelsen - der opnås med Python id () .
Dette fortæller os, at selvom listeindholdet er ændret, er det stadig det samme objekt. Derfor opfylder dette vores definition: “ Det er simpelthen et objekt, der kan ændres, når det er oprettet '
Bemærk :I eksemplet ovenfor brugte vi indeksering (mere om dette) til at ændre listen.
Manipulering af Python-lister
Med Python-lister er himlen vores grænse. Der er utallige ting, vi kan gøre med lister som tilføjer , sletter , indeksering , udskæring , kontrol for medlemskab , og meget mere. Python har også indbyggede funktioner, der hjælper med at gøre manipuleringslister mere spændende.
I dette afsnit vil vi se på nogle almindeligt anvendte listehandlinger.
Oprettelse af en liste
For at oprette en liste skal du blot sætte et antal emner eller udtryk i en firkantet parentes adskilt af kommaer.
(expression1, expression2,...,expresionN)
>>> l = (4,3,5,9+3,False) >>> l (4, 3, 5, 12, False)
Python har også et indbygget objekt kaldet liste (), der kan bruges til at oprette lister.
list( sequence )
>>> l = list() # create an empty list >>> l ()
Python liste () kan tage sekvenstyper ind og konvertere dem til lister. Dette er den typiske måde at konvertere en tuple til en liste.
>>> t = (4,3,5) # tuple >>>l = list(t) # convert into list (4,3,5)
I eksemplet ovenfor brugte vi datatypen Tuple . Det ligner en liste, men i modsætning til lister er det uforanderligt, og dets emner er omgivet af parenteser.
Et andet middel, hvormed vi kan oprette en liste, er ved hjælp af listeforståelser der har følgende syntaks.
(expression for item in sequence)
>>> (i**2 for i in range(4)) (0, 1, 4, 9)
Det er værd at bemærke, at Python-lister sendes som reference. Betydning, tildeling af en liste giver dens hukommelsesplaceringsidentitet. Den fejl, som mange nybegyndere gør, er at oprette lister på denne måde.
>>> l1 = l2 = (4,3) # wrong way to create separate list objects >>> l1 (4,3) >>> l2 (4,3)
Her tror vi måske, at vi har oprettet to forskellige lister, men virkelig har vi lige oprettet en. Lad os demonstrere dette ved at ændre en af variablerne.
>>> l1(0) = 0 >>> l1 (0,3) >>> l2 (0,3)
Vi bemærker, at ændring af den ene variabel ændrer den anden. Dette skyldes, at begge variablerne l1 og l2 har den samme hukommelsesplaceringsidentitet, så de begge peger på det samme objekt.
Tilføjelse af varer til en liste
Python har mange måder at tilføje elementer til sin liste. Den mest almindelige måde er at bruge Tilføj() metode. De andre måder er ved at bruge forlænge() metode. Indeksering og udskæring (mere om disse senere) bruges mere sandsynligt til at erstatte emner på en liste.
# 1) Brug af append () -metoden
Denne metode optager et enkelt element og tilføjer det til slutningen af listen. Det returnerer ikke en ny liste, men ændrer bare listen på plads (takket være dens æ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å ting at bemærke fra eksemplet ovenfor:
- Elementer her kan være udtryk, datatyper, sekvenser og mange flere.
- Det Tilføj() metoden har en tidskompleksitet på (0) 1. Det betyder, at det er konstant.
# 2) Brug udvidelsesmetoden ()
Denne metode tager en iterabel som argument og tilføjer alle elementerne fra den til slutningen af listen. Denne metode bruges mest, når vi vil tilføje individuelle emner i en sekvens til en liste
Dybest set er det forlænge() metode gentager sit argument og tilføjer hvert element til listen. Ligesom metoden append () returnerer den ikke en ny liste, men ændrer listen på plads.
>>> 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 at bemærke fra ovenstående eksempel:
- En streng kan gentages, så vores forlænge() metode gentages over dens tegn.
- Det forlænge() metoden har en tidskompleksitet på (0) K hvor K er længden af sit argument.
Adgang til emner fra en liste
Indeksering og udskæring er de mest almindelige midler, der bruges til at få adgang til lister. Vi kan også få adgang til emner på en liste med sløjfer som til løkke .
# 1) Indeksering
En Python-liste bruger nulbaseret nummerering system. Det vil sige, at alle dets emner identificeres entydigt med et indeksnummer, der starter fra 0 til n-1, hvor n er længden på listen.
Overvej 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 nulbaseret nummerering af en liste.
Vare | net | blå | grøn | gul | sort |
---|---|---|---|---|---|
pop () | For at slette / fjerne elementet fra det sidste på en liste. | ||||
Indeks | 0 | 1 | to | 3 | 4 |
Fra tabellen ovenfor ser vi, at det første element ('rødt') er i indekspositionen 0, og det sidste element ('sort') er i indeksposition 4 (n-1), hvor n = 5 (objektets længde farver).
Som vi så i det karakteristiske afsnit ovenfor, er Python-lister ordnede sekvenser. Dette giver os mulighed for at bruge indeksering til let at få adgang til og manipulere dets genstand.
Lad os bruge indeksering til at få adgang til emner på bestemte indekser for farverobjektet oprettet 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
Bemærk :Den sidste sætning ovenfor forsøger at få adgang til et element i indeksposition 9 fra et listeobjekt med længde 5. I Python-listen hæves adgang til et element i et indeks, der ikke findes IndexError undtagelse.
Et vigtigt begreb med indeksering er, at vi kan bruge negativ indeksering, dvs. vi kan få adgang til elementer på en liste på en omvendt måde, der starter ved -1 for det sidste element og slutter ved -n for det sidste element, hvor n er listeobjektets længde.
I ovenstående tabel, hvis vi bruger negativ indeksering, vil det se ud som vist nedenfor:
Vare | net | blå | grøn | gul | sort |
---|---|---|---|---|---|
Indeks | -5 | -4 | -3 | -to | -1 |
Lad os bruge negativ indeksering for at få adgang til nogle elementer i farveobjektet oprettet 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) Skæring
I modsætning til indeksering, der kun returnerer en vare, udskæring på den anden side kan returnere en række varer.
Den har følgende syntaks:
L(n:m)
Når n er indeksnummeret, hvor udsnittet starter (standard er 0), og m er det eksklusive indeksnummer, hvor udsnittet slutter (standardværdi til længde-1). De er adskilt af et kolon (:)
Overvej nedenstående eksempel, der bruger skæring til at få adgang til emner på bestemte indekser for farverobjektet oprettet 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 er L (n: m), n som standard 0, og m er som standard længden på listen. Så i eksempler 1 og 3 ovenfor kunne vi udelade n og m som henholdsvis farver (: 2) og farver (2:). Eller (:) som i dette tilfælde returnerer en lav kopi af hele listeobjektet.
Vi kan også bruge negative indeksnumre, mens vi udskærer lister. Dette bruges typisk, når vi ønsker at få adgang til listen på en omvendt måde.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(-3:-2) ('green') >>> colors(-2:) ('yellow', 'black')
Der er også en tredje parameter, som udskæring understøtter kaldet trin (s). Det definerer, hvor mange emner der skal bevæge sig, efter at det første element er hentet fra listen. Den er som standard 1.
L(n:m:s)
Brug vores samme farveliste som defineret ovenfor, lad os bruge udsnitets tredje parameter til at flytte 2 trin.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0:3:2) ('red', 'green')
# 3) Brug af sløjfer
Sløjfer bruges oftest til at få adgang til varer på en liste for at manipulere elementerne. Så hvis vi vil operere på emnerne på en liste, kan vi bruge til løkke for at få adgang til varerne og videregive dem for at blive betjent.
Sig, vi vil tælle antallet af bogstaver for hvert element. Vi kan bruge til løkke for at opnå det.
Åbn en editor og indsæt 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))
Produktion
For at afslutte dette afsnit skal vi se på to seje ting, der kan gøres med udskæring.
-
Lav en lav kopi af en liste
Det er den grundlæggende måde at bruge kopi() metode til listeobjektet eller den indbyggede funktion kopi. kopi . Dette kan dog opnås ved at skære.
>>> 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') >>>
-
Vend en liste
Den grundlæggende måde er at bruge baglæns metode til listeobjektet eller den indbyggede funktion omvendt () . Dette kan dog opnås ved at skære.
>>> 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') >>>
Fjernelse af emner fra en liste
Da vi kan tilføje så mange elementer til en liste, kan de også fjernes fra en liste. De tre måder, hvorpå genstande kan fjernes, er:
# 1) Brug af del-sætningen
Den har følgende syntaks:
del target_list
Mållisten ( målliste ) kan være hele listen (i tilfælde af at du vil slette listen) eller et element eller elementer på en liste (i dette tilfælde bruger du indeksering eller udskæring).
Overvej eksemplet nedenfor .
Sig, vi vil slette nogle emner fra listen over farver, der er oprettet 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 >>>
Bemærk :Del-erklæringen slettes på plads dvs. , vil det ændre det originale listeobjekt i stedet for at returnere et nyt listeobjekt.
# 2) Brug af listen. Fjern (x)
Det fjerner det første element fra listen, hvis værdi er lig med x . Det rejser en ValueError, hvis der ikke er sådan en vare.
Denne metode bruges hovedsageligt til at fjerne elementer fra en liste efter navn, i modsætning til del-sætningen, der bruger indeksering og udskæring.
>>> 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 >>>
Bemærk :Listeobjektet fjerne() metode slettes på plads dvs. , vil det ændre det originale listeobjekt i stedet for at returnere et nyt listeobjekt.
# 3) Brug af list.pop ((i))
Det fjerner og returnerer elementet på den givne position i et listeobjekt. Hvis der ikke er angivet i (indeks), fjernes og returneres det sidste element på listen.
Bemærk :Den firkantede parentes omkring i ovenfor betyder ikke en liste over i, men det betyder snarere, 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') >>>
Bemærk: Listen. pop ((i)) metode slettes på plads dvs. , vil det ændre det originale listeobjekt i stedet for at returnere et nyt listeobjekt. Det returnerer også det element, der er fjernet fra listen
Udskiftning af emner fra en liste
Udskiftning af ting er ret simpelt. I et af ovenstående afsnit så vi indeksering og udskæring. Disse kan bruges til at få adgang til og fjerne emner fra en liste.
# 1) Udskift ved hjælp af 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) Udskiftning ved hjælp af udskæring
L(n:m) = value
Bemærk : Værdi skal være en iterabel , ellers TypeFejl undtagelse hæves.
>>> 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 stillede spørgsmål
Q # 1) Hvad er en liste over lister i Python?
Svar: En liste over lister i Python er en liste, der indeholder lister som element.
For eksempel
(('a','b'),('c','d'))
Det kan også kaldes en indlejret liste .
Spørgsmål nr. 2) Hvordan erklærer du en liste i Python?
Svar: I Python kan en liste erklæres på to måder. Enten ved hjælp af den indbyggede funktion liste() eller ved hjælp af beslagnotationen (). liste() tager en iterabel og () optager elementer af enhver type adskilt med et 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 placere en liste i en liste Python?
Svar: Ja, vi kan placere en liste inde i en liste. Faktisk er en liste en containersekvens, der optager elementer af enhver datatype.
Spørgsmål nr. 4) Hvad gør liste () i Python?
Svar: liste ( ) er en indbygget funktion i Python, der opretter et listeobjekt. Det tager en iterabel ind som argumentet.
>>> list((3,2,4)) # The iterable object here is a tuple. (3, 2, 4) >>>
Q # 5) Kan en Python-liste indeholde forskellige typer?
Svar: En liste er en containersekvens, der optager elementer af alle datatyper ( liste , tuple , heltal , flyde , strenge , etc)
Mere om lister i Python
Hvad er datastruktur?
Computere bruges til at gemme et stort antal data eller til at behandle et stort antal data med høj hastighed og nøjagtighed. Derfor er det bedst at gemme data permanent for hurtig adgang.
Mens databehandling sker, skal det ske inden for den kortest mulige tid uden at miste nøjagtighed. Vi bruger datastrukturen til at håndtere data på en organiseret måde og gemme data i hukommelsen til behandling.
Da Python er et højt niveau og fortolket programmeringssprog, er det meget vigtigt at gøre brug af datastrukturen i Python.
Hvad er liste?
En liste er en datastruktur, der bruges til at gemme flere data på én gang.
Dataene, der er gemt på en liste, er homogene, og det gør det igen til den mest kraftfulde funktion i listen i Python. Vi kan også gemme flere data af forskellige datatyper som streng, heltal og objekter på en enkelt liste.
Liste kan ændres i Python, så data kan ændres når som helst, selv efter oprettelsen. Lister er meget effektive til implementering af stakke og køer i Python.
Som tidligere diskuteret er der lagret data i en ordnet rækkefølge, og der er adgang til data, der er gemt på en liste ved hjælp af deres indeks, og for listen starter indekset altid fra nul. Hvert element har et specifikt sted på listen, og alle disse data fås ved hjælp af et indeks.
På listen kan vi gemme den samme værdi flere gange, og hver data betragtes som et separat og unikt element. Lister er bedst at gemme data og gentage dem på et senere tidspunkt.
Oprettelse af en liste
Data på en liste er gemt med komma-adskilt og lukket i en firkantet parentes (()). Elementer på listen behøver ikke at være af 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 ovenstående eksempler kan vi observere, at vi har gemt elementer af forskellige datatyper med komma adskilt, 2 og 5 er af typen heltal, 6.7 er af typen float og 'Hi' er af typen String, alle disse emner er lukket liste, og det gør det til en liste.
Vi kan også erklære en tom liste. Vi kan også erklære listen inde i en anden liste, og vi kalder dette som en indlejret liste.
Eksempel 5:
List = (‘Hi’, (2, 4, 5), (‘Hello’))
I ovenstående eksempel kan du se, at en liste er blevet deklareret på en anden liste.
Adgang til værdier i listen
Der er forskellige måder, hvorpå vi kan få adgang til de emner, der findes på listen i Python.
Ved hjælp af indekset kan vi få adgang til elementerne på listen. Indeks starter fra 0, og indekset skal altid være et heltal. Hvis vi bruger et andet indeks end heltal som float, vil det resultere i TypeError.
Eksempel 1:
List = (2, 5, 6.7, ‘Hi’) print(“List is:”, List)
Produktion:
Listen er: (2, 5, 6.7, 'Hej')
Produktion:
hvordan man starter et projekt i formørkelse
I ovenstående eksempel udskriver vi listen direkte ved hjælp af udskrivningsfunktionen, vi har ikke adgang til det enkelte element fra listen.
Lad os få adgang til det enkelte element fra listen.
Eksempel: 2
List = (2, 5, 6.7, ‘Hi’) print(“Second element of the list is:”, List(1))
Produktion:
Andet element på listen er: 5
Produktion:
I ovenstående eksempel kan du se, at vi udskriver det andet element på listen, der er 5, men du kan få et spørgsmål om, hvorfor i udskriftserklæringen vi udskriver liste (1)? Det skyldes, at indekset starter fra nul, derfor refererer Liste (1) til det andet element på 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))
Produktion:
Første element i listen er: 2
Sidste element på listen er: Hej
Produktion:
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))
Produktion:
Første element på listen er: i
Elementer til stede på en anden liste er: 5
Produktion:
I ovenstående program, hvis du observerer nøje, kan du se, at vi har adgang til elementerne fra den indlejrede liste.
Internt gemmes dataene i et matrixformat som vist nedenfor:
Hej
2 4 5
Derfor, når vi prøver at få adgang til Liste (0) (1), vil den pege på 1St.række og 2ndkolonne, hvorved data vil være 'i'.
På samme måde, når vi prøver at få adgang til Liste (1) (2), vil den pege på 2ndrække og 3rdkolonne, derved vil data være 5.
Negativ indeksering
Vi kan også få adgang til data ved hjælp af et negativt indeks. Et negativt indeks starter altid fra -1, og -1 henviser til det sidste element, og -2 henviser til det sidste sekund, og så videre.
Eksempel: 1
List = (2, 5, 7, 3) print(“Last element in the list is: ”, List(-1))
Produktion:
Sidste element på listen er: 3
Produktion:
Eksempel: 2
List = (2, 5, 7, 3) print(“Second element in the list is: ”, List(-3))
Produktion:
Andet element på listen er: 5
Produktion:
Udskæring af listen
Ved hjælp af skiveoperatøren (:) kan vi få adgang til en række 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(:))
Produktion:
Elementerne fra 2. til 5. er: (2, 3, 4, 5)
Elementer, der begynder til 2. er: (1, 2, 3, 4)
Elementerne 4. til slutningen er: (4, 5, 6, 7)
Elementer fra start til slut er: (1, 2, 3, 4, 5, 6, 7)
Produktion:
Vi kan også få adgang til de elementer, der findes på listen ved hjælp af for loop.
Eksempel: 2
List = (1, 2, 3, 4, 5, 6, 7) forele in List: print(ele)
Produktion:
1
to
3
4
5
6
7
Produktion:
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 diskuteret tidligere er List in python mutable, hvilket betyder, at elementerne kan ændres, selvom det er et heltal eller en streng eller en hvilken som helst datatype.
Vi kan opdatere listen ved hjælp af tildelingsoperatøren.
Eksempel: 3
List = (2, 4, 6, 9) #updating the first element List(0) = 7 print(“Updated list is: ”, List)
Produktion:
Opdateret liste er: (7, 4, 6, 9)
Produktion:
I ovenstående eksempel opdaterer vi det første element på listen '2' med et nyt 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)
Produktion:
Opdateret liste er: (2, 5, 2, 4, 9, 0, 7)
I ovenstående eksempel opdaterer vi listen over data til listen.
Produktion:
Tilføjelse af elementer til listen
Der er flere måder, hvorpå vi kan tilføje elementer til listen, og python har en indbygget funktion kaldet append ().
Ved hjælp af append () kan vi kun tilføje et element til listen, hvis du vil tilføje flere elementer til listen, skal vi bruge til løkke . append () - funktionen tilføjer altid elementet i slutningen af listen, append () - funktionen tager kun et argument.
Hvis du vil tilføje elementer på en bestemt position, skal du bare bruge metoden insert (). insert () tager to argumenter, dvs. position og værdi, position refererer til indekset, hvor elementerne skal tilføjes, og værdi refererer til det element, der skal føjes til listen.
Der er endnu en metode, der kaldes udvidelse (), ved hjælp af hvilken vi kan tilføje elementer til listen. metoden udvid () bruges til at tilføje en liste med elementer til listen. Svarende til append () -metoden og udvidelsesmetoden () tilføjer den også elementer i slutningen af 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)
Produktion:
Liste før tilføjede værdier er: (“Hej”, “God morgen”)
Liste efter tilføjede værdier er: (“Hej”, “God morgen”, “Python”, “Hej”)
I ovenstående eksempel tilføjer vi 'Python' og 'Hi' værdier til slutningen af listen.
Produktion:
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))
Produktion:
Liste før tilføjede værdier er: (“Hej”, “God morgen”)
Længden af listen inden tilføjelse er: 2
Liste efter tilføjede værdier er: (“Hej”, “God morgen”, “Python”, “Hej”)
Længden af listen efter tilføjelse er: 4
Vi kan finde længden på listen ved hjælp af len () -funktionen, som vist i eksemplet ovenfor.
Produktion:
Vi kan også tilføje flere værdier til listen ved hjælp af 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))
Produktion:
Listen før tilføjelse af elementer er: (7, 9, 8)
Længden på listen, før elementerne tilføjes, er: 3
Liste efter tilføjelse af elementer er: (7, 9, 8, 2, 3, 4, 5)
Længden af listen efter tilføjelse af elementer er: 7
Produktion:
Hvad sker der, hvis vi føjer en liste med en liste til en liste? Lad os se det i nedenstående eksempel.
Eksempel: 4
List1 = (“Hi”, “Python”) List2 = (1, 5, 7, 2) List1.append(List2) print(“List1 after appending List2 is: “, List1)
Produktion:
List1 efter tilføjelse af List2 er: (“Hej”, “Python”, (1, 5, 7, 2))
Hvis du bemærker i ovenstående eksempel, når vi tilføjer List2 til List1, bliver List1 en indlejret liste.
Produktion:
Hvis du ikke vil oprette listen som en indlejret liste efter tilføjelse af listen, er det bedre at bruge udvidelsesmetoden ().
Eksempel: 5
List1 = (“Hi”, “Python”) List2 = (1, 5, 7, 2) List1.extend(List2) print(“List1 after appending List2 is: “, List1)
Produktion:
List1 efter tilføjelse af List2 er: (“Hej”, “Python”, 1, 5, 7, 2)
Når vi bruger udvidelsesmetoden (), udvides elementerne i Liste1 med elementerne i Liste2. Husk, det tilføjer ikke listen, når vi bruger metoden for udvidelse ().
Produktion:
Når du udvider en liste med en streng, tilføjer den hvert tegn i strengen til listen, da en streng kan gentages.
Eksempel: 6
List = (1, 5, 7, 2) List.extend(“Python”) print(“List after extending the String is: “, List)
Produktion:
Liste efter udvidelse af strengen er: (1, 5, 7, 2, 'P', 'y', 't', 'h', 'o', 'n')
Produktion:
Liste tilføj () vs udvid ()
Lad os se på nogle eksempler til udvidelse () og tilføj ().
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()
Produktion:
Elementerne i listen er: (“Hej”, 1, “Hej”, 2, 5)
Liste efter tilføjelse af strengen er: (“Hej”, 1, “Hej”, 2, 5, “Python”)
Liste efter tilføjelse af listen er: (“Hej”, 1, “Hej”, 2, 5, “Python”, (“en”, “to”, 3))
Liste1 efter udvidelse af List2 er: (“Hej”, 1, “Hej”, 2, 5, “Python”, (“en”, “to”, 3), “Æble”, “Orange”, 2, 8)
Produktion:
Eksempel: 2
List = (“Apple”, “Orange”, “Mango”, “Strawberry”) print(“List before inserting is: “, List) List.insert(2, “Watermelon”) print(“List after inserting is: “, List)
Produktion:
Listen før indsættelse er: (“Apple”, “Orange”, “Mango”, “Strawberry”)
Liste efter indsættelse er: ('Apple', 'Orange', 'Vandmelon', 'Mango', 'Strawberry')
Produktion
Som vi diskuterede tidligere, anvendes insert () -metoden til at indsætte værdier i et 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)
Produktion:
Liste efter tilføjelse af elementerne er: (2, 4, 6, 8, 1, 3, 5, 7)
Efter gentagne tilføjelser er de samme elementer: ('Hej', 'Hej', 'Hej', 'Hej', 'Hej')
Produktion:
Sletning eller fjernelse af elementer fra en liste
Vi kan også slette eller fjerne elementer fra listen ved hjælp af del og fjerne () udsagn.
hvad er processen med at identificere og fjerne fejl fra computerhardware eller software?
Lad os se i nedenstående eksempel.
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)
Produktion:
Listen før sletning af 3. element er: (1, 2, 3, 4, 5, 6, 7, 8, 9)
Liste efter sletning af 3. element er: (1, 2, 3, 5, 6, 7, 8, 9)
Liste efter sletning af flere elementer er: (1, 5, 6, 7, 8, 9)
I ovenstående eksempel kan du se, at vi har brugt del-sætning til at slette et element eller flere udsagn fra listen.
Produktion:
Nu vil vi se om metoden remove ().
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)
Produktion:
Listen før fjernelse af et element er: (1, 2, 3, 4, 5, 6, 7)
Liste efter fjernelse af et element er: (1, 2, 4, 5, 6, 7)
Liste efter at poppe elementet er: (1, 2, 4, 5, 6)
I ovenstående eksempel kan du se, at vi fjerner et element fra listen ved hjælp af remove () -metoden. Pop () -metoden bruges til at fjerne / slette det sidste element fra listen.
Produktion:
Listemetoder
Metoder | Beskrivelse |
---|---|
klar() | For at fjerne alle elementerne fra listen. |
Tilføj() | For at tilføje element i slutningen af listen. |
indsæt () | For at indsætte element i et bestemt indeks på listen. |
forlænge() | For at tilføje en liste med elementer i slutningen af listen. |
tælle() | At returnere antallet af elementer med en bestemt værdi. |
indeks() | For at returnere indekset for det første element. |
baglæns() | For at vende en eksisterende liste. |
fjerne() | For at fjerne elementerne fra listen. |
Konklusion
I denne vejledning kiggede vi på nogle egenskaber ved Python Lists sammen med de forskellige måder at manipulere en liste som f.eks oprettelse af en liste , adgang til emner fra en liste og udskiftning af emner fra en liste.
Denne vejledning på Python-listen kan afsluttes med følgende markører:
- List er en af datatyperne i Python, som også kaldes datastruktur.
- Liste bruges til lagring af et stort antal værdier af alle datatyper i en enkelt variabel, hvilket igen hjælper med at få let adgang.
- Indeks for liste starter altid fra nul som de andre programmeringssprog.
- Hvis du arbejder på listen, skal du huske alle de almindelige indbyggede funktioner i den.
=> Besøg her for at lære Python fra bunden
Anbefalet læsning
- Python-vejledning til begyndere (GRATIS Python-træning)
- Python-variabler
- Python Advanced List Tutorial (List Sort, Reverse, Index, Copy, Join, Sum)
- Python Tuple-tutorial med praktiske eksempler
- Python-strengfunktioner
- Lister i STL
- Sammenkædet liste datastruktur i C ++ med illustration
- Cirkulær sammenkædet liste Datastruktur i C ++ med illustration