I denne veiledningen vil du utforske de grunnleggende aspektene ved Python-sett, samt de ulike metodene som er tilgjengelige for å manipulere disse settene.
Sett er en fundamental datastruktur i Python. De er spesielt nyttige når du trenger å håndtere samlinger av elementer som ikke skal ha duplikater.
I de følgende avsnittene vil vi grundig gå gjennom essensen av Python-sett og de tilhørende operasjonene. Vi vil deretter undersøke hvordan man utfører vanlige settoperasjoner.
La oss sette i gang!
Grunnleggende om Python-sett
Et sett i Python er en uordnet kolleksjon av unike elementer. Det betyr at hvert element i et sett må være forskjellig fra alle andre elementer i samme sett.
Sett er mutable, noe som betyr at du kan legge til og fjerne elementer. De kan inneholde elementer av forskjellige datatyper, men alle elementer i et sett må være hashable.
Et objekt er hashbart i Python dersom dets hashverdi er konstant. De fleste immutable objekter, som strenger, tupler og tall, er hashbare.
La oss se nærmere på hvordan man lager sett. For nå, se på disse to eksemplene:
py_set = {0,1,2,(2,3,4),'Kul!'}
py_set = {0,1,2,[2,3,4],'Ups!'}
# Resultat
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-40-2d3716c7fe01> in <module>()
----> 1 py_set = {0,1,2,[2,3,4],'Ups!'}
TypeError: unhashable type: 'list'
Det første settet består av tre tall, en tuppel og en streng. Initialiseringen skjer uten feil. Det andre settet inneholder derimot en liste istedenfor en tuppel. Lister er mutable og dermed ikke hashbare, så initialiseringen resulterer i en TypeError.
📑 Oppsummert er et Python-sett en mutable samling av distinkte og hashbare elementer.
Hvordan lage et Python-sett
Vi begynner med å se på de forskjellige måtene man kan lage et sett i Python.
#1. Eksplisitt initialisering
Du kan opprette et sett ved å angi elementene inni krøllparenteser `{}`, adskilt med komma `,`.
py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)
# Resultat
set
Hvis du er kjent med Python-lister, vet du at `[]` initialiserer en tom liste. Til tross for at et sett bruker krøllparenteser `{}`, kan du ikke bruke `{}« alene for å initialisere et tomt sett, da det initialiserer en Python-ordbok og ikke et sett.
py_set2 = {}
type(py_set2)
# Resultat
dict
Du kan bruke funksjonen `type()` for å bekrefte at `py_set2` er en ordbok (dict).
#2. Bruke funksjonen `set()`
Hvis du vil opprette et tomt sett og deretter legge til elementer i det, kan du bruke funksjonen `set()`.
py_set3 = set() type(py_set3) # Resultat set
#3. Konvertere andre iterables til et sett
En annen metode for å lage sett er ved å konvertere andre iterables, som lister og tupler, til et sett ved hjelp av `set(iterable)`.
py_list = ['Python','C','C++','JavaScript','C']
py_set4 = set(py_list)
print(py_set4)
# {'C++', 'C', 'JavaScript', 'Python'} # det gjentakende elementet 'C' er fjernet
type(py_set4)
# set
I eksemplet over inneholder `py_list` `»C»` to ganger. Men i `py_set4` vises `»C»` kun én gang, siden et sett kun lagrer unike elementer. Denne teknikken for å konvertere en iterable til et sett er nyttig for å fjerne duplikater fra lister.
Hvordan legge til elementer i et Python-sett
La oss starte med å lage et tomt sett `py_set` og bruke det i resten av denne veiledningen.
py_set = set() len(py_set) # returnerer lengden på settet # Resultat 0
#1. Bruke metoden `.add()`
For å legge til elementer i et sett, kan du bruke metoden `.add()`. `set.add(element)` legger til `element` i settet.
For å være tydelig, legger vi til elementer i `py_set` og skriver ut settet etter hvert trinn.
▶️ La oss legge til strengen `»Python»` som et element i `py_set`.
py_set.add('Python')
print(py_set)
# Resultat
{'Python'}
La oss legge til enda et element.
py_set.add('C++')
print(py_set)
# Resultat
{'Python', 'C++'}
Det er viktig å forstå at metoden `.add()` bare legger til et element hvis det ikke allerede finnes i settet. Hvis settet allerede inneholder elementet, har operasjonen ingen effekt.
La oss bekrefte dette ved å prøve å legge til `»C++»` i `py_set` igjen.
py_set.add('C++')
print(py_set)
# Resultat
{'Python', 'C++'}
Settet inneholder allerede `»C++»`, så `.add()` har ingen effekt.
▶️ La oss legge til noen flere elementer i settet.
py_set.add('C')
print(py_set)
py_set.add('JavaScript')
print(py_set)
py_set.add('Rust')
print(py_set)
# Resultat
{'Python', 'C++', 'C'}
{'JavaScript', 'Python', 'C++', 'C'}
{'Rust', 'JavaScript', 'Python', 'C++', 'C'}
#2. Bruke metoden `.update()`
Vi har nå sett hvordan vi legger til elementer i et eksisterende sett – ett element av gangen.
Hva om du vil legge til mer enn ett element, for eksempel fra en liste?
Dette kan du gjøre med metoden `.update()`, med syntaksen `set.update(collection)`, som legger til alle elementene i `collection` til settet. En `collection` kan være en liste, tuppel, ordbok, etc.
py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)
# Resultat
{'C', 'C++', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}
Denne metoden er praktisk når du vil legge til en samling av elementer til et sett uten å opprette et nytt objekt i minnet.
I neste avsnitt skal vi se på hvordan du fjerner elementer fra et sett.
Hvordan fjerne elementer fra et Python-sett
La oss vurdere følgende sett (`py_set` før oppdateringsoperasjonen).
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
#1. Bruke metoden `.pop()`
`set.pop()` fjerner et tilfeldig element fra settet og returnerer det. La oss kalle `.pop()` på `py_set` og se hva som returneres.
py_set.pop() # Resultat 'Rust'
Denne gangen returnerte kallet på `.pop()` strengen `»Rust»`.
Merk: Siden `.pop()` returnerer et tilfeldig element, kan du få et annet element hvis du kjører koden.
Når vi undersøker settet, er `»Rust»` ikke lenger med.
print(py_set)
# Resultat
{'JavaScript', 'Python', 'C++', 'C'}
#2. Bruke metodene `.remove()` og `.discard()`
I praksis vil du kanskje fjerne spesifikke elementer fra et sett. Dette kan gjøres ved hjelp av `.remove()` og `.discard()`.
`set.remove(element)` fjerner `element` fra settet.
py_set.remove('C')
print(py_set)
# Resultat
{'JavaScript', 'Python', 'C++'}
Hvis vi prøver å fjerne et element som ikke finnes i settet, får vi en KeyError.
py_set.remove('Scala')
# Resultat
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-58-a1abab3a8892> in <module>()
----> 1 py_set.remove('Scala')
KeyError: 'Scala'
La oss se på `py_set` igjen. Det inneholder nå tre elementer.
print(py_set)
# Resultat
{'JavaScript', 'Python', 'C++'}
Metoden `.discard(element)` fjerner også elementer fra settet med syntaksen `set.discard(element)`.
py_set.discard('C++')
print(py_set)
# Resultat
{'JavaScript', 'Python'}
Den skiller seg imidlertid fra `.remove()` ved at den *ikke* gir en KeyError dersom vi prøver å fjerne et element som ikke finnes i settet.
Hvis vi prøver å fjerne `»Scala»` (som ikke eksisterer) fra listen ved hjelp av `.discard()`, ser vi ingen feil.
py_set.discard('Scala') #ingen feil!
print(py_set)
# Resultat
{'JavaScript', 'Python'}
Hvordan få tilgang til elementer i et Python-sett
Så langt har vi lært å legge til og fjerne elementer fra Python-sett. Vi har imidlertid ikke sett hvordan man får tilgang til individuelle elementer.
Siden et sett er en uordnet samling, kan det ikke indekseres. Hvis du prøver å få tilgang til elementer i et sett ved hjelp av indeks, får du en feil, som vist nedenfor.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
print(py_set[0])
# Resultat
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-27-0329274f4580> in <module>()
----> 1 print(py_set[0])
TypeError: 'set' object is not subscriptable
Så, hvordan får man tilgang til elementene i et sett?
Det finnes to vanlige måter:
- Iterer gjennom settet og få tilgang til hvert element
- Sjekk om et spesifikt element finnes i settet
▶️ Iterere gjennom settet og få tilgang til elementene ved hjelp av en for-løkke.
for elt in py_set: print(elt) # Resultat C++ JavaScript Python Rust C
I praksis kan det være nyttig å sjekke om et element finnes i settet ved hjelp av operatoren `in`.
Merk: `element in sett` returnerer True hvis `element` finnes i settet, ellers False.
I dette eksemplet inneholder `py_set` `»C++»` og inneholder ikke `»Julia»`, og operatoren `in` returnerer henholdsvis True og False.
'C++' in py_set # True 'Julia' in py_set # False
Hvordan finne lengden på et Python-sett
Som nevnt tidligere kan du bruke funksjonen `len()` for å få antall elementer i et sett.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)
# Resultat: 5
Slik sletter du et Python-sett
For å tømme et sett ved å fjerne alle elementene, kan du bruke metoden `.clear()`.
La oss kalle `.clear()` på `py_set`.
py_set.clear()
Hvis du prøver å skrive det ut, får du `set()` – som indikerer at settet er tomt. Du kan også kalle funksjonen `len()` for å bekrefte at lengden er null.
print(py_set) # set() print(len(py_set)) # 0
Så langt har vi sett på de grunnleggende CRUD-operasjonene på Python-sett:
- Opprett: Bruk `set()`-funksjonen, konvertering og eksplisitt initialisering
- Les: Få tilgang til elementer i settet ved hjelp av løkker og `in`-operatoren for å sjekke medlemskap
- Oppdater: Legg til, fjern elementer fra settet og oppdater settet
- Slett: Tøm et sett ved å fjerne alle elementene fra det
Vanlige settoperasjoner, forklart med Python-kode
Python-sett lar oss også utføre de grunnleggende settoperasjonene. Vi skal se nærmere på dem nå.
#1. Union av sett i Python
I settteori er unionen av to sett mengden av alle elementer som finnes i minst ett av settene. Hvis du har to sett, A og B, inneholder unionen elementer som bare finnes i A, bare i B, og elementer som finnes i både A og B.
For å finne unionen av to sett, kan du bruke operatoren `|` eller metoden `.union()`, med syntaksen `setA.union(setB)`.
setA = {1,3,5,7,9}
setB = {2,4,6,8,9}
print(setA | setB)
# Resultat
{1, 2, 3, 4, 5, 6, 7, 8, 9}
setA.union(setB)
# Resultat
{1, 2, 3, 4, 5, 6, 7, 8, 9}
Union av sett er en kommutativ operasjon, så AUB er det samme som BUA. La oss verifisere dette ved å bytte plass på `setA` og `setB` i kallet på metoden `.union()`.
setB.union(setA)
# Resultat
{1, 2, 3, 4, 5, 6, 7, 8, 9}
#2. Snitt av sett i Python
En annen vanlig settoperasjon er snittet av to sett, A og B. Snittet returnerer et sett som inneholder alle elementene som finnes i både A og B.
For å beregne snittet kan du bruke `&` eller metoden `.intersection()`, som forklart i kodebiten nedenfor.
print(setA & setB)
# Resultat
{9}
setA.intersection(setB)
# Resultat
{9}
I dette eksemplet er element 9 med i både `setA` og `setB`, så snittet inneholder kun dette elementet.
Som union av sett er også snitt en kommutativ operasjon.
setB.intersection(setA)
# Resultat
{9}
#3. Differanse mellom sett i Python
Gitt to sett, hjelper union og snitt oss med å finne elementene som er tilstede i henholdsvis begge og minst ett av settene. På den annen side hjelper settforskjell oss med å finne elementene som er tilstede i det ene settet, men ikke i det andre.
– `setA.difference(setB)` gir settet med elementer som bare finnes i `setA` og ikke i `setB`.
– `setB.difference(setA)` gir settet med elementer som bare finnes i `setB` og ikke i `setA`.
print(setA - setB)
print(setB - setA)
# Resultat
{1, 3, 5, 7}
{8, 2, 4, 6}
AB er tydeligvis ikke det samme som BA, så differanse er ikke en kommutativ operasjon.
setA.difference(setB)
# {1, 3, 5, 7}
setB.difference(setA)
# {2, 4, 6, 8}
#4. Symmetrisk differanse av sett i Python
Mens snitt gir oss elementer som finnes i begge settene, returnerer symmetrisk differanse settet med elementer som finnes i nøyaktig ett av settene.
Se på dette eksemplet:
setA = {1,3,5,7,10,12}
setB = {2,4,6,8,10,12}
For å beregne den symmetriske differansen, kan du bruke `^` eller metoden `.symmetric_difference()`.
print(setA ^ setB)
# Resultat
{1, 2, 3, 4, 5, 6, 7, 8}
Elementene 10 og 12 finnes i både `setA` og `setB`. Derfor er de ikke med i den symmetriske differansen.
setA.symmetric_difference(setB)
# Resultat
{1, 2, 3, 4, 5, 6, 7, 8}
Siden den symmetriske differansen samler alle elementer som vises i nøyaktig ett av settene, er det resulterende settet det samme uavhengig av rekkefølgen. Derfor er symmetrisk differanse en kommutativ operasjon.
setB.symmetric_difference(setA)
# Resultat
{1, 2, 3, 4, 5, 6, 7, 8}
#5. Delsett og supersett i Python
I settteori hjelper delsett og supersett med å forstå forholdet mellom to sett.
Gitt to sett, A og B, er sett B et delsett av sett A dersom alle elementene i B også finnes i A. I så fall er sett A et supersett av B.
Se på eksemplet med to sett: `languages` og `languages_extended`.
languages = {'Python', 'JavaScript','C','C++'}
languages_extended = {'Python', 'JavaScript','C','C++','Rust','Go','Scala'}
I Python kan du bruke metoden `.issubset()` for å sjekke om et sett er et delsett av et annet sett.
`setA.issubset(setB)` returnerer True hvis `setA` er et delsett av `setB`. Ellers returneres False.
I dette eksemplet er `languages` et delsett av `languages_extended`.
languages.issubset(languages_extended) # Resultat True
På samme måte kan du bruke metoden `.issuperset()` for å sjekke om et sett er et supersett av et annet sett.
`setA.issuperset(setB)` returnerer True hvis `setA` er et supersett av `setB`. Ellers returneres False.
languages_extended.issuperset(languages) # Resultat True
Siden `languages_extended` er et supersett av `languages`, returnerer `languages_extended.issuperset(languages)` True, som vist ovenfor.
Konklusjon
Jeg håper denne veiledningen har hjulpet deg med å forstå Python-sett, settmetodene for CRUD-operasjoner og vanlige settoperasjoner. Som et neste skritt kan du prøve å bruke dem i dine egne Python-prosjekter.
Du kan utforske andre grundige Python-guider for mer læring. Lykke til med læringen!