Opérations sur les ensembles (par exemple, détermination des ensembles d’union, des ensembles de produits et des sous-ensembles) avec le type d’ensemble de Python.

Affaires

Python fournit un type de données intégré, set, qui gère les ensembles.

L'ensemble de type est une collection d'éléments non dupliqués (éléments qui n'ont pas la même valeur, éléments uniques) et peut effectuer des opérations d'ensemble telles que l'ensemble d'union, l'ensemble de produit et l'ensemble de différence.

Dans cette section, les opérations de base dans les opérations de type set sont expliquées avec un exemple de code.

  • Création d'objets d'ensemble: {},set()
  • notation d'inclusion d'ensemble
  • Nombre d'éléments dans l'ensemble:len()
  • Ajout d'un élément à un ensemble:add()
  • Retirer un élément d'un ensemble: discard(),remove(),pop(),clear()
  • Wasset (fusion, union):|opérateur,union()
  • Ensembles de produits (parties communes, intersections, croisements):& opérateur,intersection()
  • complément relatif:-opérateur,difference()
  • jeu de différences de symétrie:opérateur,symmetric_difference()
  • sous-ensemble ou non:<= opérateur,issubset()
  • Ensemble supérieur ou non:>= opérateur,issuperset()
  • Déterminer s'ils sont mutuellement premiers ou non.:isdisjoint()

Le type set est un type mutable qui peut ajouter et supprimer des éléments, et il existe également un type frozenset qui possède la même opération set et d'autres méthodes que le type set mais qui est immuable (ne peut pas être modifié par l'ajout, la suppression ou toute autre modification des éléments).

Création de l'objet set :: {}, set()

Généré par les parenthèses de l'onde {}

Les objets de type ensemble peuvent être créés en enfermant les éléments entre accolades {}.

S'il y a des valeurs en double, elles sont ignorées et seules les valeurs uniques restent comme éléments.

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

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

Il est possible d'avoir différents types comme éléments. Toutefois, les objets actualisables tels que les types de listes ne peuvent pas être enregistrés. Les tuples sont autorisés.

De plus, comme les types d'ensembles ne sont pas ordonnés, l'ordre dans lequel ils sont générés n'est pas mémorisé.

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

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

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

Des types différents, tels que int et float, sont considérés comme des doublons si leurs valeurs sont équivalentes.

s = {100, 100.0}

print(s)
# {100}

Puisqu'une accolade vide {} est considérée comme un type de dictionnaire, un objet de type ensemble vide (empty set) peut être créé à l'aide du constructeur décrit ci-après.

s = {}

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

Généré par le constructeur set()

Les objets de type set peuvent également être créés avec le constructeur set().

La spécification d'un objet itérable tel qu'une liste ou un tuple comme argument génère un objet set dont les éléments sont uniquement des valeurs uniques, les éléments en double étant exclus.

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

Les types frozenset immuables sont créés avec le constructeur frozenset().

fs_l = frozenset(l)

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

Si l'argument est omis, un objet de type ensemble vide (ensemble vide) est créé.

s = set()

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

Les éléments en double peuvent être supprimés d'une liste ou d'un tuple à l'aide de set(), mais l'ordre de la liste originale n'est pas préservé.

Pour convertir un type d'ensemble en une liste ou un tuple, utilisez list(), tuple().

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

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

Consultez l'article suivant pour obtenir des informations sur la suppression des éléments en double tout en préservant l'ordre, l'extraction des éléments en double uniquement et le traitement des éléments en double dans un tableau bidimensionnel (liste de listes).

notation d'inclusion d'ensemble

En plus des compréhensions de listes, il existe des compréhensions d'ensembles. Il suffit de remplacer les crochets [] par des accolades {} dans les compréhensions de listes.

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

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

Voir l'article suivant pour plus d'informations sur la notation de la compréhension des listes.

Nombre d'éléments dans l'ensemble: len()

Le nombre d'éléments dans un ensemble peut être obtenu avec la fonction intégrée len().

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

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

Si vous voulez compter le nombre d'éléments dans chaque liste qui a des éléments avec des valeurs en double, etc, voir l'article suivant.

Ajout d'un élément à un ensemble: add()

Pour ajouter un élément à un ensemble, utilisez la méthode add().

s = {0, 1, 2}

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

Retirer un élément d'un ensemble: discard(),remove(),pop(),clear()

Pour supprimer un élément d'un ensemble, utilisez les méthodes discard(), remove(), pop() et clear().

La méthode discard() supprime l'élément spécifié dans l'argument. Si une valeur qui n'existe pas dans l'ensemble est spécifiée, rien n'est fait.

s = {0, 1, 2}

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

s = {0, 1, 2}

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

La méthode remove() supprime également l'élément spécifié dans l'argument, mais une erreur KeyError est renvoyée si une valeur qui n'existe pas dans l'ensemble est spécifiée.

s = {0, 1, 2}

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

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

La méthode pop() supprime les éléments d'un ensemble et renvoie leurs valeurs. Il n'est pas possible de sélectionner les valeurs à supprimer. Un ensemble vide entraînera une erreur KeyError.

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'

La méthode clear() supprime tous les éléments et rend l'ensemble vide.

s = {0, 1, 2}

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

Wasset (fusion, union): |opérateur, union()

L'ensemble d'union (fusion, union) peut être obtenu avec l'opérateur | ou la méthode 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}

Plusieurs arguments peuvent être spécifiés pour une méthode. En plus du type set, les listes et les tuples qui peuvent être convertis au type set par set() peuvent également être spécifiés comme arguments. Il en va de même pour les opérateurs et les méthodes suivants.

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}

Ensembles de produits (parties communes, intersections, croisements): & opérateur, intersection()

L'ensemble des produits (partie commune, intersection, et intersection) peut être obtenu avec l'opérateur & ou la méthode 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}

complément relatif: -opérateur, difference()

L'ensemble des différences peut être obtenu avec l'opérateur – ou la méthode 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}

jeu de différences de symétrie: opérateur, symmetric_difference()

L'ensemble des différences symétriques (l'ensemble des éléments contenus dans un seul des deux) peut être obtenu avec l'opérateur ^ ou symmetric_difference().

Équivalent de la disjonction exclusive (XOR) dans les opérations logiques.

s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}

s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}

sous-ensemble ou non: <= opérateur, issubset()

Pour déterminer si un ensemble est un sous-ensemble d'un autre ensemble, utilisez l'opérateur <= ou la méthode issubset().

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

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

L'opérateur <= et la méthode issubset() renvoient tous deux vrai pour des ensembles équivalents.

Pour déterminer s'il s'agit d'un sous-ensemble vrai, utilisez l'opérateur <=, qui renvoie faux pour les ensembles équivalents.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

Ensemble supérieur ou non: >= opérateur, issuperset()

Pour déterminer si un ensemble est un sur-ensemble d'un autre, utilisez l'opérateur >= ou issuperset().

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

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

L'opérateur >= et la méthode issuperset() renvoient tous deux true pour les ensembles équivalents.

Pour déterminer s'il s'agit d'un vrai sur-ensemble, utilisez l'opérateur >=, qui renvoie faux pour les ensembles équivalents.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

Déterminer s'ils sont mutuellement premiers ou non.: isdisjoint()

Pour déterminer si deux ensembles sont premiers entre eux, utilisez la méthode isdisjoint().

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

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True