Sætoperationer (f.eks. bestemmelse af foreningsmængder, produktmængder og delmængder) med Pythons sættype

Forretning

Python har en indbygget datatype, set, som håndterer mængder.

Typemængden er en samling af ikke-duplikerede elementer (elementer, der ikke har samme værdi, unikke elementer) og kan udføre mængdeoperationer som f.eks. unionsmængde, produktmængde og differencemængde.

I dette afsnit forklares de grundlæggende operationer i sæt-type sætoperationer med eksempler på kode.

  • Oprettelse af sætobjekter: {},set()
  • notation af sæt inklusion
  • Antal elementer i mængden:len()
  • Tilføjelse af et element til et sæt:add()
  • Fjern et element fra et sæt: discard(),remove(),pop(),clear()
  • Wasset (fusion, union):| operatør,union()
  • Produktsæt (fælles dele, krydsninger, krydsninger, krydsninger):& operatør,intersection()
  • relativt supplement:-operatør,difference()
  • sæt af symmetriforskelle:^ operatør,symmetric_difference()
  • delmængde eller ej:<= operatør,issubset()
  • Øvre sæt eller ej:>= operatør,issuperset()
  • Bestemmelse af, om de er indbyrdes primtal eller ej:isdisjoint()

Sættetypen er en foranderlig type, der kan tilføje og slette elementer, og der findes også en frozenset-type, der har den samme sætoperation og andre metoder som sættypen, men som er uforanderlig (kan ikke ændres ved at tilføje, slette eller på anden måde ændre elementer).

Oprettelse af et sætobjekt:: {}, set()

Genereret af bølgebøjler {}

Objekter af typen set kan oprettes ved at omslutte elementerne med parenteser {}.

Hvis der er duplikerede værdier, ignoreres de, og kun unikke værdier forbliver som elementer.

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

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

Det er muligt at have forskellige typer som elementer. Der kan dog ikke registreres opdaterbare objekter som f.eks. listetyper. Tupler er tilladt.

Da sættyper ikke er ordnede, gemmes den rækkefølge, de genereres i, heller ikke.

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

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

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

Forskellige typer, f.eks. int og float, anses for at være dubletter, hvis deres værdier er ækvivalente.

s = {100, 100.0}

print(s)
# {100}

Da en tom parentes {} betragtes som en ordbogstype, kan der oprettes et objekt af typen tomt sæt (tomt sæt) ved hjælp af den konstruktør, der beskrives nedenfor.

s = {}

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

Genereret af konstruktøren set()

Objekter af typen set kan også oprettes med konstruktøren set().

Når du angiver et iterbart objekt som f.eks. en liste eller tupel som et argument, genereres et sætobjekt, hvis elementer kun er unikke værdier, idet duplikerede elementer udelukkes.

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-typer oprettes med konstruktøren frozenset().

fs_l = frozenset(l)

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

Hvis argumentet udelades, oprettes der et tomt objekt af sæt-type (tomt sæt).

s = set()

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

Dobbelte elementer kan fjernes fra en liste eller tupel ved hjælp af set(), men rækkefølgen i den oprindelige liste bevares ikke.

Hvis du vil konvertere en sættype til en liste eller tupel, skal du bruge list(),tuple().

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

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

Se følgende artikel for oplysninger om fjernelse af dobbelte elementer med bevarelse af rækkefølgen, udtrækning af kun dobbelte elementer og behandling af dobbelte elementer i et todimensionelt array (liste af lister).

notation af sæt inklusion

Ud over listeforståelser findes der også sætforståelser. Du skal blot erstatte de firkantede parenteser [] med parenteser {} i listeforståelser.

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

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

Se følgende artikel for at få flere oplysninger om listeforståelsesnotationen.

Antal elementer i mængden: len()

Antallet af elementer i en mængde kan beregnes med den indbyggede funktion len().

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

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

Hvis du vil tælle antallet af elementer i hver liste, der har elementer med dobbelte værdier osv., kan du se følgende artikel.

Tilføjelse af et element til et sæt: add()

Hvis du vil tilføje et element til et sæt, skal du bruge add()-metoden.

s = {0, 1, 2}

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

Fjern et element fra et sæt: discard(),remove(),pop(),clear()

Hvis du vil fjerne et element fra en mængde, skal du bruge metoderne discard(), remove(), pop() og clear().

Metoden discard() sletter det element, der er angivet i argumentet. Hvis der er angivet en værdi, som ikke findes i mængden, sker der intet.

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() fjerner også det element, der er angivet i argumentet, men der returneres en KeyError-fejl, hvis der er angivet en værdi, som ikke findes i sættet.

s = {0, 1, 2}

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

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

Metoden pop() fjerner elementer fra et sæt og returnerer deres værdier. Det er ikke muligt at vælge, hvilke værdier der skal fjernes. Et tomt sæt vil resultere i en KeyError-fejl.

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() fjerner alle elementer og gør mængden tom.

s = {0, 1, 2}

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

Wasset (fusion, union): | operatør, union()

Union-sættet (merger, union) kan opnås med operatoren | 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}

Der kan angives flere argumenter for en metode. Ud over sættypen kan lister og tupler, der kan konverteres til sættypen med set(), også angives som argumenter. Det samme gælder for efterfølgende operatorer og 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}

Produktsæt (fælles dele, krydsninger, krydsninger, krydsninger): & operatør, intersection()

Produktmængden (fælles del, skæringspunkt og skæringspunkt) kan fås med &-operatoren 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 supplement: -operatør, difference()

Differencesættet kan fås ved hjælp af operatoren – eller 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}

sæt af symmetriforskelle: ^ operatør, symmetric_difference()

Det symmetriske forskelsæt (mængden af elementer, der kun er indeholdt i et af de to sæt) kan fås med ^-operatoren eller symmetric_difference().

Svarer til eksklusiv disjunktion (XOR) i logiske 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ængde eller ej: <= operatør, issubset()

Hvis du vil afgøre, om en mængde er en delmængde af en anden mængde, skal du bruge <=-operatoren eller metoden issubset() for at bestemme, om en mængde er en delmængde af en anden mængde.

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

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

Både <=-operatoren og metoden issubset() returnerer sandt for tilsvarende mængder.

Hvis du vil afgøre, om det er en sand delmængde, skal du bruge <=-operatoren, som returnerer falsk for tilsvarende mængder.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

Øvre sæt eller ej: >= operatør, issuperset()

Hvis du vil afgøre, om en mængde er en overmængde af en anden, skal du bruge operatoren >= eller issuperset().

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

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

Både operatoren >= og metoden issuperset() returnerer sandt for tilsvarende mængder.

Hvis du vil afgøre, om det er en sand overmængde, skal du bruge operatoren >=, som returnerer falsk for tilsvarende mængder.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

Bestemmelse af, om de er indbyrdes primtal eller ej: isdisjoint()

Hvis du vil bestemme, om to mængder er primordiale i forhold til hinanden, skal du bruge metoden isdisjoint().

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

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True