ajouter vs mise à jour dans l'ensemble des opérations en python

set.ajouter

set.add ajoute un élément à l'ensemble. Donc,

>>> a = set()
>>> a.add(1)
>>> a
set([1])

fonctionne, mais il ne peut pas travailler avec un objet iterable, sauf s'il est hashable. C'est la raison pour laquelle a.add([1, 2]) échoue.

>>> a.add([1, 2])
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: unhashable type: 'list'

Ici, [1, 2] est considérée comme l'élément est ajouté à l'ensemble et que le message d'erreur dit, une liste ne peut être haché mais tous les éléments d'un ensemble sont censés être hashables. Citant le la documentation,

De retour d'un nouveau set ou frozenset objet dont les éléments sont prises à partir de itératif. Les éléments d'un ensemble doivent être hashable.

set.mise à jour

En cas de set.mise à jour, vous pouvez passer plusieurs iterables d'elle et elle va se répéter tous les iterables et comprendre les différents éléments du jeu. Rappelez-vous: Il ne peut accepter que des iterables. C'est pourquoi vous obtenez une erreur lorsque vous essayez de mettre à jour avec 1

>>> a.update(1)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: 'int' object is not iterable

Mais, la suite serait de travailler parce que la liste [1] est itéré et les éléments de la liste sont ajoutés à l'ensemble.

>>> a.update([1])
>>> a
set([1])

set.update est en fait un équivalent de en place le jeu de l'union de l'opération. Considérons les cas suivants

>>> set([1, 2]) | set([3, 4]) | set([1, 3])
set([1, 2, 3, 4])
>>> set([1, 2]) | set(range(3, 5)) | set(i for i in range(1, 5) if i % 2 == 1)
set([1, 2, 3, 4])

Ici, nous avons explicitement convertir tous les iterables à des ensembles et ensuite, nous trouvons l'union. Il y a plusieurs intermédiaires, des ensembles et des syndicats. Dans ce cas, set.update est une fonction d'assistance. Depuis qu'il accepte n'importe quel itérable, vous pouvez simplement faire

>>> a.update([1, 2], range(3, 5), (i for i in range(1, 5) if i % 2 == 1))
>>> a
set([1, 2, 3, 4])

add ajoute un élément, update "ajoute" un autre objet iterable set, list ou tuple, par exemple:

In [2]: my_set = {1,2,3}

In [3]: my_set.add(5)

In [4]: my_set
Out[4]: set([1, 2, 3, 5])

In [5]: my_set.update({6,7})

In [6]: my_set
Out[6]: set([1, 2, 3, 5, 6, 7])

add accepte uniquement un hashable type. Une liste n'est pas hashable.

Je suppose que personne n'a mentionné à propos de la bonne ressource de Hackerrank. Je voudrais coller comment Hackerrank mentionne la différence entre mise à jour et d'ajouter pour définir en python.

Ensembles sont non ordonnée sac de valeurs uniques. Un ensemble unique contient des valeurs immuables type de données.

CRÉATION D'

myset = {1, 2} # Directly assigning values to a set

myset = set() # Initializing a set

myset = set(['a', 'b']) # Creating a set from a list

print(myset)  ===> {'a', 'b'}

La MODIFICATION de JEU - ajouter() et update()

myset.add('c')

myset  ===>{'a', 'c', 'b'}

myset.add('a') # As 'a' already exists in the set, nothing happens

myset.add((5, 4))

print(myset) ===> {'a', 'c', 'b', (5, 4)} 


myset.update([1, 2, 3, 4]) # update() only works for iterable objects

print(myset) ===> {'a', 1, 'c', 'b', 4, 2, (5, 4), 3}

myset.update({1, 7, 8})

print(myset) ===>{'a', 1, 'c', 'b', 4, 7, 8, 2, (5, 4), 3}

myset.update({1, 6}, [5, 13])

print(myset) ===> {'a', 1, 'c', 'b', 4, 5, 6, 7, 8, 2, (5, 4), 13, 3}

Espère que cela aide. Pour plus de détails sur Hackerrank, voici le lien.