35 questions pour tester votre connaissance des ensembles Python

le copy() fait une copie superficielle d’un ensemble.

s1 = {'a','b','c'}s2 = s1.copy()
s2 
#=> {'c', 'b', 'a'}

Un ensemble, s1 est un surensemble d’un autre ensemble, s2, si toutes les valeurs de s2 peuvent être trouvés dans s1.

Vous pouvez vérifier si un ensemble est un sur-ensemble d’un autre ensemble avec le issuperset() méthode.

a = {10,20,30}
b = {10,20}a.issuperset(b) #=> True
b.issuperset(a) #=> False

En plus de issuperset(), nous pouvons vérifier si un ensemble est un surensemble en utilisant le >= opérateurs de comparaison.

a = {10,20,30}
b = {10,20}a >= b #=> True
b >= a #=> False

Parce que toutes les valeurs d’un ensemble, s1, sont dans s1, c’est un surensemble de lui-même. Bien que ce ne soit pas un surensemble approprié.

a = {10,20,30}a.issuperset(a) 
#=> True

Un ensemble, s1 est un surensemble approprié d’un autre ensemble, s2, si toutes les valeurs de s2 sont dans s1, et s1 != s2.

Cela peut être vérifié avec le > opérateur.

a = {10,20,30}
b = {10,20}
c = {10,20}a > b #=> True
b > c #=> False

Appel du constructeur de liste, list(), sur un ensemble convertit un ensemble en liste. Mais notez que la commande n’est pas garantie.

a = {4,2,3}
list(a)
#=> [2, 3, 4]

Un ensemble peut être itéré comme n’importe quel autre itérateur avec une boucle. Mais notez encore une fois, l’ordre n’est pas garanti.

s = {'a','b','c','d','e'}for i in s:
print(i)
#=> b
#=> c
#=> e
#=> d
#=> a

Le nombre d’éléments dans un ensemble peut être retourné avec le len() une fonction.

s = {'a','b','c','d','e'}len(s)
#=> 5

Un ensemble peut être créé en utilisant la notation d’ensemble avec des accolades comme, {…}, exemple:

{1,2,3}
#=> {1, 2, 3}

Ou avec le constructeur set, exemple:

# set(1,2,3)
=> TypeError: set expected at most 1 arguments, got 3set([1,2,3])
#=> {1, 2, 3}

Mais notez que ce dernier nécessite de passer dans un autre objet itérable comme une liste.

L’union de 2 ensembles peut être trouvée en utilisant le union() méthode.

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}s1.union(s2)
#=> {1, 2, 3, 4, 5, 6, 7, 8}

Il peut également être trouvé avec le | opérateur.

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}s1 | s2
#=> {1, 2, 3, 4, 5, 6, 7, 8}

L’intersection de 2 ensembles peut être prise avec le intersection() méthode.

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}s1.intersection(s2)
# => {4, 5}

Il peut également être pris avec le & opérateur.

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}s1 & s2
# => {4, 5}

Cela peut être trouvé avec le difference() méthode.

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}s1.difference(s2)
{1, 2, 3}

Il peut également être trouvé avec le - opérateur.

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}s1 - s2
{1, 2, 3}

remove() supprime un élément d’un ensemble par valeur.

s = {'x','y','z'}
s.remove('x')
s
#=> {'y', 'z'}

pop() supprime et renvoie un élément d’un ensemble, traitant l’ensemble comme une file d’attente non ordonnée.

s = {'z','y','x'}
s.pop()
s
#=> {'y', 'z'}

Ensembles, s1 et s2 sont disjoints s’ils n’ont aucun élément en commun.

a = {1,2,3}
b = {4,5,6}
c = {3}a.isdisjoint(b) #=> True
a.isdisjoint(c) #=> False

le update() ajoute des éléments d’un autre ensemble.

a = {1,2,3}
b = {3,4,5}a.update(b)
a
#=> {1, 2, 3, 4, 5}

Cela peut également être fait avec le |= opérateur.

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

Notez que ceci est différent de union. union() renvoie un nouvel ensemble au lieu de mettre à jour un ensemble existant.

clear() supprime tous les éléments d’un ensemble. L’ensemble peut ensuite être utilisé pour de futures opérations et stocker d’autres valeurs.

a = {1,2,3}
a.clear()
a
#=> set()

discard() supprime un élément si cet élément existe, sinon il ne fait rien.

a = {1,2,3}
a.discard(1)
a
#=> {2, 3}a = {1,2,3}
a.discard(5)
a
#=> {1, 2, 3}

Comparez cela à remove() ce qui génère une erreur si vous essayez de supprimer un élément qui n’existe pas.

a = {1,2,3}
a.remove(5)
a
#=> KeyError: 5

Seules les clés du dictionnaire existeront dans l’ensemble renvoyé.

d = {'dog': 1, 'cat':2, 'fish':3}
set(d)
#=> {'cat', 'dog', 'fish'}

Oui. Mais les valeurs de chaque ensemble peuvent ne pas être jointes dans l’ordre.

Remarquez comment la 1ère valeur de l’ensemble entier a été combinée avec la 3ème valeur de l’ensemble de lettres, (1, 'c').

z = zip(
{1,2,3},
{'a','b','c'}
)
list(z)
#=> [(1, 'c'), (2, 'b'), (3, 'a')]