2.10. Sets#

En mängd (set) är en oordnad samling av unika element. Att lägga till ett värde som redan finns har ingen effekt; iterering ger varje värde exakt en gång. Mängder är rätt verktyg när medlemskap och borttagning av dubbletter är viktigt, men ordning inte är det.

2.10.1. Skapa en mängd#

Använd klammerparenteser för en icke-tom mängd, eller set() för en tom:

colours = {"red", "green", "blue"}
empty = set()

Klammerparenteserna ser ut som en dict-literal; {} för sig självt är en tom dict, inte en tom mängd – en av Pythons historiska olyckor. Använd set() för det tomma fallet.

set() bygger också en mängd från valfri itererbar, vilket är det vanliga sättet att ta bort dubbletter från en följd:

nums = [1, 2, 2, 3, 1, 4]
unique = set(nums)
print(unique)

Utdata:

{1, 2, 3, 4}

Utskriftsordningen kan variera – mängder lovar inte att iterera i någon särskild ordning.

2.10.2. Mängd kontra dict#

Både mängder och dictionaries lagrar unika element i en hashtabell. Skillnaden är vad varje element bär med sig:

  • En dict lagrar nyckel-värde-par. Att slå upp en nyckel returnerar dess värde.

  • En set lagrar enbart elementen. Att slå upp ett element talar om huruvida det finns där.

Valet mellan de två handlar om huruvida värdet bredvid varje element betyder något:

  • Välj en mängd när inget värde hör hemma bredvid varje element – du bryr dig bara om huruvida elementet finns, eller du kombinerar grupper av unika element med union/snitt.

  • Välj en dict när varje element är parat med data som uppslagningen är tänkt att hämta – en konfigurationskarta, en cache, en räknare indexerad med namn.

De två typerna delar mycket av ytsyntaxen, vilket är där det mesta av förvirringen kommer ifrån. Skillnaderna i ett block:

set

dict

rymmer

unika element

unika nycklar, var och en med ett värde

fylld literal

{1, 2, 3}

{"a": 1, "b": 2}

tom literal

set()

{}

medlemskapstest

x in s

k in d (endast nycklar)

hämta ett värde

ej tillämpligt

d[k]

lägga till ett element

s.add(x)

d[k] = v

iterera

ger element

ger nycklar (använd d.items() för par)

Asymmetrin mellan de fyllda och tomma literalerna är fallgropen värd att lyfta fram:

  • Klammerparenteser med element i sig – {1, 2, 3} – är en mängdliteral; klammerparenteser med nyckel-värde-par – {"a": 1} – är en dict-literal. Parsern skiljer dem åt utifrån vad som finns inuti.

  • Klammerparenteser med ingenting inuti – {} – är en tom dict, inte en tom mängd. Dictionaries kom först; den tomma literalen tillhör dem. En tom mängd har ingen klammerliteral alls och måste skrivas set().

Ett vanligt mönster när endast nycklarna i en dict någonsin läses är att byta till en mängd – det gör avsikten uppenbar och rensar bort de oanvända värdena ur minnet.

2.10.3. Lägga till och ta bort#

s = {1, 2, 3}
s.add(4)
s.discard(99)            # silent: 99 not in s
s.remove(2)
print(s)

Utdata:

{1, 3, 4}

2.10.4. Medlemskap#

Operatorn in testar medlemskap. På en mängd är det ungefär konstant tid oavsett storlek – vilket är huvudskälet att välja en mängd framför en list när du bara behöver fråga ”finns detta värde där”:

if "red" in colours:
    print("colour is allowed")

En list med samma innehåll skulle söka igenom från början varje gång, vilket är okej för tio element men långsamt för tiotusen.

2.10.5. Mängdoperationer#

Två mängder kan kombineras med de vanliga matematiska operationerna. Var och en har både en operatorform och en metodform:

  • a | b eller a.union(b) – allt i någon av mängderna.

  • a & b eller a.intersection(b) – endast det som förekommer i båda.

  • a - b eller a.difference(b) – i a men inte i b.

  • a ^ b eller a.symmetric_difference(b) – i den ena men inte i båda.

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a | b)
print(a & b)
print(a - b)
print(a ^ b)

Utdata:

{1, 2, 3, 4, 5, 6}
{3, 4}
{1, 2}
{1, 2, 5, 6}

Operatorformerna är skrivskyddade; metodformerna accepterar valfri itererbar på höger sida, inte bara en annan mängd (a.union([5, 6])). Välj den som läser bäst i sammanhanget.

2.10.6. Vad som kan ligga i en mängd#

Element i en mängd måste vara hashbara – samma begränsning som för nycklar i dict. int, float, str, bool, bytes och tuple (när dess innehåll själv är hashbart) fungerar alla. list och dict gör det inte; att försöka lägga till en sådan utlöser TypeError.

2.10.7. frozenset#

En vanlig set är muterbar: varje anrop till add / remove / discard ändrar objektet på plats. Den muterbarheten diskvalificerar den från att vara hashbar, så en mängd kan inte användas som en nyckel i dict eller som medlem i en annan mängd.

frozenset är den oföränderliga motsvarigheten. Den har samma uppslagningar och operatorer (in, |, &, -, ^) som set, men inget add / remove och inga metoder som muterar. Eftersom ingenting någonsin kan ändra dess innehåll är hashen för en frozenset väldefinierad – så den är hashbar:

primary = frozenset({"red", "green", "blue"})
secondary = frozenset({"yellow", "purple", "orange"})

palettes = {
    primary: "RGB",
    secondary: "mixed",
}

print(palettes[primary])

Utdata:

RGB

Konstruera en frozenset från valfri itererbar – frozenset() för det tomma fallet, frozenset(some_set) för att ta en oföränderlig stillbild av en befintlig mängd:

snapshot = frozenset(s)         # immutable copy of s
s.add("new")                    # snapshot does not change

Två vanliga skäl att ta till den:

  • Använd som nyckel i en dict eller medlem i en mängd. Överallt där ett enskilt värde inte kan fånga det du behöver kan en frozenset av värden göra det – ”mängden av särdrag som denna drivrutin stöder”, ”mängden av stift som denna profil använder”.

  • Lås fast en konstant. En frozenset på modulnivå av tillåtna namn kan inte muteras av misstag av en anropare; en vanlig set kan det. Föredra frozenset för allt som är tänkt att vara skrivskyddat efter konstruktion.