Mängdoperationer (t.ex. bestämning av föreningsmängder, produktmängder och delmängder) med Pythons mängdtyp.

Företag

Python har en inbyggd datatyp, set, som hanterar mängder.

Typmängden är en samling av element som inte är duplicerade (element som inte har samma värde, unika element) och kan utföra mängdoperationer som t.ex. föreningsmängd, produktmängd och differensmängd.

I det här avsnittet förklaras grundläggande operationer i set-typ setoperationer med exempelkod.

  • Skapande av objekt för uppsättningar: {},set()
  • Notation för inklusion av uppsättningar.
  • Antal element i mängden:len()
  • Lägga till ett element i en uppsättning:add()
  • Ta bort ett element från en mängd: discard(),remove(),pop(),clear()
  • Wasset (sammanslagning, union):| operatör,union()
  • Produktuppsättningar (gemensamma delar, korsningar, korsningar):& operatör,intersection()
  • Relativt komplement.:-operatör,difference()
  • Symmetridifferensuppsättning:^ operatör,symmetric_difference()
  • delmängd eller inte:<= operatör,issubset()
  • Övre uppsättning eller inte:>= operatör,issuperset()
  • Fastställande av om de är primära eller inte.:isdisjoint()

Set-typen är en föränderlig typ som kan lägga till och ta bort element, och det finns också en frozenset-typ som har samma set-operation och andra metoder som set-typen men är oföränderlig (kan inte ändras genom att lägga till, ta bort eller på annat sätt ändra element).

Skapande av ett objekt för en uppsättning:: {}, set()

Genereras av vågparenteser {}

Objekt av typen set kan skapas genom att omsluta elementen med parenteser {}.

Om det finns dubbla värden ignoreras de och endast unika värden kvarstår som element.

s = {1, 2, 2, 3, 1, 4}

print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>

Det är möjligt att ha olika typer av element. Uppdaterbara objekt som listtyper kan dock inte registreras. Tupler är tillåtna.

Eftersom settyperna inte är ordnade sparas inte heller den ordning i vilken de genereras.

s = {1.23, 'abc', (0, 1, 2), 'abc'}

print(s)
# {(0, 1, 2), 1.23, 'abc'}

# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'

Olika typer, t.ex. int och float, betraktas som dubbletter om deras värden är likvärdiga.

s = {100, 100.0}

print(s)
# {100}

Eftersom en tom parentes {} anses vara en ordbokstyp kan ett objekt av typen tom uppsättning (empty set) skapas med hjälp av konstruktören som beskrivs härnäst.

s = {}

print(s)
print(type(s))
# {}
# <class 'dict'>

Genereras av konstruktören set()

Objekt av typen set kan också skapas med konstruktören set().

Om du anger ett iterbart objekt, t.ex. en lista eller en tupel, som ett argument genereras ett mängdobjekt vars element endast är unika värden, med uteslutande dubbla element.

l = [1, 2, 2, 3, 1, 4]

print(l)
print(type(l))
# [1, 2, 2, 3, 1, 4]
# <class 'list'>

s_l = set(l)

print(s_l)
print(type(s_l))
# {1, 2, 3, 4}
# <class 'set'>

Immutabla frozenset-typer skapas med konstruktören frozenset().

fs_l = frozenset(l)

print(fs_l)
print(type(fs_l))
# frozenset({1, 2, 3, 4})
# <class 'frozenset'>

Om argumentet utelämnas skapas ett tomt objekt av set-typ (tom set).

s = set()

print(s)
print(type(s))
# set()
# <class 'set'>

Dubbla element kan tas bort från en lista eller tupel med set(), men ordningen i den ursprungliga listan bevaras inte.

Om du vill konvertera en uppsättningstyp till en lista eller tupel använder du list(), tupel().

l = [2, 2, 3, 1, 3, 4]

l_unique = list(set(l))
print(l_unique)
# [1, 2, 3, 4]

I följande artikel finns information om hur du tar bort dubbla element med bibehållen ordning, hur du endast extraherar dubbla element och hur du behandlar dubbla element i en tvådimensionell matris (lista av listor).

Notation för inklusion av uppsättningar.

Förutom listförståelser finns det även setförståelser. Byt helt enkelt ut hakparenteserna [] mot hakparenteser {} i listförståelser.

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

I följande artikel finns mer information om listförståelsenotation.

Antal element i mängden: len()

Antalet element i en mängd kan fås med den inbyggda funktionen len().

s = {1, 2, 2, 3, 1, 4}

print(s)
print(len(s))
# {1, 2, 3, 4}
# 4

Om du vill räkna antalet element i varje lista som har element med dubbla värden etc., se följande artikel.

Lägga till ett element i en uppsättning: add()

Om du vill lägga till ett element i en uppsättning använder du metoden add().

s = {0, 1, 2}

s.add(3)
print(s)
# {0, 1, 2, 3}

Ta bort ett element från en mängd: discard(),remove(),pop(),clear()

För att ta bort ett element från en mängd använder du metoderna discard(), remove(), pop() och clear().

Metoden discard() tar bort det element som anges i argumentet. Om ett värde som inte finns i uppsättningen anges görs ingenting.

s = {0, 1, 2}

s.discard(1)
print(s)
# {0, 2}

s = {0, 1, 2}

s.discard(10)
print(s)
# {0, 1, 2}

Metoden remove() tar också bort det element som anges i argumentet, men ett fel KeyError returneras om ett värde som inte finns i uppsättningen anges.

s = {0, 1, 2}

s.remove(1)
print(s)
# {0, 2}

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

Metoden pop() tar bort element från en mängd och returnerar deras värden. Det är inte möjligt att välja vilka värden som ska tas bort. En tom mängd kommer att resultera i ett KeyError-fel.

s = {2, 1, 0}

v = s.pop()

print(s)
print(v)
# {1, 2}
# 0

s = {2, 1, 0}

print(s.pop())
# 0

print(s.pop())
# 1

print(s.pop())
# 2

# print(s.pop())
# KeyError: 'pop from an empty set'

Metoden clear() tar bort alla element och gör mängden tom.

s = {0, 1, 2}

s.clear()
print(s)
# set()

Wasset (sammanslagning, union): | operatör, union()

Unionsuppsättningen (merger, union) kan erhållas med operatören | eller metoden union().

s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}

s_union = s1 | s2
print(s_union)
# {0, 1, 2, 3}

s_union = s1.union(s2)
print(s_union)
# {0, 1, 2, 3}

Flera argument kan anges för en metod. Förutom set-typen kan listor och tupler som kan konverteras till set-typen med set() också anges som argument. Samma sak gäller för efterföljande operatörer och metoder.

s_union = s1.union(s2, s3)
print(s_union)
# {0, 1, 2, 3, 4}

s_union = s1.union(s2, [5, 6, 5, 7, 5])
print(s_union)
# {0, 1, 2, 3, 5, 6, 7}

Produktuppsättningar (gemensamma delar, korsningar, korsningar): & operatör, intersection()

Produktuppsättningen (gemensam del, skärning och skärning) kan erhållas med &-operatorn eller metoden intersection().

s_intersection = s1 & s2
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2)
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2, s3)
print(s_intersection)
# {2}

Relativt komplement.: -operatör, difference()

Differensmängden kan erhållas med operatorn – eller med metoden difference().

s_difference = s1 - s2
print(s_difference)
# {0}

s_difference = s1.difference(s2)
print(s_difference)
# {0}

s_difference = s1.difference(s2, s3)
print(s_difference)
# {0}

Symmetridifferensuppsättning: ^ operatör, symmetric_difference()

Den symmetriska differensmängden (mängden element som ingår i endast en av de två) kan erhållas med operatorn ^ eller symmetric_difference().

Motsvarar exklusiv disjunktion (XOR) i logiska operationer.

s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}

s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}

delmängd eller inte: <= operatör, issubset()

Om du vill avgöra om en mängd är en delmängd av en annan mängd använder du operatorn <= eller metoden issubset().

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

Både <=-operatorn och metoden issubset() returnerar sant för likvärdiga mängder.

För att avgöra om det är en sann delmängd använder du <=-operatorn, som returnerar falskt för likvärdiga mängder.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

Övre uppsättning eller inte: >= operatör, issuperset()

För att avgöra om en mängd är en övermängd av en annan använder du >=-operatören eller issuperset().

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

Både >=-operatorn och metoden issuperset() returnerar sant för likvärdiga mängder.

För att avgöra om det är en sann övermängd använder du >=-operatorn, som returnerar falskt för likvärdiga mängder.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

Fastställande av om de är primära eller inte.: isdisjoint()

För att avgöra om två mängder är primära i förhållande till varandra använder du metoden isdisjoint().

s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True
Copied title and URL