UNIVERSIDAD AUSTRAL DE CHILE

SEDE PUERTO MONTT

INGENIERÍA CIVIL INDUSTRIAL

Módulos y librerı́as de Python

TIyP 002

Docente
Yordan Aguilar Ruiz
Índice general

1. Introducción a módulos y librerı́as en Python 1

1.1. Módulos en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2. Paquetes, bibliotecas o librerı́as de Python . . . . . . . . . . . . . . . . . . . 5
1.3. Módulo Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.4. Módulo Random . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.5. Módulo Statistics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.6. Módulo Datetime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2. Módulos y librerı́as para el análisis y la organización de datos 18

2.1. Librerı́a Sympy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.1.1. Polinomios y expresiones algebraicas . . . . . . . . . . . . . . . . . . 19
2.1.2. Ecuaciones, inecuaciones y sistemas . . . . . . . . . . . . . . . . . . 21
2.1.3. Cálculo y funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.1.4. Matrices y determinantes . . . . . . . . . . . . . . . . . . . . . . . . 24
2.2. Librerı́a Numpy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.2.1. Arreglos de una dimensión o vectores . . . . . . . . . . . . . . . . . . 27
2.2.2. Arreglos de dos dimensiones o matrices . . . . . . . . . . . . . . . . 31
2.3. Librerı́a Pandas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.3.1. Series y DataFrames . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.3.2. Extracción y modificación de datos . . . . . . . . . . . . . . . . . . . 36
2.3.3. Crear y modificar filas y columnas . . . . . . . . . . . . . . . . . . . 37
2.3.4. Cargar y guardar datos en un Pandas . . . . . . . . . . . . . . . . . 37

3. Introducción a la visualización de datos en Python 39

3.1. Gráficos cartesianos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.2. Gráfica de puntos, segmentos y vectores . . . . . . . . . . . . . . . . . . . . 43
3.3. Gráfica de funciones en R2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.4. Gráficos estadı́sticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.5. Procesamiento de imágenes . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

4. Estrategias para la programación eficiente 58

Capı́tulo 1

Introducción a módulos y librerı́as

en Python

En el transcurso del curso anterior, sentamos los cimientos esenciales para la creación de
programas en Python, permitiéndonos abordar principalmente proyectos de sencilla y me-
diana complejidad con destreza. En esta nueva etapa, nos embarcaremos en la exploración
de un concepto central y fundamental: la modularidad. Este principio no solo amplı́a
nuestra comprensión del lenguaje, sino que también nos capacita para fragmentar nuestros
programas en unidades más simples y manejables, brindándonos la capacidad de desglosar
la complejidad, facilitando ası́ la resolución de problemas y la gestión eficiente del código.

A lo largo de este curso, nos sumergiremos en el estudio y aplicación práctica de la modu-

laridad. Aprenderemos a diseñar y desarrollar componentes independientes, cada uno en-
cargado de una tarea especı́fica, para luego integrarlos de manera sinérgica en un conjunto
armonioso. Este enfoque nos permitirá no solo comprender mejor la estructura de nuestros
programas, sino también mejorar la legibilidad, mantenibilidad y escalabilidad de nuestro
código. Estamos emocionados por explorar este concepto crucial que transformará nuestra
manera de abordar la programación y elevará nuestras habilidades a un nivel superior.

1.1. Módulos en Python

En Python, un módulo es simplemente un archivo que contiene definiciones y declaracio-
nes de Python. Estas pueden incluir funciones, clases y variables, ası́ como instrucciones
ejecutables. La idea detrás de los módulos es organizar el código en archivos separados para
facilitar la escritura y la reutilización del código.

En términos prácticos, un módulo corresponde a un archivo con extensión .py que se es-
cribe a parte del fichero principal y que se llama a este último por medio de instrucciones
especı́ficas del lenguaje. La idea de estos archivos es que contengan estructuras individuales,
como variables, funciones o clases.

Se recomienda tener un modulo para funciones y un módulo para cada clase. Podemos
añadir también otros módulos que almacenen variables/constantes o bases de datos. Es una
buena práctica crear carpetas en el directorio principal donde se almacenen estos módulos
para tener todo más organizado.
1.1 Módulos en Python 2

Veamos un ejemplo. Creemos un fichero llamado programa principal y 3 módulos a parte,

uno que contenga a la clase cliente, otro que tenga una base de datos con productos de un
supermercado y otro con algunas funciones especı́ficas.

Programa principal
>> # Este es el módulo principal. Vacı́o por el momento.

Módulo Clase Cliente

>> class Cliente:
>> def init (self, nombre, apellido, dinero):
>> self.nombre = nombre
>> self.apellido = apellido
>> self.monto = dinero

>> def comprar(self, id, cantidad)

>> print(f”Usted ha comprado cantidad unidades de id[0]”)
>> self.monto -= id[1]
>> self. boleta(id,cantidad)

>> def boleta(self, id, cantidad):

>> print()
>> print(”- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -”)
>> print(”Supermercado Santa Isabel”)
>> print(”Dirección: Av. Cardenal Caro 1771, Conchalı́, Rg Metropolitana.”)
>> print(”Fecha: 29 de diciembre del 2023”)
>> print(”- - - - - - - - - -”)
>> print(f”Producto: id[0]”)
>> precio = id[1]*cantidad
>> print(f”Precio: precio”)
>> print(”- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -”)

Módulo Base de datos

>> Bebestibles = {001:[”Coca cola”, 2000], 002:[”Fanta”, 2000], 003:[”Sprite”, 2000],
>> 004:[”Pack cerveza”,7400], 005:[”Jugo”, 1500]}

>> Lácteos = {006:[”Leche”, 980], 007:[”Huevos”, 2500], 008:[”Yoghurt”, 260],

>> 009:[”Mantequilla”,1850]}

>> Snack = {010:[”Papas fritas”, 1300], 011:[”Ramitas”, 1700], 012:[”Doritos”, 2000],

>> 013:[”Cheetos”,2000]}

Módulo Funciones
>> def productos(base):
>> print(base.bebestibles)
>> print(base.lacteos)
>> print(base.snack)

>> def tipo prod(base, tipo):

>> if tipo == 1:
1.1 Módulos en Python 3

>> print(base.bebestibles)
>> elif tipo == 2:
>> print(base.lacteos)
>> else tipo == 3:
>> print(base.snack)

¿Cómo llamamos un módulo al programa principal?

Para llamar módulos al programa principal debemos utilizar el método import. Esta fun-
ción traerá el módulo indicado y nos permitirá utilizar todo el código que tiene escrito. La
sintáxsis es:
import nombre módulo
Si los módulos están dentro de carpetas, debemos indicar la ruta. Para ello, escribimos lo
siguiente:
import nombre carpeta.nombre módulo
Una vez que hacemos esto, somos capaces de utilizar todas las clases, funciones y variables
que definimos en los módulos. Sin embargo, para utilizarlos debemos cargarlos con ayuda
del nombre del módulo, de la siguiente forma:
modulo.variable modulo.función(...) modulo.Clase(...)
Esto indica que, siempre que queramos utilizar los elementos d eun módulo, debemos ante-
poner a la variable, función o clase el nombre de dicho módulo seguido de un punto.

Programa principal
>> import Clase cliente
>> import Base de datos
>> import Funciones

>> daniel = Clase Cliente.Cliente(”Daniel”, ”Varas”, 25000)

>> Funciones.productos(Base de datos)
>> daniel.comprar(Base de datos.Lácteos[007],2)

Aquı́, hemos traı́do los tres módulos al programa principal. Hemos creado un cliente llama-
do Daniel, hemos invocado la función productos para ver todos los productos disponibles y
hemos comprado uno de la sección de lácteos con el código de identificación 007.

Notemos lo incómodo que es llamar elementos de un módulo utilizando recurrentemente su

nombre. Más aún se complica cuando los nombres son largos y difı́ciles de recordar. Para
facilitar esto es que veremos a continuación la sintáxis para renombrarlos y simplificar
nuestro programa.
import nombre módulo as nuevo nombre
Veamos un ejemplo para comprender mejor esta sentencia:

Programa principal
>> import Clase cliente as cc
>> import Base de datos as bd
>> import Funciones as f

>> daniel = cc.Cliente(”Daniel”, ”Varas”, 25000)

1.1 Módulos en Python 4

>> f.productos(bd)
>> daniel.comprar(bd.Lácteos[007],2)

Observación. Una cosa importante que tenemos que tener en cuenta es que, para cargar
un módulo al programa principal, debemos primero hacerlo correr en su propio fichero. Si
no hacemos esto, es posible que tengamos errores por que el módulo no ha sido cargado.

¿Cómo traemos elementos y módulos especı́ficos al programa principal?

Muchas veces necesitamos utilizar solo algunos elementos (variables, funciones, clases) de
un módulo determinado. Para hacer esto, utilizaremos la siguiente sintáxis:

from nombre módulo import var, funct, class, ...

Podemos renombrar cada uno de los elementos que traemos al programa utilizando la sen-
tencia especial as.

from nombre módulo import var as new name

Si necesitamos importar todos los elementos del módulo, podemos utilizar un asterı́sco en
reemplazo de los elementos que traeremos al programa principal.

from nombre módulo import *

La idea de esto es que ya no necesitaremos anteponer el nombre del módulo del que prece-
de la variable/función/clase, pues lo hemos traı́do al programa principal y somos libres de
utilizarlas como si ahı́ estuviesen definidas.
Aunque esto facilita bastante la programación, no es una práctica recomendada, pues no es
eficiente traer cosas que no necesitaremos.

Programa principal
>> from Clase cliente import *
>> from Base de datos import *
>> from Funciones import *

>> daniel = Cliente(”Daniel”, ”Varas”, 25000)

>> javier = Cliente(”Javier”, ”Gallardo”, 40000)

Ejercicios propuestos
Ejercicio 01. Crear un módulo llamado “Asignaturas” que contenga un diccionario cu-
yas claves sean los códigos de las asignaturas (CIBA, INGI) y el valor sea una lista con el
nombre de la signatura y la cantidad de créditos que consume. Crear otro módulo llamado
“Asignaturas electivas” que tenga la misma estructura, pero sus asignaturas deben tener
como código de identificación la cadena ASEL. Por último, crear un tercer módulo llama-
do Estudiante que tenga la clase estudiante con sus atributos de nombre, apellido y edad.
Como atributo estático debe tener la cantidad de créditos (33). Como métodos deben tener
inscribir asignaturas y desinscribirlas.

Llamar estos módulos desde el programa principal y utilizarlos para crear estudiantes que
inscriban sus asignaturas. Debe haber una variable que permita ver las asignaturas inscritas.
1.2 Paquetes, bibliotecas o librerı́as de Python 5

1.2. Paquetes, bibliotecas o librerı́as de Python

En Python, un paquete (librerı́a o biblioteca) es un directorio que contiene un conjunto de
módulos relacionados entre sı́ que pueden ser utilizados para efectuar tareas especı́ficas sin
tener que escribir todo el código desde cero. Estas bibliotecas proporcionan un conjunto de
herramientas y funciones que facilitan la organización del código y su escritura.

En términos prácticos, entenderemos un paquete como una carpeta con muchos módulos.
Para que Python comprenda que una carpeta es un paquete, debe contener un módulo es-
pecial llamado init . Este módulo diferenciará al paquete y permitirá ejecutar una serie
de instrucciones a penas sea llamado al programa principal.

A grandes razgos, podemos decir que existen tres tipos de librerı́as:

Librerı́as de creación propia: Son aquellas librerı́as que nosotros creamos en nues-
tros programas. Debemos crear también los módulos que queremos que contengan.

Librerı́as estandar: Son aquellas librerı́as que ya vienen por defecto dentro de
Python y que podemos importar a nuestros programas.

Librerı́as de terceros: Son aquellas librerı́as que hicieron otras personas y que
están disponibles en la web para ser utilizadas. Antes de implementarlas debemos
descargarlas utilizando el comando pip3 install nombre paquete en la terminal de
Visual Studio Code.

El importe de paquetes al programa principal se hace con from nombre paquete import
nombre modulo. Podemos ver lo que tienen dichos módulos presionando la tecla CTRL.
Veamos un ejemplo:

Librerı́a Mat
Módulo init .py # Esto se activa a penas se invoca al módulo
>> from . import Aritmética
>> from . import Geometrı́a as geo
>> print(”Se ha cargado el paquete al sistema”)
>> PI = 3.14159265

Módulo aritmetica.py
>> def vAbs(num):
>> if num >= 0:
>> return num
>> else:
>> return num*-1

>> def factorial(n):

>> if n == 0:
>> return 1
>> valor = 1
>> for i in range(1, n+1):
>> valor *= i
>> return valor
1.2 Paquetes, bibliotecas o librerı́as de Python 6

>> def comb(m,n,fun=factorial)

>> combinatoria = factorial(a)/(factorial(b)*(factorial(a-b)))
>> return int(combinatoria)

Módulo geometria.py
>> def punto cuadrante(x,y):
>> if x>0 and y>0:
>> print(f”({x},{y}) está en el primer cuadrante”)
>> if x<0 and y>0:
>> print(f”({x},{y}) está en el segundo cuadrante”)
>> if x<0 and y<0:
>> print(f”({x},{y}) está en el tercer cuadrante”)
>> if x>0 and y<0:
>> print(f”({x},{y}) está en el cuarto cuadrante”)

>> def dist origen(x,y):

>> distancia = (x**2 + y**2)**(1/2)
>> return distancia

>> def dist dos puntos(x1,y1,x2,y2):

>> distancia = ((x1-x2)**2 + (y1-y2)**2)**(1/2)
>> return distancia

>> def dist punto recta(x,y,m,n):

>> distancia = abs(m*x - 1*y + n)/((m**2 + 1)**(1/2))
>> return distancia

Programa principal
Programa
>> import Módulo
>> print(Aritmética.factorial(4)) 24
>> print(geo.dist origen(3,4)) 5.0

Ejercicios propuestos
Ejercicio 01. Crear un paquete llamado Geometrı́a que tenga los siguientes módulos:

Punto: Este módulo debe tener los siguientes métodos: Distancia al origen, Distancia
entre dos puntos, Punto medio.

Vector: Este módulo debe tener los siguientes métodos: Suma, Resta, Producto es-
calar, Producto punto, Norma.

Recta: Este módulo debe tener los siguientes métodos: Recta por dos puntos, Forma
general de la recta, Recta paralela por un punto exterior, Recta perpendicular por un
punto exterior, Intersección de rectas.

Crear un fichero principal y llamar estos módulos del paquete Geometrı́a. Utilizar las fun-
ciones para corroborar algunos cálculos.
1.3 Módulo Math 7

1.3. Módulo Math

El módulo math es un módulo integrado de Python que nos ofrece una gamma de funciones
matemáticas que no tenemos por defecto en Python. Para poder implementarlo debemos
importarlo de la siguiente manera:

import math

Una vez importado, podemos utilizar todas las funciones que trae el módulo.

Sentencia 1 — Math.factorial. El método math.factorial(n) calcula el factorial de n con

n un número entero positivo o cero.

Sentencia 2 — Math.perm. El método math.perm(a,b) calcula la variación de a entre b,

con a, b enteros positivos y a ≥ b.

Sentencia 3 — Math.comb. El método math.comb(n,k) calcula la combinación entre n y

k, con n, k enteros positivos y n ≥ k.

El siguiente programa aproxima el valor de sen(x) por medio de una serie de potencias:

>> PI=3.14159265358979323846
>> valor = 0
>> x = PI/4
>> for i in range(0,11):
>> valor += ( ((-1)**i) * (x**(2*i+1)) )/(math.factorial(2*i+1))
>> print(round(valor,4))

El siguiente programa calcula los coef. del triángulo de Pascal utilizando combinatorias.

>> pot = 5
>> valores = [ ]
>> for i in range(0,pot+1):
>> num = int(math.comb(pot,i))
>> valores.append(num)
>> print(valores)

Sentencia 4 — Math.fabs. El método math.fabs(x) calcula el valor absoluto de x con x

un número real.

Sentencia 5 — Math.gcd. El método math.gcd(a,b) calcula el máximo común divisor de

a y b, con a, b enteros.

Sentencia 6 — Math.lcm. El método math.lcm(a,b) calcula el mı́nimo común múltiplo de

a y b, con a, b enteros.
1.3 Módulo Math 8

El siguiente código permite crear una fracción, simplificarla y calcular su distancia al origen
utilizando el máximo común divisor y el valor absoluto.

>> def fraccion(a,b):

>> frac = f”a/b”
>> return frac

>> def simplificar(frac):

>> mcd = math.gcd(int(frac[0:frac.index(”/”)]), int(frac[frac.index(”/”)+1:]))
>> frac x = int(frac[0:frac.index(”/”)])/mcd
>> frac y = int(frac[frac.index(”/”)+1:])/mcd
>> return f”int(frac x)/int(frac y)”

>> def distancia(frac):

>> frac x = int(frac[0:frac.index(”/”)])
>> frac y = int(frac[frac.index(”/”)+1:])
>> distancia = math.fabs(round(frac x / frac y,5))
>> return f”La distancia al origen es distancia”

Sentencia 7 — Math.sqrt. El método math.sqrt(x) calcula la raı́z cuadrada de x con x un

número real positivo.

Sentencia 8 — Math.pow. El método math.pow(a,b) calcula la potencia a evelado a b,

con a, b números reales.

Sentencia 9 — Math.exp. El método math.exp(x) calcula el valor de e evelado a x, con x

un número real.

Sentencia 10 — Math.log. El método math.log(b,a) calcula el logarı́tmo de b en base a

con a, b números reales positivos.

Observación. Podemos utilizar la función math.pi para utilizar el número pi y math.e para
utilizar el número e.

Las siguientes funciones permiten calcular el área de un cı́rculo dado su radio y el radio que
deberı́a tener un cı́rculo para tener el área dada utilizando la función math.pi, math.pow()
y math.sqrt().

>> area = lambda r : round(math.pi * math.pow(r,2), 4)

>> radio = lambda A : round(math.sqrt(A/math.pi), 4)

Supongamos ahora que tenemos un cultivo de k bacterias en el tiempo 0 y que cada minuto
que pasa esta cantidad de bacterias se duplica. Las siguientes funciones permiten calcular
la cantidad de bacterias que habrá al cabo de t minutos y cuanto tiempo deberı́a pasar para
tener una determinada cantidad de bacterias partiendo de un cultivo de k.

>> cant bacterias = lambda k,t : f”Un cultivo de {k} bacterias tendrá una población de
1.3 Módulo Math 9

>> {int(k*math.pow(2,t))} bacterias al cabo de {t} minutos”

>> tiempo = lambda k, k esperado : f”Deben pasar {round(math.log(k esperado/k,2),4)}
>> minutos para que un cultivo de {k} bacterias crezca a una población de {k esperado}
>> bacterias”

Sentencia 11 — Math.sin. El método math.sin(x) calcula el seno de x con x un número

real positivo. x debe estar en radianes.

Sentencia 12 — Math.cos. El método math.cos(x) calcula el coseno de x con x un número

real positivo. x debe estar en radianes.

Sentencia 13 — Math.tan. El método math.tan(x) calcula la tangente de x con x un

número real positivo. x debe estar en radianes.

Sentencia 14 — Math.asin. El método math.asin(x) calcula el arcoseno de x con x un

número real entre −1 y 1.

Sentencia 15 — Math.acos. El método math.acos(x) calcula el arcocoseno de x con x un

número real entre −1 y 1.

Sentencia 16 — Math.atan. El método math.atan(x) calcula la arcotangente de x con x

un número real positivo que no sea múltiplo de π/2.

Sentencia 17 — Math.radians. El método math.radians(x) transforma el ángulo sexagesi-

mal x a radianes.

Sentencia 18 — Math.degrees. El método math.degrees(x) transforma el ángulo x de

radianes a grados sexagesimales.

El siguiente programa permite ingresar dos lados de un triángulo y el ángulo entre medio
de dichos lados. El programa calcula las medidas de los demás lados y ángulos utilizando el
teorema del seno y del coseno.

>> a = 5
>> b = 7
>> gamma = 40
>> c = round(math.sqrt(a**2 + b**2 - 2*a*b*math.cos(math.radians(gamma))),2)
>> alpha = round(math.degrees(math.asin((a*math.sin(math.radians(gamma)))/(c))),2)
>> beta = round(180 - alpha - gamma,2)
>> print(f”Lados:\na: a\nb: b\nc: c”)
1.4 Módulo random 10

>> print( )
>> print(f”Ángulos:\nalpha: alpha\nbeta: beta\ngamma: gamma”)

Para que el programa efectúe los cálculos de manera correcta, se debe entregar gamma en
grados sexagesimales.

1.4. Módulo random

El módulo random es un módulo integrado de Python que nos ofrece una gamma de funcio-
nes generadoras de números pseudoaleatorios que no tenemos por defecto en Python. Para
poder implementarlo debemos importarlo de la siguiente manera:
import random
Una vez importado, podemos utilizar todas las funciones que trae el módulo.

Sentencia 19 — Random.seed. El método random.seed(x) establece una semilla x que

inicializa la selección de números por parte de un generador de números aleatorios; dado
el mismo número semilla, un generador de números aleatorios generará la misma serie de
números aleatorios cada vez que se ejecute. No es obligatorio utilizarla.

Sentencia 20 — Random.randint. El método random.randint(a,b) con a, b ∈ Z, entrega

un número aleatorio entero entre a y b incluyendo dichos números.

Sentencia 21 — Random.randrange. El método random.randrange(a,b,c) con a, b, c ∈ Z,

entrega un número aleatorio entero entre a y b − 1 con pasos de c.

Observación.
Si queremos generar una secuencia de números aleatorios podemos utilizar un bucle
como for o while. (Se recomienda for)
Si creamos una semilla y queremos generar varios números pseudoaleatorios debemos
activarla varias veces dentro del programa. Si volvemos a compilar el programa y
tenemos solo un generador aleatorio, se repetirá el mismo número, por que cada vez
que corramos el programa se volverá a iniciar la semilla.
El siguiente programa genera una lista con el orden en la que pasaran una serie de estu-
diantes a presentar sus trabajos.

>> lista = [”Yordan Aguilar”, ”Daniel Varas”, ”Carla Silva”, ”Catalina Ruiz”]
>> j = len(lista)-1
>> print(”Orden de presentación\n”)
>> for i in range(0,5):
>> num = random.randint(0,j)
>> print(lista[num])
>> lista.pop(num)
>> j -= 1

En este caso, utilizamos generadores de números aleatorios enteros.

1.4 Módulo random 11

Sentencia 22 — Random.random. El método random.random( ) entrega un número alea-

torio entre 0 y 1, sin incluir el 1.

Sentencia 23 — Random.uniform. El método random.uniform(a,b) con a, b ∈ R, entrega

un número aleatorio decimal entre a y b utilizando la distribución uniforme.

Sentencia 24 — Random.gauss. El método random.gauss(u,s) entrega un número aleatorio

de la distribución normal con media u y desviación estandar s.

El siguiente programa tiene una tupla formada por pares de datos donde está el nombre de
un participante y su número de la suerte. El programa va generando números aleatorios del 1
al 99 y se presenta al ganador cuando se halla el número de la suerte de una de las personas.

>> participantes = ((”Paulina”, 11),

>> (”Alejandro”, 12),
>> (”Carlos”, 17),
>> (”Luis”, 23),
>> (”Daniel”, 24),
>> (”Javiera”, 64),
>> (”Sandra”, 68),
>> (”Catalina”, 73),
>> (”Pascal”, 88),
>> (”Nicolás”, 92))

>> num = int(random.random()*100)

>> print(num)

Sentencia 25 — Random.choice. El método random.choice(iterable) permite sacar un ele-

mento al azar del iterable que le pasemos. Usualmente se trabaja con listas. Los elementos
extraı́dos se pueden repetir.

Sentencia 26 — Random.sample. El método random.sample(iterable, cantidad) permite

sacar una cantidad especı́fica de elementos de un iterable sin repetición. Usualmente se
trabaja con listas. Devuelve una lista con los elementos.

Sentencia 27 — Random.shuffle. El método random.shuffle(lista) permite barajar una

lista, cambiando de orden sus elementos de forma aleatoria.

El siguiente programa establece una muestra aleatoria de números del bingo.

>> num B = [(”B”,i) for i in range(1,16)]

>> num I = [(”I”,i) for i in range(16,31)]
>> num N = [(”N”,i) for i in range(31,46)]
>> num G = [(”G”,i) for i in range(46,61)]
>> num O = [(”O”,i) for i in range(61,76)]
1.5 Módulo statistics 12

>> num bingo = num B + num I + num N + num G + num O

>> random.shuffle(num bingo)
>> print(random.sample(num bingo, 10))

Ejercicios propuestos
Ejercicio 01. Crear un juego de Pokemon donde hayan dos pokemones en batalla. Cada
uno debe ser definido en una clase diferente que debe estar en un módulo distinto. Como
atributos deben tener su nombre, tipo y puntos de salud y como métodos, debe tener 6
ataques diferentes. Nosostros como entenadores debemos escoger nuestros propios ataques
y el contrincante debe escoger sus ataques al azar. Cada ataque disminuirá la vida del
contrario. El combate finalizará cuando uno de los dos tenga vida cero.

1.5. Módulo statistics

El módulo statistics es un módulo integrado de Python que nos ofrece una gamma de
funciones estadı́sticas para el análisis descriptivo de muestras cuantitativas. Para poder
implementarlo debemos importarlo utilizando la siguiente sintáxis:

import statistics

Usualmente, se acostumbra a renombrar a este módulo como st. Una vez importado, pode-
mos utilizar todas las funciones del módulo.

Sentencia 28 — St.mean. El método st.mean(iterable) calcula el promedio de una muestra

estadı́stica dada en un iterable como una lista o una tupla.

Sentencia 29 — St.median. El método st.median(iterable) calcula la mediana de una

muestra estadı́stica dada en un iterable como una lista o una tupla.

Sentencia 30 — St.mode. El método st.mode(iterable) calcula la moda única de una

muestra estadı́stica dada en un iterable como una lista o una tupla.

Sentencia 31 — St.multimode. El método st.multimode(iterable) calcula todas las modas

de una muestra estadı́stica dada en un iterable como una lista o una tupla.

Sentencia 32 — St.quantiles. El método st.quantiles(iterable, n = k) divide a una muestra

en partes iguales. Por defecto n = 4 coincide con los cuartiles. Si n = 5 calcula los
quintiles. Si n = 10 calcula los deciles. Si n = 100 calcula los percentiles.

El siguiente programa muestra un set de datos cuantitativos continuos con su respectivo

análisis descriptivo.

>> import statistics as st

>> import random

>> set = [round(random.uniform(1,10),2) for i in range(1,11)]

1.5 Módulo statistics 13

>> moda = round(st.mode(set),2)

>> mediana = round(st.median(set),2)
>> media = round(st.mean(set),2)
>> cuartiles = round(st.quantiles(set),2)
>> deciles = round(st.quantiles(set,n=10),2)

Sentencia 33 — St.variance. El método st.variance(iterable) calcula la varianza de una

muestra estadı́stica dada en un iterable como una lista o una tupla.

Sentencia 34 — St.stdev. El método st.stdev(iterable) calcula la desviación estandar de

una muestra estadı́stica dada en un iterable como una lista o una tupla.

Sentencia 35 — St.pvariance. El método st.pvariance(iterable) calcula la varianza de una

población estadı́stica dada en un iterable como una lista o una tupla.

Sentencia 36 — St.pstdev. El método st.stdev(iterable) calcula la desviación estandar de

una población estadı́stica dada en un iterable como una lista o una tupla.

El sigueinte programa realiza un análisis descriptivo de una muestra, incluyendo sus es-
tadı́sticos de tendencia central y de dispersión.

>> import statistics as st

>> import random
>> import math

>> set = [random.randint(4,20) for i in range(1,11)]

>> media = st.mean(set)

>> mediana = st.median(set)
>> varianza = st.variance(set)
>> des ves = st.stdev(set)

>> # Intervalo de confianza para la media

>> mu = [media-1.96*(des ves/math.sqrt(len(set))), media+1.96*(des ves/math.sqrt(len(set)))]

Sentencia 37 — St.covariance. El método st.covariance(muestra1, muestra2) calcula la

covarianza de las muestras dadas. Deben tener el mismo tamaño.

Sentencia 38 — St.correlation. El método st.correlation(muestra1, muestra2) calcula la

correlación lineal de las muestras dadas. Deben tener el mismo tamaño.

Sentencia 39 — St.linear regression. El método st.linear regression(muestra1, muestra2)

calcula la pendiente y el intercepto de la recta de regresión lineal de dos muestras.

Observación. El atributo st.linear regression(m1, m2).slope nos entrega especı́ficamente

1.6 Módulo datetime 14

el valor de la pendiente y st.linear regression(m1, m2).intercept el valor del intercepto.

El siguiente código contiene dos muestras estadı́sticas sobre la edad y el peso y calcula la
correlación lineal y la recta de regresión lineal simple entre ellas.

>> edad = [12, 23, 25, 17, 19, 19, 21]

>> peso = [55, 62, 73, 60, 61, 58, 55]

>> correlacion = st.correlation(edad, peso)

>> regresion lineal = st.linear regression(edad, peso)

>> print(correlacion)
>> print(f”y = {regresion lineal.slope}x + {regresion lineal.intercept}”)

1.6. Módulo datetime

La librerı́a datetime es una librerı́a integrada de Python que nos ofrece una gamma de
funciones para el cálculo y la implementación de fechas y horas en nuestros códigos de
programación. Para poder importarlo a nuestro programa, utilizamos la siguiente sintáxis:

import datetime

Usualmente, se acostumbra a renombrar a este módulo como dt.

Módulo datetime
Comenzaremos importando el módulo datetime para el manejo conjunto de fechas y horas.

from datetime import datetime

Una vez importado, podemos comenzar a utilizarlo.

Sentencia 40 — Dt.now. El método dt.now( ) permite inicializar una variable con la

fecha actual, considerando el año, el mes, el dı́a, la hora, el minuto, el segundo y el
microsegundo.

Una vez iniciada la fecha actual, es posible acceder a sus atributos diferenciados por medio
de las siguientes funciones:

dt.now( ).year permite acceder al año de la fecha dada.

dt.now( ).month permite acceder al mes de la fecha dada.

dt.now( ).day permite acceder al dı́a de la fecha dada.

dt.now( ).hour permite acceder a la hora de la fecha dada.

dt.now( ).minute permite acceder al minuto de la fecha dada.

dt.now( ).second permite acceder al segundo de la fecha dada.

Podemos asignar el datetime.now( ) a una variable y utilizarla para acceder a sus atributos.
1.6 Módulo datetime 15

>> fecha = datetime.now( )

>> print(f”La fecha actual es: año {fecha.year}, mes {fecha.month}, dı́a {fecha.day}”)
>> print(f”La hora actual es: hr {fecha.minute}, min {fecha.minute}, seg {fecha.second}”)

Podemos establecer nuestras propias fechas indicando el año, mes, dı́a, hora, minuto y
segundo que necesitemos. Para ello, escribimos:

nom var = datetime(year, month, day, hour, minute, second)

Una vez creada la fecha, es posible acceder a sus atributos utilizando las mismas funciones
antes vistas para la fecha actual.

Sentencia 41 — Dt.timestamp. El método dt.timestamp( ) almacena un instante de tiem-

po por medio de un número único.

Sentencia 42 — Dt.fromtimestamp. El método dt.fromtimestamp(numero) transforma un

número de tipo timestamp en una fecha con toda la información que almacena.

El siguiente código contiene una fecha inicializada por nosotros y dos funciones que la trans-
forman en un timestamp y que la regresan a su formato original.

>> fecha = datetime(2024, 2, 15, 17,30,0)

>> num = datetime.timestamp(fecha)

>> fecha = datetime.fromtimestamp(num)

Sentencia 43 — Dt.weekday. El método dt.weekday(fecha) entrega el dı́a de la semana

asociado a la fecha entregada. Si es lunes entrega 0, si es martes entrega 1, ..., si es
domingo entrega 6.

Módulo date
Analicemos otro módulo de la librerı́a datetime. El módulo date nos permite entregar fechas
indicando solo el año, el mes y el dı́a. Para importarlo, utilizamos la siguiente sintáxis:

from datetime import date

Una vez importado, podemos comenzar a utilizarlo.

Sentencia 44 — Date.today. El método date.today() entrega la fecha actual, considerando

el año, el mes y el dı́a.

Podemos crear una fecha con la sintáxis nom var = date(year, month, day) y asignarle la
información que estimemos conveniente. La idea de crear una fecha utilizando date es que
no incluiremos la hora, los minutos y los segundos.
1.6 Módulo datetime 16

Módulo time
Analicemos otro módulo de la librerı́a datetime. El módulo time nos permite entregar horas
indicando solo la hora, el minuto y el segundo. Para importarlo, utilizamos la siguiente
sintáxis:
from datetime import time
Una vez importado, podemos comenzar a utilizarlo.

Sentencia 45 — Datetime.now().time. El método datetime.now( ).time() entrega la hora

actual del sistema, considerando considerando la hora, los minutos y los segundos.

Podemos crear una hora con la sintáxis nom var = time(hour, minute, second) y asignarle
la información que estimemos conveniente. La idea de crear una hora utilizando time es que
no incluiremos el año, el mes y el dı́a.

Módulo timedelta
El último módulo que estudiaremos de la librerı́a datetime es el módulo timedelta. La idea
principal de importar timedelta es ser capaz de efectuar operaciones aritméticas con fechas
y horas, como sumas, restas, entre otros. Para importarlo, utilizaremos la siguiente sintáxis:

from datetime import timedelta

Una vez importado, podemos comenzar.

Sentencia 46 — Timedelta. El método timedelta(tiempo) nos permite crear un rango de

tiempo que podemos utilizar para operar con fechas y horas. Los rangos que podemos
agregar son weeks, days, hours, minutes y seconds.

>> from datetime import datetime, date, time, timedelta

>> fecha = datetime(2024, 1, 1, 12, 5, 55)

>> delta = timedelta(weeks=1, days=4, hours=1, minutes=1, seconds=5)

>> print(fecha + delta)

>> print(fecha - delta)

Observación.

No podemos sumar años y meses directamente, sin embargo, podemos multiplicar la

cantidad de años que queremos sumar por 365 y agregarlo por medio de los dı́as. De
la misma forma, si queremos sumar meses, multiplicamos por 30 y agregamos los dı́as
equivalentes.

Podemos utilizar los operadores de comparación para averigiar la relación que hay
entre dos fechas.

Los operadores clásicos de comparación que podemos utilizar son <, >, ≤, ≥, == y ! =.
1.6 Módulo datetime 17

Ejercicios propuestos
Ejercicio 01. Crear un programa que simule una tienda especializada en la venta de útiles
escolares (gomas, cuadernos, mochilas, carpetas, ...) donde podamos generar clientes que
asistan y compren productos.

El programa debe tener un módulo llamado Productos que tenga un diccionario como base
de datos, cuyas claves sean los números de identificación, y los valores, tuplas con el nom-
bre del producto y el precio. Debemos crear también un segundo módulo llamado Cliente
que contenga una clase con el mismo nombre, cuyos atributos sean su nombre, apellido y
presupuesto disponible, y como métodos tenga comprar y ver cesta de productos.

Invocar dichos módulos al programa principal y utilizarlos para crear clientes que asistan a
la librerı́a y compren. Los productos seleccionados se deben almacenar en una lista llamada
cesta de productos. Una vez que el usuario escoja todo lo que quiere comprar, debe poder
pagar todos los productos. Al pagar la cesta, debe generarse una boleta que contenga:

Nombre de la tienda

Dirección de la tienda y fecha exacta de la compra

Nombre y apellido del cliente

Lista de productos comprados con sus respectivos precios

Precio total a pagar

Si la cesta junta un valor superior a los $20.000, se debe aplicar un descuento del 15 % sobre
el monto final. El descuento, si procede, debe poder verse en la boleta. Por último, se debe
almacenar la boleta en una base de datos que nos permita recuperarla en caso de que se
requiera.
Capı́tulo 2

Módulos y librerı́as para el análisis

y la organización de datos

En el primer capı́tulo del curso, exploramos la modularización de programas y cómo aprove-

char las funciones de los módulos integrados en Python. En esta nueva etapa, nos sumergire-
mos más profundamente en el análisis de datos mediante el uso de bibliotecas especializadas
como SymPy y NumPy y las aprovecharemos para abordar, posteriormente, la organización
eficiente de datos con Pandas. Este enfoque nos permitirá comprender cómo realizar un
análisis de datos robusto y estructurado, utilizando herramientas especı́ficas diseñadas para
simplificar estas tareas en el entorno Python.

2.1. Librerı́a Sympy

Sympy es un módulo no integrado de Python que se emplea para el cálculo simbólico de
expresiones matemáticas avanzadas. El hecho de que desarrolle cálculo simbólico se traduce
en que todo los resultados entregados se presentan en su forma exacta y no aproximada.

Como esta librerı́a no viene integrada en Python, es necesario descargarla de la web para
poder implementarla en nuestros programas. Para ello, abrimos la terminal de VS Code y
escribimos lo siguiente:
pip3 install sympy
Una vez instalada, puede ser invocada al programa principal para utilizar sus funciones. El
importe se hace de la siguiente forma:

import sympy

Generalmente se abrevia el nombre del módulo con la expresión “sp”. Los principales cálcu-
los que podemos realizar son los siguientes:
Polinomios y expresiones algebraicas

Ecuaciones, inecuaciones y sistemas

Cálculo y funciones

Matrices y determinantes
Estudiaremos y profundizaremos a continuación cada uno de estos temas.
2.1 Librerı́a Sympy 19

2.1.1. Polinomios y expresiones algebraicas

El módulo sympy nos permite definir polinomios y expresiones algebraicas en su forma
literal para su posterior evaluación y uso. Para hacer esto, debemos partir definiendo las
variables que utilizaremos y posteriormente crear la expresión:
x, y, z, ... = sympy.symbols(“x y z ...”) # Declaración de variables
nombre variable = expresión algebraica
Podemos utilizar una gran cantidad de operadores al momento de definir nuestra expresión
algebraica. Entre los más usados, están:

+ : suma − : resta ∗ : multiplicación

/ : división ∗∗ : potencia

También hay funciones avanzadas en sympy que vienen integradas y que podemos utilizar
para añadir complejidad a nuestras expresiones algebaricas:

sympy.sin(x) sympy.cos(x) sympy.tan(x)

sympy.csc(x) sympy.sec(x) sympy.cot(x)

sympy.asin(x) sympy.acos(x) sympy.atan(x)

sympy.acsc(x) sympy.asec(x) sympy.acot(x)

sympy.Pow(x, n) sympy.sqrt(x) sympy.root(x, m)

sympy.exp(x) sympy.log(b, a) sympy.ln(x)

Una vez definida la expresión algebraica, podemos evaluarla reemplazando sus variables de
la siguiente forma:
nombre variable.subs(variable, valor) # Una variable
nombre variable.subs([(x, x0), (y, y0), (z, z0), ...]) # Varias variables
El siguiente código muestra un programa que contiene varias expresiones algebraicas que
son evaluadas en distintos puntos.

>> import sympy

>> x, y, z = sympy.symbols(”x y z”)

>> p 1 = 12*x - 5*y*z + (3/x) + 2**x - 1
>> p 2 = sympy.cos(sympy.sqrt(x**2 + 1))
>> p 3 = sympy.ln(sympy.root(2*x + z, 3))

>> print(p 1.subs([(x,1), (y,5), (z,-2)]))

>> print(p 2.subs(x,0))

No es necesario evaluar todas las variables, podemos dejar algunas sin reemplazar.
2.1 Librerı́a Sympy 20

Podemos utilizar una gran variedad de métodos para trabajar con expresiones algebraicas.
Algunas de ellas se muestran a continuación:

El método sympy.factor(expresión) permite factorizar una expresión algebraica. Si no

se puede factorizar, la deja igual.
El método sympy.expand(expresión) permite expandir el desarrollo algebraico de una
expresión polinomial. También separa los términos del numerador de una fracción
algebraica conservando el denominador.
El método sympy.simplify(expresión) permite simplificar una expresión algebraica,
reduciendo términos semejantes y simplificando fracciones algebraicas.
El método sympy.trigsimp(expresión) simplifica una expresión trigonométrica en la
forma más simple posible.
El método sympy.apart(expresión) permite hallar la descomposición en fracciones par-
ciales de una fracción algebraica.

El siguiente programa tiene una serie de expresiones algebraicas junto a operaciones de

simplificación, factorización y descomposición.

>> import sympy

>> x = sympy.symbols(”x”)

>> p1 = 3*x**4 - 13*x**3 - 54*x**2 + 160*x - 96

>> p2 = (x+2)**5
>> p3 = (x**2 + 5*x + 6)/((x+2)**2)
>> p4 = (2*sympy.cos(x)**2)/(sympy.sin(2*x))
>> p5 = (2*x + 5)/(x**3 - 16*x - x**2 + 16)

>> print(sympy.factor(p1))
>> print(sympy.expand(p2))
>> print(sympy.simplify(p3))
>> print(sympy.trigsimp(p4))
>> print(sympy.apart(p5))

Por último, veremos que es posible permitir al usuario ingresar expresiones algebraicas al
programa. Para esto, debemos ingresar lo escrito en la terminal con la sentencia input( ) y
luego transformar el str en una expresión de sympy con la siguiente función:
sympy.sympify(cadena str)
Veamos un ejemplo de esto:

>> x = sympy.symbols(”x”)

>> expression = input(”Ingrese una expresión algebraica en la variable x: ”)

>> p = sympy.sympify(expression)

Con esto, ya somos capaces de ingresar nuestras propias expresiones algebraicas y utilizar
las funciones de sympy para trabajarlas como deseemos.
2.1 Librerı́a Sympy 21

2.1.2. Ecuaciones, inecuaciones y sistemas

Solución de ecuaciones
Podemos aprovechar las expresiones matemáticas de sympy para resolver ecuaciones de
cualquier tipo. Para esto, debemos considerar las siguientes funciones:
El método sympy.Eq(exp 1, exp 2) permite establecer la ecuación exp 1 = exp 2.
El método sympy.solve(ecuación, variable) permite resolver la ecuación dada.
El siguiente código presenta la solución de varios tipos de ecuaciones matemáticas.

>> import sympy as sp

>> x = sp.symbols(”x”, real = True)

>> print(sp.solve(sp.Eq(2*x + 8, 10), x)) # Ec. lineal

>> print(sp.solve(sp.Eq(x**2 + 6*x + 3, x - 3), x)) # Ec. cuadrática
>> print(sp.solve(sp.Eq(x**3 + 3*x**2, 28*x + 60), x)) # Ec. polinomial

>> print(sp.solve(sp.Eq((x - 3)/(x + 1), -1), x)) # Ec. racional

>> print(sp.solve(sp.Eq(sp.sqrt(x + 2) - 4, 0), x)) # Ec. irracional
>> print(sp.solve(sp.Eq(sp.Abs(x - 3), 2), x)) # Ec. v. absoluto

>> print(sp.solve(sp.Eq(2**(x + 1), 8), x)) # Ec. exponencial

>> print(sp.solve(sp.Eq(sp.log(x + 4, 2), 3), x)) # Ec. logarı́tmica
>> print(sp.solve(sp.Eq(sp.sin(2*x), -1*1/2), x)) # Ec. trig.

Observación. Para resolver ecuaciones con valor absoluto debemos agregar “real = True”
al momento de definir las variables.

------------------------------------------------------------

Solución de sistemas de ecuaciones

Podemos aprovechar las expresiones matemáticas del módulo sympy para resolver sistemas
de ecuaciones lineales de cualquier cantidad de variables.
El método sympy.linsolve([ec1, ec2, ec3, ...], (var1, var2, var3, ...)) permite resolver
sistemas de ecuaciones lineales indicando sus ecuaciones y sus variables. Las ecuaciones
deben presentarse igualadas a cero.
El siguiente código presenta la solución de dos sistemas de ecuaciones lineales:

>> import sympy

>> s1 = sympy.linsolve([x + y + z - 1, 2*x - 2*y + 4*z, x - y - z - 9], (x,y,z))

>> s2 = sympy.linsolve([2*x - 3*y + z - 5, x + y - z - 15], (x,y,z))
>> s3 = sympy.linsolve([y - 4*z - 8, 2*x - 3*y + 2*z - 1, 5*x - 8*y + 7*z - 1], (x,y,z))

>> print(s1, ”\ n”, s2, ”\ n”, s3)

El primer sistema tiene solución única, el segundo, infinita, y el tercero, solución vacı́a.
2.1 Librerı́a Sympy 22

Intervalos en R
Podemos aprovechar las expresiones matemáticas que nos ofrece sympy para crear intervalos
matemáticos. Los más usuales son:
sympy.Interval(a, b) I. cerrado
sympy.Interval.open(a, b) I. abierto
sympy.Interval(a, b, left open = True) I. semiabierto a izquierda
sympy.Interval(a, b, rigth open = True) I. semiabierto a derecha
sympy.Interval(- sympy.oo, sympy.oo) I. no acotado
sympy.Interval(a, a) I. de valor único
Podemos hacer algunas operaciones con los intervalos. Las principales operaciones son:

intervalo1.union(intervalo2)
intervalo2.intersection(intervalo2)
intervalo1 - intervalo2

------------------------------------------------------------

Solución de inecuaciones
Podemos aprovechar las expresiones matemáticas de sympy para resolver inecuaciones de
cualquier tipo. Para esto, debemos considerar la siguiente función:
sympy.solveset(inecuacion, variable, domain = sympy.S.Reals)
El siguiente código presenta la solución de varios tipos de inecuaciones matemáticas:

>> import sympy as sp

>> x = sp.symbols(”x”)

>> # Inecuación lineal, cuadrática y polinomial

>> print(sp.solveset(15*x - 4 < 26, x, domain = sp.S.Reals))
>> print(sp.solveset(x**2 - 4 <= 0, x, domain = sp.S.Reals))
>> print(sp.solveset(x**4 - 7*x**2 + 6*x < 0, x, domain = sp.S.Reals))

>> # Inecuación racional e irracional

>> print(sp.solveset((x - 1)/(x**2 + 3) >= 0, x, domain = sp.S.Reals))
>> print(sp.solveset(sp.sqrt(2*x - 1) - 3 < 0, x, domain = sp.S.Reals))

>> # Inecuación con valor absoluto

>> print(sp.solveset(sp.Abs(x**2 + 5*x + 5) >= 1, x, domain = sp.S.Reals))

>> # Inecuación exponencial y logarı́tmica

>> print(sp.solveset(2*3**x > 2, x, domain = sp.S.Reals))
>> print(sp.solveset(sp.log(x**2, 2) > 1, x, domain = sp.S.Reals))
2.1 Librerı́a Sympy 23

2.1.3. Cálculo y funciones

El módulo sympy nos permite también definir funciones y utilizar herramientas del cálculo
para analizar su comportamiento. Para esto, debemos partir definiendo las variables que
utilizaremos y la función que analizaremos:

x, y, z, ... = sympy.symbols(“x y z ...”)

funcion = ... ... ...

El siguiente código define una función racional, la evalúa en algunos puntos y calcula su
dominio:

>> import sympy

>> x = sympy.symbols(“x”)

>> f = (x - 3)/(x**2 - 1)

>> # Dominio de la función

>> ceros denominador = sympy.solve(sympy.Eq(x**2 - 1,0),x)
>> dom = sympy.Interval(-sympy.oo, sympy.oo)

>> for i in ceros denominador:

>> ran = sympy.Interval(i,i)
>> dom = dom - ran

>> # Evaluación de la función en x = 0, x = 2, x = -2

>> print((0, f.subs(x,0)))
>> print((0, f.subs(x,2)))
>> print((0, f.subs(x,-2)))

Es posible analizar funciones utilizando herramientas del cálculo diferencial e integral de

una y varias variables. Para ello, utilizaremos los siguientes métodos:

sympy.limit(funcion, x, x0 ) Lı́mites

sympy.limit(funcion, x, x0 , +)

sympy.limit(funcion, x, x0 , −)

sympy.limit(funcion, (x,x0 ), (y,y0 ), ...)

sympy.diff(funcion, variable) Derivadas

sympy.diff(funcion, var1, var2, var3, ...)

sympy.integrate(funcion, variable) Integrales

sympy.integrate(funcion, (variable, a, b))

sympy.integrate(funcion, (var1, a1, b1), (var2, a2, b2), ...)

2.1 Librerı́a Sympy 24

2.1.4. Matrices y determinantes

El módulo sympy también nos permite trabajar con matrices y determinantes. Para ello,
debemos partir definiendo este tipo de objetos antes de operarlos.

sympy.Matrix([[fila1], [fila2], [fila3], ...])

El método sympy.shape(matriz) entrega el orden de la matriz en una tupla.

>> import sympy

>> m1 = sympy.Matrix([[1, 0, 0], [0, 1, 0], [0 0, 1]])

>> m2 = sympy.Matrix([[1, 2, 3], [4, 5, 6]])
>> m3 = sympy.Matrix([[0, 0], [1, 1], [2, 2], [3, 3]])

>> print(sympy.shape(m1))
>> print(sympy.shape(m2))
>> print(sympy.shape(m3))

Podemos crear matrices especiales utilizando algunos métodos del módulo sympy. Los prin-
cipales tipos son:

El método sympy.eye(n) permite crear una matriz identidad de orden n × n.

El método sympy.zeros(m,n) permite crear una matriz nula de orden m × n.

El método sympy.ones(m,n) permite crear una matriz de orden m×n cuyos coeficientes
son todos iguales a 1.

El método sympy.diag(a,b,c,...) permite crear una matriz diagonal con los elementos
entregados.

Podemos obtener elementos especı́ficos de la matriz, obtener sus filas, sus columnas, modi-
ficar la matriz e incluso eliminar filas o columnas especı́ficas.

El método nom matriz[n,m] permite obtener el elemento de la matriz que está en la

fila n + 1 y la columna m + 1.

El método nom matriz[n,m] = k permite modificar el elemento de la matriz que está

en la fila n + 1 y la columna m + 1. Lo reemplaza por k.

El método nom matriz.row(n) permite obtener la fila n + 1 de la matriz.

El método nom matriz.col(n) permite obtener la columna n + 1 de la matriz.

El método nom matriz.row del(n) permite eliminar la fila n + 1 de la matriz.

El método nom matriz.col del(n) permite eliminar la columna n + 1 de la matriz.

Veamos un ejemplo. El siguiente programa contiene una matriz que es modificada, cam-
biando sus elementos y eliminando filas y columnas.
2.1 Librerı́a Sympy 25

>> import sympy

>> matriz = sympy.Matrix([[2, 4, 0],

>> [1, 1, 0],
>> [0, 0, 0],
>> [-1,6, 0],
>> [1, 2, 0],
>> [1, 2, 1]])

>> matriz[5, 2] = 0

>> fila 1 = matriz.row(1)

>> columna 2 = matriz.col(1)

>> matriz.row del(2)

>> matriz.col del(2)

Podemos realizar algunas operaciones entre matrices utilizando los siguientes métodos:

matriz1 + matriz2 Suma de matrices

matriz1 - matriz2 Resta de matrices
k * matriz Producto por escalar
matriz1 * matriz2 Producto de matrices
matriz ** n Potencia de matrices

Veamos un ejemplo de como utilizar las diferentes operaciones entre matrices:

>> import sympy

>> matriz1 = sympy.Matrix([[1, -1, -1],

>> [-1, 0, 3],
>> [-2, 5, -3]])

>> matriz2 = sympy.Matrix([[1, 1, 1],

>> [3, 5, 4],
>> [3, 6, 5]])

>> suma = matriz1 + matriz2

>> resta = matriz1 - matriz2

>> prod escalar = -3 * matriz1

>> producto = matriz1 * matriz2

>> potencia = matriz1 ** 3

>> inversa = matriz1 ** (-1)

Notemos que para calcular la matriz inversa debemos elevar a la potencia −1.
2.1 Librerı́a Sympy 26

Hay otras funciones que podemos aplicar a matrices utilizando el módulo sympy. Entre las
más interesantes se encuentran:

nom matriz.T Matriz traspuesta

nom matriz.det( ) Determinantes de una matriz

nom matriz.rref() Matriz escalonada reducida

nom matriz.rank( ) Rango de una matriz

linsolve(sympy.Matrix([[fila1], ...]), (var1, ...)) Sistema de ecuaciones

Veamos un ejemplo aplicando estas funciones a matrices.

>> import sympy

>> x, y, z = sympy.symbols(”x y z”)

>> matriz = sympy.Matrix([[4, 2, 1, 0, 0],

>> [2, 1, 0, 1, 4],
>> [0, 2, 0, 1, 1],
>> [1, 0, 0, 0, 0],
>> [1, 0, 0, 0, 2]])

>> determinante = sympy.det(matriz)

>> MERF = matriz.rref()

>> rango = matriz.rank()

>> sistema = sympy.linsolve(sympy.Matrix([[1, 1, 1, 6], [1, -1, 2, 5], [1, -1, -3, -10]]), (x,y,z))

Debemos recordar que los coeficientes del sistema de ecuaciones son los de la matriz am-
pliada, por lo que se considera a la matriz de resultados con sus signos correspondientes.

Ejercicios propuestos
Ejercicio 01. Construir un programa que permita al usuario ingresar una función por
consola y que el programa le entrege los siguientes datos:

Máximos y mı́nimos

Intervalos de crecimiento y de decrecimiento

Intervalos de concavidad y puntos de inflexión

Probar el programa con varias funciones y corroborar la información con un graficador.

Ejercicio 02. Crear un programa que permita al usuario ingresar las ecuaciones de tres
rectas del plano y que este devuelva el área del triángulo formado. Utilizar el módulo sympy
para hallar la intersección de las rectas. Crear varias instancias para probar el programa y
corroborar con un graficador web.
2.2 Librerı́a Numpy 27

2.2. Librerı́a Numpy

Numpy es una librerı́a no integrada de Python que proporciona soporte para trabajar con
arreglos multidimensionales y matrices, ası́ como funciones matemáticas para operar en es-
tos arrays. La palabra “NumPy” es una abreviatura de “Numerical Python”. Esta biblioteca
es fundamental en el ámbito de la computación cientı́fica y el análisis de datos.

Como esta librerı́a no viene integrada en Python, es necesario descargarla de la web para
poder implementarla en nuestros programas. Para ello, abrimos la terminal de VS Code y
escribimos lo siguiente:
pip3 install numpy
Una vez instalada, puede ser invocada al programa principal para utilizar sus funciones. El
importe se hace de la siguiente forma:
import numpy
Generalmente se abrevia el nombre del módulo con la expresión “np”. Los principales objetos
que vamos a estudiar en este módulo son:
Arreglos de una dimensión o vectores
Arreglos de dos dimensiones o matrices
Estudiaremos y profundizaremos a continuación cada uno de estos temas.

2.2.1. Arreglos de una dimensión o vectores

En general, un arreglo es un objeto multidimensional que contiene elementos del mismo
tipo. Particularmente, llamaremos vector a un arreglo de una dimensión. Para definir un
vector en numpy, utilizamos la siguiente sintáxis:
np.array([x0 , x1 , x2 , x3 , ...])
Los objetos creados en numpy son de tipo numpy.ndarray. Podemos averiguar la cantidad
de elementos del vector y el tipo de elementos por medio de las siguientes funciones:
nombre vector.size Cantidad de elementos del vector
nombre vector.dtype Tipo de datos que contiene el vector
Veamos un ejemplo. El siguiente código contiene algunos vectores de numpy con sus res-
pectivas funciones de tamaño y tipo:

>> import numpy as np

>> v1 = np.array([1, 2, 3, 4, 5])

>> v2 = np.array([“perro”, “gato”, “pez”])
>> v3 = np.array([1, 2, 3, “hola”])

>> print(v1)
>> print(v2.size)
>> print(v3.dtype)

Notemos que el vector v3 a transformado automáticamente todos sus elementos en cadenas

2.2 Librerı́a Numpy 28

de texto para asegurar la homogeneidad de tipos. Esta es una caracterı́stica muy importante,
pues los arreglos trabajan exclusivamente con datos de una sola clase.

Slicing en arreglos de una dimensión

Podemos acceder a los elementos de un vector indicando su nombre y entre corchetes el
ı́ndice del elemento. Las posiciones comienzan en 0, por ende, debemos tomar siempre
un número menos a la posición en la que se encuentra. Podemos utilizar también ı́ndices
negativos. Al acceder al elemento, es posible modificarlo asignándole un nuevo dato.

nombre vector[indice]

nombre vector[indice] = nuevo valor

De la misma forma, es posible extraer rangos de datos del vector indicando los ı́ndices donde
haremos el corte. Incluso, podemos agregar un salto.

nombre vector[a : b] Extracción de un rango de datos

nombre vector[a : b : c] Extracción de un rango de datos con paso

Podemos crear vectores con un rango de datos entre a y b − 1, agregando un paso de c, con
la siguiente función:

np.arange(a, b, c)

De la misma forma, podemos crear vectores con una cantidad de elementos predefinida entre
dos números utilizando al función linspace.

np.linspace(a, b, cantidad)

Veamos algunos ejemplos para comprender mejor las funciones antes expuestas.

>> import numpy as np

>> v1 = np.array([1, 3, 4, -2, 6, 6, 3, 11, 5, 2])

>> v2 = np.arange(5, 16, 2)
>> v3 = np.linspace(1, 10, 20)

>> v1[2] = 10

>> print(v2[0 : 3])

>> print(v3[0 : 11 : 3])

Operaciones con arreglos de una dimensión

Si consideramos a los arrays de una dimensión como vectores, es posible considerar las
operaciones clásicas de la geometrı́a analı́tica tal como veremos a continuación:

vector 1 + vector 2 Suma de vectores

vector 1 − vector 2 Resta de vectores

k * vector Producto por escalar

2.2 Librerı́a Numpy 29

np.dot(vector 1, vector 2) Producto punto o escalar

np.cross(vector 1, vector 2) Producto cruz o vectorial

np.linalg.norm(vector) Norma vectorial

Observación. También podemos utilizar la operación “vector / n” para dividir todos los
elementos del vector por n, y “vector ** n” para elevar todos los elementos del vector a n.

Veamos un ejemplo de código donde se implementan las funciones antes mostradas:

>> import numpy as np

>> v1 = np.array([1, 3, 5])

>> v2 = np.array([-4, 5, 2])

>> print(v1 + v2)

>> print(v1 - v2)
>> print(3*v1 + 5*v2)

>> print(np.dot(v1, v2))

>> print(np.cross(v1, v2))

>> print(np.linalg.norm(v1))

Existen otras funciones especiales que podemos aplicar a vectores para mejorar su uso.
nombre vector.sort( ) Ordena los elementos del vector

nombre vector.round(k) Redondea todos los elementos del vector

np.concatenate((v1, v2, v3, ...)) Permite unir dos o más vectores

También es posible utilizar vectores para evaluar funciones en un rango de datos. Para ver
esto, consideremos el siguiente ejemplo:

>> import numpy as np

>> x = np.arange(1, 11) Valores eje x

>> y1 = 2*x + 1 Función lineal

>> y2 = 4*x**5 - 3*x**4 + 2*x - 6 Función polinomial

>> y3 = (x+1)/(x-15) + x Función racional

>> y4 = np.sqrt(x-1) + 2 Función raı́z cuadrada

>> y5 = np.sin(x) Función seno

>> y6 = np.cos(x) Función coseno
>> y7 = np.tan(x) Función tangente

>> y8 = np.exp(x**2 - 1) Función exponencial base e

>> y9 = np.log(x) Función logarı́tmo natural
2.2 Librerı́a Numpy 30

Funciones estadı́sticas en arreglos de una dimensión

Al igual que podemos aplicar operaciones vectoriales a un arreglo 1-dimensional, es posible
aplicar funciones estadı́sticas al considerarlo como una muestra.

Los principales estadı́sticos de tendencia central y de posición son:

np.mean(nombre vector) Promedio

np.median(nombre vector) Mediana

np.percentile(nombre vector, número percentil) Percentil

Los principales estadı́sticos de dispersión o variación son:

np.min(nombre vector) Mı́nimo

np.max(nombre vector) Máximo

np.var(nombre vector) Varianza

np.std(nombre vector) Des. estandar

Otras funciones útiles para el cálculo estadı́stico son aquellas que suman o multiplican todos
los elementos de la muestra. Estas, se implementan de la siguiente forma:

np.sum(nombre vector)

np.prod(nombre vector)

Por último, nos interesa saber, para la creación de tablas de frecuencia, los elementos que
forman parte de la muestra y la frecuencia con la que aparecen. Para esto, utilizaremos la
siguiente función:

np.unique(nombre vector, return counts = True)

Si le pasamos el ı́ndice cero, obtendremos una lista con los valores de la muestra. Si le
pasamos el ı́ndice uno, obtendremos una lista con la frecuencia de estos datos.

Veamos un ejemplo de como analizar una muestra utilizando las funciones estadı́sticas de
numpy.

>> import numpy as np

>> muestra = np.array([50, 38, 43, 56, 51, 36, 25, 33, 41, 44,
>> 34, 39, 49, 37, 40, 50, 50, 35, 22, 45,
>> 44, 38, 14, 44, 51, 27, 44, 39, 50, 35,
>> 31, 34, 48, 48, 30, 42, 26, 35, 32, 63,
>> 36, 38, 53, 23, 39, 45, 37, 31, 39, 53])

>> media = np.mean(muestra)

>> mediana = np.median(muestra)
>> cuartil 1 = np.percentile(muestra, 25)
>> cuartil 3 = np.percentile(muestra, 75)
2.2 Librerı́a Numpy 31

>> maximo = np.max(muestra)

>> minimo = np.min(muestra)

>> des est = np.std(muestra)

>> datos = np.unique(muestra, return counts=True)[0]

>> frecuencia = np.unique(muestra, return counts=True)[1]

2.2.2. Arreglos de dos dimensiones o matrices

Llamaremos matriz a un arreglo bidimensional de la librerı́a numpy. Para crear matrices en
Python, debemos utilizar la siguiente sintáxis:
np.array([[fila1], [fila2], [fila3], ...])
Por defecto, tenemos algunas funciones especiales para la creación de matrices particulares:
np.ones((m, n)) Matriz de unos

np.zeros((m, n)) Matriz de ceros

np.eye(m) Matriz identidad orden m

np.diag([x0 , x1 , x2 , x3 , ...]) Matriz diagonal

np.full((m,n), valor) Matriz de orden m,n rellena de “valor”

Veamos algunos ejemplos de como crear matrices con numpy:

>> import numpy as np

>> m1 = np.array([[1, 2, 3, 4, 5],

>> [6, 7, 8, 9, 0]])

>> m2 = np.array([[0, 1],

>> [1, 2],
>> [2, 3]])

>> m3 = np.ones((1,4))
>> m4 = np.zeros((2,2))
>> m5 = np.eye(4)
>> m6 = np.diag([1,2,3,4])
>> m7 = np.full((2,3), 10)

Podemos conocer algunas caracterı́sticas de las matrices utilizando las siguientes funciones:
nombre matriz.size N° elementos de la matriz

nombre matriz.shape Orden de la matriz

Incluso, es posible redimensionar la estructura de la matriz con la siguiente función:
np.reshape(matriz, (m, n), ”F” o ”C”)
Esta cambia la forma de la matriz y la deja con orden m × n.
2.2 Librerı́a Numpy 32

Slicing y modificación de arreglos 2 - dimensionales

Podemos acceder a los elementos de la matriz indicando su fila y su columna. Recordar que
los ı́ndices comienzan en cero. De la misma forma, es posible acceder a una fila especı́fica o
colúmna especı́fica.

nombre matriz[fila, columna] Elemento

nombre matriz[fila, : ] Fila
nombre matriz[ : , columna] Columna

Ası́ como podemos acceder a los elementos, filas y columnas de la matriz, es posible modi-
ficarlas con las siguientes funciones:

nombre matriz[fila, columna] = nuevo valor

nombre matriz[fila, : ] = [x0 , x1 , x2 , x3 , ...]
nombre matriz[ : , columna] = [y0 , y1 , y2 , y3 , ...]

Veamos un ejemplo de código de como utilizar estas funciones en matrices:

>> import numpy as np

>> m1 = np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3]])

>> m2 = np.array([1, 2], [3, 4], [5, 6], [7, 8])

>> m1[ 1 : ] = [5,4,3]

>> m2[ : 1 ] = [0, 0, 0, 0]

Muchas veces necesitamos extraer o modificar elementos de una matriz que verifiquen una
condición especı́fica. Para esto, contamos con las siguientes funciones:

nombre matriz[condición booleana]

nombre matriz[condición booleana] = nuevo valor

Estas funciones extraen los elementos de la matriz que cumplen una condición especı́fica.
Si lo deseamos, podemos reemplazarlos con un valor especı́fico. Algo importante a tener en
consideración es que, si deseamos agregar condiciones compuestas, podemos utilizar opera-
dores lógicos como & en reemplazo del and, y | en reemplazo del or. Veamos un ejemplo:

>> import numpy as np

>> m1 = np.array([[2, 4, 6, 8, 10],

>> [1,-1, 2,-2, 0],
>> [1, 4, 9, 16,25]])

>> print(m1[m1 % 2 == 0]) Extrae los pares

>> print(m1[(m1 > 5) & (m1 % 2 == 1)]) Extrae los impares mayores a 5
>> print(m1[(m1 < 0) | (m1 > 10)]) Extrae los menores a cero y mayores a 10

>> m1[m1 % 4 == 0] = 100 Reemplaza los múltiplos de 4 por 100

2.2 Librerı́a Numpy 33

Operaciones con arreglos 2 - dimensionales

Si consideramos a los arrays de dos dimensiones como matrices, es posible considerar las
operaciones clásicas del álgebra lineal tal como veremos a continuación:

matriz 1 + matriz2 Suma de matrices

matriz 1 - matriz2 Resta de matrices

k * matriz Producto por escalar

np.dot(matriz1, matriz2) Producto de matrices

np.linalg.inv(matriz) Inversa de una matriz

Otras funciones que podemos aplicar a matrices son:

np.linalg.det(matriz) Determinante de una matriz

np.trace(matriz) Traza de una matriz

np.linalg.matrix rank(matriz) Rango de una matriz

Por último, es posible utilizar arreglos 2-dimensionales (matrices) para resolver sistemas de
ecuaciones lineales, pasando directamente la amtriz de coeficientes y la amtriz de resultados.

np.linalg.solve(A, b) Resuelve el sistema A · x = b

Veamos algunos ejemplos. El siguiente código tiene un programa que considera varias ma-
trices y eraliza diferentes operaciones con ellas.

>> import numpy as np

>> A = np.array([[3, 2, -2], Definición de matrices

>> [2, -1, 3],
>> [1, 4, 2 ]])

>> b = np.array([[0 ],
>> [9 ],
>> [-4]])

>> m1 = np.array([[1, 2, 3],

>> [4, 5, 6],
>> [7, 8, 9]])

>> suma = m1 + A Operaciones con matrices

>> resta = m1 - A

>> prod escalar = 5 * m1

>> producto = np.dot(m1, A)
>> inversa = np.linalg.inv(m1)

>> sistema = np.linalg.solve(A,b)

2.3 Librerı́a Pandas 34

2.3. Librerı́a Pandas

Pandas es una librerı́a no integrada de Python que se especializa en el manejo y análisis de
estructuras de datos. Permite la manipulación de información en tablas organizadas llama-
das dataFrames por medio del lenguaje de la librerı́a numpy.

Como esta librerı́a no viene integrada en Python, es necesario descargarla de la web para
poder implementarla en nuestros programas. Para ello, abrimos la terminal de VS Code y
escribimos lo siguiente:
pip3 install pandas
Una vez instalada, puede ser invocada al programa principal para utilizar sus funciones. El
importe se hace de la siguiente forma:

import pandas

Generalmente se abrevia el nombre del módulo con la expresión “pd”. Los principales objetos
que vamos a estudiar en este módulo son:

Series

DataFrames

Estudiaremos y profundizaremos a continuación cada uno de estos temas.

2.3.1. Series y DataFrames

Una serie es un objeto unidimensional similar a un array que puede contener cualquier tipo
de datos. Está etiquetado con un ı́ndice, lo que significa que puedes acceder a los elementos
de la serie utilizando etiquetas en lugar de ı́ndices numéricos.

Índice 0 1 2 3
Valor Enero Febrero Marzo Abril

Un dataframe es una estructura bidimensional que se utiliza para almacenar y manipular

datos tabulares (como una hoja de cálculo). Puedes pensar en un dataframe como una
colección de series.

Columnas
Índice Nombre Dı́a Mes Año
0 Alice 23 Enero 2005
Filas 1 Bob 18 Febrero 1992
2 Charles 31 Marzo 2022
3 Dan 4 Abril 1983

Para crear un dataFrame en Python, utilizamos la siguiente función:

nombre DF = pd.DataFrame({clave : valor}, index = [indice1, indice2, ...])

Este método crea un dataframe por medio de un diccionario. Las claves son los encabezados
y los valores son los datos que ingresamos a las columnas.
2.3 Librerı́a Pandas 35

Por defecto, los ı́ndices parten en cero y van aumentando uno a uno marcando cada una de
las filas. Si queremos cambiar sus etiquetas, podemos agregar el parámetro index y pasarle
una lista con los nombres que queremos darles. Veamos un ejemplo:

>> import pandas as pd

>> bbdd1 = pd.DataFrame({“Nombre”:[”Daniel”, ”Yordan”, ”Javier”],

>> “Edad” : [25, 23, 31],
>> “Carrera” : [”Pedagogı́a”, ”Ingenierı́a civil”, ”Psicologı́a”]})

>> bbdd2 = pd.DataFrame({“Edad”:[18, 20, 23, 23, 24],

>> “Curso”:[1, 3, 5, 5, 6]},
>> index = [”Yordan”, ”Daniel”, ”Carla”, ”Javier”, ”Carlos”])

Podemos cambiar el nombre de las filas y columnas por medio de las siguientes funciones:
nombre DF = nombre DF.rename(index = {nombre antiguo : nombre nuevo})
nombre DF = nombre DF.rename(columns = {nombre antiguo : nombre nuevo})
Veamos un ejemplo sencillo de como aplicar estas funciones:

>> import pandas as pd

>> df = pd.DataFrame(“Nombre”:[”Yordan”, ”Daniel”], ”Edad”:[23,22])

>> df = df.rename(index = 0 : ”Persona 1”)

>> df = df.rename(columns = ”Nombre” : ”Persona”)

------------------------------------------------------------

Para crear una serie, utilizaremos la siguiente función:

nombre S = pd.Series([datos de la serie], name = “nombre”, index = [indices])
Las series no presentan etiqueta de columna, solo de fila, por lo que podemos entender a
las series como columnas de un Dataframe. Veamos un ejemplo:

>> import pandas as pd

>> s1 = pd.Series([”Perro”, ”Gato”, ”Pez”], name = ”Animales”)

>> s2 = pd.Series([23, 25, 30], name = ”Edad”, index = [”Carla”, ”Javier”, ”Felipe”])

Tenemos algunas funciones especiales de la librerı́a pandas que permiten analizar los datos
del DataFrame. Estos son:
nombre DF.describe( ) Análisis estadı́stico
nombre DF.dtypes Tipo de dato por columna
nombre DF.shape Orden del DataFrame
Los tipos de datos son “int” para valores enteros, “float” para decimales y “object” para
cadenas de texto o strings.
2.3 Librerı́a Pandas 36

2.3.2. Extracción y modificación de datos

Podemos extraer y modificar elementos especı́ficos de un dataframe de la siguiente manera:

nombre dataframe.loc[fila, columna]

nombre dataframe.loc[fila, columna] = nuevo valor

Podemos extraer filas o columnas especı́ficas de un dataframe con las siguientes funciones:

nombre dataframe.loc[fila]

nombre dataframe[columna]

Podemos extraer más de una fila o más de una columna a la vez. Esto se hace con las
siguientes funciones:

nombre dataframe.loc[[fila1, fila2, ...]]

nombre dataframe[[columna1, columna2, ...]]

Podemos extraer un subdataframe sleccionando especı́ficamente las filas y columnas que

necesitamos. Para esto, utilizamos la siguiente función:

nombre dataframe.loc[fila n : fila m, columna n : columna m]

Veamos un ejemplo sencillo de como crear un dataframe y utilizar las funciones antes vistas
para analizar y seleccionar datos:

>> import pandas as pd

>> df = pd.DataFrame({
>> ”Nombre” : [”Javier”, ”Carlos”, ”Daniel”, ”Valentina”],
>> ”Apellido” : [”Iturra”, ”Alvarado”, ”Silva”, ”Pérez”],
>> ”Edad” : [17, 24, 36, 27],
>> ”Carrera” : [”Psicologı́a”, ”Ingenierı́a”, ”Pedagogı́a”, ”Enfermerı́a”]
>> })

>> df.loc[2, ”Carrera”] = ”Pedagogı́a en inglés”

>> daniel = df.loc[2]

>> carreras = df[”Carrera”]

>> carlos valentina = df.loc[[1, 2, 3]]

>> nombre edad = df[[”Nombre”, ”Apellido”, ”Edad”]]

>> carlos daniel apellido edad = df.loc[1:2, ”Apellido”:”Edad”]

>> print(carlos daniel apellido edad)

El uso adecuado de estas funciones nos permite filtrar tablas de datos para analizar lo que
estimemos conveniente.
2.3 Librerı́a Pandas 37

2.3.3. Crear y modificar filas y columnas

Podemos crear una nueva fila en el dataframe por medio de la siguiente función:

nombre DF.loc[len(nombre DF)] = [nueva fila]

De la misma forma, podemos agregar nuevas columnas en el dataframe por medio de la

función:

nombre DF[nombre nueva columna] = [nueva columna]

Veamos un ejemplo donde consideramos un dataset y creamos una tabla de frecuencias para
su respectivo análisis:

>> import numpy as np

>> import pandas as pd

>> muestra = np.array([50, 38, 43, 56, 51, 36, 25, 33, 41, 44,
>> 34, 39, 49, 37, 40, 50, 50, 35, 22, 45,
>> 44, 38, 14, 44, 51, 27, 44, 39, 50, 35,
>> 31, 34, 48, 48, 30, 42, 26, 35, 32, 63,
>> 36, 38, 53, 23, 39, 45, 37, 31, 39, 53])

>> tabla frec = pd.DataFrame({

>> ”Clases” : np.unique(muestra, return counts=True)[0],
>> ”f” : np.unique(muestra, return counts=True)[1]
>> })

>> valor = 0
>> frecuencia acumulada = [ ]

>> for i in np.unique(muestra, return counts=True)[1]:

>> valor += i
>> frecuencia acumulada.append(valor)

>> tabla frec[”F”] = frecuencia acumulada

>> tabla frec[”fr”] = tabla frec[”f”]/50
>> tabla frec[”Fr”] = tabla frec[”F”]/50
>> tabla frec[”fr %”] = tabla frec[”fr”]*100
>> tabla frec[”Fr %”] = tabla frec[”Fr”]*100

2.3.4. Cargar y guardar datos en un Pandas

Podemos cargar datos a nuestros programas por medio de funciones del módulo Pandas.
Estos archivos pueden ser de cualquier tipo, sin embargo, es usual trabajar con Excel o
datos de tipo CSV. Para cargar datos, utilizamos la siguiente función:

nombre variable = pd.read excel(“ruta”)

Para facilitar el manejo de datos, es costumbre crear el excel y almacenarlo dentro de la

carpeta de Python. Esto facilita la dirección del archivo.
2.3 Librerı́a Pandas 38

Si el archivo no está en la carpeta de Python, debemos copiar su dirección y agregarla al

pandas. Es importante recordar que la separación de las rutas se hace con /.

>> import pandas as pd

>> excel1 = pd.read excel(”C:/Users/Yordan Aguilar Ruiz/Downloads/Módulos.xlsx”)

>> excel2 = pd.read excel(”Base de datos.xlsx”)

Una vez creado un dataframe, es posible guardarlo en nuestro computador. La idea de esto
es generar una copia de la información utilizada en el programa, ası́, no se pierde si se cierra
la aplicación. Para esto, utilizamos la siguiente función:

nombre DF.to excel(“nombre archivo.xlsx”, index = True / False)

El parámetro index = false es para almacenar los datos del dataframe sin los tı́tulos de las
columnas y los identificadores de las filas. Si ponemos True, si se guardarán.

>> import pandas as pd

>> datos = pd.DataFrame({

>> ”Nombre”: [”Yordan”, ”Daniel”],
>> ”Edad” : [23, 41],
>> ”Apellido”: [”Aguilar”, ”Varas”],
>> ”Carrera”: [”Ingenierı́a Civil”, ”Psicologı́a”]
>> })

>> datos.to excel(”BBDD.xlsx”, index = True)

Es posible cargar otro tipo de archivos distintos a excel, como CSV, Json, PDF, etc.
Capı́tulo 3

Introducción a la visualización de
datos en Python

En esta unidad, nos sumergiremos en el fascinante mundo de la visualización de datos uti-

lizando la biblioteca Matplotlib en Python. La capacidad de representar datos de manera
gráfica es fundamental para entender patrones, identificar tendencias y comunicar eficaz-
mente resultados.

A lo largo de esta unidad, aprenderás a crear gráficos de lı́neas, barras, dispersión y más,
utilizando Matplotlib. Comenzaremos desde lo básico, como la instalación y configuración,
y avanzaremos hacia técnicas más avanzadas de personalización y exploración de diferentes
tipos de gráficos.

Al final de esta unidad, no solo serás capaz de crear visualizaciones impresionantes, sino
que también comprenderás cómo estas herramientas pueden potenciar tu capacidad para
extraer información valiosa de tus datos.

Introducción a la visualización de datos

Existen varias bibliotecas diseñadas para la visualización de datos en Python, sin embargo,
la más sencilla de utilizar, y a la vez completa, es MatPlotLib. Esta librerı́a se especializa en
el trazado de gráficas 2D, sin embargo, también es posible utilizarla al momento de trazar
superficies en el espacio. Comencemos viendo como implementarla.

MatPlotLib, al ser una biblioteca no integrada de Python, requiere ser descargada e ins-
talada en nuestro sistema operativo. Para realizar dicha actividad, utilizamos el siguiente
código en la terminal de VS Code:

pip3 install matplotlib

Una vez instalada, se procede a importar. Es usual trabajar con un módulo especial de esta
librerı́a llamado pyplot.
import matplotlib.pyplot as plt
Este módulo nos entrega una serie de herramientas de diseño para la personalización y
modificación de los gráficos.
3.1 Gráficos cartesianos 40

3.1. Gráficos cartesianos

El diseño de gráficos en Python se realiza, generalmente, en dos partes. La primera parte
es la construcción y personalización del gráfico, y la segunda es la carga y muestra del gráfico.

Comencemos estableciendo la base de nuestros gráficos, el plano cartesiano sobre el cual

graficaremos.

El método plt.figure(figsize = (ancho, largo)) establece el tamaño del script donde

graficaremos.

El método plt.xlim(xmin , xmax ) establece el valor mı́nimo y el valor máximo donde se

moverá el eje x.

El método plt.ylim(ymin , ymax ) establece el valor mı́nimo y el valor máximo donde se

moverá el eje y.

El método plt.xticks([x0 , x1 , ...]) establece las etiquetas que se mostrarán en el eje x.

El método plt.yticks([y0 , y1 , ...]) establece las etiquetas que se mostrarán en el eje y.

El método plt.show( ) permite mostrar la gráfica.

Veamos un ejemplo de un gráfico simple creado con estas instrucciones.

-------------------------------------------------------------

El método plt.xlabel(“titulo”) permite agregar un tı́tulo al eje x.

El método plt.ylabel(“titulo”) permite agregar un tı́tulo al eje y.

El método plt.title(“titulo”) permite agregar un tı́tulo al gráfico.

Estas funciones admiten otros parámetros especiales para mejorar y personalizar su formato.
Estas funciones se indican a continuación:
3.1 Gráficos cartesianos 41

El método color = “color” le dá un color al texto. Podemos pasar un color en inglés
o uno en formato hexadecimal.

El método fontsize = “número” cambia el tamaño del texto.

El método fontname = “tipo” cambia el tipo de texto.

El método fontweight = “bold” deja el texto en negrita.

Veamos un ejemplo de un gráfico simple creado con estas instrucciones.

-------------------------------------------------------------

El método plt.grid( ) establece una grilla sobre el plano cartesiano.

Esta función admite otros parámetros opcionales para controlar su formato. Algunas de
estas son:

El método color = “color” le dá un color a la grilla. Podemos pasar un color en inglés
o uno en formato hexadecimal.

El método lw = número modifica el grosor de las lı́neas de la grilla.

El método alpha = número controla la transparencia de la grilla con 0 ≤ alpha ≤ 1.

El método linestyle = “estilo” cambia el estilo de las lı́neas de la grilla. Puede ser uno
de los siguientes: - - - -. :

El método axis = “eje” permite controlar las lı́neas que se mostrarán en la grilla. Si
ponemos “x” solo se mostrarán las lı́neas verticales y si ponemos “y” se muestran solo
las horizontales.

-------------------------------------------------------------

El método plt.legend( ) establece una leyenda para marcar los diferentes objetos que
agregemos al gráfico.

Esta función admite un parámetro opcional llamado loc = “localización”. Esto nos permite
ubicar la layenda donde nosotros queramos. Por defecto es “best” que es la mejor posición
3.1 Gráficos cartesianos 42

pero nosotros podemos modificarla y dejarla donde queramos según el siguiente cuadro de
posiciones:

upper left upper center upper right

center left center center right
lower left lower center lower right

-------------------------------------------------------------

El método plt.text(x0 , y0 , “texto”) permite escribir textos sobre el plano indicándo

las coordenadas x e y donde queremos ubicarlo.

Esta función admite otros parámetros especiales para mejorar y personalizar su formato.
Dentro de las principales están:

El método color = “color” le dá un color al texto. Podemos pasar un color en inglés
o uno en formato hexadecimal.

El método fontsize = “número” cambia el tamaño del texto.

El método fontname = “tipo” cambia el tipo de texto.

El método fontweight = “bold” deja el texto en negrita.

Veamos un ejemplo de un gráfico simple creado con estas instrucciones.

El texto puede ser escribo en lenguaje LaTex, para ello, utilizamos las instrucciones dentro
de $...$. Podemos rotar pasando rotate = angulo.

-------------------------------------------------------------

El método plt.axhline(y = k) permite crear una recta horizontal de ecuación y = k.

El método plt.axvline(x = k) permite crear una recta vertical de ecuación x = k.

Podemos utilizar estas rectas para crear los ejes del plano, tanto el eje x como el eje y.
3.2 Gráfica de puntos, segmentos y vectores 43

Esta función admite otros parámetros especiales para mejorar y personalizar su formato.
Dentro de las principales están:

El método color = “color” le dá un color al texto. Podemos pasar un color en inglés
o uno en formato hexadecimal.

El método lw = número modifica el grosor de la lı́nea.

3.2. Gráfica de puntos, segmentos y vectores

Podemos graficar puntos en el plano cartesiano por medio de la función plt.scatter. Esta
se explica a continuación:

x = [x1 , x2 , ..., xn ]

y = [y1 , y2 , ..., yn ]

El método plt.scatter(x,y) permite graficar todos los puntos indicados por las listas
del eje x y del eje y.

Esta función admite otros parámetros para el control del formato. Las principales son:

color = “color” modifica el color de los puntos.

edgecolor = “color” modifica el color del contorno de los puntos.

s = numero permite modificar el grosor del punto.

zorder = numero permite superponer los puntos sobre otros objetos del plano.

alpha = numero modifica la transparencia del punto. 0 ≤ alpha ≤ 1.

label = “nombre” permite poner un nombre a los puntos. Este será el nombre que
indicaremos en la leyenda.

Veamos un ejemplo de como utilizar estas funciones para la creación de puntos en el plano.

Podemos combinar puntos con segmentos para crear figuras geométricas poligonales.
3.2 Gráfica de puntos, segmentos y vectores 44

Podemos graficar segmentos en el plano cartesiano por medio de la función plt.plot. Esta
se explica a continuación:
x = [x1 , x2 , x3 , ..., xn ] y = [y1 , y2 , y3 , ..., yn ]

El método plt.plot(x,y) permite graficar segmentos que vayan desde (xi , yi ) hasta
(xi+1 , yi+1 ) siguiendo ordenadamente las listas.
Esta función admite otros parámetros para el control del formato. Las principales son:
color = “color” modifica el color de los puntos.

lw = numero permite modificar el grosor del segmento.

linestyle = “estilo” modificar el estilo del segmento. - -- -. :

alpha = numero modifica la transparencia del segmento. 0 ≤ alpha ≤ 1.

zorder = numero permite superponer los segmentos sobre otros objetos del plano.

label = “nombre” permite poner un nombre a los segmentos. Este será el nombre que
indicaremos en la leyenda.
-------------------------------------------------------------
Podemos sombrear un área del plano por medio de la función plt.fill. Esta, en conjunto
con los puntos y segmentos, permite la creación de figuras geométricas.
x = [x1 , x2 , x3 , ..., xn ] y = [y1 , y2 , y3 , ..., yn ]

El método plt.fill(x,y) permite sobrear la región limitada por los puntos indicados.
Algunos parámetros que podemos agregar a esta función son:
color = “color” modifica el color de los puntos.

alpha = numero modifica la transparencia del segmento. 0 ≤ alpha ≤ 1.

zorder = numero permite superponer los segmentos sobre otros objetos del plano.
3.3 Gráfica de funciones en R2 45

Podemos graficar vectores en el plano cartesiano por medio de la función plt.quiver. Esta
se explica a continuación:

El método plt.quiver(x0 , y0 , x+ , y+ , angles = “xy”, scale = 1, scale units=“xy”) crea

un vector que parte en (x0 , y0 ) y se mueve x+ unidades en el eje x y y+ unidades en
el eje y.

Algunos parámetros opcionales que podemos agregar para mejorar la gráfica son:

color = “color” modifica el color del vector.

width = numero modifica el grosor del vector.

alpha = numero modifica la transparencia del vector. 0 ≤ alpha ≤ 1.

zorder = numero superpone vectores frente a otros objetos del plano.

label = “nombre” le dá un nombre al vector. Este será el nombre que veremos en la
leyenda, en caso de que esta esté activada.

Veamos un ejemplo de como utilizar estas funciones para la creación de vectores.

3.3. Gráfica de funciones en R2

Podemos graficar una función considerando arreglos y elementos del módulo numpy. Las
principales funciones a considerar son:

x ** n Potencia np.sqrt(x) Raı́z cuadrada

np.exp(x) Exponencial base e np.log(x) Logarı́tmo natural

np.sin(x) Seno np.cos(x) Coseno

np.tan(x) Tangente np.arcsin(x) Arcoseno

3.3 Gráfica de funciones en R2 46

np.arccos(x) Arcocoseno np.arctan(x) Arcotangente

El procedimiento para graficar una función en el plano cartesiano es el siguiente:

x = np.arange(a,b,c) Dominio de la función
y = función Expresión algebraica que define a la función
plt.plot(x, y) Grafica la función
Podemos agregar parámetros opcionales para mejorar la gráfica. Algunos de ellos son:
color = “color” modifica el color de la gráfica.
lw = numero modifica el grosor de la función.
linestyle = “estilo” modificar el estilo de la gráfica. - -- -. :
label = “nombre” agrega un nombre a la gráfica. Este será el que veremos en la leyenda
en caso de que esta esté activada.
Podemos graficar más de una función sobre el plano, para ello, basta definir su dominio y
su expresión nuevamente y utilizar plt.plot.

-------------------------------------------------------------
Podemos sombrear el área entre curvas por medio de la función plt.fill between. Esto
se hace de la sigueinte manera:
El método plt.fill between(x, y1, y2) permite sombrear el área entre las funciones y1
y y2 considerando su mismo dominio.
Podemos agregar parámetros para mejorar la gráfica de la siguiente forma:
where = (y1 > y2) indica donde se debe sombrear la curva. En este caso, donde la
función y1 esté sobre la función y2. Podemos dar condiciones con & y |.
color = “color” permite modificar el color del sombreado.
alpha = numero permite modificar la transparencia del sombreado. (0 ≤ alpha ≤ 1)

Para el área entre dos puntos escribimos plt.fill between(x, y, where = ((x>a) & (x<b))).
3.3 Gráfica de funciones en R2 47

Podemos poner varios gráficos en un solo script. Para esto, debemos crear cada uno de
los gráficos por separado y luego ir personalizándolos uno por uno.

El método fig,(ax1, ax2, ...) = plt.subplots(nrows = m, ncols = n, figsize = (a, b))

crea varios scripts para poner distintos gráficos. El parámetro figsize = (a,b) establece
el tamaño del script.

Si queremos mostrar el script, usamos plt.show( ) igual que antes. Para modificar los gráfi-
cos, vamos accediendo uno por uno por medio del nombre ax1, ax2, ... y anteponiendo el
término “set ” antes de cada función.

Podemos agregar un tı́tulo general al script por medio de la función plt.suptitle(“titulo”).

Esta función admite algunos parámetros como:

El método color = “color” le dá un color al texto. Podemos pasar un color en inglés
o uno en formato hexadecimal.

El método fontsize = “número” cambia el tamaño del texto.

El método fontname = “tipo” cambia el tipo de texto.

El método fontweight = “bold” deja el texto en negrita.

Veamos un ejemplo de como utilizar estas funciones para hacer dos gráficos en un solo
script.

Se pueden utilizar gráficos dobles para comparar y analizar dos o más funciones del plano.
3.4 Gráficos estadı́sticos 48

3.4. Gráficos estadı́sticos

Una aplicación importante del la librerı́a matplotlib es el diseño de gráficos estadı́sticos. A
continuación estudiaremos como construir algunos de los más importantes.

Gráfico de puntos o de dispersión

Para crear un gráfico de puntos (o de dispersión) debemos utilizar el siguiente código de
programación:

x = [x1 , x2 , x3 , ..., xn ] Observaciones eje x

y = [y1 , y2 , y3 , ..., yn ] Observaciones eje y

plt.scatter(x, y) Gráfica

Algunos parámetros opcionales que podemos añadir a la gráfica son los siguientes:

marker = “marcador” añade marcadores a la gráfica. s o x

markersize = numero modifica el tamaño de los marcadores.

s = numero modifica el tamaño de los marcadores.

alpha = numero modifica la transparencia de los marcadores.

color = “color” modifica el color de la gráfica, incluyendo los marcadores.

label = “nombre” agrega un nombre a la gráfica. Este será el que veremos en la

leyenda, en caso de que esta esté activada.

Podemos graficar una serie de observaciones y calcular la recta de regresión lineal utilizando
el módulo statistics. Veamos un ejemplo:

Recordemos que la pendiente y el intercepto de la recta de regresión lineal se calcula con la

función st.linear regression(x,y) del módulo statistics.
3.4 Gráficos estadı́sticos 49

Gráfico de lı́neas o polı́gono de frecuencia

Para crear un gráfico de lı́neas (o polı́gono de frecuencia) debemos utilizar el siguiente
código de programación:
x = [x1 , x2 , x3 , ..., xn ] Clases o datos (puede ser texto)
y = [y1 , y2 , y3 , ..., yn ] Frecuencias
plt.plot(x, y) Gráfica
Algunos parámetros opcionales que podemos añadir a la gráfica son los siguientes:
marker = “marcador” añade marcadores a la gráfica. s o x
markersize = numero modifica el tamaño de los marcadores.
color = “color” modifica el color de la gráfica.
linestyle = “estilo” modifica el estilo de la gráfica. - -- -. :
label = “nombre” agrega un nombre a la gráfica. Este será el que veremos en la
leyenda, en caso de que esta esté activada.
Veamos un ejemplo de como crear un gráfico de lı́neas utilizando el código antes descrito.

Podemos utilizar gráficos dobles para comparar un polı́gono de frecuencia absoluta con uno
de frecuencia acumulada.
3.4 Gráficos estadı́sticos 50

Gráfico de barras - Variables discretas

Para crear un gráfico de barras vertical debemos utilizar el siguiente código de progra-
mación:

x = [x1 , x2 , x3 , ..., xn ] Clases o datos (puede ser texto)

y = [y1 , y2 , y3 , ..., yn ] Frecuencias

plt.bar(x, y) Gráfica

El gráfico de barras horizontal se crea con la instrucción plt.barh(x,y). Estas funciones

admiten ciertos parámetros para personalizar su estructura. Las principales funciones son:

color = “color” modifica el color de las barras del gráfico. Puede entregarse en inglés
o en formato hexadecimal.

edgecolor = “color” cambia el color del contorno de las barras.

width = numero modifica el ancho de las barras. Si es un gráfico de barras horizontales

cambiamos esta instrucción por height = numero.

linewidth = numero modifica el grosor del contorno de las barras.

alpha = numero modifica la transparencia de las barras. (0 ≤ alpha ≤ 1)

Veamos un ejemplo de como crear gráficos de barra, tanto verticales como horizontales,
utilizando las funciones de personalización.

Estos gráficos pueden ser útiles tanto para variables cuantitativas como cualitativas.
3.4 Gráficos estadı́sticos 51

Histograma - Variables continuas

Para crear un histograma debemos utilizar el siguiente código de programación:

datos = [x1 , x2 , x3 , ..., xn ] Clases o datos (puede ser texto)

plt.hist(datos, bins = cantidad de barras) Gráfica

Esta sentencia admite ciertos parámetros para personalizar su estructura. Las principales
funciones son:

color = “color” modifica el color de las barras del gráfico. Puede entregarse en inglés
o en formato hexadecimal.

edgecolor = “color” cambia el color del contorno de las barras.

linewidth = numero modifica el grosor del contorno de las barras.

alpha = numero modifica la transparencia de las barras. (0 ≤ alpha ≤ 1)

orientation = horizontal permite cambiar la orientación del gráfico. Por defecto es

vertical.

Veamos un ejemplo de como crear un histograma utilizando las funciones de personalización.

Es común utilizar algunas funciones especiales para mejorar el diseño de los histogramas.
Se recomienda calcular el número de intervalos y la amplitud de estos mismos por medio
de las siguientes ecuaciones:
r
k = 1 + 3.322 · log(n) r = xmáx − xmı́n a=
k
En este caso, k es el número aproximado de intervalos, r es el rango de los datos y a es la
amplitud.

Otra cosa a considerar es que, los histogramas, son gráficos diseñados para variables estric-
tamente cuantitativas, no se pueden emplear para otro tipo de variables como los gráficos
de barra. El eje base de las barras deben ser números.
3.4 Gráficos estadı́sticos 52

Box plot o gráfico de caja y bigote

Para crear un box plot (o diagrama de caja y bigotes) debemos utilizar el siguiente código
de programación:
datos = [x1 , x2 , x3 , ..., xn ] Datos del boxplot

nombre = [“nombre boxplot”] Nombre del boxplot

plt.boxplot(datos, labels = nombre) Gráfica

Esta sentencia admite ciertos parámetros para personalizar su estructura. Las principales
funciones son:
vert = False modifica el boxplot y lo deja en forma horizontal.

showfliers = False oculta los outliers.

Podemos poner varios boxplot en un solo gráfico, para ello, debemos modificar las instruc-
ciones de creación de la siguiente forma:
datos = [[x1 , ..., xn ], [y1 , ..., yn ], [z1 , ..., zn ], ...]

nombres = [“nombre 1”, “nombre 2”, ..., “nombre n”]

plt.boxplot(datos, labels = nombres)

Veamos algunos ejemplos de como construir boxplot para analizar el comportamiento de
los datos de una muestra estadı́stica.

Estos gráficos indican la normalidad de los datos cuando la mediana está en el centro.
3.4 Gráficos estadı́sticos 53

Pie chart o gráfico circular

Para crear un gráfico circular (o pie chart) debemos utilizar el siguiente código de pro-
gramación:

etiquetas = [“et 1”, “et 2”, ..., “et n”] Etiquetas

porcentajes = [pt 1, pt 2, ..., pt n] Porcentajes. Suman 100 %

fig, ax = plt.subplots() Crea la figura y los ejes

ax.pie(porcentajes, labels = etiqueta) Gráfica

ax.axis(“equal”) Asegura la forma circular

Esta sentencia admite ciertos parámetros para personalizar su estructura. Las principales
funciones son:

startangle = numero ı́ndica el ángulo donde comenzará la gráfica.

autopct = “ %1.0f % %” permite agregar los porcentajes al gráfico. El número despues

del punto indica la cantidad de decimales.

pctdistance = distancia modifica la distancia de los porcentajes. Entre 0 y 1.

shadow = True modifica el gráfico y crea una sombra.

explode = [sacados] permite sacar algunas rebanadas del gráfica para hacerlas sobre-
salir. Las que no queremos sacar las indicamos con cero.

wedgeprops = dict(width = radio) permite transformar el gráfico circular en un anillo.

colors = [colores] permite modificar los colores de cada rebanada del gráfico.

Veamos algunos ejemplos de como construir un gráfico circularutilizando las funciones de

personalización antes vistas.

Los gráficos circulares, de anillo o de torta son especialmente útiles cuando se analiza va-
riables cualitativas. Permite analizar la distribución y la frecuencia porcentual de los datos
para ası́ conocer las clases más relevantes del dataset.
3.5 Procesamiento de imágenes 54

3.5. Procesamiento de imágenes

Otra biblioteca importante para la visualización de información, eesta vez de imágenes, es
Pillow. Esta es una librerı́a no integrada de Python que permite importar, modificar y
almacenar imágenes para ser utilizadas por nuestros programas. Para poder descargarla en
nuestro sistema debemos utilizar el siguiente código en la terminal de VS Code:
pip3 install pillow
Una vez instalada, se procede a importar:
from PIL import Image
Este módulo nos entrega una serie de herramientas de diseño y manejo de imágenes.

Importe y guardado de imágenes

Para cargar imágenes a nuestros programas, debemos utilizar el siguiente código:
nombre variable = Image.open(“dirección imagen”) Carga la imágen
nombre variable.show() Muestra la imagen
Es costumbre crear una carpeta en el directorio de Python donde guardemos todas las
imágenes que vamos a utilizar, en cuyo caso la dirección será:
“nombre carpeta / nombre imagen”
Si las tenemos en otro lugar, podemos pasar su dirección especı́fica, pero debemos cambiar
todos los “\” por “/” para que no entregue error.

-------------------------------------------------------------

Podemos analizar algunas caracterı́sticas de la imágen por medio de las siguientes funciones:
El método nombre imagen.format indica el formato de la imágen (png, jpg, ...)
El método nombre imagen.size indica la resolución de la imágen en pixeles.
Veamos un ejemplo de como cargar imágenes y como analizar sus caracterı́sticas.
3.5 Procesamiento de imágenes 55

Podemos guardar una imágen cargada al programa donde nosotros le indiquemos. Para ello,
debemos utilizar la siguiente función:

nombre Imagen.save(“dirección”)

Podemos ingresar imágenes al programa, modificarlas y guardarlas arregladas en donde

queramos. Se acostumbranm a guiardar en carpetas destinadas a eso.

Modificación de imágenes y uso de filtros

Una imágen es una “matriz” de superficies llamadas pixeles que tienen asociado un valor
numérico que indica su color y su brillo. Cada pı́xel representa un punto en la imagen. La
mayorı́a de las imágenes se componen de tres canales de color: rojo, verde y azul (RGB).
Por lo tanto, cada pı́xel en una imagen RGB se representa mediante tres valores numéricos,
uno para cada canal.
Si representamos una imagen en una matriz, cada elemento de la matriz corresponderá a un
pı́xel y contendrá los valores numéricos de los canales de color. La dimensión de la matriz
dependerá del tamaño de la imagen.
Mientras más pixeles tenga una imágen, mejor resolución tendrá.

Veamos algunas funciones del módulo PIL para modificar las imágenes y aplicar filtros:

nom var = nom imagen.resize((ancho, largo)) Redimensiona una imágen

nom var = nom imagen.crop((Left, U, R, Lower)) Recorta una imágen

Al recortar una imagen debemos tener cuidado con las dimensiones que damos. Tanto la
izquierda como la derecha se miden desde la izquierda y tanto la parte de arriba como la
de abajo se miden desde arriba. Por ende, la derecha debe ser mayor a la izquierda y la
medida de abajo debe ser mayor a la medida de arriba.

imagen fondo.paste(imagen a pegar, (x,y))

Esta función permite pegar una imágen sobre otra. Las coordenadas (x, y) indican la posición
donde pegaremos la imágen. Podemos recortar o redimensionar la imagen que pegaremos.

nombre variable = imagen.rotate(angulo)

Esta función permite rotan una imágen en el ángulo que nosotros deseemos. El ángulo debe
ser entregado en grados sexagesimales.

La combinación de estas funciones permite modificar imágenes como mejor nos parezca.
Una vez modificada, las podemos guiardar con la función save( ).
3.5 Procesamiento de imágenes 56

Veamos un ejemplo de como utilizar estas funciones para recortar y pegar imágenes sobre
otras.

Si nos damos cuenta, las imágenes pegadas presentan un fondo negro. Idealmente, no de-
verı́an tenerlo, por tal razón es que veremos a continuación como pegar imágenes sin fondo:

Paso 01
Se carga la imagen de fondo y la imágen a pegar. Esta se debe convertir a formato RGBA.

fondo = Image.open(“dirección”)

imagen a pegar = Image.open(“dirección”).convert(“RGBA”)

Paso 02
Se redimensiona la imágen que se va a superponer sobre el fondo.

imagen a pegar = imagen a pegar.resize((ancho, largo))

Paso 03
Se crea una nueva imágen completamente transparente donde pegaremos la imagen a su-
perponer ya redimensionada.

imagen nueva = Image.new(“RGBA”, fondo.size, (0,0,0,0))

En este caso, fondo.size permite crear una imágen transparente del mismo tamaño del fondo
y el vector (0,0,0,0) lo deja transparente.

Paso 04
Se pega ahora la imágen que vamos a superponer sobre la imágen transparente recién creada.

imagen nueva.paste(imagen a pegar, (x,y))

Paso 05
Se vuelve a montar la imágen transparente sobre el fondo original, ahora con la imagen ya
superpuesta.

fondo = Image.alpha composite(fondo.convert(“RGBA”), imagen nueva)

En este caso, la función alpha composite permite fusionar dos imágenes considerando la
transparencia de la nueva imágen.
3.5 Procesamiento de imágenes 57

Veamos un ejemplo de como utilizar estas funciones para recortar y pegar imágenes sobre
otras considerando un fondo transparente.

Por último, el módulo Pillow nos permite aplicar determinados filtros a las imágenes para
cambiar su aspecto. Para ello, lo primero que debemos hacer es importar el siguiente módulo:

from PIL import ImageFilter

Una vez hecho esto, utilizamos la siguiente función para aplicar filtros a imágenes:

nombre imagen.filter(filtro)

Los principales filtros a utilizar, son:

ImageFilter.BLUR

ImageFilter.CONTOUR

ImageFilter.EMBOSS

ImageFilter.FIND EDGES

Esto finaliza la unidad de introducción a la visualización de datos en Python.

Capı́tulo 4

Estrategias para la programación

eficiente

En el mundo de la programación, la eficiencia es un factor clave para el desarrollo de software

robusto y de alto rendimiento. A medida que los proyectos crecen en complejidad y tamaño,
la atención a la eficiencia se vuelve crucial para garantizar la rapidez y la escalabilidad del
software, por tal razón, es que en esta unidad nos dedicaremos a explorar diversas estrategias
y técnicas diseñadas para optimizar la ejecución de programas escritos en Python.

Importe y organización de módulos

Se recomienda importar solo las funciones, clases o variables que se necesitan de un módulo
especı́fico. Esto evita posibles conflictos de nombres y disminuye la sobrecarga de informa-
ción innecesaria (infoxicación digital).

También es recomendable, de ser necesario, aplicar un alias a los objetos importados para
mejorar la legibilidad del código y facilitar la programación.

No traer módulos completos al programa principal si no se utilizarán todas sus funciones.

Se recomienda crear módulos con nombres únicos para evitar problemas de importación.

Por último, se recomienda utilizar paquetes para organizar módulos y legibilizar el código.
A su vez, se recomienda establecer carpetas especı́ficas para almacenar las imágenes, bases
de datos, entre otros.

Documentación de funciones, clases y módulos

Cuando desarrollamos programas, es necesario dejar documentación que nos explique que
hace cada una de las funciones, clases y módulos que codificamos. Para esto, es usual imple-
mentar estructuras de texto llamadas docstrings que indiquen que información se maneja
y como funciona.

Todos los docstrings se escriben como comentarios entre triple comillas. Para indicar tı́tulos
debemos dejar un salto de lı́nea y debajo agregar una serie de iguales. Para indicar subtı́tulos
 59

debemos dejar un salto de lı́nea y debajo agregar una serie de guiones. Para destacar texto
debemos indicarlos entre comillas dobles y para mostrar ejemplos utilizamos triples signo
mayor que, es decir, >>>.

En el caso de las funciones, podemos agregar otros marcadores que nos permitan documentar
el tipo de variables que se debe introducir y el tipo de resultado que se obtendrá. Para ello,
debemos indicar con dos puntos el tipo de variable y con una flecha el tipo de resultado.

La función nombre objeto. doc permite obtener la documentación de un objeto.

 60

Manejo de errores
El manejo de errores es muy importante cuando se diseñan programas en Python. El uso
adecuado de las sentencias Try - Except y la proporción de mensajes claros para facilitar la
depuración son de vital importancia.

Se recomienda implementar excepciones donde sea necesario para evitar los errores.

Siempre se debe programar pensando en que el usuario utilizará el programa de toda las
formas posibles, sobre todo mal.

Depuración en VS Code
Una de las herramientas importantes que nos entrega VS Code es la depuración del código.
Esta nos permite revisar lo que está sucediendo en nuestro programa paso a paso mientras
se ejecuta. Para hacer esto, debemos seguir los siguientes pasos:

1. Debemos configurar los puntos de interrupción. Estos puntos indican las lı́neas de
código donde el programa se detendrá. Para hacerlo, debemos marcar los puntos rojos
que están situados alado de los indicadores de las lı́neas.

2. Una vez configurados los puntos de interrupción, debemos activar el depurador de

archivos de Python. Este está en el menú desplegable del menú de ejecución.

3. Una vez iniciado, podemos controlar la ejecución con las flechas de la parte superior.
Esto nos muestra como avanza el programa y como se van cargando las variables.

Veamos un ejemplo de como depurar un programa que no está funcionando bien para
identificar el problema.

La parte izquierda nos va indicando como se modifican las variables y que valores toman.
Esto nos permite saber si estas están tomando los valores que realmente deben tomar o si,
en su defecto, tenemos un error de semántica.
Notemos que los puntos rojos del lado izquiero son los puntos donde el programa se inte-
rrumpe y el triángulo amarillo indica donde se está ejecutando.
 61

Una vez identificados los problemas del prograba, se procede a arreglar para que este fun-
cione como nosotros queremos.

Extensiones para VS Code

Visual Studio Code (VS Code) es un editor de código fuente muy popular y versátil, y se
puede extender aún más mediante la instalación de extensiones. Estas extensiones agregan
funcionalidades adicionales, mejoran la productividad y admiten una variedad de lenguajes
de programación y tecnologı́as. Aquı́ hay algunas extensiones útiles que podrı́as considerar
instalar en VS Code:

Indent - rainbow agrega bloques de colores para marcar la indentación del código.

Better - comments crea tipos de comentarios, cambiando colores para que sea más
facil entender lo que queremos programar.

Error - lens muestra errores de sintáxis a lo largo del código. Es muy util para
depurar mientras se programa.

Fluents icons modifica los ı́conos del VS Code.

Onedark pro cambia el color del visual studio code. Uso el estilo dark.

Codesnap permite tomar capturas de pantalla de nuestro código.

Vscode - pets agrega una mascota a VS Code. Se debe instalar en la sección de

extensiónes. Luego, se llama a las mascotas con “vscode-pets.start”.

Estas extensiones nos ayudan a mejorar nuestro programa para que se vea mejor y nos
permita programar de mejor manera.