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)

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

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.

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.

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?

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? 💚

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!

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

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.

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

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.

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.

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

Se parece mucho sobre cómo definimos a un diccionario pero en este caso tendrá solo los elementos

Un conjunto tiene o agrupa elementos que tienen algo en común.

Propiedades de los conjuntos.

1. Se pueden modificar
   • Le puedes agregar elementos
   • Le puedes quitar elementos
   • Los puedes unir con otros conjuntos
2. Los conjuntos o los elementos que tienen dentro no tienen un orden en específico.
3. Dentro de un conjunto no se permiten duplicados

Definitivamente útil si tienes muchos datos repetidos y solo quieres una tupla o lista de los representativos.

es algo nuevo que aprender, python hace todo aun mas facil ya veo por que es muy gustado

parecen anagramas los resultados de set()

'''
Sets
Se pueden modificar
No tienen un orden
No pueden tener elementos duplicados
'''

#Piensa como los conjuntos

set_paises={"col","mex","bol","bol"}
print(set_paises)
print(len(set_paises))
print(type(set_paises))

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

set_tipos={1,"hola",False,12.12}
print(set_tipos)

set_desde_strings=set("hola")
print(set_desde_strings)

set_desde_tupla=set(("abc", "def", "abc", "def"))
print(set_desde_tupla)

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

Les comparto el código de la clase 💚

# Sets
# https://platzi.com/clases/2884-notacion-matematica/47333-conjuntos/
# https://www.w3schools.com/python/python_sets.asp

'''
- Se pueden modificar
- No tienen un orden
- No permite duplicados
'''

'''
Se definen también con {} pero en este caso no tiene un par key:value
sino directamente va a tener los elementos
'''
set_countries = {"col", "mex", "bol"}
print(set_countries)
print(type(set_countries))

set_numbers = {1, 2, 2, 443, 23}
# Aunque el 2 está repetido, al imprimir lo muestra solo una vez
print(set_numbers)

set_types = {1, "Hola", False, 12.12}
# En este caso se imprime en otro orden
print(set_types)

# Creamos un conjunto a partir de un string
set_from_string = set("Hola")
print(set_from_string)

# Creamos un conjunto a partir de una tupla
set_from_tuples = set(("abc", "cbv", "as", "abc"))
print(set_from_tuples)

# Creamos un conjunto a partir de una lista
set_from_list = set([1, 2, 3, 1, 2, 3, 4])
print(set_from_list)

'''
En Python podemos tener una lista de numeros o valores duplicados,
los cuales si transformamos en conjuntos (set) conservaríamos solo los valores únicos.
'''

# Pasamos un diccionario a una lista

unique_numbers = list(set_from_list)
print(unique_numbers)
print(type(unique_numbers))

Siguiendo la clase

cities = {'gye', 'uio', 'cue', 'mnt', 'gye'}
print(cities)

age = {11, 13, 16, 37, 43, 43}
print(type(age))
print(age)

varios = {12.89, 'lalo', 2, True} 
print(varios)

traba = set('parangaricutirimicuaroo')
print(traba)

tupla = set(('abc', 'def', 'ghi', 'ghi'))
print(tupla)

num = [10, 20, 30, 40, 40, 50]
set = set(num)
print(set)
unicos = list(set)
print(unicos)

Sets o Conjuntos

• No tienen orden.
• No tienen elementos duplicados.
• No se pueden acceder a los elementos de un conjunto mediante un índice, ya que no tienen orden.
• Se pueden realizar operaciones de conjunto como la unión, intersección, diferencia, etc.

• Un set o conjunto es una colección no ordenada de objetos. No posee un índice como las listas o los diccionarios, y no puede contener objetos repetidos.
• Se declara usando llaves {0} como un diccionario pero, dado que no tiene pares clave-valor, simplemente se separan sus elementos por comas.
• Un set también puede declararse explícitamente usando la función set().
• No se puede crear un set vacío usando llaves porque se crearía un diccionario. Para crearlo es necesario hacerlo explícitamente, simplemente con conjunto = set() . Un set no puede contener valores mutables (ver más abajo).

set_countries = {'Colombia','Mexico', 'Bolivia'}
print(set_countries)
print(type(set_countries))

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

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

set_from_string = set('hoola')
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)
print(unique_numbers)

Excelente clase, esta parte no la conocia de python

""" set """
set_numbers = {3, 1, 4, 2, 0, 4, 1, 3}
print(set_numbers)
print(type(set_numbers))

set_strings = {"she", "can't", "help", "herself"}
print(set_strings)
print(type(set_strings))

set_things = {"Dolores", 12, True, "Black", 34.123, -17, "Star"}
print(set_things)
print(type(set_things))

set_from_strings = set("Sukehiro")
print(set_from_strings)
print(type(set_from_strings))

set_from_tuples = set(("bol", "mex", "col", "ch", "ar"))
print(set_from_tuples)
print(type(set_from_tuples))

set_from_list = set([1, 23, -2, 0.234])
print(set_from_list)
print(type(set_from_list))

dict = {
  "name": "Asta",
  "age": 16
}
set_from_dict = set(dict)
print(set_from_dict)
print(type(set_from_dict))

numbers = [23, -19, 23, 12, 97, -12, -19, 23]
print(numbers)
print(type(numbers))

set_from_numbers = set(numbers)
print(set_from_numbers)
print(type(set_from_numbers))

unique_numbers = list(set_from_numbers)
print(unique_numbers)
print(type(unique_numbers))

# Data Structure - set

# Sets = conjuntos ----------- # set = {}
# - Se pueden modificar
# - No tienen un orden 
# - No permite duplicados, los omite

print('-' * 30)
# creación de un conjunto de forma explícita
set_contries = {'COL', 'MEX', 'EC'}
print(type(set_contries))
print(set_contries)

print('-' * 30)
# el número 2 es omitido porque esta repetido
set_numbers = {1, 2, 2, 443, 23}
print(type(set_numbers))
print(set_numbers)

print('-' * 30)
# el output en consola cambiará el orden de los elementos del set
# num, str, bool, float ==> bool, num, str, float.... no tienen orden
set_types = {1, 'hi', False, 12.12}
print(type(set_types))
print(set_types)

print('-' * 30)
# creación de un conjunto usando "set" a partir de un string
# el string se separará por cada uno de sus caracteres y creará un nuevo conjunto sin los carácteres repetidos
set_from_string = set('correr')
print(type(set_from_string))
print(set_from_string)

print('-' * 30)
# creación de un conjunto a partir de una tupla
set_from_tupla = set(('abc', 'cbv', 'as', 'abc'))
print(type(set_from_tupla))
print(set_from_tupla)

print('-' * 30)
# creación de un conjunto a partir de una lista
list_numbers = [1,2,3,1,2,3,4,10,7,5,8,3,6,9]
set_from_list = set(list_numbers)
print(set_from_list) # el set de números se ordeno de menor a mayor
print(type(set_from_list))
print('-' * 30)
# transformación de un set a list
unique_numbers = list(set_from_list)
print(type(unique_numbers))
print(unique_numbers)

Podemos usar frozenset() de forma similar que set() podemos crear conjuntos inmutables.

Set = No tiene orden
No Permite elementos duplicados
Modificable
Depura datos duplicados

Notas

Sets

Los conjuntos se puede:

• Modificar
• No tienen un orden específico
• Un conjunto no puede tener elementos duplicados

No hay que confundir la sintaxis de los SETS con lo Dictionary

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

dictionary = {
	"Mex": 1,
	"Col": 2,
	"Bol": 3,
}

Si intenamos agregar un elemnto repetido al conjunto este no se tomara en cuenta.

import numbers

def run():
    # Set de strigs
    set_countries = {"col", "mex", "bol", "mex", "arg"}
    print(set_countries)
    print(type(set_countries))

    #Tambien podemo tener sets de ints y Floats. Si ponemos un set de numbers se imprimiran de menor a mayor
    set_numbers = {1, 2, 2, 3, 432, 7, 12, 4.0, 5.0, 4.0, 9.3862, 8.870}
    print(set_numbers)
    # print(type(set_numbers))

    #Set de varios tipos de datos
    set_types = {1, "Hola", False, 5.0,}
    print(set_types)

    #Creamos un set apartir de un string, lo que imprimira la consola será cada caracter de mi palabra hola: "h", "o", "l", "a"
    set_from_string = set("hola")
    print(set_from_string)

    #Cramos un set apartir de una tupla
    set_from_tuples =  set(("abc", "hola", "pwd", "rm", "rm"))
    print(set_from_tuples)

    #Podemos convertir listas en tuplas
    numbers = [1, 2, 3,4, 3, 5 , 64, 2, 1, 980]
    set_numbers = set(numbers)
    print(set_numbers)
    unique_numbers = list(set(numbers))
    print(unique_numbers)

if __name__ == "__main__":
    run()

#conjunto
set_a={1,2,3,4,5,6}

#diccionario
dicc_b={"a":2,"b":3}

Muy interesante la capacidad de interacción entre conjuntos, listas, tuplas, etc.

Muy interesante, la explicacion super sencilla y facil de seguir.

Gracias

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

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

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

set_from_string = set('hoola ')
print(set_from_string)

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

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

Me ha gustado la metodología que usa el profesor a la hora de explicar los conjuntos creados en python, en verdad estos deberían de ser cursos con calificaciones altas ya que pone en practica los conocimientos.

Ejemplo: tengo un texto que deseo correr para saber cuales palabras conoce el usuario, entonces con el conjunto sabre el numero exacto que se conocen.

Me gusta que parte de la teoría matemática la aplicamos aqui

Lo que no sabía es que con el import this se puede ver en python el zen… interesante para recordarlo continuamente!

Excelente clase, forma fácil de resolver problemas de números o valores únicos !

Ver las funciones disponibles para set:
dir(set())

Excelente clase, me sirivó para repasar sobre esta estructura de clases que es bastante ínteresante.

Muy buena clase acerca de conjuntos. 10/10