No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Modificando conjuntos

3/44
Recursos

Aportes 92

Preguntas 14

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Funciones de set:

  • add(): Añade un elemento.

  • update(): Añade cualquier tipo de objeto iterable como: listas, tuplas.

  • discard(): Elimina un elemento y si ya existe no lanza ningún error.

  • remove(): Elimina un elemento y si este no existe lanza el error “keyError”.

  • pop(): Nos devuelve un elemento aleatorio y lo elimina y si el conjunto está vacío lanza el error “key error”.

  • clear(): Elimina todo el contenido del conjunto.

Para ordenarlos alfabéticamente, se puede usar la función sorted()
Lo dejo por si a alguien le surgió esa duda.

set_countries = {"col", "bol", "mex"}
print(sorted(set_countries))

CRUD en Sets

set_countries = {'col', 'mex', 'bol'}


# conocer el tamaño del conjunto
size = len(set_countries)
print(size) # 3

print('col' in set_countries) # True
print('pe' in set_countries) # False

# add
set_countries.add('pe')
print(set_countries) # {'col', 'mex', 'bol', 'pe'}
set_countries.add('pe')
print(set_countries) # {'col', 'mex', 'bol', 'pe'}

# update, lo que hace es sumar elementos a los existentes
set_countries.update({'ar', 'ecua', 'pe'})
print(set_countries) # {'col', 'mex', 'bol', 'pe', 'ar', 'ecua'}

# remove

set_countries.remove('col')
print(set_countries) # {'mex', 'bol', 'pe', 'ar', 'ecua'}

# si le doy remove a un elemento que no existe, 
# lanza un error python, 
set_countries.remove('ar')

# para eso usamos discard, si no existe, no falla.
set_countries.discard('arg')
print(set_countries)
set_countries.add('arg')
print(set_countries)

# limpiar todo el conjunto, lo deja en vacío
set_countries.clear()
print(set_countries)
print(len(set_countries))

¿Por qué no puede acceder a los elementos de un conjunto a través del índice?

Dado que los conjuntos son colecciones desordenadas, en ellos no se guarda la posición en la que son insertados los elementos como ocurre en los tipos list o tuple. Es por ello que no se puede acceder a los elementos a través de un índice.

Como update añade cualquier tipo de elemento iterable, podemos agregar conjuntos completos de la siguiente forma.
Me parece que es una forma bastante cómoda de consolidar y eliminar duplicados cuando tenemos información
dispersa en muchos sets.

set_countries = {'col', 'mex', 'bol'}
set_countries_two = {'cl', 'br', 'col'}
set_countries_three = {'ur', 've'}

set_countries.update(set_countries_two, set_countries_three)

print(set_countries)

#OUTPUT -> {'col', 'ur', 'mex', 'br', 'cl', 've', 'bol'}

Me di cuenta de algo interesante:

print({True, 1})
print({False, 0})
print(f'1 == True ?: {1 == True}')
print(f'0 == False ?: {0 == False}')

Python considera a 1 y True, como en 0 y False como mismos valores en los sets y solo añadirá al primer valor que encuentre.

Esta clase la explico el profe muy bien

Mis apuntes del curso 😄

#** Modificando conjuntos**


# Apuntes de forma sensilla

#Conjunto general
set_countries = {'Pe', 'Mx', 'Col'}

# Ver el tamaño del conjunto 
size = len(set_countries)
print(size)

# Ver si esta dentro del conjunto (in)
print('Pe' in set_countries)


## Añade elemento (add)
set_countries.add('Es')
print(set_countries)

## Actualizar los elementos (update)
set_countries.update({'Ecua', 'Ar'})
print(set_countries)

## Eliminar elemento (remove)
# Si no encuentra el valor te da un error
set_countries.remove('Col')
#set_countries.remove('Ecuad')

## Otro valor valido al eliminar elemento (discard)
#Si no encuentra el valor, sigue el programa funcionando
set_countries.discard('Ecua')

# Limpia todo el conjunto (clear)
set_countries.clear()
print(set_countries)
print(len(set_countries))

No se a que se deba (si alguien lo sabe le agradecería que me pase de su conocimiento jaja :p) pero al momento de utilizar un set_countries.discard solo se puede con un solo objeto y no con varios D:

I mean, si agrego el siguiente codigo:

set_countries.discard('mex')

obviamente me elimina México, pero cuando lo realizo con

set_countries.discard({'mex', 'col', 'can'})

no elimina nada, se que podría ser por el hecho de como estoy estableciendo los objetos dentro de la operación discard, pero ¿Hay una forma que pueda descartar varios elementos a la vez? o solo puedo quitar un elemento por cada operación de .discard.

Interesante el metodo: update()

la logica nos indicaria que actualizamos un valor especifico con otro valor. Estuve buscando como actualizar un elemento especifico, y la unica solucion es hacer un remove() del elemento que queremos actualizar y luego hacer un add()

""" crud set """
set_countries = {"mex", "col", "bol"}
print(set_countries)

size = len(set_countries)
print(size)

print("pe" in set_countries)
print("bol" in set_countries)

# add update
set_countries.add("ar")
print(set_countries)

set_countries.update({"ar", "pe", "ecu"})
print(set_countries)

# remove discard
set_countries.remove("mex")
print(set_countries)

set_countries.discard("br")
print(set_countries)

set_countries.discard("pe")
print(set_countries)

set_countries.clear()
print(set_countries)
Consejo. Si bien discard() puede parecer una opción más sencilla de usar a la hora de remover un elemento de un set puede ocasionar en el programa un "error silencioso" debido a que la forma en que corrige el error es saltándoselo, a diferencia de remove() que te dice el error especifico y tu cómo programador puedes modificar el código para "atrapar" esos errores y que no resulte en un bug inesperado. Realmente aplica a conveniencia y tipo de programa que hagas, pero siguiendo el zen de python ningún error debe de omitirse y ser tratado apropiadamente.

¿Cómo funciona .difference() ?


Al igual que en teoria de conjuntos, queremos quitarle a A todos los elementos de B (incluso los que tienen en común)

Ejemplo:

#diference() = A - B 
set_number = {1, 'col', 'x', 10, 14, 'e' }
# in this case, set_number minus {10,14, 'm', 'c'}
z = set_number.difference({10,14, 'm', 'c'})
print(z)
El código con comentarios de la clase, por si a alguien le sirve. Cambié algunos países. ![](https://static.platzi.com/media/user_upload/image-77974c18-ea8c-4981-b4c1-701c8f065d91.jpg)
Con eso Pueden hacer el remove y que el código si sega ejecutando si no encuentra el elemento en ele set `try:    set_coutries.remove('cas')    print("Elemento 'cas' removido con éxito")except KeyError:    print("Error: 'cas' no encontrado en el conjunto")`

Hola a todos, aca pueden ver todas las funciones de set y de todos los tipos de datos en python: https://overapi.com/python

Modificando conjuntos.

Tamaño de un conjunto.

En Python, para obtener el tamaño de un conjunto (conjunto de elementos únicos) se puede utilizar la función len(). Por ejemplo, si tienes un conjunto llamado mi_conjunto, puedes obtener su tamaño de la siguiente manera:

mi_conjunto = {1, 2, 3, 4, 5}
tamaño_conjunto = len(mi_conjunto)
print(tamaño_conjunto)

La salida en pantalla será:

5

La función len() también se puede utilizar con otros tipos de datos, como listas, tuplas y cadenas de texto, para obtener su longitud o tamaño.


Consultar si un elemento se encuentra dentro del conjunto.

En Python, para verificar si un elemento se encuentra dentro de un conjunto, se puede utilizar el operador in. Este operador devuelve un valor booleano (True o False) dependiendo de si el elemento está presente o no en el conjunto.

Por ejemplo, si tienes un conjunto llamado mi_conjunto y quieres verificar si el elemento 3 está presente en el conjunto, puedes hacer lo siguiente:

mi_conjunto = {1, 2, 3, 4, 5}
if 3 in mi_conjunto:
    print("El elemento 3 está presente en el conjunto")
else:
    print("El elemento 3 no está presente en el conjunto")

La salida en pantalla será:

El elemento 3 está presente en el conjunto

También se puede utilizar el operador not in para verificar si un elemento no está presente en el conjunto. Por ejemplo:

mi_conjunto = {1, 2, 3, 4, 5}
if 6 not in mi_conjunto:
    print("El elemento 6 no está presente en el conjunto")
else:
    print("El elemento 6 está presente en el conjunto")

La salida en pantalla será:

El elemento 6 no está presente en el conjunto


En Python, los conjuntos (sets) son una colección de elementos únicos y no ordenados. Los conjuntos son mutables, lo que significa que se pueden modificar agregando o eliminando elementos de la colección. Aquí te muestro algunos ejemplos de cómo modificar conjuntos en Python:

Agregar elementos a un conjunto

Puedes agregar elementos a un conjunto utilizando el método add(). Este método acepta un solo argumento, que es el elemento que deseas agregar al conjunto.


frutas = {'manzana', 'plátano', 'naranja'}
frutas.add('fresa')
print(frutas) # {'naranja', 'plátano', 'fresa', 'manzana'}

Eliminar elementos de un conjunto

Puedes eliminar elementos de un conjunto utilizando los métodos discard() o remove(). Ambos métodos aceptan un solo argumento, que es el elemento que deseas eliminar del conjunto. La diferencia entre estos dos métodos es que discard() no genera un error si el elemento no se encuentra en el conjunto, mientras que remove() sí lo hace.

frutas = {'manzana', 'plátano', 'naranja'}
frutas.discard('plátano')
print(frutas) # {'naranja', 'manzana'}

frutas.remove('fresa') # Genera un KeyError porque 'fresa' no está en el conjunto

Actualizar un conjunto con otro conjunto

Puedes actualizar un conjunto con otro conjunto utilizando el método update(). Este método acepta un solo argumento, que es el conjunto que deseas agregar al conjunto original.

frutas = {'manzana', 'plátano', 'naranja'}
otras_frutas = {'fresa', 'sandía'}
frutas.update(otras_frutas)
print(frutas) # {'manzana', 'plátano', 'fresa', 'naranja', 'sandía'}

Eliminar todos los elementos de un conjunto

Puedes eliminar todos los elementos de un conjunto utilizando el método clear(). Este método no acepta argumentos.

frutas = {'manzana', 'plátano', 'naranja'}
frutas.clear()
print(frutas) # set()

Espero que esto te haya ayudado a comprender cómo modificar conjuntos en Python.

conjunto_paises = {“Colombia”,“Venezuela”,“Ecuador”}

#Para saber cuantos elementos hay en el conjunto
size = len(conjunto_paises)
print(size)

#Para saber si un elemento esta dentro del conjunto
print(“Colombia” in conjunto_paises)
print(“Peru” in conjunto_paises)

#Adicionar elementos al conjunto
conjunto_paises.add(“Peru”)
print(conjunto_paises)

#Actualizar elementos del conjunto
conjunto_paises.update({“Argentina”,“Chile”})
print(conjunto_paises)

#Eliminar elemento de un conjunto
conjunto_paises.remove(“Peru”)
print(conjunto_paises)

#Limpiar todo el conjunto
conjunto_paises.clear()
print(conjunto_paises)
print(len(conjunto_paises))

Para eliminar varios elementos de un conjunto (set) a la vez en Python, puedes utilizar el método difference_update() o la operación de diferencia (-=). Aquí tienes ejemplos de cómo puedes hacerlo:

Usando difference_update():

my_set = {1, 2, 3, 4, 5}
elements_to_remove = {3, 4}

my_set.difference_update(elements_to_remove)
print(my_set)

Usando la operación de diferencia (-=):

my_set = {1, 2, 3, 4, 5}
elements_to_remove = {3, 4}

my_set -= elements_to_remove
print(my_set)

remove():Devuelve un error si no encuentra el dato.
discard():No devuelve error si no encuentra el dato.

```js set_countries = {"per","chi","col","mex"} size = len(set_countries) print(size) print("col" in set_countries) print("bra" in set_countries) #add set_countries.add("bra") print(set_countries) set_countries.add("bra") print(set_countries) #update set_countries.update({"arg","ecu","bol"}) print(set_countries) #remove set_countries.remove("bol") print(set_countries) #discard set_countries.discard("lis") #clear set_countries.clear() print(set_countries) print(len(set_countries)) ```set\_countries = {"per","chi","col","mex"} size = len(set\_countries)print(size) print("col" in set\_countries)print("bra" in set\_countries) \#add set\_countries.add("bra")print(set\_countries)set\_countries.add("bra")print(set\_countries) \#updateset\_countries.update({"arg","ecu","bol"})print(set\_countries) \#removeset\_countries.remove("bol")print(set\_countries) \#discardset\_countries.discard("lis") \#clearset\_countries.clear()print(set\_countries)print(len(set\_countries))
`set_countries = {"per","chi","col","mex"}` `size = len(set_countries)print(size)` `print("col" in set_countries)print("bra" in set_countries)` `#add` `set_countries.add("bra")print(set_countries)set_countries.add("bra")print(set_countries)` `#updateset_countries.update({"arg","ecu","bol"})print(set_countries)` `#removeset_countries.remove("bol")print(set_countries)` `#discardset_countries.discard("lis")` `#clearset_countries.clear()print(set_countries)print(len(set_countries))`
set\_countries = {"per","chi","col","mex"} size = len(set\_countries)print(size) print("col" in set\_countries)print("bra" in set\_countries) \#add set\_countries.add("bra")print(set\_countries)set\_countries.add("bra")print(set\_countries) \#updateset\_countries.update({"arg","ecu","bol"})print(set\_countries) \#removeset\_countries.remove("bol")print(set\_countries) \#discardset\_countries.discard("lis") \#clearset\_countries.clear()print(set\_countries)print(len(set\_countries))
### Esquema de características 1. **Listas**: * **Mutable**: Puedes agregar, eliminar o cambiar elementos. * **Ordenada**: Los elementos tienen un orden, y puedes acceder a ellos mediante un índice. * **Permite duplicados**: Puedes tener múltiples elementos iguales. 2. **Tuplas**: * **Inmutable**: No puedes modificar los elementos después de la creación. * **Ordenada**: Los elementos mantienen su orden. * **Permite duplicados**: Los valores pueden repetirse. 3. **Diccionarios**: * **Mutable**: Puedes agregar, eliminar o cambiar pares clave-valor. * **No ordenado** (antes de Python 3.7), pero mantiene el orden de inserción en versiones posteriores. * **Claves únicas**: Las claves deben ser únicas, aunque los valores asociados pueden repetirse. 4. **Sets**: * **Mutable**: Puedes agregar o eliminar elementos. * **No ordenado**: No mantienen un orden de los elementos. * **Elementos únicos**: No permiten duplicados.
Funciones de set: * add(): Añade un elemento. * update(): Añade cualquier tipo de objeto iterable como: listas, tuplas. * discard(): Elimina un elemento y si ya existe no lanza ningún error. * remove(): Elimina un elemento y si este no existe lanza el error “keyError”. * pop(): Nos devuelve un elemento aleatorio y lo elimina y si el conjunto está vacío lanza el error “key error”. * clear(): Elimina todo el contenido del conjunto.
Por si a alguien le daba curiosidad, esta es la complejidad algorítmica de cada una de las operaciones: ```python Creación del conjunto (set): O(n) Obtener tamaño (len): O(1) Añadir un elemento (add): O(1) Actualizar con múltiples elementos (update): O(m) Eliminar un elemento (remove): O(1) Eliminar un elemento sin error (discard): O(1) Vaciar el conjunto (clear): O(1) ```
![]()![](https://static.platzi.com/media/user_upload/image-27da7f3b-0dcd-463e-8166-6a512f36d748.jpg)
# 💡 El simbolo `^` # Se puede hacer con `Shift + 6` si tienen el teclado en inglés. # De hecho, para **programar**, es más cómodo configurarlo en inglés. Todos los **símbolos están más a la mano**. # ![](https://static.platzi.com/media/user_upload/teclados-3830a8ae-9b36-4313-a902-81ed1683654a.jpg)
¿Es posible modificar un elemento existente dentro del conjunto sin tener que eliminar y agregar nuevamente? Ejemplo: quisiera que "ecua" fuera "ecu".
Funciones CRUD (Create, Read, Update, Delete) en conjuntos: * **add :** Agregar elemento al conjunto. * **update:** Actualizar o agregar elementos. * **Remove:** Elimina un elemento (si el elemento definido a eliminar no existe genera error). * **Discard:** Elimina el elemento (si el elemento no existe en el set no genera error). * **Clear:** elimina todo los datos del conjunto.
Una forma más sencilla de actualizar el set (aunque en realidad es crear uno nuevo 😄): `set_countries = {'col', 'mex', 'bol'}` `new_set_countries = {*set_countries, 'Arg'}` `print(new_set_countries)`
Una forma más sencilla de actualizar el set: `set_countries = {'col', 'mex', 'bol'}` `new_set_countries = {*set_countries, 'Arg'}` `print(new_set_countries)`
## Modificando conjuntos (CRUD) ### Create * `set( $param_1, $param_2...n )` : crear un conjunto y lo retorna ### read * `size()`: muestra el tamaño del conjunto * `in( $param )` : verifica si existe un elemento del conjunto ### update * `add( $param )`: Agregar un elemento al conjunto * `update({ $param_1, $param_2})`: Actualiza el conjunto con un subconjunto `{}` ### delete * `remove($param)`: Elimina un item `($param)` del conjunto, si no existe dará error a * `disacard($param)`: Elimina un item `($param)` del conjunto, si no existe no dará error a como lo haría `remove($param)` * `pop()`: el método pop se encarga de eliminar un elemento aleatorio del conjunto * `clear()`: vacía el conjunto repositorio ![](file:///home/me_angel/Im%C3%A1genes/clase-2-conjunto-comp.png)https://github.com/angel20125/python-2-comprehension-functions-2024 ![](https://static.platzi.com/media/user_upload/clase-2-conjunto-comp-e3395ebc-b699-489d-afcc-f56a5e6086a6.jpg)
¿Por qué me cambia el orden de los elementos en el set cada vez que ejecuto? por ejemplo 'pe' se mueve de lugar ![](https://static.platzi.com/media/user_upload/image-9aa70c34-7a08-4029-a83c-f02f0c37675e.jpg)
**Algunos de los errores más comunes que se pueden cometer al trabajar con conjuntos (set) en Python, junto con ejemplos:** **Intentar agregar un elemento mutable a un conjunto:** Como mencioné antes, los conjuntos sólo pueden contener elementos inmutables. Si intentas agregar un elemento mutable, como una lista o un diccionario, Python arrojará un error. mi\_conjunto = {1, 2, 3} mi\_conjunto.add(\[4, 5])  # Esto arrojará un error TypeError **Usar {} para crear un conjunto vacío:** Si intentas crear un conjunto vacío con {}, en realidad estarás creando un diccionario vacío. Para crear un conjunto vacío, debes usar set(). conjunto\_vacio = {}  # Esto crea un diccionario vacío, no un conjunto **Intentar acceder a los elementos de un conjunto por índice:** Los conjuntos en Python son colecciones no ordenadas, por lo que no puedes acceder a sus elementos por índice. Si intentas hacerlo, Python arrojará un error. mi\_conjunto = {1, 2, 3} primer\_elemento = mi\_conjunto\[0]  # Esto arrojará un error TypeError **Usar el método remove() para un elemento que no está en el conjunto:** El método remove() arrojará un error si intentas eliminar un elemento que no está en el conjunto. Si no estás seguro de si el elemento está en el conjunto, es mejor usar el método discard(), que no arroja un error en este caso. mi\_conjunto = {1, 2, 3} mi\_conjunto.remove(4)  # Esto arrojará un error KeyError
set\_countries = {"col", "mex", "bol"} size = len(set\_countries) print(size) print("col" in set\_countries) print("pe" in set\_countries) set\_countries.add("pe") print(set\_countries) set\_countries.update({"ar", "ecua", "pe"}) print(set\_countries) set\_countries.remove("col") print(set\_countries) set\_countries.remove("ar") set\_countries.discard("arg") print(set\_countries) set\_countries.add("arg") print(set\_countries) set\_countries.clear() print(set\_countries) print(len(set\_countries))
```python set_countries = {'col','mex','bol'} size = len(set_countries)#esta forma de saber cuantos hay en un conjuntos print(size) print('col' in set_countries)#esta es forma de saber si hay un elemento un conjuntos si hay el elemento = true print('pe' in set_countries)# isi hay el elemento sera = fale # add = sirve para agregar un elemnto al conjuntos set_countries.add('pe') print(set_countries) set_countries.add('pe') print(set_countries) # update = sirve para actualizar varios un conjuntos set_countries.update({'ar','ecua','pe'}) print(set_countries) # remove = sirve para eliminar un elemento del conjuntos #si eliminas un elemento que no existe en el conjuntos te da un error set_countries.remove('col')# debe eliminar un elemento especifico sino dara erro print(set_countries) set_countries.remove('ar') set_countries.discard('arg')# discard = Este método elimina el elemento especificado del conjunto si está presente. Si el elemento no está presente, no se produce ningún error y el conjunto permanece sin cambios. La sintaxis es print(set_countries) set_countries.add('arg') print(set_countries) set_countries.clear()#clear = este metodo elimina todos los elementos del conjunto print(set_countries) print(len(set_countries)) ```set\_countries = {'col','mex','bol'} size = len(set\_countries)#esta forma de saber cuantos hay en un conjuntos print(size) print('col' in set\_countries)#esta es forma de saber si hay un elemento un conjuntos si hay el elemento = true print('pe' in set\_countries)# isi hay el elemento sera = fale \# add = sirve para agregar un elemnto al conjuntos set\_countries.add('pe') print(set\_countries) set\_countries.add('pe') print(set\_countries) \# update = sirve para actualizar varios un conjuntos set\_countries.update({'ar','ecua','pe'}) print(set\_countries) \# remove = sirve para eliminar un elemento del conjuntos \#si eliminas un elemento que no existe en el conjuntos te da un error set\_countries.remove('col')# debe eliminar un elemento especifico sino dara erro print(set\_countries) set\_countries.remove('ar') set\_countries.discard('arg')# discard = Este método elimina el elemento especificado del conjunto si está presente. Si el elemento no está presente, no se produce ningún error y el conjunto permanece sin cambios. La sintaxis es print(set\_countries) set\_countries.add('arg') print(set\_countries) set\_countries.clear()#clear = este metodo elimina todos los elementos del conjunto print(set\_countries) print(len(set\_countries))
Tengo una duda...Porque los set no pueden tener como elementos listas o diccionarios? Sé que es porque son "unhashable type" pero no logro comprender en profundidad a que se refiere exactamente.
Hay alguna opción de eliminar más de un elemento al mismo tiempo? El método add() solo me deja eliminar uno por uno
# Crear un conjunto
conjunto = {1, 2, 3}

# Agregar un elemento
conjunto.add(4)
print(conjunto)  # Output: {1, 2, 3, 4}

# Agregar múltiples elementos
conjunto.update([5, 6])
print(conjunto)  # Output: {1, 2, 3, 4, 5, 6}

# Eliminar un elemento
conjunto.remove(1)
print(conjunto)  # Output: {2, 3, 4, 5, 6}

# Eliminar un elemento si está presente
conjunto.discard(2)
print(conjunto)  # Output: {3, 4, 5, 6}

# Eliminar y devolver un elemento aleatorio
elemento = conjunto.pop()
print(elemento)
print(conjunto)

# Eliminar todos los elementos
conjunto.clear()
print(conjunto)  # Output: set()
```py set\_countries = {'col', 'mex', 'bol'} size = len(set\_countries) print(size) print('col' in set\_countries) print('pe' in set\_countries) \# Add set\_countries.add('pe') print('pe' in set\_countries) set\_countries.add('pe') print(set\_countries) \# Update set\_countries.update({'ar', 'ecua', 'pe'}) print(set\_countries) \# Remove set\_countries.remove('col') print(set\_countries) try: \# If the element doesn't exists an error will be \# raised set\_countries.remove('col') except Exception as e: print('chale') print(set\_countries) \# If the element doesn't exists no error will be raised set\_countries.discard('col') print(set\_countries) \# Clear set\_countries.clear() print(set\_countries) print(type(set\_countries) == set) ```
```python set\_countries = {'col', 'mex', 'bol'} size = len(set\_countries) print(size) print('col' in set\_countries) print('pe' in set\_countries) \# Add set\_countries.add('pe') print('pe' in set\_countries) set\_countries.add('pe') print(set\_countries) \# Update set\_countries.update({'ar', 'ecua', 'pe'}) print(set\_countries) \# Remove set\_countries.remove('col') print(set\_countries) try: \# If the element doesn't exists an error will be \# raised set\_countries.remove('col') except Exception as e: print('chale') print(set\_countries) \# If the element doesn't exists no error will be raised set\_countries.discard('col') print(set\_countries) \# Clear set\_countries.clear() print(set\_countries) print(type(set\_countries) == set) ```

Diferencias entre remove() y discard():
En Python, tanto remove() como discard() son métodos utilizados en conjuntos (sets) para eliminar elementos, pero tienen una diferencia importante en su comportamiento cuando se intenta eliminar un elemento que no está presente en el conjunto.

Método remove(elemento):

  • El método remove() se utiliza para eliminar un elemento específico del conjunto.
  • Si el elemento no está presente en el conjunto, se genera un error KeyError. Por lo tanto, debes tener cuidado al usar remove() para asegurarte de que el elemento que estás intentando eliminar realmente exista en el conjunto.

Ejemplo:

my_set = {1, 2, 3, 4}
my_set.remove(3)
print(my_set)  # Output: {1, 2, 4}

# Intentar eliminar un elemento que no está presente genera un error
my_set.remove(5)  # KeyError: 5

Método discard(elemento):

  • El método discard() también se utiliza para eliminar un elemento específico del conjunto.
  • A diferencia de remove(), si el elemento no está presente en el conjunto, discard() no genera ningún error. Simplemente no hace nada.

Ejemplo:

my_set = {1, 2, 3, 4}
my_set.discard(3)
print(my_set)  # Output: {1, 2, 4}

# No hay error si el elemento no está presente
my_set.discard(5)
print(my_set)  # Output: {1, 2, 4}

En resumen, la principal diferencia entre remove() y discard() radica en cómo manejan la eliminación de elementos que no están presentes en el conjunto. remove() generará un error, mientras que discard() simplemente ignorará la operación sin generar ningún error. La elección entre ellos depende de si deseas que se genere un error al intentar eliminar un elemento que no está presente.

Diferencias entre update() y add():
En Python, tanto el método .add() como el método .update() se utilizan en conjuntos (sets) para agregar elementos, pero hay una diferencia importante en cómo manejan múltiples elementos.

Método .add(elemento):

El método .add() se utiliza para agregar un solo elemento al conjunto. Si intentas agregar un elemento que ya está presente en el conjunto, no se producirá ningún cambio en el conjunto, ya que los conjuntos no permiten elementos duplicados.

Ejemplo:

my_set = {1, 2, 3}
my_set.add(4)
my_set.add(2)  # No tiene efecto, ya que 2 ya está en el conjunto
print(my_set)  # Output: {1, 2, 3, 4}

Método .update(iterable):

El método .update() se utiliza para agregar múltiples elementos a un conjunto. Toma un iterable como argumento (por ejemplo, una lista, una tupla o incluso otro conjunto) y agrega cada elemento del iterable al conjunto. Si algún elemento del iterable ya está presente en el conjunto, ese elemento no se duplicará.

Ejemplo:

my_set = {1, 2, 3}
my_set.update([3, 4, 5, 6])
print(my_set)  # Output: {1, 2, 3, 4, 5, 6}

En este ejemplo, el conjunto original {1, 2, 3} se actualiza con los elementos de la lista [3, 4, 5, 6]. Aunque 3 ya estaba en el conjunto, no se duplica.

En resumen, la principal diferencia es que .add() agrega un solo elemento, mientras que .update() agrega múltiples elementos desde un iterable.

El tipo de datos set en Python es una colección desordenada y mutable de elementos únicos. Aquí están las funciones y métodos más comunes asociados con la estructura set():

Creación de un Conjunto

Puedes crear un conjunto utilizando llaves {} o la función set():

# Crear un conjunto vacío
conjunto_vacio = set()

# Crear un conjunto con elementos
conjunto = {1, 2, 3, 4, 5}

Funciones y Métodos de Conjuntos

  1. add(elemento)

    • Descripción: Agrega un elemento al conjunto.
    conjunto = {1, 2, 3}
    conjunto.add(4)
    # Resultado: {1, 2, 3, 4}
    
  2. update(iterable)

    • Descripción: Agrega todos los elementos de un iterable (lista, tupla, conjunto, etc.) al conjunto.
    conjunto = {1, 2, 3}
    conjunto.update([3, 4, 5])
    # Resultado: {1, 2, 3, 4, 5}
    
  3. remove(elemento)

    • Descripción: Elimina el elemento del conjunto. Genera un error si el elemento no está presente.
    conjunto = {1, 2, 3, 4, 5}
    conjunto.remove(3)
    # Resultado: {1, 2, 4, 5}
    
  4. discard(elemento)

    • Descripción: Elimina el elemento del conjunto. No genera error si el elemento no está presente.
    conjunto = {1, 2, 3, 4, 5}
    conjunto.discard(6)
    # Resultado: {1, 2, 3, 4, 5}
    
  5. pop()

    • Descripción: Elimina y devuelve un elemento aleatorio del conjunto.
    conjunto = {1, 2, 3, 4, 5}
    elemento = conjunto.pop()
    # Resultado: elemento contiene el valor eliminado
    
  6. clear()

    • Descripción: Elimina todos los elementos del conjunto.
    conjunto = {1, 2, 3, 4, 5}
    conjunto.clear()
    # Resultado: conjunto vacío {}
    
  7. Operaciones de Conjuntos:

    • Los conjuntos en Python admiten operaciones comunes de conjuntos como unión, intersección, diferencia y diferencia simétrica.
    A = {1, 2, 3}
    B = {3, 4, 5}
    
    union = A.union(B)  # También se puede usar A | B
    # Resultado: {1, 2, 3, 4, 5}
    
    interseccion = A.intersection(B)  # También se puede usar A & B
    # Resultado: {3}
    
    diferencia = A.difference(B)  # También se puede usar A - B
    # Resultado: {1, 2}
    
    diferencia_simetrica = A.symmetric_difference(B)  # También se puede usar A ^ B
    # Resultado: {1, 2, 4, 5}
    
  8. copy()

    • Descripción: Devuelve una copia superficial del conjunto.
    conjunto = {1, 2, 3}
    copia = conjunto.copy()
    # Resultado: copia es una copia de conjunto
    

Estas son algunas de las funciones y métodos más comunes asociados con los conjuntos en Python. Los conjuntos son útiles cuando necesitas almacenar elementos únicos y realizar operaciones de conjuntos eficientes.

En Python, los conjuntos son mutables, lo que significa que puedes agregar, eliminar y modificar elementos en un conjunto después de crearlo. Aquí te muestro cómo puedes modificar conjuntos en Python:

Agregar elementos a un conjunto:
Para agregar un elemento a un conjunto, puedes usar el método add() o el operador | (para realizar una unión con otro conjunto). Aquí tienes ejemplos de ambas formas:

conjunto = {1, 2, 3}

# Usando el método add()
conjunto.add(4)  # Agrega el elemento 4 al conjunto

# Usando el operador de unión
conjunto |= {5, 6}  # Agrega los elementos 5 y 6 al conjunto

Después de ejecutar estos pasos, el conjunto conjunto contendrá los elementos {1, 2, 3, 4, 5, 6}.

Eliminar elementos de un conjunto:
Para eliminar elementos de un conjunto, puedes utilizar los métodos remove(), discard() o pop(). Aquí tienes ejemplos de cada uno:

conjunto = {1, 2, 3, 4, 5}

conjunto.remove(3)  # Elimina el elemento 3, si no existe, genera un error.
conjunto.discard(4)  # Elimina el elemento 4, si existe, sin generar errores si no se encuentra.
elemento_eliminado = conjunto.pop()  # Elimina y devuelve un elemento arbitrario del conjunto.

Después de ejecutar estos pasos, el conjunto conjunto contendrá los elementos {1, 2, 5}.

Modificar elementos en un conjunto:
Los conjuntos en Python son colecciones de elementos únicos, por lo que no puedes modificar un elemento existente directamente en el conjunto. En lugar de eso, debes eliminar el elemento y luego agregar el nuevo elemento que deseas. Por ejemplo:

conjunto = {1, 2, 3}

# Modificar el elemento 2 por el 4
conjunto.remove(2)  # Elimina el elemento 2
conjunto.add(4)     # Agrega el elemento 4

# El conjunto ahora contiene {1, 3, 4}

Recuerda que los conjuntos son útiles para mantener colecciones de elementos únicos y no tienen un orden específico, por lo que no puedes modificar elementos en función de su posición en el conjunto.

Interesante la forma de usar crud en los sets. No imagine que esto fuera sencillo y nos permitiese entender las funcionalidades de este.

countries = {"colombia", "peru", "brazil"}
size = len(countries)
print(size)
print("peru" in countries)
# Para agregar un elemento a un conjunto
countries.add("bolivia")
print(countries)
# Para agregar dos o más elementos a un conjunto
countries.update({"argentina", "chile"})
print(countries)
# Para elimilar un elemento de un conjunto
countries.remove("peru")
print(countries)
# Para eliminar un elemento de un conjunto, pero si no esta este elemnto que no bote un  error
countries.discard("ecuador")
print(countries)
# Para eleminar el primer elemento de un conjunto
countries.pop()
print(countries)
countries.pop()
print(countries)
countries.pop()
print(countries)
# Para limpiar todo el conjunto
countries.clear()
print(countries)

Hola, me llamó mucho la atención la forma corta para saber el tamaño del conjunto:

Mis apuntes:

set_countries = {'col', 'mex', 'bol'}

# Para conocer el tamaño del set
size = len(set_countries)
print(size) # 3

# too we can buscar un element inside del set
print('col' in set_countries) # True
print('pe' in set_countries) # False

# add
set_countries.add('pe')
print(set_countries) # {'col', 'pe', 'mex', 'bol'}
# If I try de volver to add 'pe' no me dejara, pues no puede tener elements duplicates

# update
set_countries.update({'ar', 'ecu', 'pe'})
print(set_countries) # {'col', 'ecu', 'mex', 'ar', 'pe', 'bol'}, no add 'pe' again

#remove
set_countries.remove('col')
print(set_countries) #{'ar', 'pe', 'bol', 'mex', 'ecu'}

set_countries.remove('ar') # Si lo escribo mal 'arg', me dará error, use '.discard'
set_countries.discard('arg') # Con discard, si no lo encuentra, no lo elimina, como es el caso
print(set_countries) # {'mex', 'ecu', 'bol', 'pe'}
set_countries.add('arg')
print(set_countries) #{'bol', 'pe', 'ecu', 'mex', 'arg'}

set_countries.clear() # De esta forma eliminariamos TODO
print(set_countries) #set()
print(len(set_countries)) # Con 'len' buscamos la cantidad de elementos, que aqui es 0```

Modificando conjuntos

Los conjuntos en Python son mutables, lo que significa que puedes realizar modificaciones en un conjunto después de haberlo creado. Algunas de las operaciones de modificación más comunes que puedes realizar en conjuntos incluyen:

Operaciones de modificación

Agregar elementos

Puedes agregar un elemento a un conjunto utilizando el método add().

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

Después de ejecutar esto, mi_conjunto contendrá {1, 2, 3, 4}.

Eliminar elementos

Puedes eliminar un elemento específico de un conjunto utilizando el método remove() o discard(). La diferencia principal entre ellos es que remove() generará un error si el elemento no está presente en el conjunto, mientras que discard() no generará un error.

mi_conjunto = {1, 2, 3}
mi_conjunto.remove(2)

Después de ejecutar esto, mi_conjunto contendrá {1, 3}.

mi_conjunto.discard(4)

Esto no generará un error, ya que el elemento 4 no está presente en el conjunto.

Eliminar un elemento aleatorio

Puedes utilizar el método pop() para eliminar y devolver un elemento aleatorio del conjunto. Esto es útil cuando no necesitas especificar qué elemento se eliminará.

mi_conjunto = {1, 2, 3, 4, 5}
elemento_eliminado = mi_conjunto.pop()

elemento_eliminado contendrá el valor de un elemento eliminado al azar del conjunto.

Borrar el conjunto

Puedes eliminar todos los elementos de un conjunto y dejarlo vacío utilizando el método clear().

mi_conjunto = {1, 2, 3}
mi_conjunto.clear()

Después de ejecutar esto, mi_conjunto estará vacío.

Es importante recordar que estas operaciones modifican el conjunto original. Si deseas realizar operaciones de modificación sin afectar al conjunto original, debes crear una copia del conjunto antes de modificarlo. Por ejemplo:

conjunto_original = {1, 2, 3}
conjunto_modificado = conjunto_original.copy()
conjunto_modificado.add(4)

En este caso, conjunto_original no se verá afectado por la adición de 4 a conjunto_modificado.

Actualizar elementos de un conjunto

Puedes usar el método update() para agregar múltiples elementos a un conjunto a la vez. Esto puede hacerse proporcionando otro conjunto, una lista o cualquier otra iterable como argumento.

mi_conjunto = {1, 2, 3}
mi_conjunto.update([3, 4, 5])

Después de ejecutar esto, mi_conjunto contendrá {1, 2, 3, 4, 5}.

Seria bueno fuera haciendo recordatorios rápidos de cosas que menciona y ya se vieron. Por ejemplo si menciona lista, que es, como se crea y modifica o por lo menos tener un hipervínculo a un lado .

Conjunto de países

paises = {“España”, “Francia”, “Alemania”, “Italia”, “Portugal”}
print(“Conjunto:”, paises)

Convertir a lista

lista_paises = list(paises)
print(“Lista:”, lista_paises)

Convertir a tupla

tupla_paises = tuple(paises)
print(“Tupla:”, tupla_paises)

Convertir a diccionario (con valores ficticios de población)

diccionario_paises = {pais: “Población” for pais in paises}
print(“Diccionario:”, diccionario_paises)

# definir un conjunto 
set_countries = {'col', 'mex', 'bol'}

# tamaño del conjunto
size = len(set_countries)
print(size) # => 3

# preguntar si un elmento esta en el conjunto
print('col' in set_countries)    # => True
print('pe' in set_countries)     # => False

# añadir un elemento nuevo al conjunto
set_countries.add('pe')         
print(set_countries)             # => {'col', 'pe', 'mex', 'bol'}
set_countries.add('pe')          
print(set_countries)             # => {'col', 'pe', 'mex', 'bol'}

# actualizar el conjunto / añadir mas de 1 elemento
set_countries.update({'ar', 'ecua', 'pe'})
print(set_countries)             # => {'col', 'pe', 'mex', 'ar', 'ecua', 'bol'}

# eliminar un elemento del conjunto
set_countries.remove('col')
print(set_countries)             # => {'pe', 'mex', 'ar', 'ecua', 'bol'}
set_countries.remove('ar')
'''
set_countries.remove('arg') -> rompe el programa al no encontrar 
                               el elemento para eliminar
'''

# eliminar un elemento de manera segura (sin romper programa)
set_countries.discard('arg')
print(set_countries)             # => {'pe', 'mex', 'ecua', 'bol'}

# limpiar todo el conjunto
set_countries.clear()            
print(set_countries)             # => set()
print(len(set_countries))        # => 0

Dejo lo que escribí en esta clase:

set_countries = {'col', 'mex', 'bol'}

# Muy bonito los conjuntos, pero... Y si quiero medir el tamaño?
size = len(set_countries)
print(size)

# Bien, pero... y si quiero saber si un objeto está en el conjunto?
print('col' in set_countries)
print('pr' in set_countries)

# y si quiero adicionar un elemento al conjunto?
set_countries.add('pe')
print(set_countries) # {'col', 'pe', 'mex', 'bol'}

# Y si por error agrego 2 veces el mismo elemento?

set_countries.add('pe')
print(set_countries) # {'col', 'pe', 'mex', 'bol'}

# Y si quiero actualizar un conjunto?
set_countries.update({'arg', 'ecua', 'pe'})
print(set_countries)

# Y si quiero eliminar algo?

set_countries.remove('col')
print(set_countries)

set_countries.remove('arg')
print(set_countries)

# Y si quiero hacer eliminaciones sin el miedo ha que fallen?
#set_countries.discard('ven')

# Y si por cosas de la vida, decido limpiar todo el conjunto?
set_countries.clear()
print(set_countries)
print(len(set_countries))

# Ok esto si es impresionante

Notas de clase

set_countries = {'col', 'mex', 'bol'}

size = len(set_countries)
print('Tamaño del set:', size)
print('Está Colombia en el set? =>', 'col' in set_countries)

#add
set_countries.add('pe')
print(set_countries)

#Para ordenarlos alfabéticamente, se puede usar la función sorted()
print(sorted(set_countries))

#Actualizar un conjunto
set_countries.update({'ar', 'ecu'})
print(set_countries)

#Quitar algún elemento
set_countries.remove('bol')
print(set_countries)

#para quitar un elemento y no tener problemas por si no está
set_countries.discard('arg')
print(set_countries)

#Eliminar varios elementos a la vez
elements_to_remove = {'pe', 'mex'}
set_countries.difference_update(elements_to_remove)
print(set_countries)

elements_to_remove = {'ar', 'ecu'}
set_countries -= elements_to_remove
print(set_countries)

#Limpiar el conjunto
set_countries.clear()
print(set_countries)

Entonces, cuando se hace un update en un conjunto, agregándole otro conjunto, es como si hiciese un merge, evitando repetir los elementos de esta forma.

Interesante.

Modificando conjuntos

Podemos moficiador, agregar, remover.


# cantidad de elementos en un conjunto
set_countries = {'col', 'mex', 'bol'}
size = len(set_countries)
print(size)
3
# saber si un elemento esta en un conjunto
print('chil' in set_countries)
print('col' in set_countries)
False
True
# agregar elementos 
set_countries.add('pe')
print(set_countries)
{'mex', 'col', 'pe', 'bol'}
# no se repiten elementos, si agrego 'pe' no lo repetira
set_countries.add('pe')
print(set_countries)
{'mex', 'col', 'pe', 'bol'}
# update, actualizar conjunto
set_countries.update({'ar', 'ecua', 'pe'})
print(set_countries)
                    
{'pe', 'ecua', 'bol', 'mex', 'col', 'ar'}
# remove, eliminar elementos 
set_countries.remove('col')
print(set_countries)
{'pe', 'ecua', 'bol', 'mex', 'ar'}
# que pasa si elimino un elemento que no existe, dará error
# para eliminar pero que no falle si no existe en el conjunto discard
set_countries.discard('arg')
print(set_countries)
​
{'pe', 'ecua', 'bol', 'mex', 'ar'}
# limpiar todo el conjuntom nos arroja que tiene 0 elementos
set_countries.clear()
print(set_countries)
print(len(set_countries))
set()
0

excelente para saber escoger bien qué tipo de iterable aplica y así ser más optimo.

Muy buena clase, entendí muy bien las modificaciones que se puede hacer en un conjunto. Lo que me parece interesante, es que se puede añadir un subconjuntos completos.

Te puedes ahorras una línea de código evitando declarar la variable utilizando la función len dentro del print:

set_countries = {'col','mex','bol'}
print(len(set_countries))
set_countries = {'col', 'mex', 'bol', 'col'}

size = len(set_countries)
print(size)

print('col' in set_countries)
print('pe' in set_countries)

# add
set_countries.add('pe')
print(set_countries)
set_countries.add('pe')

# update
set_countries.update({'ar', 'ec', 'pe'})
print(set_countries)

# remove
set_countries.remove('col')
print(set_countries)

set_countries.remove('ar')
set_countries.discard('arg')
print(set_countries)
set_countries.add('arg')
print(set_countries)
set_countries.clear()
print(set_countries)
print(len(set_countries))

Se debe tener cuidado al usar “update” con diccionarios.
Cuando realizas update con una lista le adiciona los elementos, pero cuando lo haces con un diccionario adiciona las llaves.

set_countries = {'col', 'mex', 'bol'}
lista = [1, 2, 3, 1, 1, 1]
set_countries.update(lista)
print(set_countries)
# Agrega los elementos de la lista
# {1, 2, 'col', 3, 'mex', 'bol'}

diccionario = {'x': 1, 'y': 2, 'z': 'DAMIAN'}
set_countries.update(diccionario)
print(set_countries)
# Agrega las llaves del diccionario
# {1, 2, 'col', 3, 'x', 'mex', 'y', 'z', 'bol'}
'''
add(): Añade un elemento.

update(): Añade cualquier tipo de objeto iterable como: listas, tuplas.

discard(): Elimina un elemento y si ya existe no lanza ningún error.

remove(): Elimina un elemento y si este no existe lanza el error “keyError”.

pop(): Nos devuelve un elemento aleatorio y lo elimina y si el conjunto está vacío lanza el error “key error”.

clear(): Elimina todo el contenido del conjunto.
'''

set_countries = {'col', 'mex', 'bol'}

# para saber el tamaño del conunto
size = len(set_countries)
print("El tamaño del conjunto es: ", size)

# para revisar si existe un elemento dentro del conjunto
print ("Existe la palabra col en el conjunto? ", "col" in set_countries)
print ("Existe la palabra lol en el conjunto? ", "lol" in set_countries)

# para agregar un elemento al conjunto 
set_countries.add("pe")
print(set_countries)

# para agregar al conjunto 
set_countries.update({"arg", "ecu"})
print(set_countries)

# para eliminar del conjunto 
# forma 1 con .remove(), de esta manera si se ingresa un valor que no existe aparecerá un error
set_countries.remove("col")
set_countries.remove("arg")
print(set_countries)

# forma 2 con . dicard(), de esta manera si se ingresa un valor que no existe no aparecerá ningun error simplemente no hará nada
set_countries.discard("arg")

# para eliminar todos los elementos del conjunto usar .clear()
set_countries.clear()
print(set_countries)

Funciones de set:

  • add(): Añade un elemento.
  • update(): Añade cualquier tipo de objeto iterable como: listas, tuplas.
  • discard(): Elimina un elemento y si ya existe no lanza ningún error.
  • remove(): Elimina un elemento y si este no existe lanza el error “keyError”.
  • pop(): Nos devuelve un elemento aleatorio y lo elimina y si el conjunto está vacío lanza el error “key error”.
  • clear(): Elimina todo el contenido del conjunto.

UN EXTRA

  • sorted() ordena alfabéticamente los datos dentro de un conjunto.

Set CRUD (conjunto)

#saber el tamano de un conjunto
set_countries = {'col', 'mex', 'bol'}
size = len(set_countries)
print(size)

#buscar si elemento esta en un conjunto
print('col' in set_countries)
print('pe' in set_countries)

#add
set_countries.add('pe')
print(set_countries)

#update
set_countries.update({'arg', 'ecu', 'pe'})
print(set_countries)

#remove
set_countries.remove('col')
print(set_countries)

Modificando conjuntos:
Para modificar conjuntos en Python contamos con algunos métodos o funciones, veamos cuales son y que hacen:

Para saber los elementos de un conjunto usamos la función size().
Podemos preguntar si un elemento pertenece a un conjunto con la palabra reservada in.
Podemos agregar elemento a un conjunto con el método .add()
Para añadir elementos a un conjunto usamos .update()
Para eliminar un elemento usamos .remove(), pero si el elemento que pasamos no existe nos dará un error.
Para eliminar un elemento y si no existe no nos da error usamos .discard()
Para limpiar un conjunto usamos .clear()

set_countries = {'col', 'mex', 'bol'}

# Conocer el tamaño de un Set
print(len(set_countries))

# Saber si un elemento es parte de un Set
print('col' in set_countries)
print('pe' in set_countries)

# Agregar un elemento al conjunto
set_countries.add('pe')
print(set_countries)

# Aunque se agregue un elemento dos veces, solo aparecerá una vez
set_countries.add('pe')
print(set_countries)

# Actualizar un conjunto
set_countries.update({'ar', 'ecua', 'pe'})
print(set_countries)

# Remover elemntos de un Set
set_countries.remove('col')
print(set_countries)

set_countries.remove('ar')
print(set_countries)

# Si se intenta remover un elemento que no existe obtenemos un KeyError
# set_countries.remove('ar')
# print(set_countries)

# usar la función discard para no obtener ese error aunque el elemento no exista
set_countries.discard('ar')
print(set_countries)

# Eliminar todos los elementos de un Set
set_countries.clear()
print(set_countries)

Algunos métodos útiles en Python para trabajar con conjuntos son:

add(): Agrega un elemento al conjunto
remove(): Elimina un elemento del conjunto
union(): Devuelve la unión de dos conjuntos
intersection(): Devuelve la intersección de dos conjuntos
difference(): Devuelve la diferencia entre dos conjuntos
issubset(): Comprueba si un conjunto es subconjunto de otro
issuperset(): Comprueba si un conjunto es superconjunto de otro

El discard()método elimina el elemento especificado del conjunto.

Este método es diferente del remove()método, porque el remove() método generará un error si el elemento especificado no existe, y el discard()método no lo hará .

OjO. Si agregas estas líneas al inicio de tu código la pantalla se limpia cada vez que ejecutas

# Libreria para limpiar pantalla
import random
import os
os.system("cls")

Hola!! Aqui les dejo mi codigo espero ayude!

jumpline = '-' * 25
set_countries = {'col', 'mex', 'bol'}

# Con len() puedo saber la longitud de el set
size = len(set_countries)
print(size) # 3
print(jumpline)

# Verificar si un elemento esta dentro de este conjunto
print('col' in set_countries) # True
print('pe' in set_countries) # False
print(jumpline)

# Adicionar elementos al set con .add()
print(set_countries) # {'col', 'mex', 'bol'}
set_countries.add('pe')
print(set_countries) # {'col', 'pe', 'mex', 'bol'}

# Aunque le pida adicionar otro elemento si esta repetido no lo agrega
set_countries.add('pe')
print(set_countries) # {'col', 'pe', 'mex', 'bol'}
print(jumpline)

# .update() Para actualizar un conjunto usar {} 
print(set_countries) # {'col', 'pe', 'mex', 'bol'}
set_countries.update({'ar', 'ecua', 'pe'})
print(set_countries) # {'col', 'pe', 'mex', 'ar', 'ecua', 'bol'}
print(jumpline)

# Remover elementos tiene diferentes metodos
print(set_countries) # {'col', 'pe', 'mex', 'ar', 'ecua', 'bol'}
set_countries.remove('col')
print(set_countries) # {'pe', 'mex', 'ar', 'ecua', 'bol'}
set_countries.remove('ar')
print(set_countries) # {'pe', 'mex', 'ecua', 'bol'}
print(jumpline)

# Si no estamos seguros que un elemento esta para borrarlo .remove() dara error
#set_countries.remove('arg') # Syntax error
# Usamoos .discard() cuando no estamos seguros. Si el elemento no existe no saltara el error
set_countries.discard('arg') # No pasa nada
print(jumpline)

# Corrigo el error de argentina abreviado
print(set_countries) # {'pe', 'mex', 'ecua', 'bol'}
set_countries.add('arg')
print(set_countries) # {'pe', 'mex', 'arg', 'ecua', 'bol'}
print(jumpline)

# Puedo limpiar completamente un set con .clear()
print(set_countries) # {'pe', 'mex', 'arg', 'ecua', 'bol'}
set_countries.clear()
print(set_countries) # set()
print(len(set_countries)) # 0
print(jumpline)

Les dejo mi codigo con notas! Espero ayude

jumpline = '-' * 25
set_countries = {'col', 'mex', 'bol'}

# Con len() puedo saber la longitud de el set
size = len(set_countries)
print(size) # 3
print(jumpline)

# Verificar si un elemento esta dentro de este conjunto
print('col' in set_countries) # True
print('pe' in set_countries) # False
print(jumpline)

# Adicionar elementos al set con .add()
print(set_countries) # {'col', 'mex', 'bol'}
set_countries.add('pe')
print(set_countries) # {'col', 'pe', 'mex', 'bol'}

# Aunque le pida adicionar otro elemento si esta repetido no lo agrega
set_countries.add('pe')
print(set_countries) # {'col', 'pe', 'mex', 'bol'}
print(jumpline)

# .update() Para actualizar un conjunto usar {} 
print(set_countries) # {'col', 'pe', 'mex', 'bol'}
set_countries.update({'ar', 'ecua', 'pe'})
print(set_countries) # {'col', 'pe', 'mex', 'ar', 'ecua', 'bol'}
print(jumpline)

# Remover elementos tiene diferentes metodos
print(set_countries) # {'col', 'pe', 'mex', 'ar', 'ecua', 'bol'}
set_countries.remove('col')
print(set_countries) # {'pe', 'mex', 'ar', 'ecua', 'bol'}
set_countries.remove('ar')
print(set_countries) # {'pe', 'mex', 'ecua', 'bol'}
print(jumpline)

# Si no estamos seguros que un elemento esta para borrarlo .remove() dara error
#set_countries.remove('arg') # Syntax error
# Usamoos .discard() cuando no estamos seguros. Si el elemento no existe no saltara el error
set_countries.discard('arg') # No pasa nada
print(jumpline)

# Corrigo el error de argentina abreviado
print(set_countries) # {'pe', 'mex', 'ecua', 'bol'}
set_countries.add('arg')
print(set_countries) # {'pe', 'mex', 'arg', 'ecua', 'bol'}
print(jumpline)

# Puedo limpiar completamente un set con .clear()
print(set_countries) # {'pe', 'mex', 'arg', 'ecua', 'bol'}
set_countries.clear()
print(set_countries) # set()
print(len(set_countries)) # 0
print(jumpline)
set_countries = {'col', 'mex', 'bol'}

# size : para saber cual es el tamaño de ese conjunto
size = len(set_countries)
print(size)

# in : para saber si hay un elemeto dentro del conjuto
print('col' in set_countries)
print('pe' in set_countries)

# .add : agrega un elemeto pero no lo duplica
set_countries.add('pe')
print(set_countries)
set_countries.add('pe')
print(set_countries)

# .update : agrega al conjunto un subconjunto de elementos 
set_countries.update({'ar', 'ecua', 'pe'})
print(set_countries)

# .remove : elimina el valor que querramos que exista en el conjunto, genera erro al eliminar algo que no existe

set_countries.remove('col')
print(set_countries)

set_countries.remove('ar')
#.discard es para eliminar pero si no existe el elemeto para eliminar no genera ningun error
set_countries.discard('arg')
print(set_countries)
set_countries.add('arg')
print(set_countries)
#.clear elimina todo lo que existe dentro del conjunto
set_countries.clear()
print(set_countries)
print(len(set_countries))

¿Qué es el CRUD en Python?

Significa Crear, Leer, Actualizar y Eliminar. Se refiere a las cuatro operaciones básicas que se pueden realizar en un conjunto de datos. En el contexto de los Sets en Python, el CRUD se puede aplicar de la siguiente manera:

  1. Crear: Para crear un Set en Python, se puede utilizar la función set() o los corchetes {}.
  2. Leer: Para leer los elementos de un Set, se puede iterar sobre el conjunto o acceder a un elemento específico utilizando la sintaxis de índice.
  3. Actualizar: Para actualizar un elemento de un Set, se debe eliminar y volver a agregar el elemento con los nuevos valores. Sin embargo, es importante tener en cuenta que los Sets no permiten elementos duplicados, por lo que si se agrega un elemento que ya existe, no habrá cambios en el Set.
  4. Eliminar: Para eliminar un elemento de un Set, se puede utilizar el método remove() o el método discard(). El método remove() eliminará el elemento especificado y generará una excepción si el elemento no existe. Por otro lado, el método discard() eliminará el elemento especificado sin generar una excepción, incluso si el elemento no existe.
# Crear un Set
colores = set(["rojo", "verde", "azul"])
print("Set inicial:", colores)

# Leer los elementos del Set
for color in colores:
    print("Elemento:", color)

# Actualizar un elemento del Set
colores.remove("rojo")
colores.add("amarillo")
print("Set actualizado:", colores)

# Eliminar un elemento del Set
colores.discard("verde")
print("Set después de eliminar verde:", colores)

Algo como:

#Modificando conjuntos

#Ya dijimos que el set puede modificarse

set_paises={"col","mex","bol","bol"}

print(len(set_paises))
print("col" in set_paises)
print("per" in set_paises)

#Add o añadir
set_paises.add("pe")
print(set_paises)
set_paises.add("pe") #No admite duplicidad
print(set_paises)  

#Update / Añadir varios
set_paises.update({"arg","ecua","pe"})
print(set_paises) 

#Eliminacion
#Si el elemento no esta, colapsa
set_paises.remove("col")
print(set_paises)

#Si el elemento si esta, no colapsa
set_paises.discard("ar")
print(set_paises)

set_paises.clear()
print(set_paises)

'''
Funciones de set:

add(): Añade un elemento.
update(): Añade cualquier tipo de objeto iterable como: listas, tuplas.
discard(): Elimina un elemento y si ya existe no lanza ningún error.
remove(): Elimina un elemento y si este no existe lanza el error “keyError”.
pop(): Nos devuelve un elemento aleatorio y lo elimina y si el conjunto está vacío lanza el error “key error”.
clear(): Elimina todo el contenido del conjunto

'''

Excelente clase, conceptos muy claros!

Les comparto el código:

# Modificando conjuntos

set_countries = {"col", "mex", "bol"}

# Tamaño del conjunto
size = len(set_countries)
print(size)

# Preguntar por un elemento en especifico
print("col" in set_countries)
print("pe" in set_countries)

# Agregar un elemento al conjunto 
# add()
set_countries.add("pe")
print(set_countries)

# Aunque lo agregue varias veces, conserva su regla de no duplicados
set_countries.add("pe")
print(set_countries)

# Actualizar los elementos
# Es muy similar a agregar elementos
# update()
set_countries.update({"ar", "ec", "pe"})
print(set_countries)

# Elimir elementos
# remove()
set_countries.remove("col")
print(set_countries)

set_countries.remove("ar")
print(set_countries)

# Remover un elemento que no existe
# remove()
#set_countries.remove("arg")

# discard()
'''
Con este método, si el elemento existe lo elimina,
en caso contrario, no genera error por no encontrarlo
'''
set_countries.discard("arg")
print(set_countries)

# Agregamos argentina
set_countries.add("arg")
print(set_countries)

# Limpiar el conjunto, elimina todos los elementeos
# clear()
set_countries.clear()
print(set_countries)
set_primerset = {13.4, 'col', True, 'mex', 'bol'}

#Cantidad de elementos
size= len(set_primerset)

#Saber si hay un elemento dentro del conjunto
idk = 13.4 in set_primerset

#Agregar elementos
new = set_primerset.add('gaaa')

#Actualizar
set_primerset.update({1, 'uno', False})

#Remover, sino encuentra el elemento, lanza un error
set_primerset.remove(1)

#Remover, sino encuentra el elemento, no pasa nada
set_primerset.discard('argggg')

#Vacear el conjunto
#set_primerset.clear

Buena clase la de hoy, saludos

#cuantos elementos hay
cities = {'gye', 'uio', 'cue', 'mnt', 'gye'}
tam = len(cities)
print(tam)
#busqueda
print('col' in cities)
print('gye' in cities)
# adicionar elemento
cities.add('uio')
cities.add('gal')
print(cities)

# actualizar conjunto

cities.update({'esm', 'bab', 'loj'})
print(cities)

#remover, si no esta lanza error

cities.remove('bab')
print(cities)

#descartar, si no esta no lanza error

cities.discard('uio')
print(cities)

#dejar vacio el conjunto
cities.clear()
print(cities)
print(len(cities))

set_countries = {'col','mex','bol'}

size = len(set_countries)
print(size)

print ('col' in set_countries)
print('pe' in set_countries)

# add
set_countries.add('pe')
print(set_countries)
set_countries.add('pe')
print(set_countries)

# update
set_countries.update({'ar','ecua', 'pe'})
print(set_countries)

# remove
set_countries.remove('col')
print(set_countries)

set_countries.remove('ar')
set_countries.discard('arg')
print(set_countries)
set_countries.add('arg')
print(set_countries)
set_countries.clear()
print(set_countries)
print(len(set_countries))

Métodos sets


s.add(<elem>)
  • El método add() permite añadir un elemento al set.
l = set([1, 2])
l.add(3)
print(l) #{1, 2, 3}
s.remove(<elem>)
  • El método remove() elimina el elemento que se pasa como parámetro. Si no se encuentra, se lanza la excepción KeyError.
s = set([1, 2])
s.remove(2)
print(s) #{1}
s.discard(<elem>)
  • El método discard() es muy parecido al remove(), borra el elemento que se pasa como parámetro, y si no se encuentra no hace nada.
s = set([1, 2])
s.discard(3)
print(s) #{1, 2}
s.pop()
  • El método pop() elimina un elemento aleatorio del set.
s = set([1, 2])
s.pop()
print(s) #{2}
s.clear()
  • El método clear() elimina todos los elementos de set.
s = set([1, 2])
s.clear()
print(s) #set()
  • Otros

  • Los sets cuentan con una gran cantidad de métodos que permiten realizar operaciones con dos o más, como la unión o la intersección.

  • Podemos calcular la unión entre dos sets usando el método union(). Esta operación representa la “mezcla” de ambos sets. Nótese que el método puede ser llamado con más parámetros de entrada, y su resultado será la unión de todos los sets.


s1 = {1, 2, 3}
s2 = {3, 4, 5}
print(s1.union(s2)) #{1, 2, 3, 4, 5}
  • También podemos calcular la intersección entre dos o más set. Su resultado serán aquellos elementos que pertenecen a ambos sets.
s1 = {1, 2, 3}
s2 = {3, 4, 5}
print(s1.intersection(s2)) #{3}
  • Los set en Python tiene gran cantidad de métodos, por lo que lo dejaremos para otro capítulo, pero aquí os dejamos con un listado de ellos:

`

  1. ``
    s1.union(s2[, s3 …])
    s1.intersection(s2[, s3 …])
    s1.difference(s2[, s3 …])
    s1.symmetric_difference(s2)
    s1.isdisjoint(s2)
    s1.issubset(s2)
    s1.issuperset(s2)
    s1.update(s2[, s3 …])
    s1.intersection_update(s2[, s3 …])
    s1.difference_update(s2[, s3 …])
    s1.symmetric_difference_update(s2)

Modificando conjuntos

def run ():
    # Esta es otra forma de hacer un set
    # set_countries = {"col", "mex", "arg"}
    set_countries = set(["col", "mex", "arg"])
    print(set_countries)

    #---------------------------------------------------------------------------------------------------------------------------------------------#

    # El metodo len nos dice la longitud de nuestro set, o sea cuantos elementos tiene.
    size = len(set_countries)
    print(size)

    #---------------------------------------------------------------------------------------------------------------------------------------------#

    #Podemos preguntarle si un cierto elemento esta en nuestro conjunto con "in".
    print("col" in set_countries)
    print("niger" in set_countries)
    
    #---------------------------------------------------------------------------------------------------------------------------------------------#

    # Podemos agregar elemntos a nuestro set.
    set_countries.add("pe")
    print(set_countries)

    #---------------------------------------------------------------------------------------------------------------------------------------------#

    # Con el metodo "update" podemos actualizar nuestro set, y por mas veces que repitamos un elmento este no sera impreso de nuevo.
    set_countries.update({"bol", "ecua", "pe"})
    print(set_countries)

    #---------------------------------------------------------------------------------------------------------------------------------------------#

    # Con el metodo "remove" podemos borrar un elemento de un set.
    set_countries.remove("col")
    print(set_countries)

    #---------------------------------------------------------------------------------------------------------------------------------------------#

    # Con el elemento "discard" es silenciar un error, si queremos borrar un elemnto que no esta y para que no nos salte error usamos dicard
    set_countries.discard("per")

    #---------------------------------------------------------------------------------------------------------------------------------------------#

    # Con "clear" eliminamos todo nuestro conjunto 
    set_countries.clear()
    print(set_countries)
    print(len(set_countries))

if __name__ == "__main__":
    run()

<aside>
🎒 En la clase aprendimos a usar los métodos para modificar nuestro conjunto; vimos el método add, remove, clear, discard, len, in y update.

</aside>

set_countries = {'col' , 'mex' , 'bol'}

size = len(set_countries)
print(size)

print('col' in set_countries)
print('pe' in set_countries)

#add
set_countries.add('pe')
print(set_countries)
set_countries.add('pe') #no agrega repetidos
print(set_countries)

#Update
set_countries.update({'ar' , 'ecu', 'pe'})
print(set_countries)    

#remove
set_countries.remove('pe')
print(set_countries)

set_countries.remove('ar')
set_countries.discard('arg')
print(set_countries)
set_countries.add('arg')
print(set_countries)
set_countries.clear()
print(set_countries)
print(len(set_countries))

I love Python!!!

Gracias profesor por hacer las cosas fáciles y entendibles.
Con esto la mente comienza a buscar como las aplicaciones de los conjuntos como lo mencione en el video anterior voy a intentar realizar un programa al terminar el curso de un texto como base.

Hola!, les dejo mis apuntes. Buena clase:

#Tenemos el siguiente conjunto inicial:

set_countries = {"col", "mex", "bol"}

#Podemos saber cuántos elementos hay dentro de un conjunto:
size = len(set_countries)
print(size)


#Para confirmar que efectivamente tenemos los elementos "col" y "peru" en nuestro conjunto:
print("col" in set_countries)
print("peru" in set_countries)

#add. Agregar un país a nuestro conjunto
set_countries.add("pe")
print(set_countries)
set_countries.add("pe")
print(set_countries)

#update. Agregar un conjunto a nuestro conjunto principal
set_countries.update({"ar", "ecua","pe"})
print(set_countries)


#remove. Retirar uno de los países de nuestro conjunto
set_countries.remove ("col")
print(set_countries)

set_countries.remove("ar")
print(set_countries)

#remove. Eliminar elementos que no existen (Tendremos como resultado un error)
set_countries.remove("ar")
print(set_countries)

#Eliminar un elemento sin tener un fallo como resultado
set_countries.discard("arg")
print(set_countries)

set_countries.add("arg")
print(set_countries)

#Eliminar todo el conjunto
set_countries.clear()
print(set_countries)

#Contar cuántos elementos quedan en el conjunto = 0
print(len(set_countries))
Operaciones más comunes en Python: <https://j2logo.com/python/tutorial/tipo-set-python/>