Forstå forskjellen mellom Python Tuples og Lister
I denne veiledningen vil du utforske likhetene og forskjellene mellom tupler og lister i Python. Du vil også få innsikt i når det er mest hensiktsmessig å bruke en tuppel.
Både lister og tupler er sentrale datastrukturer i Python. De er utformet for å lagre samlinger av elementer.
Med funksjoner som indeksering, slicing og evnen til å håndtere forskjellige datatyper, kan tupler og lister virke veldig like. Derfor er det viktig å forstå nyansene mellom dem for å velge den rette datastrukturen for ditt behov.
La oss begynne å utforske dette!
👩🏽💻 Du kan starte en Python REPL (Read-Eval-Print Loop) og følge med, eller bruke en online Python-editor som tipsbilk.net for å skrive og teste koden.
Likheter mellom Python Tuples og Lister
Først ser vi på hva som er likt mellom lister og tupler. For å gjøre det mer oversiktlig, vil vi se på eksempler for begge typer.
#1. Python Itererbare Objekter
I Python defineres lister med firkantede parenteser `[]`, mens tupler bruker vanlige parenteser `()`. Du kan også definere en tuppel ved å separere verdier med komma, uten parenteser.
Både lister og tupler er itererbare, noe som betyr at du kan gå gjennom dem ved hjelp av en `for`-løkke.
Kodesnutten nedenfor viser hvordan man itererer gjennom en liste:
nums = [2,6,7,10]
print(f"Type of nums is {type(nums)}")
for num in nums:
print(num)
# Output
Type of nums is <class 'list'>
2
6
7
10
Som vist nedenfor, kan du også iterere gjennom en tuppel ved hjelp av en løkke:
nums = (2,6,7,10)
# Merk: nums = 2,6,7,10 er også en gyldig tuppel. Hvis du er usikker, test det raskt!
print(f"Type of nums is {type(nums)}")
for num in nums:
print(num)
# Output
Type of nums is <class 'tuple'>
2
6
7
10
#2. Opprettelse fra Andre Sekvenser
En annen likhet er at både lister og tupler kan opprettes fra eksisterende sekvenser, som for eksempel strenger.
sample_str = "Koding!"
Følgende kode viser hvordan `list(streng)` returnerer en liste hvor hvert element er et tegn fra strengen.
list_from_str = list(sample_str)
print(list_from_str)
# Output
['K', 'o', 'd', 'i', 'n', 'g', '!']
På samme måte kan en tuppel lages fra en streng eller en annen sekvens ved å bruke `tuple(sekvens)`. Kodesnutten under demonstrerer hvordan:
tuple_from_str = tuple(sample_str)
print(tuple_from_str)
# Output
('K', 'o', 'd', 'i', 'n', 'g', '!')
#3. Støtte for Indeksering og Slicing
Python bruker nullindeksering, der det første elementet har indeks 0, det andre har indeks 1, og så videre. Python tillater også negativ indeksering, der det siste elementet har indeks -1, det nest siste har -2, og så videre.
list_from_str = ['K', 'o', 'd', 'i', 'n', 'g', '!']
print(list_from_str[1])
# o
Elementet med indeks -2 er det nest siste elementet, «g».
tuple_from_str = ('K', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[-2])
# g
Slicing lar deg jobbe med deler av en liste eller tuppel. `liste[start:slutt]` returnerer en del av listen fra `start`-indeksen opp til, men ikke inkludert `slutt`-indeksen. Standardverdien for `start` er 0, og `slutt` er det siste elementet i den itererbare.
Du kan bruke samme syntaks for å slice tupler. La oss lage deler av listen og tuppelen vi har brukt tidligere.
list_from_str = ['K', 'o', 'd', 'i', 'n', 'g', '!']
print(list_from_str[0:5])
['K', 'o', 'd', 'i', 'n']
I tillegg til `start` og `slutt` kan du også spesifisere en `steg`-verdi. `tuple(start:slutt:steg)` returnerer en del av tuppelen fra `start` til `slutt` – 1, i stegvise sprang.
tuple_from_str = ('K', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[::2])
('K', 'd', 'n', '!')
Her har vi satt stegverdien til 2, slik at slicen inneholder hvert andre element.
#4. Samlinger av Forskjellige Datatyper
I eksemplene vi har sett til nå har elementene i listene og tuplene hatt samme datatype.
Men du kan lagre verdier av ulike datatyper i en enkel liste eller tuppel.
Kodesnutten under viser at `student_list` inneholder elevens navn som en streng, alder som et heltall, og karakterer som et flyttall.
student_list = ["Ola", 22, 96.5]
for item in student_list:
print(f"{item} is of type {type(item)}")
# Output
Ola is of type <class 'str'>
22 is of type <class 'int'>
96.5 is of type <class 'float'>
Vi kan se et lignende eksempel for en tuppel:
student_tuple = ("Kari", 23, 99.5)
for item in student_tuple:
print(f"{item} is of type {type(item)}")
# Output
Kari is of type <class 'str'>
23 is of type <class 'int'>
99.5 is of type <class 'float'>
#5. Støtte for Medlemskapstesting
Både lister og tupler lar deg sjekke om et element finnes i samlingen. Du kan bruke `in`-operatoren for å teste om et element finnes i listen eller tuppelen.
Uttrykket `element in iterable` gir `True` hvis `iterable` inneholder `element`, ellers `False`.
"Alex" in student_list
# False
"Kari" in student_tuple
# True
Nå har du lært om likhetene mellom lister og tupler. La oss se på de viktigste forskjellene mellom dem.
Forskjeller mellom Python Tuples og Lister
#1. Endringsdyktighet i Lister vs. Uforanderlighet i Tupler
Den viktigste forskjellen mellom lister og tupler i Python er at tupler er uforanderlige. Det vil si at du ikke kan endre en tuppel etter at den er laget.
▶️ Her er et eksempel:
tuple1 = ("Java", "Python", "C++")
tuple1[0] = "Rust"
# Output
----> 2 tuple1[0] = "Rust"
TypeError: 'tuple' object does not support item assignment
En liste er en endringsdyktig datastruktur, så vi kan modifisere den ved å endre et element ved en spesifikk indeks, som vist i koden under.
list1 = ["Java", "Python", "C++"]
list1[0] = "Rust"
print(list1)
# Output
['Rust', 'Python', 'C++']
#2. Lister med Variabel Lengde vs. Tupler med Fast Lengde
Python-listen er en datastruktur med variabel lengde.
Du kan for eksempel:
- Legge til elementer på slutten av listen.
- Legge til elementer fra en annen liste til slutten av den nåværende listen.
- Fjerne elementer fra en spesifikk indeks i listen.
list1 = [2,3,4,5]
# legge til et element på slutten
list1.append(9)
print(list1)
# legge til elementer fra list2 til slutten av list1
list2 = [0,7]
list1.extend(list2)
print(list1)
# fjerne et element fra list1
list1.pop(0)
print(list1)
▶️ Utdata fra kodesnutten ovenfor:
# Output
[2, 3, 4, 5, 9]
[2, 3, 4, 5, 9, 0, 7]
[3, 4, 5, 9, 0, 7]
Tupler er datastrukturer med fast lengde, så du kan ikke legge til eller fjerne elementer fra en eksisterende tuppel. Du kan derimot omdefinere tuppelen med forskjellige elementer.
tuple1 = (2,4,6,8)
tuple1 = (1,8,9)
print(tuple1)
# Output
(1, 8, 9)
#3. Størrelse i Minnet
Vi bygger nå videre på det vi lærte i forrige del: at listen er en datastruktur med variabel lengde.
Når du definerer en liste, tildeles den en viss størrelse i minnet. Hvis du endrer listen med metodene `append()` eller `extend()`, tildeles mer minne for å lagre de nye elementene. Denne tildelingen overstiger ofte antallet elementer du legger til.
Derfor må Python holde styr på antall elementer i listen, og den tildelte plassen. I tillegg, siden lister har variabel lengde, er det en peker som viser til adressen til listeelementene. Dermed tar lister med lengde k opp mer minne enn en tuppel med de samme k elementene.
Her er en enkel illustrasjon.
Du kan bruke `sys`-modulens `getsizeof()`-metode til å finne størrelsen på et Python-objekt i minnet.
import sys
list1 = [4,5,9,14]
list_size = sys.getsizeof(list1)
print(f"Størrelse på liste: {list_size}")
tuple1 = (4,5,9,14)
tuple_size = sys.getsizeof(tuple1)
print(f"Størrelse på tuple: {tuple_size}")
Som utdataene nedenfor viser, tar en liste opp mer minne enn en tuppel med samme antall og verdi på elementene:
# Output
Størrelse på liste: 104
Størrelse på tuple: 88
Når bør du bruke en Python Tuple?
Ut fra likhetene og forskjellene mellom Python lister og tupler, vet du at du bør bruke en liste hvis du trenger en samling som kan endres.
Men når er det best å bruke en tuppel?
Det skal vi se nærmere på i denne delen.
#1. Skrivebeskyttet Samling
Når du trenger en samling som ikke skal endres, bør du definere den som en tuppel. La oss si at `farge = (243, 55, 103)` er en tuppel som inneholder RGB-verdiene for en fargetone. Ved å definere `farge` som en tuppel, sikrer du at den ikke kan endres.
Med andre ord, når du trenger en skrivebeskyttet samling – der verdiene ikke skal endres underveis i programmet – er det lurt å bruke en tuppel. Dette forhindrer utilsiktede endringer.
#2. Ordboknøkler
La oss si at du skal lage en ordbok, der elementene i en liste `key_list` skal brukes som nøkler. Du kan bruke `dict.fromkeys()`-metoden til å lage en ordbok fra en liste.
key_list = list("ABCD")
dict.fromkeys(key_list)
{'A': None, 'B': None, 'C': None, 'D': None}
Anta at du endrer listen slik at den inneholder «D» som første element (indeks 0) før du oppretter ordboken.
Hva skjer med ordboknøkkelen «A» nå?
Hvis du prøver å lage en ordbok fra `key_list` og hente verdien som tilsvarer nøkkelen «A», vil du få en `KeyError`.
key_list[0] = 'D'
dict.fromkeys(key_list)['A']
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-31-c90392acc2cf> in <module>()
----> 1 dict.fromkeys(key_list)['A']
KeyError: 'A'
Nøklene i en ordbok må være unike. Så du kan ikke ha en «D» som nøkkel flere ganger.
dict.fromkeys(key_list)
{'B': None, 'C': None, 'D': None} # A er ikke lenger en nøkkel.
Hvis du bruker en tuppel i stedet, er det umulig å gjøre slike endringer, og du er mindre sannsynlig å få feil. Derfor bør du lage en ordbok med elementene i en tuppel som nøkler.
key_tuple = tuple("ABCD")
dict.fromkeys(key_tuple)
{'A': None, 'B': None, 'C': None, 'D': None}
key_tuple[0] = 'D'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-12-2cecbefa7db2> in <module>()
----> 1 key_tuple[0] = 'D'
TypeError: 'tuple' object does not support item assignment
#3. Funksjonsargumenter
Tuplenes uforanderlighet gjør dem også egnet som funksjonsargumenter.
La oss se på funksjonen `finn_volum()` som returnerer volumet av en kube gitt lengde, bredde og høyde.
def finn_volum(dimensjoner):
l, b, h = dimensjoner
return l * b * h
Anta at disse dimensjonene er tilgjengelige i en liste kalt `dimensjoner`. Kall på `finn_volum()` med `dimensjoner` som argument returnerer volumet.
dimensions = [2, 8, 5]
finn_volum(dimensions)
80
Du kan alltid endre dimensjonene som er lagret i en liste.
dimensions = [20, 8, 5]
finn_volum(dimensions)
800
Noen ganger skal verdiene være konstante og ikke kunne endres. Da bør du vurdere å lagre argumentene som en tuppel og bruke dem i funksjonskallet.
#4. Returverdier fra Funksjoner
I Python vil du ofte se tupler som returverdier fra funksjoner. Når du returnerer flere verdier fra en funksjon, returnerer Python dem implisitt som en tuppel.
La oss se på funksjonen `returner_partall()`:
def returner_partall(num):
partall = [i for i in range(num) if (i % 2 == 0)]
return partall, len(partall)
- Den tar et tall `num` som argument.
- Den returnerer en liste over partall i intervallet [0, `num`), og lengden på listen.
La oss sette verdien av `num` til 20 og kalle funksjonen.
num = 20
Kaller du `returner_partall()`, får du de to verdiene i en tuppel. Du kan bruke `type()`-funksjonen for å sjekke dette.
type(returner_partall(num)) # <class 'tuple'>
Du kan skrive ut returverdien for å verifisere at det er en tuppel som inneholder en liste over partall som første element, og lengden på listen som andre element.
print(returner_partall(num))
([0, 2, 4, 6, 8, 10, 12, 14, 16, 18], 10)
Siden tuppelen har to elementer, kan du pakke dem ut i to variabler som vist under.
partall_liste, antall = returner_partall(num)
print(partall_liste)
print(antall)
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
10
Konklusjon
Jeg håper denne veiledningen har gitt deg en god oversikt over forskjellene mellom Python tupler og lister.
La oss avslutte veiledningen med en oppsummering:
- Lister og tupler er grunnleggende datastrukturer i Python.
- Likheter: itererbare objekter, støtte for indeksering, slicing, ulike datatyper og medlemskapstesting.
- Hovedforskjellen: Lister er endringsdyktige, mens tupler er uforanderlige.
- Andre forskjeller: Tupler har fast lengde, lister har variabel lengde. Tupler bruker mindre minne enn lister.
- Når bør du bruke tupler? For uforanderlige samlinger, ordboknøkler og funksjonsargumenter.
Du kan nå sjekke ut Python-prosjekter for å øve og lære. Eller du kan lære hvordan du fjerner duplikate elementer fra Python-lister. Lykke til med læringen! Og god koding! 👩🏽💻