Sök…


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

Uppsättningar är oordnade och har mycket snabb uppslagstid (amorterad O (1) om du vill bli teknisk). Det är bra att använda när du har en samling saker, beställningen spelar ingen roll, och du letar upp mycket efter namn. Om det är mer vettigt att slå upp objekt efter ett indexnummer kan du överväga att använda en lista istället. Om beställningen är viktig, bör du också tänka på en lista.

Uppsättningar är muterbara och kan därför inte hashas, så du kan inte använda dem som ordbokstangenter eller lägga dem i andra uppsättningar, eller någon annanstans som kräver hashable-typer. I sådana fall kan du använda en frozenset .

Elementen i en uppsättning måste vara hashbar . Detta innebär att de har en korrekt __hash__ metod, vilket är förenligt med __eq__ . I allmänhet är muterbara typer som list eller set inte hashbara och kan inte läggas i en uppsättning. Om du stöter på det här problemet kan du överväga att använda dict och immutable nycklar.

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:

metod drift på plats på plats metod
union s | = t uppdatering
genomskärning s & = t intersection_update
skillnad s - = t difference_update
symmetric_difference s ^ = t symmetric_difference_update

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

Python 2.x 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:

Metod Operatör
a.intersection(b) a & b
a.union(b) a | b
a.difference(b) a - b
a.symmetric_difference(b) a ^ b
a.issubset(b) a <= b
a.issuperset(b) a >= b

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


Modified text is an extract of the original Stack Overflow Documentation
Licensierat under CC BY-SA 3.0
Inte anslutet till Stack Overflow