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.
Para los que quieren entender más a fondo las diferencias entre listas y duplas:
listas vs duplas
tuplas*
Tienes razón Eduardo, una dupla sería como una 2-tupla jeje
"""
------TUPLAS------Lastuplas(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,3tup =(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------Losconjuntos(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(2inA)print(0inA)# 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 -------# UtilizandoFiniteSet 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 importFiniteSetC=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())# Cardinalidadprint('-'*30)print("La cardinalidad del conjunto potencia del conjunto C = {0} es {1}".format(C,len(C.powerset())))# Igualdadprint('-'*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*Bprint(P)for elem inP: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**2print(P2)P3=A**3print(P3)for elem inP3: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.pyplotas 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()
Muchas gracias
Gracias por el resumen
Los mejores trabajos son aquellos que utilizan la herramienta correcta para el trabajo correcto
❤️🦄
Estos conceptos de conjuntos en Python los son buenos para practicar con clases de Matemáticas Discretas
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.
Podemos pasar de listas a tuplas asi
tupla =tuple(lista)
y de tupla a lista asi
lista =list(tupla)
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.
Casi muero con el reto.
jajaja yo también.
estuvo rebueno-dificil y me emocione cuando lo logre, genial esa sensacion!
Los sets nacen de la teoría de conjuntos. No permiten elementos duplicados.
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
POV: En la prepa pensaste que jámas usarías conjuntos en la vida real 🤡
me gusta mucho ver la teoría aplicada
Ayuda mucho al aprendizaje
Los buenos programas, son los que utilizan la herramienta correcta para el trabajo correcto.
Sets
.
!img
.
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
En la parte de 'Set para teoría de conjuntos' se han seteado listas y no sets, deben están entre {} y no entre []
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.
genial
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 inclientes: clientes.append( cliente )else:print('El cliente ya se encuentra en la lista.')def listar_cliente(): global clientes
for indice, cliente inenumerate( 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 inclientes:if cliente['nombre']== nombre_cliente:returnTrueelse:returnFalsedef _buscar_cliente_x_nombre(): global clientes
nombre_cliente =_obtener_campo_cliente('nombre')for indice, valor inenumerate( clientes ):if valor['nombre']== nombre_cliente:return indice
else:return-1def _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 =Nonewhile 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__":whileTrue:_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()ifencontrado:print('El cliente se encuentra en la lista.')else:print('El cliente no se encuentra en la lista.')listar_cliente() elif comando =='S':breakelse:print('Comando inválido.')
Mil disculpas que está todo en español, tan solo que aprovecho y genero material para mis clases.
Conjuntos o Sets
Matemáticas discretas!!!
Las tuplas se comportan similar a las listas, pero la diferencia es que son inmutables.
Los mejores trabajos son aquellos que utilizan la herramienta correcta para el trabajo correcto
alta frase
En otro curso se manejaron los conceptos muy de la mano.
