Setbewerkingen (bv. bepalen van union sets, product sets, en subsets) met Python’s set type

Bedrijf

Python heeft een ingebouwd gegevenstype, set, dat sets afhandelt.

Het type verzameling is een verzameling van niet-duplicate elementen (elementen die niet dezelfde waarde hebben, unieke elementen) en kan setbewerkingen uitvoeren zoals union set, product set, en difference set.

In deze sectie worden de basisbewerkingen in set-type set-bewerkingen uitgelegd met voorbeeldcode.

  • Creëren van reeksobjecten: {},set()
  • set inclusie notatie
  • Aantal elementen in de verzameling:len()
  • Een element aan een verzameling toevoegen:add()
  • Een element uit een verzameling verwijderen: discard(),remove(),pop(),clear()
  • Wasset (fusie, unie):|operator,union()
  • Productreeksen (gemeenschappelijke delen, kruisingen, kruispunten):& operator,intersection()
  • relatieve aanvulling:-operator,difference()
  • set symmetrieverschillen:^ operator,symmetric_difference()
  • deelverzameling of niet:<= operator,issubset()
  • Bovenste set of niet:>= operator,issuperset()
  • Bepaling of ze onderling priem zijn of niet:isdisjoint()

Het set-type is een muteerbaar type dat elementen kan toevoegen en verwijderen, en er is ook een frozenset-type dat dezelfde set-bewerking en andere methoden heeft als het set-type, maar immuteerbaar is (kan niet gewijzigd worden door elementen toe te voegen, te verwijderen, of op een andere manier te wijzigen).

Creëren van set object:: {}, set()

Gegenereerd door golfbeugels {}

Objecten van het type set kunnen worden gemaakt door elementen in accolades {} te zetten.

Als er dubbele waarden zijn, worden die genegeerd en blijven alleen unieke waarden over als elementen.

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

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

Het is mogelijk om verschillende typen als elementen te hebben. Bijgewerkte objecten, zoals lijsttypen, kunnen echter niet worden geregistreerd. Tupels zijn toegestaan.

En omdat verzameltypes niet geordend zijn, wordt de volgorde waarin ze gegenereerd worden niet opgeslagen.

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

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

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

Verschillende types, zoals int en float, worden als duplicaten beschouwd als hun waarden gelijkwaardig zijn.

s = {100, 100.0}

print(s)
# {100}

Aangezien een lege accolade {} als een woordenboek-type wordt beschouwd, kan een object van het type lege set (lege set) worden gemaakt met de hierna beschreven constructor.

s = {}

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

Gegenereerd door de constructor set()

Objecten van het type set kunnen ook gemaakt worden met de constructor set().

Door een iterabel object, zoals een lijst of een tupel, als argument op te geven, wordt een verzameling gegenereerd waarvan de elementen alleen unieke waarden zijn, waarbij dubbele elementen uitgesloten zijn.

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'>

Immutable frozenset types worden aangemaakt met de constructor frozenset().

fs_l = frozenset(l)

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

Indien het argument wordt weggelaten, wordt een leeg object van het type verzameling (lege verzameling) aangemaakt.

s = set()

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

Dubbele elementen kunnen uit een lijst of tupel verwijderd worden met set(), maar de volgorde van de oorspronkelijke lijst wordt niet bewaard.

Om een verzamelingstype om te zetten in een lijst of tupel, gebruik je list(),tuple().

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

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

Zie het volgende artikel voor informatie over het verwijderen van dubbele elementen met behoud van volgorde, het extraheren van alleen dubbele elementen, en het verwerken van dubbele elementen in een tweedimensionale array (lijst van lijsten).

set inclusie notatie

Naast lijst comprehensies zijn er ook set comprehensies. Vervang gewoon de vierkante haakjes [] door accolades {} in lijst comprehensies.

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

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

Zie het volgende artikel voor meer informatie over de notatie van lijstbegrip.

Aantal elementen in de verzameling: len()

Het aantal elementen in een verzameling kan worden verkregen met de ingebouwde functie len().

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

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

Als u het aantal elementen in elke lijst wilt tellen dat elementen heeft met dubbele waarden, enz., zie dan het volgende artikel.

Een element aan een verzameling toevoegen: add()

Om een element aan een verzameling toe te voegen, gebruik je de add() methode.

s = {0, 1, 2}

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

Een element uit een verzameling verwijderen: discard(),remove(),pop(),clear()

Om een element uit een verzameling te verwijderen, gebruik je de methodes discard(), remove(), pop(), en clear().

De methode discard() verwijdert het element dat in het argument is opgegeven. Indien een waarde wordt gespecificeerd die niet bestaat in de verzameling, wordt niets gedaan.

s = {0, 1, 2}

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

s = {0, 1, 2}

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

De methode remove() verwijdert ook het element gespecificeerd in het argument, maar een fout KeyError wordt teruggegeven indien een waarde wordt gespecificeerd die niet bestaat in de verzameling.

s = {0, 1, 2}

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

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

De methode pop() verwijdert elementen uit een verzameling en geeft hun waarden terug. Het is niet mogelijk om te selecteren welke waarden verwijderd moeten worden. Een lege set zal resulteren in een KeyError-fout.

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'

De clear() methode verwijdert alle elementen en maakt de set leeg.

s = {0, 1, 2}

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

Wasset (fusie, unie): |operator, union()

De unieverzameling (fusie, unie) kan worden verkregen met de operator | of de methode 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}

Meerdere argumenten kunnen worden opgegeven voor een methode. Naast het set-type kunnen ook lijsten en tupels die door set() naar het set-type kunnen worden geconverteerd, als argumenten worden opgegeven. Hetzelfde geldt voor volgende operatoren en methoden.

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}

Productreeksen (gemeenschappelijke delen, kruisingen, kruispunten): & operator, intersection()

De productverzameling (gemeenschappelijk deel, intersectie en doorsnede) kan verkregen worden met de operator & of de intersectie() methode.

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}

relatieve aanvulling: -operator, difference()

De verschilverzameling kan worden verkregen met de operator – of met de methode 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}

set symmetrieverschillen: ^ operator, symmetric_difference()

De symmetrische verschilverzameling (de verzameling van elementen die in slechts één van de twee voorkomen) kan worden verkregen met de operator ^ of symmetric_difference().

Equivalent aan exclusieve disjunctie (XOR) in logische bewerkingen.

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

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

deelverzameling of niet: <= operator, issubset()

Om te bepalen of een verzameling een deelverzameling is van een andere verzameling, gebruikt u de operator <= of de methode issubset().

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

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

Zowel de operator <= als de methode issubset() geven waar terug voor gelijkwaardige verzamelingen.

Om te bepalen of het een ware deelverzameling is, gebruikt u de operator <=, die voor gelijkwaardige verzamelingen false teruggeeft.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

Bovenste set of niet: >= operator, issuperset()

Om te bepalen of een verzameling een superset is van een andere, gebruik je de operator >= of issuperset().

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

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

Zowel de operator >= als de methode issuperset() geven waar terug voor gelijkwaardige verzamelingen.

Om te bepalen of het een echte superset is, gebruik je de operator >=, die false teruggeeft voor equivalente verzamelingen.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

Bepaling of ze onderling priem zijn of niet: isdisjoint()

Om te bepalen of twee verzamelingen priem tot elkaar zijn, gebruik je de methode isdisjoint().

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

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True