Tuplas y Sets en Python: Uso y Manipulación Práctica

Operadores para sets en Python:

>>> A = {1, 2, 3}	# conjunto A
>>> B = {3, 4 ,5}	# conjunto B
>>> A | B		#unión
{1, 2, 3, 4, 5}
>>> A & B	# intersección
{3}
>>> A - B		# diferencia entre A y B
{1, 2}
>>> B - A		# diferencia entre B y A
{4, 5}

Declaracion de tuplas
a= 1,2,3
a=(1,2,3)
Operaciones con tuplas:
Acceder a un valor mediante indice de tupla
a[0]=1
Conteo de cuantas veces está un valor en la tupla
a.count(1)—>1

Declaración conjutos o Sets
a= set([1,2,3])
a={1,2,3}
Operaciones con conjuntos:

• NO se puede acceder a un valor mediante índice
• NO se puede agregar un valor ya existente, por ejemplo
  Agregar un valor a conjunto
  a.add(1)—> error!! (valor existente en set)
  a.add(20)—> a={1,2,3,20}

Tenemos:
a={1,2,3,20}
b={3,4,5}
a.intersection(b)–> {3} (elementos en común)
a.union(b)—>{1,2,3,20,4,5} (elementos de a + b pero sin repetir ninguno)
a.difference(b)–>{1,2,20} (elementos de a que no se encuentran en b)
b.difference(a)–>{4,5} (elementos de b que no se encuentran en a)

"""
------ 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()

Creo que sería buena idea ir haciendo perqueños proyectos
en cada clase, simplemente para facilitar un tema en específico.

Un dato interesante.

Para realizar la suma de 2 conjuntos podemos utilizar " | ". Ej:

a = {1,2,3}
b = {3,4,5}

c = a | b

print(c)

{1,2,3,4,5}

Set o conjuntos

Podemos determinar si un numero esta dentro de un conjunto

2 in [1,2,3]
True

otra forma de hacer union es:

a | b

intersección

a  &  b

diferencia

a - b

Excelente clase, la propiedad de set de no repetir valores es muy importante y se puede usar para eliminar los valores repetidos de una lista de una manera muy simple:

>>>a=[1,2,3,2,3,4,5,6,7,3,2,3,4,3,5,6,3,2,1,4]
>>>list(set(a))
[1,2,3,4,5,6,7]

Documentación: https://docs.python.org/3/library/stdtypes.html?highlight=tuple#tuple

Métodos en los conjuntos:

• add(e): Añade un elemento al conjunto.
• clear(): Elimina todos los elementos del conjunto.
• copy(): Devuelve una copia superficial del conjunto.
• difference(iterable): Devuelve la diferencia del conjunto con el iterable como un conjunto nuevo.
• difference_update(iterable): Actualiza el conjunto tras realizar la diferencia con el iterable.
• discard(e): Elimina, si existe, el elemento del conjunto.
• intersection(iterable): Devuelve la intersección del conjunto con el iterable como un conjunto nuevo.
• intersection_update(iterable): Actualiza el conjunto tras realizar la intersección con el iterable.
• isdisjoint(iterable): Devuelve True si dos conjuntos son disjuntos.
• issubset(iterable): Devuelve True si el conjunto es subconjunto del iterable.
• issuperset(iterable): Devuelve True si el conjunto es superconjunto del iterable.
• pop(): Obtiene y elimina un elemento de forma aleatoria del conjunto.
• remove(e): Elimina el elemento del conjunto. Si no existe lanza un error.
• symmetric_difference(iterable): Devuelve la diferencia simétrica del conjunto con el iterable como un conjunto nuevo.
• symmetric_difference_update(iterable): Actualiza el conjunto tras realizar la diferencia simétrica con el iterable.
• union(iterable): Devuelve la unión del conjunto con el iterable como un conjunto nuevo.
• update(iterable): Actualiza el conjunto tras realizar la unión con el iterable.

si una estructura se dice que es inmutable significa que sus valores, los ítem de la misma, no pueden ser modificados, pero se puede modificar todo el valor de la estructura con una asignación.

Me gusto esta clase En el curso anterior no se hablo de los métodos de las tuplas, pero en esta actulización si

(a.union(b)).difference(a.intersection(b)): diferencia simétrica

No tenía idea que existieran los conjuntos en python. ¡Excelente clase!

#TUPLA
#No se puede modificar, si permite duplicados
a=1,2,3,4
a=(1,2,3,4,)
#SET
#No tienen un orden implicito, no permite duplicados
a=set([1,2,3])
b={3,4,5}

#Para mostrar los elementos repetidos
a.intersection(b)
#Para mostrar todos unidos
a.union(b)
#Para mostrar los elementos diferentes 
a.difference(b)
#eliminar alguno
a.remove(20)
#Ahi se elimino el 20

Python 3.7.3 (default, Mar 27 2019, 17:13:21) [MSC v.1915 64 bit (AMD64)] :: Anaconda, Inc. on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> a=1,2,3
>>> b=[1,2,3]
>>> c={1,2,3}
>>> d={}
>>> d["pizza"]="es lo mas chido"
>>> type(a)
<class 'tuple'>
>>> type(b)
<class 'list'>
>>> type(c)
<class 'set'>
>>> type(d)
<class 'dict'>
>>>```

Cuando agregas el valor 20 en los dos ‘sets’ ordena el numero en direfentes posiciones porque pasa esto ?, entiendo que los Sets -> no tienen un orden

b = set([1,2,3])
b1 = {3,4,5}

print(type(b))
print(type(b1))

b.add(20)
b1.add(20)
print(b, b1)

en la prepa esta clase estaría increíble para lógica y desde luego en mate de secundaria!!!

Python para todes!!!

¿Como ahí que?

tupla
las uplas no se pueden reasignar sus elementos son inmutables

a = 1,2,3,4

a = (1,2,3,4)

a[0]

out - 1

metods de tuple 

count = cuantas veces aparece el elemento
index = el indice de la primera instancia donde aparece un elemento

sets

los set reciben un iterable

a = set([1,2,3])

b ={3,4,5}

a.add(65) agrega el valor 65

a.interseccion(b) que elementos tienen en comun las listas

a.union(b) la union de ambas listas

a difference(b) lo que hay en a pero no en b

a.remove(20) eliminar un valor

metodos de un set ‘add’,
‘clear’,
‘copy’,
‘difference’,
‘difference_update’,
‘discard’,
‘intersection’,
‘intersection_update’,
‘isdisjoint’,
‘issubset’,
‘issuperset’,
‘pop’,
‘remove’,
‘symmetric_difference’,
‘symmetric_difference_update’,
‘union’,
‘update’

Comparación de Colecciones:

https://drive.google.com/open?id=1Z-JiKNXhJnyzNCWDmwggTSrzXeFIPBqN

tuplas

set o conjuntos

Buena clase, mas que todo para el tema de duplicados.

SET Para menejar conjuntos, mira …:

a
{1, 2, 3, 4, 5}
b
{4, 5, 6, 7}
Se puede hacer operaciones lógicas mezclando los operadores.:
Ejm. ((a ^ b) | (a ^ b)) | (a & b)
Esto da como resultado {1, 2, 3, 4, 5, 6, 7} …prueba …!
Mira como operan .:

Puedes tener n conjuntos de SET, y operar entre los distintos conjuntos (ejm. a, b, c, d, e, f, …), y los resultados los puedes operar con otro conjunto, o con el resultado de otra operación, y asi …los puedes llagar a mezclar de esta manera.:
Ejm. ((a ^ b) | (a ^ b)) | (a & b) & c
OPERADORES.: {operador: significado}
| => Simbolo Pipe, Unión de a y b Menos los Repetidos.
Ejm, a | b ===> {1, 2, 3, 4, 5, 6, 7} - {4, 5}

^ => Simbolo de Potencia, Unión de a y b Menos la Inrsección.
Ejm. a ^ b ===> {1, 2, 3, 6, 7} - {5, 6}

& > Ampersand, Intersección de a y b.
Ejm. a & b ===> {4, 5}

SALUDOS …!

Podemos declarar sets de la forma:

a = set([1, 2, 3])
b = {3, 4, 5}

Si tratamos de hacer: a.add(3) no funcionará porque los sets no pueden tener valores repetidos, en este caso sí podemos hacer, por ejemplo a.add(20).

A = {1, 2, 3} # conjunto A
B = {3, 4 ,5} # conjunto B
A | B #unión
{1, 2, 3, 4, 5}
A & B # intersección
{3}
A - B # diferencia entre A y B
{1, 2}
B - A # diferencia entre B y A
{4, 5}

Documentación para sets

Más documentación para sets

excelente clase

Excelente explicación, la verdad el profesor David enseña increible !
mucho mejor que en mi universidad jeje! Saludos!!!

Genial!!

funcion con tupla
interacion de tupla

Python 3.7.3 (default, Mar 27 2019, 17:13:21) [MSC v.1915 64 bit (AMD64)] :: Anaconda, Inc. on win32
Type “help”, “copyright”, “credits” or “license” for more information.

a=1,2,3
b=[1,2,3]
c={1,2,3}
d={}
d[“pizza”]="es lo mas chido"
type(a)
<class ‘tuple’>

type(b)
<class ‘list’>

type©
<class ‘set’>

type(d)
<class ‘dict’>

Los mètodos permiten trabajar con más de 2 conjuntos aquí un ejemplo.

cual es la diferencia entre append y add?

Excelente clase vamos practicando

En la ultima version de python el ingresar datos en un set, cambia?
Porque nose si lo hice mal pero si me dejo.

" The Python Standard Library - Set "

https://docs.python.org/3.8/library/stdtypes.html#set-types-set-frozenset

Remover un elemento que no se encuentre en el conjunto da un KeyError

Los sets no tienen un orden implícito, por lo que no hay tenemos un índice.Pero podemos saber que tiene por dentro.

Tenemos la forma literal: s = {1,2,3,4} y la forma funcional s = set([1,2,3,4])

.count() para contar el número que tengamos dentro de la tupla, e index() nos indica la primera aparición del objeto en la tupla.

.count() para contar el número que tengamos dentro de la tupla, e index() nos indica la primera aparición del objeto en la tupla.

Los programadores, estamos en un juego de utilizar los métodos que tenemos a la mano y de asignarles significado a esos compútos.

Las tuplas también tienen índices.

Enfoque: En esta clase practicaremos en código lo aprendido en la clase anterior sobre tuplas(tuples) y conjuntos(sets) para que sea mucho más claro entenderlo.

• count(), Es un metodo de tuplas que recibe un valor y retorna el numero de veces encontradas dentro de la tupla

• index(), Retorna el index de un objeto dentro de una tupla

• add(), Recibe un objeto como parametro y lo agrega al conjunto de set

• intersection(), Recibbe como parametro un objeto y ese lo retorna en el caso de que sea interseccion

• difference(), Recibe como parametro un set y retornara todos los elementos que no se encuentren en entre las tuplas, es decir la diferencia

si lo importante es practicar

>>> a = set([1,2,3])
>>> b = {3,4,5]
  File "<stdin>", line 1
    b = {3,4,5]
              ^
SyntaxError: closing parenthesis ']' does not match opening parenthesis '{'
>>> b = {3,4,5}
>>> type(a)
<class 'set'>
>>> type(b)
<class 'set'>
>>> a
{1, 2, 3}
>>> b
{3, 4, 5}
>>> dir(a)
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
>>> a.add(2)
>>> a
{1, 2, 3}
>>> a.add(2)
>>> a
{1, 2, 3}
>>> a.add(22)
>>> a
{1, 2, 3, 22}
>>> a.intersection(b)
{3}
>>> a.union(b)
{1, 2, 3, 4, 5, 22}
>>> a.difference(b)
{1, 2, 22}
>>> b.difference(a)
{4, 5}
>>> a.remove(22)
>>> a
{1, 2, 3}
>>> 
KeyboardInterrupt
>>> 

Comparto un video para complementar los SETS

.