Python Language
Uppsättning

Syntax

• empty_set = set () # initiera en tom uppsättning
• literal_set = {'foo', 'bar', 'baz'} # konstruera en uppsättning med 3 strängar i den
• set_from_list = set (['foo', 'bar', 'baz']) # ring inställningsfunktionen för en ny uppsättning
• set_from_iter = set (x för x inom intervallet (30)) # använd godtyckliga iterables för att skapa en uppsättning
• set_from_iter = {x för x i [random.randint (0,10) för i inom området (10)]} # alternativ notation

Anmärkningar

Få de unika elementen i en lista

Låt oss säga att du har en lista med restauranger - kanske du har läst den från en fil. Du bryr dig om de unika restaurangerna i listan. Det bästa sättet att få de unika elementen från en lista är att förvandla det till en uppsättning:

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

Observera att uppsättningen inte är i samma ordning som originallistan; det beror på att uppsättningar är oordnade , precis som dict .

Detta kan lätt förvandlas tillbaka till en List med Python inbyggda list funktion som ger en annan lista som är samma lista som originalet utan dubbletter:

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

Det är också vanligt att se detta som en rad:

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

Nu kan alla operationer som kan utföras på den ursprungliga listan göras igen.

Verksamhet på uppsättningar

med andra uppsättningar

# 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

med enstaka element

# 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!

Set-operationer returnerar nya uppsättningar, men har motsvarande versioner på plats:

Till exempel:

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

Ställer in mot multisets

Uppsättningar är oordnade samlingar av distinkta element. Men ibland vill vi arbeta med oordnade samlingar av element som inte nödvändigtvis är olika och hålla reda på elementens mångfald.

Tänk på detta exempel:

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

Genom att spara strängarna 'a' , 'b' , 'b' , 'c' i en uppsatt datastruktur har vi förlorat informationen om att 'b' inträffar två gånger. Naturligtvis behåller du informationen om du sparar elementen i en lista

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

men en listadatasstruktur introducerar en extra onödig beställning som kommer att bromsa våra beräkningar.

För implementering av multisets tillhandahåller Python Counter klassen från collections (från version 2.7):

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

Counter är en ordlista där element lagras som ordbokstangenter och deras räkning lagras som ordboksvärden. Och som alla ordböcker är det en oordnad samling.

Ställ in operationer med metoder och inbyggda funktioner

Vi definierar två uppsättningar a och b

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

OBS: {1} skapar en uppsättning av ett element, men {} skapar en tom dict . Rätt sätt att skapa en tom uppsättning är set() .

Genomskärning

a.intersection(b) returnerar en ny uppsättning med element som finns i både a och b

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

Union

a.union(b) returnerar en ny uppsättning med element som finns i antingen a och b

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

Skillnad

a.difference(b) returnerar en ny uppsättning med element som finns i a men inte i b

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

Symmetrisk skillnad

a.symmetric_difference(b) returnerar en ny uppsättning med element som finns i antingen a eller b men inte i båda

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

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

Underuppsättning och superset

c.issubset(a) testar om varje element i c finns i a .

a.issuperset(c) testar om varje element i c finns i a .

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

De senare operationerna har likvärdiga operatörer som visas nedan:

Disjoint uppsättningar

Sätt a och d är osammanhängda om inget element i a är i d och vice versa.

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

Testa medlemskap

Det inbyggda in sökordet söker efter händelser

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

Längd

Funktionen inbyggd len() returnerar antalet element i uppsättningen

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

Uppsättning av uppsättningar

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

leder till:

TypeError: unhashable type: 'set'

frozenset :

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