Agregar vs actualizar en las operaciones establecidas en Python

¿Cuál es la diferencia entre las operaciones de agregar y actualizar en python si solo quiero agregar un valor único al conjunto?

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

¿Alguien puede explicar por qué esto es así?

set.add

set.add agrega un elemento individual al conjunto. Asi que,

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

funciona, pero no puede funcionar con un iterable, a menos que sea hashable. Esa es la razón por la que a.add([1, 2]) falla.

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

Aquí, [1, 2] se trata como el elemento que se agrega al conjunto y, como dice el mensaje de error, una lista no se puede modificar, pero se espera que todos los elementos de un conjunto sean hashables. Citando la documentación ,

Devuelve un nuevo set u objeto frozenset cuyos elementos se hayan tomado de iterable. Los elementos de un conjunto deben ser hashable .

set.update

En el caso de set.update , puede pasarle varios iterables, set.update todos los iterables e incluirá los elementos individuales en el conjunto. Recuerda: solo puede aceptar iterables. Es por eso que está recibiendo un error cuando intenta actualizarlo con 1

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

Pero, lo siguiente funcionaría porque la lista [1] está iterada y los elementos de la lista se agregan al conjunto.

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

set.update es básicamente un equivalente de una operación de unión de conjuntos en el lugar. Considere los siguientes casos

 >>> 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]) 

Aquí, convertimos explícitamente todos los iterables en conjuntos y luego encontramos la unión. Hay múltiples conjuntos intermedios y uniones. En este caso, set.update sirve como una buena función auxiliar. Ya que acepta cualquier iterable, simplemente puede hacer

 >>> 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 es más rápido para un solo elemento porque es exactamente para ese propósito, agregando un solo elemento:

 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 espera un iterable o iterables, por lo tanto, si tiene que agregar un único elemento hashable, use add si tiene un iterable o iterables de elementos hashable para agregar el uso update .

s.add (x) agrega elemento x para establecer s

s.update (t) s | = t devuelve los conjuntos s con elementos agregados desde t

add agrega un elemento, la update “agrega” otro set , list o tuple iterable, por ejemplo:

 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() está destinado a un solo element , mientras que .update() es para la introducción de otros conjuntos.

De ayuda ():

 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. 

add solo acepta un tipo de hashable. Una lista no es hashable.

a.update(1) en su código no funcionará. add acepta un elemento y lo coloca en el conjunto si aún no está allí, pero la update toma un iterable y hace uniones del conjunto con ese iterable. Es como append y extend a las listas.

Supongo que nadie mencionó el buen recurso de Hackerrank. Me gustaría pegar cómo Hackerrank menciona la diferencia entre actualizar y agregar para establecer en Python.

Los conjuntos son bolsa desordenada de valores únicos. Un solo conjunto contiene valores de cualquier tipo de datos inmutables.

CREANDO SET

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

MODIFICAR CONJUNTO – agregar () y actualizar ()

 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} 

Espero eso ayude. Para más detalles sobre Hackerrank, aquí está el enlace.

el método agregar agrega directamente elementos al conjunto, mientras que el método de actualización convierte el primer argumento en un conjunto, luego agrega que la lista es hashable, por lo tanto, no podemos agregar una lista de hashable al conjunto que no se puede lavar.