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!

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.

  Hva er en WebP-fil (og hvordan åpner jeg en)?

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.

  Slik tar du opp Zoom-møte på iPhone

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.

  Løs problemer med å godta en invitasjon til en Xbox-fest

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!

x