Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Curso Profesional de Python

Curso Profesional de Python

Facundo García Martoni

Facundo García Martoni

Sets

16/21
Recursos

Aportes 31

Preguntas 5

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Un pequeño resumen:

Los sets son una estructura de datos muy similares a las listas en cuanto a su forma, pero presentan ciertas características particulares:

  • Los sets son inmutables

  • Cada elemento del set es único, esto es que no se admiten duplicados, aun si durante la definición del set se agregan elementos repetidos pyhton solo guarda un elemento

  • los sets guardan los elementos en desorden

Para declararlos se utilizan los {} parecido a los diccionarios solo que carece de la composición de conjunto {a:b, c:d}

# set de enteros
my_set = {1, 3, 5}
print(my_set)

# set de diferentes tipos de datos
my_set = {1.0, "Hi", (1, 4, 7)}
print(my_set)

Los sets no pueden ser leídos como las listas o recorridos a través de slices, esto debido a que no tienen un criterio de orden. Sin embargo si podemos agregar o eliminar items de los sets utilizando métodos:

  • add(): nos permite agregar elementos al set, si se intenta agregar un elemento existente simplemente python los ignorara
  • update(): nos permite agregar múltiples elementos al set
  • remove(): permite eliminar un elemento del set, en el caso en que no se encuentre presente dicho elemento, Python elevará un error
  • discard(): permite eliminar un elemento del set, en el caso en que no se encuentre presente dicho elemento, Python dejará el set intacto, sin elevar ningún error.
  • pop(): permite eliminar un elemento del set, pero lo hará de forma aleatoria.
  • clear(): Limpia completamente el set, dejándolo vació.
#ejemplo de operaciones sobre sets 
my_set = {1, 2, 3} 
print(my_set) #Output {1, 2, 3} 

#añadiendo un elemento al set 
my_set.add(4) 
print(my_set) #Output {1, 2, 3, 4}

#añadiendo varios elementos al set, python ignorará elementos repetidos 
my_set.update([1, 5, 6]) 
print(my_set) #Output {1, 2, 3, 4, 5, 6}

# eliminado elementos del set 
my_set.discard(1) 
print(my_set) #Output {2, 3, 4, 5, 6}

# borrando un elemento aleatorio 
my_set.pop()
print(my_set) #Output el set menos un elemento aleatorio 

#limpiar el set 
my_set.clear()
print(my_set) # Output set() 

Podemos utilizar estructuras de datos existentes para transformarlas a sets utilizando el método set:

#usando listas para crear sets
my_list = [1, 2, 3, 3, 4, 5]
my_set = set(my_list)
print(my_set)  #output {1, 2, 3, 4, 5}

#usando tuplas para crear sets 
my_tuple: ('hola', 'hola', 1, 2)
my_set2: set(my_tuple)
print(my_set2) #Output {'hola', 1}

Una aclaración:
Los set.pop() No borran un elemento aleatorio, Borran el primer elemento del objeto set.
Para los mas interesados: https://www.geeksforgeeks.org/python-set-pop/

Se me hacia extraño que en muchos lenguajes ya sea C o Java, C#, etc. pop elimina el elemento de orden superior o dicho el primero y en Python 1 aleatorio.

Sets

Conjuntos: Una colección desordenada de elementos únicos e inmutables.

Características:

  • Un set al ser impreso puede presentar diferente orden al definido pues Python los ordena a modo de optimizar/ahorrar memoria: un set es una colección desordenada.
  • En caso de existir elementos repetidos, los elimina, pues: un set es una lista de elementos únicos.
  • En caso de indicar una lista, por ejemplo, en un set este nos arroja un error, dado que: un set es inmutable.

Al set no se puede acceder con un índice.

Para declarar un set, el grupo de elementos debe ir entre llaves. Se diferencia de los diccionarios ya que no contienen el símbolo “:”, por lo que automáticamente Python lo entiende como un set de datos.

En caso de desear declarar un set vacío no es posible usar llaves ya que al no contener datos entre las llaves las interpreta como un diccionario. En este caso la declaración de un set debe ser explicita mediante el comando set()

Casting con Sets

Para convertir una estructura de datos a un set se utiliza el comando set()

Si se castea una lista a un set como resultado tenemos un set de elementos únicos ya que elimina los elementos repetidos. Los elementos mutables, en caso de existir, este comando los eliminará.

Agregando elementos a un Set

Para agregar un solo elemento se utiliza el método .add de los sets, en cambio, para agregar múltiples elementos se utiliza el método .update. En ambos se eliminan todos los elementos que fuesen repetido en el set o mutables.

Eliminando elementos de un Set

Existen 4 métodos:

  • .discard() = Se indica como parámetro el elemento a eliminar, en caso de no exisitir el elemento no realiza ninguna operación y continúa con la ejecución.
  • .remove() = También se indica como parámetro el elemento a eliminar, pero en este caso si no exististe el elemento arroja un error (KeyError) y detiene la ejecución.
  • .pop() = Elimina un elemento del set de manera aleatoria.
  • .clear() = Limpia el set completo.

como dato , my_set.pop() , devuelve el elemento borrado.
podriamos hacer algo tipo :

elemento_eliminado = my_set.pop() ##Elimina un elemento aleatorio del set, y lo devuelve
    print(f"elemento eliminado = {elemento_eliminado}")

y asi tenemos en cuenta cual se borro, por si hacemos un programa de un sorteo o algo asi.

Mis conjuntos…

Sets

  • Los sets, o conjuntos, son una colección desordenada de elementos únicos e inmutables. ✨

  • Tuplas, strings, números, True, False, etc son sets. 🤯

  • Para crear un set:

    my_set = {3, 4, 5}
    print(my_set) # {3, 4, 5}
    
    my_set2 = {"Hola", 23.3, False, True}
    print(my_set2) # {False, True, "Hola", 23.3}
    
    my_set3 = {3, 3, 2}
    print(my_set3) # {3, 2}
    
    my_set4 = {[1, 2, 3], 4} # ERROR!!!
    
    empty_set = {} # Esto es dict por defecto
    print(type(empty_set)) # <class 'dict'>
    
    empty_set = set()
    print(type(empty_set)) # <class 'set'>
    
  • Para hacer casting a sets usamos set(). Esto elimina los repetidos de una lista o tupla y los hace set.

  • Para añadir elementos a un set, usamos my_set.add(<elemento inmutable>). Para añadir varios elementos, hacemos my_set.update(<lista>, <tupla>).

  • Para borrar elementos de un set, usamos my_set.remove(<elemento>) pero debemos estar seguro de que el set contiene ese elemento. Si no sabemos si existe el elemento my_set.discard(<elemento?>). 👀

  • Para borrar un elemento aleatorio, usamos my_set.pop(). Para borrar todo usamos my_set.clear().

Sets

Los sets (conjuntos) son una colección desordenada de elementos únicos e inmutables.

my_set = {3, 4, 5}
print(f"my_set = {my_set}")

my_set2 = {"Hola",23.3, False, True}
print(f"my_set = {my_set2}")

my_set3 = {3, 3, 2} # Python automáticamente elimina los duplicados
print(f"my_set = {my_set3}")

my_set4 = {[1,2,3] , 4} #Error
print(f"my_set = {my_set4}")

empty_set = {} # Dictionary
empty_set = set() # Set

my_list = [1,1,2,3,4,4,5]
my_set = set(my_list)
print(my_set) # {1, 2, 3, 4, 5}

my_tuple = ("Hola", "Hola", "Hola", 1)
my_set2 = set(my_tuple)
print(my_set2) # {'Hola', 1}

Añadiendo y quitando elementos a los sets:

my_set = {1, 2, 3}

# Añadir un elemento
my_set.add(4)

# Añadir varios elementos
my_set.update([1, 2, 5])
my_set.update((1, 7, 2), {6, 8})

# Borrar un elemento existente
my_set.discard(1)
my_set.remove(2)

# Borrar un elemento inexistente
my_set.discard(10) # No hay problema
my_set.remove(10) # Error, ese elemento no existe

# borrar elemento aleatorio
my_set.pop()

# Borrar todos los elementos
my_set.clear()

APUNTES DE LA CLASE DE SETS 🐍

Un set es una colección desordenada de elementos únicos e inmutables.

¿Cómo se crean los sets?

my_set = {1, 2, 3, 4, 5}
print("my_set =", my_set)

my_set2 = {"Hola", 2.4, False, True}
print("my_set2 =", my_set2)

my_set3 = {3,3,2}
print("my_set3 =", my_set3)

my_set4 = {[1,2,3], [4,5,6],4}
print("my_set4 =", my_set4)
## Este último da error porque una lista es un elemento mutable

Una llave sin los dos puntos crea un set

Se puede crear sets vacíos…

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

empty_set = set()
print(type(empty_set)) # <class 'set'>

Datos a tener en cuenta:

  • Python trata las llaves como un diccionario
  • Se usa la función set() para indicar que es un set

Casting con set

Convertir un set a otra estructura de datos, o una estructura de datos a un set

my_list = [1,1,2,3,45,324]
my_set = set(my_list)
print(my_set)

my_tulpe = ("hola", "hola", "hola", 1)
my_set2 = set(my_tulpe)
print(my_set2)
# {1, 2, 3, 324, 45}
# {1, 'hola'}

Datos a tener en cuenta:

  • Para transformar una lista y una tupla. solo tenemos que usar el set() sobre la variable
  • El set() elimina los elementos que se repiten.

Añadir elementos a un set

my_set = {1,2,3}
print(my_set)

#añadir un elemento

my_set.add(4)
print(my_set)

#añadir múltiples elementos
my_set.update([1,2,5])

#añadir múltiples elementos
my_set.update([1,7,2], {6,8})
print(my_set)
# {1, 2, 3}
# {1, 2, 3, 4}
# {1, 2, 3, 4, 5, 6, 7, 8}

Datos a tener en cuenta:
acá podemos apreciar de que hay métodos que se pueden combinar con los set, por ejemplo .add() y .update(). el .add para agregar un elemento y el update para agregar múltiples elementos


Borrar elementos de un set


my_set = {1,2,3,4,5,6,7}
print(my_set)

#Borrar un elemento existente
my_set.discard(1)

my_set.discard(2)
print(my_set)

#borrar un elemento inexistene
my_set.discard(10)

my_set.remove(12)
print(my_set)
# {1, 2, 3, 4, 5, 6, 7}
# {3, 4, 5, 6, 7}
# Traceback (most recent call last):
#   File "python.py", line 28, in <module>
#     my_set.remove(12)
# KeyError: 12

Se usan los métodos discard y remove
Si el elemento no existe con remove, lanza un error de tipo KeyError. Remove, es más exigene.

Para eliminar elementos aleatorios se usa el pop() y para eliminar todos los elementos del set se usa .clear()

Sets.

Se declaran con { } con la ausencia de ":"
El order que establecemos no es respetado, Python lo presenta distinto para ahorrar memoria y tiempo. Además comprende que es un Set por ello nos ayuda a eleminar elementos repetidos.

# Declarar un diccionario y un set vacío
dic = {}
set = set()

Casting With Sets

Para transformar un elemento a un Set debemos aplicar la función set(elemento). Este proceso elimina todos los elementos repetidos y mutables que contenga.

Los sets no pueden ser leídos como las listas o recorridos a través de slices, esto debido a que no tienen un criterio de orden. Sin embargo si podemos agregar o eliminar items de los sets utilizando métodos:
add(): nos permite agregar elementos al set, si se intenta agregar un elemento existente simplemente python los ignorara
update(): nos permite agregar múltiples elementos al set
remove(): permite eliminar un elemento del set, en el caso en que no se encuentre presente dicho elemento, Python elevará un error
discard(): permite eliminar un elemento del set, en el caso en que no se encuentre presente dicho elemento, Python dejará el set intacto, sin elevar ningún error.
pop(): permite eliminar un elemento del set, pero lo hará de forma aleatoria.
clear(): Limpia completamente el set, dejándolo vació.

  • Un set es una colección desordenada de elementos únicos e inmutables.
myset=set() # set empity
myset=set(mylist) # convert to set
myset.add(element) # add new element
myset.update(elements) # update set elements
myset.remove(element) # delete element
myset.discard(element) # delete element
myset.pop() # delete random element
myset.clear() # delete all elements

Sets

  • Una colección desordenada de elementos únicos e inmutables
Sets = "Colección desordenada de elementos que no se repiten y son inmutables"

IMPORTANTE: Si tratan de hacer my_set.add(“String”) se añadirá el string completo al set, PERO si hacen my_set.update(“String”) añadirá cada uno de los caracteres por separado al SET a menos de que metan el String en una lista:

my_set.update([“String”])

sets -> son una colección desordenada de elementos únicos e inmutables

Añadir elementos en un set -> .add - .update

Remover o quitar elementos de un set -> .remove - .discard - .pop - .clear

Buenas tardes, Estuve aplicando el método pop() en varios set creados con múltiples elementos y en todas las veces aplicadas elimina solo el primer elemento del set.

  1. Imprimo el set original
  2. Aplico el método pop()
  3. Imprimo el set nuevamente.

Y en todos los casos eliminó el primer elemento que se veía al imprimir el set antes de aplicar pop()

O esto aplicando pop() incorrectamente?

Los sets (conjuntos) son una estructura de datos muy similares a las listas en cuanto a su forma, pero presentan ciertas características particulares:
Los sets son inmutables
Cada elemento del set es único, esto es que no se admiten duplicados, aun si durante la definición del set se agregan elementos repetidos pyhton solo guarda un elemento.
los sets guardan los elementos en desorden
Para declararlos se utilizan los {} parecido a los diccionarios solo que carece de la composición de conjunto {a:b, c:d}

Los Sets o Conjuntos son una colección desordenada de elementos únicos e inmutables.

Ojo con el pop, borra en el orden en que fueron ingresados, “first in first out”. En este caso el set es ordenado por python de menor a mayor y toma al menor de los números (en caso ser un set de números) como el primero.

Disclaimer:
El keyword pop() no borra un elemento aleatorio del set, sino que borra el primer elemento del mismo.

Se realizo el reto propuesto:

Un conjunto es una colección no ordenada de objetos únicos. Python provee este tipo de datos «por defecto» al igual que otras colecciones más convencionales como las listas, tuplas y diccionarios.

Los conjuntos son ampliamente utilizados en lógica y matemática, y desde el lenguaje podemos sacar provecho de sus propiedades para crear código más eficiente y legible en menos tiempo.
Creación de un conjunto

Para crear un conjunto especificamos sus elementos entre llaves:

s = {1, 2, 3, 4}

Al igual que otras colecciones, sus miembros pueden ser de diversos tipos:

>>> s = {True, 3.14, None, False, "Hola mundo", (1, 2)}

No obstante, un conjunto no puede incluir objetos mutables como listas, diccionarios, e incluso otros conjuntos.

>>> s = {[1, 2]}
Traceback (most recent call last):
  ...
TypeError: unhashable type: 'list'

Python distingue este tipo operación de la creación de un diccionario ya que no incluye dos puntos. Sin embargo, no puede dirimir el siguiente caso:

s = {}

Por defecto, la asignación anterior crea un diccionario. Para generar un conjunto vacío, directamente creamos una instancia de la clase set:

s = set()

De la misma forma podemos obtener un conjunto a partir de cualquier objeto iterable:

s1 = set([1, 2, 3, 4])
s2 = set(range(10))

Un set puede ser convertido a una lista y viceversa. En este último caso, los elementos duplicados son unificados.

>>> list({1, 2, 3, 4})
[1, 2, 3, 4]
>>> set([1, 2, 2, 3, 4])
{1, 2, 3, 4}

Elementos

Los conjuntos son objetos mutables. Vía los métodos add() y discard() podemos añadir y remover un elemento indicándolo como argumento.

>>> s = {1, 2, 3, 4}
>>> s.add(5)
>>> s.discard(2)
>>> s
{1, 3, 4, 5}

Nótese que si el elemento pasado como argumento a discard() no está dentro del conjunto es simplemente ignorado. En cambio, el método remove() opera de forma similar pero en dicho caso lanza la excepción KeyError.

Para determinar si un elemento pertenece a un conjunto, utilizamos la palabra reservada in.

>>> 2 in {1, 2, 3}
True
>>> 4 in {1, 2, 3}
False

La función clear() elimina todos los elementos.

>>> s = {1, 2, 3, 4}
>>> s.clear()
>>> s
set()

El método pop() retorna un elemento en forma aleatoria (no podría ser de otra manera ya que los elementos no están ordenados). Así, el siguiente bucle imprime y remueve uno por uno los miembros de un conjunto.

while s:
    print(s.pop())

remove() y pop() lanzan la excepción KeyError cuando un elemento no se encuentra en el conjunto o bien éste está vacío, respectivamente.

Para obtener el número de elementos aplicamos la ya conocida función len():

>>> len({1, 2, 3, 4})
4

Operaciones principales

Algunas de las propiedades más interesantes de los conjuntos radican en sus operaciones principales: unión, intersección y diferencia.

La unión se realiza con el caracter | y retorna un conjunto que contiene los elementos que se encuentran en al menos uno de los dos conjuntos involucrados en la operación.

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

La intersección opera de forma análoga, pero con el operador &, y retorna un nuevo conjunto con los elementos que se encuentran en ambos.

>>> a & b
{3, 4}

La diferencia, por último, retorna un nuevo conjunto que contiene los elementos de a que no están en b.

>>> a = {1, 2, 3, 4}
>>> b = {2, 3}
>>> a - b
{1, 4}

Dos conjuntos son iguales si y solo si contienen los mismos elementos (a esto se lo conoce como principio de extensionalidad):

>>> {1, 2, 3} == {3, 2, 1}
True
>>> {1, 2, 3} == {4, 5, 6}
False

Otras operaciones

Se dice que B es un subconjunto de A cuando todos los elementos de aquél pertenecen también a éste. Python puede determinar esta relación vía el método issubset().

>>> a = {1, 2, 3, 4}
>>> b = {2, 3}
>>> b.issubset(a)
True

Inversamente, se dice que A es un superconjunto de B.

>>> a.issuperset(b)
True

La definición de estas dos relaciones nos lleva a concluir que todo conjunto es al mismo tiempo un subconjunto y un superconjunto de sí mismo.

>>> a = {1, 2, 3, 4}
>>> a.issubset(a)
True
>>> a.issuperset(a)
True

La diferencia simétrica retorna un nuevo conjunto el cual contiene los elementos que pertenecen a alguno de los dos conjuntos que participan en la operación pero no a ambos. Podría entenderse como una unión exclusiva.

>>> a = {1, 2, 3, 4}
>>> b = {3, 4, 5, 6}
>>> a.symmetric_difference(b)
{1, 2, 5, 6}

Dada esta definición, se infiere que es indistinto el orden de los objetos:

>>> b.symmetric_difference(a)
{1, 2, 5, 6}

Por último, se dice que un conjunto es disconexo respecto de otro si no comparten elementos entre sí.

>>> a = {1, 2, 3}
>>> b = {3, 4, 5}
>>> c = {5, 6, 7}
>>> a.isdisjoint(b)
False  # No son disconexos ya que comparten el elemento 3.
>>> a.isdisjoint(c)
True   # Son disconexos.

En otras palabras, dos conjuntos son disconexos si su intersección es el conjunto vacío, por lo que puede ilustrarse de la siguiente forma:

>>> def isdisjoint(a, b):
...     return a & b == set()
...
>>> isdisjoint(a, b)
False
>>> isdisjoint(a, c)
True

Conjuntos inmutables

frozenset es una implementación similar a set pero inmutable. Es decir, comparte todas las operaciones de conjuntos provistas en este artículo a excepción de aquellas que implican alterar sus elementos (add(), discard(), etc.). La diferencia es análoga a la existente entre una lista y una tupla.

>>> a = frozenset({1, 2, 3})
>>> b = frozenset({3, 4, 5})
>>> a & b
frozenset({3})
>>> a | b
frozenset({1, 2, 3, 4, 5})
>>> a.isdisjoint(b)
False

Esto permite, por ejemplo, emplear conjuntos como claves en los diccionarios:

>>> a = {1, 2, 3}
>>> b = frozenset(a)
>>> {a: 1}
Traceback (most recent call last):
  ...
TypeError: unhashable type: 'set'
>>> {b: 1}
{frozenset({1, 2, 3}): 1}

Es interesante saber qué estructura está detrás de los sets en Python, así como la complejidad algorítmica detrás de los métodos…en una entrevista que tuve con Microsoft me hicieron una pregunta respecto a eso.

https://www.quora.com/What-is-the-underlying-data-structure-of-set-in-Python

Les comparto mis apuntes:

my_set= {1, 2, 3, 4, 5,}
print (my_set)

#Añadir un elemento
my_set.add(5)
print(my_set)

#Añadir multiples elementos
my_set.update([1, 3, 3, 4, 4, 6])
print(my_set)

#Añadir multiples elementos y estructuras de datos
my_set.update([7, 8], ["Hola"], {9, 9, 10, 11.5})
print (my_set)

#Borrar un elemento de un set
my_set.discard(1)
print(my_set)

#Borrar un elemento de un set
my_set.remove(2)
print(my_set)


##Ambos sirven para borrar pero:
##DISCARD puede borrar elementos asi
##No esten en el set, mientras que si
##Se intenta usar REMOVE con un elemento
##Que no existe en el set va a arrojar error

#Ejemplo

my_set.discard(15)
print(my_set)

# my_set.remove(15)
# print(my_set)
##Leer el error por favor al ejecutar
##Quitar el # antes de ejecutar para visualizar
##El error

#POP elimina elementos aleatorios del set
my_set.pop()
print(my_set)

#CLEAR elimina todos los elementos del set
my_set.clear()
print(my_set)

Entendido

Apuntes

Set

Una colección desordenada

  • de elementos únicos
  • e inmutables

Una tupla es un elemento inmutable, porque no puedes modificar ninguno de los elementos

Las cadenas de caracteres son inmutables no se pueden modificar una vez creadas

Se crea con llaves

my_set = {3, 4, 5}

Una lista es une elemento mutable y no puede ser contenido dentro de un set, nos daré un mensaje de tipo TypeError: unhashable type: ‘list’

Un conjunto vacío se crea

empty_set = {}
print(type(empty_set))  # esto es un diccionario <class 'dict'>
emtpy_set = set()
print(type(empty_set))  # esto es un un set      <class 'set'>

se pueden añadir elementos a un set con el método

  • add: un solo elemento
  • update: varios elementos

se pueden eliminar un elemento a un set con el método

  • discard: un elemento existente
  • remove: un elemento existente, si borro algo que no existe me da KeyError
  • pop: elimina un elemento aleatorio
  • clear: limpia el set

Hay cuatro tipos de datos de recopilación en el lenguaje de programación Python:
Listas, Tuplas, Sets, Diccionarios
Cuando escojamos uno de estos, es util entender las propiedades de ese tipo, escoger el correcto en la situacion correcta puede significar un incremento en eficiencia o seguridad
más información aquí

SETS -> CONJUNTOS
Colección desordenada de elementos únicos (no se repiten) e inmutables (no puedo modificarlos una vez creados).
Para declararlos se utilizan las llaves ’ { } ’ y a diferencia de los diccionarios que se colocaba dos puntos ’ : ’ simplemente se colocan los elementos del conjunto. Ej: my_set = {3, 4, 5}

Para convertir una estructura de datos a un set:
my_set = set(estructura_a_convertir)

  • Añadir elementos a un set:
    • .add: Para agregar un número a mi set.
    • .update: Para agregar varios elementos ami set.
  • Borrar elementos a un set:
    • .discard: Para borrar un elemento en mi set. Puedo intentar borrar elementos inexistentes y no pasa nada.
    • .remove: Para borrar un elemento en mi set. Puedo intentar borrar elementos inexistentes y me genera un error.
    • .pop: Para borrar un elemento aleatorio del set.
    • .clear: Para borrar todos los elementos del set.
my_set = {1, 2, 4, 5}
my_second_set = {x*2 for x in my_set}

print(my_second_set)
print(type(my_second_set))

print(my_set)
print(type(my_set))

my_set2 = {3, 3, 4}
print(my_set2)

my_set3 = my_set.union(my_set2)
print(my_set3)

# Empty set
my_set4 = set()
print(my_set4)
print(type(my_set4))


print("-----")

my_set = {1, 2, 3}
my_set.add(4)
print(my_set)

my_set.update([1, 2, 5])
print(my_set)

my_set.update([1, 7, 2], {6, 8})
print(my_set)

my_set.remove(2)
print(my_set)

my_set.discard(1)
print(my_set)

rnd = my_set.pop()
print(rnd)
print(my_set)

my_set.clear()
print(my_set)

my_set.add(1)
my_set.add(2)
my_set.add(3)
my_set.add(4)
print(my_set)

my_set.difference_update([1, 2])
print(my_set)

Set
Los sets en Python son una estructura de datos usada para almacenar elementos de una manera similar a las listas, pero con ciertas diferencias.

Crear set Python
Los set en Python son un tipo que permite almacenar varios elementos y acceder a ellos de una forma muy similar a las listas pero con ciertas diferencias:

Los elementos de un set son único, lo que significa que no puede haber elementos duplicados.
Los set son desordenados, lo que significa que no mantienen el orden de cuando son declarados.
Sus elementos deben ser inmutables.

https://ellibrodepython.com/sets-python