Python Language
reeks

Syntaxis

• empty_set = set () # initialiseer een lege set
• literal_set = {'foo', 'bar', 'baz'} # construeer een set met 3 strings erin
• set_from_list = set (['foo', 'bar', 'baz']) # roep de set-functie aan voor een nieuwe set
• set_from_iter = set (x voor x in bereik (30)) # gebruik willekeurige iterables om een set te maken
• set_from_iter = {x voor x in [random.randint (0,10) voor i in bereik (10)]} # alternatieve notatie

Opmerkingen

Download de unieke elementen van een lijst

Stel dat u een lijst met restaurants hebt - misschien leest u deze uit een bestand. Je geeft om de unieke restaurants in de lijst. De beste manier om de unieke elementen uit een lijst te krijgen, is door er een set van te maken:

restaurants = ["McDonald's", "Burger King", "McDonald's", "Chicken Chicken"]
unique_restaurants = set(restaurants)
print(unique_restaurants)
# prints {'Chicken Chicken', "McDonald's", 'Burger King'}

Merk op dat de set niet in dezelfde volgorde staat als de originele lijst; dat komt omdat sets niet geordend zijn , net als dict s.

Dit kan gemakkelijk weer worden omgezet in een List met Python's ingebouwde list functie, het geven van een andere lijst, dat is dezelfde lijst als het origineel, maar zonder duplicaten:

list(unique_restaurants)
# ['Chicken Chicken', "McDonald's", 'Burger King']

Het is ook gebruikelijk om dit als één regel te zien:

# Removes all duplicates and returns another list
list(set(restaurants))

Nu kunnen alle bewerkingen die op de oorspronkelijke lijst kunnen worden uitgevoerd, opnieuw worden uitgevoerd.

Bewerkingen op sets

met andere sets

# Intersection    
{1, 2, 3, 4, 5}.intersection({3, 4, 5, 6})  # {3, 4, 5}
{1, 2, 3, 4, 5} & {3, 4, 5, 6}              # {3, 4, 5}

# Union
{1, 2, 3, 4, 5}.union({3, 4, 5, 6})  # {1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5} | {3, 4, 5, 6}       # {1, 2, 3, 4, 5, 6}

# Difference
{1, 2, 3, 4}.difference({2, 3, 5})  # {1, 4}
{1, 2, 3, 4} - {2, 3, 5}            # {1, 4}

# Symmetric difference with
{1, 2, 3, 4}.symmetric_difference({2, 3, 5})  # {1, 4, 5}
{1, 2, 3, 4} ^ {2, 3, 5}                      # {1, 4, 5}

# Superset check
{1, 2}.issuperset({1, 2, 3})  # False
{1, 2} >= {1, 2, 3}           # False

# Subset check
{1, 2}.issubset({1, 2, 3})  # True
{1, 2} <= {1, 2, 3}         # True

# Disjoint check
{1, 2}.isdisjoint({3, 4})  # True
{1, 2}.isdisjoint({1, 4})  # False

met enkele elementen

# Existence check
2 in {1,2,3}      # True
4 in {1,2,3}      # False
4 not in {1,2,3}  # True

# Add and Remove
s = {1,2,3}
s.add(4)        # s == {1,2,3,4}

s.discard(3)    # s == {1,2,4}
s.discard(5)    # s == {1,2,4}

s.remove(2)     # s == {1,4}
s.remove(2)     # KeyError!

Setbewerkingen retourneren nieuwe sets, maar hebben de bijbehorende in-place-versies:

Bijvoorbeeld:

s = {1, 2}
s.update({3, 4})   # s == {1, 2, 3, 4}

Sets versus multisets

Sets zijn ongeordende verzamelingen van verschillende elementen. Maar soms willen we werken met ongeordende collecties van elementen die niet noodzakelijkerwijs onderscheiden zijn en de veelvoud van de elementen bijhouden.

Beschouw dit voorbeeld:

>>> setA = {'a','b','b','c'}
>>> setA
set(['a', 'c', 'b'])

Door de strings 'a' , 'b' , 'b' , 'c' op te slaan in een ingestelde gegevensstructuur, zijn we de informatie kwijt over het feit dat 'b' twee keer voorkomt. Natuurlijk zou het opslaan van de elementen in een lijst deze informatie behouden

>>> listA = ['a','b','b','c']
>>> listA
['a', 'b', 'b', 'c']

maar een lijst datastructuur introduceert een extra onnodige bestelling die onze berekeningen zal vertragen.

Voor het implementeren van multisets biedt Python de klasse Counter uit de collections (vanaf versie 2.7):

>>> from collections import Counter
>>> counterA = Counter(['a','b','b','c'])
>>> counterA
Counter({'b': 2, 'a': 1, 'c': 1})

Counter is een woordenboek waarin elementen worden opgeslagen als woordenboeksleutels en hun tellingen worden opgeslagen als woordenboekwaarden. En zoals alle woordenboeken, is het een ongeordende verzameling.

Stel bewerkingen in met behulp van methoden en ingebouwde modules

We definiëren twee sets a en b

>>> a = {1, 2, 2, 3, 4}
>>> b = {3, 3, 4, 4, 5}

OPMERKING: {1} maakt een set van één element, maar {} maakt een leeg dict . De juiste manier om een lege set te maken is set() .

kruispunt

a.intersection(b) retourneert een nieuwe set met elementen in zowel a als b

>>> a.intersection(b)
{3, 4}

Unie

a.union(b) retourneert een nieuwe set met elementen aanwezig in a en b

>>> a.union(b)
{1, 2, 3, 4, 5}

Verschil

a.difference(b) geeft een nieuwe set terug met elementen aanwezig in a maar niet in b

>>> a.difference(b)
{1, 2}
>>> b.difference(a)
{5}

Symmetrisch verschil

a.symmetric_difference(b) retourneert een nieuwe set met elementen aanwezig in a of b maar niet in beide

>>> a.symmetric_difference(b)
{1, 2, 5}
>>> b.symmetric_difference(a)
{1, 2, 5}

OPMERKING : a.symmetric_difference(b) == b.symmetric_difference(a)

Subset en superset

c.issubset(a) test of elk element van c deel c.issubset(a) van a .

a.issuperset(c) test of elk element van c zich in a .

>>> c = {1, 2}
>>> c.issubset(a)
True
>>> a.issuperset(c)
True

De laatste operaties hebben gelijkwaardige operatoren zoals hieronder getoond:

Onsamenhangende sets

Sets a en d zijn onsamenhangend als er geen element in a ook in d en omgekeerd.

>>> d = {5, 6}
>>> a.isdisjoint(b) # {2, 3, 4} are in both sets
False
>>> a.isdisjoint(d)
True

# This is an equivalent check, but less efficient
>>> len(a & d) == 0
True

# This is even less efficient
>>> a & d == set()
True

Lidmaatschap testen

De ingebouwde in zoeken op trefwoorden voor occurances

>>> 1 in a
True
>>> 6 in a
False

Lengte

De ingebouwde len() functie retourneert het aantal elementen in de set

>>> len(a)
4
>>> len(b)
3

Set van sets

{{1,2}, {3,4}}

leidt tot:

TypeError: unhashable type: 'set'

Gebruik in plaats daarvan frozenset :

{frozenset({1, 2}), frozenset({3, 4})}