Sets

Sets

• Se pueden modificar
• No tienen un orden
• No pueden tener elementos duplicados

# no tiene un par key-value, así me doy cuenta que es un set, un conjunto.
set_countries = {'col', 'mex', 'bol'}
print (set_countries)

# si yo pongo algo repetido, él me lo quita al imprimir
set_countries2 = {'col', 'mex', 'bol', 'col'}
print (set_countries2) # {'col', 'mex', 'bol'}

# puede ser mixto. El set se ordena solo, lo importante es lo que tengo dentro.
set_types = {1, 'hola', False, 12.12}
print(set_types) # {False, 1, 12.12, 'hola'}

# la podemos crear a partir de un string
set_from_string = set('hoola')
print (set_from_string) # {'a', 'l', 'o', 'h'}

# la podemos crear a partir de una tupla
set_from_tuples = set (('abc','cbv','as','abc'))
print (set_from_tuples) # {'as', 'abc', 'cbv'}

# la podemos crear a partir de una lista
numbers = [1,2,3,1,2,3,4]
set_numbers= set(numbers)
print (set_numbers) # {1, 2, 3, 4}
# si quiero convertir este set único a una lista, lo puedo hacer:
unique_numbers = list(set_numbers)
print (unique_numbers)

• 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 un conjunto de 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.
  Para entender mejor los sets, es necesario entender ciertos conceptos matemáticos como la teoría de conjuntos.

• Para crear un set en Python se puede hacer con set() y pasando como entrada cualquier tipo iterable, como puede ser una lista. Se puede ver como a pesar de pasar elementos duplicados como dos 8 y en un orden determinado, al imprimir el set no conserva ese orden y los duplicados se han eliminado.

s = set([5, 4, 6, 8, 8, 1])
print(s)       #{1, 4, 5, 6, 8}
print(type(s)) #<class 'set'>

• Se puede hacer lo mismo haciendo uso de {} y sin usar la palabra set() como se muestra a continuación.

s = {5, 4, 6, 8, 8, 1}
print(s)       #{1, 4, 5, 6, 8}
print(type(s)) #<class 'set'>

El video fue bastante fácil de seguir

False = 0
True = 1
"set" los toma como iguales, solo considera el primero de izquierda a derecha, los demas no los considera.

set_from_tupla= set(('abs',145, False,'TEST',0))
print(set_from_tupla)


set_from_list=set([2,2.5,True, 'Bye',1])
print(set_from_list)

Sets

Conjuntos, es una agrupación de elementos que tienen propiedades en común.

• Se puede modificar
• No tiene un orden específico
• No se permiten duplicados

Los sets (conjuntos) comparten la sintaxis con los diccionarios al momento de definirlos ya que usan curly braces {}, lo que los diferencia es que los sets no contienen la estructua de clave-valor.

para practicar ingles y la función SET en python:
https://www.youtube.com/watch?v=sBvaPopWOmQ

I LOVE PYTHON!!!

Para señalar los conjuntos se utilizan las {}, similar a los diccionarios, sin embargo no se utilizar la relación llave:valor.

Además los conjuntos también se pueden duplicar, no tienen un orden y no pueden tener duplicados.

Viendo detalles de Python como el tema de quedarse automáticamente con los valores únicos solo por convertir un dato a Conjunto (o Set) nos damos cuenta de la potencia, elegancia y sencillez del lenguaje.
¿Cómo no amar a Python? 💚

Me pasa que en el ambiente replit solo corre con el programa main, si agrego un segundo archivo, no me lo permite ejecutar me genera error, porque siempre me pide y corre solo el archivo “main” con ext py

Alguien me puede ayudar pf?

Tabla de diferencias entre lista, conjunto y tupla:
Lista:

Las listas son mutables.
Es la recogida ordenada de artículos.
Los elementos de la lista se pueden reemplazar o cambiar.

Conjunto:

El conjunto es mutable
Es una colección desordenada de artículos.
Los elementos del conjunto no se pueden cambiar ni reemplazar.

Tupla:

Tupla es inmutable
Es la recogida ordenada de artículos.
Los elementos de la tupla no se pueden cambiar ni reemplazar.

texto extraído de:https://barcelonageeks.com/diferencia-entre-list-vs-set-vs-tuple-en-python/

Realmente util y pedagogico!

Similitudes y diferencias.
Lista: es una colección ordenada y modificable. Permite miembros duplicados.
Tuple: es una colección ordenada e inmutable. Permite miembros duplicados.
Conjunto: es una colección desordenada, inmutable* y no indexada. No hay miembros duplicados.
Diccionario: es una colección ordenada** y modificable. No hay miembros duplicados.

Comparto algo que me sucedio en los ejercicios cuando lo modifique y no me imprimia el TRUE, puede suceder dos cosas.

True y False son valores booleanos, y en un conjunto, solo se permite un valor único, Python considera que True y False son equivalentes y solo mantiene uno de ellos en el conjunto.
El número 1 en conjntos de python lo ve equivalente a TRUE

set_from_literals = {1, 2, 3, 4, True, False, 'hola'}
print(set_from_literals)

response

{False, 1, 2, 3, 4, 'hola'}

Esta es una pregunta que me han realizado en bastantes entrevistas donde se prioriza que conozcas los conjuntos y reconozcas sus propiedades comparandolos con los otros tipos de array, con el fin de grabarmelo más facil tuve que entender que todos los tipos de arreglos en python tienen los siguientes atributos.

• Organizados
• Mutables
• Valores repetidos
  luego los organizo en la siguiente tabla que les será de utilidad en un futuro.

Listas: Son colecciones ordenadas y mutables de elementos en Python. Permiten almacenar valores repetidos.

Tuplas: También son colecciones ordenadas, pero a diferencia de las listas, son inmutables, lo que significa que no se pueden modificar después de su creación. Las tuplas también permiten valores repetidos.

Conjuntos: No mantienen un orden específico y no permiten elementos repetidos. Son mutables, lo que significa que se pueden agregar o eliminar elementos después de su creación.

Diccionarios: No están ordenados y permiten almacenar pares clave-valor. Son mutables y permiten valores repetidos para las claves, aunque las claves en sí deben ser únicas.

Arrays de NumPy: Son colecciones ordenadas y mutables de elementos, pero a diferencia de las listas, los arrays de NumPy están optimizados para cálculos numéricos y pueden almacenar elementos del mismo tipo de datos de manera más eficiente. También permiten valores repetidos.

Comparto un bloc de notas con todos mis apuntes de la ruta de aprendizaje de Análisis de Datos con Python

Para ahorrarnos 2 líneas de código, podemos hacer las funciones list y set en una misma lineal, primero ejecutando el set para que nos organice el set y después, convirtiéndolo a lista así:

number= [1,2,3,1,2,3,4]
print(list(set(number)))

Gracias

Un set en Python es una estructura de datos que representa una colección desordenada de elementos únicos. Esto significa que no puede haber elementos duplicados dentro de un set. Los set son muy útiles cuando necesitas almacenar elementos únicos y no te importa el orden en que se encuentran.

Para crear un set, puedes encerrar una serie de elementos entre llaves {}, o usar el constructor de la clase set() y pasarle como argumento un objeto iterable (como una lista, una tupla, una cadena, etc.).

# Crea un conjunto con una serie de elementos entre llaves
# Los elementos repetidos se eliminan
>>> c = {1, 3, 2, 9, 3, 1}
>>> c
{1, 2, 3, 9}

# Crea un conjunto a partir de un string
# Los caracteres repetidos se eliminan
>>> a = set('Hola Pythonista')
>>> a
{'a', 'H', 'h', 'y', 'n', 's', 'P', 't', ' ', 'i', 'l', 'o'}

# Crea un conjunto a partir de una lista
# Los elementos repetidos de la lista se eliminan
>>> unicos = set( [3, 5, 6, 1, 5])
>>> unicos
{1, 3, 5, 6}

Cuales son las diferencias entre set, listas y tuplas?
.
Las listas, tuplas y conjuntos (sets) son tipos de datos en Python que se utilizan para almacenar colecciones de elementos, pero tienen algunas diferencias clave en términos de mutabilidad, orden y duplicados. Aquí hay una comparación detallada:

Listas:

1. Mutabilidad:

   • Las listas son mutables, lo que significa que puedes cambiar, agregar o quitar elementos después de haber creado la lista.

   my_list = [1, 2, 3]
   my_list[0] = 0  # Modificar un elemento
   my_list.append(4)  # Agregar un elemento
   

2. Orden:

   • Las listas mantienen el orden de los elementos. El orden en que agregas elementos es el mismo en el que se mantienen en la lista.

   my_list = [3, 1, 4, 1, 5, 9]
   print(my_list)  # Output: [3, 1, 4, 1, 5, 9]
   

3. Duplicados:

   • Las listas permiten elementos duplicados. Puedes tener el mismo valor en la lista más de una vez.

   my_list = [1, 2, 2, 3, 4, 4]
   

Tuplas:

1. Inmutabilidad:

   • Las tuplas son inmutables, lo que significa que no puedes modificar, agregar ni quitar elementos después de haber creado la tupla.

   my_tuple = (1, 2, 3)
   # Intentar modificar la tupla generará un error
   

2. Orden:

   • Las tuplas mantienen el orden de los elementos, similar a las listas.

   my_tuple = (3, 1, 4, 1, 5, 9)
   print(my_tuple)  # Output: (3, 1, 4, 1, 5, 9)
   

3. Duplicados:

   • Al igual que las listas, las tuplas permiten elementos duplicados.

   my_tuple = (1, 2, 2, 3, 4, 4)
   

Conjuntos (Sets):

1. Mutabilidad:

   • Los conjuntos son mutables, pero los elementos individuales deben ser inmutables y hashables. Puedes agregar y quitar elementos, pero no puedes modificar un elemento existente.

   my_set = {1, 2, 3}
   my_set.add(4)  # Agregar un elemento
   my_set.remove(2)  # Quitar un elemento
   

2. Orden:

   • Los conjuntos no mantienen un orden específico de los elementos. No puedes asumir un orden particular al iterar sobre un conjunto.

   my_set = {3, 1, 4, 1, 5, 9}
   print(my_set)  # Output: El orden puede variar
   

3. Duplicados:

   • Los conjuntos no permiten elementos duplicados. Si intentas agregar un elemento que ya está presente, no se producirá ningún cambio en el conjunto.

   my_set = {1, 2, 2, 3, 4, 4}  # Se convierte automáticamente a {1, 2, 3, 4}
   

En resumen, la elección entre listas, tuplas y conjuntos dependerá de los requisitos específicos de tu programa. Si necesitas una colección ordenada y mutable con duplicados, utiliza listas. Si buscas inmutabilidad, pero manteniendo el orden, utiliza tuplas. Para conjuntos sin duplicados y sin importar el orden, utiliza conjuntos.

Cuales son los beneficios de los sets o conjuntos?
En Python, un conjunto (set) es una estructura de datos que representa una colección no ordenada y sin elementos duplicados. Los conjuntos son una parte integral del lenguaje y proporcionan varios beneficios en términos de rendimiento y funcionalidad:

1. Eliminación de duplicados:

• Los conjuntos no permiten elementos duplicados. Al agregar elementos a un conjunto, automáticamente se eliminan duplicados, lo que facilita la gestión de colecciones únicas.

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

2. Verificación de pertenencia (Membership testing):

• Los conjuntos proporcionan una verificación de pertenencia extremadamente eficiente. La operación in para conjuntos tiene complejidad O(1), lo que significa que la búsqueda es casi instantánea incluso para conjuntos grandes.

my_set = {1, 2, 3, 4, 5}
print(3 in my_set)  # Output: True

3. Operaciones de conjuntos:

• Los conjuntos admiten operaciones matemáticas de conjuntos estándar, como unión, intersección, diferencia y diferencia simétrica. Estas operaciones son útiles en situaciones donde se deben comparar o combinar conjuntos de elementos.

set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}

union_set = set1 | set2         # Unión
intersection_set = set1 & set2  # Intersección
difference_set = set1 - set2    # Diferencia
symmetric_difference_set = set1 ^ set2  # Diferencia simétrica

4. Iteración eficiente:

• Los conjuntos son iterables, lo que significa que puedes recorrer sus elementos de manera eficiente utilizando bucles for. La iteración se realiza en un orden no específico, ya que los conjuntos no tienen un orden definido.

my_set = {1, 2, 3, 4, 5}
for element in my_set:
    print(element)

5. Eficiencia en búsquedas:

• La búsqueda de elementos en conjuntos se realiza en tiempo constante (O(1)), lo que significa que la velocidad de búsqueda no depende del tamaño del conjunto. Esto los hace eficientes para verificar la presencia de elementos en grandes conjuntos de datos.

6. Mutabilidad y hashability:

• Los conjuntos son mutables (puedes agregar y quitar elementos), pero los elementos individuales deben ser inmutables y hashables. Esto significa que los conjuntos pueden contener números, cadenas y tuplas, pero no listas o conjuntos.

7. Implementación eficiente:

• Internamente, los conjuntos en Python están implementados como tablas hash, lo que garantiza un acceso rápido y eficiente a los elementos.

8. Uso en algoritmos específicos:

• Los conjuntos son útiles en algoritmos donde se necesita realizar comprobaciones rápidas de pertenencia, eliminación de duplicados o manipulación de conjuntos de datos únicos.

En resumen, los conjuntos en Python ofrecen una forma eficiente y conveniente de trabajar con colecciones únicas de elementos, proporcionando beneficios en términos de rendimiento y funcionalidad en diversas aplicaciones.

Estructuras de datos

1. Listas:

• Descripción:

  • Una lista es una estructura de datos mutable y ordenada que puede contener elementos de diferentes tipos.

• Creación:

  lista = [1, 2, 3, "cuatro", 5.0]
  
  

• Características clave:

  • Soporta duplicados.
  • Puede ser modificada (agregar, modificar, eliminar elementos).
  • Acceso a elementos mediante índices.

• Métodos importantes:

  • append(): Agrega un elemento al final de la lista.
  • remove(): Elimina un elemento específico.
  • pop(): Elimina y devuelve el elemento en una posición dada.
  • extend(): Extiende la lista con elementos de otra lista.
  • index(): Devuelve el índice del primer elemento coincidente.

2. Tuplas:

• Descripción:

  • Una tupla es una estructura de datos inmutable y ordenada que puede contener elementos de diferentes tipos.

• Creación:

  tupla = (1, 2, 3, "cuatro", 5.0)
  
  

• Características clave:

  • Inmutable (no se pueden modificar después de la creación).
  • Puede contener elementos de diferentes tipos.
  • Acceso a elementos mediante índices.

• Operaciones:

  • Acceso a elementos mediante índices.
  • Desempaquetado de tuplas.

3. Diccionarios:

• Descripción:

  • Un diccionario es una estructura de datos mutable y no ordenada que almacena pares clave-valor.

• Creación:

  diccionario = {"clave1": "valor1", "clave2": 2, 3: "valor3"}
  
  

• Características clave:

  • Acceso a valores a través de claves.
  • Las claves son únicas.
  • Puede contener elementos de diferentes tipos.
  • Mutable.

• Operaciones:

  • Acceso a valores mediante claves.
  • Adición y eliminación de pares clave-valor.
  • Métodos como keys(), values(), items().

4. Conjuntos:

• Descripción:

  • Un conjunto es una estructura de datos mutable o inmutable que almacena elementos únicos y no tiene orden.

• Creación:

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

• Características clave:

  • No contiene elementos duplicados.
  • No tiene orden.
  • Soporta operaciones de conjuntos como unión, intersección, etc.

• Operaciones:

  • add(): Agrega un elemento al conjunto.
  • remove(): Elimina un elemento específico.
  • Operaciones de conjuntos como unión, intersección, diferencia, etc.

5. Cadenas de Caracteres (Strings):

• Descripción:

  • Una cadena es una secuencia de caracteres inmutable.

• Creación:

  cadena = "Hola, mundo!"
  
  

• Características clave:

  • Inmutable.
  • Acceso a caracteres mediante índices.
  • Soporta operaciones de cadena como concatenación, slicing, etc.

Sets en python
Un conjunto (set) en Python es una colección desordenada de elementos únicos e inmutables. Se utilizan cuando el orden de los elementos no es importante, pero la unicidad sí lo es. Los conjuntos son implementados como una tabla hash, lo que permite búsquedas y operaciones de conjunto de manera eficiente.

Creación de un conjunto:

Puedes crear un conjunto vacío usando la función set() o especificando elementos dentro de llaves {}.

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

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

Características clave:

1. Unicidad: Los conjuntos no permiten elementos duplicados. Si intentas agregar un elemento que ya está presente, no se realizará ninguna acción.

   conjunto = {1, 2, 3, 4, 5, 1, 2}
   print(conjunto)
   # Salida: {1, 2, 3, 4, 5}
   

2. Inmutabilidad: Los elementos de un conjunto deben ser inmutables, lo que significa que no puedes tener conjuntos dentro de conjuntos ni listas, pero puedes tener tuplas.

   conjunto = {(1, 2), 3, 4}
   

Operaciones comunes con conjuntos:

1. Añadir elementos:

   • Utiliza el método add() para agregar un solo elemento.

     conjunto = {1, 2, 3}
     conjunto.add(4)
     print(conjunto)
     # Salida: {1, 2, 3, 4}
     

   • Utiliza el método update() para agregar múltiples elementos.

     conjunto = {1, 2, 3}
     conjunto.update([3, 4, 5])
     print(conjunto)
     # Salida: {1, 2, 3, 4, 5}
     

2. Eliminar elementos:

   • Utiliza el método remove() para eliminar un elemento. Genera un error si el elemento no está presente.

     conjunto = {1, 2, 3, 4, 5}
     conjunto.remove(3)
     print(conjunto)
     # Salida: {1, 2, 4, 5}
     

   • Utiliza el método discard() para eliminar un elemento sin generar un error si el elemento no está presente.

     conjunto = {1, 2, 3, 4, 5}
     conjunto.discard(6)
     print(conjunto)
     # Salida: {1, 2, 3, 4, 5}
     

3. Operaciones de conjuntos:

   • Unión (union o |)

     A = {1, 2, 3}
     B = {3, 4, 5}
     unión = A.union(B)
     # O también puedes usar el operador |: unión = A | B
     print(unión)
     # Salida: {1, 2, 3, 4, 5}
     

   • Intersección (intersection o &)

     A = {1, 2, 3}
     B = {3, 4, 5}
     intersección = A.intersection(B)
     # O también puedes usar el operador &: intersección = A & B
     print(intersección)
     # Salida: {3}
     

   • Diferencia (difference o -)

     A = {1, 2, 3}
     B = {3, 4, 5}
     diferencia = A.difference(B)
     # O también puedes usar el operador -: diferencia = A - B
     print(diferencia)
     # Salida: {1, 2}
     

   • Diferencia simétrica (symmetric_difference o ^)

     A = {1, 2, 3}
     B = {3, 4, 5}
     diferencia_simétrica = A.symmetric_difference(B)
     # O también puedes usar el operador ^: diferencia_simétrica = A ^ B
     print(diferencia_simétrica)
     # Salida: {1, 2, 4, 5}
     

4. Otros métodos:

   • clear(): Elimina todos los elementos del conjunto.
   • copy(): Devuelve una copia superficial del conjunto.
   • pop(): Elimina y devuelve un elemento aleatorio del conjunto.

Uso de conjuntos en Python:

Los conjuntos son útiles en situaciones donde la unicidad de elementos es esencial, como eliminar duplicados de una lista, verificar membresía rápidamente, o realizar operaciones de conjuntos. Por ejemplo, al comparar listas para encontrar elementos únicos o comunes.

lista1 = [1, 2, 3, 4, 5, 5, 2]
lista2 = [3, 4, 5, 6, 7]

conjunto1 = set(lista1)
conjunto2 = set(lista2)

elementos_comunes = conjunto1.intersection(conjunto2)
print(elementos_comunes)
# Salida: {3, 4, 5}

Es importante recordar que los conjuntos no mantienen el orden de los elementos, por lo que si el orden es importante, debes considerar otras estructuras de datos como las listas o las tuplas.

Sí quieren enteder esto mucho más fácil por favor vean esta clase: (Y sí pueden vean el curso)
https://platzi.com/clases/2884-notacion-matematica/47333-conjuntos/

Les dejo este link si quieren tener mas claras las diferencias entre sets, diccionarios, listas y tuplas.
https://makeitrealcamp.gitbook.io/guias-de-make-it-real/python/diccionarios-tuplas-y-sets

Me gusto esta clase con respecto a los set. Estos nos ayudaran a mejorar nuestra habilidad de programadores.

En Python, un conjunto (set en inglés) es una estructura de datos que representa una colección de elementos únicos y desordenados. Los conjuntos son muy útiles cuando necesitas almacenar elementos sin duplicados y no te importa el orden en el que se almacenan los elementos. Aquí tienes algunas características clave de los conjuntos en Python:

1. Elementos Únicos: Los conjuntos no permiten elementos duplicados. Si intentas agregar un elemento que ya está en el conjunto, no se añadirá nuevamente.

2. Desordenados: Los elementos en un conjunto no tienen un orden específico. No puedes acceder a ellos por su posición, ya que no están indexados.

3. Mutabilidad: Los conjuntos son mutables, lo que significa que puedes agregar y eliminar elementos de un conjunto después de crearlo. Sin embargo, los elementos mismos deben ser inmutables (por ejemplo, números, cadenas o tuplas).

4. Sintaxis de Conjunto: Para crear un conjunto en Python, puedes usar llaves {} o la función set(). Aquí tienes ejemplos:

   pythonCopy code
   # Crear un conjunto usando llaves
   mi_set = {1, 2, 3}
   
   # Crear un conjunto usando la función set()
   otro_set = set([4, 5, 6])
   
   

5. Operaciones de Conjunto: Los conjuntos en Python admiten operaciones típicas de conjuntos como unión, intersección, diferencia y comprobación de pertenencia. Por ejemplo:

   pythonCopy code
   conjunto1 = {1, 2, 3}
   conjunto2 = {3, 4, 5}
   
   # Unión de conjuntos
   union = conjunto1 | conjunto2  # También puedes usar conjunto1.union(conjunto2)
   
   # Intersección de conjuntos
   interseccion = conjunto1 & conjunto2  # También puedes usar conjunto1.intersection(conjunto2)
   
   # Diferencia entre conjuntos
   diferencia = conjunto1 - conjunto2  # También puedes usar conjunto1.difference(conjunto2)
   
   # Comprobación de pertenencia
   pertenece = 1 in conjunto1
   
   

Los conjuntos son útiles cuando necesitas realizar operaciones matemáticas de conjuntos o cuando debes mantener una colección de elementos únicos. Por ejemplo, se pueden usar para eliminar duplicados de una lista, verificar la existencia de elementos únicos o realizar operaciones de búsqueda rápida.

Set

En Python, un conjunto (set en inglés) es una colección no ordenada de elementos únicos e inmutables. Los conjuntos se utilizan para almacenar elementos sin duplicados, lo que los hace muy útiles para eliminar duplicados de una lista o verificar la membresía de un elemento en tiempo constante. Aquí hay algunas características clave de los conjuntos en Python:

1. Elementos Únicos: Los elementos en un conjunto son únicos, lo que significa que no puede haber duplicados en un conjunto. Si intentas agregar un elemento que ya está presente, no se agregaría nuevamente.

2. No Ordenados: A diferencia de las listas, los conjuntos no tienen un orden específico. Los elementos no se almacenan en una secuencia particular, por lo que no puedes acceder a ellos por su índice.

3. Inmutables: Los conjuntos en sí son mutables, lo que significa que puedes agregar y eliminar elementos, pero los elementos individuales dentro de un conjunto deben ser inmutables. Por ejemplo, puedes tener números, cadenas o tuplas en un conjunto, pero no puedes tener listas o otros conjuntos.

4. Sintaxis: Para crear un conjunto en Python, puedes utilizar llaves {} o la función set(). Por ejemplo:

mi_conjunto = {1, 2, 3}
otro_conjunto = set([3, 4, 5])

1. Operaciones: Los conjuntos admiten operaciones comunes de conjuntos, como unión, intersección, diferencia y comprobación de membresía. Puedes realizar estas operaciones utilizando métodos incorporados o operadores, como union(), intersection(), difference(), issubset(), issuperset(), entre otros.

Ejemplo de operaciones de conjunto:

conjunto1 = {1, 2, 3}
conjunto2 = {3, 4, 5}

union = conjunto1.union(conjunto2)  # Union de conjuntos
interseccion = conjunto1.intersection(conjunto2)  # Intersección de conjuntos
diferencia = conjunto1.difference(conjunto2)  # Diferencia entre conjuntos

Los conjuntos son útiles en situaciones en las que necesitas mantener una colección de elementos únicos y no necesitas preocuparte por el orden.

Les comparto los métodos más usados de sets:
(https://github.com/JuanCode29/fundamentosPython2/blob/main/sets.py)

#Conjunto de paises latinos """ Para declarar los conjuntos se usan las {} igual que en el diccionario, pero aquí solo se agregan los elementos y no las llaves : """ set_countries = {'col', 'mex', 'bol'} print(set_countries) print(type(set_countries)) print("="*50 + "Ejemplo1") """ En un conjunto no deben existir elementos/ valores iguales. Si se colocan valores duplicados, automaticamente python los elimina """ set_numbers = {1, 2, 2, 443, 23, 1, 23} print(set_numbers) print("="*50 + "Ejemplo2") """Al igual qu

<#Conjunto de paises latinos
"""
Para declarar los conjuntos se usan las {}
igual que en el diccionario, pero aquí solo
se agregan los elementos  y no las llaves :
""" 
set_countries = {'col', 'mex', 'bol'} 
print(set_countries)
print(type(set_countries))
print("="*50 + "Ejemplo1")
"""
En un conjunto no deben existir elementos/ valores 
iguales. Si se colocan valores duplicados, automaticamente
python los elimina
"""
set_numbers = {1, 2, 2, 443, 23, 1, 23}
print(set_numbers)
print("="*50 + "Ejemplo2")
"""Al igual que en las listas, se pueden tener varios tipos de datos """
set_types = {1, 'hola', False, 12.12}
print(set_types)
print("="*50 + "Ejemplo3")
"""
Crea un conjunto de caracteres apartir de un string
"""
set_from_string = set('hoola')
print(set_from_string)
print("="*50+ "Ejemplo4")
"""
Crear un conjunto a partir de una tupla ()
"""
set_from_tuples = set(('abc', 'cbv', 'as', 'abc', 'bdf'))
print(set_from_tuples)
print("="*50 + "Ejemplo5") 
"""
De una lista de numeros se puede transformar a 
un conjunto sin valores repetidos
"""
numbers = [1,2,3,1,2,3,4]
print(numbers)
print(type(numbers))
set_numbers = set(numbers) #Convertir de list a set
print(set_numbers)
print(type(set_numbers))
unique_numbers = list(set_numbers)#Conversion de set a list
print(unique_numbers)
print(type(unique_numbers))> 

Sets

🖊️ Es un tipo de definición para definir conjuntos

Recordar que en un conjunto no se tienen elementos duplicados

Ejemplo

set_countries = {'col', 'per', 'par', 'mex', 'col'}
set_numbers = {4, 1, 2, 4, 12, 35, 19, 20}

print( set_countries )
print( set_numbers )

Los elementos repetidos solo se muestran una sola vez, esto es ideal si queremos datos sin repetición

set

Obtener un conjunto a partir de una función (set)

Ejemplo

# A partir de un texto
set_hola = set('hoola')
print(set_hola)
# A partir de una tupla
set_tuple = set( ('arg', 'per', 'col', 'mex') )
print(set_tuple)
# A partir de un lista
numbers = [2, 5, 19, 10, 15, 5, 5, 2]
set_list = set(numbers)
print(set_list)
#Convertir el set de número a una lista
numbers_no_repeat = list(set_list)

Resumen

🖊️ set es un tipo de dato que permite la creación de conjuntos, cuya característica consiste en no permitir elementos repetidos, lo que nos permite eliminar los número duplicados o elementos duplicados de un conjunto de datos.

Además este proceso es más sencillo debido a la función set(type_data_structure_or_list) que permite la conversión de un list, diccionario, tupla de datos a un set.

Como en el anterior curso, voy a dejar mis aportes con comentarios explicando cada cosa (a veces con un poco de humor 😏) les dejo mi código:

# Presentado los conjuntos (que vienen de la teoría del mismo nombre, ya sabes, esa de los diagramas de Venn)

#Un conjunto:
'''
1. Se puede modificar
2. No tiene orden
3. No pueden tener elementos duplicados
4. Se puede confudir con los diccionarios pero...
5. No tiene par clave y valor
6. Puede tener lo que sea...
'''

set_countries = {'col', 'mex', 'bol'} # strings
print(set_countries)
print(type(set_countries))

set_numbers = {1, 2, 3, 443, 23} # numeros
print(set_numbers)

set_types = {1, 'hola', False, 12.12} # O lo que sea!
print(set_types) # Aqui cambia el orden de DESC a ASC, pero no nos preocupemos

# -'y si quiero hacer un conjunto a traves de un string'- talves digas
# pues...
set_from_string = set('hola')
print(set_from_string)

# -'bueno, pero esta vez lo quiero desde una tupla'-
# pues...
set_from_tuples = set(('abc', 'cbv', 'as', 'abc'))
print(set_from_tuples)

#-'¡Pues ahora de una lista!'-
# pues...

numbers = [1,2,3,1,2,3,4]
set_numbers = set(numbers)
print(set_numbers)

# -'Bien bien, ahora, toma esa lista de números y conviertela en un array o en lista'-
# pues...
unique_numbers = list(set_numbers)
print(unique_numbers)

# -'¡ME RINDO! *se va de la habitación'-

Me acabo de dar cuenta que cuando se coloca un valor True, y 1 entero solo se pinta el que primero se haya definido, es decir si tenemos

my_set = {1, True}
print(my_set)

Solo aparecerá el 1 en el conjunto y se produce el mismo comportamiento de la forma inversa

trabajando en conjuntos cuando este tiene presencia de el numero 1 y el valor booleano True,elimina al 1 porque lo toma como valor duplicado de True y lo mismo con el False y el cero

En Python, un “set” (conjunto) es una colección desordenada de elementos únicos. Es una estructura de datos que se utiliza para almacenar múltiples elementos sin permitir duplicados. Los conjuntos son mutables, lo que significa que se pueden agregar, eliminar y modificar elementos después de su creación.

La principal característica de los conjuntos es que no conservan ningún orden específico de los elementos. Esto significa que no puedes acceder a los elementos de un conjunto por índice, ya que no hay un orden establecido. Sin embargo, puedes iterar sobre los elementos de un conjunto utilizando un bucle for.

La ventaja clave de utilizar conjuntos en Python es su capacidad para verificar rápidamente la existencia de un elemento y eliminar duplicados en una lista de elementos. Además, los conjuntos admiten operaciones matemáticas como intersección, unión, diferencia y diferencia simétrica.

Aquí tienes un ejemplo de cómo crear y trabajar con conjuntos en Python:

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

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

# Agregar elementos al conjunto
mi_conjunto.add(6)
mi_conjunto.add(7)

# Eliminar un elemento del conjunto
mi_conjunto.remove(3)

# Verificar la existencia de un elemento en el conjunto
existe = 4 in mi_conjunto

# Iterar sobre los elementos del conjunto
for elemento in mi_conjunto:
    print(elemento)

# Operaciones con conjuntos
conjunto1 = {1, 2, 3}
conjunto2 = {3, 4, 5}

# Intersección de conjuntos
interseccion = conjunto1.intersection(conjunto2)

# Unión de conjuntos
union = conjunto1.union(conjunto2)

# Diferencia de conjuntos
diferencia = conjunto1.difference(conjunto2)

# Diferencia simétrica de conjuntos
diferencia_simetrica = conjunto1.symmetric_difference(conjunto2)

Los conjuntos en Python son útiles cuando necesitas almacenar una colección de elementos únicos y realizar operaciones eficientes con ellos.

El vídeo fue genial. Tuve que volver a ciertas cosas de Tuplas, listas y diccionarios. Pero veo que existen, al menos hasta ahora., 4 tipos de estructuras de datos:

Tuplas
Listas
Diccionarios
Conjuntos

Si creas un set = { 1,0,3,True , False, ‘David’}

python obviará True y False porque los toma como 1 y 0 respectivamente. Como lo mencionó el profe, python no puede tener elementos repetidos en un set.

Todo el codigo del profesor explicado linea por linea

set_countries = {'col', 'mexico', 'bolivia'} # Definimos nuestro conjunto

print(set_countries) # Imprime los datos del conjunto
print(type(set_countries)) # Imprime "Set" afirmando que la estructura de datos es un conjunto

set_countries = {'col', 'mexico', 'bolivia', 'col'} #Agregamos un elemento duplicado
print(set_countries) #Elimina el elemento duplicado, y solo imprime valores unicos


set_types = {1, 'Hola', False, 3.1416} #Los conjuntos permiten agrupar varios tipos de datos
print(set_types)

set_from_sring = set('Hola') # Podemos generar conjuntos a partir de un string
print(set_from_sring) #Genera cada letra como unica y la agrega al conjunto

set_from_sring = set('holaa') #Intentamos generar conjuntos a partir de un string con datos duplicado
print(set_from_sring) #No permite elementos duplicados

set_from_tuples = set(('abc', 'cbv', 'as', 'abc')) #Podemos generar un conjunto desde una tupla
print(set_from_tuples) #Genera el conjunto pero elimina los elementos duplicados

numbers = [1,2,3,1,2,3,4] # Lista con numeros
set_numbers = set(numbers) #Generamos el set desde la lista 'numbers'
print(set_numbers) #Elimina los numeros duplicados
unique_numbers = list(set_numbers) #Pasamos los numeros unicos a formato de lista
print(unique_numbers) #Imprime los numeros unicos como una lista

Excelente curso!

Sets -> Conjuntos

Tienen o agrupan datos en su interior
Sus propiedades

• Lo podemos modificar
• No tienen un orden en específico
• No se permiten duplicados
  Los conjuntos se expresan entre corchetes como los diccionarios pero no tienen llaves.

#Los conjunstus = se pueden modificar, no tienen un orde y no permite duplicados.

set_countries = {"colombia", "mexico", "bolivia"}
print(set_countries)
print(type(set_countries)) # No es posible replicar elementos en un conjunto

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


set_types = {1, "hola", True, 1.2}
print(set_types)

set_from_strings = set("Holaa")
print(set_from_strings)

set_from_tupla = set(("abc", "cbw", "acg"))
print(set_from_tupla)

numbers = [1,2,3,4,5,2,1]
set_numbers = set(numbers)
print(set_numbers)

numeros_unicos = list(set_numbers)
print(numeros_unicos)

# SETS

"""
Un conjunto agrupa elementos que tienen algo en común.
 - Se pueden modificar
 - No tienen un orden
 - No pueden tener elementos duplicados

 Por ejemplo: Los países.
 Colombia, Meximo y Bolivia pertenecen al continente America.
"""

# no tiene un par key-value, así nos damos cuenta que es un set, un conjunto, y no un diccionario.
set_countries = {'col', 'mex', 'bol'}
print(set_countries)
print(type(set_countries))

# Si tenemos algo repetido en el set, Python elimina el duplicado al imprimir
set_countries2 = {'col', 'mex', 'bol', 'bol', 'col'}
print(set_countries)
print(type(set_countries))

# También se puede con números
set_numbers = {1, 2, 2, 443, 23}
print(set_numbers)

# Podemos tener un conjunto con varios tipos de datos
set_types = {1, 'hola', False, 12.12}
print(set_types)

# Podemos crear un conjunto a partir de un string
set_from_string = set('hoola') # el hoola es a propósito para ver que en el print elimiina los duplicados
print(set_from_string)

set_from_tuples = set(('abc', 'cbv', 'as', 'abc'))
print(set_from_tuples)

# Podemos crear a partir de una lista o tupla de numeros
numbers = [1,2,3,1,2,3,4]
set_numbers = set(numbers)
print(set_numbers)

# Convertir un set de números a una lista
unique_numbers = list(set_numbers)
print(unique_numbers)

Profundizar con la documentación vale la pena.

If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.

Podriamos decir que con el simple hecho de crear un conjunto a partir de numbers. Estoy limpiando esos datos desordenado o cantidad de numeros, dejando solo numeros unicos. Se podria decir que estoy haciendo una limpieza de datos.

set_paises = {“colombia” , “mexico” , “bolivia”}
print(set_paises)
print(type(set_paises))

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

set_tipos = {1,“hola”,False,25.25}
print(set_tipos)
print(type(set_tipos))

set_String = set(“Hola”)
print(set_String)

set_tupla = set ((“abc”,“def”,“ghi”,“abc”))
print(set_tupla)

numeros = [1,2,3,1,2,3,4]
numeros=set(numeros)
print(numeros)
numeros_unicos= list(set_numeros)

2. Sets

Conjuntos de toda la vida con algo en común

• Se pueden modificar.
• No tienen un orden.
• No permite duplicados.

set_countries = {'col', 'mex', 'bol', 'col'} # Como los diccionarios pero sin claves
print(set_countries) # Elimina los duplicados
print(type(set_countries))

set_numbers = {1, 2, 3, 4, 4}
print(set_numbers)

set_types = {1, 'hola', False, 12.12}
print(set_types)

set_from_string = set('hiloo') # set(elemento) crea un conjunto a partir de un elemento que yo quiera
print(set_from_string)

set_from_tuples = set(('abc', 'cbv', 'as', 'abc'))
print(set_from_tuples)

numbers = [1,2,3,1,2,3,4]
set_numbers = set(numbers)
print(set_numbers)
unique_numbers = list(set_numbers) # se puede pasar de diccionario a lista y viceversa
print(unique_numbers)

Los conjuntos:

• Puedes almacenar objetos de diferente tipo
• Son modificables
• No tienen orden
• Los elementos dentro de él son únicos
• Puede almacenar tuplas
• Dos tuplas las considera iguales si tienen los mismos elementos en el mismo orden
• No puedes hacer conjuntos de diccionarios, estos son “No hasheables”
• No puedes hacer conjuntos de listas, estos son “No hasheables”
• Crear conjunto: mi_conjunto = {elemento1, elemento2, elemento3}

set_countries = {'col', 'mex', 'bol'}
print(type(set_countries), ' => ',set_countries)
# <class 'set'>  =>  {'col', 'mex', 'bol'}

print('*'*20)
# ********************

# Las dos tuplas las considera iguales si tienen 
# los mismos elementos en el mismo orden
countries1 = ('bra', 'usa', 'ecu');
countries2 = ('bra', 'usa', 'ecu');
set_arrays = {countries1, countries2, countries2}
print(type(set_arrays), ' => ',set_arrays)
# <class 'set'>  =>  {('bra', 'usa', 'ecu')}

'''
# No puedes hacer conjuntos de diccionarios
countries1 = { 'n1': 'bra', 'n2': 'usa', 'n3': 'ecu'};
countries2 = { 'n1': 'bra', 'n2': 'usa', 'n3': 'ecu'};
set_arrays = {countries1, countries2, countries2}
print(type(set_arrays), ' => ',set_arrays)
'''
# Traceback (most recent call last):
#   File "main.py", line 19, in <module>
#     set_arrays = {countries1, countries2, countries2}
# TypeError: unhashable type: 'dict'

'''
# No puedes hacer conjuntos de listas
countries1 = ['bra', 'usa', 'ecu'];
countries2 = ['bra', 'usa', 'ecu'];
set_arrays = {countries1, countries2, countries2}
print(type(set_arrays), ' => ',set_arrays)
'''
# Traceback (most recent call last):
#  File "main.py", line 32, in <module>
#    set_arrays = {countries1, countries2, countries2}
# TypeError: unhashable type: 'list'


countries1 = {'n1': 'bra', 'n2': 'usa', 'n3': 'ecu'}
countries2 = {'n1': 'bra', 'n2': 'usa', 'n3': 'ecu'}
set_arrays = {countries1, countries2, countries2}
print(type(set_arrays), ' => ',set_arrays) 

Sets o conjuntos.

En Python, un set o conjunto es una colección no ordenada de elementos únicos. Los sets se definen usando llaves {} o la función set(). Veamos un ejemplo:

# Definir un set
numeros = {1, 2, 3, 4, 5}
print(numeros)

# Agregar un elemento al set
numeros.add(6)
print(numeros)

# Remover un elemento del set
numeros.remove(3)
print(numeros)

La salida de este código sería:

{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5, 6}
{1, 2, 4, 5, 6}

Los sets son útiles cuando necesitamos almacenar elementos únicos y no nos importa el orden en que se encuentran. Además, los sets tienen métodos útiles para realizar operaciones como unión, intersección y diferencia entre sets.

Continuando con el ejemplo anterior, veamos cómo se pueden realizar algunas operaciones básicas con sets en Python:

# Definir dos sets
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# Unión de sets
union = set1.union(set2)
print(union)

# Intersección de sets
interseccion = set1.intersection(set2)
print(interseccion)

# Diferencia de sets
diferencia = set1.difference(set2)
print(diferencia)

La salida de este código sería:

{1, 2, 3, 4, 5, 6, 7, 8}
{4, 5}
{1, 2, 3}

Como se puede ver, la unión de set1 y set2 contiene todos los elementos de ambos sets, mientras que la intersección contiene solo los elementos que se encuentran en ambos sets. Por otro lado, la diferencia de set1 y set2 contiene los elementos que están en set1 pero no en set2.

En resumen, los sets son una herramienta útil en Python para trabajar con colecciones de elementos únicos. Además de permitirnos realizar operaciones básicas como agregar o remover elementos, los sets también nos permiten realizar operaciones más complejas como unión, intersección y diferencia entre sets.

• No importa el orden.
• No acepta elementos duplicados.
• Puede contener varios tipos de datos, ej. (strings, numbes, boolean).
• Puede generar un conjunto de forma implícita a partir de un strings, tuplas, listas.

Los sets y los diccionarios en Python son similares en el sentido de que ambos son colecciones no ordenadas de elementos. Sin embargo, mientras que los sets contienen solo elementos únicos, los diccionarios contienen pares clave-valor únicos.

Los sets se definen usando llaves {} o la función set(), mientras que los diccionarios se definen usando llaves {} y pares clave-valor separados por dos puntos :. Además, los elementos en un set se pueden acceder mediante iteración, mientras que los elementos en un diccionario se acceden mediante la clave correspondiente.

En resumen, la principal diferencia entre sets y diccionarios es que los sets son colecciones de elementos únicos, mientras que los diccionarios son colecciones de pares clave-valor únicos.

Los Sets

• No son modificables: lo que quiere decir, que una vez un set es creado no podemos cambiarlo, sin embargo podemos agregarle o eliminarle elementos.

• No son ordenados: Quire decir que sus elementos no tienen un orden definido, y cada vez que ejecutemos el set, aparecerán de manera diferente.

• No permite valores duplicados: Como los sets no son indexados, es decir, no podemos acceder a ellos por medio de sus indices [index], no permitirá valores duplicados.

thisset = {"apple", "banana", "cherry", True, 1, 2, "apple"}

print(thisset)

Nota: Los elementos True y 1 son iguales, por lo tanto python los tratara de la misma forma y solo mostrará el True(porque no permite duplicados) lo mismo pasará con "apple"

print("#-----strings-------#")
set_countries = {'col', 'mex', 'bol'}
print(set_countries)
print(type(set_countries))

print("#-----numbers-------#")
set_numbers = {2, 5, 7, 8, 9, 1, 2}
print(set_numbers)
print(type(set_numbers))

print("#-----types-------#")
set_types = {1, 'hola', True, False, 52.6}
print(set_types)
print(type(set_types))

print("#-----set_from_strings-------#")
set_from_strings = set('hooooola')
print(set_from_strings)
print(type(set_from_strings))

print("#-----set_from_tuples-------#")
set_from_tuples = set(('abc', 'def', 'avc', 'abc'))
print(set_from_tuples)
print(type(set_from_tuples))

numbers = [1, 7, 2, 6, 2, 8, 2, 8, 7, 1, 0, 2, 8, 2]
set_from_number = set(numbers)
print(set_from_number)
print(type(set_from_number))

Sets (conjuntos)

1. Se pueden modificar.
2. No tiene un orden.
3. No permite duplicados.
4. Permite cualquier tipo de dato dentro de un mismo set =str, boolean, num, flot.

var = {”bol”, ”mex”, “True”, “2”, ”5.6” …} (Se parece a un diccionario, pero no lo es porque no se presenta la relación llave:valor "key:value”)

También se puede convertir listas y caracteres en sets con el comando “set()” y luego se puede regresar a su tipo anterior con el comando correspondiente “str”, “list”… Esto es útil para asegurarnos que ningún carácter este repetido.

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

# El número 2 solo se guarda una vez, ya que los Set no permiten valores duplicados
set_numbers = {1, 2, 2, 443, 23}
print(set_numbers)

# Crear un Set con diferentes tipos de datos
set_types = {1, 'Hola', False, 12.12}
print(set_types)

# Crear un Set a partir de un String
set_from_string = set('hoola')
print(set_from_string)

# Crear un Set a partir de una tupla
set_from_tuple = set(('abc', 'def', 'fgh', 'abc'))
print(set_from_tuple)

# Convertir una lista a Set
numbers = [1,2,3,1,2,3,4]
set_numbers = set(numbers)
print(set_numbers)

# Obtener los números únicos de una lista usando con ayuda de Set
unique_numbers = list(set_numbers)
print(unique_numbers)

En Python, un conjunto es una colección no ordenada y mutable de elementos únicos. Los conjuntos se definen utilizando llaves ({}) o la función “set()”. Por ejemplo:

# Crear un conjunto con llaves
conjunto1 = {"manzana", "naranja", "plátano"}

# Crear un conjunto con la función set()
conjunto2 = set(["pera", "mango", "uva"])

Las principales propiedades de los Sets o Conjuntos en Python son:

1. No permiten elementos duplicados: los conjuntos no permiten tener elementos repetidos. Si se intenta agregar un elemento que ya está presente en el conjunto, éste simplemente es ignorado.

2. No tienen orden: los conjuntos no tienen un orden definido. Cuando se recorren los elementos de un conjunto, el orden en que se obtienen puede variar de una ejecución a otra.

3. Son mutables: los conjuntos pueden ser modificados después de haber sido creados. Es decir, se pueden agregar o eliminar elementos.

4. Usan la función hash: para lograr la propiedad de no permitir elementos duplicados, los conjuntos utilizan una función hash internamente. Esta función permite determinar de manera eficiente si un elemento ya está presente en el conjunto o no.

5. Soportan operaciones de conjuntos: los conjuntos en Python soportan operaciones de conjuntos como la unión, intersección y diferencia, entre otras. Estas operaciones son útiles para trabajar con conjuntos y realizar operaciones en ellos de manera eficiente.

# Conjunto vacío
conjunto_vacio = set()

# Conjunto de números enteros
numeros = {1, 2, 3, 4, 5}

# Conjunto de cadenas de texto
palabras = {'hola', 'mundo', 'python'}

# Conjunto de elementos mixtos
conjunto_mixto = {1, 'hola', 3.14, (2, 3, 4)}

# Conjunto generado a partir de una lista
lista = [1, 2, 3, 2, 1]
conjunto_lista = set(lista)

# Conjunto de colores
colores = {'rojo', 'verde', 'azul'}

# Conjunto de frutas
frutas = {'manzana', 'naranja', 'banana'}

# Conjunto de ciudades
ciudades = {'New York', 'Paris', 'Tokyo', 'London'}

En Python, un conjunto (set) es una colección de elementos únicos e inmutables, es decir, que no pueden ser modificados una vez que han sido añadidos al conjunto. Los conjuntos se definen mediante llaves {} o mediante la función preconstruida set().

Los conjuntos son útiles en Python por varias razones:

Eliminan elementos duplicados: Si se tiene una lista con elementos duplicados, se puede convertir en un conjunto para eliminar los duplicados.

Realizar operaciones de conjuntos: Se pueden realizar operaciones de conjuntos como la unión, intersección, diferencia y diferencia simétrica entre conjuntos.

Comprobar si un elemento está en un conjunto: Es más eficiente buscar un elemento en un conjunto que en una lista, ya que los conjuntos están optimizados para esta operación.

Son mutables: Se pueden agregar o eliminar elementos de un conjunto después de su creación.

En resumen, los conjuntos son una estructura de datos útil en Python para trabajar con colecciones de elementos únicos y realizar operaciones de conjuntos eficientes.

Este curso es casi similar de curso basico python o es otro poco avanzado

Ya se me están ocurriendo varias aplicaciones para los conjuntos

la unica forma que encontre de que se repita un valor, por ejemplo un numero en un set, es ponerlo la primera vez como numero, la segunda como string. no se para que carajos sirviria esto. pero queria compartirlo.

BUENAS NOCHES!
AQUI LES DEJO MI CODIGO CON NOTAS ESPERO AYUDE

'''
Conjuntos

Conjutos agrupan elementos que tienen algo en comun

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

print(set_countries) # {'col', 'mex', 'bol'}
print(type(set_countries)) # <class 'set'>
print(jumpline)

#No puedo tener items repetidos, al hacer print los va eliminar
set_countries = {'col', 'mex', 'bol', 'col'} 
print(set_countries) # {'col', 'mex', 'bol'}
print(jumpline)

set_numbers = { 1, 2, 2, 443, 23}
print(set_numbers) # {1, 2, 443, 23}
print(jumpline)

# Tambien puedo almacenar diferentes tipos de datos
# No importa el orden que le demos
set_types = {1, 'Hola', False, 12.2}
print(set_types) # {False, 1, 12.2, 'Hola'}
print(jumpline)

# Puedo crear un set a partir de un string
set_from_string = set('hola')
print(set_from_string) # {'l', 'a', 'h', 'o'}
print(jumpline)

set_from_string = set('hoooolaaaaa')
print(set_from_string) # {'l', 'a', 'h', 'o'}
print(jumpline) 

# Puedo crear un set a partir de una tupla
set_from_tuples = set(('abc', 'cbv', 'as', 'abc'))
print(set_from_tuples) # {'as', 'cbv', 'abc'}
print(jumpline)

# Puedo igualmente hacer sets desde una lista
numbers = [1,2,3,1,2,3,4]
set_numbers = set(numbers)
print(set_numbers) # {1,2,3,4}

# Y volver un set una lista con los items unicos
unique_numbers = list(set_numbers)
print(unique_numbers) # {1,2,3,4}
print(unique_numbers[1]) # 2
print(jumpline)

Habia desprestigiado los sets, está clase me iluminó 🤯

Me gusta la forma en la que Nicolas imparte el curso. Hace que me guste programar.👌👌

Mi resumen:

importante recordar que los sets, solo recupera numeros unicos!

Los Sets en Python:

Son estructuras de datos que contienen elementos únicos. Son similares a las listas o tuplas, pero no permiten elementos duplicados. Los Sets son una forma eficiente de mantener colecciones de datos sin duplicados y proporcionan operaciones útiles para trabajar con conjuntos, como la unión, la intersección y la diferencia.

En Python, los Sets se pueden crear utilizando la función set() o con los corchetes {}. Ejemplo:

# Crear un Set usando la función set()
colores = set(["rojo", "verde", "azul"]

Tambien claro esta podemos hacerlo con una tupla

numbers = [1,2,3,12,1,2,3]
set_number = set(numbers)
unique_tuple = tuple(set_number)
print(unique_tuple)

Si ponemos un set de números serán impresos de menor a mayor