I den här handledningen lär du dig grunderna i Python-uppsättningar och de olika uppsättningsmetoderna du kan använda för att ändra Python-uppsättningar.
Uppsättningar är en av de inbyggda datastrukturerna i Python. När du behöver arbeta med en icke-upprepande samling av element använder du uppsättningen som datastruktur som går till.
Under de följande flera avsnitten kommer vi att gå över grunderna i python-uppsättningar och de uppsättningsmetoder du kan använda för att arbeta med dem. Vi kommer sedan att lära oss hur man utför vanliga uppsättningsoperationer i Python.
Låt oss börja!
Innehållsförteckning
Grunderna i Python-set
I Python är en uppsättning en oordnad samling av icke-repeterande element. Detta betyder att alla element i en uppsättning bör vara distinkta.
Du kan lägga till och ta bort element från en uppsättning; därför är uppsättningen en föränderlig samling. Den kan innehålla element av olika datatyper. Däremot bör de enskilda elementen i en uppsättning vara det hashbart.
I Python sägs ett objekt vara hashbart om dess hashvärde aldrig ändras. De flesta oföränderliga objekt som Python-strängar, tupler och ordböcker är hashbara.
Vi kommer att lära oss hur du skapar set i detalj. För nu, överväg följande två uppsättningar:
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'
Den första uppsättningen innehåller tre nummer, en tuppel och en sträng. Den inställda initieringen körs utan fel. Medan den andra uppsättningen innehåller en lista istället för en tupel. En lista är en föränderlig samling, den kan inte hashas, och initieringen ger ett TypeError.
📑 Genom att sätta ihop allt kan vi definiera en Python-uppsättning som en föränderlig samling av distinkta och hashbara element.
Hur man skapar en Python-uppsättning
Vi börjar med att lära oss hur man skapar en uppsättning i Python.
#1. Använder explicit initiering
Du kan skapa en uppsättning i Python genom att ange elementen i uppsättningen, separerade med kommatecken (,) och omslutna av ett par hängslen {}.
py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)
# Output
set
Om du har arbetat med Python-listor tidigare vet du det [] initierar en tom lista. Även om en Python-uppsättning är innesluten i ett par hängslen {}, kan du inte använda ett par {} för att initiera en uppsättning. Detta beror på att {} den initierar en Python-ordbok och inte en Python-uppsättning.
py_set2 = {}
type(py_set2)
# Output
dict
Du kan återigen anropa funktionen type() för att verifiera att py_set det är en ordbok (dict).
#2. Använda set()-funktionen
Om du vill initiera en tom uppsättning och sedan lägga till element till den, kan du göra det med funktionen set().
py_set3 = set() type(py_set3) # Output set
#3. Casta andra Iterables till en uppsättning
Ett annat sätt att skapa set är att gjuta andra iterables, såsom listor och tupler, till set, med 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 exemplet ovan innehåller py_list ’C’ två gånger. Men i py_set4 visas ’C’ bara en gång, eftersom uppsättningen är en samling distinkta element. Denna teknik för att casta in i setet används ofta för att ta bort dubbletter från Python-listor.
Hur man lägger till element i en Python-uppsättning
Låt oss börja med att skapa en tom uppsättning py_set och arbeta med den under resten av denna handledning.
py_set = set() len(py_set) # returns the length of a set # Output 0
#1. Använda .add()-metoden
För att lägga till element till en uppsättning kan du använda metoden .add(). set.add(element) lägger till element till uppsättningen.
För tydlighetens skull lägger vi till element i Python-uppsättningen och skriver ut uppsättningen vid varje steg.
▶️ Låt oss lägga till strängen ’Python’ som ett element i py_set.
py_set.add('Python')
print(py_set)
# Output
{'Python'}
Därefter lägger vi till ytterligare ett element.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
Det är viktigt att förstå att .add()-metoden bara lägger till ett element i uppsättningen om det inte redan finns. Om uppsättningen redan innehåller det element som du vill lägga till har tilläggsoperationen ingen effekt.
För att verifiera detta, låt oss försöka lägga till ’C++’ till py_set.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
Uppsättningen innehåller ’C++’, så tilläggsoperationen har ingen effekt.
▶️ Låt oss lägga till några fler element till setet.
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. Använda metoden .update().
Hittills har vi sett hur man lägger till element i den befintliga uppsättningen – ett element i taget.
Vad händer om du vill lägga till mer än ett element i en sekvens av element?
Du kan göra det med metoden .update() med syntaxen: set.update(collection) för att lägga till element i samlingen till en uppsättning. Samlingen kan vara en lista, tupel, ordbok och så vidare.
py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)
# Output
{'C', 'C++', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}
Den här metoden är användbar när du vill lägga till en samling element till en uppsättning utan att skapa ett annat objekt i minnet.
I nästa avsnitt, låt oss lära oss hur man tar bort element från en uppsättning.
Hur man tar bort element från en Python-uppsättning
Låt oss överväga följande uppsättning (py_set före uppdateringsoperationen).
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
#1. Använda .pop()-metoden
set.pop() tar bort ett element slumpmässigt från uppsättningen och returnerar det. Låt oss kalla popmetoden på py_set och se vad den returnerar.
py_set.pop() # Output 'Rust'
Den här gången returnerade anropet till .pop()-metoden strängen ’Rust’.
Obs: Eftersom .pop()-metoden returnerar ett element slumpmässigt, när du kör koden i slutet, kan du lika gärna få ett annat element.
När vi undersöker uppsättningen är ’Rust’ inte längre närvarande i uppsättningen.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++', 'C'}
#2. Använda metoderna .remove() och discard().
I praktiken kanske du vill ta bort specifika element från uppsättningen. För att göra detta kan du använda metoderna .remove() och .discard().
set.remove(element) tar bort element från uppsättningen.
py_set.remove('C')
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Om vi försöker ta bort ett element som inte finns i uppsättningen, stöter vi på ett 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'
Låt oss ta en titt på py_set det igen. Vi har nu tre element.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Med syntaxen set.discard(element), tar metoden .discard() också bort element från uppsättningen.
py_set.discard('C++')
print(py_set)
# Output
{'JavaScript', 'Python'}
Den skiljer sig dock från metoden .remove() genom att den inte genererar ett KeyError när vi försöker ta bort ett element som inte finns.
Om vi försöker ta bort ’Scala’ (som inte finns) från listan med metoden .discard() ser vi inget fel.
py_set.discard('Scala') #no error!
print(py_set)
# Output
{'JavaScript', 'Python'}
Hur man får åtkomst till element i en Python-uppsättning
Hittills har vi lärt oss hur man lägger till och tar bort element från Python-uppsättningar. Men vi har ännu inte sett hur man kommer åt enskilda element i en uppsättning.
Eftersom en uppsättning är en oordnad samling är den inte indexerbar. Därför, om du försöker komma åt elementen i en uppsättning med hjälp av indexet, kommer du att stöta på ett fel, som visas.
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å hur kommer du åt element i en uppsättning?
Det finns två vanliga sätt att göra detta:
- Gå igenom setet och få tillgång till varje element
- Kontrollera om ett visst element är en del av uppsättningen
▶️ Slinga genom setet och komma åt elementen med en for-loop.
for elt in py_set: print(elt) # Output C++ JavaScript Python Rust C
I praktiken kanske du vill kontrollera om ett givet element finns i uppsättningen med in-operatorn.
Obs: element i set returnerar True om element finns i set; annars returneras False.
I det här exemplet innehåller py_set ’C++’ och innehåller inte ’Julia’ och operatorn in returnerar True respektive False.
'C++' in py_set # True 'Julia' in py_set # False
Hur man hittar längden på en Python-uppsättning
Som sett tidigare kan du använda len()-funktionen för att få antalet element som finns i en uppsättning.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)
# Output: 5
Hur man rensar en Python-uppsättning
För att rensa en uppsättning genom att ta bort alla element kan du använda metoden .clear().
Låt oss anropa metoden .clear() på py_set.
py_set.clear()
Om du försöker skriva ut den får du set() – vilket indikerar att setet är tomt. Du kan också anropa len()-funktionen för att verifiera att längden på mängden är noll.
print(py_set) # set() print(len(py_set)) # 0
Hittills har vi lärt oss hur man utför grundläggande CRUD-operationer på Python-set:
- Skapa: Använd funktionen set(), typ casting och initiering
- Läs: Få tillgång till element i uppsättningen med loopar och in-operator för medlemskapstestning
- Uppdatera: Lägg till, ta bort element från uppsättningar och uppdatera uppsättningar
- Ta bort: Rensa en uppsättning genom att ta bort alla element från den
Common Set Operations, förklaras med Python Code
Python-uppsättningar tillåter oss också att utföra de grundläggande uppsättningsoperationerna. Vi kommer att lära oss om dem i det här avsnittet.
#1. Union of Sets i Python
I mängdteorin är föreningen av två mängder mängden av alla element i åtminstone en av de två mängderna. Om det finns två uppsättningar, A och B, innehåller föreningen element som bara finns i A, bara i B, och elementen som finns i både A och B.
För att hitta föreningen av uppsättningar kan du använda | operatorn eller .union() metoden med syntaxen: 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 är en kommutativ operation; så AUB är samma som BU A. Låt oss verifiera detta genom att byta ut positionerna för setA och setB i .union() metodanropet.
setB.union(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
#2. Skärning av uppsättningar i Python
En annan gemensam uppsättningsoperation är denna skärningspunkt av två uppsättningar, A och B. Set skärningsoperation returnerar en uppsättning som innehåller alla element som finns i både A och B.
För att beräkna skärningspunkten kan du använda &-operatorn eller metoden .intersection(), som förklaras i kodavsnittet nedan.
print(setA & setB)
# Output
{9}
setA.intersection(setB)
# Output
{9}
I detta exempel finns element 9 i både setA och setB; så skärningsuppsättningen innehåller endast detta element.
Liksom setunionen är även set-korsningen en kommutativ operation.
setB.intersection(setA)
# Output
{9}
#3. Ställ in skillnad i Python
Med tanke på vilka två uppsättningar som helst, hjälper union och skärningspunkt oss att hitta de element som finns i båda respektive åtminstone en av uppsättningarna. Å andra sidan hjälper uppsättningsskillnad oss att hitta de element som finns i en uppsättning men inte i den andra.
– setA.difference(setB) ger uppsättningen av element som endast finns i setA och inte i setB.
– setB.difference(setA) ger uppsättningen av element som endast finns i setB och inte i setA.
print(setA - setB)
print(setB - setA)
# Output
{1, 3, 5, 7}
{8, 2, 4, 6}
AB är uppenbarligen inte detsamma som BA, så den inställda skillnaden är inte en kommutativ operation.
setA.difference(setB)
# {1, 3, 5, 7}
setB.difference(setA)
# {2, 4, 6, 8}
#4. Symmetrisk uppsättningsskillnad i Python
Medan mängdskärningspunkten ger oss element som finns i båda uppsättningarna, returnerar den symmetriska mängdskillnaden uppsättningen av element som finns i exakt en av uppsättningarna.
Betrakta följande exempel.
setA = {1,3,5,7,10,12}
setB = {2,4,6,8,10,12}
För att beräkna den symmetriska skillnadsuppsättningen kan du använda operatorn ^ eller metoden .symmetric_difference().
print(setA ^ setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Elementen 10 och 12 finns i både setA och setB. Så de finns inte i den symmetriska skillnadsuppsättningen.
setA.symmetric_difference(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Eftersom operationen symmetrisk uppsättningsskillnad samlar in alla element som förekommer i exakt en av de två uppsättningarna, är den resulterande uppsättningen densamma oavsett i vilken ordning elementen samlas in. Därför är en symmetrisk uppsättningsskillnad en kommutativ operation.
setB.symmetric_difference(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
#5. Delmängder och supermängder i Python
I mängdteorin hjälper delmängder och supermängder till att förstå sambandet mellan två uppsättningar.
Givet två mängder A och B är mängd B en delmängd av mängd A om alla element i mängd B också finns i mängd A. Och mängd A är supermängd av mängd B.
Betrakta exemplet med två uppsättningar: languages och languages_extended.
languages = {'Python', 'JavaScript','C','C++'}
languages_extended = {'Python', 'JavaScript','C','C++','Rust','Go','Scala'}
I Python kan du använda metoden .issubset() för att kontrollera om en given uppsättning är en delmängd av en annan uppsättning.
setA.issubset(setB) returnerar True om setA är en delmängd av setB; annars returnerar den False.
I det här exemplet är språk en delmängd av languages_extended.
languages.issubset(languages_extended) # Output True
På samma sätt kan du använda metoden .issuperset() för att kontrollera om en given uppsättning är en superuppsättning av en annan uppsättning.
setA.issuperset(setB) returnerar True om setA är en superset av setB; annars returnerar den False.
languages_extended.issuperset(languages) # Output True
Eftersom languages_extended är en superuppsättning av språk, returnerar languages_extended.issuperset(languages) True, som ses ovan.
Slutsats
Jag hoppas att den här handledningen hjälpte dig att förstå hur Python-uppsättningar fungerar, uppsättningsmetoderna för CRUD-operationer och vanliga uppsättningsoperationer. Som nästa steg kan du prova att använda dem i dina Python-projekt.
Du kan kolla in andra djupgående Python-guider. Lycka till med lärandet!