Laboratorio de Estructuras Discretas Página: 1

UNIVERSIDAD CATÓLICA DE SANTA MARÍA

ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS

Laboratorio N° 02

CONJUNTOS ORIENTADOS A RELACIONES

OBJETIVOS

Identificar los Conjuntos en Python.

Aplicar las características de los Conjuntos en la solución de problemas.
Utilizar los paquetes en Python que trabajan con Relaciones y conocer sus algoritmos

II

TEMAS A TRATAR
Conjuntos
Relaciones
Paquetes Python para relaciones

III

MARCO TEÓRICO

Un conjunto es una colección bien definida de objetos, que se denominan elementos o

miembros del conjunto. Las letras mayúsculas A, B, X, Y, . . . , denotan conjuntos y
las minúsculas a, b, x, y, . . . , denotan elementos de conjuntos. Algunos sinónimos
de “conjunto” son “clase”, “colección” y “familia”. La pertenencia a un conjunto se
denota: a ∈ S denota que a pertenece al conjunto S. a, b ∈ S denota que a y b
pertenecen al conjunto S. Aquí ∈ es el símbolo para indicar “es un elementos de” y ∉
significa “no es un elemento de”.
Ej.
A = {1, 3, 5, 7, 9} y B = {x | x es un entero par, x > 0}
Es decir, A consta de los elementos 1, 3, 5, 7, 9. El segundo conjunto se lee: B es el
conjunto de x tal que x es un entero par y x es mayor que 0, denota el conjunto B,

Carlo Corrales Delgado - Karim Guevara Puente de la Vega Lab. 02

Laboratorio de Estructuras Discretas Página: 2

cuyos elementos son los enteros pares positivos. Observe que para denotar un miembro
del conjunto se usa una letra, casi siempre x; la recta vertical | se lee “tal que” y la
coma “y”.

Mas Ejemplos:
El conjunto A anterior también se escribe como A = {x | x es un entero positivo impar,
x < 10}.
Aunque no es posible listar todos los elementos del conjunto B anterior, a este
conjunto se le especifica como B = {2, 4, 6, . . .} donde se supone que todo mundo lo
entiende. Observe que 8 ∈ B, pero 3 ∉ B.

1. SUBCONJUNTOS

Suponga que todo elemento de un conjunto A también es un elemento de un conjunto

B; es decir, si a ∈ A implica que a ∈ B. Entonces se dice que A es un subconjunto de
B. También se dice que A está contenido en B o que B contiene a A. Esta relación se
escribeA ⊆ B o B ⊇ A
Dos conjuntos son iguales si ambos tienen los mismos elementos o, equivalentemente,
si cada uno está contenido en el otro. Es decir:A = B si y sólo si A ⊆ B y B ⊆ A
Si A no es un subconjunto de B , porque al menos un elemento de A no pertenece a
B— se escribe A ⊈ B.
Ej.
A = {1, 3, 4, 7, 8, 9}, B = {1, 2, 3, 4, 5}, C = {1, 3}.Entonces C ⊆ A y C ⊆ B, ya que
1 y 3, los elementos de C, también son miembros de A y B. Pero B ⊈ A, puesto que
algunos elementos de B, por ejemplo, 2 y 5, no pertenecen a A. En forma semejante, A
⊈ B.

2. OPERACIONES CON CONJUNTOS

Se presentan varias operaciones con conjuntos, como son las operaciones básicas de
unión, intersección y complemento.

2.1 Unión e intersección:

La unión de dos conjuntos A y B, que se denota por A ∪ B, es el conjunto de todos los
elementos que pertenecen a A o a B; es decir, A ∪ B = {x | x ∈ A o x ∈ B}
Aquí “o” se usa en el sentido incluyente de y/o.
La figura 1a) es un diagrama de Venn en el que A ∪ B está sombreada.

La intersección de dos conjuntos A y B, que se denota por A ∩ B , es el conjunto de

los elementos que pertenecen tanto a A como a B; es decir,A ∩ B = {x | x ∈ A y x ∈
B}
La figura 1b) es un diagrama de Venn en el que A ∩ B está sombreada.

Carlo Corrales Delgado - Karim Guevara Puente de la Vega Lab. 02

Laboratorio de Estructuras Discretas Página: 3

FIGURA 1: Operaciones de Intersección y Unión

2.2 Complementos, diferencias y diferencias simétricas:

Recuerde que todos los conjuntos a considerar en un momento particular son subconjuntos de
un conjunto universo fijo U. El complemento absoluto o, simplemente, el complemento de un
conjunto A, denotado por AC, es el conjunto de elementos que pertenecen a U, pero que no
pertenecen a A. Es decir, AC = {x | x ∈ U, x ∉ A. }En algunos textos el complemento de A se
̅ . La figura 2a) es un diagrama de Venn en el que AC está sombreado.
denota por A’ o 𝐴
El complemento relativo de un conjunto B respecto de un conjunto A o, simplemente, la
diferencia de A y B, denotada por A\B, es el conjunto de elementos que pertenecen a A pero
que no pertenecen a B; es decir,A\B = {x | x ∈ A, x ∉ B}. El conjunto A\B se lee “A menos
B”. En muchos textos la expresión A\B aparece como A − B o como A ∼ B. La figura 2b) es
un diagrama de Venn en el que A\B está sombreada.
La diferencia simétrica de los conjuntos A y B, denotada por A ⊕ B, consta de los elementos
que pertenecen a A o a B pero no a ambos. Es decir,A ⊕ B = (A ∪ B)\(A ∩ B) o A ⊕ B =
(A\B) ∪ (B\A)
La figura 2c) es un diagrama de Venn en el que A ⊕ B está sombreada.

FiGURA 2. Operaciones Complemento, Diferencia y Diferencia Simétrica

Carlo Corrales Delgado - Karim Guevara Puente de la Vega Lab. 02

Laboratorio de Estructuras Discretas Página: 4

IV

ACTIVIDADES

1. Conjuntos en Python:

thisset = {"apple", "banana", "cherry"}

print(thisset)
for x in thisset:
print(x)

print("banana" in thisset)

{'cherry', 'banana', 'apple'}

cherry
banana
apple
True

Intercambiando items:

thisset.add("orange")
print(thisset)

thisset.update(["orange", "mango", "grapes"])

print(thisset)

{'cherry', 'banana', 'orange', 'apple'}

{'orange', 'mango', 'cherry', 'apple', 'grapes', 'banana'}

Longitud de un Conjunto:

print(len(thisset))

Eliminando un item de un conjunto:

thisset.remove("apple")
print(thisset)

thisset.discard("banana")
print(thisset)

x = thisset.pop()
print(x)

Carlo Corrales Delgado - Karim Guevara Puente de la Vega Lab. 02

Laboratorio de Estructuras Discretas Página: 5

print(thisset)

{'orange', 'mango', 'cherry', 'grapes', 'banana'}

{'orange', 'mango', 'cherry', 'grapes'}
orange
{'mango', 'cherry', 'grapes'}

Borrando elementos:

thisset.clear()
print(thisset)

del thisset
print(thisset)

set()
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-17-b99874a4d6ea> in <module>()
3
4 del thisset
----> 5 print(thisset)

NameError: name 'thisset' is not defined

Constructor de conjuntos:

thisset = set(("apple", "banana", "cherry"))

# note the double round-brackets
print(thisset)

{'cherry', 'banana', 'apple'}

Uniendo dos conjuntos:

set1 = {"a", "b" , "c"}

set2 = {1, 2, 3}

set3 = set1.union(set2)
print(set3)

set3 = {"a", "b" , "c"}

set4 = {1, 2, 3}

set3.update(set4)
print(set3)

Carlo Corrales Delgado - Karim Guevara Puente de la Vega Lab. 02

Laboratorio de Estructuras Discretas Página: 6

{1, 2, 3, 'b', 'c', 'a'}

{1, 2, 3, 'b', 'c', 'a'}

Otros Métodos en Python:

Method Description

add() Adds an element to the set

clear() Removes all the elements from the set

copy() Returns a copy of the set

difference() Returns a set containing the difference between two or more sets

difference_update() Removes the items in this set that are also included in another, specified set

discard() Remove the specified item

intersection() Returns a set, that is the intersection of two other sets

intersection_update() Removes the items in this set that are not present in other, specified set(s)

isdisjoint() Returns whether two sets have a intersection or not

issubset() Returns whether another set contains this set or not

issuperset() Returns whether this set contains another set or not

pop() Removes an element from the set

remove() Removes the specified element

symmetric_difference() Returns a set with the symmetric differences of two sets

symmetric_difference_update() inserts the symmetric differences from this set and another

union() Return a set containing the union of sets

update() Update the set with the union of this set and others

2. Relaciones en Python:

Relación de Equivalencia (como conjunto de tuplas)

relations = {(1,2), (1,3), (2,3), (2,1), (2,2), (3,2), (3,3)}

Función que chequea que una relación es Reflexiva:

def is_reflexive(relation,X):

Carlo Corrales Delgado - Karim Guevara Puente de la Vega Lab. 02

Laboratorio de Estructuras Discretas Página: 7

for i in X:
if (i,i) not in relation:
return False
return True

X = {1,2,3}
relations = {(1,2),(1,3),(2,3),(2,1),(2,2),(3,2),(3,3),(1,1),(3,1)}
print("Es reflexiva? ",is_reflexive(relations,X))

Función que chequea que una relación es Simétrica

def is_symmetric(relations):
for a,b in relations:
if (b,a) not in relations:
return False
return True

print("Es simétrica? ",is_symmetric(relations))

def is_symmetric2(relation):
# checks symmetric property: (a, b) -> (b, a)
return all(rel[::-1] in relation for rel in relation)

Función que chequea que una relación es Transitiva:

def is_transitive(relation):
for a, b in relation:
for c, d in relation:
# checks transitive property: (a, b) && (b, c) -> (a, c)
if b == c and (a,d) not in relation:
return False
return True

Función que chequea la conjunción de las dos anteriores funciones:

def check_relation(relation):
return is_symmetric(relation) and is_transitive(relation)

Las 3 funciones son probadas aquí:

relations = {(1,2), (1,3), (2,3), (2,1), (2,2), (3,2), (3,3)}

print("Is symmetric? ",is_symmetric(relations))
print("Is transitive? ",is_transitive(relations))
print("Is both? ",check_relation(relations),"\n")

Carlo Corrales Delgado - Karim Guevara Puente de la Vega Lab. 02

Laboratorio de Estructuras Discretas Página: 8

relations = {(1,2), (1,3), (2,3), (2,1), (2,2), (3,2), (3,3),(3,1)}

print("Is symmetric? ",is_symmetric(relations))
print("Is transitive? ",is_transitive(relations))
print("Is both? ",check_relation(relations),"\n")

relations = {(1,2), (1,3), (2,3), (2,1), (2,2), (3,2), (3,3),

(3,1),(1,1)}
print("Is symmetric? ",is_symmetric(relations))
print("Is transitive? ",is_transitive(relations))
print("Is both? ",check_relation(relations))

Is symmetric? False
Is transitive? False
Is both? False

Is symmetric? True
Is transitive? False
Is both? False

Is symmetric? True
Is transitive? True
Is both? True

Función que devuelve si la Relación es antisimétrica:

def is_antisymmetric(relations):
for a,b in relations:
if a==b:
continue
if (b,a) in relations:
return False
return True

rel2 = {('a','a'),('b','c'),('d','d'),('b','b'),('c','c')}
print("Es antisimétrica? ",is_antisymmetric(relations))
print("Es antisimetrica la rel2? ",is_antisymmetric(rel2))

Función que devuelve si la Relación es de orden Parcial:

def is_partialOrder(relations,X):
return is_reflexive(relations,X) and is_antisymmetric(relations) and
is_transitive(relations)

Función que devuelve la inversa de la Relación:

def inverse(relations):

Carlo Corrales Delgado - Karim Guevara Puente de la Vega Lab. 02

Laboratorio de Estructuras Discretas Página: 9

rpta = set()
for a,b in relations:
rpta.add((b,a))
return rpta

rel3 = {(1,2),(4,5)}
inv = inverse(rel3)
print("La relacion inversa es ",inv)

Composición de Funciones en Python (Uso de la función lambda):

# Function to combine two

# function which it accepts
# as argument
def composite_function(f, g):
return lambda x : f(g(x))

# Function to add 2
def add(x):
return x + 2

# Function to multiply 2
def multiply(x):
return x * 2

# Composite function returns

# a lambda function. Here add_multiply
# will store lambda x : multiply(add(x))
add_multiply = composite_function(multiply, add)

print("Adding 2 to 5 and multiplying the result with 2: ",

add_multiply(5))

Adding 2 to 5 and multiplying the result with 2: 14

Componiendo n números en funciones:

# Function to combine two

# function which it accepts
# as argument
def composite_function(f, g):

return lambda x : f(g(x))

# Function to add 2

Carlo Corrales Delgado - Karim Guevara Puente de la Vega Lab. 02

Laboratorio de Estructuras Discretas Página: 10

def add(x):
return x + 2

# Function to multiply 2
def multiply(x):
return x * 2

# Function to subtract 2
def subtract(x):
return x - 1

# Composite function returns a lambda function. Here

# add_subtract_multiply will store lambda x : multiply(subtract(add(x)))
add_subtract_multiply = composite_function(composite_function(multiply,
subtract),
add)

print("Adding 2 to 5, then subtracting 1 and multiplying the result with

2: ",
add_subtract_multiply(5))

Adding 2 to 5, then subtracting 1 and multiplying the result with 2: 12

Ahora modifiquemos nuestra funcion de composición a una que puede componer cualquier
cantidad de funciones en vez de usar las dos; usando reduce() de la librería functools.

# importing reduce() from functools

from functools import reduce

# composite_function accepts N
# number of function as an
# argument and then compose them
def composite_function(*func):

def compose(f, g):

return lambda x : f(g(x))

return reduce(compose, func, lambda x : x)

# Function to add 2
def add(x):
return x + 2

# Function to multiply 2
def multiply(x):
return x * 2

# Function to subtract 2
def subtract(x):

Carlo Corrales Delgado - Karim Guevara Puente de la Vega Lab. 02

Laboratorio de Estructuras Discretas Página: 11

return x - 1

# Here add_subtract_multiply will

# store lambda x : multiply(subtract(add(x)))
add_subtract_multiply = composite_function(multiply, subtract, add)

print("Adding 2 to 5, then subtracting 1 and multiplying the result with

2: ",
add_subtract_multiply(5))

Adding 2 to 5, then subtracting 1 and multiplying the result with 2: 12

3. Uso de paquetes para relaciones en Python:

Calculando la Cerradura transitiva Sparse de una matriz sparsa scipy

import numpy as np
import networkx as nx
import scipy.stats as stats
import scipy.sparse as sparse

A = sparse.random(6, 6, density=0.2, format='csr',

data_rvs=stats.randint(1, 2).rvs).astype(np.uint8)
G = nx.DiGraph(A) # directed because A need not be symmetric
paths = nx.all_pairs_shortest_path_length(G)
indices = []
indptr = [0]
for row in paths:
reachable = [v for v in row[1] if row[1][v] > 0]
indices.extend(reachable)
indptr.append(len(indices))
print(indices)
print("indptr: ",indptr)

data = np.ones((len(indices),), dtype=np.uint8)

print("data: ",data)
A_trans = A + sparse.csr_matrix((data, indices, indptr), shape=A.shape)
print("A: \n", A, "\nA_trans: \n", A_trans)

[]
[4, 0, 5]
[4, 0, 5]
[4, 0, 5, 0]
[4, 0, 5, 0, 0, 5]
[4, 0, 5, 0, 0, 5, 0]
indptr: [0, 0, 3, 3, 4, 6, 7]
data: [1 1 1 1 1 1 1]
A:
(1, 1) 1

Carlo Corrales Delgado - Karim Guevara Puente de la Vega Lab. 02

Laboratorio de Estructuras Discretas Página: 12

(1, 4) 1
(3, 0) 1
(4, 0) 1
(4, 5) 1
(5, 0) 1
(5, 5) 1
A_trans:
(1, 5) 1
(1, 0) 1
(1, 4) 2
(1, 1) 1
(3, 0) 2
(4, 5) 2
(4, 0) 2
(5, 5) 1
(5, 0) 2

Transitiva y Reflexiva:

for row in paths:

indices.extend(row[1])
indptr.append(len(indices))
data = np.ones((len(indices),), dtype=np.uint8)
A_trans = sparse.csr_matrix((data, indices, indptr), shape=A.shape)
print(A, "\n\n", A_trans)

(1, 1) 1
(1, 4) 1
(3, 0) 1
(4, 0) 1
(4, 5) 1
(5, 0) 1
(5, 5) 1

(1, 4) 1
(1, 0) 1
(1, 5) 1
(3, 0) 1
(4, 0) 1
(4, 5) 1
(5, 0) 1

Transitiva, Reflexiva y Simétrica

import numpy as np
import scipy.stats as stats
import scipy.sparse as sparse
import itertools

A = sparse.random(20, 20, density=0.02, format='csr',

data_rvs=stats.randint(1, 2).rvs).astype(np.uint8)
components = sparse.csgraph.connected_components(A, directed=False)

Carlo Corrales Delgado - Karim Guevara Puente de la Vega Lab. 02

Laboratorio de Estructuras Discretas Página: 13

nonzeros = []
for k in range(components[0]):
idx = np.where(components[1] == k)[0]
nonzeros.extend(itertools.product(idx, idx))
row = tuple(r for r, c in nonzeros)
col = tuple(c for r, c in nonzeros)
data = np.ones_like(row)
B = sparse.coo_matrix((data, (row, col)), shape=A.shape)
print(B, "\n\n")
print(B.toarray())

(0, 0) 1
(1, 1) 1
(2, 2) 1
(3, 3) 1
(4, 4) 1
(4, 11) 1
(11, 4) 1
(11, 11) 1
(5, 5) 1
(5, 6) 1
(5, 7) 1
(5, 9) 1
(5, 13) 1
(5, 14) 1
(6, 5) 1
(6, 6) 1
(6, 7) 1
(6, 9) 1
(6, 13) 1
(6, 14) 1
(7, 5) 1
(7, 6) 1
(7, 7) 1
(7, 9) 1
(7, 13) 1
: :
(9, 9) 1
(9, 13) 1
(9, 14) 1
(13, 5) 1
(13, 6) 1
(13, 7) 1
(13, 9) 1
(13, 13) 1
(13, 14) 1
(14, 5) 1
(14, 6) 1
(14, 7) 1
(14, 9) 1
(14, 13) 1
(14, 14) 1
(8, 8) 1
(10, 10) 1
(10, 18) 1
(18, 10) 1
(18, 18) 1

Carlo Corrales Delgado - Karim Guevara Puente de la Vega Lab. 02

Laboratorio de Estructuras Discretas Página: 14

(12, 12) 1
(15, 15) 1
(16, 16) 1
(17, 17) 1
(19, 19) 1

[[1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0]
[0 0 0 0 0 1 1 1 0 1 0 0 0 1 1 0 0 0 0 0]
[0 0 0 0 0 1 1 1 0 1 0 0 0 1 1 0 0 0 0 0]
[0 0 0 0 0 1 1 1 0 1 0 0 0 1 1 0 0 0 0 0]
[0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 1 1 1 0 1 0 0 0 1 1 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0]
[0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0]
[0 0 0 0 0 1 1 1 0 1 0 0 0 1 1 0 0 0 0 0]
[0 0 0 0 0 1 1 1 0 1 0 0 0 1 1 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0]
[0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1]]

EJERCICIOS

1. Conjuntos:

a) Los conjuntos son listas sin entradas duplicadas. Supongamos que quieres
recopilar una lista de palabras usadas en un párrafo;

print(set("my name is Eric and Eric is my name".split()))

Esto imprimirá una lista que contiene "my", "name", "is" "Eric", y finalmente "and".
Como el resto de la frase usa palabras que ya están en nuestro conjunto, no se
incluyen una segunda vez.

Escribe un ejemplo donde una variable sea igual a un texto de una poesia completa, y
cuenta cuantas palabras diferentes contiene.

b) Los conjuntos son una poderosa herramienta en Python dado que tienen la
habilidad de calcular diferencias e intersecciones entre otros conjuntos. Por
ejemplo, pongamos que tienes una lista de participantes en los eventos A y B:

Carlo Corrales Delgado - Karim Guevara Puente de la Vega Lab. 02

Laboratorio de Estructuras Discretas Página: 15

a = set(["Jake", "John", "Eric"])

print(a)
b = set(["John", "Jill"])
print(b)

Define conjuntos de datos de tipo Booleanos, Enteros y nros Reales.

c) Para buscar que miembros asistirán a los dos eventos, debemos usar el
método "intersection":

a = set(["Jake", "John", "Eric"])

b = set(["John", "Jill"])

print(a.intersection(b))
print(b.intersection(a))

Escribe un par de ejemplos donde muestres la intersección de 2 conjunto vacia, y un

par de ejemplos donde muestres la intersección de 2 conjuntos a y b donde el
resultado sea todo el conjunto a.

d) Para buscar que miembros asistirán solo a uno de los eventos, usaremos el
método "symmetric_difference":

a = set(["Jake", "John", "Eric"])

b = set(["John", "Jill"])

print(a.symmetric_difference(b))
print(b.symmetric_difference(a))

Ejemplifica dos conjuntos que representen la asistencia a clases de Estructuras

Discretas los días Martes y Miercoles, y muestra qué alumnos solo asistieron a uno de
los dos dias.

e) Para buscar que miembros asistirán a un evento y no al otro, usaremos el

método "difference":

a = set(["Jake", "John", "Eric"])

b = set(["John", "Jill"])

print(a.difference(b))
print(b.difference(a))

Continua con el ejemplo de asistencia a Estructuras Discretas y ahora muestra qué

alumnos asistieron solo al dia Martes y no al Miércoles.

Carlo Corrales Delgado - Karim Guevara Puente de la Vega Lab. 02

Laboratorio de Estructuras Discretas Página: 16

f) Para obtener una lista de todos los participantes, usaremos el método "union":

a = set(["Jake", "John", "Eric"])

b = set(["John", "Jill"])

print(a.union(b))

En el mismo ejemplo muestra qué alumnos asistieron al menos a uno de los dos días
de clases.

g) En el siguiente ejercicio, usaremos las listas a y b para imprimir un conjunto

que contenga todos los participantes del evento A que no vayan a asistir al
evento B.

a = ["Jake", "John", "Eric"]

b = ["John", "Jill"]

h) Crea un conjunto a partir de un string. Los caracteres repetidos se eliminan

>>> a = set('Hola Pythonista')
>>> a
{'a', 'H', 'h', 'y', 'n', 's', 'P', 't', ' ', 'i', 'l', 'o'}

i) Crea un conjunto a partir de una lista. Los elementos repetidos de la lista se

eliminan
>>> unicos = set([3, 5, 6, 1, 5])
>>> unicos
{1, 3, 5, 6}

j) Confirma que para crear un conjunto vacío, simplemente llama al

constructor set() sin parámetros.

k) set vs frozenset: En realidad, en Python existen dos clases para representar

conjuntos: set y frozenset. La principal diferencia es que set es mutable, por lo
que después de ser creado, se pueden añadir y/o eliminar elementos del
conjunto. Por su parte, frozenset es inmutable y su contenido no puede ser
modificado una vez que ha sido inicializado. Para crear un conjunto de
tipo frozenset, se usa el constructor de la clase frozenset() :
>>> f = frozenset([3, 5, 6, 1, 5])
>>> f
frozenset({1, 3, 5, 6})

l) Dado que los conjuntos son colecciones desordenadas, en ellos no se guarda

la posición en la que son insertados los elementos como ocurre en los
tipos list o tuple. Es por ello que no se puede acceder a los elementos a través
de un índice. Sin embargo, sí se puede acceder y/o recorrer todos los
elementos de un conjunto usando un bucle for:

Carlo Corrales Delgado - Karim Guevara Puente de la Vega Lab. 02

Laboratorio de Estructuras Discretas Página: 17

>>> mi_conjunto = {1, 3, 2, 9, 3, 1}

>>> for e in mi_conjunto:
... print(e)

1
2
3
9

Verifica si siempre aparecen los elementos de un conjunto en el mismo órden.

m) Prueba añadir elementos a un conjunto con el método add() . También prueba el

método update() , que puede tomar como argumento una lista, tupla,
string, conjunto o cualquier objeto de tipo iterable.

n) Prueba eliminar elementos de un conjunto a través de estos 4 métodos:

discard() , remove() , pop() y clear() .

y remove(elemento) eliminan elemento del conjunto. La única

discard(elemento)
diferencia es que si elemento no existe, discard() no hace nada mientras
que remove() lanza la excepción KeyError .
pop() es un tanto peculiar. Este método devuelve un elemento aleatorio del
conjunto y lo elimina del mismo. Si el conjunto está vacío, lanza la
excepción KeyError . Finalmente, clear() elimina todos los elementos contenidos en
el conjunto.

o) Para saber si un elemento pertenece a un conjunto se usa el operador de

pertenencia in :
>>> mi_conjunto = set([1, 2, 5, 3, 1, 5])
>>> print(1 in mi_conjunto)
True
>>> print(6 in mi_conjunto)
False
>>> print(2 not in mi_conjunto)
False
Prueba con un ejemplo donde un conjunto tiene los meses del año. Verifica si
alguno de los meses pertenece e inventa un valor de un mes inexistente para
probarlo.

p) Prueba con ejemplos el operador union | para realizar la unión de dos o más
conjuntos. ¿Funciona? >>> a | b.

q) Prueba con ejemplos el operador & para realizar la intersección de dos

conjuntos. ¿Funciona? >>> a & b

Carlo Corrales Delgado - Karim Guevara Puente de la Vega Lab. 02

Laboratorio de Estructuras Discretas Página: 18

r) Prueba el operador - para realizar la diferencia de dos o más conjuntos.

¿Funciona? >>> a - b

s) Prueba el operador ^ para realizar la diferencia simétrica de dos o más

conjuntos. ¿Funciona? a ^ b

t) En Python se utiliza el operador <= para comprobar si un conjunto A es

subconjunto de B y el operador >= para comprobar si un conjunto A es
superconjunto de B. Pruebalos.

u) ¿Cómo comparas la igualdad de dos conjuntos? Ejemplifica

v) Ejemplifica las funciones max() y min() si es que trabajan para conjuntos.

Prueba conjuntos numéricos y alfanuméricos.

2. Relaciones:

2.1 Implemente una Relación de Composición R2cR1 que se define así: Sea R1 una relación
de X a Y y R2 una relación de Y a Z. La composición de R1 y R2, denotada por R2cR1, es la
relación de X a Z definida por R2 c R1 ={(x, z) | (x, y) ∈ R1 y (y, z) ∈ R2 para alguna y ∈ Y}. La
composición de las relaciones R1 = {(1, 2), (1, 6), (2, 4), (3, 4), (3, 6), (3, 8)} y R2 = {(2, u), (4,
s), (4, t), (6, t), (8, u)} es:

R2 cR1 = {(1,u),(1,t),(2,s),(2,t),(3,s),(3,t),(3,u)}

VI

BIBLIOGRAFÍA Y MATERIAL DE REFERENCIA

• Aguilera, N. Matemáticas y programación con Python. 2014.

• Seymur Lipchup. Matemática Discreta.
• Tutorial de Python 3.6.3 Documentation. Disponible en:
https://tutorial.python.org.ar/en/latest/

Carlo Corrales Delgado - Karim Guevara Puente de la Vega Lab. 02