web-dev-qa-db-fra.com

add vs update dans les opérations set en python

Quelle est la différence entre les opérations d'ajout et de mise à jour en python si je veux juste ajouter une valeur unique à l'ensemble.

a = set()
a.update([1]) #works
a.add(1) #works
a.update([1,2])#works
a.add([1,2])#fails

Quelqu'un peut-il expliquer pourquoi est-ce ainsi.

pythonset
56
aceminer

set.add

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

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

fonctionne, mais il ne peut pas fonctionner avec un itérable, à moins que ce soit 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 traité en tant qu'élément ajouté à l'ensemble et, comme le dit le message d'erreur, une liste ne peut pas être hachée mais tous les éléments d'un ensemble doivent être hashables. Citer la documentation ,

Renvoie un nouvel objet set ou frozenset dont les éléments sont extraits de iterable. Les éléments d'un ensemble doivent être lavables .

set.update

Dans le cas de set.update , vous pouvez lui transmettre plusieurs éléments itérables. Tous les éléments itérables seront itérés et les éléments individuels de l'ensemble seront inclus. Rappelez-vous: _ Il ne peut accepter que des iterables. C'est pourquoi vous obtenez une erreur lorsque vous essayez de le mettre à jour avec 1

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

Toutefois, les éléments suivants fonctionneraient, car la liste [1] est itérée et les éléments de la liste sont ajoutés à l'ensemble.

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

set.update est fondamentalement un équivalent de l'opération d'union d'ensemble sur place. 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 convertissons explicitement tous les itérables en ensembles, puis nous trouvons l'union. Il existe plusieurs ensembles et unions intermédiaires. Dans ce cas, set.update est une fonction d'assistance utile. Puisqu'il accepte n'importe quelle valeur, 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])
75
thefourtheye

add est plus rapide pour un seul élément, car c'est précisément dans ce but que vous ajoutez un seul élément:

In [5]: timeit a.update([1])
10000000 loops, best of 3: 191 ns per loop

In [6]: timeit a.add(1) 
10000000 loops, best of 3: 69.9 ns per loop

update s'attend à un élément iterable ou iterables; si vous avez un seul élément hashable à ajouter, utilisez add si vous avez un élément iterable ou iterables à ajouter, utilisez update.

s.add (x) ajoute un élément x pour définir s

s.update (t) s | = t renvoie un ensemble s avec des éléments ajoutés à partir de t

15
Padraic Cunningham

add ajoute un élément, update "ajoute" une autre itérative 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])
11
Akavall

.add() est destiné à une seule element, alors que .update() est destiné à l'introduction d'autres ensembles.

De l'aide (): 

add(...)
    Add an element to a set.

    This has no effect if the element is already present.


update(...)
    Update a set with the union of itself and others.
4
monkut

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

3
Frank

a.update(1) dans votre code ne fonctionnera pas. add accepte un élément et le met dans l'ensemble s'il n'y est pas déjà mais update prend un élément itérable et en fait une union avec l'ensemble. C'est un peu comme append et extend pour les listes.

2
ekipmanager

Je suppose que personne n'a parlé de la bonne ressource de Hackerrank. Je voudrais coller comment Hackerrank mentionne la différence entre update et add for set en python. 

Les ensembles sont un sac non ordonné de valeurs uniques. Un seul ensemble contient les valeurs de tout type de données immuable. 

SET DE CRÉATION 

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

MODIFYING SET - add () 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}

J'espère que ça aide. Pour plus de détails sur Hackerrank, voici le lien.

1
harrisonthu

la méthode add ajoute directement des éléments à l'ensemble tandis que la méthode update convertit le premier argument en ensemble, puis ajoute la liste est hashable, nous ne pouvons donc pas ajouter de liste hashable à un ensemble non fastidieux.

0
PRATIK M VYAS