I denna genomgång kommer du att utforska grunderna i Python-mängder och de olika metoderna som kan användas för att manipulera dem.
Mängder är en grundläggande datatyp i Python. De används när du behöver arbeta med en kollektion av unika element, utan upprepningar.
I de följande avsnitten kommer vi att gå igenom de grundläggande principerna för Python-mängder, samt de metoder som är tillgängliga för att hantera dem. Vi kommer även att se hur man utför vanliga mängdoperationer i Python.
Låt oss börja!
Grundläggande om Python-mängder
En Python-mängd är en oordnad samling av distinkta element. Det betyder att varje element i en mängd måste vara unikt.
Du kan lägga till och ta bort element från en mängd, vilket gör den till en muterbar datatyp. Mängder kan innehålla element av olika datatyper. Dock måste de individuella elementen i en mängd vara hashbara.
Ett objekt i Python sägs vara hashbart om dess hashvärde aldrig ändras. De flesta oföränderliga objekt, som strängar, tupler och numeriska värden, är hashbara.
Vi kommer att undersöka hur man skapar mängder i detalj. Betrakta dessa två exempelmängder:
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 mängden innehåller tal, en tupel och en sträng. Initieringen av denna mängd fungerar felfritt. Den andra mängden däremot innehåller en lista istället för en tupel. En lista är en föränderlig datatyp, och därför inte hashbar, vilket resulterar i ett TypeError.
📑 Sammanfattningsvis kan vi definiera en Python-mängd som en muterbar samling av unika och hashbara element.
Hur man skapar en Python-mängd
Låt oss se hur man skapar en mängd i Python.
#1. Använda explicit initiering
Du kan skapa en mängd i Python genom att ange elementen, separerade med kommatecken (,) och omslutna av klammerparenteser {}.
py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)
# Output
set
Om du har arbetat med Python-listor, vet du att [] initierar en tom lista. Även om en Python-mängd använder klammerparenteser {}, kan du inte använda ett tomt par {} för att initiera en tom mängd. Detta beror på att {} istället initierar en Python-ordbok.
py_set2 = {}
type(py_set2)
# Output
dict
Du kan använda funktionen `type()` för att verifiera att `py_set2` är en ordbok (dict).
#2. Använda funktionen `set()`
Om du vill initiera en tom mängd 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. Konvertera andra iterables till en mängd
Ett annat sätt att skapa mängder är att konvertera andra iterables, som listor och tupler, till mängder med hjälp av `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` elementet ’C’ två gånger. Men i `py_set4` visas ’C’ bara en gång, eftersom en mängd inte tillåter upprepade element. Denna teknik används ofta för att ta bort dubbletter från Python-listor.
Hur man lägger till element i en Python-mängd
Låt oss skapa en tom mängd `py_set` och använda den som exempel under resten av denna genomgång.
py_set = set() len(py_set) # returns the length of a set # Output 0
#1. Använda metoden `.add()`
För att lägga till element till en mängd kan du använda metoden `.add()`. `set.add(element)` lägger till `element` till mängden.
För tydlighets skull, låt oss lägga till element till Python-mängden och skriva ut mängden 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'}
Nu 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()` bara lägger till ett element i mängden om det inte redan finns där. Om mängden redan innehåller elementet som du vill lägga till, har operationen ingen effekt.
För att verifiera detta, låt oss försöka lägga till ’C++’ till `py_set` igen.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}
Mängden innehåller redan ’C++’, så operationen har ingen effekt.
▶️ Låt oss lägga till några fler element till mängden.
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 mängden – ett element i taget.
Vad händer om du vill lägga till fler än ett element, som i en sekvens av element?
Du kan göra det med metoden `.update()` med syntaxen: `set.update(collection)` för att lägga till elementen i `collection` till en mängd. `collection` kan vara en lista, tupel, ordbok, etc.
py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)
# Output
{'C', 'C++', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}
Denna metod är användbar när du vill lägga till en samling av element till en mängd utan att skapa ett annat objekt i minnet.
I nästa avsnitt kommer vi att se hur man tar bort element från en mängd.
Hur man tar bort element från en Python-mängd
Låt oss utgå från följande mängd (py_set före uppdateringsoperationen).
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
#1. Använda metoden `.pop()`
`set.pop()` tar slumpmässigt bort ett element från mängden och returnerar det. Låt oss anropa metoden `pop` på `py_set` och se vad den returnerar.
py_set.pop() # Output 'Rust'
Denna gång returnerade anropet till `.pop()` strängen ’Rust’.
Obs: Eftersom `.pop()` returnerar ett element slumpmässigt, kan du få ett annat element när du kör koden.
När vi undersöker mängden, ser vi att ’Rust’ inte längre finns med.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++', 'C'}
#2. Använda metoderna `.remove()` och `.discard()`
I praktiken kan du vilja ta bort specifika element från mängden. För att göra detta kan du använda metoderna `.remove()` och `.discard()`.
`set.remove(element)` tar bort `element` från mängden.
py_set.remove('C')
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}
Om vi försöker ta bort ett element som inte finns i mängden, kommer vi att få 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 titta på `py_set` 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 mängden.
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()`, får 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-mängd
Hittills har vi lärt oss hur man lägger till och tar bort element från Python-mängder. Men vi har ännu inte sett hur man kommer åt enskilda element i en mängd.
Eftersom en mängd är en oordnad samling, är den inte indexerbar. Om du försöker komma åt element i en mängd med hjälp av dess index, kommer du att få ett felmeddelande, som visas nedan.
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 man åt element i en mängd?
Det finns två vanliga sätt att göra detta:
- Gå igenom mängden och få tillgång till varje element
- Kontrollera om ett visst element ingår i mängden
▶️ Slinga genom mängden och kom åt elementen med en `for`-loop.
for elt in py_set: print(elt) # Output C++ JavaScript Python Rust C
I praktiken kan det vara användbart att kontrollera om ett visst element finns i mängden, med hjälp av operatorn `in`.
Obs: `element in set` returnerar `True` om `element` finns i `set`; annars returneras `False`.
I det här exemplet innehåller `py_set` ’C++’ men 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-mängd
Som vi sett tidigare kan du använda funktionen `len()` för att få antalet element som finns i en mängd.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)
# Output: 5
Hur man rensar en Python-mängd
För att rensa en mängd 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 mängden är tom. Du kan också anropa funktionen `len()` 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-mängder:
- Skapa: Använd funktionen `set()`, typkonvertering och initiering
- Läs: Få tillgång till element i mängden med loopar och operatorn `in` för medlemskapstestning
- Uppdatera: Lägg till, ta bort element från mängder och uppdatera mängder
- Ta bort: Rensa en mängd genom att ta bort alla element från den
Vanliga mängdoperationer, förklarade med Python-kod
Python-mängder tillåter oss också att utföra de grundläggande mängdoperationerna. Vi kommer att se på dem i det här avsnittet.
#1. Union av mängder i Python
Inom mängdteorin är unionen av två mängder mängden av alla element som finns i minst en av de två mängderna. Om vi har två mängder, A och B, innehåller unionen element som bara finns i A, bara i B, samt element som finns i både A och B.
För att hitta unionen av mängder kan du använda operatorn `|` eller metoden `.union()`, 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}
Mängdunion är en kommutativ operation, så A∪B är samma som B∪A. Låt oss verifiera detta genom att byta plats på `setA` och `setB` i anropet till metoden `.union()`.
setB.union(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
#2. Snittet av mängder i Python
En annan vanlig mängdoperation är snittet av två mängder, A och B. Snittoperationen returnerar en mängd som innehåller alla element som finns i både A och B.
För att beräkna snittet kan du använda operatorn `&` eller metoden `.intersection()`, vilket förklaras i kodavsnittet nedan.
print(setA & setB)
# Output
{9}
setA.intersection(setB)
# Output
{9}
I det här exemplet finns elementet 9 i både `setA` och `setB`, så snittet innehåller endast detta element.
Precis som mängdunionen, är även mängdsnittet en kommutativ operation.
setB.intersection(setA)
# Output
{9}
#3. Mängddifferens i Python
Givet två mängder hjälper union och snitt oss att hitta de element som finns i båda respektive minst en av mängderna. Å andra sidan hjälper mängddifferens oss att hitta de element som finns i en mängd men inte i den andra.
– `setA.difference(setB)` ger mängden av element som endast finns i `setA` och inte i `setB`.
– `setB.difference(setA)` ger mängden 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}
A∖B är uppenbarligen inte samma sak som B∖A, så mängddifferensen är inte en kommutativ operation.
setA.difference(setB)
# {1, 3, 5, 7}
setB.difference(setA)
# {2, 4, 6, 8}
#4. Symmetrisk mängddifferens i Python
Medan mängdsnittet ger oss element som finns i båda mängderna, returnerar den symmetriska mängddifferensen mängden av element som finns i exakt en av mängderna.
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 differensen 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 ingår inte i den symmetriska differensen.
setA.symmetric_difference(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
Eftersom den symmetriska differensen samlar alla element som förekommer i exakt en av de två mängderna, blir den resulterande mängden densamma oavsett i vilken ordning elementen samlas in. Därför är den symmetriska differensen en kommutativ operation.
setB.symmetric_difference(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}
#5. Delmängder och övermängder i Python
Inom mängdteorin hjälper delmängder och övermängder till att förstå relationerna mellan två mängder.
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 då en övermängd av mängd B.
Betrakta exemplet med två mängder: `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 mängd är en delmängd av en annan mängd.
`setA.issubset(setB)` returnerar `True` om `setA` är en delmängd av `setB`; annars returneras `False`.
I det här exemplet är `languages` 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 mängd är en övermängd av en annan mängd.
`setA.issuperset(setB)` returnerar `True` om `setA` är en övermängd av `setB`; annars returneras `False`.
languages_extended.issuperset(languages) # Output True
Eftersom `languages_extended` är en övermängd av `languages`, returnerar `languages_extended.issuperset(languages)` `True`, som visas ovan.
Slutsats
Jag hoppas att den här genomgången hjälpte dig att förstå hur Python-mängder fungerar, mängdmetoderna för CRUD-operationer och vanliga mängdoperationer. 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!