Python Language
Ensemble

Syntaxe

• empty_set = set () # initialise un ensemble vide
• literal_set = {'foo', 'bar', 'baz'} # construit un jeu avec 3 chaînes à l'intérieur
• set_from_list = set (['foo', 'bar', 'baz']) # appelle la fonction set pour un nouvel ensemble
• set_from_iter = set (x pour x dans la plage (30)) # utilise des itérables arbitraires pour créer un ensemble
• set_from_iter = {x pour x dans [random.randint (0,10) pour i dans la plage (10)]} # notation alternative

Remarques

Obtenez les éléments uniques d'une liste

Disons que vous avez une liste de restaurants - peut-être que vous le lisez dans un fichier. Vous vous souciez des restaurants uniques dans la liste. La meilleure façon d’obtenir des éléments uniques dans une liste est de les transformer en un ensemble:

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

Notez que le jeu n'est pas dans le même ordre que la liste d'origine. c'est parce que les ensembles ne sont pas ordonnés , tout comme les dict .

Cela peut facilement être transformé en une List avec la fonction de list intégrée de Python, en donnant une autre liste qui est la même liste que l'original mais sans doublons:

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

Il est également fréquent de voir cela comme une seule ligne:

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

Maintenant, toutes les opérations pouvant être effectuées sur la liste d'origine peuvent être effectuées à nouveau.

Opérations sur ensembles

avec d'autres ensembles

# 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

avec des éléments simples

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

Les opérations d'ensemble renvoient de nouveaux ensembles, mais ont les versions en place correspondantes:

Par exemple:

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

Ensembles versus multisets

Les ensembles sont des ensembles non ordonnés d'éléments distincts. Mais parfois, nous voulons travailler avec des ensembles non ordonnés d'éléments qui ne sont pas nécessairement distincts et garder une trace des multiplicités des éléments.

Considérez cet exemple:

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

En enregistrant les chaînes 'a' , 'b' , 'b' , 'c' dans une structure de données définie, nous avons perdu les informations sur le fait que 'b' se produit deux fois. Enregistrer les éléments dans une liste conserverait bien sûr cette information

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

mais une structure de données de liste introduit un ordre supplémentaire inutile qui ralentira nos calculs.

Pour implémenter des multisets, Python fournit la classe Counter partir du module de collections (à partir de la version 2.7):

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

Counter est un dictionnaire où les éléments sont stockés en tant que clés de dictionnaire et leurs comptes sont stockés en tant que valeurs de dictionnaire. Et comme tous les dictionnaires, c'est une collection non ordonnée.

Définir les opérations en utilisant des méthodes et des intégrations

Nous définissons deux ensembles a et b

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

REMARQUE: {1} crée un ensemble d'un élément, mais {} crée un dict vide. La manière correcte de créer un ensemble vide est set() .

Intersection

a.intersection(b) renvoie un nouvel ensemble avec des éléments présents à la fois dans a et b

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

syndicat

a.union(b) renvoie un nouvel ensemble avec des éléments présents dans a et b

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

Différence

a.difference(b) renvoie un nouvel ensemble avec des éléments présents dans a mais pas dans b

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

Différence symétrique

a.symmetric_difference(b) renvoie un nouvel ensemble avec des éléments présents dans a ou b mais pas dans les deux

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

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

Sous-ensemble et superset

c.issubset(a) teste si chaque élément de c est dans a .

a.issuperset(c) teste si chaque élément de c est dans a .

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

Ces dernières opérations ont des opérateurs équivalents comme indiqué ci-dessous:

Ensembles disjoints

Les ensembles a et d sont disjoints si aucun élément dans a n'est également dans d et 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

Test d'adhésion

La commande interne in les recherches de mots clés pour occurances

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

Longueur

La fonction intégrée len() renvoie le nombre d'éléments de l'ensemble

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

Ensemble de jeux

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

mène à:

TypeError: unhashable type: 'set'

Utilisez frozenset :

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