Tuplas y conjuntos en Python

Clase 26 de 49 • Curso Práctico de Python: Creación de un CRUD

Contenido del curso

Básicos del Lenguaje

Uso de strings y ciclos

Estructuras de Datos

Uso de objetos y módulos

Resumen

Domina dos estructuras esenciales de Python para escribir código claro y efectivo: tuplas y conjuntos. Aprenderás qué son, cómo inicializarlas sin confusión y cuándo usarlas, incluyendo operaciones clave de teoría de conjuntos como intersección, unión y diferencia. Practica sin miedo al error: lo importante es desarrollar resolución de problemas, no frustrarte y seguir adelante.

¿Qué son las tuplas en Python y cuándo usarlas?

Las tuples son como listas, pero inmutables: no cambian después de crearse. A diferencia de los strings, pueden guardar muchos tipos de valores, no solo caracteres. Se expresan como una serie de valores separados por coma y, para legibilidad, suelen llevar paréntesis.

Estructura de datos inmutable que agrupa valores heterogéneos.
Útiles para retornar múltiples valores de una función.
Se inicializan con paréntesis o con la notación funcional usando la built-in function tuple.
Elegir la herramienta correcta evita el “Swiss Army Knife” en código: cada estructura sirve a un propósito.

# tupla literal con paréntesis
punto = (3, 5)

# tupla creada con notación funcional
tupla_numeros = tuple([1, 2, 3])

¿Cómo devolver múltiples valores con una tupla?

Cuando una función necesita regresar más de un valor (por ejemplo, un punto en un plano cartesiano), una tupla es ideal.

def obtener_punto():
    x = 3
    y = 5
    return (x, y)  # dos valores empaquetados en una tupla

px, py = obtener_punto()

¿Qué son los conjuntos y cómo se inicializan sin confusión?

Los sets vienen de la set theory y en Python representan colecciones sin elementos duplicados. A diferencia de las tuplas, los conjuntos son mutables: puedes agregar o eliminar elementos. Se parecen a las listas porque agrupan varios valores, pero con reglas distintas.

Colección sin duplicados y mutable.
Dos notaciones: literal con llaves y funcional con set.
Recomendación: usar la notación funcional para evitar confusiones con diccionarios, que también usan llaves.

# notación literal con llaves
conjunto_a = {1, 2, 3}

# notación funcional preferida
conjunto_b = set([3, 4, 5])

¿Qué notación elegir: literal o funcional?

La forma literal con llaves es breve, pero puede generar confusión con diccionarios. Por claridad, es preferible set(...) cuando declares conjuntos, especialmente en código educativo o colaborativo.

¿Cómo interpretar intersección, unión y diferencia con diagramas de Venn?

Imagina dos conjuntos válidos (sin repetidos): A = {1, 2, 3} y B = {3, 4, 5}. Con un diagrama de Venn se visualiza qué comparte cada uno y qué conserva por separado. Estas operaciones son la base para razonar con conjuntos en código.

Intersección: elementos comunes. Resultado: {3}.
Unión: todos los elementos de ambos conjuntos sin repetir. Resultado: {1, 2, 3, 4, 5}.
Diferencia A − B: lo que está en A y no en B. Resultado: {1, 2}.
Diferencia B − A: lo que está en B y no en A. Resultado: {4, 5}.

Estas ideas te preparan para implementarlas en Python y entender por qué los conjuntos son tan prácticos cuando necesitas operaciones matemáticas limpias y sin duplicados.

¿Te gustaría ver más ejemplos prácticos o proponer un reto con tuplas y conjuntos? Deja tus dudas y comenta qué caso quieres resolver a continuación.

Mario Barbero Santillán

student•

"""
------ TUPLAS ------
Las tuplas (tuples) son similares a las listas.
La unica diferencia es que las tuplas son inmutables.
La diferencia con los strings es que pueden recibir muchos tipos valores.
Son una serie de valores separados por comas, casi siempre se le agregan
paréntesis para que sea mucho más legible.
tup = 1,2,3
tup = (1,2,3)-->Esta opción es la más se utiliza

Para poderla inicializar utilizamos la función 'tuple'.
Un uso muy común es utilizarlas para regresar más de
un valor en una función.
return (students,teachers)

------ CONJUNTOS ------
Los conjuntos (sets) son una colección sin orden que no 
permite elementos duplicados. A diferencia de los tuples podemos
agregar y eliminar, son mutables.
Los sets se inicializan con la función 'set'.
Para añadir elementos utilizamos el método 'add' y para eliminarlos
utilizamos el método 'remove'
"""

## LISTA --> ages = [12,18,24,34,50]
## TUPLA --> ages = (12,18,24,34,50)
## CONJUNTOS --> ages = {12,18,24,34,50}

"""Con las tuplas que pueden utilizar casi todas las (las mismas)
funciones y métodos que funcionan con las listas"""

##------ TUPLAS ------
a = (1,2,2,3)
b = (3,4,5)
c = b+a
print(c)

print(a.count(2)) ## Nos dice cuantas veces aparece el numero 2 en la tupla
print(b.index(4)) ## NOs dice en que posición aparece por primera el numero 4 en la tupla

##Esto no lo podemos hacer porque son inmutables, al contrario que las listas, que son mutables
##a[1]= 10
##c[2] = 22

##------ CONJUNTOS ------
# Creando un conjunto en python
print('-'*30)
A = {1,2,3}
print(A)

# Creando un conjunto a partir de una lista
print('-'*30)
lista = ["bananas", "manzanas", "naranjas", "limones"]
B = set(lista)
print(B)

# Los conjuntos eliminan los elementos duplicados
print('-'*30)
lista = ["bananas", "manzanas", "naranjas", "limones",
        "bananas", "bananas", "limones", "naranjas"]
B = set(lista)
print(B)

# Creando el conjunto vacío
print('-'*30)
C = set()
print(C)

# Cardinalidad de un conjunto con len().
print('-'*30)
print("La cardinalidad del conjunto A = {0} es {1}".format(A,len(A)))

# comprobando membresía
print('-'*30)
print(2 in A)
print(0 in A)

# Igualdad entre conjuntos. El orden de los elementos no importa.
print('-'*30)
A = {1,2,3,4}
B = {4,2,3,1}
print(A == B)

# Subconjunto. No hay distincion entre subconjunto y propio
# para el conjunto por defecto de python.
print('-'*30)
A = {1,2,3}
B = {1,2,4,3,5}
"""issubset() busca si los valores de A están en B, sin importar el orden"""
print(A.issubset(B))

# Union de conjuntos. Omite los valores repetidos
print('-'*30)
A = {1,2,3,4,5}
B = {4,5,6,7,8,9,10}
print(A.union(B))

# Intersección de conjuntos, es decir, los valores que se repiten
print('-'*30)
print(A.intersection(B))

# Diferencia entre conjuntos
print('-'*30)
print(A.difference(B))
print(B.difference(A))
print(A - B)
print(B - A)

##------ Utilizando sympy -------
# Utilizando FiniteSet de sympy
"""Para que el import no de error, abrir el power shell como admin
en la carpeta donde este el archivo (en mi caso, que utilizo el 
sublime text 3) o si ejecutais desde el interprete por consola, en ambos
casos teneis que poner pip install sympy"""
print('-'*30)
from sympy import FiniteSet
C = FiniteSet(1, 2, 3)
print(C)

# Generando el conjunto potencia. Esto no se puede
# hacer utilizando el conjunto por defecto de python.
print('-'*30)
print(C.powerset())

# Cardinalidad
print('-'*30)
print("La cardinalidad del conjunto potencia del conjunto C = {0} es {1}".
     format(C, len(C.powerset())))

# Igualdad
print('-'*30)
A = FiniteSet(1, 2, 3)
B = FiniteSet(1, 3, 2)
print(A == B)

A = FiniteSet(1, 2, 3)
B = FiniteSet(1, 3, 4)
print(A == B)

# Subconjunto y subconjunto propio
print('-'*30)
A = FiniteSet(1,2,3)
B = FiniteSet(1,2,3,4,5)
print(A.is_subset(B))

# A == B. El test de subconjunto propio da falso
print('-'*30)
B = FiniteSet(2,1,3)
print(A.is_proper_subset(B))

# Union de dos conjuntos
print('-'*30)
A = FiniteSet(1, 2, 3)
B = FiniteSet(2, 4, 6)
print(A.union(B))

# Interseccion de dos conjuntos
print('-'*30)
A = FiniteSet(1, 2) 
B = FiniteSet(2, 3) 
print(A.intersect(B))

# Diferencia entre conjuntos
print('-'*30)
print(A - B)

# Calculando el producto cartesiano. Con el conjunto por 
# defecto de python no podemos hacer esto con el operador *
print('-'*30)
A = FiniteSet(1, 2)
B = FiniteSet(3, 4)
P = A * B
print(P)

for elem in P:
    print(elem)

# Elevar a la n potencia un conjunto. Calcula el n 
# producto cartesiano del mismo conjunto.
print('-'*30)
A = FiniteSet(1, 2, 3, 4)
P2 = A ** 2
print(P2)

P3 = A ** 3
print(P3)

for elem in P3:
    print(elem)

# Dibujanto el diagrama de venn de 2 conjuntos
"""Para que el import no de error, abrir el power shell como admin
en la carpeta donde este el archivo (en mi caso, que utilizo el 
sublime text 3) o si ejecutais desde el interprete por consola, en ambos
casos teneis que poner pip install 'matplotlib'
y ' pip install matplotlib_venn'"""
print('-'*30)
from matplotlib_venn import venn2, venn2_circles
import matplotlib.pyplot as plt
   
print(dir(plt))
A = FiniteSet(1, 3, 5, 7, 9, 11, 13, 15, 17, 19)
B = FiniteSet(2, 3, 5, 7, 11, 13, 17, 19, 8)

plt.figure(figsize=(10, 8))
v = venn2(subsets=[A, B], set_labels=('A', 'B'))
v.get_label_by_id('10').set_text(A - B)
v.get_label_by_id('11').set_text(A.intersection(B))
v.get_label_by_id('01').set_text(B - A)
c = venn2_circles(subsets=[A, B], linestyle='dashed')
c[0].set_ls('solid')
plt.show()

Fredy Mendoza Vargas

student•

Muchas gracias

Francisco Garcia [C6]

student•

Gracias por el resumen

Néstor Iván Cepeda Munevar

Eduardo Siavichay

Ingrid Natalia Rodriguez Ovalle

Omar Daniel Centeno

Juan Carlos Pinzón

Daniel Correa

Iván Fernández

Wilson Montenegro

fidel angel ochoa

Wilson Fernando Antury Torres

Omar Rodríguez Aldama

Evander Nassem Ramírez Hernández

Wilson Delgado

Miguel Andres Rendon Reyes

Junior Peves

Orlando Ramirez

Guillermo Pizarro

Sergio Velasquez

Emmanuel Lopez

Angel Jimenez

Nicolas Alpargatero

Tuplas y conjuntos en Python

Básicos del Lenguaje

Introducción a Python: Instalación y Conceptos Básicos

Desarrollo de CRUD con Python 3

Configuración de Ubuntu en Windows 10 para Ejecutar Comandos Linux

Qué es la programación y cómo crear un programa

Por qué Python es ideal para principiantes

Operadores y tipos de datos en Python

<target-language>Spanish</target-language> Variables y expresiones en Python

Cómo crear tu primer comando en Python

Cómo declarar y usar funciones en Python

Funciones y scope global en Python

Operadores de comparación en Python

Personalizar programa Python con interfaz CLI

Uso de strings y ciclos

Strings inmutables en Python y memoria

Métodos esenciales de strings en Python

Refactorización Python: método auxiliar privado

Comando delete en Python: borrar elementos

Slices en Python: extraer rebanadas de texto

For loops y While loops en Python

While loops: validación de entrada con break

Iteradores y Generadores en Python: Creación y Uso Práctico

Estructuras de Datos

Listas de Python: mutable vs inmutable

Operadores y métodos de listas en Python

Refactorizar código con listas en Python

Diccionarios Python: llaves, valores e items

Python: diccionarios para estructura de cliente

Tuplas y conjuntos en Python

Tuplas y sets en Python: cómo funcionan

Colecciones Avanzadas en Python: UserDict, namedtuple y más

Python comprehensions: listas, sets y diccionarios

Búsqueda binaria vs fuerza bruta

Implementar búsqueda binaria recursiva en Python

Persistencia de datos con CSV en Python

Uso de objetos y módulos

Qué son decoradores en Python: concepto clave

Creación de decoradores en Python paso a paso

Los cuatro principios clave de POO

Class y __init__ en Python básico

Names y Namespaces en Python: Conceptos Fundamentales

Framework Click para aplicaciones CLI

Estructura de archivos para CLI con Click

Cómo estructurar una app CLI con orientación a objetos

Comando Create con Click: opciones y persistencia CSV

Método list_clients con csv.DictReader

CSV con tabla temporal en Python

Cómo actualizar clientes en CLI con Click

Jerarquía de errores en Python: try, except y finally

Gestión de Contextos en Python: Clases y Generadores

Python en el mundo real

Siguientes pasos con Python: ciencias y backend

Conclusiones finales

Transición de Python 2 a Python 3 y PEPs esenciales

Clases bonus

Instalación pip y ambientes virtuales Python

Class y init en Python básico