Tuplas y Conjuntos en Python: Características y Usos Prácticos

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

Resumen

Tuplas(tuples) son iguales a las listas, la única diferencia es que 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.

Para poderla inicializar utilizamos la función tuple.

Uno de sus usos muy comunes es cuando queremos regresar más de un valor en nuestra función.

Una de las características de las Estructuras de Datos es que cada una de ellas nos sirve para algo especifico. No existe en programación una navaja suiza que nos sirva para todos. Los mejores programas son aquellos que utilizan la herramienta correcta para el trabajo correcto.

Conjutos(sets) nacen de la teoría de conjuntos. Son una de las Estructuras más importantes y se parecen a las listas, podemos añadir varios elementos al conjunto, pero no pueden existir elementos duplicados. A diferencia de los tuples podemos agregar y eliminar, son mutables.

Los sets se pueden inicializar con la función set. Una recomendación es inicializarlos con esta función para no causar confusión con los diccionarios.

add nos sirve añadir elementos.
remove nos permite eliminar elementos.

Néstor Iván Cepeda Munevar

student•

Para los que quieren entender más a fondo las diferencias entre listas y duplas:
listas vs duplas

Eduardo Siavichay

student•

tuplas*

Néstor Iván Cepeda Munevar

student•

Tienes razón Eduardo, una dupla sería como una 2-tupla jeje

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

Ingrid Natalia Rodriguez Ovalle

student•

Los mejores trabajos son aquellos que utilizan la herramienta correcta para el trabajo correcto

Omar Daniel Centeno

student•

❤️🦄

Juan Carlos Pinzón

student•

Estos conceptos de conjuntos en Python los son buenos para practicar con clases de Matemáticas Discretas

Omar Daniel Centeno

student•

A mí me parece que también se va construyendo una especie de relación entre Python con las bases de datos relacionales que me está gustando.

Daniel Correa

student•

Podemos pasar de listas a tuplas asi

tupla = tuple(lista)

y de tupla a lista asi

lista = list(tupla)

Iván Fernández

student•

Compa David. Que bien explicaste listas, diccionarios y tuplas. Ahora sí estructuraste bien el desarrollo de estos temas. No se nota improvisado como el curso anterior que te aventaste XD
Excelente.

Wilson Montenegro

student•

Casi muero con el reto.

Omar Daniel Centeno

student•

jajaja yo también.

fidel angel ochoa

student•

estuvo rebueno-dificil y me emocione cuando lo logre, genial esa sensacion!

Wilson Fernando Antury Torres

student•

Los sets nacen de la teoría de conjuntos. No permiten elementos duplicados.

Omar Rodríguez Aldama

student•

la mayor diferencia de una tupla con una lista es que la lista es inmutable

ventajas de una tupla frente a una lista, la tupla puede regresar varios valores

los conjuntos se parecen a la teoría de conjuntos donde se pueden añadir varios elementos al conjunto pero no existe elementos duplicados su palabra es set

listas = [] , list diccionarios = {}. dict tuplas = (). conjuntos = set, {}

Evander Nassem Ramírez Hernández

student•

POV: En la prepa pensaste que jámas usarías conjuntos en la vida real 🤡

Wilson Delgado

student•

me gusta mucho ver la teoría aplicada

Omar Daniel Centeno

student•

Ayuda mucho al aprendizaje

Miguel Andres Rendon Reyes

student•

Los buenos programas, son los que utilizan la herramienta correcta para el trabajo correcto.

Omar Daniel Centeno

student•

Sets

Ejercita tus conocimientos con simples ejercicios de SETS

. 1.- Crea un SET

primos = set()

# primos = {} un set vacion

# Podemos agregar valores a partir de una lista o una tupla conviertiendo esas estructuras a sets con el método set()

mi_lista  = [3,5,7,9,11,13]

primos = set(mi_lista)

# primos = {3, 5, 7, 9, 11, 13}

>>> primos = {3,5,7,9,11,13}
	
>>> type(primos)
<class 'set'>

# Puedes agregar valores con add(). También agregarlos a partir de otra estructura con .update() 

primos.add(21)

# {3,5,7,9,11,13}

# Tambien podrás eliminar valores del set con .discard() y .remove(). La diferencia es que si el elemento no se encuentra en el ser .remove reportará un error mientras que .discard no lo hará.

primos.discard(3)

# {5, 7, 9, 11, 13}

platzi = set('NuncaParesdeAprender')
print(platzi)

# {'P', 'n', 'N', 'p', 'A', 'c', 's', 'e', 'u', 'd', 'a', 'r'}

# Eliminando el contenido de un set con .clear()

platzi.clear()

# platzi = {}

Sets para teoría de conjuntos

# Los siguientes símbolos se utilizan para operar conjuntos con sets: 

se1 = [1, 2, 3]
set2 = [3, 4, 5]

Unión: ( | ) ......................................sets = set1 | set2
Intersección: (&) .............................sets = set1 & set2
Diferencia: (-) ..................................sets = set1 - set2
Diferencia simétrica: (^) ..................sets = set1 ^ set2
Comparando dos Sets: (==)............sets = set1 == set2
Comprobando membresía: (in) .......sets = set1 in set2

Junior Peves

student•

En la parte de 'Set para teoría de conjuntos' se han seteado listas y no sets, deben están entre {} y no entre []

Orlando Ramirez

student•

Tuples

======

A pesar de parecerse a las listas, las tuplas son más livianas y tienen menos métodos disponibles, esto sucede debido a que las tuplas son inmutables, es decir, no se pueden modificar, a diferencia de las listas. Un punto a favor de las tuplas es que al ser más livianas se pueden trabajar mejor con grandes extensiones de datos.

Si se desea crear una tupla que sólo contenga un elemento, esto se puede hacer con la siguiente sintaxis

prueba = a,


type(prueba)
<class 'tuple'>

Teoría de conjuntos

======

La teoría de conjuntos es una parte de la matemática que estudia como se relacionan un tipo especial de objetos llamados conjuntos, esta se suele hacer de forma gráfica a través de los diagramas de Venn.

La teoría de conjuntos posee además una álgebra de conjuntos que tiene las siguientes operaciones básicas:

Union: que enlaza dos conjuntos y se representa (A ∪ B)
Intersección: en esta se ubican todos los elementos que esten en ambos objetos (A ∩ B)
Diferencia: (A \ B) nos muestra los elementos que estan en A y no pertenecen a B, (B \ A) Tiene todos los elementos de B que no pertenercen a A.

Sets

No son ordenados, es decir, no importa el orden en que agregues datos a el set, estos pueden aparecer en diferente orden. Por otro lado si se agregan dos veces el mismo dato en un set, este agregara el dato la primera vez y la segunda lo ignorara.

Por ejemplo si yo creo el siguiente set en mi computadora

examp = set({1, 9, 'casa', 'hoy'})


#Luego imprimp examp me da el siguiente valor
examp
{'casa', 1, 9, 'hoy'}

En caso de intentarlo en tu computadora con los exactos mismos números y strings, es muy probable que cuando imprimas examp te de un orden distinto.

Los sets tienen los siguientes métodos para las operaciones de conjuntos

para la unión se usa el método union.
para intersección posee intersection.
para diferencia se usa difference.
además posee distintos métodos para otras operaciones como symmetric_difference, issubset, copy.
Para borrar todo un set se utiliza clear.

Omar Daniel Centeno

student•

genial

Guillermo Pizarro

student•

Ahí va mi solución:

import sys

clientes = [
    {
        'nombre': 'Pablo',
        'empresa': 'Google',
        'email': 'pablo@google.com',
        'posicion': 'Software Engineer'
    },
    {
        'nombre': 'Ricardo',
        'empresa': 'Facebook',
        'email': 'ricardo@facebook.com',
        'posicion': 'Data Engineer'
    }
] 

def crear_cliente( cliente ):
    global clientes

    if cliente not in clientes:
        clientes.append( cliente )
    else:
        print('El cliente ya se encuentra en la lista.')


def listar_cliente():
    global clientes

    for indice, cliente in enumerate( clientes ):
        _mostrar_cliente( indice )


def actualizar_cliente(id_cliente, cliente_nuevo):
    global clientes

    clientes[id_cliente] = cliente_nuevo


def eliminar_cliente( id_cliente ):
    global clientes

    del clientes[ id_cliente ]


def buscar_cliente( ):
    global clientes

    nombre_cliente = _obtener_campo_cliente( 'nombre' )

    for cliente in clientes:
        if cliente['nombre'] == nombre_cliente:
            return True
    else:
        return False

def _buscar_cliente_x_nombre():
    global clientes

    nombre_cliente = _obtener_campo_cliente( 'nombre' )

    for indice, valor in enumerate( clientes ):
        if valor['nombre'] == nombre_cliente:
            return indice
    else:
        return -1

def _mostrar_cliente( indice ):
    global clientes

    print( '{uid} | {nombre} | {empresa} | {email} | {posicion}'.format( 
        uid=indice, 
        nombre=clientes[indice]['nombre'],
        empresa=clientes[indice]['empresa'],
        email=clientes[indice]['email'],
        posicion=clientes[indice]['posicion'] ) )


def _obtener_campo_cliente( nombre_campo ):
    campo = None

    while not campo:
        campo = input( '¿Cuál es el {} del cliente?: '.format(nombre_campo) )
    
    return campo

def _obtener_cliente( ):
    cliente = {
        'nombre': _obtener_campo_cliente('nombre'),
        'empresa': _obtener_campo_cliente('empresa'),
        'email': _obtener_campo_cliente('email'),
        'posicion': _obtener_campo_cliente('posicion')
    }
    return cliente

def _imprimir_bienvenida():
    print( 'BIENVENIDO A PLATZI VENTAS' )
    print( '*' * 50 )
    print( '¿Qué te gustaría realizar?: ' )
    print( '[C]rear Cliente' )
    print( '[L]istar Cliente' )
    print( '[A]ctualizar Cliente' )
    print( '[E]liminar Cliente' )
    print( '[B]uscar Cliente' )
    print( '[S]alir' )


if __name__ == "__main__":
    while True:
        _imprimir_bienvenida()

        comando = input()
        comando = comando.upper()

        if comando == 'C':
            cliente = _obtener_cliente()
            crear_cliente( cliente )
            listar_cliente()
        elif comando == 'L':
            listar_cliente()
        elif comando == 'A':
            id_cliente = _buscar_cliente_x_nombre()
            if id_cliente != -1:
                _mostrar_cliente( id_cliente )
                cliente_nuevo = _obtener_cliente()
                actualizar_cliente( id_cliente, cliente_nuevo )
                listar_cliente()
            else:
                print('El cliente no se encuentra en la lista de clientes.')
        elif comando == 'E':
            id_cliente = _buscar_cliente_x_nombre()
            if id_cliente != -1:
                eliminar_cliente( id_cliente )
                listar_cliente()
            else:
                print('El cliente no se encuentra en la lista de clientes.')
        elif comando == 'B':
            encontrado = buscar_cliente( )
            if encontrado:
                print( 'El cliente se encuentra en la lista.' )
            else:
                print( 'El cliente no se encuentra en la lista.' )

            listar_cliente()
        elif comando == 'S':
            break
        else:
            print( 'Comando inválido.' )