En komplet vejledning med kodeeksempler

Af
Tweet
Share
Share
Pin

I denne vejledning lærer du det grundlæggende i Python-sæt og de forskellige sætmetoder, du kan bruge til at ændre Python-sæt.

Sæt er en af ​​de indbyggede datastrukturer i Python. Når du skal arbejde med en ikke-gentagende samling af elementer, skal du bruge sættet som den gå-til-datastruktur.

I de følgende flere sektioner vil vi gennemgå det grundlæggende i python-sæt og de sætmetoder, du kan bruge til at arbejde med dem. Vi vil derefter lære, hvordan man udfører almindelige sæt-operationer i Python.

Lad os begynde!

Grundlæggende om Python-sæt

I Python er et sæt en uordnet samling af ikke-gentagende elementer. Det betyder, at elementerne i et sæt alle skal være forskellige.

Du kan tilføje og fjerne elementer fra et sæt; derfor er sættet en foranderlig samling. Det kan indeholde elementer af forskellige datatyper. Det skal de enkelte elementer i et sæt dog være hashable.

I Python siges et objekt at være hashbart, hvis dets hashværdi aldrig ændres. De fleste uforanderlige objekter såsom Python-strenge, tupler og ordbøger er hashbare.

Vi lærer mere om oprettelse af sæt. Overvej i øjeblikket følgende to sæt:

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 sæt indeholder tre tal, en tupel og en streng. Den indstillede initialisering kører uden fejl. Hvorimod det andet sæt indeholder en liste i stedet for en tupel. En liste er en foranderlig samling, den kan ikke hashes, og initialiseringen kaster en TypeError.

📑 Ved at sætte det hele sammen kan vi definere et Python-sæt som en foranderlig samling af distinkte og hashbare elementer.

Sådan opretter du et Python-sæt

Vi starter med at lære, hvordan man opretter et sæt i Python.

#1. Brug af eksplicit initialisering

Du kan oprette et sæt i Python ved at angive elementerne i sættet, adskilt af kommaer (,) og omsluttet af et par krøllede klammeparenteser {}.

py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)

# Output
set

Hvis du har arbejdet med Python-lister før, ved du det [] initialiserer en tom liste. Selvom et Python-sæt er omsluttet af et par krøllede seler {}, kan du ikke bruge et par {} til at initialisere et sæt. Dette er fordi {} den initialiserer en Python-ordbog og ikke et Python-sæt. 

py_set2 = {}
type(py_set2)

# Output
dict

Du kan igen kalde funktionen type() for at bekræfte, at py_set det er en ordbog (dict).

#2. Brug af set()-funktionen

Hvis du gerne vil initialisere et tomt sæt og derefter tilføje elementer til det, kan du gøre det ved at bruge set()-funktionen.

py_set3 = set()
type(py_set3)

# Output
set

#3. Casting af andre iterables i et sæt

En anden måde at oprette sæt på er at caste andre iterables, såsom lister og tuples, i sæt ved hjælp af 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 ovenstående eksempel indeholder py_list ‘C’ to gange. Men i py_set4 optræder ‘C’ kun én gang, da sættet er en samling af særskilte elementer. Denne teknik til casting i sættet bruges ofte til at fjerne dubletter fra Python-lister.

  Retter fejlen 'iTunes kunne ikke oprette forbindelse til denne iPhone'

Sådan tilføjes elementer til et Python-sæt

Lad os starte med at oprette et tomt sæt py_set og arbejde med det i resten af ​​denne øvelse.

py_set = set()
len(py_set) # returns the length of a set
# Output
0

#1. Brug af .add() metoden

For at tilføje elementer til et sæt, kan du bruge .add() metoden. set.add(element) tilføjer element til sættet.

For klarhedens skyld tilføjer vi elementer til Python-sættet og udskriver sættet ved hvert trin.

▶️ Lad os tilføje strengen ‘Python’ som et element til py_set. 

py_set.add('Python')
print(py_set)

# Output
{'Python'}

Dernæst tilføjer vi endnu et element.

py_set.add('C++')
print(py_set)

# Output
{'Python', 'C++'}

Det er vigtigt at forstå, at .add()-metoden kun tilføjer et element til sættet, hvis det ikke allerede er til stede. Hvis sættet allerede indeholder det element, du vil tilføje, har tilføjelsesoperationen ingen effekt.

For at bekræfte dette, lad os prøve at tilføje ‘C++’ til py_set. 

py_set.add('C++')
print(py_set)

# Output
{'Python', 'C++'}

Sættet indeholder ‘C++’, så tilføjelsesoperationen har ingen effekt.

▶️ Lad os tilføje et par flere elementer til sættet.

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. Brug af .update()-metoden

Indtil videre har vi set, hvordan man tilføjer elementer til det eksisterende sæt – ét element ad gangen.

Hvad hvis du gerne vil tilføje mere end ét element til en sekvens af elementer?

Du kan gøre det ved at bruge .update()-metoden med syntaksen: set.update(collection) for at tilføje elementer i samlingen til et sæt. Samlingen kan være en liste, tupel, ordbog og så videre.

py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)

# Output
{'C', 'C++', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}

Denne metode er nyttig, når du vil tilføje en samling af elementer til et sæt uden at oprette et andet objekt i hukommelsen.

Lad os i næste afsnit lære, hvordan man fjerner elementer fra et sæt.

Sådan fjerner du elementer fra et Python-sæt

Lad os overveje følgende sæt (py_set før opdateringsoperationen).

py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}

#1. Brug af .pop()-metoden

set.pop() fjerner et element tilfældigt fra sættet og returnerer det. Lad os kalde pop-metoden på py_set og se, hvad den returnerer.

py_set.pop()

# Output
'Rust'

Denne gang returnerede kaldet til .pop()-metoden strengen ‘Rust’.

Bemærk: Fordi .pop()-metoden returnerer et element tilfældigt, når du kører koden i din ende, kan du lige så godt få et andet element.

Når vi undersøger sættet, er ‘Rust’ ikke længere til stede i sættet.

print(py_set)

# Output
{'JavaScript', 'Python', 'C++', 'C'}

#2. Brug af metoderne .remove() og discard().

I praksis vil du måske fjerne bestemte elementer fra sættet. For at gøre dette kan du bruge metoderne .remove() og .discard().

set.remove(element) fjerner elementer fra sættet.

py_set.remove('C')
print(py_set)

# Output
{'JavaScript', 'Python', 'C++'}

Hvis vi forsøger at fjerne et element, der ikke findes i sættet, løber vi ind i 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'

Lad os tage et kig på py_set det igen. Vi har nu tre elementer.

print(py_set)

# Output
{'JavaScript', 'Python', 'C++'}

Med syntaksen set.discard(element) fjerner .discard()-metoden også elementer fra sættet. 

py_set.discard('C++')
print(py_set)

# Output
{'JavaScript', 'Python'}

Den adskiller sig dog fra .remove()-metoden ved, at den ikke rejser en KeyError, når vi forsøger at fjerne et element, der ikke er til stede.

  Få tekst til at udvide/skjule ved klik i MS Word 2013

Hvis vi forsøger at fjerne ‘Scala’ (som ikke findes) fra listen ved hjælp af .discard()-metoden, ser vi ingen fejl.

py_set.discard('Scala') #no error!
print(py_set)

# Output
{'JavaScript', 'Python'}

Sådan får du adgang til elementer i et Python-sæt

Indtil videre har vi lært, hvordan man tilføjer og fjerner elementer fra Python-sæt. Vi har dog endnu ikke set, hvordan man får adgang til individuelle elementer i et sæt.

Da et sæt er en uordnet samling, kan det ikke indekseres. Derfor, hvis du forsøger at få adgang til elementerne i et sæt ved hjælp af indekset, vil du løbe ind i en fejl, 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 adgang til elementer i et sæt?

Der er to almindelige måder at gøre dette på:

  • Gå gennem sættet og få adgang til hvert element
  • Tjek, om et bestemt element er medlem af sættet

▶️ Sløjfe gennem sættet og få adgang til elementer ved hjælp af en for-løkke.

for elt in py_set:
  print(elt)

# Output
C++
JavaScript
Python
Rust
C

I praksis vil du måske kontrollere, om et givet element er til stede i sættet ved hjælp af in-operatoren.

Bemærk: element i sæt returnerer True, hvis element er til stede i sæt; ellers returnerer den Falsk.

I dette eksempel indeholder py_set ‘C++’ og indeholder ikke ‘Julia’, og in-operatoren returnerer henholdsvis True og False.

'C++' in py_set
# True
'Julia' in py_set
# False

Sådan finder du længden af ​​et Python-sæt

Som set tidligere kan du bruge len()-funktionen til at få antallet af elementer til stede i et sæt.

py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)

# Output: 5

Sådan rydder du et Python-sæt

For at rydde et sæt ved at fjerne alle elementer, kan du bruge metoden .clear().

Lad os kalde .clear()-metoden på py_set. 

py_set.clear()

Hvis du prøver at printe det ud, får du set() – hvilket indikerer at sættet er tomt. Du kan også kalde len()-funktionen for at bekræfte, at længden af ​​sættet er nul.

print(py_set)
# set()
print(len(py_set))
# 0

Indtil videre har vi lært, hvordan man udfører grundlæggende CRUD-operationer på Python-sæt:

  • Opret: Brug set()-funktionen, skriv casting og initialisering
  • Læs: Få adgang til sættets elementer ved hjælp af loops og in-operator til medlemskabstest
  • Opdater: Tilføj, fjern elementer fra sæt, og opdater sæt
  • Slet: Ryd et sæt ved at fjerne alle elementer fra det

Fælles sætoperationer, forklaret med Python-kode

Python-sæt giver os også mulighed for at udføre de grundlæggende sæt-operationer. Vi lærer om dem i dette afsnit.

#1. Union of Sets i Python

I mængdeteori er foreningen af ​​to mængder mængden af ​​alle elementer i mindst en af ​​de to mængder. Hvis der er to sæt, A og B, så indeholder foreningen elementer, der kun er til stede i A, kun i B, og de elementer, der er til stede i både A og B.

  Sådan deaktiveres Motion Smoothing på et LG TV

For at finde foreningen af ​​sæt, kan du bruge | operator 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}

Set union er en kommutativ operation; så AUB er det samme som BU A. Lad os verificere dette ved at udveksle positionerne for setA og setB i .union() metodekaldet.

setB.union(setA)

# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}

#2. Skæring af sæt i Python

En anden fælles sætoperation er denne skæring af to sæt, A og B. Sæt skæringsoperation returnerer et sæt, der indeholder alle de elementer, der er til stede i både A og B.

For at beregne skæringspunktet kan du bruge &-operatoren eller .intersection()-metoden, som forklaret i kodestykket nedenfor.

print(setA & setB)

# Output
{9}

setA.intersection(setB)

# Output
{9}

I dette eksempel er element 9 til stede i både sætA og sætB; så skæringssættet indeholder kun dette element.

Ligesom sætunionen er det indstillede skæringspunkt også en kommutativ operation.

setB.intersection(setA)

# Output
{9}

#3. Indstil forskel i Python

Givet vilkårlige to sæt, hjælper union og skæring os med at finde de elementer, der er til stede i henholdsvis begge og mindst et af sættene. På den anden side hjælper sætforskel os med at finde de elementer, der er til stede i det ene sæt, men ikke i det andet.

– sætA.difference(sætB) giver det sæt af elementer, der kun er til stede i sætA og ikke i sætB.

– sætB.difference(sætA) giver det sæt af elementer, der kun er til stede i sætB og ikke i sætA.

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 indstillede forskel er ikke en kommutativ operation.

setA.difference(setB)
# {1, 3, 5, 7}

setB.difference(setA)
# {2, 4, 6, 8}

#4. Symmetrisk sæt forskel i Python

Mens sæt skæringspunkter giver os elementer, der er til stede i begge mængder, returnerer den symmetriske mængdeforskel mængden af ​​elementer, der er til stede i nøjagtig et af mængderne.

Overvej følgende eksempel.

setA = {1,3,5,7,10,12}
setB = {2,4,6,8,10,12}

For at beregne det symmetriske differenssæt kan du bruge operatoren ^ eller metoden .symmetric_difference().

print(setA ^ setB)

# Output
{1, 2, 3, 4, 5, 6, 7, 8}

Elementerne 10 og 12 er til stede i både sæt A og sæt B. Så de er ikke til stede i det symmetriske differenssæt.

setA.symmetric_difference(setB)

# Output
{1, 2, 3, 4, 5, 6, 7, 8}

Da den symmetriske mængdeforskel-operation samler alle elementer, der optræder i nøjagtig et af de to sæt, er det resulterende sæt det samme uanset den rækkefølge, som elementerne er indsamlet i. Derfor er en symmetrisk mængdeforskel en kommutativ operation.

setB.symmetric_difference(setA)

# Output
{1, 2, 3, 4, 5, 6, 7, 8}

#5. Undersæt og supersæt i Python

I mængdeteori hjælper delmængder og supersæt med at forstå forholdet mellem to sæt.

Givet to mængder A og B er mængde B en delmængde af mængde A, hvis alle elementer i mængde B også er til stede i mængde A. Og mængde A er supermængden af ​​mængde B.

Overvej eksemplet med to sæt: sprog og sprog_udvidet. 

languages = {'Python', 'JavaScript','C','C++'}
languages_extended = {'Python', 'JavaScript','C','C++','Rust','Go','Scala'}

I Python kan du bruge metoden .issubset() til at kontrollere, om et givet sæt er en delmængde af et andet sæt.

setA.issubset(setB) returnerer True, hvis sætA er en delmængde af sætB; ellers returnerer den Falsk.

I dette eksempel er sprog en delmængde af languages_extended.

languages.issubset(languages_extended)
# Output
True

På samme måde kan du bruge metoden .issuperset() til at kontrollere, om et givet sæt er et supersæt af et andet sæt.

sætA.issuperset(sætB) returnerer True, hvis sætA er et supersæt af sætB; ellers returnerer den Falsk.

languages_extended.issuperset(languages)
# Output
True

Da languages_extended er et supersæt af sprog, returnerer languages_extended.issuperset(languages) True, som det ses ovenfor.

Konklusion

Jeg håber, at denne tutorial hjalp dig med at forstå, hvordan Python-sæt fungerer, sætmetoderne til CRUD-operationer og almindelige sæt-operationer. Som et næste trin kan du prøve at bruge dem i dine Python-projekter.

Du kan tjekke andre dybdegående Python-vejledninger. God læring!