Una introducción para

ingeniería y ciencias
Andreiv Domínguez Martínez
Vidju Press
 PYTHON Una introducción

Andreiv Domínguez Martínez

Universidad Politécnica de Puebla
Universidad Politécnica Metropolitana de Puebla

Tecnología
Vidju Press (http://www.vidjupress.org.mx).
Copyright© Python, una introducción
Correo Electrónico: [email protected]
Vidju Press
San Andrés Cholula, Puebla
Teléfono (000)00000
Fax (222)0000000

Domínguez Martínez, Andreiv.

Python, una introducción.
Domínguez Martínez A. – 0.1 ed.
– Vidju Press. 2020.
xxx p.
ISBN
1. Python 2. Programación 3. Algoritmos
 Tecnología
Licencia. Vidju Press
http://www.vidjupress.org.mx

Imagen de portada: Photo by Peter Neumann on Unsplash, https://unsplash.com/photos/d7uB_0OoWGk

Fuente de Protada: REFORMA, diseñada por pampatype.com para la Universidad Nacional de Córdoba, Argentina.
El formato del libro es una modificación de las plantillas elaboradas para LATEXpor Alexánder Borbón A. y Wal-
ter Mora F del Tecnólogico de Costa Rica http://www.tec-digital.itcr.ac.cr/revistamatematica/Libros/
LATEX/plantillaslatex.htm.

La imagenes se generaron con el paquete Tikz para LATEXy algunas de ellas se basan en ejemplos disponibles en
la página http://www.texample.net/tikz/examples/.
 ÍNDICE GENERAL

PRÓLOGO IX

1 ALGORITMOS Y PYTHON
1.1 Algoritmos
1
1
1.2 Introducción a Python 6
Interfaces de Python 6
1.3 Programas 9
Scripts 9
Funciones 10
1.4 Librerías 12

2 TIPOS DE DATOS 13

3 VARIABLES Y CONSTANTES
3.1 Operadores
17
17

4 FLUJO DE UN PROGRAMA
Condicionales
19
19
Ciclos 20

5 GRÁFICAS
5.1 2D
25
25
Gráficas de funciones 25
5.2 Animación 33
5.3 Turtle 33
5.4 3D 34
5.5 Librerías 36
OpenGL 37
VPython 37

6 ARCHIVOS 39

7 SYMPY 43

8 SCIPY 59
V
9 BASES DE DATOS 61

10 SONIDO Y MÚSICA 63

11 PROCESAMIENTO DE IMÁGENES
11.1 OpenCV
65
66

12 ARDUINO 69

13 SOLUCIONES 71

BIBLIOGRAFÍA 72
 “El criterio que orientará a esa educación se basará en los
resultados del progreso científico, luchará contra la ignorancia
y sus efectos, las servidumbres, los fanatismos y los prejuicios.”
Párrafo del Artículo Tercero de la Constitución Política
de los Estados Unidos Mexicanos

VII
Prólogo
Vivimos en un mundo digital, rodeados de dispositvos como teléfonos inteligentes, tabletas o compu-
tadoras. Pero no sólo eso, estamos a las puertas de una revolución tecnológica que traerá la robótica
a nuestras vidas diarias con robots personales o de limpieza, vehículos autónomos, conexión per-
manente a la nube, etc. Tenemos además, la inteligencia artificial y la ciencia de datos, principalmete
para el consumo masivo y las empresas. En esta revolución, llamada Revolución 4.0, la programación
juega un papel crucial y Python en particular por ser el lenguaje de la inteligencia artificial y la ciencia
de datos. Python es un lenguaje accesible y poderoso para el novato y para el programador avanzado.

Esta guía presenta las nociones básicas para comenzar a programar en Python, esperando que el
lector se interese en el maravilloso mundo de los algoritmos y la programación.

Puebla, Febrero de 2020. ANDREIV DOMÍNGUEZ MARTÍNEZ

 1 Algoritmos y Python
1.1 Algoritmos

Programar es una herramienta en la vida cotidiana, pero es esencial en la ciencia y en la ingeniería para recolectar,
analizar datos y para comunicar resultados. Pero programar significa implementar un algoritmo que automatiza
un proceso y que una computadora pueda llevarlo a cabo, por esta razón comenzamos hablando de algoritmos
antes de hablar sobre Python.

Definición 1. Un algoritmo es una sucesión ordenada de pasos definidos para resolver un problema.

Previo a escribir un programa es necesario diseñar el algoritmo en papel o en un diagrama. No es recomendable

diseñar el algoritmo al tiempo que escribimos el progrma, es fácil equivocarse (que el programa no funcione o lo
haga de manera incorrecta) o no ser eficiente. No hay un algoritmo para diseñar algoritmos, pero si una estrategia
general.

1. Identificar el problema a resolver.

2. Identificar el resultado al que deseamos llegar.

3. Identificar si necesita datos de entrada y como obtener esos datos.

4. Definir el proceso para obtener el resultado. Un proceso se compone principalmente de la toma de decisio-
nes y de realizar operaciones de operaciones.

5. Presentar el resultado.

Otra parte del algoritmo es analizar el tiempo de ejecución mediante el número de operaciones realizadas y la
duración de cada una de ellas para medir la eficiencia, pero esto se estudia en un libro especializado en algorit-
mos.

Escribiendo algoritmos
Un algoritmo puede escribirse en lenguaje cotidiano, pero esto suele introducir errores o ambigüedades. Otra
manera es mediante diagramas de flujo que muestra la ejecución del algoritmo de manera visual, dicho método
es práctico para algoritmos cortos.

1
 Inicio

Ingresar
Mundo real
datos

Ajustar Procesar
modelo datos

¿Predice
datos
no
futuros?

si

Alto

Diagrma de flujo. Modificado de

http://www.texample.net/tikz/examples/simple-flow-chart/.

A continuación mostramos un ejemplo con un algoritmo para resolver una ecuación cuadrática.

Ejemplo 1. Diseña un algoritmo que calcule las raíces reales de una ecuación cuadrática ax 2 + bx + c = 0.

2
 Inicio

Ingresamos
los coefi-
cientes
a, b y c .

Calculamos el
discriminante
D = b 2 − 4ac .

p
no si −b ± D
¿D < 0? ¿D > 0 ? x=
2a

si
no

−b
x=
Sin solucio- 2a
nes reales.

Fin

Para realizar un diagrama de flujo se tienen las reglas siguientes:

1. Se indica el inicio y el fin del algoritmo con un óvalo o un rectángulo redondeado.

2. Un paralelogramo indica la entrada o salida de datos.

3. Un rectángulo se usa para indicar procesos.

4. Con un rombo o diamante mostramos la toma de una decisión.

5. El flujo del algoritmo se indica mediante flechas direccionadas.

Una forma alternativa de escribir un algoritmo es mediante pseudocódigo el cual tiene la ventaja de ser similar a
la forma en que se escribe el algorimo en un lenguaje de programación y por lo tanto la implementación es más

3
sencilla.

Ejemplo 2. Escribimos el algoritmo para hallar las raíces reales de una ecuación cuadrática ax 2 + bx + c = 0.

Naturalmente el problema a resolver es hallar la raíces reales de la ecuación.

1. Hay tres opciones: que no hay raíces reales, hay una única raíz real o dos raíces reales distintas.

2. Los datos de entrada son los coeficientes a, b y c de la ecuación cuadrática.

3. El proceso consiste en calcular el discriminate para decidir si hay raíces reales y cuales son.

4. El resultado se imprime en pantalla.

El seudocódigo se muestra a continuación.

Algorithm 1.1: Algoritmo para hallar las raíces reales de la ecuación ax 2 + bx + c = 0.
Data: Los coeficientes a, b y c.
Result: Las soluciones de una ecuación cuadrática.
1 Inicio;
2 if D<0 then
3 No hay raíces reales.
4 else
5 if D>0 then p p
−b + D −b − D
6 Las raíces son x 1 = y x2 = .
2a 2a
7 else
−b
8 Hay una única raíz x =
2a
9 end
10 end

Se recomienda diseñar algoritmos complejos en forma modular, es decir, dividir en soluciones parciales hasta
integrar una solución global. Esto facilita la estructura y comprensión del algoritmo.

Como en toda actividad cotidiana, de ciencia o de ingeniería, el éxito depende de la planeación y el diseño inicial.
Diseña tu algoritmo antes de programar, efectuando las operaciones y procesos mentalmente y obteniendo re-
sultados válidos. Considera posibles datos válidos de entrada, pero también datos improbables o incorrctos, tu
programa debe responder ante estas situaciones.

Actividad 1.1
1. Diseña un algoritmo que ordene un conjunto de números, por ejemplo que el conjunto 5, 7, 2, 4, 1 lo
escriba de menor a mayor como 1, 2, 4, 5, 7.

2. Diseña un algoritmo para buscar una palabra y su significado en un diccionario. Prueba con diez
palabras de tu elección para diseñar tu algoritmo.

3. Investiga si hay un algoritmo para resolver el cubo de Rubik.

4
5
1.2 Introducción a Python

Para implementar un algoritmo en una computadora es necesario un lenguaje de programacoón y Python es un

lenguaje de programación versátil para resolver problemas de ciencias e ingeniería, fue creado por Guido Van
Rossum y es de código abierto (cualquiera puede modificarlo y contribuir en su desarrollo). Se puede descargar
de www.python.org, pero es necesario instalar librerías adicionales lo cual puede ser un poco complicado pa-
ra usuarios novatos. Nuestra recomendación es instalar la distribución Anaconda que incluye lo necesario para
nuestros propósitos, se descarga de https://www.anaconda.com/distribution/#download-section, elige tu sis-
tema operativo y la versión 3.7 o posterior. Instalamos de acuerdo a las instrucciones indicadas. Para iPad existe
la aplicación Pythonista, aunque tiene costo. Inclusive puede usarse en línea en la página oficial www.python.org.

Para instalar Python por ti mismo está la página https://www.python.org/downloads/ y elegimos la opción de
acuerdo a nuestro equipo.
Las librerías se instalan como se muestra en el documento siguiente https://docs.python.org/3.2/install/
index.html

Como ejemplo del uso de Python tenemos la primera fotografía de un agujero negro que obtuvo en 2019 la es-
tudiante de doctorado del MIT Katie Bouman y actualmente profesora asistente del California Institute of Tech-
nology.

Katie Bouman Fotografía del

agujero negro

Figura 1.1. Fuente:

https://math.mit.edu/wim/2019/04/12/that-image-of-a-black-hole-you-saw-everywhere-thank-katie-bouman-for-making-it-possib
consultado el 22 de Febrero de 2020.

1.2.1 Interfaces de Python

Para usar Python tenemos la interfaz llamada Spyder que viene preinstalada en Anaconda, sólo es necesario abrir
la aplicación. Dentro de Spyder encontramos un editor para escribir programas y una terminal para ejecutarlos,
además de los menús usuales de cualquier programa interactivo.

6
 Aplicaciones de Anaconda.

Python en Spyder.

Actividad 1.2

1. Descarga la versión adecuada para tu sistema operativo y realiza la instalación.

2. Abre Spyder.

3. Ejecuta todos los programas que aparecen en este capítulo, puedes copiar y pegar, con cuidado
porque algunas veces se cambia el tipo de comillas y tenemos que corregirlas.

Python es un lenguaje interpretado, esto significa que puedes escribir comandos directamente en la terminal.

7
 Comando en la terminal.

Escribir en la terminal tiene ventajas cuando el programa es corto y será usado una o dos veces, en caso con-
trario es preferible escribir un programa en el editor y guardar el archivo con extensión .py para preservarlo. Se
recomienda que el nombre del programa haga referencia a su utilidad; también es recomendable escribir el au-
tor, una descripción del programa, la fecha y comentar las distintas partes del programa, esto puede ser un poco
tedioso, pero nos ahorrará frustraciones futuras al reutilizar el programa y no recordar lo que hace.

Un programa en el editor.

Ahora ejecutamos el archivo con el botón Ù, que se muestra en la gráfica siguiente, o con la tecla F5.

Un programa en el editor.

El resultado es el siguiente.

Resultado del programa anterior.

Spyder es similar al entorno de Matlab, pero hay otra interfaz de Python que se abre en el navegador y se lla-
ma Jupyter, algunas ventajas de Jupyter es la modalidad interactiva. Es el usuario el que decidirá la interfaz de
acuerdo a sus necesidades y gustos.

8
 Elegimos la versión de Python.

Interfaz de Spyder.

1.3 Programas
En Python encontramos dos tipos de programas que describimos por separado.

1.3.1 Scripts
Un script es un programa que se escribe en el editor o en la terminal (se recomienda en el editor) y que se ejecuta
cada vez que se necesita.

Recordemos que un programa requiere de comentarios que ayudan a documentar el objetivo del programa y su
autor, las acciones de un comando o parte de un programa. Los comentarios se indican con # para una sola línea
o """ """ para varia líneas.

Veamos la estructura de un programa en acción.

9
 #Programa que calcula el doble de un número.
#Nombre del programa: Doble.py
#Autor: Andreiv Domínguez Martínez

#Ingresamos el número.
entrada=int(input(’Ingresa el número: ’))

#Realizamos operaciones.
doble=2*entrada

#Mostramos resultados.
print(’El doble del número es:’, doble)

Antes de continuar, hablaremos un poco de las funciones input( ) y print( ) que usamos en el ejemplo anterior.
La función input( ) permite ingresar datos a Python, cabe aclarar que siempre los introduce como una palabra
y es necesario convertir a un número en algunos casos.
Para ingresar una palabra escribimos lo siguiente.
>>> nombre = input("Ingresa el nombre: ")
Ingresa el nombre: Diego
>>> nombre
Diego

Por otro lado, para escribir un número usamos la función modificada.

>>> edad = int(input("Ingresa la edad: "))
Ingresa la edad: 25
>>> edad
25

Para la función print() escribimos

>>> print("Hola")
Hola
>>> print(25)
25

Si queremos incluir un dato almacenado en una variable hacemos lo siguiente.

>>> edad = 25
>>> print(’La edad es %s ’ % edad)
La edad es 25

Ejercicios 1. Realiza los siguientes programas usando como base el ejemplo anterior.

1) Que pida tu nombre y devuelva un saludo personalizado.

2) Calcule el triple de un número.
3) Calcule el cuadrado de un número (usa la operación producto que se representa con *).
4) Calcule el cubo de un número con la operación producto.

1.3.2 Funciones
Ya usamos dos funciones que son input( ) y print( ), las funciones son programas que son parte del entorno
de Python. Python incluye gran cantidad de funciones predefinidas, pero cualquiera puede escribir sus propias
funciones. A diferencia de un script que es necesario ejecutar cada vez que se necesita, las funciones se incor-
poran al entorno de Python y pueden llamarse cada vez que es necesario. Una función puede tener cero, uno o
varios valores de entrada, que se llaman argumentos. De manera similar, puede tener cero, uno o múltiples valo-
res de salida que son llamados valores; la salida de una función puede ser una acción. Si una función es corta,

10
entonces puede escribirse directamente en el intérprete, de lo contrario se recomienda escribirlo como un script.

La estructura para escribir nuestras funciones es la siguiente:

Entradas Salidas
Función

Figura 1.2. Esquema de una función.

La estructura general de una función se muestra a continuación.

#Descripción breve y clara de la función.

def Nombre(Argumentos de entrada):
Operaciones
return Valores de salida

¡Notas una identación en los procedimientos “Operaciones” y “return Valores de salida”?, esto es común en los
lenguajes de programación para dar claridad al código, pero en Python es obligatorio porque esto señala la es-
tructura de los procedimientos correspondientes, será común encontrarlos en este libro y deben escribirse de
la misma manera. Python no utiliza el punto y coma o las llaves que se usan en otros lenguajes para delimitar
partes y procedimientos de código.

En una función, las operaciones breves pueden indicarse en la línea de “Valores de salida”.
Ejemplo 1.

#Función que calcula el doble de un número.

#Nombre del programa: doble.py
#Autor: Andreiv Domínguez Martínez

def doble(a): #Definimos la función.

return (2*a) #Resultado de salida.

Cuando no es posible escribir las operaciones requeridas en return( ), en este caso podemos escribir la res-
puesta obtenida en las operaciones o escribir none y la función devuelve resultados previamente.
Ejemplo 2.
#Función que calcula el doble de un número.
#Nombre del programa: doble.py
#Autor: Andreiv Domínguez Martínez

def doble(a): #Definimos la función.

print(2*a) #Procedimiento.
return( ) #Resultado de salida queda vacío.

Ahora es posible llamar la función en la terminal.

>>> doble(4)
8

>>> doble(-5)
-10

Se recomienda que el nombre de una función o script haga referencia a su funcionalidad, esto aporta claridad
en su uso; por ejemplo valorTemperatura o valorPH.
Ejercicios 2. Realiza las siguientes funciones.

11
 1. Calcule la operación 2*m*n.

2. Calcule la operación m*n-1.

3. Convierta de grados Celsius a Fahrenheit.

4. Calcule la altura de un objeto en caída libre que parte desde el reposo.

5. Calcule el interés de una cuenta bancaria.

6. Calcule las raíces de un polinomio cuadrático a partir de los coeficientes, incluyendo soluciones en los números
complejos.

1.4 Librerías
Python hace uso de librerías, que son conjuntos de funciones relacionadas y nos permiten ampliar nuestras he-
rramientas para resolver problemas. Las librerías usadas frecuentemente se enumeran a continuación.

1. Math para funciones matemáticas.

2. Numpy para arreglos de datos.

3. Sympy para matemática simbólica.

4. Scipy para computación científica.

5. Matplotlib para gráficas matemáticas en 2D.

6. Pandas para datos.

Para hacer uso de una librería, es necesario importarla con el comando import y en ocasiones renombrarla para
abreviar la escritura de comandos de esa librería.

import numpy as np
import matplotlib as mlp

Es posible importar una parte una librería, puede ser una función o una constante.
from numpy import pi

12
 2 Tipos de datos
Python tiene los tipos de datos usuales a otros lenguajes de programación.

Valor Significado Ejemplo

int Número entero a =3
float Número real b = 3,14
double Número real c = 3,14159
char o string Palabras “Hola”
boolean Verdadero o falso True

1. Números enteros: int.

2. Números flotantes: float. Estos se utilizan para representar números racionales e irracionales, pero si en
las operaciones intervienen múmeros flotantes se recomienda escribir todo en números flotantes con el
uso del punto decimal como 4.0 o -2.0 y otros similares.

3. Cadenas: str. Se usan para representar letras, palabras, cadenas de palabras y datos no númericos. Se
escriben entre comillas o comillas dobles.
’a’, ’Hola’, “Ecribe el primer dato.”

4. Booleanos: bool. Son los valores lógicos de falso (False) y verdadero (True).

5. Números complejos
La unidad imaginaria i se escribe como 1 j en Python, por lo tanto un número complejo a + bi se escribe
como a+b j o como complex(a,b). Python hace algunas operaciones de números complejo, pero para usar
algunas más es necesaria la librería cmath.
Si z = a + b j y w = c + d j son números complejos en Python, tenemos las operaciones básicas siguientes:

a) Suma: z+w e) Módulo: abs(z)

b) Resta: z-w f) Conjugado: z.conjugate()
c) Producto: z*w g) Parte real: z.real
d) Cociente: z/w h) Parte imaginaria: z.imag

La librería cmath (Complex mathematics) permite otras operaciones, pero el número complejo a + b j se
representa como (a, b).

a) Raíz cuadrada: cmath.sqrt(z)

b) Fase, θ : cmath.phase(z)
c) Forma polar (r, θ): cmath.polar(z)
d) Forma cartesiana a + b j : cmath.rect(r, θ )

6. Arreglos: list.
Representan arreglos numéricos (conjuntos ordenados). Se escriben entre corchetes A=[5,4,3,6,7] y es-
tán ordenados de 0 a n − 1 con n el número de datos del arreglo. Para acceder a un dato del arreglo es
necesario conocer su posición: A[0] será 0 y A[3] será 6. Hay algunas operaciones de arreglos que usare-
mos y que mencionamos a continuación.

El comando range( ) es una herramienta práctica para crear listas. El comando tiene tres opciones de uso.

13
 a) range(n) crea una lista de 0 a n-1 con incrementos de una unidad.
b) range(m,n) crea una lista de m a n-1 con incrementos de una unidad.
c) range(m,n,h) cre una lista de valores que inicia en m hasta n-1 con cambios de h unidades.

Si escribimos el comando range() no se genera una lista, es necesario anteponer el comando list.

#Ejemplos del comando range.

>>> list(range(7))
[0, 1, 2, 3, 4, 5, 6]

>>> list(range(4,10))
[4, 5, 6, 7, 8, 9]

>>> list(range(4,10,2))
[4, 6, 8]

Concatenación
Concatenar unir dos listas en una, una a continuación de la otra.

>>> A=[1,2]
>>> B=[3,4]
>>> A+B
[1, 2, 3, 4]

Con * se crea una nueva lista a partir de una anterior que se repite según se indica en la operación.
>>> A=[1,2]
>>> 5*A
[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
>>> B=[1]
>>> 15*B
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

Con el comando [m:n] se toman los elementos desde m hasta n-1 y se colocan en una lista nueva.
>>> A=[10,11,12,13,14,15,16,17,18,19,20]
>>> A[2:5]
[12, 13, 14]
>>> A[:5]
[10, 11, 12, 13, 14]
>>> A[3:]
[13, 14, 15, 16, 17, 18, 19, 20]
>>> A[1:7:2] # A[Inicio:Fin:Incremento].
[11, 13, 15]
>>> A[::2] #Seleccionar cada dos elementos a partir del primero.
[10, 12, 14, 16, 18, 20]
>>> A[::4] #Seleccionar cada cuatro elementos a partir del primero.
[10, 14, 18]

Este comando también permite modificar una parte de una lista.

14
>>> A[2:5]=[5,6,7]
>>> A
[10, 11, 5, 6, 7, 15, 16, 17, 18, 19, 20]

Los elementos de una lista pueden ser de naturaleza distinta.

>>> B=[5, ’Hola’]
>>> B
[5, ’Hola’]

Para agregar elementos al final de una lista se usa el comando .append( ).

>>> A.append(21)
>>> A
[10, 11, 5, 6, 7, 15, 16, 17, 18, 19, 20, 21]

Otra forma de agregar una lista al final de otra es con .extend( ), este comando no crea una nueva lista,
mantiene los datos en la primera.

>>> B=[22,23,24,25]
>>> A.extend(B)
>>> A
[10, 11, 5, 6, 7, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 22, 23, 24, 25]

El comando .sort( ) ordena los elementos de una lista.

>>>C=[3,2,5,1,4]
>>>C.sort( )
>>>C
[1, 2, 3, 4, 5]

La función sum( ) suma los elementos de un conjunto o una lista. Con .pop se borran elementos de una
lista y los guarda en otro valor.
>>> sum(C)
15
>>>a=C.pop(2)
>>>C
[1, 2, 4, 5]
>>>a
3

Con del A[i] se borra el elemento en el lugar i. Con .remove(m) se borra el elemento m. Observa la dife-
rencia.
>>>A=[1,2,3,4,5]
>>>del A[0]
>>>A
[2, 3, 4, 5]
>>>A.remove(3)
>>>A
[2, 4, 5]
>>>B=[1,2,3,4,5,6,7]
>>>del B[2:5]
>>>B
[1, 2, 6, 7]

Por último, comentamos que una cadena son tratadas como listas.

15
 >>> c="Hola"
>>> c[0]
H
>>> c[1]
0

7. Diccionarios: dict. Son datos relacionados en parejas como una tabla de datos.

>>> Datos[’Mayra’]
25
>>> Datos[’Ana’]
22

En un diccionario, a los valores de la primera columna se le llama claves (keys) y los de la segunda se
llaman valores, cada columna puede extraerse. En un diccionario es posible agragar otros datos.

>>> Datos.keys()
dict_keys([’Mayra’, ’Daniela’, ’Rafael’, ’Ana’])
>>> Datos.values()
dict_values([25, 27, 28, 22])
>>> ’Mayra’ in Datos
True
>>> Datos[’David’]=23
>>> Datos
{’Mayra’: 25, ’Daniela’: 27, ’Rafael’: 28, ’Ana’: 22, ’David’: 23}

Tanto las claves, como los valores pueden ser datos de distinto tipo.

Para saber el tipo de dato usamos el comando type( ).

16
 3 Variables y constantes
Definición 1. Una variable es un valor que puede modificarse en un programa.
Las variables se representan por un nombre que puede ser una letra, pero se recomienda usar nombres que ha-
cen referencia la papel que representa la variables como valorPromedio. La asignación de valores a una variable
es de derecha a izquierda con el signo de igualdad, como valorPromedio=4, esto significa que el número 4 se
asigna a la variable valorPromedio. No debe entenderse la asignación de valores como una igualdad matemática
o caeríamos en contradicciones, por ejemplo la expresión i=i+1 significa que al valor de i se le suna 1 esto se
asigna a la misma variable.

En Python no es necesario declarar variables antes de usarlas.

Definición 2. Una constante es un valor que no puede ser modificado durante la ejecución de un programa.
Como ejemplo tenemos el valor de π.

3.1 Operadores
Operadores aritméticos

Operación Operador Ejemplo Resultado

Suma + 3+8 11
Resta − 5−2 3
Producto ∗ 2 ∗ 10 20
Cociente / 15/4 3,75
División entera // 15//4 3
(cociente de la
división)
Módulo (residuo % 15 %4 3
de una división)
Exponente ** 2**8 256

En Python podemos usar el último resultado en una nueva operación mediante el símbolo guión bajo: _.
>>> 2*5
10
>>> _ + 8
18
>>> _ / 2
9.0

Operadores relacionales

1. Iguales: == 4. Menor que: <

2. Diferentes: != 5. Mayor o igual que: >=

3. Mayor que: > 6. Menor o igual que: <=

17
>>> 1<2
True
>>> 4==5
False
>>> 7>=3
True

Operadores lógicos
Estos relacionan proposiciones lógicas.

1. Conjunción: and

2. Disyunción: or

3. Negación: not

>>> 2<5 and -1>-3

True
>>> 1<2 or 1<-1
True
>>> not(4<4)
True
>>> 2<1 or 5<3
False
>>> not(1!=2)
False
>>> 3-1 == 2
True

18
 4 Flujo de un programa
Un algoritmo (por lo tanto también un programa) generalmente se basa en dos tipos de estructuras.

1. Condicionales que sirven para tomar decisiones.

2. Ciclos para procesos repetitivos mientras se cumpla una condición lógica.

4.0.1 Condicionales
La condicionales se clasifican por un caso, dos casos y casos múltiples.

Para un caso se usa la condicional if con la estructura siguiente.

#Condicional de un caso.
if Condición logica:
Procedimiento

El procedimiento sólo se ejecuta cuando la condición es verdadera.

#Condicional de un caso.
if a>0:
a=a+5

Para dos casos tenemos la estructura alternativa.

#Condicional de dos casos.

if Proposición lógica:
Procedimiento
else:
Procedimiento alternativo

Si la proposición lógica es verdadera, se ejecuta el procedimiento. Si es falsa, se ejecuta el procedimiento alter-

nativo. Como en el ejemplo siguiente.

#Condicional de dos casos.

if a==5:
print(’El dato coincide con 5.’)
else:
print(’El dato no coincide.’)

Para casos múltiples tenemos dos casos. El primero ocurre cuando tenemos varios casos posibles y uno último
en caso de no cumplirse alguno de los anteriores.

#Condicional de casos múltiples.

if Proposición lógica 1:
Procedimiento 1
elif Proposición lógica 2:
Procedimiento 2
elif Proposición lógica 3:
Procedimiento 3
else:
Procedimiento alternativo

19
 El código se ejecuta secuencialmete hasta hallar una proposición lógica que sea verdadera, entonces se ejecuta
el procedimiento asociado y salimos del condicional. En caso de tener todas las proposiciones lógicas falsas, se
ejecuta el procedimiento alternativo.
Ejemplo 1.

#Calificación
if 9 <= calificacion <= 10:
print(’Excelente’)
elif calificacion == 8:
print(’Bueno’)
elif calificacion == 7:
print(’Aceptable’)
elif 0 <= calificacion <= 6:
print(’No suficiente’)
else:
print(’Dato incorrecto’)

El procedimiento alternativo puede quedar vacío, se ejecutura el procedimiento cuya proposición lógica asociada
sea verdadera. En caso de resultar falsas las proposiciones lógicas, no se ejecuta acción alguna.
#Condicional de casos múltiples sin procedimiento alternativo.
if Proposición lógica 1:
Procedimiento 1
elif Proposición lógica 2:
Procedimiento 2
elif Proposición lógica 3:
Procedimiento 3

Ejemplo 2.

#Calificación
if 9 <= calificacion <= 10:
print(’Excelente’)
elif calificacion == 8:
print(’Bueno’)
elif calificacion == 7:
print(’Aceptable’)
elif 0 <= calificacion <= 6:
print(’No suficiente’)
else:
print(’Dato incorrecto’)

Las condicionales pueden anidarse, es decir, puede escribirse una dentro de otra.

4.0.2 Ciclos
Un ciclo ejecuta un procedimiento cierto numero de veces.

For
El ciclo for realiza un procedimiento un número de veces dado por un rango o una lista. Su estructura se muestra
a continuación.
#Estrucutura de un ciclo for.
for i in Lista:
Procedimiento

20
En un ciclo for es posible usar el comando range( ) sin necesidad de convertir a lista.
Ejemplo 3.
for i in range(11):
print(i,i**2)

Este es el resultado.

0 0
1 1
2 4
3 9
4 16
5 25
6 36
7 49
8 64
9 81
10 100

While
El ciclo while se ejecuta mientras una condición lógica sea verdadera, mostramos su estructura. Generalmente
un ciclo while lleva una variable asociada llamada contador y sirve para evaluar la condición lógica.

#Estructura de un ciclo while.

Valor inicial del contador.
while Proposición lógica:
Procedimiento
Cambiar el valor del contador.

Ejemplo 4.
a=0 #Valor inicial
while a<=10: #Condición lógica
print(a) #Imprimir el número
a+=1 #Incrementa el valor de a en 1.

El resultado es el siguiente.

0
1
2
3
4
5
6
7
8
9
10

En el ciclo while primero se verifica la condición y si es verdadera se ejecuta el procedimiento, este ciclo puede no
ejecutarse ni una vez si la proposición resulta falsa para el valor inicial del contador. Una vez que el ciclo resulta
falso, el ciclo se detiene. Se debe tener cuidado para no obtener un ciclo sin fin.

Los ciclos for y while pueden ser anidados.

21
Break
El comando break se utiliza para detener un ciclo una vez que se cumpla una condición adicional, puede consi-
derarse como una opción de escape del ciclo.
Ejemplo 5.
#Estructura de la función break.
while True:
print(’Escribe Salir para terminar el programa.’)
line = input(’> ’)
if line == ’Salir’:
break
print(line)
print(’¡Te deseo un buen día!’)

Ejemplo 6.
#Programa que calcula los cuadrados de un número natural desde uno hasta
#infinito.

x=1
while x>0:
print(’Presiona la tecla "Enter" para continuar, escribe "Salir" o
"S" para salir’)
entrada=input()

if entrada==’Salir’ or entrada==’S’:
break
else :
print([x,x**2])
x+=1

print(’Programa terminado’)

La salida se muestra así.

[8, 64]
Presiona la tecla "Enter" para continuar, escribe "Salir" o "S" para salir

[9, 81]
Presiona la tecla "Enter" para continuar, escribe "Salir" o "S" para salir

[10, 100]
Presiona la tecla "Enter" para continuar, escribe "Salir" o "S" para salir

Actividad 4.1
1. Diseña e implementa un algoritmo, mediante el ciclo while, que obtenga la sucesión de Fibonacci
que sean menores a 1000. Recuerda que la suceción de Fibonacci es 1, 1, 2, 3, 5, 8, 13,...

2. Diseña
µ ¶ e implementa un algoritmo, mediante el ciclo while, que obtenga los términos de la sucesión
1
mayores a una tolerancia d el t a de 0, es decir, que su distanncia a d el t a sea mayor que cero.
n
3. Diseña e implemente un algoritmo que indique si una persona puede ingresar a un lugar sólo cuando
es mayor de edad, haga uso del condicional if.

22
4. Diseña e implementa un algoritmo, con el ciclo for, que obtenga el promedio de los números 0 a 10.

23
 5 Gráficas
https://www.southampton.ac.uk/~feeg1001/notebooks/Matplotlib.html
https://matplotlib.org/3.1.1/tutorials/colors/colormaps.html

5.1 2D

5.1.1 Gráficas de funciones

Para realizar gráficas necesitamos algunas librerías como Numpy, Sympy y Matplotlib.

"""
Created on Tue Mar 26 16:23:09 2019

@author: andreiv
"""

#Importamos las librerías

import numpy as np
import matplotlib.pyplot as plt

#Definir el dominio de la función.

x = np.linspace(-4, 4, 200)

# Definir la función
y = np.sin(x)

#Gráfica de la función.
plt.plot(x, y)

#Mostrar la gráfica
plt.show()

25
 1.00
0.75
0.50
0.25
0.00
0.25
0.50
0.75
1.00
4 3 2 1 0 1 2 3 4

Figura 5.1. Una gráfica muy simple.

El siguiente código muestra los elementos esenciales para elaborar la gráfica de una función.

#basica.py
@author: Andreiv
"""

#Importamos las librerías

import numpy as np
import matplotlib.pyplot as plt

#Definimos el valor de pi.

pi=3.14
# Definir dominio de la función (valor inicial, valor final, número de puntos).
x = np.linspace(0, 4, 200)
# Definir la función
y = np.sin(pi*x)
#Gráfica(x,y,color y estilo, título, ancho de línea)
plt.plot(x, y, ’b-’, label=’$f(x)=sen(x)$’, linewidth=3.0)

#Nombre de ejes
plt.xlabel(’x’)
plt.ylabel(’y’)

#Mostrar la gráfica
plt.show()

26
 1.00
0.75
0.50
0.25
0.00
y

0.25
0.50
0.75
1.00
0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0
x
Figura 5.2. Ejemplo de una gráfica básica en Python

Para mejorar la gráfica tenemos muchas opciones, algunas de ellas se muestran con un ejemplo a continuación.

"""#Cap05_02.py

@author: Andreiv
"""
#Importamos las librerías
import numpy as np
import matplotlib.pyplot as plt

#Definimos el valor de pi.

pi=3.14
# Definir dominio de la función (valor inicial, valor final, número de puntos).
x = np.linspace(0, 4, 200)
# Definir la función
y = np.sin(pi*x)
# Crear gráfica, tamaño de ventana y resolución de imagen
plt.figure(1, figsize = (8,6),dpi=180 )
#Cuadrícula
plt.grid(True)
#Gráfica(x,y,color y estilo, título, ancho de línea)
plt.plot(x, y, ’b-’, label=’$f(x)=sen(x)$’, linewidth=3.0)
#Definimos longitud de los ejes [x1,x2,y1,y2].
plt.axis([0, 4, -1.5, 1.5], linewidth=3.0)
#Anotaciones en la gráfica
plt.annotate(’Maximo local’, xy=(0.48, 1), xytext=(0.98, 1.35),
arrowprops=dict(facecolor=’red’, shrink=0.05),
)

plt.annotate(’Minimo local’, xy=(1.48, -1), xytext=(1.98, -1.4),

arrowprops=dict(facecolor=’red’, shrink=0.05),
)

27
#Nombre de ejes
plt.xlabel(’x’)
plt.ylabel(’y’)
#Título de la función
plt.legend(loc=’upper right’)
#Título de la gráfica
plt.suptitle(u’Máximos y mínimos’)
#Estilo de los ejes.
plt.axhline(color = ’black’, linewidth=2.0, zorder=-1)
plt.axvline(color = ’black’, linewidth=2.0, zorder=-1)
# Guardar gráfica en archivo
plt.savefig(’seno1.pdf’)
# Mostrar gráfica en pantalla
plt.show()

Máximos y mínimos
1.5
Maximo local f(x) = sen(x)

1.0

0.5

0.0
y

0.5

1.0

Minimo local
1.5
0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0
x

Figura 5.3. Ejemplo de una gráfica en Python

# -*- coding: utf-8 -*-

"""

Created on Mon Dec 5 13:30:08 2016

@author: Andreiv

28
"""

#Importamos las librerías

import numpy as np
import matplotlib.pyplot as plt

#Definimos el valor de pi.

pi=3.14

# Definir dominio de la función (valor inicial, valor final, número de puntos).

x = np.linspace(0, 12.56, 2000)

# Definir la función
y4 = np.sin(4*x)

# Crear gráfica, tamaño de ventana y resolución de imagen

plt.figure(1, figsize = (7,4),dpi=300 )

#Cuadrícula
plt.grid(True)

#Gráfica(x,y,color y estilo, título, ancho de línea)

plt.plot(x, y, color="brown", linewidth=2.5, linestyle="-", label="$B=4$")

#plt.legend(loc=’upper left’)

#Definimos longitud de los ejes [x1,x2,y1,y2].

plt.axis([0, 12.56, -1.5, 1.5], linewidth=3.0)

#Etiquetas de los ejes.

plt.xticks([ 0, np.pi/2, np.pi, 3*np.pi/2, 2*np.pi, 5*np.pi/2, 3*np.pi, 7*np.pi/2,
4*np.pi],
[ r’$0$’, r’$\frac{\pi}{2}$’, r’$\pi$’, r’$\frac{3\pi}{2}$’, r’$2\pi$’,
r’$\frac{5\pi}{2}$’, r’$3\pi$’, r’$\frac{7\pi}{2}$’, r’$4\pi$’])
plt.yticks([-1, 0, 1],
[ r’$-1$’, r’$0$’, r’$1$’])

#Nombre de ejes
plt.xlabel(’x’)
plt.ylabel(’y’)

#Título de la función
plt.legend(loc=’upper right’)

#Título de la gráfica
plt.suptitle(u’’)

#Estilo de los ejes.

plt.axhline(color = ’black’, linewidth=2.0, zorder=-1)
plt.axvline(color = ’black’, linewidth=2.0, zorder=-1)

# Guardar gráfica en archivo

plt.savefig(’senB1.pdf’)

29
# Mostrar gráfica en pantalla
plt.show()

B=4
1

0
y

0 2
3
2
2 5
2
3 7
2
4
x
Figura 5.4. Cambiamos las etiquetas de los ejes.

Coordenadas polares en Python

import numpy as np
import matplotlib.pyplot as plt

r = np.arange(0, 5, 0.01)
theta = 5 * np.pi * r

ax = plt.subplot(111, projection=’polar’)
ax.plot(theta, r)
ax.set_rmax(2)
ax.set_rticks([0.5, 1, 1.5, 2]) # Indicamos las etiquetas radiales.
ax.set_rlabel_position(-22.5) # Ángulo de las etiquetas radiales.
ax.grid(True)

ax.set_title("Una curva en coordenadas polares", va=’bottom’)

plt.show()

30
Vectores

import matplotlib.pyplot as plt

ax = plt.axes()
ax.arrow(0, 0, 0.5, 0.5, head_width=0.05, head_length=0.1, fc=’k’, ec=’k’)
plt.show()

31
Gráficas de pastel

import matplotlib.pyplot as plt

# Gráfica de pastel con los datos ordenados en contra de las manecillas del reloj:
labels = ’Fútbol’, ’Atletismo’, ’Natación’, ’Basquetbol’
sizes = [30, 20, 25, 25]
explode = (0, 0, 0, 0) # No se resalta rebanada alguna.

fig1, ax1 = plt.subplots(dpi=300)

ax1.pie(sizes, explode=explode, labels=labels, autopct=’ %1.1f % %’,
shadow=False, startangle=90)
ax1.axis(’equal’) # Ejes iguales para que la gráfica sea un círculo.

plt.show()

import matplotlib.pyplot as plt

# Gráfica de pastel con los datos ordenados en contra de las manecillas del reloj:
labels = ’Fútbol’, ’Atletismo’, ’Natación’, ’Basquetbol’
sizes = [30, 20, 25, 25]
explode = (0, 0.1, 0, 0) # Resaltamos la segunda rebanada: Atletismo.

fig1, ax1 = plt.subplots(dpi=300)

ax1.pie(sizes, explode=explode, labels=labels, autopct=’ %1.1f % %’,
shadow=False, startangle=90)
ax1.axis(’equal’) # Ejes iguales para que la gráfica sea un círculo.

plt.show()

32
5.2 Animación

25

20

15

10

0
3 2 1 0 1 2 3

Figura 5.5. Gráfica básica en Python.

5.3 Turtle

from turtle import *

color(’blue’, ’cyan’)
begin_fill()
while True:
forward(200)
left(170)
if abs(pos()) < 1:
break

33
 end_fill()
done()

https://docs.python.org/3.2/library/turtle.html

5.4 3D

@author: Andreiv
"""

from mpl_toolkits import mplot3d

#matplotlib inline
import numpy as np
import matplotlib.pyplot as plt

fig = plt.figure(1,dpi=300)
ax = plt.axes(projection=’3d’)

def f(x, y):

return x**2+y**2

x = np.linspace(-6, 6, 30)
y = np.linspace(-6, 6, 30)

X, Y = np.meshgrid(x, y)
Z = f(X, Y)

ax.contour3D(X, Y, Z, 1000, cmap=’ocean’)#Curvas de nivel

#ax.plot_surface(X, Y, Z, cmap=’viridis’)#Superficie
#ax.plot_wireframe(X, Y, Z, rstride=10, cstride=10)#Wireframe
#cset = ax.contour(X, Y, Z, zdir=’x’, offset=6, cmap=’viridis’)
#cset = ax.contour(X, Y, Z, zdir=’y’, offset=-6, cmap=’viridis’)#Curvas de vivel proyectadas
#cset = ax.contour(X, Y, Z, zdir=’z’, offset=5, cmap=’viridis’)

ax.set_xlabel(’x’)
ax.set_ylabel(’y’)
ax.set_zlabel(’z’);

plt.savefig(’Funcion2b.jpg’)
# Mostrar gráfica en pantalla
plt.show()
#ax.view_init(60, 35)
#fig

https://matplotlib.org/users/colormaps.html
https://jakevdp.github.io/PythonDataScienceHandbook/04.12-three-dimensional-plotting.html
https://matplotlib.org/gallery/index.html

from mpl_toolkits.mplot3d import Axes3D

from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter

34
from matplotlib.pyplot import *
from numpy import *

x = arange(-15, 15, 0.1)

y = arange(-15, 15, 0.1)
X, Y = meshgrid(x, y)
R = sqrt(X**2 + Y**2)
Z = -.4 + (X+15)/30. + (Y+15)/40.+.5*sin(R)

figure(1)
CS = contour(X, Y, Z, cmap=cm.coolwarm)
clabel(CS, inline=1, fontsize=10)
title(’Gráfica de contornos’)

show()

fig = figure(2)
ax = fig.gca()
heatmap = ax.imshow(Z, cmap = cm.coolwarm)
fig.colorbar(heatmap, shrink = 0.5, aspect=5)
title(’Mapa de calor’)
show()

fig = figure(3)
ax = fig.gca(projection=’3d’)
surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.coolwarm,
linewidth=0, antialiased=False)
ax.set_zlim(-2.01, 2.01)

ax.zaxis.set_major_locator(LinearLocator(10))
ax.zaxis.set_major_formatter(FormatStrFormatter(’ %.02f’))

fig.colorbar(surf, shrink=0.5, aspect=5)

show()

35
 Figura 5.6. Resultado de la segunda gráfica.

Figura 5.7. Resultado de la tercera gráfica.

https://www.cs.toronto.edu/~guerzhoy/411/lec/W01/numpy/Numpy3d.html

5.5 Librerías
Una de las librerías para gráficas más comunes en el mundo de la programación es OpenGL, de ella hablaremos
brevemente en esta sección. También hablaremos de una librería nativa de Python llamada VPython.

36
5.5.1 OpenGL
La librería OpenGL se instala en Anaconda con alguno de los comandos siguientes:

conda install -c vpython vpython

conda install -c vpython/label/pre-release vpython conda install -c vpython/label/internal_testing vpython

import sys
import OpenGL.GL as gl
import OpenGL.GLUT as glut

def display():
glut.glutSwapBuffers()

def reshape(width,height):
gl.glViewport(0, 0, width, height)

def keyboard( key, x, y ):

if key == b’\x1b’:
sys.exit( )

glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutCreateWindow(’Hello world!’)
glut.glutReshapeWindow(512,512)
glut.glutReshapeFunc(reshape)
glut.glutDisplayFunc(display)
glut.glutKeyboardFunc(keyboard)
glut.glutMainLoop()

5.5.2 VPython
Para instalar VPython escribimos conda install -c vpython vpython

37
 6 Archivos
Es momento de abordar la lectura y escritura de archivos de datos en formatos permanentes como texto.

Comenzamos con un archivo llamaddo Edades.txt que contiene las edades de un equipo de estudiantes. Abrimos
el archivo con open( ). Para abrir la carpeta que contiene el archivo puedes usar los comandos ls que muestra
los archivos y subcarpetas de la carpeta actual y el comando cd para cambiar a la carpeta requerida.

>>> cd LIBRO/images/Python/
C:\Users\mxstu\Desktop\ESTADÍSTICA\LIBRO\images\Python

>>> edades=open(’Edades.txt’)

Para leer el archivo usamos la función la función .readline( )

>>> edades.readline()
’15\n’
>>> edades.readline()
’17\n’

La función lee cada línea siguiente siguiente al ejecutarse. Si queremos ver los datos es preferible usar un ciclo
for.

edades = open(’Edades.txt’)
for line in edades :
datos = line.strip()
print(datos)

Para usar Python con los datos es necesario tener los datos en forma de arreglo.
edades = open(’Edades.txt’)
for line in edades :
arregloEdades.append( int(line.strip()) )

print(arregloEdades)
[15, 17, 15, 14, 16, 17, 16, 16]

Es posible hacer una búsqueda dentro de los datos.

#Función que cuenta el número de veces que aparece el dato n en \textit{arreglo}.
def moda(arreglo,n):
contador = 0
for dato in arreglo:
if dato == n:
contador=contador+1
return contador

Para guardar o crear datos en un archivo de texto se usa la función open(’nombre.txt’, ’w’) para crear el
archivo.
salida = open(’Costos.txt’, ’w’)

Escribimos línea a línea los datos que coontendrá el archivo.

39
>>> line1 = "1000\n"
>>> salida.write(line1)
5

>>> line2 = "1200\n"

>>> salida.write(line2)
5

Es necesario cerrar el archivo para guardar los datos.

salida.close()

Para guardar datos en un archivo es necesario que sean en formato str, de lo contrario es necesario usar la
función .write(str( ))
a=2000
salida.write(str(a))

Hay otra manera de leer archivos .txt usando la librería Numpy, si tenemos un archivo llamado archivo.txt con
dos columnas de datos.
1 4
2 3
3 5
4 1
5 2
Leemos el archivo y lo convertimos en arreglos de Python.
datos=open(’archivo.txt’)

#Colocamos cada columna en arreglos nx1.

x, y= np.loadtxt(datos, delimiter=’ ’, usecols=(0, 1), unpack=True)

#Graficamos los datos.

plt.plot(x,y)

5.0

4.5

4.0

3.5

3.0

2.5

2.0

1.5

1.0

1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0

Figura 6.1. Gráfica de los datos del archivo.

Es posible graficar datos de un archivo y una función en la misma gráfica.

import numpy as np
import matplotlib.pyplot as plt

40
# Leer datos desde archivo
xdata, ydata = np.loadtxt(’datos.txt’, unpack=True)

# Definir dominio de la función (valor inicial, valor final, número de puntos)

x = np.linspace(-3, 3, 50)

# Definir la función
y = np.exp(x)

# Crear gráfica
plt.figure(1, figsize = (8,6) )
plt.plot(x, y, ’b-’, label=’exp(x)’)
plt.plot(xdata, ydata, ’ro’, label="data")
plt.xlabel(’x’)
plt.ylabel(’y’)
plt.legend(loc=’upper right’)
plt.axhline(color = ’gray’, zorder=-1)
plt.axvline(color = ’gray’, zorder=-1)

# Guardar gráfica en archivo

plt.savefig(’datos.pdf’)

# Mostrar gráfica en pantalla

plt.show()

20.0 f(x)=exp(x)
datos

17.5

15.0

12.5

10.0
y

7.5

5.0

2.5

0.0

−3 −2 −1 0 1 2 3
x

Figura 6.2. Gráfica de los datos de un archivo y una función.

Es posible guardar y leer archivos en formato .mat para Matlab.

from scipy import io as spio
import numpy as np
A = np.ones((3, 3))
spio.savemat(’archivo.mat’, {’A’: A}) # savemat espera un diccionario.
datos = spio.loadmat(’archivo.mat’)
datos[’A’]

El resultado es array([[5, 6, 4, 3, 8, 9]]). Un arreglo de una dimensión en formato .mat se lee como un
arrego de tamaño 1 × n , aunque son equivalentes Python no los considera objetos iguales.

El comando clear limpia el terminal de los comandos anteriores.

41
Actividad 6.1

1. Escribe e implementa un programa que determine si un objeto aparece en un arreglo.

2. Escribe un programa que lea las edades de tus compañeros y las guarde en un archivo de texto.

42
 7 Sympy
La librería Sympy se utiliza para matemática simbólica, esto nos permite realizar operaciones con números ra-
cionales, irracionales o expresiones algebraicas. Importamos la librería.

import sympy as sym

>>> r = sym.Rational(2, 5)
>>> r
2/5

>>> r**2
4/25

>>> s=sym.pi
>>> s
pi

>>> t=sym.pi.evalf()
>>> t
3.14159265358979

Álgebra
Para usar literales tenemos los ejemplos siguientes.
>>> x = sym.Symbol(’x’)
>>> y = sym.Symbol(’y’)

Ahora es posible realizar operaciones algebraicas comunes.

>>> 2*x+4*y-5*x+7*y
-3*x + 11*y

En Sympy existe el concepto de infinito.

>>> sym.oo
oo

Los resultados tienen el formato de Python, pero es posible obtener un resultado más presentable y simbólico,
para ello llamamos una librería y algunas de sus funciones.
from sympy import init_printing
from sympy import init_session
init_session()

Las librerías pueden requerir la instalación de un lenguaje para composición de textos matemáticos y científicos
llamado LATEX, que también es software libre y se puede conseguir para distintos sistemas operativos. Este libro
se escribió en LATEX.

1. Linux: TexLive.

2. Windows: MikTex y TexLive.

3. MacOS: Mactex y texlive.

43
Al cargar las librerías y sus opciones adicionales el resultado cambia y es fácil leerlo.
>>> 2*x+4*y-5*x+7*y
−3x + 11y
Mostramos algunass operaciones algebraicas como el desarrollo de polinomios y otras.
>>> sym.expand((x + y) ** 5)
x 5 + 5x 4 y + 10x 3 y 2 + 10x 2 y 3 + 5x y 4 + y 5

>>>sym.expand(sym.sin(x + y), trig=True)

¡ ¢ ¡ ¢
% sin (x) cos y + sin y cos (x)

>>> sym.simplify((x**2-9) /(x-3) )

x +3

>>> sym.simplify( sym.sin(x)/sym.cos(x))

tan(x)
Para factorizar usamos la función factor().
>>> factor(x**2-9)
(x-3)(x+3)

Ecuaciones
Resolvemos ecuaciones lineales y cuadráticas. Todos las ecuaciones deben estar igualadas a cero.
Ejemplo 1. Resolvemos las ecuaciones siguientes.

1. 3x + 5 = 0

2. x + 2y = −1
5x + 2y = 5

3. x 2 − 5x + 6 = 0

#Ecuacion lineal de una variable.

>>> sym.solveset(3*x + 5, x)
© 5ª
>>> −3

#Sistemas de dos ecuaciones de dos variables.

>>> sym.solve((x + 2 * y + 1, 5 * x + 2 * y - 5), (x, y))
x : 32 , y : − 54
© ª

#Ecuaciones cuadráticas.
>>> sym.solveset(x**2 - 5*x + 6, x)
{2, 3}
Incluso resuelve ecuaciones con funciones como e x = 1
>>> sym.solveset(sym.exp(x) - 1, x)
{2ni π | n ∈ Z}

Límites
Sympy calcula límites con el siguiente código.
sym.limit(Función, Variable independiente, Valor al que tiende la variable independiente)

Ejemplo 2. Calculamos algunos límites.

44
 1. lı́m sen(x)
x→0

1
2. lı́m
x→∞ x
1
3. lı́m
x→0 x

>>> sym.limit(sym.sin(x) / x, x, 0)
1

>>> sym.limit(1 / x, x, sym.oo)

0

>>> sym.limit(1 / x, x, 0)
∞

Para calcular límites laterales se agrega un ’+’ para límites por la derecha y ’-’ para límites por la izquierda.
Ejemplo 3. Calculamos dos límites al infinito.
1
1. lı́m
x→3+ x −3
1
2. lı́m−
x→3 x −3

>>> limit(1/(x-3), x, 3, ’+’)

∞

>>> limit(1/(x-3), x, 3, ’-’)

−∞

Derivadas
Las derivadas de orden superior se calculan con la función
sym.diff(Función, Variable independiente)

Ejemplo 4. Calculamos derivadas.

1. f (x) = tan x

2. g (x) = cos(x 2 )

>>> sym.diff(sym.tan(x), x)
tan2 (x) + 1

>>> sym.diff(sym.cos(x**2), x)
−2x sin x 2
¡ ¢

Se pueden calcular derivadas de orden superior con la función.

sym.diff(Función, Variable independiente, Grado de la derivada.)

1. Calcular la primera derivada de f (x) = sen(x 2 ).

2. Calcular la tercera derivada de f (x) = sen(x 2 ).

45
>>> sym.diff(sym.sin(x**2), x, 1)
2x cos(x 2 )

>>> sym.diff(sym.sin(x**2), x, 3)
−4x 2x 2 cos x 2 + 3 sin x 2
¡ ¡ ¢ ¡ ¢¢

Series de Taylor
Calculamos las seriers de Taylor de las funciones f (x) = e x y tan(x).
>>> sym.series(sym.exp(x), x)
2 3 x4 x5
1 + x + x2 + x6 + 24 + O x6
¡ ¢
+ 120

>>> sym.series(sym.tan(x), x)
3 5
x + x3 + 2x
¡ 6¢
15 + O x

Integrales
En Python podemos calcular integrales indefinidas y definidas.
Ejemplo 5. Calculamos dos integrales indefinidas.
Z
1. x9d x
Z
2. cos xd x

>>> sym.integrate(x ** 9, x)
x10
10

>>> sym.integrate(sym.cos(x), x)
sen(x)

Para las integrales definidas agregamos los límites de integración, esto incluye las integrales impropias.
Ejemplo 6. Calculamos tres integrales indefinidas.
Z 1
1. x2d x
−1
Z π
2
2. cos xd x
− π2
Z 0
3. exd x
−∞

>>> sym.integrate(x**2, (x, -1, 1))

2
3

>>> sym.integrate(sym.cos(x), (x, -sym.pi / 2, sym.pi / 2))

2

>>> sym.integrate(sym.exp(x), (x, -sym.oo, 0))

1

46
Gráficas de funciones
Sympy nos permite graficar funciones, funciones paramétricas y funciones cuyo dominio es de dos variables,
esto lo hace mediante la librería matplotlib, no olvides el comando %matplotlib si quieres las gráficas en forma
interactiva.

Importamos las librerías necesarias.

>>> from sympy import symbols

>>> from sympy.plotting import plot

El formato para grafica es el siguiente.

#Una gráfica.
>>> plot(expr, rango, **kwargs)

#Múltiples gráficas con el miemo dominio.

>>> plot(expr1, expr2, ..., range, **kwargs)

#Múltiples gráficas con dominio distinto.

>>> plot((expr1, rango), (expr2, rango), ..., **kwargs)

Declaramos la variable y graficamos la función.

>>> x = symbols(’x’)
>>> plot(x**2, (x, -5, 5))
f(x)

25

20

15

10

0
−4 −2 0 2 4
x

Figura 7.1. Nuestra primera gráfica.

Pueden agregarse opciones a la gráfica.

>>> plot(x**2, (x, -5, 5),title=’Función’, xlabel=’x’, ylabel=’y’,legend=False)

47
 Función

y
25

20

15

10

0
−4 −2 0 2 4
x

Figura 7.2. Múltiples funciones en la misma gráfica.

Mostramos la lista de opciones y su tipo de argumento.

title:str
xlabel:str
ylabel:str
legend:bool
xscale:{’linear’, ’log’}
yscale:{’linear’, ’log’}
axis:bool
axis_center:tuple of two floats or {’center’, ’auto’}
xlim:tuple of two floats
ylim:tuple of two floats
aspect_ratio:tuple of two floats or {’auto’}
autoscale:bool
margin:float in [0, 1]

Otra posibilidad es cambiar el color de la gráfica usando el espacio RGB.

>>> plot(x**2, (x, -5, 5),title=’Función’, xlabel=’x’, ylabel=’y’,legend=False, line_color=(1,0,0))

Función
y

25

20

15

10

0
−4 −2 0 2 4
x

Figura 7.3. Gráfica en otro color.

Graficamos varias funciones al mismo tiempo.

>>> plot(x, x**2, x**3, (x, -3, 3))

48
 f(x)
20

10

0
−3 −2 −1 0 1 2 3
x
−10

−20

Figura 7.4. Múltiples funciones en la misma gráfica.

Funciones con distinto dominio.

>>> plot((x**2, (x, -2, 2)), (-3*x, (x, -3, 3)))

f(x)

7.5

5.0

2.5

0.0
−3 −2 −1 0 1 2 3

−2.5 x

−5.0

−7.5

Figura 7.5. Múltiples funciones con dominios diferentes.

Limitamos el número de puntos graficados.

>>> plot(x**2, adaptive=False, nb_of_points=5)

49
 f(x)
100

80

60

40

20

0
−10.0 −7.5 −5.0 −2.5 0.0 2.5 5.0 7.5 10.0
x

Figura 7.6. Gráfica con cinco puntos.

Para funciones paramétricas importamos dos librerías.

>>> from sympy import symbols, cos, sin

>>> from sympy.plotting import plot_parametric

El formato general se muestra a continuación.

#Una gráfica.
>>> plot_parametric(expr_x, expr_y, rango, **kwargs)

#Múltiples gráficas con el miemo dominio.

>>> plot_parametric((expr1_x, expr1_y), (expr2_x, expr2_y), range, **kwargs)

#Múltiples gráficas con dominio distinto.

>>> plot_parametric((expr_x, expr_y, range), ..., **kwargs)

Declaramos la variable y graficamos la función.

>>> t = symbols(’t’)
>>> plot_parametric(cos(t), sin(t), (t, -3.14, 3.14))

1.00

0.75

0.50

0.25

0.00
−1.00 −0.75 −0.50 −0.25 0.00 0.25 0.50 0.75 1.00

−0.25

−0.50

−0.75

−1.00

Figura 7.7. Gráfica paramétrica (cos(t ), sen(t )).

Múltiples gráficas paramétricas.

50
>>> plot_parametric((cos(t), sin(t), (t, -5, 5)), (t, cos(t), (t, -5, 5)))

1.00

0.75

0.50

0.25

0.00
−4 −2 0 2 4

−0.25

−0.50

−0.75

−1.00

Figura 7.8. Gráfica paramétrica (cos(t ), sen(t )).

El dominio de una función paramétrica es de −10 a 10 por defecto, cuando no se indica. Las opciones de gráfica
coincide con lass mencionadas para las funciones.

Las superficies 3D pueden graficarse con la misma facilidad, para ello importamos las librerías.
>>> from sympy import symbols
>>> from sympy.plotting import plot3d

Declaramos las variables y graficamos la función.

>>> x, y = symbols(’x y’)
>>> plot3d(x**2+y**2, (x, -5, 5), (y, -5, 5))

50
40
30
20
10

4
2
−4 0
−2 0 −2
2 4 −4

Figura 7.9. Superficie 3D.

Agregamos algunas opciones.

>>> plot3d(x**2+y**2, (x, -5, 5), (y, -5, 5), title=’$x^2+y^2$’,xlabel=’x’,ylabel=’y’)

51
 x2 + y2

50
40
30
20
10

4
2
−4 0
−2 −2 y
0
x 2 −4
4

Figura 7.10. Superficie 3D modificada.

Múltiples superficies con el mismo dominio.

>>> plot3d(x**2-y**2, x**2+y**2, (x, -5, 5), (y, -5, 5))

50
40
30
20
10
0
−10
−20

4
2
−4 0
−2 0 −2
2 4 −4

Figura 7.11. Superficis dadas por f (x, y) = x 2 − y 2 y f (x, y) = x 2 + y 2 .

Múltiples superficies con distinto dominio.

>>> plot3d((x**2 - y**2, (x, -5, 5), (y, -5, 5)), (x**2+y**2, (x, -3, 3), (y, -4, 4)))

52
 20
10
0
−10
−20

4
2
−4 0
−2 0 −2
2 4 −4

Figura 7.12. Superficis dadas por f (x, y) = x 2 − y 2 y f (x, y) = x 2 + y 2 con distinto dominio.

También es posible graficar curvas y superficies paramétricas.

Importamos las librerías

>>> from sympy import symbols, cos, sin

>>> from sympy.plotting import plot3d_parametric_line

El formato general es el siguiente.

#Una superficie.
>>> plot3d(expr, range_x, range_y, **kwargs)

#Múltiples superficies con el miemo dominio.

>>> plot3d(expr1, expr2, range_x, range_y, **kwargs)

#Múltiples superficies con dominio distinto.

>>> plot3d((expr1, range_x, range_y), (expr2, range_x, range_y), ..., **kwargs)

Declaramos la variable de parametrización y graficamos la función.

>>> t = symbols(’t’)
>>> plot3d_parametric_line(2*cos(3*t), 2*sin(3*t), t, (t, -5, 5))

53
 4

−2

−4

1.5
1.0
0.5
−1.5 0.0
−1.0 −0.5
−0.5
0.0 −1.0
0.5 −1.5
1.0
1.5

Figura 7.13. Función paramétrica de una variable.

Graficamos dos funciones paramétricas.

plot3d_parametric_line( (cos(3*t), sin(3*t), t, (t, -6, 6) ), (cos(t), t, t, (t, -5, 5)) , xlim=(-4,4), ylim=(

4
2
0
−2
−4
4
3
2
−4 −3 1
−2 −1 0
−1
0 1 −2
2 3 −3
4 −4

Figura 7.14. Funciones paramétricas don distinto dominio.

Para superficies paramétricas llamamos las librerías necesarias.

>>> from sympy import symbols, cos, sin
>>> from sympy.plotting import plot3d_parametric_surface

Las funciones para graficas son las siguientes.

#Una superficie.
plot3d_parametric_surface(expr_x, expr_y, expr_z, rango_s, range_t, Argumentos opcionales)

#Superficies múltiples.
plot3d_parametric_surface((expr_x, expr_y, expr_z, rango_s, range_t), ..., **kwargs)

Declaramos las variables y gráficamos una superficie (cos s sen t , sen s sen t , cos t ) con 0 ≤ s ≤ 2π y 0 ≤ π.

54
>>> s, t = symbols(’s t’)
>>> plot3d_parametric_surface(cos(s)*sin(t), sin(s)*sin(t), cos(t), (s, 0, 2*sym.pi), (t, 0, sym.pi))

1.00

0.75

0.50

0.25

0.00

−0.25

−0.50

−0.75

−1.00

1.00
0.75
0.50
0.25
−1.00 0.00
−0.75
−0.50 −0.25
−0.25
0.00 −0.50
0.25 −0.75
0.50
0.75 −1.00
1.00

Figura 7.15. Una esfera como función paramétrica.

Finalmente tenemos las ecuaciones implícitas. Importamos la librería.

>>> from sympy import plot_implicit, cos, sin, symbols, Eq, And

Declaramos las variables y la ecuación.

>>> x, y = symbols(’x y’)

#Dominio por defecto.

>>> plot_implicit(Eq(x**2 + y**2, 5))

#Dominio indicado.
>>> plot_implicit(Eq(x**2 + y**2, 16), (x, -10, 10), (y, -10, 10))
y

0
−4 −2 0 2 4
x

−2

−4

Figura 7.16. Gráfica de una circunferencia con dominio por defecto.

55
 y
4

0
−4 −2 0 2 4
x

−2

−4

Figura 7.17. Gráfica de una circunferencia con domininio indicado.

Graficamos regiones del plano.

>>> plot_implicit(5 < x**2+y**2)
y

0
−4 −2 0 2 4
x

−2

−4

Figura 7.18. Gráfica de la región x 2 + y 2 > 5.

Consulta más información en las páginas:

https://docs.sympy.org/latest/modules/plotting.html
https://docs.sympy.org/latest/tutorial/

Matrices
Sympy opera con matrices numéricas o algebraicas.
>>> sym.Matrix([[3, 0], [0, 3]])
· ¸
3 0
0 3

>>> A = sym.Matrix([[1, x], [1, y]])

56
 · ¸
1 x
1 y

>>> A**2
· ¸
x +1 xy +x
y +1 x + y2

Ecuaciones diferenciales
Con la función dsolve Sympy puede resolver algunas ecuaciones diferenciales ordinarias.

Primero creamos dos funciones desconocidas.

>>> f, g = sym.symbols(’f g’, cls=sym.Function)

Llamamos a la función y establecemos la ecuación diferencial

>>> f(x)
>>> f(x).diff(x, x) - f(x)
2
− f (x) + ddx 2 f (x)

Resolvemos la ecuación.
>>> sym.dsolve(f(x).diff(x, x) - f(x), f(x))
f (x) = C 1 e −x +C 2 e x

Si sabemos que es separable, lo indicamos como sugerencia para agilizar el proceso.

>>> sym.dsolve(sym.sin(x) * sym.cos(f(x)) + sym.cos(x) * sym.sin(f(x)) * f(x).diff(x), f(x), hint=’separable’)
h ³ ´ ³ ´i
C1 C1
f (x) = − acos cos (x) + 2π, f (x) = acos cos (x)

Se recomiendan las lecturas [3], [2] y [5].

57
8 Scipy

59
 9 Bases de datos
Las bases de datos se utilizan para almacenar datos en forma de tabla.

Importamos la librería.
import sqlite3

Conectamos o creamos la base de datos.

conn = sqlite3.connect(’base_escuela.sqlite’)
cursor = conn.cursor()
print("Base de datos abierta.")

Obtenemos la respuesta siguiente.

Base de datos abierta.

Ahora creamos la estructura de la base de datos.

cursor.execute(’’’CREATE TABLE ESCUELA
(MATRICULA INT PRIMARY KEY NOT NULL,
NOMBRE TEXT NOT NULL,
EDAD INT NOT NULL,
EMAIL CHAR(50),
CALIFICACION INT);’’’)
cursor.close()

Guardamos cambios y cerramos la base de datos.

#Guardar.
conn.commit()

#Cerrar.
conn.close()

Para cargar o modificar valores en la base de datos se usa el comando.

conn = sqlite3.connect(’base_escuela.sqlite’)
cursor = conn.cursor()

cursor.execute("INSERT INTO ESCUELA (MATRICULA,NOMBRE,EDAD,EMAIL,CALIFICACION) \

VALUES (001, ’Daniel’, 17, ’[email protected]’, 8)");
cursor.execute("INSERT INTO ESCUELA (MATRICULA,NOMBRE,EDAD,EMAIL,CALIFICACION) \
VALUES (002, ’Sara’, 16, ’[email protected]’, 9 )");
cursor.execute("INSERT INTO ESCUELA (MATRICULA,NOMBRE,EDAD,EMAIL,CALIFICACION) \
VALUES (003, ’Karla’, 18, ’[email protected]’, 10 )");
cursor.execute("INSERT INTO ESCUELA (MATRICULA,NOMBRE,EDAD,EMAIL,CALIFICACION) \
VALUES (004, ’Aldo’, 17, ’[email protected]’, 10)");
conn.commit()
conn.close()

Para visualizar la base de datos de la página https://www.sqlite.org/download.html descargamos el archivo

sqlite-tools-win32-x86-3300100.zip para Windows. Creamos una carpeta como C:\sqlite en el cual des-
comprimimos nuestro archivo descargado. Posteriormente descargamos e instalamos el programa SQLiteBrow-
ser de https://sqlitebrowser.org/dl/. Para Ubuntu se instalan ambos de la siguiente manera.

61
$ sudo apt-get update
$ sudo apt-get install sqlite3
$ sudo apt-get install sqlitebrowser

En el caso de Mac se descarga el archivo sqlite-tools-osx-x86-3300100.zip de la misma página de descarga

para Windows, creamos una carpeta y descomprimos en ella nuestro programa. El navegador se instala con los
comandos siguientes.
$ ruby -e "$(curl -fsSL
https://raw.githubusercontent.com/Homebrew/install/master/install)"
< /dev/null 2>
/dev/null
$ brew install sqlitebrowser

Figura 9.1. Nvegador de la base de datos.

62
 10 Sonido y música
"""
Created on Tue Mar 26 10:48:40 2019
@author: Andreiv
"""

import numpy as np
import wave
import struct

#Duración del sonido.

segundos=5

#Frecuencia de la onda.
frequencia = 220

#Número de muestras por segundo.

num_muestras = 48000*segundos

# Tasa de muestreo
tasa_muestreo = 48000.0

amplitud = 16000

# Declaramos el archivo y su formato: wav, mp3, aac, aif, ogg.

file = "test.aif"

# Generamos la onda seno.

onda_seno = [np.sin(2 * np.pi * frequencia * x/tasa_muestreo) for x in range(num_muestras)]

nframes=num_muestras

comptype="NONE"

compname="not compressed"

nchannels=2

sampwidth=2

wav_file=wave.open(file, ’w’)

wav_file.setparams((nchannels, sampwidth, int(tasa_muestreo), nframes, comptype, compname))

for s in onda_seno:

wav_file.writeframes(struct.pack(’h’, int(s*amplitud)))

https://www.pythonforengineers.com/audio-and-digital-signal-processingdsp-in-python/

63
 11 Procesamiento de imágenes
El procesamiento de imágenes es sencillo en Python, una imagen puede convertirse a un arreglo y un arreglo a
una imagen. Son necesarias algunas librerías.

from scipy import ndimage #Módulo para procesamiento de imagenes.

import matplotlib.pyplot as plt
from scipy import misc

Imágenes simples
Definimos una matriz.

imagen=np.array([[.5,0],[0,.5]])

plt.imshow(imagen)

Figura 11.1. Nuestra primera imagen.

import numpy as np
import matplotlib.pyplot as plt

# Generamos una matriz cuadrada aleatoria y su gráfica.

imagen = np.random.rand(25, 25)
plt.imshow(imagen, cmap=plt.cm.cool)

65
11.1 OpenCV
Instalar OpenCV en Windows 10.
1. Al instalar Anaconda, elegir “Add Anaconda to the system PATH environment variable” y “Register Anaconda
as the system Python 3.x”.
2. Comprueba la instalación en una terminal del sistema.
a) python -V
Python 3.7.3
b) pip -V
pip 19.0.3 from C:\ProgramData\Anaconda3\lib\site-packages\pip (python 3.7)
Ambos resultados deben ser positivos.
Se recomienda actualizar pip con python -m pip install -U pip.
3. Descarga el archivo que que corresponde a tu sistema operativo y versión de Python de la página https:
//www.lfd.uci.edu/~gohlke/pythonlibs/#opencv, en este caso fue el archivo
opencv_python-3.4.6+contrib-cp37-cp37m-win_amd64.whl

4. Instalamos el archivo con

pip install ".\opencv_python-3.4.6+contrib-cp37-cp37m-win_amd64.whl"

Processing c:\users\mxstu\opencv_python-3.4.6+contrib-cp37-cp37m-win_amd64.whl
Installing collected packages: opencv-python
Successfully installed opencv-python-3.4.6+contrib

5. Creamos en el Bloc de notas el archivo prueba.py:

66
import cv2

# Leemos la imagen.
imagen = cv2.imread("python-logo.png")

# Mostramos la imagen en pantalla.

cv2.imshow("Prueba de OpenCV", imagen)
cv2.waitKey(0)

Puedes usar cualquier imagen, pero el archivo y la imagen deben estar en la misma carpeta.

6. Ejecutamos el archivo con python prueba.py.

Para activar la cámara de video se usa el código siguiente.

import numpy as np
import cv2 as cv
cap = cv.VideoCapture(0)
if not cap.isOpened():
print("No fue posible abrir la camara")
exit()
while True:
# Capturar cuadro por cuadro.
ret, cuadro = cap.read()
# si cuadro puede leerse correctamente, entonces ret es True
if not ret:
print("No se recibe cuadro. Saliendo...")
break
# Nuestras operaciones sobre el cuadro van aqui
gray = cv.cvtColor(cuadro, cv.COLOR_BGR2GRAY)
# Mostrando el cuadro resultante
cv.imshow(’cuadro’, cuadro)
if cv.waitKey(1) == ord(’q’):
break
# Cuando todo esta hecho, lanzar la captura
cap.release()
cv.destroyAllWindows()

67
https://programarfacil.com/blog/vision-artificial/instalar-opencv-python-anaconda/
https://docs.opencv.org/3.4/d6/d00/tutorial_py_root.html

68
12 Arduino

69
13 Soluciones

71
Bibliografía
[1] Peter Agger, et al. “A Practical Guide to Biomedical Research for the Aspiring Scientist”. Springer
International Publishing AG. 2017.

[2] Gerardo Ayala San Martín “Algoritmos y programación”. Universidad de las Américas-Puebla. 2018.

[3] Allen Downey. “Think Python: How to Think Like a Computer Scientist”. Green Tea Press, 2015. https:
//greenteapress.com/wp/think-python-2e/

[4] John Kitchin. “pycse - Python3 Computations in Science and Engineering”. Carnegie Mellon University,
2015. http://kitchingroup.cheme.cmu.edu/pycse/pycse.pdf

[5] Gaël Varoquaux, et al. “Scipy Lecture Notes”. Green Tea Press, 2015. http://scipy-lectures.org/

73