En komplett veiledning med kodeeksempler
I denne opplæringen lærer du det grunnleggende om Python-sett og de ulike settmetodene du kan bruke for å endre Python-sett.
Sett er en av de innebygde datastrukturene i Python. Når du trenger å jobbe med en ikke-gjentakende samling av elementer, bruker du settet som datastrukturen.
I de følgende avsnittene vil vi gå over det grunnleggende om python-sett og settmetodene du kan bruke for å jobbe med dem. Vi vil da lære hvordan du utfører vanlige settoperasjoner i Python.
La oss begynne!
Innholdsfortegnelse
Grunnleggende om Python-sett
I Python er et sett en uordnet samling av ikke-repeterende elementer. Dette betyr at alle elementene i et sett skal være forskjellige.
Du kan legge til og fjerne elementer fra et sett; derfor er settet en foranderlig samling. Den kan inneholde elementer av forskjellige datatyper. Imidlertid bør de enkelte elementene i et sett være det hashable.
I Python sies et objekt å være hashbart hvis hashverdien aldri endres. De fleste uforanderlige objekter som Python-strenger, tuples og ordbøker er hashable.
Vi lærer om å lage sett i detalj. For nå, vurder følgende to sett:
py_set = {0,1,2,(2,3,4),'Cool!'}
py_set = {0,1,2,[2,3,4],'Oops!'}
# Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-40-2d3716c7fe01> in <module>()
----> 1 py_set = {0,1,2,[2,3,4],'Oops!'}
TypeError: unhashable type: 'list'
Det første settet inneholder tre tall, en tuppel og en streng. Den angitte initialiseringen kjører uten feil. Mens det andre settet inneholder en liste i stedet for en tuppel. En liste er en mutbar samling, den kan ikke hashes, og initialiseringen gir en TypeError.
📑 Ved å sette alt sammen, kan vi definere et Python-sett som en foranderlig samling av distinkte og hashbare elementer.
Hvordan lage et Python-sett
Vi starter med å lære hvordan du lager et sett i Python.
#1. Bruker eksplisitt initialisering
Du kan lage et sett i Python ved å spesifisere elementene i settet, atskilt med kommaer (,) og omsluttet av et par krøllete klammeparenteser {}.
py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)
# Output
set
Hvis du har jobbet med Python-lister før, vet du det [] initialiserer en tom liste. Selv om et Python-sett er omsluttet av et par krøllete klammeparenteser {}, kan du ikke bruke et par {} for å initialisere et sett. Dette er fordi {} den initialiserer en Python-ordbok og ikke et Python-sett.
py_set2 = {}
type(py_set2)
# Output
dict
Du kan igjen kalle type()-funksjonen for å bekrefte at py_set det er en ordbok (dict).
#2. Bruke set()-funksjonen
Hvis du ønsker å initialisere et tomt sett og deretter legge til elementer til det, kan du gjøre det ved å bruke set()-funksjonen.
py_set3 = set() type(py_set3) # Output set
#3. Casting av andre iterables til et sett
En annen måte å lage sett på er å kaste andre iterables, som lister og tuples, til sett, ved å bruke set(iterable).
py_list = ['Python','C','C++','JavaScript','C']
py_set4 = set(py_list)
print(py_set4)
# {'C++', 'C', 'JavaScript', 'Python'} # repeating element 'C' removed
type(py_set4)
# set
I eksemplet ovenfor inneholder py_list «C» to ganger. Men i py_set4 vises «C» bare én gang, siden settet er en samling av forskjellige elementer. Denne teknikken for å kaste inn i settet brukes ofte til å fjerne duplikater fra Python-lister.
Hvordan legge til elementer i et Python-sett
La oss starte med å lage et tomt sett py_set og jobbe med det for resten av denne opplæringen.
py_set = set() len(py_set) # returns the length of a set # Output 0
#1. Ved å bruke .add()-metoden
For å legge til elementer i et sett, kan du bruke .add()-metoden. set.add(element) legger til element til settet.
For klarhetens skyld legger vi til elementer i Python-settet og skriver ut settet ved hvert trinn.
▶️ La oss legge til strengen «Python» som et element i py_set.
py_set.add('Python')
print(py_set)
# Output
{'Python'}
Deretter legger vi til et annet element.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
Det er viktig å forstå at .add()-metoden bare legger til et element i settet hvis det ikke allerede er til stede. Hvis settet allerede inneholder elementet du vil legge til, har add-operasjonen ingen effekt.
For å bekrefte dette, la oss prøve å legge til «C++» til py_set.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
Settet inneholder «C++», så add-operasjonen har ingen effekt.
▶️ La oss legge til noen flere elementer til settet.
py_set.add('C')
print(py_set)
py_set.add('JavaScript')
print(py_set)
py_set.add('Rust')
print(py_set)
# Output
{'Python', 'C++', 'C'}
{'JavaScript', 'Python', 'C++', 'C'}
{'Rust', 'JavaScript', 'Python', 'C++', 'C'}
#2. Ved å bruke .update()-metoden
Så langt har vi sett hvordan du legger til elementer i det eksisterende settet – ett element om gangen.
Hva om du vil legge til mer enn ett element i en sekvens av elementer?
Du kan gjøre det ved å bruke .update()-metoden med syntaksen: set.update(collection) for å legge til elementer i samlingen til et sett. Samlingen kan være en liste, tuppel, ordbok og så videre.
py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)
# Output
{'C', 'C++', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}
Denne metoden er nyttig når du vil legge til en samling av elementer til et sett uten å opprette et annet objekt i minnet.
I neste avsnitt, la oss lære 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. Ved å bruke .pop()-metoden
set.pop() fjerner et element tilfeldig fra settet og returnerer det. La oss kalle pop-metoden på py_set og se hva den returnerer.
py_set.pop() # Output 'Rust'
Denne gangen returnerte kallet til .pop()-metoden strengen «Rust».
Merk: Fordi .pop()-metoden returnerer et element tilfeldig, når du kjører koden på slutten, kan du like godt få et annet element.
Når vi undersøker settet, er «Rust» ikke lenger til stede i settet.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++', 'C'}
#2. Ved å bruke metodene .remove() og discard().
I praksis kan det være lurt å fjerne bestemte elementer fra settet. For å gjøre dette kan du bruke metodene .remove() og .discard().
set.remove(element) fjerner elementer fra settet.
py_set.remove('C')
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Hvis vi prøver å fjerne et element som ikke finnes i settet, får vi en KeyError.
py_set.remove('Scala')
# Output
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-58-a1abab3a8892> in <module>()
----> 1 py_set.remove('Scala')
KeyError: 'Scala'
La oss ta en titt på py_set det igjen. Vi har nå tre elementer.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Med syntaksen set.discard(element), fjerner .discard()-metoden også elementer fra settet.
py_set.discard('C++')
print(py_set)
# Output
{'JavaScript', 'Python'}
Den skiller seg imidlertid fra .remove()-metoden ved at den ikke oppstår en KeyError når vi prøver å fjerne et element som ikke er tilstede.
Hvis vi prøver å fjerne «Scala» (som ikke eksisterer) fra listen ved å bruke .discard()-metoden, ser vi ingen feil.
py_set.discard('Scala') #no error!
print(py_set)
# Output
{'JavaScript', 'Python'}
Hvordan få tilgang til elementer i et Python-sett
Så langt har vi lært hvordan du legger til og fjerner elementer fra Python-sett. Vi har imidlertid ennå ikke sett hvordan du får tilgang til individuelle elementer i et sett.
Siden et sett er en uordnet samling, kan det ikke indekseres. Derfor, hvis du prøver å få tilgang til elementene i et sett ved hjelp av indeksen, får du en feil, som vist.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
print(py_set[0])
# Output
---------------------------------------------------------------------------
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 du tilgang til elementer i et sett?
Det er to vanlige måter å gjøre dette på:
- Gå gjennom settet og få tilgang til hvert element
- Sjekk om et bestemt element er medlem av settet
▶️ Sløyfe gjennom settet og få tilgang til elementene ved hjelp av en for-løkke.
for elt in py_set: print(elt) # Output C++ JavaScript Python Rust C
I praksis kan det være lurt å sjekke om et gitt element er til stede i settet ved å bruke in-operatoren.
Merk: element i sett returnerer True hvis element er til stede i sett; ellers returnerer den False.
I dette eksemplet inneholder py_set «C++» og inneholder ikke «Julia» og in-operatoren returnerer henholdsvis True og False.
'C++' in py_set # True 'Julia' in py_set # False
Hvordan finne lengden på et Python-sett
Som sett tidligere, kan du bruke len()-funksjonen for å få antall elementer som er tilstede i et sett.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)
# Output: 5
Slik sletter du et Python-sett
For å fjerne et sett ved å fjerne alle elementer, kan du bruke .clear()-metoden.
La oss kalle .clear()-metoden 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 len()-funksjonen for å bekrefte at lengden på settet er null.
print(py_set) # set() print(len(py_set)) # 0
Så langt har vi lært hvordan du utfører grunnleggende CRUD-operasjoner på Python-sett:
- Opprett: Bruk set()-funksjonen, skriv casting og initialisering
- Les: Få tilgang til elementer i settet ved hjelp av loops og in-operator for medlemskapstesting
- Oppdater: Legg til, fjern elementer fra sett og oppdater sett
- Slett: Fjern et sett ved å fjerne alle elementer fra det
Vanlige settoperasjoner, forklart med Python-kode
Python-sett lar oss også utføre de grunnleggende settoperasjonene. Vi lærer om dem i denne delen.
#1. Union of Sets i Python
I settteori er foreningen av to sett mengden av alle elementer i minst ett av de to settene. Hvis det er to sett, A og B, inneholder foreningen elementer som bare er tilstede i A, bare i B, og elementene til stede i både A og B.
For å finne foreningen av sett, kan du bruke | operatoren eller .union() metoden med syntaksen: setA.union(setB).
setA = {1,3,5,7,9}
setB = {2,4,6,8,9}
print(setA | setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
setA.union(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
Sett union er en kommutativ operasjon; så AUB er det samme som BU A. La oss verifisere dette ved å bytte posisjonene til setA og setB i .union()-metodekallet.
setB.union(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
#2. Kryss av sett i Python
En annen felles settoperasjon er dette skjæringspunktet mellom to sett, A og B. Setskjæringsoperasjon returnerer et sett som inneholder alle elementene som er tilstede i både A og B.
For å beregne skjæringspunktet kan du bruke &-operatoren eller .intersection()-metoden, som forklart i kodebiten nedenfor.
print(setA & setB)
# Output
{9}
setA.intersection(setB)
# Output
{9}
I dette eksemplet er element 9 tilstede i både settA og settB; så skjæringssettet inneholder kun dette elementet.
I likhet med settunionen er også settskjæringspunktet en kommutativ operasjon.
setB.intersection(setA)
# Output
{9}
#3. Angi forskjell i Python
Gitt hvilke som helst to sett, hjelper union og skjæring 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 til stede i det ene settet, men ikke i det andre.
– setA.difference(settB) gir settet med elementer som bare er tilstede i settA og ikke i settB.
– setB.difference(settA) gir settet med elementer som bare er tilstede i settB og ikke i settA.
print(setA - setB)
print(setB - setA)
# Output
{1, 3, 5, 7}
{8, 2, 4, 6}
AB er tydeligvis ikke det samme som BA, så den angitte forskjellen er ikke en kommutativ operasjon.
setA.difference(setB)
# {1, 3, 5, 7}
setB.difference(setA)
# {2, 4, 6, 8}
#4. Symmetrisk settforskjell i Python
Mens settskjæringspunktet gir oss elementer som er tilstede i begge settene, returnerer den symmetriske settforskjellen settet med elementer som er tilstede i nøyaktig ett av settene.
Tenk på følgende eksempel.
setA = {1,3,5,7,10,12}
setB = {2,4,6,8,10,12}
For å beregne det symmetriske differansesettet kan du bruke ^-operatoren eller .symmetric_difference()-metoden.
print(setA ^ setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Elementene 10 og 12 er tilstede i både sett A og settB. Så de er ikke til stede i det symmetriske differansesettet.
setA.symmetric_difference(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Siden den symmetriske settdifferanseoperasjonen samler alle elementene som vises i nøyaktig ett av de to settene, er det resulterende settet det samme uavhengig av rekkefølgen elementene er samlet inn. Derfor er en symmetrisk settforskjell en kommutativ operasjon.
setB.symmetric_difference(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
#5. Undersett og supersett i Python
I settteori hjelper delmengder og supersett til å forstå forholdet mellom to sett.
Gitt to sett A og B, er sett B en delmengde av sett A hvis alle elementene i sett B også er tilstede i sett A. Og sett A er supermengden av sett B.
Tenk 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 .issubset()-metoden for å sjekke om et gitt sett er et undersett av et annet sett.
settA.isdelsett(settB) returnerer True hvis settA er en delmengde av settB; ellers returnerer den False.
I dette eksemplet er språk en undergruppe av languages_extended.
languages.issubset(languages_extended) # Output True
På samme måte kan du bruke .issuperset()-metoden for å sjekke om et gitt sett er et supersett av et annet sett.
setA.issuperset(setB) returnerer True hvis settA er et supersett av settB; ellers returnerer den False.
languages_extended.issuperset(languages) # Output True
Siden languages_extended er et supersett av språk, returnerer languages_extended.issuperset(languages) True, som vist ovenfor.
Konklusjon
Jeg håper denne opplæringen hjalp deg med å forstå hvordan Python-sett fungerer, settmetodene for CRUD-operasjoner og vanlige settoperasjoner. Som et neste trinn kan du prøve å bruke dem i Python-prosjektene dine.
Du kan sjekke ut andre dybdegående Python-guider. God læring!
