I denne veiledningen vil du utforske hvordan du kan benytte deg av Python-listemetoder for å utvide, modifisere og slette elementer fra lister i Python.
Når du starter din reise innenfor programmering med Python, vil lister raskt vise seg å være en av de første innebygde datastrukturene du vil stifte bekjentskap med. I de kommende minuttene skal vi gi et overblikk over det grunnleggende ved Python-lister, og deretter studere en rekke praktiske listemetoder som du kan benytte i arbeidet med lister.
La oss sette i gang!
En introduksjon til Python-lister
I Python er en liste definert som en ordnet samling av elementer, som kan være av samme eller ulike datatyper. Du har muligheten til å iterere gjennom samlingen for å hente ut elementene, ved hjelp av løkkekonstruksjoner som for-løkker.
Som alle iterable objekter i Python, benytter lister nullindeksering og gir støtte for slice-operasjoner.
De er mutable samlinger, som betyr at du kan foreta endringer i dem direkte. Dette inkluderer handlinger som å legge til og fjerne elementer fra listen, ordne elementene i en bestemt rekkefølge, snu rekkefølgen på elementene, og mye mer. Pythons innebygde listemetoder er til stor hjelp for å utføre disse operasjonene.
La oss nå ta en kikk på noen nyttige Python-listemetoder.
Innebygde listemetoder i Python
I dette avsnittet vil vi undersøke et utvalg listemetoder som kan være svært nyttige. Vi kommer til å generere kodeeksempler for å se disse metodene i praksis.
Vi skal benytte oss av følgende liste ved navn `pgm_langs`. Dette er en liste som inneholder strenger med navn på populære programmeringsspråk.
pgm_langs = ['Python','Go','Rust','JavaScript']
Sett inn elementer i listen ved hjelp av `insert()`
Det kan hende at du ønsker å plassere et element på en bestemt indeks. Dette kan du gjøre ved å bruke `insert()`-metoden. `insert()`-metoden krever følgende argumenter:
- Indeksen der elementet skal settes inn, og
- Elementet som skal settes inn.
La oss plassere strengen «Scala» på indeks 1 ved hjelp av `insert()`-metoden.
pgm_langs = ['Python','Go','Rust','JavaScript'] pgm_langs.insert(1,'Scala') print(pgm_langs) # Output: ['Python', 'Scala', 'Go', 'Rust', 'JavaScript']
Legg til elementer på slutten av listen med `append()`
Noen ganger vil du legge til et element helt på slutten av listen. For å gjøre dette kan du bruke `append()`-metoden.
La oss legge til strengen «Java» på slutten av listen ved hjelp av `append()`-metoden.
pgm_langs.append('Java')
print(pgm_langs)
# Output: ['Python', 'Scala', 'Go', 'Rust', 'JavaScript', 'Java']
Legg til en itererbar samling med `extend()`
Vi vet at vi kan benytte `append()`-metoden for å legge til et enkelt element. Men hva om du vil legge til flere elementer til en eksisterende liste, for eksempel en annen liste med elementer? `extend()`-metoden tilbyr en enkel og elegant måte å gjøre dette på.
La oss legge til elementene i listen `more_langs` til listen `pgm_langs` ved hjelp av `extend()`-metoden.
more_langs = ['C++','C#','C'] pgm_langs.extend(more_langs) print(pgm_langs) # Output: ['Python', 'Scala', 'Go', 'Rust', 'JavaScript', 'Java', 'C++', 'C#', 'C']
Du kan iterere gjennom listen med elementer og benytte `append()`-metoden for å legge til ett element om gangen. Dette kan imidlertid være litt tungvint, og det er mer praktisk å bruke `extend()`-metoden i stedet.
for lang in more_langs:
pgm_langs.append(lang)
Snu rekkefølgen på elementene i listen med `reverse()`
For å reversere rekkefølgen på elementer i en liste, kan du benytte `reverse()`-metoden.
Vi ser at listen `pgm_langs` nå har blitt reversert direkte.
pgm_langs.reverse() print(pgm_langs) # Output: ['C', 'C#', 'C++', 'Java', 'JavaScript', 'Rust', 'Go', 'Scala', 'Python']
Sortere en liste med `sort()`
Du kan sortere en Python-liste direkte ved hjelp av `sort()`-metoden. Ettersom `pgm_langs` er en liste med strenger, ser vi at sorteringen foregår i alfabetisk rekkefølge.
pgm_langs.sort() print(pgm_langs) # Output: ['C', 'C#', 'C++', 'Go', 'Java', 'JavaScript', 'Python', 'Rust', 'Scala']
For å sortere listen i omvendt alfabetisk rekkefølge, kan du sette parameteren `reverse` til `True` i kallet til `sort()`-metoden.
pgm_langs.sort(reverse=True) print(pgm_langs) # Output: ['Scala', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++', 'C#', 'C']
Utforsk mer om sortering av lister i Python.
Lag en overfladisk kopi av listen med `copy()`
Noen ganger kan det være hensiktsmessig å modifisere en kopi av den opprinnelige listen, i stedet for å endre selve den opprinnelige listen. Listemetoden `copy()` returnerer en overfladisk kopi av Python-listen.
La oss generere en overfladisk kopi av `pgm_langs`-listen og kalle den `pgm_langs_copy`. Deretter skal vi endre det første elementet i listen til «Haskell» og skrive den ut.
pgm_langs_copy = pgm_langs.copy() pgm_langs_copy[0]='Haskell'
print(pgm_langs_copy) # Output: ['Haskell', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++', 'C#', 'C']
Vi ser imidlertid at den opprinnelige listen `pgm_langs` ikke har blitt endret. Det å lage en overfladisk kopi og endre den endrer dermed ikke den opprinnelige listen.
print(pgm_langs) # Output: ['Scala', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++', 'C#', 'C']
Få elementtelling med `count()`
Av og til kan det være nyttig å vite hvor mange ganger et bestemt element forekommer i en liste. `count()`-metoden returnerer antall ganger et element forekommer i en liste.
I listen `pgm_langs` forekommer alle elementer nøyaktig én gang. Så når vi prøver å hente tellingen for «Go», får vi 1, som stemmer.
print(pgm_langs.count('Go'))
# Output: 1
Å bruke `count()`-metoden er én av flere måter å fjerne dupliserte elementer fra lister i Python.
Finn indeksen til et element med `index()`
For å finne indeksen til et element i en Python-liste, kan du benytte `index()`-metoden. Anta at vi ønsker å finne indeksen til «C#» i listen `pgm_langs`. Vi kan bruke `assert`-setningen for å bekrefte at elementet på indeks 7 er «C#».
print(pgm_langs.index('C#'))
# Output: 7
assert pgm_langs[7] == 'C#'
Fjern element ved en indeks med `pop()`
La oss nå se på listemetodene for å slette elementer fra Python-lister. `pop()`-metoden brukes for å fjerne og returnere et element på en spesifikk indeks. Fra det forrige kodeeksemplet vet vi at «C#» er språket på indeks 7.
Når vi kaller `pop()`-metoden på listen `pgm_langs` med 7 som indeks, ser vi at den returnerer «C#», altså elementet på indeks 7, og den fjerner det også fra listen.
print(pgm_langs.pop(7)) # Output: 'C#' print(pgm_langs) # Output: ['Scala', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++', 'C']
`pop()`-metoden fjerner og returnerer et element på den angitte indeksen. Det er imidlertid valgfritt å spesifisere indeksen. Når du ikke spesifiserer indeksen, fjerner og returnerer `pop()`-metoden det siste elementet i Python-listen, slik som vist:
print(pgm_langs.pop()) # Output: 'C' print(pgm_langs) # Output: ['Scala', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++']
Fjerne elementer med `remove()`
Noen ganger vet du kanskje hvilket element du skal fjerne, men ikke indeksen. I slike tilfeller kan du bruke metoden `remove()`. Metoden tar et element som input og fjerner det fra listen. La oss fjerne «Java» fra `pgm_langs`-listen ved å bruke `remove()`-metoden, slik det vises under.
pgm_langs.remove('Java')
print(pgm_langs)
# Output: ['Scala', 'Rust', 'Python', 'JavaScript', 'Go', 'C++']
Fjern alle elementer med `clear()`
Hva hvis du ønsker å fjerne alle elementene fra en Python-liste? Du kan iterere gjennom listen og fjerne hvert element ved hjelp av `remove()`-metoden, slik som dette:
for lang in pgm_langs:
pgm_langs.remove(lang)
Men finnes det en mer effektiv måte? Jada, du kan bruke `clear()`-metoden. Vi ser at kallet til `clear()`-metoden på `pgm_langs`-listen fjerner alle elementene, og `pgm_langs` er nå en tom liste.
pgm_langs.clear() print(pgm_langs) # Output: []
En oppsummering av Python-listemetoder
La oss raskt summere de ulike listemetodene og deres syntaks:
| Listemetode | Syntaks | Beskrivelse |
| `insert()` | `list1.insert(index, elt)` | Setter inn `elt` på `index` i `list1` |
| `append()` | `list1.append(elt)` | Legger `elt` til på slutten av `list1` |
| `extend()` | `list1.extend(list2)` | Legger til elementer fra `list2` til slutten av `list1` |
| `sort()` | `list1.sort()` | Sorterer listen direkte |
| `reverse()` | `list1.reverse()` | Reverserer `list1` direkte |
| `copy()` | `list1.copy()` | Returnerer en overfladisk kopi av `list1` |
| `count()` | `list1.count(elt)` | Returnerer tellingen av `elt` i `list1` |
| `index()` | `list1.index(elt)` | Returnerer indeksen for `elt` i `list1` |
| `pop()` | `list1.pop(index)` | Fjerner `elt` på `index` og returnerer den. |
| `remove()` | `list1.remove(elt)` | Fjerner `elt` fra `list1` |
| `clear()` | `list1.clear()` | Fjerner alle elementer fra `list1` |
Konklusjon
Jeg håper at denne opplæringen har hjulpet deg å forstå hvordan du kan bruke noen av de mest vanlige listemetodene i Python. Som et neste steg kan du utforske Python-tupler, og undersøke forskjellene mellom lister og tupler i Python.
Hvis du lærer Python, kan du sjekke ut denne listen over nybegynnervennlige læringsressurser.