Python For Science & Engineering - Traducido

Machine Translated by Google
Python para
ciencia e ingeniería
HansPetter Halvorsen
https://www.halvorsen.blog
Prefacio
Python es un lenguaje de programación popular y es uno de los lenguajes de programación más

utilizados en la actualidad.
Python funciona en todas las principales plataformas y sistemas operativos que se utilizan en la
actualidad, como Windows, macOS y Linux.
Python es un lenguaje de programación multipropósito, que se puede usar para simulación, creación
de páginas web, comunicación con sistemas de bases de datos, etc.
Mi blog/sitio web [1]: https://

www.halvorsen.blog
Aquí encontrarás multitud de recursos técnicos sobre Tecnología, Programación, Ingeniería del
Software, Automatización y Control, Informática Industrial, etc.
Aquí encuentras mi página web con recursos de Python:
https://www.halvorsen.blog/documents/programming/python/
Estos recursos son un complemento de este libro de texto. Aquí puede descargar el software,
descargar ejemplos de código, etc.
Este libro de texto está escrito en LATEX utilizando Overleaf.
LATEX es un sistema de preparación de documentos utilizado para la comunicación y publicación

de documentos científicos.
2
Para más información sobre LATEX:

https://www.latexproject.org
Overleaf es un sistema LATEX basado en la web , lo que significa que puede escribir sus
documentos LATEX en su navegador web, colaborar y compartir documentos con otros.
Para más información sobre Overleaf: https://

www.overleaf.com
Libros de Python
Puede encontrar otros libros de texto de Python dentro de diferentes dominios en mi página
web
de Python: https://www.halvorsen.blog/documents/programming/python/
Libros de Python:
• Programación en Python: este es un libro de texto sobre programación en Python con

muchos ejemplos prácticos y ejercicios. Aprenderá la base necesaria para la
programación básica con enfoque en Python.
• Python para ciencia e ingeniería: este es un libro de texto sobre programación Python
con muchos ejemplos, ejercicios y aplicaciones prácticas dentro de las matemáticas,
simulaciones, etc. El enfoque está en los cálculos numéricos en matemáticas e
ingeniería. Se presenta la teoría necesaria además de muchos ejemplos prácticos.
• Python para ingeniería de control: este es un libro de texto sobre programación en

Python con muchos ejemplos, ejercicios y aplicaciones prácticas dentro de las
matemáticas, simulaciones, sistemas de control, DAQ, sistemas de bases de datos,
etc. El enfoque está en el uso de Python dentro de las mediciones. , toma de datos
(DAQ), tecnología de control, tanto análisis de sistemas de control (análisis de
estabilidad, respuesta en frecuencia,…) como implementación de sistemas de control
(PID, etc.). La teoría requerida se presenta además de muchos ejemplos prácticos y
ejercicios en Python.
• Python para el desarrollo de software: este es un libro de texto sobre programación en

Python con muchos ejemplos, ejercicios y aplicaciones prácticas dentro de los sistemas
de software, desarrollo de software, ingeniería de software, sistemas de bases de
datos, aplicaciones de escritorio de aplicaciones web, aplicaciones GUI, etc. El
enfoque trata sobre el uso de Python para crear sistemas de software modernos. Se
presenta la teoría requerida además de muchos ejemplos prácticos y ejercicios en
Python.
3
Programación
La forma en que creamos software hoy en día ha cambiado drásticamente en los últimos 30 años,
desde la infancia de las computadoras personales a principios de los años 80 hasta los poderosos
dispositivos de hoy en día, como teléfonos inteligentes, tabletas y PC.
Internet también ha cambiado la forma en que usamos los dispositivos y el software. Todavía tenemos
aplicaciones de escritorio tradicionales, pero los sitios web, las aplicaciones web y las llamadas
aplicaciones para teléfonos inteligentes, etc. dominan el mercado de software en la actualidad.
Necesitamos encontrar y aprender lenguajes de programación que sean adecuados para la Nueva Era
de la Programación.
Hoy tenemos varios miles de lenguajes de programación diferentes. Supongo que necesitará aprender
más de un lenguaje de programación para sobrevivir en el mercado de software actual.
Aquí encontrará muchos recursos de programación: https://

www.halvorsen.blog/documents/programming/
Ingeniería de software
La ingeniería de software es la disciplina para crear aplicaciones de software. Un enfoque sistemático
para el diseño, desarrollo, prueba y mantenimiento de software.
Las principales partes o fases en el proceso de Ingeniería de Software son:
• Planificación
• Análisis de requerimientos
• Diseño
• Implementación
• Pruebas
• Despliegue y Mantenimiento
Aquí encontrará muchos recursos de ingeniería de software: https://

www.halvorsen.blog/documents/programming/softwareengineering/
4
Contenido
Primeros pasos con Python 13
1 Introducción 1.1 14
La Nueva Era de la Programación . . . . ... . . . . . . . . . . . 14 18
1.2 MATLAB. . . . . . . . . . . . ... . ... . . . . . . . . . . .
2 ¿Qué es Pitón? 20
2.1 Introducción a Python. . . . . . . . . . . . . . . . . . . . . . 20 21
2.1.1 Interpretado vs Compilado. . . . . . . . . . . . . . . . .
2.2 Paquetes de Python. . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.2.1 Paquetes de Python para ciencia y cálculos numéricos 23 2.3 Anaconda . .
. . . .. . . . . . . . . . . . . . . . . . . . . . . . . .
23 2.4 Editores de Python
. . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.4.1 Python INACTIVO. . . . . . . . . . . . . . . . . . . . . . . . . 24
2.4.2 Código de Visual Studio. . . . . . . . . . . . . . . . . . . . . . 25
2.4.3 Spyder. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.4.4 Visual Studio. . . . . . . . . . . . . . . . . . . . . . . . . 25
2.4.5 PyCharm. . . . . . . . . . . . . . . . . . . . . . . . . . . 25 .
2.4.6 IDE de Wing Python . . . . . . . . . . . . . . . . . . . . . 26 .
2.4.7 Cuaderno Jupyter. . . . . . . . . . . . . . . . . . . . . 26 .
2.5 Recursos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 .
2.6 Instalación de Python. . . . . . . . . . . . . . . . . . . . . . . . . . 26 .
2.6.1 Aplicación Python Windows 10 Store . . . . . . . . . . . . . . 27 .
2.6.2 Instalación de Anaconda. . . . . . . . . . . . . . . . . . . . 27 .
2.6.3 Instalación del código de Visual Studio. . . . . . . . . . . . . . . 27
3 Comience a usar Python

3.1 Python IDE. . . . . . . ... . ... . . . . . . . . . . . . . . . 29 .
3.2 Mi primer programa en Python. . . ... . . . . . . . . . . . . . . . 29 .
3.3 Estructura de Python. . . . . . . . . . ... . . . . . . . . . . . . . . . 29 .
3.4 Ejecutando Python desde la Consola. . . . . . . . . . . . . . . . 30 .
30 3.4.1 Apertura de la Consola en macOS . . . . 31 3.4.2 . .Abriendo
. . . . la
. Consola
. . . . en
. . . . . . .
Windows . . 32 3.4.3 Agregar Python a la ruta . . 32 3.5 Modo de secuencias. . . .de
. . . . . . . . . . . . .
comandos . . 34 3.5.1 Ejecutar secuencias de comandos de Python desde . . . . .Python
.
. . . . . . . . . . . . . . . . . . . . . . . . .
IDLE . . 34 3.5.2 Ejecutar secuencias de comandos de Python desde la consola (Terminal).
macOS 35 3.5.3 Ejecutar secuencias de comandos de Python desde . . el
. símbolo
. . . del
sistema en Win
bajas . . . . . . . . . . . . . . ... . . . . . . . . . . . . 36
6
3.5.4 Ejecutar secuencias de comandos de Python desde Spyder. . . . . . . . . . . . . . 36
4 Programación básica en Python 4.1 39

Programa básico en Python . . . . . ... . ... . . . . . . . . . . . . 39
4.1.1 Obtener ayuda. . . . . . . . ... . ... . . . . . . . . . . . . 39
4.2 Variables. . . . . . . . . . . . ... . . . . . . . . . . . . . . . . 39
4.2.1 Números. . . . . . . . . . . . ... . . . . . . . . . . . . 41 .
4.2.2 Cadenas. . . . . . . . . . ... . . . . . . . . . . . . . . . 42 .
4.2.3 Entrada de cadena. . . . . . . ... . . . . . . . . . . . . . . . 43 .
4.3 Funciones integradas. . . ... . . . . . . . . . . . . . . . . . . . 43 .
4.4 Biblioteca estándar de Python. . . ... . . . . . . . . . . . . . . . 44 .
4.5 Uso de bibliotecas, paquetes y módulos de Python. . . . . . . . . 45 .
4.5.1 Paquetes de Python. . . . . . . . ... . . . . . . . . . . . 47 .
4.6 Trazado en Python. . . ... . ... . . . . . . . . . . . . . . . 47 .
4.6.1 Subparcelas. . . . . . . . . . . . . . . . . . . . . . . . . . . 50 .
4.6.2 Ejercicios. . . . . . . . ... . ... . . . . . . . . . . . 52
II Programación Python 53
5 Programación en Python 5.1

Si... Si no. . . . . . . . ... . ... . . . . . . . . . . . . . . . 54 .
5.2 Matrices. . . . . . . . . . ... . ... . . . . . . . . . . . . . . . 54 .
5.3 Bucles For . . . . . . . . . . . . ... . ... . . . . . . . . . . . 55 .
5.3.1 Bucles For anidados. . . . . . . . ... . . . . . . . . . . . 57 .
5.4 Ciclos while. . . . . . . . . . . ... . . . . . . . . . . . . . . . 60 .
5.5 Ejercicios. . . . . . . . ... . ... . . . . . . . . . . . . . . . 61 . 61
6 Creación de funciones en Python 63 .

6.1 Introducción. . . . . . . ... . ...
. . . . . . . . . . . . . . . 63 .
6.2 Funciones con múltiples valores de retorno. . . . . . . . . . . . . . sesenta

6.3 Ejercicios. . . . . . . . ... . ... . . . . . . . . . . . . . . . y cinco . 66
7 Creación de clases en Python 7.1

Introducción. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 .
7.2 La función init () . . . . . . . . . . . . . . . . . . . . . . . 69 .
7.3 Ejercicios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 . 73
8 Creación de módulos de Python

8.1 Módulos de Python. . . . . . . . ... . . . . . . . . . . . . . . . 74 .
8.2 Ejercicios. . . . . . . . ... . ... . . . . . . . . . . . . . . . 74 . 75
9 Manejo de archivos en Python

9.1 Introducción. . . . . . . ... . ... . . . . . . . . . . . . . . . 77 .
9.2 Escribir datos en un archivo. . . . . . . . . . . . . . . . . . . . . . . . 77 .
9.3 Leer datos de un archivo. . . . . ... . ... . . . . . . . . . . . 77 .
9.4 Registro de datos en un archivo. . . . . . ... . ... . . . . . . . . . . . 78 .
9.5 Recursos web. . . . . . . . . ... . . . . . . . . . . . . . . . 78 .
9.6 Ejercicios. . . . . . . . ... . ... . . . . . . . . . . . . . . . 79 . 79
7
10 Manejo de errores en Python 10.1 82

Introducción al manejo de errores. . . . . . . . . . . . . . . . . . . 82
10.1.1 Errores de sintaxis. . . . . . . . . . . . . . . . . . . . . . . . . 82
10.1.2 Excepciones. . . . . . . ... . ... . . . . . . . . . . . . 82
10.2 Manejo de excepciones. . . . . . . . . . . . . . . . . . . . . . . . . 83
11 Depuración en Python 85
12 Instalación y uso de paquetes de Python 12.1 86

¿Qué es PIP? . . . . . . . . . . ... . . . . . . . . . . . . . . . . 86
III Entornos y distribuciones de Python 87
13 Introducción a los entornos y distribuciones de Python 88

13.1 Administradores de paquetes y entornos. ... . . . . . . . . . . . . 89
13.1.1 PIP. . . . . . . . . . . ... . ... . . . . . . . . . . . . 89
13.1.2 Conda. . . . . . . . . . . . . . ... . . . . . . . . . . . . 89
13.2 Entornos virtuales de Python. ... . . . . . . . . . . . . . . . . 90
14 Anaconda
14.1 Navegador Anaconda . . . . . . . . . . ... . . . . . . . . . . . 91 . 91
15 Pabellón pensado 93
Editores IV de Python 94
16 editores de Python 95
17 araña 97
18 código de estudio visual

18.1 Introducción a Visual Studio Code. . . . . . . . . . . . . . . . 99 .
18.2 Python en Visual Studio Code. ... . . . . . . . . . . . . . . . 99 . 100
19 estudio visual
19.1 Introducción a Visual Studio. ... . . . . . . . . . . . . . . . 101 .
19.2 Trabajar con Python en Visual Studio. . . . . . . . . . . . . . . . 101 .
19.2.1 Prepare Visual Studio para la programación con Python. . 101 .
19.2.2 Python interactivo. . . ... . . . . . . . . . . . . . . . 102 .
19.2.3 Nuevo Proyecto Python . . . . . . . . . . . . . . . . . . . . 102 . 103
20 PyCharm 109
IDE Python de 21 alas 111
22 Jupyter Notebook 22.1 113

JupyterHub . . . . . . . ... . ... . . . . . . . . . . . . . . . . 114
22.2 Cuadernos de Microsoft Azure. . ... . . . . . . . . . . . . . . . . 114
8
V Python para aplicaciones matemáticas 116
23 Matemáticas en Python 117

23.1 Funciones matemáticas básicas. . . . . . . .
.
. . . . . . . . . . . . . . . 117
23.1.1 Ejercicios. . . . . . . . ... .
... . . . . . . . . . . . . 119
23.2 Estadísticas. . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . 121
23.2.1 Introducción a la Estadística. . .
. . . . . . . . . . . . . . . 121 .
23.2.2 Funciones estadísticas en Python. . . . . . . . . . . . . . . 122 .
23.3 Funciones trigonométricas. . . . ... . . . . . . . . . . . . . . . 124 .
23.4 Polinomios. . . . . . . ... . ... . . . . . . . . . . . . . . . 128
24 Álgebra lineal en Python 24.1

Introducción al álgebra lineal. . . . ... . . . . . . . . . . . 131 .
24.2 Álgebra lineal con Python. . ... . . . . . . . . . . . . . . . 131 .
24.2.1 Vectores. . . . . . . . . ... . ... . . . . . . . . . . . 132 .
24.2.2 Matrices. . . . . . . . . ... . . . . . . . . . . . . . . . 133 .
24.2.3 Álgebra lineal (numpy.linalg) . ... . . . . . . . . . . . 134 .
24.2.4 Suma de matrices. . . . ... . ... . . . . . . . . . . . 134 .
24.2.5 Sustracción de matrices. . . . . . . . . . . . . . . . . . . . . 134 .
24.2.6 Multiplicación de matrices. ... . . . . . . . . . . . . . . . 135 .
24.2.7 Transpuesta de una matriz. . . . . ... . . . . . . . . . . . 136 .
24.2.8 Determinante. . . . . . ... . ... . . . . . . . . . . . 139 . 140
24.2.9 Matriz inversa. . . . . ... . ... . . . . . . . . . . . . 141
24.3 Resolución de ecuaciones lineales. . . . . . . . . . . . . . . . . . . . . . 142
24.4 Ejercicios. . . . . . . . ... . ... . . . . . . . . . . . . . . . . 144
25 números complejos en Python 146

25.1 Introducción a los Números Complejos. . ... . . . . . . . . . . . . 146 .
25.2 Números complejos con Python. . . . ... . . . . . . . . . . . 148
26 Ecuaciones Diferenciales 150

26.1 Introducción a las Ecuaciones Diferenciales . . . . . . . . . . . . . . . 150 .
26.2 Solucionadores de ODE en Python . . . . . . . . . . . . . . . . . . . . . . 153 .
26.3 Resolución de ecuaciones diferenciales múltiples de 1. orden . . . . . . . . . 156 .
26.4 Resolución de ecuaciones diferenciales de orden superior. . . . . . . . . . . 159 .
26.5 Ejercicios. . . . . . . . ... . ... . . . . . . . . . . . . . . . 161
27 Interpolación
27.1 Ejercicios. . . . . . . . ... . ... . . . . . . . . . . . . . . . 166 . 169
28 Ajuste de curvas Ajuste de modelos a datos

28.1 Regresión lineal. . . . . . . . ... . . . . . . . . . . . . . . . 172 .
28.2 Regresión polinomial. . . . . ... . . . . . . . . . . . . . . . 172 .
28.3 Ejercicios. . . . . . . . ... . ... . . . . . . . . . . . . . . . 174 . 180
29 Método de mínimos cuadrados 183
30 Derivación numérica 30.1 187

Derivación en polinomios . . . . . . . . . . . . . . . . . . . 193
9
31 Integración numérica 31.1 197

Integración sobre polinomios . . ... . . . . . . . . . . . . . . . . 202
31.2 Ejercicios. . . . . . . . ... . ... . . . . . . . . . . . . . . . . 203
32 Optimización 205
VI Uso de Python para simulaciones 209
33 Introducción a las simulaciones 210
34 Ecuaciones Diferenciales 211

34.1 Introducción a las Ecuaciones Diferenciales . . . . . . . . . . . . . . . 211
35 Sistemas discretos 213

35.1 Discretización. . . . . . ... . . . . . . . . . . . . . . . . . . . . 213
35.2 Ejercicios. . . . . . . . ... . . . . . . . . . . . . . . . . . . . . 217
36 Simulaciones en tiempo real 36.1 219

Introducción . . . . . . . ... . ... . . . . . . . . . . . . . . . . 219 .
36.2 Introducción al trazado en tiempo real. . . . . . . . . . . . . . . . 221 .
36.3 Trazado en tiempo real con animación. ... . . . . . . . . . . . 226 .
36.3.1 Aceleración de la animación de la trama. . . . . . . . . . . . . 230
VII Adquisición de datos (DAQ) con Python 235
37 Trazado de datos del sensor 236

37.1 Introducción . . . . . . . ... . ... . . . . . . . . . . . . . . . . 236
37.2 Introducción al trazado en tiempo real. . . . . . . . . . . . . . . . . 236 .
37.3 Trazado en tiempo real con animación. ... . . . . . . . . . . . 238 .
37.3.1 Aceleración de la animación de la trama. . . . . . . . . . . . . 240
38 Adquisición de datos (DAQ) con Python 38.1

Introducción a DAQ . . ... . ... . . . . . . . . . . . . . . . 243 .
38.2 Adquisición de datos utilizando dispositivos NI DAQ. . . . . . . . . . . . . 243 .
38.2.1 NIDAQmx. . . . . . . . . . . ... . . . . . . . . . . . 243 .
38.2.2 Explorador de automatización de medidas (MAX) . . . . . . . 245 .
38.3 NIDAQmx API Python. . . . ... . ... . . . . . . . . . . . 246 .
38.3.1 Escritura analógica. . . . . . . . . . . . . . . . . . . . . . . . 246 .
38.3.2 Lectura analógica. . . . . . . . . . . . . . . . . . . . . . . . 247 .
38.3.3 Escritura digital. . . . . . ... . . . . . . . . . . . . . . . 247 .
38.3.4 Lectura digital. . . . . . ... . ... . . . . . . . . . . . 249 .
38.4 Control de LED. . . . ... . ... . . . . . . . . . . . . . . . 249 .
38.5 Lectura de datos de sensores de temperatura. . . . . . . . . . . . . . 250 .
38.5.1 Leer datos del sensor de temperatura TMP36. . . . . . 252 .
38.5.2 Leer datos del termistor. . ... . . . . . . . . . . . 252 .
38.5.3 Lectura de Datos Dispositivo de Termopar NI TC01 . . . . . . . 256 . 260
38.6 Registro de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
10
VIII Desarrollo de base de datos Python 262
39 Aplicaciones de bases de datos con Python 263

39.1 Lenguaje de consulta estructurado (SQL) . . . . . . . . . . . . . . . . . 263
39.2 Servidor SQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
39.3 MySQL. . . . . . . . . . . . . ... . . . . . . . . . . . . . . . 264 .
39.4 MongoDB. . . . . . . . . . . . ... . ... . . . . . . . . . . . 264 . 264
40 MongoDB con Python 265

40.1 Introducción a MongoDB . . . ... . ... . . . . . . . . . . . .
40.2 MongoDB con Python. . . . ... . ... . . . . . . . . . . . 265 .
40.2.1 PyMongo. . . . . . . . . . . . ... . . . . . . . . . . . 265 .
40.3 Recursos adicionales. . . . . . ... . . . . . . . . . . . . . . . 265 . 266
IX Desarrollo de aplicaciones Python 267
41 Desarrollo de Aplicaciones con Python 41.1 268

Matemáticas, Ciencias e Ingeniería . . . . . . . . . . . . . . .
41.2 Aplicaciones GUI de escritorio. . . . . . . . . . . . . . . . . . . . . 269 .
41.2.1 PyQt. . . . . . . . . . ... . ... . . . . . . . . . . . 269 .
41.2.2 PySide2 . . . . . . . . . ... . ... . . . . . . . . . . . 270 .
41.2.3 Tkinter . . . . . . . . . ... . . . . . . . . . . . . . . . 271 .
41.2.4 WxPython . . . . . . . ... . ... . . . . . . . . . . . 271 .
41.3 Aplicaciones web. . . . ... . ... . . . . . . . . . . . . . . . 271 .
41.4 Aplicaciones de bases de datos. . . . . . . . . . . . . . . . . . . . . . . 272 .
41.4.1 Servidor SQL. . . . . . . ... . ... . . . . . . . . . . . 272 .
41.4.2 MySQL. . . . . . . . . ... . ... . . . . . . . . . . . 272 .
41.4.3 MariaDB. . . . . . . . ... . ... . . . . . . . . . . . 272 .
41.4.4 MongoDB. . . . . . . . . . . . ... . . . . . . . . . . . 273 . 273
42 Integración de Python con Visual Studio 274
43 Integración de Python con LabVIEW 43.1

¿Qué es LabVIEW? . . . . . . ... . ... . . . . . . . . . . . 275 .
43.2 Usando Python en LabVIEW . . ... . ... . . . . . . . . . . . 275 . 275
44 Raspberry Pi y Python 44.1 ¿Qué 280

es Raspberry Pi? . . . . . ... . . . . . . . . . . . . . . . . 280
45 Aprendizaje automático con Python 281

45.1 Introducción al aprendizaje automático. . ... . . . . . . . . . . . . 281
X Recursos 282
46 Python para usuarios de MATLAB 283

46.1 Usar Python dentro de MATLAB. . . . . ... . . . . . . . . . . . . 284
46.2 Llamar a MATLAB desde Python. . . . ... . . . . . . . . . . . . 285
11
47 Recursos de Python 287

47.1 Distribuciones de Python . . ... . . . . . . . . . . . . . . . . . . . . 287
47.2 Bibliotecas de Python. . . . ... . ... . . . . . . . . . . . . . . . . 287
47.3 Editores de Python. . . . . ... . ... . . . . . . . . . . . . . . . . 287
47.4 Tutoriales de Python . . . . ... . ... . . . . . . . . . . . . . . . . 288
47.5 Python en Visual Studio. . . . ... . . . . . . . . . . . . . . . . 288
XI Soluciones a Ejercicios 291
12
Parte I
Empezar con
Pitón
13
Capítulo 1
Introducción
Con este libro de texto aprenderás la programación básica de Python. El libro de texto contiene muchos
ejemplos y tareas a su propio ritmo que los usuarios deben realizar y resolver a su propio ritmo.
Encontrará recursos adicionales en mi blog/sitio web [1]. https://

www.halvorsen.blog
Mi sitio web sobre Python es: https://

www.halvorsen.blog/documents/programming/python/
Ver Figura 1.1
1.1 La nueva era de la programación

La forma en que creamos software hoy en día ha cambiado drásticamente en los últimos 30 años,
desde la infancia de las computadoras personales a principios de los años 80 hasta los poderosos
dispositivos de hoy en día, como teléfonos inteligentes, tabletas y PC.
Internet también ha cambiado la forma en que usamos los dispositivos y el software. Todavía tenemos
aplicaciones de escritorio tradicionales, pero los sitios web, las aplicaciones web y las llamadas
aplicaciones para teléfonos inteligentes, etc. dominan el mercado de software en la actualidad.
Necesitamos encontrar y aprender lenguajes de programación que sean adecuados para la Nueva Era
de la Programación.
Tenemos hoy varios miles de lenguajes de programación diferentes, entonces, ¿por qué deberíamos
aprender Python? Supongo que necesitará aprender más de un lenguaje de programación para
sobrevivir en el mercado de software actual. Python es fácil de aprender, por lo que es un buen punto
de partida para los nuevos programadores.
Python es un lenguaje de programación interpretado, de alto nivel y de propósito general.

Creado por Guido van Rossum y lanzado por primera vez en 1991 [2].
14
Figura 1.1: Sitio Web Python
Python es un lenguaje de programación bastante antiguo (1991) en comparación con muchos otros
lenguajes de programación como C# (2000), Swift (2014), Java (1995), PHP (1995).
Python se ha vuelto cada vez más popular durante los últimos 10 años. Hoy, Python se ha convertido en
uno de los lenguajes de programación más populares.
Hay muchas clasificaciones diferentes con respecto a qué lenguaje de programación es el más popular. En
la mayoría de estos rankings, Python está en el top 10.
Una de estas clasificaciones es la clasificación de IEEE Spectrum de los principales lenguajes de

programación [3].
De este ranking vemos que Python es el lenguaje de programación más popular en 2018. Ver Figura 1.2
Como vemos en la Figura 1.2 clasifican
los diferentes lenguajes de programación en las siguientes categorías:
• Internet
15
Figura 1.2: Los lenguajes de programación más populares
• Móvil
• Empresa
• Incorporado
De acuerdo con la Figura 1.2, vemos que Python se puede usar para programar aplicaciones
web, aplicaciones empresariales y aplicaciones integradas.
Hasta ahora, Python no se usa o no está optimizado para crear aplicaciones móviles.
Tenemos hoy 2 plataformas móviles principales; Las aplicaciones de iOS se programan
principalmente con el lenguaje de programación Swift, mientras que las aplicaciones de
Android se programan principalmente con Java o Kotlin.
Otra encuesta es la "Encuesta para desarrolladores de desbordamiento de pila 2018" [4]. Consulte la Figura
1.3.
Como podemos ver en [5] y la Figura 1.4, Python se vuelve cada vez más popular año tras
año.
Basado en la Figura 1.4, la fuente [5] intenta predecir el futuro de Python, vea la Figura 1.5.
Basado en las encuestas y estadísticas mencionadas anteriormente, obviamente Python es

un lenguaje de programación que debes aprender.
Resumamos:
• Python es divertido de aprender y usar y también lleva el nombre del grupo de comedia
británico llamado Monty Python.
• Python tiene una estructura de código simple y flexible y el código es fácil de

leer.
dieciséis
Figura 1.3: Los principales lenguajes de programación Encuesta de desbordamiento de pila
• Python es altamente extensible debido a su gran número de libre disponible

Python empaquetado y bibliotecas
• Python se puede utilizar en todas las plataformas (Windows, macOS y Linux).
• Python es polivalente y se puede utilizar para programar aplicaciones web, aplicaciones

empresariales y aplicaciones integradas, y dentro de las aplicaciones de ciencia e ingeniería de
datos.
• La popularidad de Python está creciendo rápidamente.
• Python es de código abierto y de uso gratuito
• La creciente comunidad de Python facilita la búsqueda de documentación,

ejemplos de código y obtener ayuda cuando sea necesario
En general, Python es un lenguaje de programación multipropósito que se puede usar en muchas

situaciones. Pero no existe un lenguaje de programación que sea mejor en todo tipo de situaciones,
por lo que es importante que conozca y tenga habilidades en diferentes lenguajes.
Mi lista de recomendaciones (una de tantas):
• Visual Studio y C
• LabVIEW: un lenguaje de programación gráfico muy adecuado para hardware

integración, toma de medidas y registro de datos
• MATLAB Cálculos numéricos y Computación científica
• Python: cálculos numéricos y computación científica, etc.
• Programación web, como HTML, CSS, JavaScript y un marco/lenguaje de programación del lado
del servidor como PHP, ASP.NET (C o VB.NET), Django (basado en Python)
17
Figura 1.4: El increíble crecimiento de Python
• Bases de datos (como SQL Server y MySQL) y el uso de Structured

Query Language (SQL) o las próximas bases de datos NoSQL
• Desarrollo de aplicaciones para las 2 plataformas principales iOS (XCode usando Swift
Lenguaje de programación) y Android (Android Studio usando Java
Lenguaje de programación o lenguaje de programación Kotlin)
Si tiene habilidades en la mayoría de las herramientas, lenguajes de programación y marcos

mencionados anteriormente, está bien preparado para trabajar como programador o ingeniero de
software a tiempo completo.
1.2 MATLAB
Si está buscando MATLAB, consulte lo siguiente: https://
www.halvorsen.blog/documents/programming/matlab/
18
Figura 1.5: El futuro de Python
19
Capitulo 2
¿Qué es Python?
2.1 Introducción a Python

Python es un lenguaje de programación de código abierto y multiplataforma, que se ha
vuelto cada vez más popular en los últimos diez años. Fue lanzado por primera vez en
1991. La última versión es 3.7.0. CPython es la implementación de referencia del lenguaje
de programación Python. Escrito en C, CPython es la implementación predeterminada y
más utilizada del lenguaje.
Python es un lenguaje de programación multipropósito (debido a sus muchas extensiones),

los ejemplos son computación y cálculos científicos, simulaciones, desarrollo web (usando,
por ejemplo, el marco web Django), etc.
Página de inicio de Python

[6]: https://www.python.org
El lenguaje de programación se mantiene y está disponible en (Python Software

Foundation): https://www.python.org Aquí puede descargar las funciones básicas de Python
en un paquete, que incluye el intérprete del lenguaje de programación Python y un editor
de código básico. o un entorno de desarrollo integrado, llamado IDLE. Ver Figura 2.1
Pero esto es solo el núcleo de Python, es decir, el intérprete, un editor muy básico y lo
mínimo necesario para crear programas básicos de Python.
Por lo general, necesitará más funciones para resolver sus tareas. Luego puede instalar y
usar paquetes de Python separados creados por terceros. Estos paquetes deben
descargarse e instalarse por separado (por lo general, se usa algo llamado PIP) o se elige
usar, por ejemplo, un paquete de distribución como Anaconda.
Python es un lenguaje de programación orientado a objetos (OOP), pero puede usar

Python en una aplicación básica sin necesidad de conocer o usar las funciones orientadas
a objetos en Python.
Python es un lenguaje de programación interpretado, esto significa que como desarrollador
20
Figura 2.1: IDLE Editor básico de Python
escribe archivos de Python (.py) en un editor de texto y luego coloca esos archivos en el intérprete
de python para que se ejecuten. Dependiendo del editor que esté utilizando, esto se hace
automáticamente o debe hacerlo manualmente.
Aquí hay algunas fuentes importantes de Python: [6], [7], [8].
2.1.1 Interpretado vs. Compilado

¿Cuáles son las diferencias entre los lenguajes de programación interpretados y los lenguajes
de programación compilados? ¿Qué tipo debería elegir y por qué debería molestarse?
Los lenguajes de programación generalmente se clasifican en una de dos categorías: compilados

o interpretados. Con un lenguaje compilado, el código que ingresa se reduce a un conjunto de
instrucciones específicas de la máquina antes de guardarse como un archivo ejecutable.
Ambos enfoques tienen sus ventajas y desventajas.
21
Con los idiomas interpretados, el código se guarda en el mismo formato que ingresó. Los
programas compilados generalmente se ejecutan más rápido que los interpretados porque los
programas interpretados deben reducirse a instrucciones de máquina en tiempo de ejecución.
Por lo general, es más fácil desarrollar aplicaciones en un entorno interpretado porque no tiene
que volver a compilar su aplicación cada vez que quiera probar una pequeña sección.
Python es un lenguaje de programación interpretado, mientras que, por ejemplo, C/C++ se

traducen ejecutando el código fuente a través de un compilador, es decir, C/C++ son lenguajes
compilados.
Los lenguajes interpretados, por el contrario, deben analizarse, interpretarse y ejecutarse cada
vez que se ejecuta el programa.
Otro ejemplo de un lenguaje de programación interpretado es PHP, que se utiliza principalmente

para crear páginas web dinámicas y aplicaciones web.
Todos los idiomas compilados se traducen ejecutando el código fuente a través de un compilador.
Esto da como resultado un código muy eficiente que se puede ejecutar cualquier número de
veces. Los gastos generales de la traducción se incurren solo una vez, cuando se compila la
fuente; a partir de entonces, solo necesita cargarse y ejecutarse.
Durante el diseño de una aplicación, es posible que deba decidir si usar un lenguaje compilado
o un lenguaje interpretado para el código fuente de la aplicación.
Los lenguajes interpretados, por el contrario, deben analizarse, interpretarse y ejecutarse cada
vez que se ejecuta el programa.
Por lo tanto, un lenguaje interpretado generalmente es más adecuado para realizar cálculos o
simulaciones "ad hoc", mientras que los lenguajes compilados son mejores para aplicaciones
permanentes donde la velocidad está enfocada.
2.2 Paquetes de Python

Con Python no obtienes mucho de la caja. En lugar de tener toda su funcionalidad integrada en
su núcleo, debe instalar diferentes paquetes para diferentes temas.
Este enfoque tiene ventajas y desventajas. Una desventaja es que necesita instalar estos
paquetes por separado y luego importar estos módulos en su código.
Este también es un enfoque típico para el software de código abierto, porque todos pueden
crear sus propios paquetes de Python y distribuirlos. De esa manera, también encontrará
paquetes de Python para casi todo, desde Computación científica hasta Desarrollo web.
22
Estos paquetes deben descargarse e instalarse por separado, o puede optar por utilizar, por
ejemplo, un paquete de distribución como Anaconda, donde normalmente obtiene los
paquetes que necesita para la computación científica. Con Anaconda normalmente obtiene
las mismas características que con MATLAB.
Existen muchos paquetes de Python, dependiendo de lo que vayas a resolver.

Tenemos paquetes de Python para desarrollo de GUI de escritorio, desarrollo de bases de
datos, desarrollo web, desarrollo de software, etc.
Vea una descripción general de Aplicaciones para

Python: https://www.python.org/about/apps/
Consulte también el sitio web del Python Package Index

(PyPI): https://pypi.org
Aquí puede buscar, descargar e instalar cientos de paquetes de Python dentro de diferentes
temas y aplicaciones. También puede crear sus propios paquetes de Python y distribuirlos
aquí.
2.2.1 Paquetes de Python para ciencia y cálculos numéricos
Algunos paquetes de Python importantes para la ciencia y los cálculos numéricos son:
• NumPy NumPy es el paquete fundamental para la computación científica con Python

[9]
• SciPy: SciPy es una biblioteca de Python gratuita y de código abierto que se utiliza
para la informática científica y la informática técnica. SciPy contiene módulos para
optimización, álgebra lineal, integración, interpolación, funciones especiales, FFT,
procesamiento de señales e imágenes, solucionadores de ODE y otras tareas
comunes en ciencia e ingeniería. [9]
• Matplotlib: Matplotlib es una biblioteca de trazado 2D de Python. [10]
• Pandas Biblioteca de análisis de datos Python de Pandas [11]
ejemplo, un paquete de distribución como Anaconda, donde normalmente obtiene los
paquetes que necesita para la computación científica. Con Anaconda normalmente obtiene
las mismas características que con MATLAB.
2.3 Anaconda
Anaconda es un paquete de distribución, donde obtiene el compilador de Python, los
paquetes de Python y el editor de Spyder, todo en un solo paquete.
Anaconda incluye Python, Jupyter Notebook y otros paquetes de uso común para la
informática científica y la ciencia de datos.
23
Ofrecen una versión gratuita (Anaconda Distribution) y una versión paga (Enter prise)
Anaconda está disponible para Windows, macOS y Linux
Web:
https://www.anaconda.com
Wikipedia:
https://en.wikipedia.org/wiki/Anaconda(P ythondistribution)
Spyder y los paquetes de Python (NumPy, SciPy, Matplotlib, ...) mencionados

anteriormente +++ están incluidos en la distribución de Anaconda.
2.4 Editores de Python

Un Editor es un programa donde creas tu código (y donde puedes ejecutarlo y probarlo).
La mayoría de los editores también tienen funciones para la depuración. Para programas
simples de Python, puede usar IDLE Editor, pero para programas más avanzados se
recomienda un mejor editor.
Ejemplos de editores de Python:

• Python IDLE
• Código de estudio visual
• Espía
• Estudio visual
• PyCharm
• IDE de ala Python
• Cuaderno Jupyter
Estos editores se describen brevemente a continuación y con más detalle más adelante en este libro
de texto.
El editor que debe usar depende de su experiencia, qué tipo de editores de código ha
usado anteriormente, sus habilidades de programación, lo que va a desarrollar en Python,
etc.
2.4.1 Python IDLE El lenguaje
de programación se mantiene y está disponible en (Python Software Foundation): https://

www.python.org Aquí puede descargar las funciones básicas de Python en un paquete,
que incluye el intérprete del lenguaje de programación Python y un editor de código
básico, o un entorno de desarrollo integrado, llamado IDLE. Ver Figura 2.1
Web:
https://www.python.org
24
2.4.2 Código de Visual Studio
Visual Studio Code es un editor de código fuente desarrollado por Microsoft para Windows,
Linux y macOS.
Web:
https://code.visualstudio.com
Recursos: Primeros pasos con Python en Visual Studio Code
2.4.3 Espía
Spyder es un entorno de desarrollo integrado (IDE) multiplataforma de código abierto para
la programación científica en el lenguaje Python.
Web:
https://www.spyderide.org
Wikipedia:
https://en.wikipedia.org/wiki/Spyder(software )
Spyder está incluido en la distribución de Anaconda.
2.4.4 Estudio visual
Microsoft Visual Studio es un entorno de desarrollo integrado (IDE) de Microsoft. Se utiliza

para desarrollar programas informáticos, así como sitios web, aplicaciones web, servicios
web y aplicaciones móviles. El lenguaje de programación predeterminado (principal) en
Visual Studio es C, pero se admiten muchos otros lenguajes de programación.
Visual Studio está disponible para Windows y macOS.
Visual Studio (desde 2017), tiene soporte integrado para Python, se llama "Soporte de
Python en Visual Studio".
Web:
https://visualstudio.microsoft.com
Wikipedia:
https://en.wikipedia.org/wiki/MicrosoftVisualStudio
2.4.5 PyCharm
PyCharm es multiplataforma, con versiones de Windows, macOS y Linux. La Community
Edition es de uso gratuito, mientras que la Professional Edition (versión de pago) tiene
algunas características adicionales.
25
Web:
https://www.jetbrains.com/pycharm/
2.4.6 Wing Python IDE La familia Wing
Python IDE de entornos de desarrollo integrado (IDE) de Wingware se creó específicamente para
el lenguaje de programación Python.
Existen 3 versiones diferentes de Wing [12]:
• Wing 101: una versión gratuita muy simplificada, para enseñar a profesionales principiantes
gramáticos
• Wing Personal: versión gratuita que omite algunas funciones, para estudiantes y
aficionados
• Wing Pro: una versión comercial (de pago) con todas las funciones, para profesionales
programadores
2.4.7 Cuaderno Jupyter

Jupyter Notebook es una aplicación web de código abierto que le permite crear y compartir
documentos que contienen código en vivo, ecuaciones, visualizaciones y texto.
Web:
http://jupyter.org
Wikipedia:
https://en.wikipedia.org/wiki/ProjectJupyter
2.5 Recursos
Aquí hay algunos recursos útiles de Python:
• El Tutorial oficial de Python https://

docs.python.org/3.7/tutorial/index.html
• La documentación oficial de Python

https://docs.python.org/3.7/index.html
• Tutorial de Python (w3schools.com) [13] https://

www.w3schools.com/python/
2.6 Instalación de Python

El lenguaje de programación Python se mantiene y está disponible en (Python
Fundación de Software):
26
Aquí puede descargar las funciones básicas de Python en un solo paquete, que incluye el intérprete
del lenguaje de programación Python y un editor de código básico, o un entorno de desarrollo
integrado, llamado IDLE. Ver Figura 2.1
Para la programación básica de Python, esto es lo suficientemente bueno.
Para una programación de Python más avanzada, normalmente necesita un editor de código mejor
y paquetes adicionales.
Para los ejemplos básicos de Python al principio, el software básico de Python de: https://
www.python.org es lo suficientemente bueno.
Le sugiero que comience con el software básico de Python para aprender los conceptos básicos,
luego puede actualizar a un editor mejor, instalar paquetes adicionales de Python (ya sea
manualmente o instalar Anaconda donde se incluye "todo").
2.6.1 Aplicación Python Windows 10 Store

Python 3.7 también está disponible en Microsoft Store para Windows 10.
La versión de Microsoft Store de Python 3.7 es un instalador simplificado para ejecutar scripts y
paquetes.
La versión de Microsoft Store de Python 3.7 es muy básica pero es lo suficientemente buena para
ejecutar scripts simples.
Python 3.7 Microsoft Store Edition recibirá todas las actualizaciones automáticamente cuando se
publiquen y no se requiere ninguna acción manual de su parte.
Para instalar la versión de Microsoft Store de Python, simplemente abra Microsoft Store en Windows
10 y busque Python.
2.6.2 Instalación de Anaconda El editor de
código de Spyder y los paquetes de Python (como NumPy, SciPy, mat plotlib, etc.) están incluidos
en la distribución de Anaconda.
Descargar e instalar desde: https://

www.anaconda.com
2.6.3 Instalación del código de Visual Studio

El código de Visual Studio Code es un editor simple y fácil de usar que se puede usar para muchos
lenguajes de programación diferentes.
27
Descargar e instalar desde:

Primeros pasos con Python en Visual Studio Code: https://

code.visualstudio.com/docs/python/pythontutorial
28
Capítulo 3
Empezar a usar Python
En este capítulo comenzaremos a usar Python en algunos ejemplos simples.
3.1 IDE de Python

El editor de código básico, o un entorno de desarrollo integrado, llamado IDLE.
Consulte la figura 3.1.
Otros editores de Python se discutirán con más detalle más adelante. Por ahora, puede usar el
IDE básico de Python (IDLE) o Spyder si ha instalado el paquete de distribución de Anaconda.
Figura 3.1: Shell de Python / Editor IDLE de Python
3.2 Mi primer programa en Python

Comenzaremos a usar Python y crearemos algunos ejemplos de código.
29
Ejemplo 3.2.1. Trazado en Python
Abramos su editor de Python y escribamos lo siguiente:
1 letra ( ” Hola Mundo ! ” )

Listado 3.1: Ejemplo de Hello World Python
[Fin del ejemplo]
Un comando extremadamente útil es help(), que ingresa a una funcionalidad de ayuda

para explorar todo lo que Python le permite hacer, directamente desde el intérprete.
Presione q para cerrar la ventana de ayuda y volver al indicador de Python.
Puede usar Python de diferentes maneras, ya sea en modo "interactivo" o en modo

"Scripting".
El programa python que ha instalado actuará de forma predeterminada como algo llamado
intérprete. Un intérprete toma los comandos de texto y los ejecuta a medida que los
ingresa, muy útil para probar cosas.
Puede ejecutar Python de manera interactiva de diferentes maneras, ya sea usando la

Consola, que es parte del sistema operativo, o Python IDLE y Python Shell, que es parte
de la instalación básica de Python desde https://www.python.org.
3.3 Estructura de Python

En el modo interactivo, usa Python Shell como se ve en la Figura 3.1.
Aquí escribe uno y un comando a la vez después del signo ">>>" en Python Shell.
1 >>> imprimir ( ” Hola Mundo ! ” )
3.4 Ejecutando Python desde la Consola

Una consola (o "terminal" o "símbolo del sistema") es una forma textual de interactuar con
su SO (sistema operativo).
El programa python que ha instalado actuará de forma predeterminada como algo llamado
intérprete. Un intérprete toma los comandos de texto y los ejecuta a medida que los
ingresa, muy útil para probar cosas.
A continuación, vemos cómo podemos ejecutar Python desde la consola, que es parte del sistema operativo.
30
3.4.1 Apertura de la consola en macOS

La consola estándar en macOS es un programa llamado Terminal. Abra Terminal navegando a
Aplicaciones, luego Utilidades, luego haga doble clic en el programa Terminal. También puede
buscarlo fácilmente en la herramienta de búsqueda del sistema en la parte superior derecha.
La Terminal de línea de comando es una herramienta para interactuar con su computadora. Se abrirá
una ventana con un mensaje de línea de comando, algo como esto:
Último iniciar sesión:˜ mar dic 11 0 8: 3 3: 5 1 en cons ol e

nombre de equipo : nombre de usuario
Simplemente escriba python en su consola, presione Entrar y debe ingresar al Intérprete de Python.
1 Último inicio de sesión: martes 11 de diciembre 1 2: 3 4: 1 6 en ttys 0 0 0

2 Hans−Pe t te r−Work−MacBook−Air : ˜ hansha$ python 3 Python 3 . 6 5 |
Anaconda Inc. | (por defecto 0 8 : 4 2 : 3 7, ) , 26 de abril de 2 0 1 ,
8 4 [CCG 4 . 2 . 1 sonido compatible 4 . 0 1 (etiquetas /RELEASE 401/final)] en
darwin 5
” ” ” , ” creditos ” o ” licencia ” para más
Escriba ” h el pinfo , copiar a la derecha
rm a c ió n .
6 >>>
El aviso >>> en la última línea indica que ahora se encuentra en una sesión interactiva de interpretación
de Python, también llamada "shell de Python". ¡Esto es diferente del símbolo del sistema de terminal
normal!
Ahora puede ingresar un código para que python se ejecute. Intentar:
>>> imprimir ( ” Hola Mundo " )
Véase también la Figura 3.2.
Figura 3.2: Consola macOS
Pruebe con otros comandos de Python, por ejemplo:
1 >>> a = 5 2 >>>
b = 2 3 >>> x = 5
4 >>> y = 3 a +
b 5 >>> y
31
3.4.2 Abriendo la Consola en Windows

La consola de Windows se llama Símbolo del sistema, llamada cmd. Una forma sencilla de acceder a
él es mediante la combinación de teclas Windows+R (Windows significa el botón del logotipo de
Windows), que debería abrir un cuadro de diálogo Ejecutar. Luego escriba cmd y presione Entrar o
haga clic en Aceptar.
También puedes buscarlo desde el menú de inicio.
Debería verse como:
C: \Usuarios\minombredeusuario>
Simplemente escriba python en el Símbolo del sistema, presione Entrar y debe ingresar al Intérprete
de Python. Consulte la figura 3.3.
Figura 3.3: Ventana del símbolo del sistema
Si recibe un mensaje de error como este:
'python' no se reconoce como un comando interno o externo, un programa operable o un archivo por
lotes.
Luego, debe agregar Python a su ruta. Consulte las instrucciones a continuación.
¡Nota! Esta también es una opción durante la configuración. Durante la instalación, puede seleccionar
"Agregar Python.exe a la ruta". Esta opción está configurada de forma predeterminada en "Desactivado".
Para obtener esa opción, debe seleccionar "Personalizar", sin usar la instalación "Predeterminada".
3.4.3 Agregar Python a la ruta

En el menú de Windows, busque "configuración avanzada del sistema" y seleccione Ver configuración
avanzada del sistema.
En la ventana que aparece, haga clic en Variables de entorno. . . cerca de la parte inferior derecha.
Consulte la Figura 3.4.
32
Figura 3.4: Propiedades del sistema de Windows
En la siguiente ventana, busque y seleccione la variable de usuario denominada Ruta y haga clic en
Editar. . . para cambiar su valor. Consulte la Figura 3.5.
Seleccione "Nuevo" y agregue la ruta donde se encuentra "python.exe". Consulte la Figura 3.6.
La ubicación predeterminada es:
C:\Usuarios\usuario\AppData\L oc al\Programs\Python\Python37 −32\
Haga clic en Guardar y abra el símbolo del sistema una vez más e ingrese "python" para verificar que
funciona. Consulte la Figura 3.3.
33
3.5 Modo de secuencias de comandos
En el modo "Secuencias de comandos", puede escribir un programa de Python con varios comandos
de Python y luego guardarlo como un archivo (.py).
3.5.1 Ejecutar secuencias de comandos de Python desde Python IDLE

Desde Python Shell, seleccione Archivo → Nuevo archivo, o puede abrir un programa Pytho
existente o Python Script seleccionando Archivo → Abrir...
Vamos a crear un nuevo Script y escribir lo siguiente:
1 letra ( ” ” ) 2Hola
letras
( ”Mundo” ) 3 letras
( ”¿Cómo estás?” )
En la Figura 3.7 vemos cómo se hace esto. Como puede ver, podemos ingresar muchos comandos
de Python que juntos forman un programa de Python o un script de Python.
Desde Python Shell, seleccione Ejecutar → Ejecutar módulo o presione F5 para ejecutar o ejecutar
el script de Python. Consulte la Figura 3.8.
34
El editor IDLE es muy básico, para tareas más complicadas normalmente puede preferir usar
otro editor como Spyder, Visual Studio Code, etc.
3.5.2 Ejecutar secuencias de comandos de Python desde la consola (Terminal)

macOS
Desde la Consola (Terminal) en macOS:
1 $ cd / Usuarios / nombre de usuario /

Descargas 2 $ python h ell owo rl d . py
¡Nota! ¡Asegúrese de estar en el símbolo del sistema de su sistema, que tendrá $ o > al final, no
en el modo Python (que tiene >>> en su lugar)!

Luego responde con:
1 Hola 2
Mundo 3
¿Cómo estás?
35
Figura 3.7: Guión Python
3.5.3 Ejecutar secuencias de comandos de Python desde el símbolo del sistema en

ventanas
Desde el símbolo del sistema en la ventana:
1 > cd / 2
> cd Temp 3 >
python h ell owo rl d . py
¡Nota! ¡Asegúrese de estar en el símbolo del sistema de su sistema, que tendrá > al final, no
en el modo Python (que tiene >>> en su lugar)!

Luego responde con:
1 Hola 2
Mundo 3
¿Cómo estás?
3.5.4 Ejecutar secuencias de comandos de Python desde Spyder
Si ha instalado el paquete de distribución de Anaconda, puede usar el editor de Spyder. Ver

3.11.
En el editor de Spyder, tenemos el Editor de secuencias de comandos a la izquierda y el shell

interactivo de Python o la ventana Consola a la derecha. Ver Ver 3.11.
36
Figura 3.8: Ejecución de un script de Python
Figura 3.9: Ejecución de secuencias de comandos de Python desde la ventana Consola en macOS
Figura 3.10: Ejecución de secuencias de comandos de Python desde la ventana Consola en macOS
37
Figura 3.11: Ejecución de una secuencia de comandos de Python en Spyder
38
Capítulo 4
Programación básica de Python
4.1 Programa básico de Python

Comenzaremos a usar Python y crearemos algunos ejemplos de código.
Usamos el editor IDLE básico (u otro editor de Python)
Ejemplo 4.1.1. Hola mundo ejemplo
Abramos su editor de Python y escribamos lo siguiente:
1 letra ( ” Hola Mundo ! ” )

Listado 4.1: Ejemplo de Hello World Python
[Fin del ejemplo]
4.1.1 Obtener ayuda

Un comando extremadamente útil es help(), que ingresa a una funcionalidad de ayuda para
explorar todo lo que Python le permite hacer, directamente desde el intérprete.
Presione q para cerrar la ventana de ayuda y volver al indicador de Python.
4.2 Variables
Las variables se definen con el operador de asignación, “=”. Python se tipifica dinámicamente,
lo que significa que las variables se pueden asignar sin declarar su tipo y que su tipo puede
cambiar. Los valores pueden provenir de constantes, de cálculos que involucren valores de
otras variables o de la salida de una función.
Pitón
39
Ejemplo 4.2.1. Crear y usar variables en Python
Usamos el IDLE básico (u otro editor de Python) y escribimos lo siguiente:

1 >>> x = 3
2 >>> x 3 3
Listado 4.2: Uso de variables en Python
Aquí definimos una variable y establecemos el valor igual a 3 y luego imprimimos el resultado
en la pantalla.
[Fin del ejemplo]
Puede escribir un comando por tiempo en IDLE. Si sale de IDLE, las variables y los datos se
perderán. Por lo tanto, si desea escribir un programa un poco más largo, es mejor que use
un editor de texto para preparar la entrada para el intérprete y ejecutarlo con ese archivo
como entrada. Esto se conoce como crear un script.
Los scripts o programas de Python se guardan como un archivo de texto con la extensión .py
Ejemplo 4.2.2. Cálculos en Python
Podemos usar variables en un cálculo como este:

1x=3
2y=3 x
3 imprimir ( y )
Listado 4.3: Uso e impresión de variables en Python
Podemos implementar la fórmula y = ax + b así:

1 un = 2 2
segundo =
53x=3
4
5y=a x+b
6
7 imprimir (y)
Listado 4.4: Cálculos en Python
Como se ve en los ejemplos, puede usar el comando print() para mostrar los valores en la
pantalla.
[Fin del ejemplo]
40
Una variable puede tener un nombre corto (como x e y) o un nombre más descriptivo (suma, cantidad,
etc.).
No necesita definir las variables antes de usarlas (como debe hacerlo, por ejemplo, C/C++/C).
La Figura 4.1 muestra estos ejemplos usando el editor IDLE básico.
Figura 4.1: Python básico
Aquí hay algunas reglas básicas para las variables de Python:
• Un nombre de variable debe comenzar con una letra o el carácter de subrayado
• Un nombre de variable no puede comenzar con un número
• Un nombre de variable solo puede contener caracteres alfanuméricos (Az, 09) y

guiones bajos
• Los nombres de las variables distinguen entre mayúsculas y minúsculas, por ejemplo, cantidad, Cantidad y CANTIDAD
son tres variables diferentes.
4.2.1 Números
Hay tres tipos numéricos en Python:
• En t
• flotar
• complejo
41
Las variables de tipos numéricos se crean cuando les asignas un valor, por lo que en la codificación
normal no necesitas preocuparte.
Ejemplo 4.2.3. Tipos numéricos en Python
1 x = 1 # int # float 2 y = 2.
+2j# 83z=3
complejo
Listado 4.5: Tipos numéricos en Python
Esto significa que simplemente asigna valores a una variable sin preocuparse de qué tipo de datos
es.
1 impresión ( tipo (x)) 2

impresión ( tipo (y)) 3
impresión ( tipo (z))
Listado 4.6: Comprobar tipos de datos en Python
Si usa el Editor de Spyder, puede ver los tipos de datos que tiene una variable usando el Explorador
de variables (Figura 4.2):
Figura 4.2: Editor de variables en Spyder
[Fin del ejemplo]
4.2.2 Cadenas
Las cadenas en Python están entre comillas simples o comillas dobles. 'Hola' es lo mismo que 'Hola'.
Las cadenas se pueden enviar a la pantalla usando la función de impresión. Por ejemplo: imprimir(”Hola”).
A continuación vemos ejemplos del uso de cadenas en Python:
1 un = ” Hola Mundo ! ”
2
3 imprimir ( un )
4
5 imprimir ( a [ 1 ] )
6 imprimir ( a [ 2 : 5 ] )
7 imprimir ( len ( a ) )
8 imprimir ( a . l ow er ( ) )
42
9 imprimir ( a . superior
( ) ) 10 imprimir ( a . reemplazar , ”J” ) )
( ”H” 11 imprimir ( a . dividir ( ” ” ) )
Listado 4.7: Cadenas en Python
Como puede ver en el ejemplo, hay muchas funciones integradas que manipulan cadenas en
Python. El ejemplo muestra solo algunos de ellos.
Las cadenas en Python son matrices de bytes y podemos usar el índice para obtener un carácter
específico dentro de la cadena, como se muestra en el código de ejemplo.
[Fin del ejemplo]
4.2.3 Entrada de cadena

Python permite la entrada de línea de comandos.
Eso significa que podemos pedirle al usuario que ingrese.
El siguiente ejemplo solicita el nombre del usuario, luego, usando el método input(), el programa
imprime el nombre en la pantalla:
1 letra ( ” ” ) Ingrese su nombre :
2 x = entrada ( )
”
3 letra ( ” Hell o , +x)
Listado 4.8: Entrada de cadena
[Fin del ejemplo]
4.3 Funciones integradas
Python consta de muchas funciones integradas. Algunos ejemplos son la función print(9) que ya
hemos utilizado (quizás sin darnos cuenta, en realidad es una función integrada).
Python también consta de diferentes módulos, bibliotecas o paquetes. Estos Módulos, Bibliotecas
o Paquetes consisten en muchas funciones predefinidas para diferentes temas o áreas, como
matemáticas, gráficos, manejo de sistemas de bases de datos, etc.
Consulte la Sección 4.4 para obtener más información y detalles al respecto.
En otro capítulo aprenderemos a crear nuestras propias funciones desde cero.
43
4.4 Biblioteca estándar de Python

Python le permite dividir su programa en módulos que pueden reutilizarse en otros programas de
Python. Viene con una gran colección de módulos estándar que puede usar como base de sus
programas.
La biblioteca estándar de Python consta de diferentes módulos para el manejo de E/S de archivos,
matemáticas básicas, etc. No necesita instalarlos por separado, pero debe tenerlos en cuenta cuando
desee utilizar algunos de estos módulos o algunas de las funciones. dentro de estos módulos.
El módulo matemático tiene todas las funciones matemáticas básicas que necesita, tales como:
Funciones métricas trigonométricas: sin(x), cos(x), etc. Funciones logarítmicas: log(), log10(), etc.
Constantes como pi, e, inf, nan, etc. etc.
Ejemplo 4.4.1. Usando el módulo de matemáticas
Creamos algunos ejemplos básicos de cómo usar una Biblioteca, un Paquete o un Módulo:
Si solo necesitamos la función sin(), podemos hacer esto:

1 de matemáticas importar pecado
2
3 x = 3. 1 4
4 y = sen ( x )
5
6 imprimir (y)
Si necesitamos algunas funciones, podemos hacer esto
1 de importación matemática si n , porque
3 x = 3. 1 4
4 y = sen ( x ) 5
imprimir ( y )
6
7 y = cos ( x ) 8
imprimir ( y )
Si necesitamos muchas funciones podemos hacer así:

1 de importación matemática
2
3 x = 3. 1 4 4
y = sin ( x ) 5
imprimir ( y )
6
7 y = cos ( x ) 8
imprimir ( y )
También podemos usar esta alternativa:
1 importación de matemáticas
2
3 x = 3. 1 4 4 y =
matemática . pecado ( x )
5
6 imprimir (y)
44
También podemos escribirlo así:
1 importar matemáticas como mt

2
3 x = 3. 1 4 4 y =
metro . pecado ( x )
5
6 imprimir (y)
[Fin del ejemplo]
Hay ventajas y desventajas con los diferentes enfoques. Es posible que en su programa
necesite usar funciones de muchos módulos o paquetes diferentes. Si importa todo el
módulo en lugar de solo las funciones que necesita, usará más memoria de la computadora.
Muy a menudo, también necesitamos importar y usar varias bibliotecas donde las diferentes
bibliotecas tienen algunas funciones con el mismo nombre pero un uso diferente.
Otros módulos útiles en la biblioteca estándar de Python son las estadísticas (donde tiene
funciones como mean(), stdev(), etc.)
Para obtener más información sobre las funciones de la biblioteca estándar de Python,
ver:
https://docs.python.org/3/library/index.html
4.5 Uso de bibliotecas, paquetes y mods de Python

ules
En lugar de tener toda su funcionalidad integrada en su núcleo, Python fue diseñado para
ser altamente extensible. Este enfoque tiene ventajas y desventajas.
Una desventaja es que necesita instalar estos paquetes por separado y luego importar estos
módulos en su código.
Algunos paquetes importantes son:
• NumPy NumPy es el paquete fundamental para la computación científica

con pitón
• SciPy: SciPy es una biblioteca de Python gratuita y de código abierto que se utiliza para
la informática científica y la informática técnica. SciPy contiene módulos para
optimización, álgebra lineal, integración, interpolación, funciones especiales, FFT,
procesamiento de señales e imágenes, solucionadores de ODE y otras tareas comunes
en ciencia e ingeniería.
• Matplotlib: Matplotlib es una biblioteca de trazado 2D de Python
45
Existen muchos otros paquetes, dependiendo de lo que vayas a resolver.
ejemplo, un paquete de distribución como Anaconda.
Aquí encontrará una descripción general de la biblioteca

NumPy: http://www.numpy.org

SciPy: https://www.scipy.org

Matplotlib: https://matplotlib.org
Aprenderá las funciones básicas en todas estas bibliotecas. Usaremos todos los en diferentes
ejemplos y ejercicios a lo largo de este libro de texto.
Ejemplo 4.5.1. Uso de bibliotecas
En este ejemplo usamos la biblioteca NumPy:

1 importar numpy como np
2
3x = 3
4
5 y = np. pecado ( x )
6
7 imprimir (y)
En este ejemplo, usamos el módulo de matemáticas en la biblioteca estándar de Python y la

biblioteca NumPy:
1 importar matemáticas como
mt 2 importar numpy como np
3
4x = 3
5
6 y = mt. pecado ( x )
7
8 imprimir (y)
9
10
12
13 imprimir (y)
¡Nota! Como se ve en este ejemplo, usamos una función llamada sin() que existe tanto en el
módulo matemático en la biblioteca estándar de Python como en la biblioteca NumPy.
En este caso dan los mismos resultados. En este caso no se recomienda el siguiente código:
2 de importación numérica
3
4x = 3
5
46
6 y = sen ( x )
7
8 imprimir (y)
9
10
11 y = sen ( x )
12
13 imprimir (y)
En este caso funciona, pero suponga que tiene 2 funciones diferentes con el mismo nombre
que tienen un significado diferente en 2 bibliotecas diferentes.
[Fin del ejemplo]
4.5.1 Paquetes de Python

Además de la biblioteca estándar de Python, hay una colección cada vez mayor de varios
miles de componentes (desde programas y módulos individuales hasta paquetes y marcos de
desarrollo de aplicaciones completos), disponibles en el Índice de paquetes de Python.
Índice de paquetes de Python (PYPI):

https://pypi.org
Aquí puede descargar e instalar paquetes individuales de Python.

Una alternativa fácil es Anaconda Distribution, donde se incluyen muchos de los paquetes de
Python más utilizados.
Anaconda:
https://www.anaconda.com/distribution/
4.6 Trazado en Python

Por lo general, necesita crear algunos diagramas o gráficos. Para hacer diagramas o gráficos
en Python, necesitará una biblioteca externa. La biblioteca más utilizada es Matplotlib.
Matplotlib es una biblioteca de trazado 2D de Python

Matplotlib: https://matplotlib.org
Si está familiarizado con MATLAB y el trazado básico en MATLAB, el uso de Matplotlib es muy
similar.
La principal diferencia con MATLAB es que necesita importar la biblioteca, ya sea la biblioteca
completa o una o más funciones.
Para simplificar, importamos toda la biblioteca de esta manera:
1 alfombra de importación pl o tli b . py pl otasplt
47
Funciones gráficas que usarás mucho:
• trama()
• título()
• etiquetax()
• ylabel()
• eje()
• red()
• subtrama()
• leyenda()
• espectáculo()
Vamos a crear algunos ejemplos básicos de trazado usando la biblioteca Matplotlib:
En este ejemplo tenemos arreglos con datos. Queremos graficar x contra y. Podemos suponer
que x es una serie de tiempo y y es la temperatura correspondiente en i grados Celsius.

2
3x=[1 , 2, 3 , 4 , 5, 6, 7, 8, 9 , 1 0]
4
5y=[5 , 2 ,4 , 4 , 8, 7, 4 , 8, 10, 9]
6
7 plt. parcela ( x , y ) 8
plt . xlabel ( 'Tiempo(s)' ) 9 plt. ylabel
( 'Temperatura (degC)' )10 plt. espectáculo ( )
Obtenemos la siguiente trama:

También podemos escribir así:
1 de mat pl o tli b . py plot import

2
3x=[14y , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 1 0]
=[5 , 2 ,4 , 4 , 8 , 7 , 4 , 8 , 1 0 , 9 ]
5
6 plot ( x , y ) 7
xlabel ( 'Tiempo ( s ) ' ) 8 ylabel
(' Temperatura (degC) ' ) 9 mostrar
()
Esto hace que el código sea más fácil de leer. aparece un problema con este enfoque suponiendo
que importamos y usamos varias bibliotecas y que las diferentes bibliotecas tienen algunas
funciones con el mismo nombre pero con un uso diferente.
48
Figura 4.3: Trazado en Python
[Fin del ejemplo]
Hemos utilizado 4 funciones básicas de trazado en la biblioteca Matplotlib:
• trama()
• etiquetax()
• ylabel()
• espectáculo()
Ejemplo 4.6.2. Trazado de una curva sinusoidal
1 importar numpy como np 2

importar mat pl o tli b . py pl otasplt
3
4x=[0 , 1, 2, 3, 4, 5, 6, 7]
5
7
plt . etiqueta x ( ' ' ) 10Xplt .
ylabel ( ' ' ) 11 plt . y
espectáculo ( )
Esto da la siguiente gráfica (ver Figura 4.4): Una mejor

solución será entonces:
49
Figura 4.4: Trazado de una función Seno en Python
1 alfombra de importación pl o tli b . py pl otasplt 2

importar numpy como np
3
4 xstart = 0 5 xst op
= 2 np . pi 6 incremento
remen t = 0. 1
7
8 x = np. ar an ge (xinicio xstop , inc remen t ) ,

9
11
plt . etiqueta x ( ' ' ) 14 Xplt .
ylabel ( ' ' ) 15 plt . y
espectáculo ( )
Esto da la siguiente gráfica (ver Figura 4.5): Si

desea cuadrículas, puede usar la función grid().
[Fin del ejemplo]
4.6.1 Subparcelas
El comando subparcela le permite mostrar varias parcelas en la misma ventana.
Escribir ”subplot(m,n,p)” divide la ventana de la figura en una matriz mbyn de pequeñas
subtramas y selecciona la subtrama para la trama actual. Los gráficos están numerados
en la primera fila de la ventana de la figura, luego en la segunda fila y así sucesivamente.
Ejemplo 4.6.3. Creación de subtramas
50
Figura 4.5: Trazado de una función de seno en Python Mejor implementación
Crearemos y trazaremos sin() y cos() en 2 subtramas diferentes.

1 alfombra de importación pl o tli b . py pl otasplt 2
importar numpy como np
3
remen t = 0. 1
7

9
11
12 z = np. porque ( x )
13
14
15 plt. subtrama ( 2 16 plt . ,1 ,1)

'
plot ( x 17 plt . título ( ' , y , gramo ')
18 plt . xlabel ( ' 19 plt .
sen ' )
X
ylabel ( ' 20 plt . g ri d ( )
21 plt . mostrar ( ) ' ) sen ( x ) ' )
22
23
24 plt. subtrama ( 2 25 plt . ,1 ,2)

z , 'r
plot ( x 26 plt . título ( ' , ')
porque ')
27 plt . xlabel ( ' 28 plt .
X ')
ylabel ( ' 29 plt . g ri d ( )
30 plt . show ( ) porque ( x ) ' )
[Fin del ejemplo]
51
Figura 4.6: Creación de subparcelas en Python
4.6.2 Ejercicios
A continuación encontrará diferentes ejercicios a su propio ritmo que debe realizar y resolver por
su cuenta. ¡La única forma de aprender Python es hacer muchos ejercicios!
Ejercicio 4.6.1. Crea sin(x) y cos(x) en 2 gráficos diferentes
Crea sin(x) y cos(x) en 2 gráficos diferentes.
Debe usar todas las funciones de trazado enumeradas a continuación en su código:
• trama()
• título()
• etiquetax()
• ylabel()
• eje()
• red()
• leyenda()
• espectáculo()
[Fin del ejercicio]
52
Parte II
Programación Python
53
Capítulo 5
Programación Python
Hemos repasado los conceptos básicos de Python, como las variables, el uso de algunas
funciones básicas integradas, el trazado básico, etc.
Es posible que llegue lejos solo con estos delgados, pero para crear aplicaciones reales, necesita
conocer y usar funciones como:
• Si... Si no
• Para bucles
• Mientras Bucles
• matrices...
Si está familiarizado con uno o más lenguajes de programación, estas funciones le resultarán
familiares y conocidas. Todos los lenguajes de programación tienen estas características
incorporadas, pero la sintaxis es ligeramente diferente de un idioma a otro.
5.1 Si... Si no
Una "sentencia if" se escribe utilizando la palabra clave if.
Aquí hay algunos ejemplos de cómo usar oraciones If en Python:
Ejemplo 5.1.1. Uso de bucles for en Python
1 un = 5 2
segundo = 8
3
4 si a > b :
5 imprimir ( ”aismayor que b” )
6
7 si b > a :
8 print ( ”bismayor que a” )
9
10 si a == b :
11 print ( ”aisequ al tob” )
Listado 5.1: Uso de arreglos en Python
54
Intente cambiar los valores de a y b.
Usando If Else:
1 un = 5 2
segundo = 8
3
4 si a > b :
5 imprimir ( ”aismayor que b” )
6 más :
7 print ( ”bismayor que aora y bareequ al ” )
Usando Elif:
1 un = 5 2
segundo = 8
3
4 si a > b :
5 print ( ”aesmayor que b” ) 6 elif b > a :
print ( ”bismayor
7 que a” ) 8 elif a == b :
9 imprimir ( ”aisequ al tob” )

¡Nota! Python usa "elif" y no "elseif" como lo hacen muchos otros lenguajes de
programación.
[Fin del ejemplo]
5.2 Matrices
Una matriz es una variable especial que puede contener más de un valor a la vez.
Aquí hay algunos ejemplos de cómo puede crear y usar matrices en Python:
1 dato = [ 1 . 6 , 3.4 , 5.5 , 94]

2
3 N = longitud (datos)
4
5 imprimir (N)
6
7 imprimir (datos [2])

8
9 datos [ 2 ] = 7. 3
10
11 imprimir ( datos [ 2 ] )
12
13
14 para x en datos:
15 imprimir (x)
55
dieciséis
17
18 datos. agregar ( 1 1 . 4 )
19
20
22
23 impresión (N)
24
25
26 para x en datos:
27
imprimir (x)
Usted define una matriz como esta:
1 dato = [ 1 . 6 , 3.4 , 5.5 , 94]
También puedes usar texto como este:

” Te sl a ”
1 carlista = [ ”Volvo” , , "Ford" ]
Puede usar matrices en bucles como este:

1 para x en datos:
2 imprimir (x)
Puede devolver la cantidad de elementos en la matriz de esta manera:
Puede obtener un valor específico dentro de la matriz de esta manera:

1 índice x = 2 2 x =
coches [ índice x ]
Puede usar el método append() para agregar un elemento a una matriz:

1 datos agregar ( 1 1 . 4 )
[Fin del ejemplo]
Tiene muchos métodos integrados que puede usar en combinación con matrices, como sort(), clear(),
copy(), count(), insert(), remove(), etc.
Deberías probar todos estos métodos.
56
5.3 Bucles For

Un bucle For se usa para iterar sobre una secuencia. Supongo que todos sus programas usarán uno
o más bucles For. Entonces, si no ha usado bucles For antes, asegúrese de aprenderlo ahora.
A continuación, verá un ejemplo básico de cómo puede usar un bucle For en Python:
1 para i inr an ge ( 1 print , 10):

2 (i)
El bucle For es probablemente una de las funciones más útiles de Python (o de cualquier tipo de
lenguaje de programación). A continuación, verá diferentes ejemplos de cómo puede usar un bucle
For en Python.
1 dato = [ 1 . 6 , 3.4 , 5.5 , 94]

2
3 para x en datos:
4 imprimir (x)
5
6
” Te sl a ”
7 carlista = [ ”Volvo” , , "Ford" ]
8
9 para coche en carlista:

10 imprimir (coche)
Listado 5.5: Uso de bucles For en Python
La función range() es útil para usar en For Loops:
1 norte = 10
3 para el rango de x (N) : print

4 (x)
La función range() devuelve una secuencia de números, comenzando desde 0 de forma predeterminada,
se incrementa en 1 (de forma predeterminada) y termina en un número específico.
También puede usar la función range() de esta manera:

1 inicio = 4 2
parada = 12 #pero sin incluir
3
4 para el rango de x ( impresión , detener ) :

5 inicial (x)
Finalmente, también puede usar la función range() de esta manera:

1 inicio = 4 2
parada = 12 #pero sin incluir 3 pasos = 2
5 para el rango de x ( impresión detener paso ) :

6 inicial (x)
57
Debería probar todos estos ejemplos para aprender la estructura básica de un bucle For.
[Fin del ejemplo]
Ejemplo 5.3.2. Uso de bucles for para la suma de datos
Por lo general, desea usar un bucle For para encontrar la suma de un conjunto de datos dado.
1 dato = [ 1 , 5, 6, 3, 12, 3]
2
3 suma = 0
4
5 #Encontrar la suma de todos los números 6 para x

en datos: 7 suma =
suma + x
8
9 imprimir ( suma)
10
11 #Encuentra la Media o Promedio de todos los números

12
14
15 media = suma/N
dieciséis
17 imprimir (media)
Esto da los siguientes resultados:
1 30
2 5. 0
[Fin del ejemplo]
Ejemplo 5.3.3. Implementando números de Fibonacci usando un ciclo For en Python
Los números de Fibonacci se utilizan en el análisis de los mercados financieros, en estrategias como
el retroceso de Fibonacci, y se utilizan en algoritmos informáticos como la técnica de búsqueda de
Fibonacci y la estructura de datos del montón de Fibonacci.
También aparecen en entornos biológicos, como la ramificación de los árboles, la disposición de las
hojas en un tallo, los frutos de una piña, la floración de la alcachofa, un helecho que se despliega y
la disposición de una piña.
En matemáticas, los números de Fibonacci son los números en la siguiente secuencia: 0, 1, 1, 2, 3,

5, 8, 13, 21, 34, 55, 89, 144, . . .
Por definición, los dos primeros números de Fibonacci son 0 y 1, y cada número subsiguiente es la
suma de los dos anteriores.
Algunas fuentes omiten el 0 inicial y, en cambio, comienzan la secuencia con dos 1.
58
En términos matemáticos, la secuencia Fn de los números de Fibonacci está definida por la

relación de recurrencia
fn = fn−1 + fn−2 (5.1)
con valores semilla:
f0 = 0, f1 = 1
Escribiremos un script de Python que calcule los N primeros números de Fibonacci.

El script de Python se vuelve así:
1 norte = 10
3 mentira 1 = 0 4
mentira 2 = 1
6 impresión (fib 1)
7 impresión (fib 2)
8
9 para k inr an ge (N−2) : fibnext

10 = fib 2 +fib 1 fib 1 = fib 2 fib 2
11 = fibnext
12
13 imprimir (fibnext)
Listado 5.6: Números de Fibonacci usando un ciclo For en Python
Solución alternativa:
1 norte = 10
3 fib = [ 0 , 1]
4
6 para k inr an ge (N−2) : fibnext

7 = fib [ k+1] + fib [ k ] fib . agregar (fibnext)
8
10 imprimir (falta)
Listado 5.7: Números de Fibonacci usando un ciclo For en Python Alt2
Otra solución alternativa:

1 norte = 10
3 mentira = [ ]
4
5 para parentesco (N) : fib .

6 agregar (0)
7
8 mentiras [ 0 ] = 0 9 mentiras
[1]=1
10
59
11 para k inr an ge (N−2) : fib

12 [ k+2] = fib [ k+1] + fib [ k ]
13
14
15 letra (falta)
Otra solución alternativa:

2
4 norte = 10
6 fib = np. ceros (N)

7
8 mentiras [ 0 ] = 0 9 mentiras
[1]=1
10
11 para k inr an ge (N−2) : fib

12 [ k+2] = fib [ k+1] + fib [ k ]
13
14
15 letra (falta)
[Fin del ejemplo]
5.3.1 Bucles For anidados

En Python y otros lenguajes de programación, puede usar un bucle dentro de otro bucle.
Sintaxis para bucles For anidados en Python:

1 para iterarvar en secuencia:
2 para iterar var en secuencia : sentencias ( s )
3 sentencias ( s )
4
Ejemplo sencillo:
1 para el rango i ( 1 1 0 ) : para
, el
2 rango k ( 1 1 0 ) : print ( ik, )
3 ,
Ejercicio 5.3.1. Números primos
Los primeros 25 números primos (todos los números primos menores que 100)
son: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89,
97
60
Por definición, un número primo tiene tanto al 1 como a sí mismo como divisor. Si tiene
cualquier otro divisor, no puede ser primo.
Un número natural (1, 2, 3, 4, 5, 6, etc.) se llama número primo (o primo) si es mayor que 1 y
no se puede escribir como producto de dos números naturales que son ambos más pequeños.
que eso.
Cree un script de Python donde encuentre todos los números primos entre 1 y 200.
¡Consejo! Supongo que esto se puede hacer de muchas maneras diferentes, pero una forma es usar
2 For Loops anidados.
[Fin del ejercicio]
5.4 Ciclos while

El bucle while repite un grupo de sentencias un número indefinido de veces bajo el control de
una condición lógica.
Ejemplo 5.4.1. Uso de bucles while en Python
1 metro = 8
2
3 mientras que m >
4 2 : imprime
5 (m) m = m − 1
Listado 5.10: Uso de bucles while en Python
[Fin del ejemplo]
5.5 Ejercicios
A continuación encontrará diferentes ejercicios a su propio ritmo que debe realizar y resolver
por su cuenta. ¡La única forma de aprender Python es hacer muchos ejercicios!
Ejercicio 5.5.1. Gráfico del sistema dinámico
Dado el sistema autónomo:

x˙ = hacha (5.2)
Dónde:
1
un =
T
61
donde T es la constante de tiempo.
La solución de la ecuación diferencial es:
x(t) = e atx0 (5.3)
Establecer T=5 y la condición inicial x(0)=1.
Crea un Script en Python (archivo .py) donde trazas la solución x(t) en el intervalo de tiempo:
0 ≤ t ≤ 25
Agregue la cuadrícula y las etiquetas de título y eje adecuadas a la trama.
[Fin del ejercicio]
62
Capítulo 6
Creación de funciones en
Pitón
6.1 Introducción
Una función es un bloque de código que solo se ejecuta cuando se le llama. Puede pasar
datos, conocidos como parámetros, a una función. Una función puede devolver datos como
resultado.
Anteriormente, hemos estado usando muchas de las funciones integradas en Python
Si está familiarizado con uno o más lenguajes de programación, la creación y el uso de

funciones debería resultarle familiar y conocido. Todos los lenguajes de programación tienen
la posibilidad de crear funciones, pero la sintaxis es ligeramente diferente de un lenguaje a otro.
Algunos lenguajes de programación usan el término Método en lugar de Función.

Las Funciones y los Métodos se comportan de la misma manera, pero se podría decir que los
Métodos son funciones que pertenecen a una Clase. Aprenderemos más sobre las Clases en
el Capítulo 7.
Scripts vs Funciones
Es importante saber la diferencia entre un Script y una Función.
Guiones:
• Una colección de comandos que ejecutarías en el Editor
• Se utiliza para automatizar tareas repetitivas
Funciones:
• Operar sobre la información (entradas) que se les alimenta y devolver salidas
• Tener un espacio de trabajo separado y variables internas que solo son válidas dentro
la función
63
• Sus propias funciones definidas por el usuario funcionan de la misma manera que las funciones
integradas que usa todo el tiempo, como plot(), rand(), mean(), std(), etc.
Python tiene muchas funciones integradas, pero muy a menudo necesitamos crear nuestras propias
funciones (podríamos referirnos a estas funciones como funciones definidas por el usuario)
En Python, una función se define usando la palabra clave def:
1 def Nombre de función:

2 <afirmación −1>
3 .
4 .
5 <sentencia−N>
6 volver _ . .
Ejemplo 6.1.1. Crear una función en un archivo separado
A continuación, verá una función simple creada en Python:
1 def suma ( x , y ) :
2
3 volver x + y
Listado 6.1: Función básica de Python
La función suma 2 números. El nombre de la función es agregar y devuelve la respuesta mediante la

declaración de retorno.
La instrucción return [expresión] sale de una función y, opcionalmente, devuelve una expresión a la
persona que llama. Una declaración de devolución sin argumentos es lo mismo que devolver Ninguno.
Tenga en cuenta que debe usar dos puntos ":" al final de la línea donde define la función.
Tenga en cuenta también la sangría utilizada.
Aquí ves un script de Python donde usamos la función:
2
3 volver x + y
4
6x=27y=5
9 z = sumar ( x , y )
10
11 imprimir (z)
Listado 6.2: Creación y uso de una función de Python
64
[Fin del ejemplo]
Ejemplo 6.1.2. Crear una función en un archivo separado
Comenzamos creando un archivo Python separado (myfunctions.py) para la función:
1 def promedio ( x , y ) :
2
3
retorno ( x + y ) /2
Listado 6.3: Función que calcula el promedio
A continuación, creamos un nuevo archivo de Python (p. ej., testaverage.py) donde usamos
la función que creamos:
1 del promedio de importación de mis funciones

2
3 un = 2 4
segundo = 3
6 c = promedio (a ,b )
7
8 imprimir ( c )
Listado 6.4: Prueba de la función promedio
[Fin del ejemplo]
6.2 Funciones con múltiples valores de retorno

Por lo general, queremos devolver más de un valor de una función.
Ejemplo 6.2.1. Crear una función Función con múltiples valores de retorno
Crea el siguiente ejemplo:
1 estadística de definición (x):

2
3 suma total = 0
4
5 #Encuentre la suma de todos los números para

6 x en los datos: suma
7 total = suma total + x
8
10 #Encuentra la Media o Promedio de todos los números

11
13
14 media = suma total /N

15
dieciséis
17 devolver la suma total , significar
18
19
20
sesenta y cinco
21 datos = [ 1 , 5 , 6 , 3 , 12 , 3]
22
23
24 suma total , media = estadística (datos)

25
26 imprimir ( suma total , significar )
Listado 6.5: Función con múltiples valores de retorno
[Fin del ejemplo]
6.3 Ejercicios
A continuación encontrará diferentes ejercicios a su propio ritmo que debe realizar y

resolver por su cuenta. ¡La única forma de aprender Python es hacer muchos ejercicios!
Ejercicio 6.3.1. Crear función de Python
Crea una función calpromedio que encuentre el promedio de dos números.
[Fin del ejercicio]
Ejercicio 6.3.2. Cree funciones de Python para convertir entre radianes y grados
Dado que la mayoría de las funciones trigonométricas requieren que el ángulo se exprese
en radianes, crearemos nuestras propias funciones para convertir entre radianes y grados.
Es bastante fácil convertir de radianes a grados o de grados a radianes.
Tenemos eso:
2π[radianes] = 360[grados] (6.1)
Esto da:
180
d[grados] = r[radianes] × ( ) (6.2)
π
y
π
r[radianes] = d[grados] × ( ) 180 (6.3)
Cree dos funciones que conviertan de radianes a grados (r2d(x)) y de grados a radianes
(d2r(x)) respectivamente.
Estas funciones deben guardarse en un archivo de Python .py.
Pruebe las funciones para asegurarse de que funcionan como se esperaba.
66
[Fin del ejercicio]
Ejercicio 6.3.3. Crear una función que implemente números de Fibonacci
Los números de Fibonacci se utilizan en el análisis de los mercados financieros, en estrategias como
el retroceso de Fibonacci, y se utilizan en algoritmos informáticos como la técnica de búsqueda de
Fibonacci y la estructura de datos del montón de Fibonacci.
También aparecen en entornos biológicos, como la ramificación de los árboles, la disposición de las
hojas en un tallo, los frutos de una piña, la floración de la alcachofa, un helecho que se despliega y
la disposición de una piña.
En matemáticas, los números de Fibonacci son los números en la siguiente secuencia: 0, 1, 1, 2, 3,

5, 8, 13, 21, 34, 55, 89, 144, . . .
Por definición, los dos primeros números de Fibonacci son 0 y 1, y cada número subsiguiente es la
suma de los dos anteriores.
Algunas fuentes omiten el 0 inicial y, en cambio, comienzan la secuencia con dos 1.
En términos matemáticos, la secuencia Fn de los números de Fibonacci está definida por la relación
de recurrencia
fn = fn−1 + fn−2 (6.4)
con valores semilla:
f0 = 0, f1 = 1
Crear una función que implemente los N primeros números de Fibonacci
[Fin del ejercicio]
Ejercicio 6.3.4. Números primos
Los primeros 25 números primos (todos los números primos menores que 100) son: 2, 3,
5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97
Por definición, un número primo tiene tanto al 1 como a sí mismo como divisor. Si tiene cualquier
otro divisor, no puede ser primo.
Un número natural (1, 2, 3, 4, 5, 6, etc.) se llama número primo (o primo) si es mayor que 1 y no se
puede escribir como producto de dos números naturales que son ambos más pequeños. que eso.
¡Consejo! Supongo que esto se puede implementar de muchas maneras diferentes, pero una forma
es usar 2 For Loops anidados.
67
Cree una función de Python donde verifique si un número dado es un número primo o no.
Puede verificar la función en la ventana de comandos de esta manera:

1 número = 4 2
chec ki fp rim e ( número )
Entonces Python responde con Verdadero o Falso.
[Fin del ejercicio]
68
Capítulo 7
Crear clases en Python
7.1 Introducción
Python es un lenguaje de programación orientada a objetos (POO). Casi todo en Python es
un objeto, con sus propiedades y métodos.
La base de todos los lenguajes de programación orientada a objetos (POO) son las clases.
Para crear una clase, use la palabra clave class:
1 clase ClassName:
2 <sentencia −1>
3 .
4 .
5 .
6 <sentencia−N>
Ejemplo 7.1.1. Ejemplo de clase simple
Crearemos una clase simple en Python.
Coche de 1 clase :
2 modelo = ”Volvo”
3 color = ”Azul”
4
6 coche = coche ( )
7
9 letras (coche. modelo)

10 letras (coche. color)
Listado 7.1: Clase de Python simple
Los resultados serán en este caso:
1 volvo
2 azul
69
Este ejemplo no ilustra las cosas buenas con las clases, por lo que crearemos algunos
ejemplos más.
[Fin del ejemplo]
Ejemplo 7.1.2. Clase de pitón
Vamos a crear el siguiente código de Python:

Coche de 1 clase :
2 modelo = ””
color = ””
3
5 coche = coche ( )
6
7 coche. modelo = coche
”Volvo” 8 . color = ”Azul”
9
””
10 estampados ( coche . color + + coche modelo )
11
12 coche. modelo = coche
”Ford” 13 . color = ”Verde”
14
””
15 estampados ( coche . color + + coche modelo )
Listado 7.2: Ejemplo de clase de Python
Deberías probar estos ejemplos.
[Fin del ejemplo]
7.2 La función init ()

En Python, todas las clases tienen una función integrada llamada init (), que siempre se
ejecuta cuando se inicia la clase.
En muchos otros lenguajes OOP lo llamamos Constructor.
Ejercicio 7.2.1. La función init ()
Crearemos un ejemplo simple donde usamos la función init () para ilustrar el principio.
Cambiamos nuestro ejemplo de coche anterior así:

Coche de 1 clase :
2 de f inicial , self . , color ) :
(self model
3 model = model self . color
4 = color
5
6 coche 1 = Coche ( ”Ford” , ”Verde” )

7
8 impresión (coche 1. modelo)

9 impresión (coche 1. color)
10
11
70
12 coche 2 = Coche ( ”Volvo” , ”Azul” )

13
14 impresiones (coche 2. modelo)

15 impresiones (coche 2. color)
Listado 7.3: Ejemplo de constructor de clases de Python
Extiendamos la Clase definiendo una Función también:

1 # D e fi nición de la Clase Coche 2
clase Coche : de f
3 init (auto modelo auto
, . , color ) :
4 modelo = modelo auto .
5 color = color
6
7 def di s p a yC ar (self): print

8 (self. model) print (self.
9 color)
10
11
12 # Comencemos la clase
13
”
14 coche 1 = coche ( ” tesla , ”Rojo” )
15
16 coche 1 . disp l a yC ar ( )
17
18

20

23
24

26

29
30 coche 3 . color =”Negro”

31
Listado 7.4: Clase de Python con función
Como puede ver en el código, ahora hemos definido una Clase "Coche" que tiene 2 variables
de Clase llamadas "modelo" y "color", y además hemos definido una Función (o Método)
llamada "displayCar()".
Es normal usar el término "Método" para funciones que se definen dentro de una clase.
Los métodos de clase se declaran como funciones normales con la excepción de que el
primer argumento de cada método es self.
Para crear instancias de una clase, llame a la clase usando el nombre de la clase y pase
cualquier argumento que acepte su método init ().
Por ejemplo:
71
1 coche 1 = Coche ( ” tesla

”
, ”Rojo” )
[Fin del ejemplo]
Ejercicio 7.2.2. Cree la clase en un archivo de Python separado
Empezamos creando la Clase y luego guardamos el código en ”Car.py”:
1 # D e fi nición de la Clase Coche 2

clase Coche : def
3 modelo auto
(selfinit ,
. modelo = , color ) :
4 modelo auto . color = color
5
7 def di s p a yC ar (self): print

8 (self. model) print (self.
9 color)
Listado 7.5: Defina la clase de Python en un archivo separado
Luego creamos un Script de Python (testCar.py) donde estamos usando la Clase:
1 # Importación del Auto Clase 2 desde

Car import Car
3
4 # Comencemos la clase
5
”
6 coche 1 = coche ( ” tesla , ”Rojo” )
7
9
10

12

15
dieciséis

18

21
22 coche 3 . color =”Negro”
23
Listado 7.6: Script que está usando la Clase
Observe la siguiente línea en la parte superior:
1 de Auto importación Auto
[idioma=Python]
[Fin del ejemplo]
72
7.3 Ejercicios

Ejercicio 7.3.1. Crear clase de Python
Cree una clase de Python donde calcule los grados en Fahrenheit en función de la
temperatura en Celsius y viceversa.
La fórmula para convertir de Celsius a Fahrenheit es:
Tf = (Tc × 9/5) + 32 (7.1)

La fórmula para convertir de Fahrenheit a Celsius es:
Tc = (Tf − 32) × (5/9) (7.2)
[Fin del ejercicio]
73
Capítulo 8
Creación de módulos de Python
A medida que su programa se hace más largo, es posible que desee dividirlo en varios
archivos para facilitar el mantenimiento. También puede querer usar una función útil que haya
escrito en varios programas sin copiar su definición en cada programa.
Para respaldar esto, Python tiene una forma de colocar definiciones en un archivo y usarlas
en un script o en una instancia interactiva del intérprete (la ventana de la Consola de Python).
8.1 Módulos de Python

Un módulo es un archivo que contiene definiciones y declaraciones de Python. El nombre del
archivo es el nombre del módulo con el sufijo .py adjunto.
Python le permite dividir su programa en módulos que pueden reutilizarse en otros programas
de Python. Viene con una gran colección de módulos estándar que puede usar como base de
sus programas como hemos visto ejemplos en capítulos anteriores. No es el momento de
hacer tus propios módulos desde cero.
Considere que un módulo es lo mismo que una biblioteca de código. Un archivo que contiene
un conjunto de funciones que desea incluir en su aplicación.
Anteriormente, ha estado utilizando diferentes módulos, bibliotecas o paquetes creados por la

organización de Python o por otros. Aquí crearás tus propios módulos desde cero.
Ejemplo 8.1.1. Crea tu primer módulo de Python
Crearemos un módulo Python con 2 funciones. La primera función debe convertir de Celsius
a Fahrenheit y la otra función debe convertir de Fahrenheit a Celsius.
Tf = (Tc × 9/5) + 32 (8.1)
74
Tc = (Tf − 32) × (5/9) (8.2)
Primero, creamos un módulo de Python con las siguientes funciones (fahrenheit.py):

1 def c 2 f (Tc ) :
2
3 Tf = (Tc 9 / 5 ) + 32 vuelta
4 Tf
5
7 def f 2 c ( Vf ) :
8
9 Tc = ( Tf − 3 2 ) (5/9)
10 regresa Tc
Listado 8.1: Funciones Fahrenheit
Luego, creamos un script de Python para probar las funciones (testfahrenheit.py):

1 de farenheit importar c 2 f f2c
2
,
3 Tc = 0
5 Tf = c 2 f (Tc )
6
7 letra ( ”F ahrenh ei t : ” + str ( Tf ) )

8
10 Tf = 32
11
12 Tc = f 2 c ( Tf )
13
14 imprime ( ” C elsius : ” + cadena (Tc ) )
Listado 8.2: Python Script probando las funciones
Los resultados se convierten en:
1 Fahrenheit : 3 2. 0
2 C elsius : 0. 0
8.2 Ejercicios

Ejercicio 8.2.1. Crear módulo de Python para convertir entre radianes y grados
Dado que la mayoría de las funciones trigonométricas requieren que el ángulo se exprese
en radianes, crearemos nuestras propias funciones para convertir entre radianes
75
y grados.

Tenemos eso:

Esto da:
180 d[grados] = r[radianes] × (π) (8.4)

y
π
Cree dos funciones que conviertan de radianes a grados (r2d(x)) y de grados a

radianes (d2r(x)) respectivamente.
Pruebe las funciones para asegurarse de que funcionan como se esperaba. Puede optar
por crear un nuevo archivo .py para probar estas funciones o puede usar la ventana Consola.
[Fin del ejercicio]
76
Capítulo 9
Manejo de archivos en Python
9.1 Introducción
Python tiene varias funciones para crear, leer, actualizar y eliminar archivos.
La función clave para trabajar con archivos en Python es la función open().
La función open() toma dos parámetros; Nombre de archivo y Modo.
Hay cuatro métodos (modos) diferentes para abrir un archivo:
• ”x” Crear Crea el archivo especificado, devuelve un error si el archivo existe
• ”w” Escribir Abre un archivo para escritura, crea el archivo si no existe
• ”r” Lectura Valor por defecto. Abre un archivo para lectura, error si el archivo lo hace
no existe
• ”a” Agregar: abre un archivo para agregar, crea el archivo si no lo hace

existir
Además, puede especificar si el archivo debe manejarse como modo binario o de texto.
• ”t” Texto Valor por defecto. Modo de texto
• ”b” Binario Modo binario (por ejemplo, imágenes)
9.2 Escribir datos en un archivo

Para crear un nuevo archivo en Python, use el método open(), con uno de los siguientes parámetros:
• ”x” Crear Crea el archivo especificado, devuelve un error si el archivo existe

existir
77
Para escribir en un archivo existente, debe agregar un parámetro a la función open():

existir
Ejemplo 9.2.1. Escribir datos en un archivo
”
1 f = abrir ( ” mi archivo . txt , "x" )
2
3 datos = ”Mundo Helo”

4
5f . escribir (datos)
6
7f . cerca ( )
Listado 9.1: Escribir datos en un archivo
[Fin del ejemplo]
9.3 Leer datos de un archivo

Para leer un archivo existente, debe agregar el siguiente parámetro a la función open():
• ”r” Lectura Valor por defecto. Abre un archivo para lectura, error si el archivo lo hace
no existe
Ejemplo 9.3.1. Leer datos de un archivo
” ”r
1 f = abrir ( ” mi archivo . txt , ”)
2
3 datos = f . leer ( )
4
5 imprimir (datos)
6
7f . cerca ( )
Listado 9.2: Leer datos de un archivo
[Fin del ejemplo]
9.4 Registro de datos en un archivo

Por lo general, desea escribir varios datos en, por ejemplo, suponga que lee algunos datos de
temperatura a intervalos regulares y luego desea guardar los valores de temperatura en un archivo.
Ejemplo 9.4.1. Registro de datos en un archivo
78
1 dato = [ 1 . 6
, 3.4 , 5.5 , 94]
2
”
3 f = abrir ( ” mi archivo . txt
, "x" )
4
5 para el valor de los datos:

6
7
registro = str ( valor ) f .
8
escribir ( registrar )
9
f . escribir ( ”\n” )
10 f. cerca ( )
Listado 9.3: Registro de datos en un archivo
[Fin del ejemplo]
Ejemplo 9.4.2. Leer datos registrados del archivo
” , ” r
1 f = abrir ( ” mi archivo . txt
2
”)
3 para registro en f :
4
5
registro = registro. reemplazar ( ”\n” , ”” )
6
imprimir (registro)
7f . cerca ( )
Listado 9.4: Leer datos registrados desde un archivo
[Fin del ejemplo]
9.5 Recursos web
A continuación encontrará diferentes recursos útiles para el manejo de archivos.
Manejo de archivos Python w3school: https://

www.w3schools.com/python/pythonf ilehandling.asp
Leer y escribir archivos python.org: https://

docs.python.org/3/tutorial/inputoutput.htmlreadingandwritingfiles
9.6 Ejercicios
A continuación encontrará diferentes ejercicios a su propio ritmo que debe realizar y resolver por su cuenta.
¡La única forma de aprender Python es hacer muchos ejercicios!
Ejercicio 9.6.1. Registro de datos
Suponga que tiene los siguientes datos que desea registrar en un archivo como se muestra en la Tabla 9.1.
Registre estos datos en un archivo.
Cree otro script de Python que lea los mismos datos.
79
[Fin del ejercicio]
Ejercicio 9.6.2. Registro de datos 2
Suponga que lee datos de un sensor de temperatura cada 10 segundos durante un período
de, digamos, 5 minutos.
Registre los datos en un archivo.
Puedes usar el generador aleatorio en Python. A continuación se muestra un ejemplo de cómo

usar el generador aleatorio:
1 import random 2 for x

inr an ge ( 1 0 ) : data = random .
3 corrió di nt ( 1 impresión (datos) ,3 1 )
4
Listado 9.5: Leer datos de un archivo
Asegúrese de registrar tanto el tiempo como el valor de la temperatura
Cree otro script de Python que lea los mismos datos.
También debe trazar los datos que lee del Archivo.
[Fin del ejercicio]
80
Tabla 9.1: Datos registrados

Valor de tiempo 1
22 2 25 3 28
... ...
81
Capítulo 10
Manejo de errores en Python
10.1 Introducción al manejo de errores

Hasta ahora no se han discutido los mensajes de error. Se podría decir que tenemos 2 tipos
de errores: errores de sintaxis y excepciones.
10.1.1 Errores de sintaxis

A continuación vemos un ejemplo de errores de sintaxis:
1 >>> print ( H el mundo )

2 Archivo ”<ipython−input −1−10cb182148e3>” print (H ell o , línea 1
3
4
World) ˆ
5 Error de sintaxis:
sintaxis inválida
En el ejemplo, hemos escrito print(Hello World) en lugar de print(”Hello World”) y luego el

intérprete de Python nos da un mensaje de error.
10.1.2 Excepciones
Incluso si una declaración o expresión es sintácticamente correcta, puede causar un error
cuando se intenta ejecutarla. Los errores detectados durante la ejecución se denominan
excepciones y no son incondicionalmente fatales: pronto aprenderá a manejarlos en los
programas de Python. Sin embargo, la mayoría de las excepciones no son manejadas por
programas y dan como resultado mensajes de error como se muestra aquí:
1 >>> 10 (1/0)
2 Seguimiento (última llamada más reciente):
3
4
5
Archivo ”<ipython−input −2−0b280 f36835c>” 10 ( 1 / 0 ) , línea 1 , en <módulo>
6
7 Z ero Di vi si on E rror : división por cero
o:
1 >>> '2 '

+2
2 Seguimiento (última llamada más reciente):
3
82
4 Archivo ”<ipython−input −3−d2b23a1db757>” + 2 , linea 1 , en <módulo>

5
'2 '
6
7 TypeError: debe ser str , no ent
10.2 Manejo de excepciones

Es posible escribir programas que manejen excepciones seleccionadas.
En Python podemos usar las siguientes funciones integradas de manejo de excepciones:
• El bloque de prueba le permite probar un bloque de código en busca de errores.
• El bloque excepto le permite manejar el error.
• El bloque finalmente le permite ejecutar código, independientemente del resultado del intento.
y excepto bloques.
Cuando ocurre un error, o una excepción como lo llamamos, Python normalmente se detendrá y
generará un mensaje de error.
Estas excepciones se pueden manejar usando las sentencias try except.
Algún ejemplo básico:
1
2 intento : 10 (1/
0)3
4 excepto : imprimir ( ”El cálculo falló ” )
o:
1
2 intento :
imprimir (x)
4 3 excepto : imprimir ( ”x no está defi nido” )
También puede utilizar varias excepciones:
1
2 intento :
imprimir (x) 3 excepto
4 NameError: imprimir ( "x no está
definido" ) 5
6 excepto : imprimir ( "Algo está mal" )
El bloque finalmente, si se especifica, se ejecutará independientemente de si el bloque de prueba

genera un error o no.
Ejemplo:
83
1x=2
3
4 intente :
imprimir (x) 5 excepto
6 NameError: imprimir ( "x no está
definido" )
8 7 excepto : imprimir ( "Algo está
mal" ) 9
10 finalmente : imprimir ( "El programa ha terminado" )
En general, debe usar probar, excepto, finalmente cuando intente abrir un archivo, leer o
escribir archivos, conectarse a una base de datos, etc.
Ejemplo:
1
2 intento : f = abrir archivo
( ” ” ) mi.
3 txtf . w ri te ( ”Lorum Ipsum” )
4 excepto :
5 print ( ”Algo salió mal al escribir en el archivo ” ) 6 finalmente : f . cerca ( )
84
Capítulo 11
Depuración en Python
La depuración es el proceso de encontrar y resolver defectos o problemas dentro de un programa

de computadora que impiden el correcto funcionamiento del software o de un sistema [14].
Los depuradores son herramientas de software que permiten al programador monitorear la

ejecución de un programa, detenerlo, reiniciarlo, establecer puntos de interrupción y cambiar
valores en la memoria. El término depurador también puede referirse a la persona que realiza la
depuración.
Como programador, una de las primeras cosas que necesita para desarrollar un programa serio
es un depurador.
Python tiene un depurador incorporado que se puede usar si está codificando Python con un
editor de texto básico y ejecutando sus programas de Python desde la línea de comandos.
Una mejor opción es utilizar las funciones de depuración integradas en su editor de Python. La
depuración generalmente se integra con el editor de Python que está utilizando.
Consulte el capítulo específico para los diferentes editores de Python.
85
Capítulo 12
Instalación y uso de Python

Paquetes
Un paquete contiene todos los archivos que necesita para un módulo. Los módulos son bibliotecas
de código de Python que puede incluir en su proyecto.
Dado que Python es de código abierto, puede encontrar miles de paquetes de Python que puede
instalar y usar en sus programas de Python.
Puede usar una distribución de Python como la distribución de Anaconda (o distribuciones de Python
similares) para descargar e instalar muchos paquetes de Python comunes como se mencionó
anteriormente.
12.1 ¿Qué es PIP?
PIP es un administrador de paquetes para paquetes de Python, o módulos si lo desea. PIP es una
herramienta para instalar paquetes de Python.
Si no tiene PIP instalado, puede descargarlo e instalarlo desde esta página: https://pypi.org/project/
pip/
PIP generalmente se usa desde el Símbolo del sistema (Windows) o la ventana Terminal (macOS).
Instalación de paquetes de Python:
Nombre del paquete de instalación de 1 pip
Desinstalación de paquetes de Python:

Nombre del paquete de desinstalación de 1 pip
Algunos editores de Python también tienen una forma gráfica de instalar paquetes de Python, como,
por ejemplo, Visual Studio.
86
Parte III
Entornos Python y
Distribuciones
87
Capítulo 13
Introducción a Python
Ambientes y
Distribuciones
Python viene con muchos sabores y versiones.
Python es de código abierto y todos pueden agrupar y distribuir Python y otros paquetes de Python.
Un entorno de Python es un contexto en el que ejecuta el código de Python e incluye paquetes de

Python.
Un entorno consta de un intérprete, una biblioteca (normalmente, la biblioteca estándar de Python)

y un conjunto de paquetes instalados.
Estos componentes juntos determinan qué construcciones de lenguaje y sintaxis son válidas, a qué
funcionalidad del sistema operativo puede acceder y qué paquetes puede usar.
Puede tener múltiples entornos de Python en su computadora.
Algunos de ellos son:
• Distribución de CPython disponible en python.org
• Anaconda
• Pabellón pensado
• WinPython
• etc.
Es fácil comenzar a usar Python instalando una de estas distribuciones de Python.
88
Pero también puede instalar el núcleo de Python desde:

Luego instale los paquetes de Python adicionales que necesita mediante PIP. https://
pypi.org/proyecto/pip/
13.1 Administradores de paquetes y entornos

Las dos herramientas más populares para instalar paquetes de Python y configurar
Los entornos de Python son:
• PIP: un administrador de paquetes de Python
• Conda: un administrador de paquetes y entornos (para Python y otras redes

calibres)
13.1.1 PIP
Web:
https://pypi.org
PIP generalmente se usa desde el Símbolo del sistema (Windows) o la ventana Terminal (macOS).
Instalación de paquetes de Python:
Nombre del paquete de instalación de 1 pip
Desinstalación de paquetes de Python:
Nombre del paquete de desinstalación de 1 pip
13.1.2 Conda
Conda es un sistema de administración de paquetes y un sistema de administración de entornos de
código abierto que se ejecuta en Windows, macOS y Linux. Conda instala, ejecuta y actualiza paquetes
y sus dependencias.
El administrador de paquetes y entornos de Conda está incluido en todas las versiones de Ana conda.
Conda fue creado para programas de Python, pero puede empaquetar y distribuir software para
cualquier idioma.
Conda también le permite crear entornos separados que contengan archivos, paquetes y sus
dependencias que no interactuarán con otros entornos.
89
Web:
https://conda.io/
Conda es parte o está integrado con Anaconda Python Distribution.
Web:
13.2 Entornos virtuales de Python

Los "entornos virtuales" de Python permiten que los paquetes de Python se instalen en
una ubicación aislada para una aplicación en particular, en lugar de instalarse
globalmente.
Puede tener múltiples entornos de Python en su computadora.
Los entornos virtuales de Python tienen sus propios directorios de instalación y no

comparten bibliotecas con otros entornos virtuales.
Python "Entornos virtuales" es útil cuando tiene diferentes aplicaciones de Python que
necesitan diferentes versiones de Python o diferentes versiones de los paquetes de
Python que está utilizando.
90
capitulo 14
Anaconda
Anaconda no es un editor, sino un paquete de distribución de Python. Spyder está

incluido en el paquete de distribución de Python. También puede usar Anaconda para
instalar otros editores o paquetes de Python.
Está disponible para Windows, macOS y Linux.
Web:
Wikipedia:
https://en.wikipedia.org/wiki/Anaconda(P ythondistribution)
14.1 Navegador Anaconda

Anaconda Navigator es una interfaz gráfica de usuario (GUI) de escritorio incluida en la
distribución de Anaconda que permite a los usuarios iniciar aplicaciones y administrar
paquetes de Python. Anaconda Navigator puede buscar paquetes e instalarlos en su
computadora, ejecutar los paquetes y actualizarlos.
La Figura 14.1 muestra el Navegador Anaconda.
91
Figura 14.1: Navegador Anaconda
92
Capítulo 15
Pabellón pensado
Enthought Canopy es una plataforma de Python o una distribución de Python para

científicos e ingenieros.
Está disponible para Windows, macOS y Linux.
Canopy está disponible gratuitamente para todos los usuarios bajo la licencia de Canopy.
Canopy brinda acceso a varios cientos de paquetes de Python, incluidos NumPy, SciPy,
Pandas, Matplotlib e IPython.
Además, tenemos el Canopy Python Editor.
Enthought Canopy es un competidor de Anaconda Python Distribution. Es cuestión de

gustos a quién prefieres.
Web:
https://www.enthought.com/product/canopy/
93
Parte IV
Editores de Python
94
capitulo 16
Editores de Python
Un Editor es un programa donde creas tu código (y donde puedes ejecutarlo y probarlo).

La mayoría de los editores también tienen funciones de depuración e IntelliSense.
En teoría, puede usar el Bloc de notas de Windows para crear programas de Python,
pero en la práctica es imposible crear programas sin tener un editor con Depuración,
IntelliSense, formato de color, etc.
Para programas simples de Python, puede usar IDLE Editor, pero para programas más
avanzados, se recomienda un mejor editor.
Ejemplos de editores de Python:
• Espía
• Código de estudio visual
• Estudio visual
• PyCharm
• Ala
• Cuaderno Jupyter
Daremos una descripción general de estos editores de código en los próximos capítulos.
Supongo que se pueden usar cientos de editores diferentes para la programación de

Python, ya sea fuera de la caja o si instala una extensión adicional que asegure que
puede usar Python en ese editor.
Si ya tiene un editor de código favorito, es un buen cambio que pueda usarlo para la
programación de Python.
El editor que debe usar depende de su experiencia, qué tipo de editores de código ha
usado anteriormente, sus habilidades de programación, lo que va a desarrollar en
Python, etc.
95
Si está familiarizado con MATLAB, se recomienda Spyder. Además, si desea utilizar

Python para cálculos y cálculos numéricos, Spyder es una buena opción.
Si desea crear aplicaciones web u otros tipos de aplicaciones, probablemente sea

mejor usar otros editores.
Para obtener una lista de los "mejores editores de Python", consulte [15].
96
capitulo 17
espía
Spyder: abreviatura de "Entorno de desarrollo científico de PYthon".
Spyder es un entorno de desarrollo integrado (IDE) multiplataforma de código abierto para la programación
científica en el lenguaje Python.
Figura 17.1: Editor Spyder
El editor de Spyder consta de las siguientes partes o ventanas:
• Ventana del editor de código
• Ventana de la consola de iPython
97
• Explorador de variables
• etc.
Web:
Si ha usado MATLAB anteriormente o quiere usar Python para uso científico, Spyder es una buena
opción. es fácil de instalar usando Anaconda Distribution.
Web:
98
capitulo 18
código de estudio visual
18.1 Introducción al código de Visual Studio
Visual Studio Code es un editor simple y fácil de usar que se puede usar para muchos
lenguajes de programación diferentes.
Figura 18.1: Uso de Visual Studio Code como editor de Python
Haga clic con el botón derecho y seleccione "Ejecutar archivo de Python en la terminal"
Web:
Wikipedia:
https://en.wikipedia.org/wiki/VisualStudioC ode
99
18.2 Python en código de Visual Studio

Además de Visual Studio Code, debe instalar la extensión de Python para Visual Studio
Code.
Debe instalar un intérprete de Python usted mismo por separado de la extensión.

Para una instalación rápida, use Python de python.org.
Python es un lenguaje interpretado, y para ejecutar el código de Python y obtener Python

IntelliSense dentro de Visual Studio Code, debe decirle a Visual Studio Code qué
intérprete usar.
Web:
https://code.visualstudio.com/docs/languages/python
100
capitulo 19
Estudio visual
19.1 Introducción a Visual Studio

Microsoft Visual Studio es un entorno de desarrollo integrado (IDE) de Microsoft. Se utiliza
para desarrollar programas informáticos, así como sitios web, aplicaciones web, servicios
web y aplicaciones móviles. El lenguaje de programación predeterminado (principal) en
Visual Studio es C, pero se admiten muchos otros lenguajes de programación.
Se podría decir que Visual Studio es el hermano mayor de Visual Studio Code.
Visual Studio (desde 2017), tiene soporte integrado para Python, se llama "Soporte de
Web:
Wikipedia:
Vaya a mi sitio web para obtener más información sobre Visual Studio y la programación
en C: https://www.halvorsen.blog/
Visual Studio y C: https://

www.halvorsen.blog/documents/programming/csharp/
19.2 Trabajar con Python en Visual Studio

Trabaje con Python en Visual Studio:
https://docs.microsoft.com/visualstudio/python/
101
Figura 19.1: Uso de Visual Studio como editor de Python
19.2.1 Prepare Visual Studio para la programación de Python
Visual Studio es principalmente para Windows. Existe una versión para MacOS de Visual
Studio, pero tiene muchas menos funciones que la edición de Windows.
Tenga en cuenta que la compatibilidad con Python solo está disponible en Visual Studio para
Windows. Si usa Mac y Linux, necesita usar Visual Studio Code. Se podría decir que Visual
Studio Code es una versión reducida de Visual Studio.
Visual Studio (desde 2017), tiene soporte integrado para Python, se llama "Soporte de Python
en Visual Studio". Incluso si está integrado, debe seleccionar manualmente qué componentes
desea instalar en su computadora. Asegúrese de descargar y ejecutar el último instalador de
Visual Studio 2017 para Windows.
cuando ejecuta el instalador de Visual Studio (ya sea por primera vez o si ya instaló Visual
Studio 2017 y desea modificarlo), aparece la ventana que se muestra en la Figura 19.2.
El instalador le presenta una lista de las denominadas cargas de trabajo, que son grupos de
opciones relacionadas para áreas de desarrollo específicas. Para Python, seleccione la carga
de trabajo "Desarrollo de Python" y seleccione Instalar (Figura 19.3).
19.2.2 Python interactivo

Para probar rápidamente la compatibilidad con Python, inicie Visual Studio, presione Alt+I (o
seleccione del menú: Herramientas Python Ventana interactiva de Python) para abrir la
ventana interactiva de Python. Consulte la Figura 19.4.
Escribamos algo como esto:

1 >>> un = 2
102
Figura 19.2: Instalación de la extensión de Python para Visual Studio
Figura 19.3: Carga de trabajo de desarrollo de Python
2 >>> segundo
= 5 3 >>> x = 3
4 >>> y = a x + segundo
5 >>> y
19.2.3 Nuevo proyecto de Python Veamos
cómo podemos crear una aplicación de Python.
Comience seleccionando del menú: Archivo Nuevo Proyecto... Aparecerá la ventana Nuevo
proyecto. Consulte la figura 19.5.
Podemos crear una aplicación ordinaria de Python (uno o más scripts de Python), podemos
optar por crear una aplicación web utilizando marcos web como Django o Flask, o podemos
crear diferentes aplicaciones de GUI de escritorio. También podemos crear Juegos.
Ejemplo 19.2.1. Aplicación Python Hello World en Visual Studio
103
Figura 19.4: Python interactivo
Comenzamos creando una aplicación básica de Python Hello World. Consulte la Figura 19.1.
Seleccione Archivo Nuevo Proyecto... Aparecerá la ventana Nuevo proyecto. Consulte la figura 19.5.
Asigne un nombre al proyecto, por ejemplo, "PythonApplication1".

En el Explorador de proyectos, abra el archivo "PythonApplication1.py" e ingrese el siguiente código de Python:
1 letra ( ” Hola Mundo” )
Presione F5 (nuestro clic en la flecha verde) para ejecutar o ejecutar el programa Python.
También puede hacer clic con el botón derecho en el archivo y seleccionar "Iniciar sin depurar".
[Fin del ejemplo]
Ejemplo 19.2.2. Trazado de Visual Studio Python
Cree un nuevo archivo de Python haciendo clic con el botón derecho en el Explorador de soluciones y seleccione
Agregar Nuevo elemento... y luego seleccione "Vaciar archivo de Python".
Ingrese el siguiente código de Python:

3
remen t = 0. 1
7

9
11
12 plt. parcela ( x , y )
13 plt . título ( ' y=sin ( x ) ' )
104
Figura 19.5: Nuevo Proyecto Python
14 plt. xlabel ( ' 15 plt . X ' )

ylabel ( ' 16 plt . grid ( ) y ' )
17 plt . eje ( [ 0 ,
2 np . pi , −1, 1 ] ) 18 plt . mostrar ( )

Asegúrese de seleccionar el entorno de Python adecuado. Ver Figura (19.7). Visual Studio
admite varios entornos de Python.
En este ejemplo, usamos el paquete Matplotlib para trazar, por lo que debemos tener ese
paquete instalado en la computadora. Puede instalar el paquete Matplotlib en diferentes
entornos de Python.
Instalé el paquete Matplotlib como parte de la configuración de la distribución de Anaconda,

así que seleccioné "Anaconda xxx" en la ventana Entornos de Python.
Si aún no ha instalado el paquete Matplotlib (ya sea como parte de Anaconda o manualmente
mediante PIP), también puede instalar fácilmente los paquetes de Python desde Visual
Studio. Consulte la Figura 19.8.
También puede ver fácilmente qué paquetes de Python están instalados para los diferentes
entornos de Python. Consulte la Figura 19.9.
105
Figura 19.6: Ejemplo de trazado de Python con Visual Studio
Lo bueno de usar Visual Studio es que tiene una interfaz gráfica de usuario para todo, no necesita
usar la ventana de comandos, etc. para instalar paquetes de Python, etc.
Presione F5 (nuestro clic en la flecha verde) para ejecutar o ejecutar el programa Python.
También puede hacer clic con el botón derecho en el archivo y seleccionar "Iniciar sin depurar".
Obtenemos los siguientes resultados, ver Figura 19.10.
[Fin del ejemplo]
106
Figura 19.7: Seleccione su entorno de Python
Figura 19.8: Instalar paquetes de Python desde Visual Studio
107
Figura 19.9: Instalación de paquetes de Python para diferentes entornos de Python

desde Visual Studio
Figura 19.10: Ejemplo de trazado de Python con Visual Studio
108
capitulo 20
PyCharm
PyCharm es multiplataforma, con versiones de Windows, macOS y Linux. La Community

Edition es de uso gratuito, mientras que la Professional Edition (versión de pago) tiene
algunas características adicionales.
El Editor PyCharm se muestra en la Figura 20.1.
Figura 20.1: Editor PyCharm Python
Web:
Wikipedia:
https://en.wikipedia.org/wiki/PyCharm
Anaconda y JetBrains también tienen una colaboración y ofrecen lo que llaman Py Charm
para Anaconda. Puedes descargarlo aquí:
109
https://www.jetbrains.com/pycharm/promo/anaconda/
Tenemos editores de código como Visual Studio y Visual Studio Code que se pueden
usar para muchos lenguajes de programación diferentes al instalar diferentes tipos de
complementos.
Los editores como Spyder y PyCharm son editores hechos a medida para Python lan
calibre
Spyder es un IDE liviano que generalmente se usa para uso científico. PyCharm, por otro
lado, es un IDE completo para el desarrollo de software en general mediante el uso del
lenguaje Python. Admite muchos complementos, es más fácil programar Django, etc.
110
capitulo 21
IDE de ala Python
La familia Wing Python IDE de entornos de desarrollo integrados (IDE) de Wingware se creó
específicamente para el lenguaje de programación Python.
Existen 3 versiones diferentes de Wing [12]:
• Wing 101: una versión gratuita muy simplificada, para enseñar a profesionales principiantes
gramáticos
• Wing Personal: versión gratuita que omite algunas funciones, para estudiantes y
aficionados
• Wing Pro: una versión comercial (de pago) con todas las funciones, para profesionales
programadores
Figura 21.1: IDE de Wing Python
Web:
https://wingware.com
111
Wikipedia:
https://en.wikipedia.org/wiki/WingIDE
112
capitulo 22
Cuaderno Jupyter
Jupyter Notebook es una aplicación web de código abierto que le permite crear y
compartir documentos que contienen código en vivo, ecuaciones, visualizaciones y
texto.
Notebook es compatible con más de 40 lenguajes de programación, incluido Python.
Figura 22.1: Cuaderno Jupyter [16]
Web:
http://jupyter.org
Wikipedia:
https://en.wikipedia.org/wiki/ProjectJupyter
113
22.1 JupyterHub
JupyterHub es una versión multiusuario del portátil diseñada para empresas, aulas y laboratorios de
investigación [17].
JupyterHub se ejecuta en la nube o en su propio hardware.
JupyterHub es de código abierto y está diseñado para ejecutarse en una variedad de infraestructura.
Esto incluye proveedores comerciales de nube, máquinas virtuales o incluso el hardware de su propia
computadora portátil.
Web:
http://jupyter.org/hub
22.2 Cuadernos de Microsoft Azure

Microsoft Azure Notebooks es una versión de Jupyter Notebook de Microsoft.
Lo bueno de Microsoft Azure Notebooks es que tiene la infraestructura y todo en funcionamiento listo
para usar. Puedes usarlo gratis también.
Web:
https://notebooks.azure.com
Ejemplo 22.2.1. Nombre de ejemplo
La figura 22.2 muestra una descripción general de mis proyectos de Azure Notebook.
Figura 22.2: Proyectos de Azure Notebook
La figura 22.3 muestra una descripción general de mis cuadernos de Azure Notebook Project.
La figura 22.4 muestra un ejemplo de un cuaderno simple.
[Fin del ejemplo]
114
Figura 22.3: Cuadernos del proyecto Azure Notebook
Figura 22.4: Ejemplo de Azure Notebook
115
Parte V
Python para Matemáticas

Aplicaciones
116
capitulo 23
Matemáticas en Python
Python es una poderosa herramienta para los cálculos matemáticos.
Si está buscando algo similar usando MATLAB, eche un vistazo a estos re

fuentes:
https://www.halvorsen.blog/documents/programming/matlab/
23.1 Funciones matemáticas básicas

La biblioteca estándar de Python consta de diferentes módulos para el manejo de E/S de
archivos, matemáticas básicas, etc. No necesita instalarlos por separado, pero debe tenerlos en
cuenta cuando desee utilizar algunos de estos módulos o algunas de las funciones. dentro de
estos módulos.
En este capítulo nos centraremos en el módulo matemático que forma parte de la biblioteca
estándar de Python.
El módulo matemático tiene todas las funciones matemáticas básicas que necesita, tales como:
Funciones métricas trigonométricas: sin(x), cos(x), etc. Funciones logarítmicas: log(), log10(), etc.
Constantes como pi, e, inf, nan, etc. etc.
Ejemplo 23.1.1. Usando el módulo de matemáticas
Creamos algunos ejemplos básicos de cómo usar una Biblioteca, un Paquete o un Módulo:
Si solo necesitamos la función sin(), podemos hacer esto:

1 de matemáticas importar pecado
2
3 x = 3. 1 4
4 y = sen ( x )
5
6 imprimir (y)
Si necesitamos algunas funciones, podemos hacer esto
117
1 de importación matemática si n , porque
3 x = 3. 1 4
4 y = sen ( x ) 5
imprimir ( y )
6
7 y = cos ( x ) 8
imprimir ( y )
Si necesitamos muchas funciones podemos hacer así:

2
3 x = 3. 1 4 4 y
= sin ( x ) 5 imprimir
(y)
6
7 y = cos ( x ) 8
imprimir ( y )
También podemos usar esta alternativa:
1 importación de matemáticas
2
3 x = 3. 1 4 4 y =
matemática . pecado ( x )
5
6 imprimir (y)
También podemos escribirlo así:

2
3 x = 3. 1 4
4 y = mt. pecado ( x )
5
6 imprimir (y)
[Fin del ejemplo]
Hay ventajas y desventajas con los diferentes enfoques. Es posible que en su programa necesite
usar funciones de muchos módulos o paquetes diferentes. Si importa todo el módulo en lugar de
solo las funciones que necesita, usará más memoria de la computadora.
Muy a menudo, también necesitamos importar y usar varias bibliotecas donde las diferentes
bibliotecas tienen algunas funciones con el mismo nombre pero un uso diferente.
Otros módulos útiles en la biblioteca estándar de Python son las estadísticas (donde tiene funciones
como mean(), stdev(), etc.)
ver:
https://docs.python.org/3/library/
118
23.1.1 Ejercicios
Ejercicio 23.1.1. Crear expresiones matemáticas en Python
Cree una función que calcule la siguiente expresión matemática:
z = 3x 2
+ x + y (x)
+e
22 en
(23.1)
Prueba con diferentes valores para x e y.
[Fin del ejercicio]
Ejercicio 23.1.2. Crear expresiones matemáticas avanzadas en Python
Cree la siguiente expresión en Python:
ln (ax2 + bx + c) − sin(ax2 + bx + c) f(x) =

4πx2 + (23.2)
cos(x − 2)(ax2 + bx + c)
Dado a = 1, b = 3, c = 5 Encuentre f(9)

(La respuesta debería ser f(9) = 0.0044)
¡Consejo! Debe dividir las expresiones en diferentes partes, como:
poli = ax2 + bx + c
número = ...
guarida . . .
=f= ...
Esto hace que la expresión sea más fácil de leer y comprender, y minimiza el riesgo de
cometer un error al escribir la expresión en Python.
Cuando obtenga la respuesta correcta, intente cambiar a, por ejemplo, a = 2, b = 8, c = 6
Encuentre f(9)
[Fin del ejercicio]
Ejercicio 23.1.3. Pitágoras
119
Figura 23.1: Triángulo rectángulo
El teorema de Pitágoras es el siguiente:
2c 2 = un 2
+ segundo
(23.3)
Cree una función que use Pitágoras para calcular la hipotenusa de un triángulo rectángulo
(Figura 23.1), por ejemplo:
1 def py th agoras (a ,b )
2 ...
3 ...
4 volver c
[Fin del ejercicio]
Ejercicio 23.1.4. Albert Einstein
Dada la famosa ecuación de Albert Einstein:
E = mc2 (23.4)
El sol irradia 385x1024J/s de energía.
Calcula cuánto de la masa del sol se usa para crear esta energía por día.
¿Cuántos años se necesitarán para convertir toda la masa del sol por completo? ¿Debemos
preocuparnos si el sol se agotará en nuestra generación o en la siguiente? justificar la
respuesta.
La masa del sol es 2x1030 kg.
120
[Fin del ejercicio]
Ejercicio 23.1.5. Área de superficie del cilindro
Cree una función que encuentre el área de la superficie de un cilindro en función de la altura (h) y el
radio (r) del cilindro. Ver figura ??.
Figura 23.2: cilindro
[Fin del ejercicio]
23.2 Estadísticas
23.2.1 Introducción a la Estadística
Media o promedio: La
media es la suma de los datos dividida por el número de puntos de datos. Comúnmente se le llama
“el promedio”,
Fórmula para la media:

norte
x1 + x2 + x3 + ... + xN norte 1
x¯ = = xi (23.5)
ni
=1
Ejemplo 23.2.1. Significar
Dado el siguiente conjunto de datos: 2.2, 4.5, 6.2, 3.6, 2.6
Significar:
norte
1 2,2 + 4,5 + 6,2 + 3,6 + 2,6 19.1

x¯ = xi = = = 3,82 (23.6)
norte
yo=1
5 5
121
[Fin del ejemplo]
Diferencia:
La varianza es una medida de la variación en un conjunto de datos.
norte
1 2
var(x) = (xi x¯) (23.7)
ni
=1
Desviación estándar: la
desviación estándar es una medida de la dispersión de los valores en un conjunto de datos o el valor
de una variable aleatoria. Se define como la raíz cuadrada de la varianza.
norte
1
2
estándar(x) = σ = √ var = (xi x¯) (23.8)
ni
=1
Por lo general, usamos el símbolo σ para la desviación estándar.
Tenemos que σ 2
= var(x)
23.2.2 Funciones estadísticas en Python

Funciones de estadísticas matemáticas en Python:
https://docs.python.org/3/library/statistics.html
Las estadísticas son parte de la biblioteca estándar de Python.
ver:
Ejemplo 23.2.2. Estadísticas utilizando el módulo de estadísticas en la biblioteca estándar de Python
A continuación, encontrará algunos ejemplos de cómo usar algunas de las funciones de estadísticas en
el módulo de estadísticas en la biblioteca estándar de Python:
1 estadísticas de importaciónasst
2
, 2.5 , 3. 2 5 , 5.75]
3 datos = [ −1. 0
4
5 #Media o Promedio 6 m =
st . media (datos) 7 imprimir (m)
9 # Desviación estándar 10 Desvst =

st . desvst (datos)
122
11 imprimir (desvst)
12
13 # Mediana 14
med = st . mediana (datos) 15 impresión
(med)
dieciséis
17 # V a ri anza 18
var = st . va ri anza (datos) 19 imprimir (var)
Listado 23.1: Funciones estadísticas en Python
[Fin del ejemplo]
IMPORTANTE: No nombre su archivo "statistics.py" ya que la importación se confundirá y arrojará

los errores de que la biblioteca no existe y la función media no existe.
También puede usar la biblioteca NumPy. NumPy es el paquete fundamental para la computación
científica con Python.

Ejemplo 23.2.3. Estadísticas utilizando la biblioteca NumPy
A continuación encontrará algunos ejemplos de cómo usar algunas de las funciones estadísticas en
NúmPy:

2
3 datos = [ −1. 0 , 2.5 , 3. 2 5 , 5.75]

4
5 #Media o Promedio 6 m =
np . media (datos) 7 imprimir
(m)
8
9 # Desviación estándar 10
Desviación estándar = np . std (datos)
11 imprimir (stdev)
12
13 # Mediana 14
med = np . mediana (datos) 15 impresión
(med)
dieciséis
17 # Valor mínimo 18 minv =

np . min (datos) 19 imprimir (minv)
20
21 # Valor máximo 22 maxv

= np . max( datos) 23 imprimir (maxv)
Listado 23.2: Estadísticas usando la biblioteca NumPy
123
[Fin del ejemplo]
Ejercicio 23.2.1. Crea tu propio módulo de estadísticas en Python
El uso de las funciones integradas en la biblioteca estándar de Python o la biblioteca NumPy

es sencillo.
Para obtener una comprensión más profunda de las matemáticas detrás de estas funciones
y aprender más sobre programación en Python, debe crear su propio módulo de estadísticas
en Python.
Cree su propio módulo de estadísticas en Python (p. ej., ”mystatistics.py) y luego cree un
script de Python (p. ej., ”testmystatistics.py) donde pruebe estas funciones.
Al menos debe implementar funciones para la media, la varianza, la desviación estándar, el

mínimo y el máximo.
[Fin del ejercicio]
23.3 Funciones trigonométricas

Python ofrece muchas funciones trigonométricas, por ejemplo, sin, cos, tan, etc.
¡Nota! La mayoría de las funciones trigonométricas requieren que el ángulo se exprese en

radianes.
Ejemplo 23.3.1. Funciones trigonométricas en el módulo de Matemáticas

2
3x = 2 mt. Pi
4
5 y = mt. sen ( x ) 6
imprimir ( y )
7
8 y = mt. cos ( x ) 9
imprimir ( y )
10
11 y = mt. bronceado ( x )
12 imprimir ( y )
Listado 23.3: Funciones trigonométricas en el módulo Math
Aquí hemos utilizado el módulo Math en la biblioteca estándar de Python.
ver:
124
[Fin del ejemplo]
Ejemplo 23.3.2. Representación de funciones trigonométricas
En el ejemplo anterior, usamos algunas de las funciones trigonométricas en cálculos básicos.
Veamos si somos capaces de graficar estas funciones.
1 importar matemáticas
como mt 2 importar mat pl o tli b . py pl otasplt
3
4 datos x = [ ] 5 datos y =
[]
6
7 para el rango de x ( 0 1 0 ,) :
8 xdata . agregar ( x ) y
9 = mt . sen(x)ydatos.
10 agregar (y)
11
12 plt. plot (xdata, ydata) 13 plt. espectáculo ( )
Listado 23.4: Trazado de funciones trigonométricas
En el ejemplo que hemos trazado sin(x), podemos extender fácilmente el programa para trazar
cos(x), etc.
ver:
[Fin del ejemplo]
Ejemplo 23.3.3. Funciones trigonométricas usando NumPy
El problema con el uso de funciones trigonométricas en el módulo matemático de la biblioteca

estándar de Python es que no manejan una matriz como entrada.
En su lugar, usaremos la biblioteca NumPy porque maneja matrices, además de toda la

funcionalidad práctica en la biblioteca NumPy.

3
4 xstart = 0 5 xst op =
2 np . pi 6 incremento remen t = 0. 1
8 x = np. ar an ge ( xstart inc rement ) , xstop ,

9
125
plt . título ( ' y=sin ( x ) ' ) 13 plt . etiqueta
x ( ' ' ) 14 plt . ylabel ( ' ' ) X15
plt . cuadrícula ( ) 16 plt . yeje
( [ 0 , 2 np . pi , −1,
1 ] ) 17 plt . espectáculo( )
18
19 y = np. porque ( x ) 20
plt . parcela ( x , y ) 21 plt .
título ( ' y=cos ( x ) ' ) 22 plt . etiqueta x
( ' ' ) 23 plt . ylabel ( ' ' ) 24X
plt . cuadrícula ( ) 25 plt . yeje
( [ 0 , 2 np . pi , −1,
1 ] ) 26 plt . espectáculo( )
27
28 y = np. bronceado (x)

plt . título ( ' y=bronceado ( x ) ' ) 31 plt .
X
etiqueta x ( ' ' ) 32 plt . ylabel
( ' ' ) 33 plt . cuadrícula ( )y34
plt . eje ( [ 0 , 2 np .
pi , −1, 1 ] ) 35 plt . espectáculo ( )
Listado 23.5: Funciones trigonométricas usando NumPy
Este script de Python proporciona los gráficos como se muestra en la Figura 23.3.
[Fin del ejemplo]
Ejercicio 23.3.1. Crear funciones de Python para convertir entre radianes y grados.
Dado que la mayoría de las funciones trigonométricas requieren que el ángulo se

exprese en radianes, crearemos nuestras propias funciones para convertir entre
radianes y grados.
Tenemos eso:

Esto da:
180
d[grados] = r[radianes] × ( ) π
(23.10)
y
π
Cree dos funciones que conviertan de radianes a grados (r2d(x)) y de grados a

radianes (d2r(x)) respectivamente.
126
Pruebe las funciones para asegurarse de que funcionan como se esperaba.
[Fin del ejercicio]
Ejercicio 23.3.2. Funciones trigonométricas en triángulo rectángulo
Dado el triángulo rectángulo como se muestra en la figura 23.4.
Cree una función que encuentre el ángulo A (en grados) en función de los argumentos de entrada (a,c), (b,c) y
(a,b) respectivamente.
Utilice, por ejemplo, un tercer "tipo" de entrada para definir los diferentes tipos anteriores.
Use su función anterior r2d() para asegurarse de que la salida de su función esté en grados y no en radianes.
Pruebe la función para asegurarse de que funciona correctamente.
¡Consejo! Tenemos eso:
a
pecado(A) = → A = arcosen(a ) (23.12)
C C
b cos(A) = b → A = arccos( ) (23.13)

C C
a
bronceado(A) = → A = arctan(a ) (23.14)
b b
También es posible que necesitemos usar el teorema de Pitágoras:
2c 2 = un 2
+ segundo
(23.15)
1 >>> a=5 2
>>> b=8 3 >>>
c = raíz cuadrada ( a 2+b 2)
4
5 >>> A = triángulo rectángulo ( a 6 A = 3 2. , C ' pecado ' )

0054 ,
7
8
9 >>> A = triángulo rectángulo ( b ,C ' co s ' )

10 A = ,
11 3 2. 0 0 5 4
'
12 >>> A = triángulo rectángulo ( a 13 A = 3 , broncearse
')
b,
2. 0 0 5 4
14
Vemos también que la respuesta en este caso es la misma, la esperada.
127
[Fin del ejercicio]
Ejercicio 23.3.3. Ley de los cosenos
Dado el triángulo como se muestra en la figura 23.5.
Crea una función donde encuentres c usando la ley de los cosenos.
2 2 c = un 2
+ segundo
− 2ab cos(C) (23.16)
Pruebe las funciones para asegurarse de que funciona correctamente.
[Fin del ejercicio]
Ejercicio 23.3.4. Representación de funciones trigonométricas
Trazar sen(θ) y cos(θ) para 0 ≤ θ ≤ 2π en el mismo gráfico (ambos en el mismo gráfico y en 2

subgráficos diferentes).
Asegúrese de agregar etiquetas y una leyenda y use diferentes estilos de línea y colores para las
gráficas.
[Fin del ejercicio]
23.4 Polinomios
Un polinomio se expresa como:
n−1
+ p2x
norte
p(x) = p1x + ... + pnx + pn+1 (23.17)
donde p1, p2, p3, ... son los coeficientes del polinomio.
Usaremos el módulo polinomial en el paquete NumPy.
Web:
https://docs.scipy.org/doc/numpy1.13.0/reference/routines.polynomials.polynomial.html
Otros recursos:
Temas del curso avanzado de Python: polinomios: https://

www.pythoncourse.eu/polynomialclassinpython.php
128
129
Figura 23.3: Funciones trigonométricas

Figura 23.4: Triángulo Rectángulo
Figura 23.5: Ley de los cosenos
130
capitulo 24
Álgebra lineal en Python
24.1 Introducción al Álgebra Lineal

Una matriz es una estructura de datos bidimensional donde los números se organizan en filas y
columnas.
Matrix es un caso especial de matriz bidimensional donde cada elemento de datos tiene
estrictamente el mismo tamaño.
Las matrices son estructuras de datos muy importantes para muchos cálculos matemáticos y
científicos.
Una matriz general se define como:
a11 a12 ... a1m

a21 a22 .. a2m nxm
un = R (24.1)
... ... ... ...
an1 an2 ... anm
Donde n es el número de filas y m es el número de columnas.
Ejemplo de una matriz de 3 x 3:
15346
un = 6389 (24.2)
1534457
un = 87893 (24.3)
131
15
45
un = (24.4)
32
78
Python no tiene un tipo incorporado para matrices. Sin embargo, podemos tratar la lista de una
lista como una matriz.
Ejemplo 24.1.1. Definición de matriz con Python estándar
Aquí hay un ejemplo de cómo podemos implementar un vector y una matriz en estándar
Pitón:
1 un = [ 1 , 3, 7 , 2]
2
3 imprime ( ”a =" , a)
4
6A=[[1[5 , 3 , 7 , 2],
7 [6 , 8 , −9, 0 ] , 1
8 −7, 1 1 , 2]],
9
10 imprime ( ”A =" , A)
Listado 24.1: Matrices de Python
Esto da la siguiente salida:

1 un = [ 1 , 3, 7,
2A=[[1 , 3 , 7 , 2]2], [5 , 8 , −9, 0 ] , [ 6 , −7, 1 1 , 12]]
Entonces, podemos definir vectores y matrices con Python estándar, pero Python
estándar no admite la manipulación y el cálculo de ellos.
Pero, afortunadamente, podemos usar el paquete NumPy para crear matrices y

manipular matrices.
[Fin del ejemplo]
24.2 Álgebra lineal con Python

Usaremos el paquete NumPy para la manipulación de matrices.
NumPy es el paquete fundamental para la computación científica con Python.

Ejemplo 24.2.1. Manipulación de matrices usando la biblioteca NumPy
132
A continuación, verá cómo podemos usar NumPy para crear vectores y matrices y
manipularlos usando NumPy:

2
3 a = np. matriz ( [ 1 , 3, 7 , 2])

4
6
9 A = np. matriz ( [ [ 1 [ 5 [ 6 , 3, 7, ,
10 , 2 ] , −9, 0 ] ,
11 8 , −7, 1 1 , 12]])
12
13
14 imprime ( ”A =" , A)
15
dieciséis
17
18
19 A = np. matriz ( [ [ 0 1 ] , [ −2 , −3]] ) ,

20
21
22 B = np. matriz ( [ [ 1 [ 3 ,
23 0 ] , , −2]] )
24
25 C = A + B 26
imprimir (C)
27
28
29 C = A. punto (B) 30
letra (C)
31
32 C = A. transponer ( ) 33
imprimir (C)
Listado 24.2: Manipulación de matrices usando NumPy
[Fin del ejemplo]
24.2.1 Vectores
Use np.array() cuando defina vectores:
2
3 a = np. matriz ( [ 1 , 3, 7 , 2])

4
Listado 24.3: Manipulación de matrices usando NumPy
133
24.2.2 Matrices
También puede usar np.array() al definir matrices, pero es incluso mejor usar
np.matrix().
El objeto de matriz numpy es una subclase del objeto de matriz numpy y está hecho a medida
para matrices. Las matrices numpy son estrictamente bidimensionales, mientras que las
matrices numpy pueden tener cualquier dimensión.
Ejemplo:
2
3 A = np. matriz ( [ [ 0 1 ] [ −2 , −3]] ) , ,

4
6 imprime ( ”A =" , A)
24.2.3 Álgebra lineal (numpy.linalg)

Para obtener más funciones de álgebra lineal en la biblioteca NumPy, debe usar el
módulo numpy.linalg.
Aquí encontrará una descripción general del módulo

numpy.linalg: https://docs.scipy.org/doc/numpy/reference/routines.linalg.html
Usaremos el numpy.linalg en diferentes ejemplos en este capítulo.
24.2.4 Suma de matrices

Dadas las matrices:
A R nxm
B R nxm
Entonces
nxm
C=A+B R
Ejemplo:
0 1 −2
un = (24.5)
−3
103
B= (24.6)
−2
134
Entonces obtenemos:
0 1 −2 103 0 + 1 1 + 0 −2 111
A+B = = = (24.7)
−3 −2 + 3 −3 − 2 −5
Ejemplo 24.2.2. Suma de matrices en Python

2
3 A = np. matriz ( [ [ 0 1 ] [ −2 , −3]] ) , ,

4
6 B = np. matriz ( [ [ 1 0 ] , [ 3 , −2]] ) ,

7
8
9 C = A + B 10
imprimir (C)
Listado 24.4: Suma de matrices en Python
Obtenemos:
1 [[11][1
2 −5]]
[Fin del ejemplo]
24.2.5 Sustracción de matrices

Dadas las matrices:
A R nxm
B R nxm
Entonces
nxm
C = UN − segundo R
Ejemplo:
0 1 −2
un = (24.8)
−3
135
103
B= (24.9)
−2
Entonces obtenemos:
0 1 −2 103 0 − 1 1 − 0 −2 − 3 −1 1 −5
A−B= = =
−3 −2 −3 − (−2) −1 (24.10)
Ejemplo 24.2.3. Subración de matriz en Python

2
3 A = np. matriz ( [ [ 0 1 ] , [ −2 , −3]], )

4
6 B = np. matriz ( [ [ 1 0 ] , [ 3 , −2]] ),

7
8
9 C = A − B 10
imprimir (C)
Listado 24.5: Sustracción de matrices en Python
Obtenemos:
1 [[ −1 1 ] 2 [−5
−1]]
[Fin del ejemplo]
24.2.6 Multiplicación de matrices

Dadas las matrices:
nxm
A R
B R mxp
Entonces
C = AB R nxp
136
Dónde
norte
cjk = ajlblk
l=1
Ejemplo:
0 1 −2
un = (24.11)
−3
103
B= (24.12)
−2
Entonces obtenemos:
0 1 −2 103
AB =
−3 −2
0 ∙ 1 + 1 ∙ 3 0 ∙ 0 + 1 ∙ (−2) −2 ∙ 3 −2
= = (24.13)
1 − 3 ∙ 3 −2 ∙ 0 − 3 ∙ (−2) −11 6
Hacemos lo mismo en Python:
Ejemplo 24.2.4. Multiplicación de matrices en Python

2
3 A = np. matriz ( [ [ 0 1 ] , [ −2 , −3]] ) ,

4
6 B = np. matriz ( [ [ 1 0 ] , [ 3 , −2]] ) ,

7
8
9C=A B 10
imprimir (C)
Listado 24.6: Multiplicación de matrices en Python
Esto da:
1 [ [ 3 −2] 2 [−11
6]]
A continuación, verá diferentes soluciones alternativas que se pueden utilizar:

2
3 A = np. matriz ( [ [ 0 1 ] [ −2 , −3]] ) , ,

4
6 B = np. matriz ( [ [ 1 , 0],
137
7 [ 3 , −2]] )
8
9 #Al terna ti va 1 10
C = A. punto (B) 11
imprimir (C)
12
C = np . punto (A,B) 15
letra (C)
dieciséis
C = np . estera (A) np . tapete (B) 19
estampado (C)
Listado 24.7: Multiplicación de matrices en Python Soluciones alternativas
Como se muestra en el ejemplo, puede usar una sintaxis diferente. Las 3 alternativas del ejemplo
dan el mismo resultado. Intentalo.
[Fin del ejemplo]
En la multiplicación de matrices, las matrices no necesitan ser cuadráticas, pero las dimensiones
internas deben ser las mismas. El tamaño de la matriz resultante serán las dimensiones exteriores.
Ver Figura 24.1.
Figura 24.1: Multiplicación de matrices
También tenemos las siguientes reglas de matriz:
AB = BA (24.14)
A(BC) = (AB)C (24.15)
(A + B)C = AC + BC (24.16)
C(A + B) = CA + CB (24.17)
Ejercicio 24.2.1. Reglas de matriz
Cree un script de Python donde verifique que las reglas anteriores sean correctas.
[Fin del ejercicio]
138
24.2.7 Transpuesta de una matriz

Una matriz general se define como:
a11 a12 ... a1m

a21 a22 .. a2m nxm
un = R (24.18)
... ... ... ...
an1 an2 ... anm
Donde n es el número de filas y m es el número de columnas.
La transpuesta de la matriz a es entonces:
a11 a21 ... an1

T
= a12 a22 .. a2m MXN
A R (24.19)
... ... ... ...
a1m an2 ... anm
La transformada de una matriz se forma convirtiendo todas las filas de una matriz dada en
columnas y viceversa.
Ejemplo 24.2.5. Transposición de una matriz en Python

2
3 A = np. matriz ( [ [ 0 1 ] , [ −2 , −3]] ) ,

4
6 En = np. transponer (A) 7

imprimir ( At )
8
10 B = np. matriz ( [ [ 1 4 ] [ 3 , −2, 8 ] ] ) , 0 , ,

11
12
13 Bt = np. transponer (B) 14

imprimir (Bt)
15
dieciséis
17
18 C = np. matriz ( [ [ 1 , ] , [ 2 −3 ,] , [ −6 , −2]] ) , 4

19 ,
20
21
22 Ct = np. transponer (C) 23

imprimir (Ct)
Listado 24.8: Transpuesta de una matriz
1 [ [ 0 −2] [ 1
2 −3]]
3
4 [ [ 1 3 ] [ 0 −2]
5
139
6 [48]]
7
8 [ [ 1 2 −6] [ 4 −3
9 −2]]
[Fin del ejemplo]
24.2.8 Determinante
Dada una matriz A el Determinante viene dado por:
det(A) = |A|
Para una matriz A de 2x2:
un = a11 a12
(24.20)
a21 a22
Tenemos:
det(A) = |A| = a11a22 − a21a12 (24.21)
Ejemplo:
12
un = (24.22)
34
Obtenemos:
det(A) = |A| = 1 ∙ 4 − 3 ∙ 2 = 4 − 6 = −2 (24.23)
Ejemplo 24.2.6. Determinante
Ejemplo de pitón:
importar numpy. linalgasla
3
4 A = np. matriz ( [ [ 1 [ 3 , ,
5 , 2]4]])
6
7 Adet = la . de t (A)
8
9 impresión (Adet)
Listado 24.9: Determinante
140
Esto da:
1 −2.0000000000000004
Listado 24.10: Determinante
[Fin del ejemplo]
24.2.9 Matriz inversa

La inversa de una matriz cuadrática A Rnxn está definida por:
−1
A
Para una matriz cuadrada A, la inversa se escribe A−1 . Cuando A se multiplica por A−1, el
resultado es la matriz identidad I. Las matrices no cuadradas no tienen inversas.
Tenemos eso:
AA−1 = A −1A = yo (24.24)

Para una matriz de 2x2 tenemos:
a11 a12
un = (24.25)
a21 a22
El inverso de A se convierte en:
−1 1 a22 −a12
A = (24.26)
det(A) −a21 a11
Ejemplo 24.2.7. Matriz inversa
Ejemplo de pitón:
3
4 A = np. matriz ( [ [ 1 [ 3 , 2],

5 , 4]])
6
7 Ainv = la . en v (A)
8
9 imprimir ( Ainv )
Listado 24.11: Matriz inversa
Obtenemos los siguientes

resultados: 1 1 .
2 [[ −2. ] [ 1. 5 −0. 5]]
[Fin del ejemplo]
141
24.3 Resolución de ecuaciones lineales

Ejemplo 24.3.1. Resolviendo Ecuaciones Lineales
Dadas las ecuaciones:
x1 + 2x2 = 5 (24.27)
3x1 + 4x2 = 6 (24.28)
Queremos establecer las ecuaciones de la siguiente forma:
hacha = b (24.29)
Necesitamos encontrar A y b y definirlos en Python.
Entonces podemos resolver las ecuaciones, es decir, encontrar x1 y x2 usando Python.
Se puede resolver así:
−1
x = un segundo
(24.30)
Obtenemos:
12
un = (24.31)
34
5
segundo =
6
(24.32)
x1
x= (24.33)
x2
Escritura de Python:
3
4 A = np. matriz ( [ [ 1 [ 3 , ,
5 , 2]4]])
6
7 b = np. matriz ( [ [ 5 ] ,
142
8 [6]])
9
10 Ainv = la . en v (A)
11
12 x = Ainv. punto (b)

13
14 imprimir ( x )
1 [[ −4. ] [ 4 .
2 5]]
También puedes usar lo siguiente:
1 x = np. Linalg. resolver (a, b)

2
3 A = np. matriz ( [ [ 1 [ 3 , ,
4 , 2]4]])
5
6 b = np. matriz ( [ [ 5 ] ,
7 [6]])
8
9 x = np. Linalg. resolver (A, b ) 10

imprimir ( x )
¡Nota! La matriz A debe ser cuadrada y de rango completo, es decir, la matriz inversa debe existir.
[Fin del ejemplo]
En muchos casos no podemos encontrar la matriz inversa, por ejemplo, cuando la matriz no es cuadrática.
Encontrar la matriz inversa para matrices grandes también requiere mucho tiempo.
Se puede usar el módulo numpy.linalg.
Aquí encontrará una descripción general del módulo numpy.linalg: https://

docs.scipy.org/doc/numpy/reference/routines.linalg.html
Ejemplo 24.3.2. Resolver ecuaciones lineales cuando A no es cuadrático
Usamos lstsq para la mejor "solución" de mínimos cuadrados del sistema/ecuación.

2
3 A = np. matriz ( [ [ 1 [ 3 , 2],

4 [7, ,
5 , 4]8]])
143
7 b = np. matriz ( [ [ 5 ] [ 6 ] [ 9 ] ] ) ,
8 ,
9
10
11 #x = np. Linalg. resolver (A, b) #No funciona porque la inversa (A) no funciona
existe
12
13
14 x = np. Linalg. lstsq (A, b , rcond=Ninguno) [ 0 ]

15
16 imprimir ( x )
1 [[ −3. 5 ] [ 4 . 1 7 8 5 7 1 4
2 3]]
[Fin del ejemplo]
24.4 Ejercicios
A continuación encontrará diferentes ejercicios a su propio ritmo que debe realizar y resolver por su
cuenta. ¡La única forma de aprender Python es hacer muchos ejercicios!
Ejercicio 24.4.1. Ejercicio Resolución de ecuaciones lineales
Dadas las siguientes ecuaciones:
x1 + 2x2 = 5 (24.34)
3x1 + 4x2 = 6 (24.35)
7x1 + 8x2 = 9 (24.36)
Encuentre las soluciones para las ecuaciones dadas usando Python.
[Fin del ejercicio]
Ejercicio 24.4.2. Suma, resta y multiplicación de matrices mediante bucles For anidados
Suponga que no puede realizar sumas, restas y multiplicaciones de matrices como se muestra en
los ejemplos anteriores.
Cree un módulo de Python con 3 funciones (p. ej., matrixaddition(), matrixsubtraction(),

matrixmultiplication()) donde implemente su propia versión de suma, resta y multiplicación de
matrices usando For Loops anidados.
Asegúrese de probar las funciones que funcionan como se esperaba, por ejemplo:
144
1 importar mymatrixmodule como matriz

2
3A=[[1[5[6 ,3, ,
4 , 7]8,
5 −9] , , −7, 1 1 ] ]
6
, 3,
7 segundo = [ [ 2 5 ] [ 5 , −9, −9] , [ 6 ,
8 1]]
9 , 8,
10
11 c = matriz. mat ri xadición (A, B) 12 imprimir (C)
13
14 c = matriz. resta mat ri x (A, B) 15 print (C)
dieciséis
17 c = matriz. multiplicacion de matrices (A, B) 18 imprimir

(C)
Listado 24.12: Matrices Python
Debe probar su función haciendo los cálculos a mano y usando la funcionalidad numpy.
Compare los resultados y asegúrese de obtener el mismo
respuestas
[Fin del ejercicio]
145
capitulo 25
números complejos en
Pitón
25.1 Introducción a los números complejos

Un número complejo se define así:
z = a + jb (25.1)
Donde la unidad imaginaria j se define como i = √ −1
Donde a se llama parte real de z y b se llama parte imaginaria de z, es decir:
Re(z) = a, Im(z) = b
La figura 25.1 muestra una ilustración de números complejos.
En Python definimos un número complejo como este:

1 >>> z = 2 + 3 j
El complejo conjugado de z se define como:
z = a − jb (25.2)
También puede usar números imaginarios en forma exponencial/polar:
z = rejθ (25.3)
146
Dónde:
2
r = |z| = un + segundo 2
(25.4)
b θ = arctan (25.5)
a
Tenga en cuenta que a = r cos θ y b = r sin θ
La figura 25.2 muestra una ilustración de números complejos en forma polar.
Figura 25.1: Números complejos
Para sumar o restar dos números complejos, simplemente sumamos (o restamos) sus partes
reales y sus partes imaginarias.
En división y multiplicación, usamos la forma polar.
Dados los números complejos:
jθ1
z1 = r1e (25.6)
jθ2
z2 = r2e (25.7)
Multiplicación:
j(θ1+θ1)
z3 = z1z2 = r1r1e (25.8)
147
Figura 25.2: Números complejos Forma polar
División:
jθ1
z1 r1e r1
z3 = = = y j(θ1−θ2) (25.9)
z2 r2e jθ2 r2
25.2 Números complejos con Python

En Python puedes usar la biblioteca cmath que tiene funciones matemáticas para números complejos.
https://docs.python.org/3/library/cmath.html
cmath es parte de la biblioteca estándar de Python.
ver:
Ejemplo 25.2.1. Números complejos básicos en Python
Dados los siguientes números complejos:
a = 5 + 3j (25.10)
148
b = 1 1j (25.11)
En Python podemos definir los números complejos y realizar operaciones básicas (+,
, *, /) como esta:
1 un = 5 + 3 j 2 segundo =
11j
3
4c=a+b5
imprime ( c )
6
7 re = un − segundo
8 imprimir ( re )
9
10 mi = un segundo
11 letra ( e )
12
13 f = a / b 14
imprimir ( f )
Listado 25.1: Números complejos básicos en Python
[Fin del ejemplo]
Ejemplo 25.2.2. Funciones de números complejos en Python
1 importación cmath
2
3 x = 2 4 y = −3
6 # convertir x y y en números complejos usando complejo ( ) 7 z = complejo ( x , y )

8 imprimir ( z . real ) 9
imprimir ( z . imag )
10
11 imprimir ( z . conjugar ( ) )
12
13 # convertir números complejos en top olar si ngp ol ar ( ) 14 w = cmath . polar

(z) 15 imprimir (w)
dieciséis
17
18 # convirtiendo un número complejo en un rectángulo en un rectángulo ( ) 19 w =

cmath . rect ( 2 20 letra (w) , 3)
Listado 25.2: Funciones de números complejos en Python
[Fin del ejemplo]
149
capitulo 26
Ecuaciones diferenciales
26.1 Introducción a las ecuaciones diferenciales

Una ecuación diferencial es una ecuación matemática que relaciona alguna función con sus
derivadas.
En las aplicaciones, las funciones generalmente representan cantidades físicas, las derivadas
representan sus tasas de cambio y la ecuación diferencial define una relación entre las dos.
Debido a que tales relaciones son extremadamente comunes, las ecuaciones diferenciales
desempeñan un papel destacado en muchas disciplinas, incluidas la ingeniería, la física, la
economía y la biología.
Por lo general, queremos resolver ecuaciones diferenciales ordinarias (EDO) de la forma:
dy
= f(t, y), y(t0) = y0 dt (26.1)
¡Nota! Se utiliza una notación diferente: dy = y'= ˙y

dt
Este documento utilizará estas diferentes notaciones indistintamente.
Ejemplo 26.1.1. Ejemplo de Sistema Dinámico
Dada la siguiente ecuación diferencial:
x˙ = −ax + bu (26.2)
¡Nota! ˙x es lo mismo que dx

dt
Tenemos lo siguiente:
• x Variable de proceso, p. ej., nivel, presión, temperatura, etc.
• u Variable de entrada, por ejemplo, señal de control del controlador
• a, b Constantes
150
[Fin del ejemplo]
Con Python have podemos resolver estas ecuaciones diferenciales de muchas maneras diferentes.
Podemos usar los llamados solucionadores ODE o podemos hacer una versión discreta de las
ecuaciones diferenciales usando métodos de discretización como Euler, etc.
Con los solucionadores de EDO, Python puede resolver estas ecuaciones numéricamente. Las
ecuaciones diferenciales de orden superior deben reformularse en un sistema de ecuaciones
diferenciales de primer orden.
En el capítulo 35 simularemos (resolveremos y graficaremos los resultados) tales ecuaciones

diferenciales numéricamente usando la discretización de Euler.
Ejemplo 26.1.2. Ejemplo de ecuación diferencial
x˙ = hacha (26.3)
donde a = − 1
T, donde T se define como la constante de tiempo del sistema.

dt
Se encuentra que la solución de la ecuación diferencial es:
x(t) = e atx0 (26.4)
Graficaremos la solución para esta ecuación diferencial usando Python.
En nuestro sistema podemos establecer T = 5 y la condición inicial x0 = x(0) = 1

código pitón:
como mt 2 importar numpy
como np 3 importar mat pl o tli b . py pl otasplt
4
6 # Parámetros
7T=58a
= −1/T
9
10 x0 = 1 11
t=0
12
13 tstart = 0 14 tstop
= 25
15
16 aum rem ento = 1

17
18 x = [ ] 19
x = np . ceros ( tstop +1)
20
21 t = np. ar an ge (comenzar , tstop +1, inc remen t )
151
22
23
24 # Defina la Ecuación 25 para k inr

an ge ( tstop ) : x [ k ] = mt . Exp ( un
26 t[k]) x0
27
28
29 # Trazar los resultados 30 plt.

,
parcela ( tx ) 31 plt . title
( ' Trazado de la solución de la ecuación diferencial ' ) 32 plt . etiqueta x ( ' ' ) 33 plt .
ylabel ( ' x ( t ) ' ) 34 plt .t
cuadrícula ( ) 35 plt . eje ( [ 0 36
plt . Mostrar ( )
, 25 , 0 , 1])
Listado 26.1: Ecuación diferencial
Esto da el gráfico que se muestra en la Figura 26.1.
Figura 26.1: Trazado de la solución de la ecuación diferencial
Un código de Python alternativo y quizás más simple:

3
5 # Parámetros
6T=5
152
7 a = −1/T
8
9x0 = 1
10 t = 0
11
12 tstart = 0 13 tstop
= 25 14 inc remen t
=1
15 norte = 25
dieciséis
17 #t = np. ar an ge ( tstar t 18 t = np . , tstop +1, inc rement ) #Aproximación al terna ti va tstop , N)

linspace ( tstar t ,
19
20 x = np. Exp ( a t) x0
21
22
23 # Trazar los resultados 24

, .
plt . parcela ( tx ) 25 plt
title ( ' Trazado de la solución de la ecuación diferencial ' ) 26 plt . etiqueta x ( ' ' ) 27 plt .
ylabel ( ' x ( t ) ' ) 28 plt .t
plt . mostrar ( )
, 25 , 0 , 1])
Listado 26.2: Ecuación diferencial
Este código Python alternativo proporciona el mismo gráfico que se muestra en la Figura 26.1.
Resolver ecuaciones diferenciales como se muestra en este ejemplo funciona bien, pero el problema
es que primero tenemos que encontrar manualmente (con lápiz y papel) la solución a la ecuación
diferencial.
Una alternativa es usar solucionadores para ecuaciones diferenciales ordinarias (ODE) en Python.
En los ejemplos y tareas a continuación, aprenderemos cómo podemos usar estos solucionadores
ODE integrados.
Otro enfoque consiste en resolver tales ecuaciones desde "cero" haciendo una versión discreta de
la ecuación diferencial. Este enfoque se presenta más adelante en este libro de texto (capítulo 35).
[Fin del ejemplo]
26.2 Solucionadores de ODE en Python

La biblioteca scipy.integrate tiene dos potentes funciones, ode() y odeint(), para resolver
numéricamente ecuaciones diferenciales ordinarias (EDO) de primer orden. El ode() es más flexible,
mientras que odeint() (integrador ODE) tiene una interfaz de Python más simple que funciona bien
para la mayoría de los problemas.
Para obtener más información, consulte la documentación de SciPy:
153
https://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.odeint.html
https://docs.scipy.org/doc/scipy0.14.0/reference/generated/scipy.integrate.ode.html
Ejemplo 26.2.1. Usando ODE Solver en Python
x˙ = hacha (26.5)
donde a = − 1
T,
donde T se define como la constante de tiempo del sistema.

dt
Usaremos la función odeint().
La sintaxis es la siguiente:
1 x = od ei nt (nombre de función , x0 , t)
Donde tenemos:
functioname: Función que devuelve valores derivados en los valores x y t solicitados como dxdt =
model(x,t)
x0: Condiciones iniciales de los estados diferenciales
t: Puntos de tiempo en los que se debe informar la solución. A menudo se calculan puntos internos
adicionales para mantener la precisión de la solución, pero no se notifican.
Donde primero tenemos que definir nuestra ecuación diferencial:

1 def nombre de función ( x , t):
2 dxdt = a x
3 return dxdt
El código de Python se convierte en:
1 importó numpy como np 2

de s ci py . integrar import od ei nt 3 import mat pl o
tli b . py pl otasplt
4
5 # Inicialización 6 tstart = 0 7 tstop = 25 8

inc remen t = 1
10 x0 = 1 11 t = np.
ar an ge (comenzar , tstop +1, inc remen t )

12
13
14 # Función que devuelve dx/dt 15 def mi di

ff (xt): ,
dieciséist=5
17 a = −1/T
154
18
19 dxdt = a x
20
21 volver dxdt
22
23
24 # Resuelve ODE
25 x = od e nt ( mydi f f 26 print , x0 , t)
(x)
27
28

,
ylabel ( ' x ( t ) ' ) 34 plt .t
plt . mostrar ( )
, 25 , 0 , 1])
Listado 26.3: Uso de ODE Solver en Python
Esto da el mismo gráfico que se muestra en la Figura 26.1.
Algunas modificaciones al código de Python:
1 importó numpy como np 2 de

s ci py . integrar import od ei nt 3 import mat pl o tli b . py
pl otasplt
4

inc remen t = 1
10 T = 5
11a = −1/T
12 x0 = 1 13 t = np .
ar an ge (comenzar , tstop +1, inc remen t )

14
15
16 # Función que devuelve dx/dt 17 def my di ff

(xa): , t ,
18
19 dxdt = a x
20
21 volver dxdt
22
23
24 # Resuelve ODE
25 x = od e nt ( mydi f f 26 print , x0 , t , argumentos =(a , ) )
(x)
27
28

,
ylabel ( ' x ( t ) ' ) 34 plt .t
cuadrícula ( ) 35 plt . eje ( [ 0
, 25 , 0 , 1])
155
36 plt. espectáculo ( )
Listado 26.4: Uso de ODE Solver en Python
Esto da el mismo gráfico que se muestra en la Figura 26.1.
En el ejemplo modificado tenemos los parámetros usados en la ecuación diferencial (en este caso
a) como argumento de entrada. Al hacer esto, es muy fácil cambiar los valores de los parámetros
utilizados en la ecuación diferencial sin cambiar el código de la ecuación diferencial.
También puede ejecutar fácilmente múltiples simulaciones como esta:
1a = −0.2
2 x = od ei nt ( mydi ff , x0 , t , argumentos =(a , ) )
3
4 a = −0.1 5 x
= od ei nt ( mydi ff , x0 , t , argumentos =(a , ) )
[Fin del ejemplo]
26.3 Resolver ecuaciones diferenciales de orden 1 múltiplo

ciones
En la vida real, normalmente tenemos ecuaciones diferenciales de orden superior, o tenemos un
conjunto de ecuaciones diferenciales de primer orden que describen un sistema dado. ¿Cómo
podemos resolver tales ecuaciones en Python?
Ejemplo 26.3.1. Conjunto de ecuaciones diferenciales de 1 orden
Dadas las ecuaciones diferenciales:
dx
= −y (26.6)
dt
dy
=x (26.7)
dt
Suponga las condiciones iniciales x(0) = 1 y y(0) = 1.
El código de Python es casi similar a los ejemplos anteriores, pero necesitamos hacer un pequeño
truco para que funcione.
código pitón:
156

de s ci py . integrar import od ei nt 3 import mat pl o tli
b . py pl otasplt
4
5 # Inicialización 6 tstart = −1 7 tstop = 1 8

inc remen t = 0. 1
10 # Condición inicial en 11 z0 = [ 1 1 ]
,
12
13

15
dieciséis

, =z
( zt ) : dxdt = −z [ 1 ] dydt
19 [0]
20
21
22 dzdt = [ dxdt , dydt ]

23 devuelve dzdt
24
25
26 # Resuelve ODE
27 z = od e nt ( mydi f f 28 , z0 , t)
print ( z )
29
30 x = z [ : 31 y = z [ : ,0]
,1]
32
33

plt . parcela ( tx ) 36,
plt . parcela ( t , y ) 37
plt . title ( ' Trazado de soluciones de ecuaciones diferenciales ' ) 38 plt . etiqueta x ( '
' ) 39 plt . ylabel ( ' z ( t t) ' )
40 plt . cuadrícula ( ) 41 plt . eje
([ −1 42 plt .
mostrar ( ) , 1 , −1,5 , 1 . 5 ] )
Listado 26.5: xxx
También podemos reescribir las ecuaciones diferenciales así (¿para que sea más fácil de
entender?):
dx1
= −x2 (26.8)
dt
dx2
= x1 (26.9)
_
El código de Python se convierte entonces en:
157
Figura 26.2: Nombre de la figura

b . py pl otasplt
4
5 # Inicialización 6 tstart = −1 7 tstop = 1 8

inc remen t = 0. 1
10 # I nitialcon di ti on 11 xinit = [ 1 1 ]
,
12
13

15
dieciséis

,
( xt ) : dx1dt = −x [ 1 ] dx2dt
19 =x[0]
20
21
22 dxdt = [ dx1dt , dx2dt]

23 volver dxdt
24
25
26 # Resuelva ODE
27 x = od e nt ( mydi f f 28 , xinit , t)
print ( x )
29
30 x1 = x [ : ,0 ]
158
31 x2 = x [ : ,1]
32
33

plt . parcela ( t x1 ) 36,
plt . parcela ( t x2 ) 37,
' ) 39 plt . ylabel ( ' x ( t t) ' )
40 plt . cuadrícula ( ) 41 plt . eje
([ −1 42 plt .
mostrar ( ) , 1 , −1,5 , 1 . 5 ] )
Listado 26.6: xxx
La trama y los resultados serán los mismos.
[Fin del ejemplo]
26.4 Resolución de ecuaciones diferenciales de orden superior

Usaremos Python para resolver y graficar los resultados de la siguiente ecuación diferencial:
2
(1 + t ) ¨w + 2tw˙ + 3w = 2 (26.10)
¡Nota! No se confunda porque en este ejemplo se usa w y no x o y. Todos estos son solo
parámetros o nombres de variables.
¡Nota! ˙w = dw d 2w
y ¨w = dt2
dt
Resolveremos la ecuación diferencial en el intervalo [0,5s].
Usaremos las siguientes condiciones iniciales: w(t0) = 0 y ˙w(t0) = 1
Primero, debemos reescribir la ecuación para obtener la derivada más alta sola en el lado
izquierdo de la ecuación:
2 − 2tw˙ − 3w
w¨ = (26.11)
1+t2
¡Nota! Las ecuaciones diferenciales de orden superior deben reformularse en un sistema de

ecuaciones diferenciales de primer orden.
Hacemos el siguiente “truco”:
159
w = x1 (26.12)
w˙ = x2 (26.13)
Esto da un conjunto de ecuaciones diferenciales de primer orden:
x˙ 1 = x2 (26.14)
=
2 − 2tx2 − 3x1 1
x2 (26.15)
+t2
Ahora podemos implementar el sistema con relativa facilidad en Python.
código pitón:

b . py pl otasplt
4

inc remen t = 0. 1
10 # Condición inicial en 11 xinit = [ 0 1 ]

,
12
13

15
dieciséis
17 # Función que devuelve dx/dt 18 def mi di ff

(x , t):
19 dx1dt = x [ 1 ]
20 dx2dt = ( 2 − t x [ 1 ] − 3 x [ 0 ] ) / ( 1 + t 2)
21
22 dxdt = [ dx1dt , dx2dt]

23 devuelve dxdt
24
25
26 # Resuelva ODE
27 x = od e nt ( mydi f f 28 , xinit , t)
print ( x )
29
30 x1 = x [ : 31 x2 = x [ : ,0]
,1]
32
33

,
plt . parcela ( t x1 ) 36
,
plt . parcela ( t x2 ) 37
' ) 39 plt . yetiqueta ( ' xt
(t)')
160
40 plt. cuadrícula
( ) 41 plt . eje ( [ 0 , 5 , −1, 2 ] )
42 plt . Mostrar ( )
Listado 26.7: xxx
Figura 26.3: Ecuación diferencial de 2.orden
26.5 Ejercicios

Ejercicio 26.5.1. Población de bacterias
En esta tarea simularemos un modelo simple de una población de bacterias en un frasco.
El modelo es el siguiente:
tasa de natalidad = bx (26.16)
161
tasa de mortalidad = px2 (26.17)
Entonces la tasa total de cambio de la población de bacterias es:
x˙ = bx − px2 (26.18)

dt
Establecer b=1/hora y p=0,5 bacteriashora
Simularemos el número de bacterias en el frasco después de 1 hora, asumiendo que

inicialmente hay 100 bacterias presentes.
Utilice uno de los solucionadores de ODE en Python como se muestra en los ejemplos anteriores.
[Fin del ejercicio]
Ejercicio 26.5.2. Ecuación diferencial
x˙ = hacha + b (26.19)
1 Donde a = − T , donde T se define como la constante de tiempo del sistema. Podemos
establecer b = 1.

dt
Trace la solución para esta ecuación diferencial usando Python.
En nuestro sistema podemos establecer T = 5 y la condición inicial x0 = x(0) = 1

Cuando haya hecho eso, debe probar con diferentes valores para a y b. Asegúrate de pasar
estos valores
[Fin del ejercicio]
Ejercicio 26.5.3. Simulación de Sistema Dinámico
x˙ = −ax + bu (26.20)

dt
162
• a, b Constantes
Comience configurando a = 0,25, b = 2 y u = 1. Grafique los resultados de la simulación. Utilice uno

de los solucionadores de ODE en Python.
Explora con otros valores para a, b y u.
[Fin del ejercicio]
Ejercicio 26.5.4. Sistema MasaResorteAmortiguador
Dado un sistema ”MasaResorteAmortiguador” como se muestra en la Figura 26.4.
Figura 26.4: Sistema MasaResorteAmortiguador
El sistema se puede describir mediante la siguiente ecuación:
F(t) − cx˙(t) − kx(t) = mx¨(t) (26.21)
Donde t es el tiempo de simulación, F(t) es una fuerza externa aplicada al sistema, c es la constante
de amortiguamiento del resorte, k es la rigidez del resorte, m es una masa.
x(t) es la posición del objeto (m).
163
x˙(t) es la primera derivada de la posición, que es igual a la velocidad del objeto (m).
x¨(t) es la segunda derivada de la posición, que es igual a la aceleración del objeto (m).
Use sus habilidades aprendidas de los ejemplos anteriores para simular este sistema. Utilice uno de los
solucionadores de ODE en Python.
Debe probar con diferentes valores para F, c, k y m.
[Fin del ejercicio]
Ejercicio 26.5.5. ODA
Use uno de los solucionadores de EDO en Python para resolver y trazar los resultados de la siguiente
ecuación diferencial en el intervalo [t0, tf ]:
1
+1+t w = cos(t) 3w (26.22)
2
Donde las condiciones iniciales son t0 = 0, tf = 5, w(t0) = 1
¡Nota! w es lo mismo que ˙w que es lo mismo que dw diferentes notaciones para el

dt
mismo.
[Fin del ejercicio]
Ejercicio 26.5.6. modelo de péndulo
Use uno de los solucionadores de ODE en Python para resolver y trazar los resultados de las siguientes
ecuaciones diferenciales:
x˙ 1 = x2 (26.23)
b
X2 =−
gramo x1 x2 (26.24)
r mr2
Las ecuaciones diferenciales anteriores son un modelo simplificado de un péndulo donde m es la masa,
r es la longitud del brazo del péndulo, g es la gravedad y b es un coeficiente de fricción.
En el modelo, x1 es la distancia desde el punto de partida (que es cuando el péndulo cuelga hacia
abajo) y x2 es la velocidad.
164
Figura 26.5: Péndulo
En la figura 26.5 se muestra un péndulo.
Puede utilizar los siguientes valores: m = 8, r = 5 y b = 10 (las unidades no son tan

importantes en este caso). También puede explorar con otros valores.
Suponga que, por ejemplo, retira el péndulo del punto de partida y luego lo deja caer,
¿qué sucede entonces? Puede, por ejemplo, utilizar las condiciones iniciales x1(0) = 0,5
y x2(0) = 0.
Explicar los resultados de la simulación y verlos en relación con el mundo real. ¿Tienen
sentido los resultados de la simulación?
[Fin del ejercicio]
165
capitulo 27
Interpolación
La interpolación se utiliza para estimar puntos de datos entre dos puntos conocidos. La
técnica de interpolación más común es la interpolación lineal.
Podemos utilizar los siguientes paquetes:
numpy.interp
https://docs.scipy.org/doc/numpy/reference/generated/numpy.interp.html
scipy.interpolar https://
docs.scipy.org/doc/scipy/reference/tutorial/interpolate.html
Ejemplo 27.0.1. Ejemplo de interpolación básica

3
4x=[15y , 2, 3]
=[3 , 2, 0]
6
7 x nuevo = 2. 5
8
9 y nuevo = np. interp ( 2 . 5 , X ,y)

10
11 print ( ”Nuevo valor interpolado: ” ) 12 print ( y nuevo )
13
14 plt. plot ( x 15 plt . , y , ' o' )

mostrar ( )
Listado 27.1: Ejemplo de interpolación básica
La Figura 27.1 muestra la gráfica dada por el código.
Al usar la función de interpolación interp que es parte de la biblioteca numpy, podemos

encontrar un valor interpolado para x = 2.5 en este ejemplo. Python da los siguientes
resultados:
1 Nuevo valor interpolado: 2 1. 0
166
Figura 27.1: Ejemplo de interpolación básica
Y visto en la Figura 27.1, ese es el resultado esperado.
[Fin del ejemplo]
Ejemplo 27.0.2. Ejemplo de interpolación usando scipy.interpolate

importar mat pl o tli b . py pl otasplt 3 de s ci py
importar interpolar
4
5x = np. arreglar ( 0 1 0 ) 6 y =, np .
exp(−x / 3 . 0 ) 7 f = interpolar .
interp 1 d ( x , y )
8
9 xnuevo = np. ar an ge ( 0 10 , 9 , 0 1)
ynew = f ( xnew ) # usa la función de interpolación devuelta por ' interp 1 d
'
'o '
11 plt. plot ( x 12 plt . , y , , xnuevo , nuevo , '' )
mostrar ( )
Listado 27.2: Ejemplo de interpolación
La figura 27.2 muestra el gráfico generado por el código.
167
Figura 27.2: Ejemplo de interpolación
[Fin del ejemplo]
Ejemplo 27.0.3. Otro ejemplo de interpolación usando scipy.interpolate

importar mat pl o tli b . py pl otasplt 3 de s ci py .
interpolar importación interp 1 d
4
1 0 , num=11, punto final t=Verdadero)

5x = np. espacio lineal ( 0 6 y = np . cos (−x
,
2 / 9. 0 )
7
8 f = interp 1 d ( x , y ) #linearisdefault 9 f 2 = interp 1 d ( x kind='

cu bi c ' ) ,y,
10
11
1 0 , num=41, punto final t=Verdadero)

12 xnuevo = np. espacio lineal ( 0
13
,
' ' ' '
14 plt. plot ( x 15 ,y, o ,
xnuevo, f ( xnuevo ) , , xnuevo , f 2 (xnuevo), '' )
' c']
plt . leyenda ( [ ' data ' 16 plt . , ' lineal cúbico , ' loc=' mejor' )
,
mostrar ( )
Listado 27.3: Ejemplo de interpolación
168
La Figura 27.3 muestra el gráfico generado por el código.
En la Figura 27.3 vemos que la interpolación cúbica da buenos resultados basados en la función
coseno que usamos en este ejemplo.
[Fin del ejemplo]
27.1 Ejercicios
Ejercicio 27.1.1. Interpolación básica
Dados los siguientes datos como se muestra en la Tabla 28.2.

Encuentre el valor interpolado para x = 3.5.
Debe probar con diferentes tipos de interpolación.
169
También debe trazar los puntos de datos y los datos interpolados en el mismo gráfico.
[Fin del ejercicio]
Ejercicio 27.1.2. Interpolación

Grafique u versus T. Encuentre los datos interpolados y grafíquelos en el mismo gráfico.
Pruebe diferentes tipos de interpolación.
Discuta los resultados. ¿Qué tipo de interpolación es mejor en este caso?
¿Cuál es el valor interpolado para u=2680.78 KJ/kg?
[Fin del ejercicio]
170
Tabla 27.1: Datos

xy 0
15 1 10
2936
4250
Tabla 27.2: Datos

Temperatura T [C] Energía u [KJ/kg] 100 150
200 2506.7
250 2582.8
300 2658.1
400 2733.7
500 2810.4
2967.9
3131.6
171
capitulo 28
Ajuste de curvas Ajuste

Modelos a datos
En el capítulo anterior encontramos puntos interpolados, es decir, encontramos valores entre los
puntos medidos usando la técnica de interpolación. Sería más conveniente modelar los datos como
una función matemática y=f(x). Entonces podríamos calcular fácilmente cualquier dato que queramos
basándonos en este modelo.
Usaremos Python para crear un modelo de datos empíricos. Es importante tener en cuenta que estos
modelos son buenos solo en la región en la que hemos recopilado datos.
Estas técnicas utilizan un polinomio de grado N que se ajusta mejor a los datos Y en un sentido de
mínimos cuadrados. Un polinomio se expresa como:
n−1
+ p2x
norte
p(x) = p1x + ... + pnx + pn+1 (28.1)
donde p1, p2, p3, . . . son los coeficientes del polinomio.
Tenemos Regresión Lineal y Regresión Polinomial.
Podemos usar la función de ajuste de curvas en la biblioteca de Scipy Python para ayudarnos con el
ajuste de curvas.
https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.curve fit.html
28.1 Regresión lineal

Aquí crearemos un modelo lineal de nuestros datos en el formulario:
y = hacha + b (28.2)
172
Este es en realidad un polinomio de 1. orden.
Ejemplo 28.1.1. Ajuste de curvas

Queremos determinar la pendiente (a) y el intercepto (b) de la recta que mejor se ajusta a los datos.
Código Python:
1 de scipy. op timi ze import curvefit

2
3x=[04y= , 1 , 2 , 3 , 4 , 5]
[15 , 10, 9 , 6 , 2 , 0]
5
7 def li nearmodel ( x return a , a , b):

8 x+b
9
10 popt, pcov = curvefit (li nearmodel , X ,y)

11
12 imprimir ( popt )
Listado 28.1: Ejemplo de ajuste de curvas
La función de ajuste de curva devuelve dos elementos, que podemos extraer y pcov. El argumento
popt son los parámetros de mejor ajuste para a y b.
La variable pcov contiene la matriz de covarianza, que indica las incertidumbres y correlaciones
entre parámetros.
Del código de Python obtenemos los siguientes resultados:
[2.91428571 14.28571429]
Esto significa a = −2.91428571 yb = 14.28571429.
Basado en eso, obtenemos el siguiente modelo basado en los datos dados:
y = −2.9x + 14.3 (28.3)
A continuación, también es una buena idea trazar los datos reales en el mismo gráfico que el modelo
para comparar.
Extendemos el código de la siguiente manera:

s ci py . op timi ze import curvefit 3 import mat pl o tli b . py
pl otasplt
4
5x=[0 , 1, 2, 3, 4 , 5]
173
6y=[15 , 10, 9 , 6 , 2 , 0]
7
8
9 def li nearmodel ( x return a , a , b):

10 x+b
11
, X ,y)
12 popt, pcov = curvefit (li nearmodel
13
15
'o
16 plt. trama ( x ,y, ')
17
18
19 xstart = −1 20 xst op
= 6 21 inc remen t =
0. 1
22 xmodelo = np. ar an ge ( xstart inc rement ) , xstop ,
23
24 a = posición [ 0 ] 25
b = posición [ 1 ]
26
27 ymodelo = a xmodelo + b
28
29 plt. trazar ( xmodel , ymodel , 'b' )
Listado 28.2: Ejemplo de ajuste de curvas
[Fin del ejemplo]
28.2 Regresión polinomial

En la sección anterior usamos la regresión lineal, que es un polinomio de primer orden.
En esta sección estudiaremos polinomios de orden superior. En la regresión polinomial encontraremos
el siguiente modelo:
norte n−1
y(x) = a0x + a1x + ... + an−1x + an (28.4)
Ejemplo 28.2.1. Ajuste de curvas con regresión polinomial
Queremos encontrar modelos en el formulario:
norte n−1
y(x) = a0x + a1x + ... + an−1x + an (28.5)
174
Usaremos Python para encontrar y comparar los modelos usando diferentes órdenes del polinomio.
Investigaremos modelos de 2.order, 3.order, 4.order y 5.order.
Solo tenemos 6 puntos de datos, por lo que un modelo con un orden superior a 5 no hará
sentido.
Empezamos con un modelo de 2.orden:
y(x) = ax2 + bx2 + c (28.6)
Código Python:

de s ci py . op timi ze import curvefit 3 import mat pl o tli
b . py pl otasplt
4
175
5x=[06y=[1 , 1 , 2 , 3 , 4 , 5]
5 , 10, 9 , 6 , 2 , 0]
7
8
9 def li nearmodel ( x return a , a , b , C):

10 x 2+b x+c
11

13
15
16 plt. parcela ( x , y , 'bien' )

17
18
19 xstart = −1 20 xst op = 6 21
inc remen t = 0. 1 22
xmodel = np . ar an ge ( xstart inc
rement ) , xstop ,
23
24 a = posición [ 0 ] 25 b =
posición [ 1 ] 26 c = posición
[2]
27
28 ymodelo = a xmodelo 2+b xmodelo + c

29
30 plt. pl ot ( xmodel , ymodel , Listado 28.3: Ejemplo de 'b' )
ajuste de curvas modelo de orden 2
El código Python da los siguientes resultados:
[0.05357143 3.18214286 14.46428571]
Estos son los coeficientes a, b y c en el modelo.
Podemos cambiar el código Python para hacer un 3.order, 4.order y 5.order también.
Aquí está el código de Python para un modelo de orden 5 (basado en eso, puede crear código
fácilmente para los modelos de orden 3 y 4):

s ci py . op timi ze import curvefit 3 import mat pl o tli b . py pl
otasplt
4
5x=[06y=[1 , 1 , 2 , 3 , 4 , 5]
5 , 10, 9 , 6 , 2 , 0]
7
8
9 def li nearmodel ( x , a , b , C , d , mi , f ) :
10 volver a x 5+b x 4+c x 3+d x 2+e x+f
11

13
15
16 plt. trama ( x ,y, 'bien' )

17
18
176
19 xinicio = −1
20 xst op = 6 21
inc remen t = 0. 1
23
24 a = punto [ 0 ] 25
b = punto [ 1 ] 26 c =
punto [ 2 ] 27 d =
punto [ 3 ] 28 e =
punto [ 4 ] 29 f =
punto [ 5 ]
30
31 ymodelo = a xmodelo 5+b xmodelo 4+c xmodelo 3+d xmodelo

2+e xmodelo + f
32
33 plt. trazar ( xmodel , ymodel , 'm' )

Listado 28.4: Ejemplo de ajuste de curvas modelo de 5. orden
La Figura 28.2 muestra el gráfico generado por el código para los diferentes modelos.
Como era de esperar, los modelos de orden superior coinciden cada vez mejor con los datos.
¡Nota! El modelo de quinto orden coincide exactamente porque solo había seis puntos de datos
disponibles.
Es importante tener en cuenta que estos modelos son buenos solo en la región.
177
hemos recopilado datos.
[Fin del ejemplo]
Ejemplo 28.2.2. Regresión polinomial usando funciones polyfit y polyval
En este ejemplo usaremos las funciones NumPy polyfit y polyval.
Empezamos con un modelo de 3.order:
y(x) = ax3 + bx2 + cx + d (28.7)
código pitón:

3
4 # Datos originales 5 x = [ 0
236y=[15, 1, , , 4 , 5]
, 10, 9 , 6 , 2 , 0]
7

9
10
11 # Encontrando el Modelo 12 orden

del modelo = 3
13
14 pags = np . polyfit ( x 15 ,y, orden del modelo)

estampado ( p )
dieciséis
17 # Trazar el modelo 18 xstart

= −1 19 xstop op = 6 20
inc remen t = 0. 1
21 xmodel = np . ar an ge
( xstart inc rement ) , xstop ,
22
23 ymodelo = np. pol yv al ( p , xmodelo)

24
'r
25 plt. trazar ( xmodel , ymodel , ')
Listado 28.5: Regresión polinomial usando funciones polyfit y polyval
Obtenemos los siguientes resultados:
[0.06481481 0.53968254 4.07010582 14.65873016]
Esto significa el siguiente modelo de orden 3:
3 2
y(x) = −0.06x + 0,54x − 4,1x + 14,7 (28.8)
178
Figura 28.3: Ejemplo de interpolación: modelo de 3. orden
Extiendamos el código creando diferentes modelos con diferentes órdenes. Para una fácil
comparación de diferentes modelos en el mismo programa, podemos usar un bucle For como se
muestra en el ejemplo de código a continuación.

3
4 # Datos originales 5 x = [ 0 3 6 y = [ 1
5 , 1, 2, , 4 , 5]
, 10, 9 , 6 , 2 , 0]
7

9
10 # xvalorespara el modelo 11 xinicio = −1 12

xparada = 6 13 increm ento =
0.1

15
dieciséis
17 orden inicial = 1 18 orden final = 5
19
20 para el rango de pedido del modelo ( pedido de inicio , poner orden , 1):
21
22 # Encontrando el Modelo p =
23 np . polifit ( x ,y, orden del modelo)
179
24
25 imprimir (pag)
26
27 # Traza el modelo ymodel

28 = np . pol yv al ( p , xmodelo)
29
30 por favor parcela (xmodel, ymodel)
Listado 28.6: Regresión polinomial usando funciones polyfit y polyval
Los resultados son los mismos que se muestran en la Figura 28.2.
[Fin del ejemplo]
28.3 Ejercicios
Ejercicio 28.3.1. Interpolación

Comience graficando u versus T.
A continuación, debe crear un modelo lineal de nuestros datos en el formulario:
y = hacha + b (28.9)
Trace los datos y el modelo en el mismo gráfico para comparar.
Pruebe también otros tipos de interpolación.
Discuta los resultados. ¿Qué tipo de interpolación es mejor en este caso?
[Fin del ejercicio]
Ejercicio 28.3.2. Interpolación de polinomios

Use las funciones polyfit y polyval en Python y compare los modelos usando diferentes órdenes del
polinomio.
Use subtramas y asegúrese de agregar títulos, etc.
[Fin del ejercicio]
180
Tabla 28.1: Datos

xy 0
15 1 10
2936
4250
Tabla 28.2: Datos

Temperatura T [C] Energía u [KJ/kg] 100 150 200
250 2506.7
300 2582.8
400 2658.1
500 2733.7
2810.4
2967.9
3131.6
Tabla 28.3: Datos de ejemplo

X
10 23 20
45 30 60
40 82 50
111 60 140
70 167 80
198 90 200
100 220

Altura, h [ft] Caudal, f [ft3/s]
0 0
1,7 2,6
1,9 5 3,6
2,60 4,03 6,45
2,92 11.22
4,04 5,24 30.61
181
Ejercicio 28.3.3. Ajuste del modelo

Cree un modelo de 1. (lineal), 2. (cuadrático) y 3. orden (cúbico). ¿Cuál da el mejor modelo?
Grafique el resultado en la misma gráfica y compárelos. Agregue xlabel, ylabel, título y una leyenda
al gráfico y use diferentes estilos de línea para que el usuario pueda ver fácilmente la diferencia.
[Fin del ejercicio]
182
capitulo 29
Método de mínimos cuadrados
El método de mínimos cuadrados requiere que el modelo se configure de la siguiente forma en

función de los datos de entrada y salida:
Y = Φθ (29.1)
Dónde:
θ es un vector con los parámetros desconocidos en los que queremos encontrar los valores.
Y es un vector con medidas conocidas.
Φ es la llamada matriz de regresión. Esta matriz consta de valores conocidos.
De las matemáticas tenemos el correspondiente b = Ax donde queremos resolver un sistema de

ecuaciones lineales. En principio es lo mismo, pero como puede ver, usamos una notación
ligeramente diferente en la identificación del sistema.
Supongamos que tenemos algunos datos y queremos encontrar un modelo matemático que se ajuste
a los datos.
Podemos ilustrarlo con un simple croquis, ver Figura 29.1.
Queremos minimizar la suma de las desviaciones e1, e2, e3, ..., em
Podemos definir esto como la siguiente función de criterio:
2 2 2 2 + mi + mi + ... + mi 2 3
V (θ) = mi 1 metro
(29.2)
Encontramos el mínimo igualando la derivada a 0:
dV
=0 (29.3)
dθ
183
Figura 29.1: Principios de mínimos cuadrados
En base a esto podemos encontrar la siguiente fórmula de mínimos cuadrados:
θLS = (ΦT Φ)−1Φ T Y (29.4)
Derivaremos esta ecuación más adelante, pero primero debemos pasar por algunos ejemplos básicos.
Ejemplo 29.0.1. Método básico de mínimos cuadrados
Dado el siguiente modelo:
y(u) = au + b (29.5)
Donde los parámetros del modelo a y b son desconocidos.
Los siguientes valores se encontraron a partir de experimentos:
y(1) = 0,8 (29.6)
y(2) = 3.0 (29.7)
y(3) = 4.0 (29.8)
184
Figura 29.2: Encontrar el Mínimo de la Función de Criterios
Queremos encontrar los parámetros desconocidos del modelo a y b usando el método de mínimos
cuadrados en Python.
Primero, necesitamos ponerlo en forma de mínimos cuadrados.
Tenemos:
Y = Φθ (29.9)
Entonces obtenemos:
0.8 = a1 + b (29.10)
3.0 = a2 + b (29.11)
0.8 = a1 + b (29.12)
Esto se convierte en (Y = Φθ):
0.8 11
a
3.0 = 21 (29.13)
b
4.0 31
185
Usamos la fórmula de mínimos cuadrados:
θLS = (ΦT Φ)−1Φ T Y (29.14)
Implementemos esta fórmula con Python:

2
3 Phi = np. matriz ( [ [ 1 , 1],

4 [2 , ,
5 [3 , 1]1]])
6
7 Y = np. matriz ( [ [ 0 . 8 ] [ 3 . 0 ] [ 4 . 0 ] ] ) ,
8 ,
9
10
11
12 #Método 1 − Ax = b (No funciona en este caso) 13 #theta = np . Linalg. solve (Phi, Y) #No funciona porque es
inversa (Phi)
no existe
14
15
16 #Method 2 − u si ngb uil t −in Función de mínimos cuadrados en NumPy 17 theta = np . Linalg. lstsq (Phi, Y, rcond=Ninguno) [ 0 ]
18
19 imprimir ( theta )
20
21
22 #Método 3 − Implementación de mínimos cuadrados desde cero 23 theta = np . Linalg. en v ( Phi . transponer ( ) np . mat
( Phi ) ) Phi .
transponer ( ) Y
24
25 letra ( theta )
Listado 29.1: xxx
El código Python da lo siguiente:
1 [[1.6]
2 [0.6]]
[Fin del ejemplo]
186
capitulo 30
Diferenciación numérica
La derivada de una función y = f(x) es una medida de cómo cambia y con x.
Suponga lo siguiente (Figura 30.1):
Entonces tenemos la siguiente definición:
df(x) f(x + h) − f(x) =

lím h (30.1)
dx h→0
En Python normalmente nos ocupamos de los cálculos numéricos, por lo que nos
centraremos en encontrar un enfoque numérico y usar diferentes funciones para la
diferenciación numérica.
Una aproximación numérica a la derivada de una función y = f(x) es:
dy = ∆y =
y2 − y1
(30.2)
dx ∆x x2 − x1
Esta aproximación de la derivada corresponde a la pendiente de cada segmento de línea

que se usa para conectar cada punto de datos que existe.
Podemos usar la función NumPy diff() para implementar este enfoque numérico. A
continuación se proporcionarán varios ejemplos.
Ejemplo 30.0.1. Diferenciación numérica
Usaremos diferenciación numérica para encontrar dydx

en la siguiente función:
2y=x (30.3)
187
Figura 30.1: Diferenciación numérica
Usamos los siguientes datos como se muestra en la Tabla 30.1.
código pitón:
3
5 xstart = −2 6 xst op =
2. 1 7 inc remen t = 0.
1
9
10 y = x 2
11
12 plt. trazar ( x , y )
13
14
= 3 17 inc remen t =
1 18 x = np . ar an ge ( xstart
inc rement ) , xstop ,
188
19
20 y = x 2;
21
22 plt. trama ( x ,y, '−o' )
Listado 30.1: Diferenciación numérica
Figura 30.2: Ejemplo de diferenciación numérica básica
Sabemos que la solución exacta al problema es:
dy
= 2x (30.4)
dx
Para los valores dados en la Tabla 30.1 tenemos lo siguiente:
dy
(30.5)
dx(x = −2) = −4
dy
(30.6)
dx(x = −1) = −2
dy
(30.7)
dx(x = 0) = 0
dy
(30.8)
dx(x = 1) = 2
189
dy
(30.9)
dx(x = 2) = 4
En el siguiente fragmento de código, calcularemos los valores numéricos y los compararemos

con las soluciones exactas que se enumeran anteriormente.
código pitón:
3
5 xstart = −2 6 xst op =
3 7 inc remen t = 1

10
11 y = x 2;
12
13
14 # S olu ción Exacta / A n a lí ti c a

15
16 d yd xex ac t = 2 x
17
18 imprimir ( d yd xex ac t )
19
20 plt. plot ( x , dydx exac t , ' o' )

21
22
23

25
26 dydx num = np. diferencia ( y ) / np . diferencia(x);

27
28 imprimir (número dydx)

29
30 xinicio = −2 31 xst op
=2
32

34
35
36 plt. plot ( x , dydx num , ' o' )

dydx exacto = [4 2 0 2 4] dydx

num = [3. 1. 1. 3.]
Vemos que hay algunas diferencias entre las soluciones exactas y las soluciones numéricas.
190
Figura 30.3: Ejemplo de diferenciación numérica
Pero, ¿qué sucede si disminuimos el intervalo (h en la figura 30.1) entre 2 puntos?
En el siguiente fragmento de código, reduciremos el intervalo entre 2 puntos a h =

0,1.
código pitón:
3
= 2. 1 7 inc remen t =
0. 1
9
10 y = x 2;
11
12

14
15 d yd xex ac t = 2 x
dieciséis
17 plt. plot ( x , dydx exac t , ' o' )

18
19
20
191
22
23 dydx num = np. diferencia ( y ) / np . diferencia(x);

24
25 xinicio = −2 26 xst op
=2
27

29
30
31 plt. plot ( x , dydx num , ' o' )

Figura 30.4: Ejemplo de diferenciación numérica
Vemos que las soluciones numéricas se acercan mucho a las soluciones exactas.
Cuando h → 0, debemos esperar que las soluciones numéricas coincidan exactamente
con las soluciones exactas.
[Fin del ejemplo]
Ejercicio 30.0.1. Diferenciación numérica
Dada la siguiente ecuación:
192
2
3y=x + 2x −x+3 (30.10)
Encuentre dy analíticamente (utilice "bolígrafo y papel").
dx
Defina un vector x de 5 a +5 y use la función diff para aproximar la derivada y con respecto
a x (∆y/∆x).
Compare los datos en una matriz 2D y/o grafique el valor exacto de la aproximación y el
dx
dy en el mismo gráfico.
Aumente el número de puntos de datos para ver si hay alguna diferencia.
Haga lo mismo para las siguientes funciones:
y = sen(x) (30.11)
y=x 5−1 (30.12)
[Fin del ejercicio]
30.1 Diferenciación en polinomios

n−1
(30.13)
norte
p(x) = p1x + p2x + ... + pnx + pn+1
La diferenciación del polinomio p(x) será:
dp(x) n−2
= p1nxn−1 + p2(n − 1)x dx + ... + pn (30.14)
Realizar la diferenciación de polinomios en fácil porque solo necesita usar las reglas básicas
de diferenciación:
n−1
f(x) = axn → f (x) = un ∙ norte ∙ x (30.15)
f(x) = C → f (x) = 0 (30.16)
Donde C es una constante.
193
Ejemplos:
3 2
f(x) = 4x → f(x) = 12x (30.17)
f(x) = 5 → f(x) = 0 (30.18)
Fácilmente podríamos hacer una función general en Python que pudiera manejar esto. Si
no quiere hacer eso, puede usar la función polyder() NumPy.
Ejemplo 30.1.1. Diferenciación en Polinomios
Dado el polinomio
3
p(x) = 2 + x (30.19)
Podemos reescribir el polinomio así:
3+0∙x 2 +0∙x+2
p(x) = 1 ∙ x (30.20)
2
Sabemos que: p(x) = 3x
El polinomio se define en Python como:

2
3p=[1 , 0, 0, 2]
4
5 dpdx = np. pól yder ( p )

6
7 imprimir (dpdx)
Listado 30.4: Diferenciación en polinomios
Los resultados:
dpdx = [3 0 0]
Lo cual es correcto, porque
2 + 0 ∙ 2x + 0 ∙ 1
p(x) = 3 ∙ x (30.21)
con los coeficientes: p1 = 3, p2 = 0, p3 = 0 Y esto

se escribe como una matriz [3 0 0] en Python.
El código de Python también se puede escribir así:
194

2
3p = np. poli1d ( [ 1 4 imprimir , 0 , 0 , 2 ] )

(p)
5
6 dpdx = np. pól yder ( p ) 7 imprimir

( dpdx )
Listado 30.5: Diferenciación en polinomios
Aquí hemos usado la función poly1d() en la biblioteca NumPy. ¡Asegúrate de probar este
ejemplo!
[Fin del ejemplo]
Ejercicio 30.1.1. Diferenciación en Polinomios
Considere la siguiente ecuación:
2 −x+3
y = x 3 + 2x (30.22)
Usa la diferenciación en el polinomio para encontrar dy

dx
[Fin del ejercicio]
Ejercicio 30.1.2. Diferenciación en Polinomios
Encuentre la derivada del producto:
2 2
y = (3x + 6x + 9)(x + 3x) (30.23)
es decir, necesitas encontrar dy

dx
[Fin del ejercicio]
195

xy 2 4
1 1 0
011
24
196
capitulo 31
Integracion numerica
La integral de una función f(x) se denota como:
f(x)dx (31.1)
a
Una integral se puede ver como el área bajo una curva.
Dado y = f(x), la aproximación del Área (A) bajo la curva se puede encontrar dividiendo el área
en rectángulos y luego sumando la contribución de todos los rectángulos:
n−1
(xi+1 − xi) ∙ (yi+1 + yi)/2 (31.2)

yo=1
Esto se conoce como la regla del trapezoide.
Aproximamos la integral usando n trapecios formados usando segmentos de línea recta entre
los puntos (xi−1, yi−1) y (xi , yi) para 1 ≤ i ≤ n como se muestra en la figura 31.1.
El área de un trapezoide se obtiene sumando el área de un rectángulo y un triángulo (31.3):
1 (y0 + y1)∆x
A = y0∆x + (y1 − y0)∆x = 2 2 (31.3)
Ejemplo 31.0.1. Ejemplo de integral básica
Dada la función:
2y=x (31.4)
197
Figura 31.1: Enfoque Integral Numérico
Figura 31.2: El área de un trapecio
Sabemos que la solución exacta es:
b 3
un
x 2 dx = (31.5)
a
3
La integral de 0 a 1 es:
1
1 2 dx = ≈ 0,3333 x 3 (31.6)
0
Usaremos la regla del trapezoide y la función diff en MATLAB para resolver la integral numérica de x
2 de 0 a 1.
El código de Python implementa la fórmula conocida como regla trapezoidal:
b norte
yo = 1 f(x)dx ≈ 2 (f(xi) + f(xi+1)) ∙ (xi − xi−1) (31.7)

i=1
a
198
Suponiendo que usamos N subintervalos para calcular la aproximación, obtenemos:
∆x
norte
un = (f(xi) + f(xi+1)) (31.8)

2
yo=1
Dónde
segundo
− un ∆x = (31.9)
norte
El código Python para esto es:

3
4 un = 0 5
segundo = 1
6 norte = 10
7
8
9 x = np. espacio lineal (un , segundo, N+1)

10
11 y = x 2;
12
13 yderecha = y [ 1 : ] 14 yizquierda =
y [: −1]
15
dieciséis
17 # T r apez oid Regla 18 dx

= ( segundo − un ) /N 19
UN = ( dx / 2 ) np . suma( yderecha + yizquierda)
20
21 impresión (A)
22
23
24 plt. parcela ( x , y ) 25 plt . xlim

, 31.1: Regla trapezoidal
( [ 0 1 ] ) ; por favor ylim ( [ 0 Listado , 1]);
= 0,3350000000000001
Lo cual es una buena aproximación cuando sabemos que la respuesta exacta es A = 13
[Fin del ejemplo]
En el ejemplo anterior, implementamos nuestra propia integración desde cero. Ese siempre es un buen
enfoque porque entonces llegamos a conocer las matemáticas detrás.
Pero, por lo general, desea utilizar una función predefinida que haga el trabajo por usted.
El subpaquete SciPy scipy.integrate contiene varias funciones para aproximar numéricamente integrales
definidas.
199
Eche un vistazo más de cerca a la documentación en prder para obtener una descripción general de
las diferentes funciones que están disponibles.
https://docs.scipy.org/doc/scipy/reference/integrate.htmlmodulescipy.integrate
Ejemplo 31.0.2. Integración usando la función cuádruple
En este ejemplo, usaremos la función cuádruple en el subpaquete SciPy scipy.integrate.
Consulte lo siguiente para obtener información detallada sobre la función cuádruple:

https://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.quad.htmlscipy.integrate.quad
código pitón:
1 de s ci py importar integrar
2
3 un = 0 4
segundo = 1
6 def y ( x ) :
7 vuelve x 2
8
9 I = integrar. cuádruple (y,

a , b)
10
11 imprimir ( yo )
Listado 31.2: xxx
Yo = (0.33333333333333337, 3.700743415417189e15)
Lo cual es una buena aproximación cuando sabemos que la respuesta exacta es A = 13
El segundo resultado es una estimación del error absoluto en el resultado dado.
[Fin del ejemplo]
Ejemplo 31.0.3. Integración usando la función trapz incorporada
En este ejemplo, usaremos la función trapz integrada en SciPy.
Consulte lo siguiente para obtener información detallada sobre la función trapz: https://
docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.trapz.htmlscipy.integrate.trapz
código pitón:

2
3 un = 0 4
segundo = 1
5 norte = 10 6 dx
= ( segundo − un ) / norte
200
8 x = np. espacio lineal (un , segundo, N+1)

9
10 y = x 2;
11
12 I = np. trampa (y,

X , dx)
13
14 imprimir ( yo )
Listado 31.3: xxx
I = 0.33499999999999996 Lo
cual es una buena aproximación cuando sabemos que la respuesta exacta es A = 13
[Fin del ejemplo]
Ejercicio 31.0.1. Integracion numerica
Use algunas de las aproximaciones integrales que se muestran en los ejemplos anteriores
en la siguiente ecuación:
2
3y=x + 2x −x+3 (31.10)
Encuentra la integral de y con respecto a x, evaluada de 1 a 1
Compara los diferentes métodos.
También debe encontrar la solución exacta usando "bolígrafo y papel" para comparar.
Compara el resultado con la solución exacta.
[Fin del ejercicio]
Ejercicio 31.0.2. Integración Numérica 2
Use algunas de las aproximaciones integrales que se muestran en los ejemplos anteriores
en la siguiente ecuación:
y = sen(x) (31.11)
[Fin del ejercicio]
201
Ejercicio 31.0.3. Integración Numérica 3
Use algunas de las aproximaciones integrales que se muestran en los ejemplos anteriores en la
siguiente ecuación:
5y=x −1 (31.12)
[Fin del ejercicio]
31.1 Integración en Polinomios

n−1
p(x) = p1x + p2x + ... + pnx + pn+1 (31.13)
norte
En Python podemos usar la función polyint para realizar la integración en polinomios. Esta
función funciona de la misma manera que la función polyder que realiza la diferenciación de
polinomios.
Ejercicio 31.1.1. Integración en Polinomios
Dada la siguiente ecuación:
2
y = x 3 + 2x −x+3 (31.14)
Encuentre la integral para esta función usando polyint.
También debe trazar la función en el intervalo [a,b] donde elige diferentes valores para a y b.
También debe encontrar la integral para estos intervalos.
[Fin del ejercicio]
202
31.2 Ejercicios
A continuación encontrará diferentes ejercicios a su propio ritmo que debe realizar y resolver por
su cuenta. ¡La única forma de aprender Python es hacer muchos ejercicios!
Ejercicio 31.2.1. Cilindro de pistón
Dado el siguiente cilindro de pistón que se muestra en la figura 31.3.
Figura 31.3: Cilindro de pistón
Encuentre el trabajo (W) producido en un dispositivo de cilindro de pistón resolviendo la siguiente

ecuación:
V2
W= P dV (31.15)
V1
Suponga que se aplica el mínimo del gas ideal:
VP = nRT (31.16)
Dónde:
• P = Presión
203
• V = Volumen [m3 ]
• n = número de moles [kmol]
• R = constante universal de los gases [8,314 kJ/kmolK]
• T = Temperatura, [K]
También suponemos que el pistón contiene 1 mol de gas a 300 K y que la temperatura es
constante durante el proceso. V1 = 1m3 , V2 = 5m3
Implemente la integral utilizando algunos de los diferentes métodos que se muestran en los
ejemplos anteriores. También debe intentar encontrar la solución exacta usando "lápiz y
papel" para comparar.
[Fin del ejercicio]
204
capitulo 32
Mejoramiento
La optimización es importante en las aplicaciones de matemáticas, control y simulación.

La optimización se basa en encontrar el mínimo de una función de criterio dada.
Ejemplo 32.0.1. Optimización básica
Dada la siguiente función:
2
f(x) = x + 2x + 1 (32.1)
Comenzamos graficando la función:

3
4 xmín = −5 5 xmáx = 5
6 dx = 0. 1
8 N = int ( ( xmáx − xmín ) /dx )

9
10 x = np. linspace ( xmin 11 #x = np . ar an ge , xmáx , N+1)

( xmin , , dx ) #Implementación al terna ti va xmax+dx
12
13 y = x 2+2 x+1;
14
15
16 plt. parcela ( x , y ) 17 plt . xlim

( [ xmín , xmáx])
Listado 32.1: Optimización en Python
Usaremos fminbound para encontrar el mínimo de la función.
código pitón:
1 de s ci py import op timi ze
2
205
Figura 32.1: Ejemplo de optimización
3 xmín = −5 4 xmáx = 5
7 def y ( x ) :
8 vuelve x 2+2 x+1
9
10
xmín , xmáx)
11 x min = optimizar . finminbound ( y ,
12
13 impresiones (x min)
Listado 32.2: xxx
El resultado se convierte en:
xmín = 1.0
Vemos que esta es la respuesta correcta según nuestra gráfica en la Figura 32.1.
[Fin del ejemplo]
Ejercicio 32.0.1. Haz tu propia función de Minimización
2
f(x) = x + 2x + 1 (32.2)
206
Implemente una función de minimización básica desde cero utilizando un bucle For o un bucle
While.
Asegúrese de probar la función y ver si obtiene la misma respuesta que en el ejemplo anterior.
[Fin del ejercicio]
Otras funciones de optimización en Python:
scipy.optimizar.fmin
scipy.optimize.minimize escalar
scipy.optimizar.minimizar
Ejercicio 32.0.2. Funciones de optimización en Python
2 + 2x + 1
f(x) = x (32.3)
Pruebe las diferentes funciones de optimización (búsqueda del mínimo):
Compara los resultados.
[Fin del ejercicio]
Ejercicio 32.0.3. Mejoramiento
f(x) = x 3 − 4x (32.4)
Pruebe las diferentes funciones de optimización (búsqueda del mínimo):
scipyoptimize.fminbound
207
Compara los resultados. También debería trazar la función.
[Fin del ejercicio]
Ejercicio 32.0.4. Mínimo para función con 2 variables
f(x, y) = 2(x − 1)2 + x − 2 + (y − 2)2 + y (32.5)
Representa gráficamente la función y encuentra el mínimo.
[Fin del ejercicio]
Ejercicio 32.0.5. Optimización Función Banana de Rosenbrock
2 2 2
f(x, y) = (1 − x) + 100(y − x ) (32.6)
Esta función se conoce como función banana de Rosenbrock.
Representa gráficamente la función y encuentra el mínimo.
[Fin del ejercicio]
208
Parte VI
Usando Python para

Simulaciones
209
capitulo 33
Introducción a las simulaciones
Python es muy poderoso para realizar simulaciones, como simular sistemas dinámicos, es decir, resolver
ecuaciones diferenciales numéricas.
Consulte los siguientes capítulos para obtener muchos ejemplos prácticos.
210
capitulo 34
Ecuaciones diferenciales
34.1 Introducción a las ecuaciones diferenciales

Una ecuación diferencial es una ecuación matemática que relaciona alguna función con sus
derivadas.
En las aplicaciones, las funciones generalmente representan cantidades físicas, las derivadas
representan sus tasas de cambio y la ecuación diferencial define una relación entre las dos.
Debido a que tales relaciones son extremadamente comunes, las ecuaciones diferenciales
desempeñan un papel destacado en muchas disciplinas, incluidas la ingeniería, la física, la
economía y la biología.
Por lo general, queremos resolver ecuaciones diferenciales ordinarias (EDO) de la forma:
dy
= f(t, y), y(t0) = y0 dt (34.1)
¡Nota! Se utiliza una notación diferente: dy = y'= ˙y

dt
Este documento utilizará estas diferentes notaciones indistintamente.
Ejemplo 34.1.1. Ejemplo de Sistemas Dinámicos
x˙ = −ax + bu (34.2)

dt
• a, b Constantes
211
[Fin del ejemplo]
Con Python have podemos resolver estas ecuaciones diferenciales en muchos diferentes
maneras.
Podemos usar los llamados solucionadores ODE o podemos hacer una versión discreta de las
ecuaciones diferenciales usando métodos de discretización como Euler, etc.
Con los solucionadores de EDO, Python puede resolver estas ecuaciones numéricamente. Las
ecuaciones diferenciales de orden superior deben reformularse en un sistema de ecuaciones
diferenciales de primer orden.
En el capítulo 35 simularemos (resolveremos y graficaremos los resultados) tales ecuaciones

diferenciales numéricamente usando la discretización de Euler.
212
capitulo 35
Sistemas discretos
Cuando tratamos con computadoras, necesitamos tratar con sistemas discretos.
35.1 Discretización
A veces queremos o necesitamos discretizar un sistema continuo y luego simularlo en Python. Cuando
se trata de simulación por computadora, necesitamos crear una versión discreta de nuestro sistema.
Esto significa que necesitamos hacer una versión discreta de nuestras ecuaciones diferenciales
continuas. La interpolación, el ajuste de curvas, etc. también se basan en un conjunto de valores
discretos (puntos de datos o medidas). Lo mismo con la Diferenciación Numérica y la Integración
Numérica, etc.
A continuación vemos una señal continua frente a la señal discreta para un sistema dado con un
intervalo de tiempo discreto T s = 0,1 s.
Figura 35.1: Discretización
Para discretizar un modelo continuo existen muchos métodos diferentes para

usar.
Un método de discretización simple es el método de Euler Forward:
x(k + 1) − x(k) x˙ =
(35.1)
ts
213
Ts es el tiempo de muestreo
Figura 35.2: Métodos de discretización de Euler
Existen muchos otros métodos de discretización, como "Euler hacia atrás", Zero Order Hold (ZOH),
el método de Tustin, etc.
Ejemplo 35.1.1. Simulación de Sistema Discreto
x˙ = −ax + bu (35.2)
dx
¡Nota! ˙x es lo mismo que dt
• a, b Constantes
Comenzamos con encontrar la ecuación diferencial discreta.
Podemos usar, por ejemplo, la aproximación de Euler:
x˙ ≈
xk+1 − xk
(35.3)
ts
Ts Intervalo de muestreo
Entonces obtenemos:
xk+1 − xk =
−axk + buk (35.4)
ts
214
Esto da la siguiente ecuación diferencial discreta:
xk+1 = (1 − Tsa)xk + Tsbuk (35.5)
Ahora estamos listos para simular el sistema.
Establecemos a=0.25, b=2 y u=1 (Puedes explorar con otros valores por tu cuenta)
Comenzamos creando el Python Script para la simulación de este sistema:
1 # Sim ul a ci onofdiscrete model 2 import numpy

as np 3 import mat pl o tli b . py
pl otasplt
4
5 # Parámetros del modelo 6 a = 0. 2 5 7 b = 2
9 # Parámetros de simulación 10 Ts =
0. 1 11 Tstop =
30 12 uk = 1 #
Respuesta de paso 13 xk = 0 14 N = int
( Tstop /Ts )
# Longitud de simulación 15 data = [ ] 16 datos . agregar (xk)
17
18
19 # Sim ul a ti on 20
for k inr an ge (N) : xk1 = ( 1 −
21 a Ts ) xk + Ts b uk xk = xk1 data . agregar (xk1)
22
23
24
25
26 # Trazar los resultados de la sim ul a ción 27 t = np . arreglar ( 0 Ts )

, Tstop+Ts ,
28
29 plt. parcela ( t , datos )

30
31 # Formatear la apariencia del Pl ot 32 plt . title ( ' Simulación de

dxdt = −ax + bu ' ) 33 plt . xlabel ( ' t [ s ] ' ) 34 plt . ylabel ( ' ' ) 35 plt .
plt . mostrar ( ) X
, 30, 0, 8])
Listado 35.1: Simulación de un sistema dinámico discreto en Python
La simulación da los resultados que se muestran en la Figura 35.3.
También echemos un vistazo al Explorador de variables como se muestra en la Figura 35.4.
215
Figura 35.3: Simulación de Sistema Discreto usando Python
Aquí se presenta una solución alternativa:
1 # Sim ul a ci onofdiscrete model 2 import

numpy as np 3 import mat pl
o tli b . py pl otasplt
4
9 # Parámetros de simulación 10 Ts
= 0. 1 # Tiempo de muestreo 11 Tstop
= 30 # Fin del tiempo de simulación 12 uk = 1 #
Respuesta de paso 13 N = int (Tstop /
Ts) # Sim ul a ti onlongitud 14 x = np . ceros (N+2) #
Inicialización del vector x 15 x [ 0 ] = 0
dieciséis
17
for k inr an ge (N+1) : x [ k+1] =
20 ( 1 − a Ts ) x [ k ] + Ts b uk
21
22
23 # Trazar los resultados de la sim ul a ción

24 t = np . a r ga je ( 0 Ts ) #C re a la S erie T iempo , Tstop+2 Ts ,
25
26 plt. parcela ( t ,X)

27
28 # Formatear la apariencia del Pl ot 29 plt . title ( ' Simulación

de dxdt = −ax + bu ' ) 30 plt . xlabel ( ' t [ s ] ' ) 31 plt . yetiqueta ( '
')
X
216
Figura 35.4: Explorador de variables para el ejemplo de simulación discreta
32 plt. cuadrícula
( ) 33 plt . eje ( [ 0 , 3 0 , 0 , 8 ] )
34 plt . mostrar ( )
Esto da, por supuesto, los mismos resultados y la misma trama.
Debe probar ambos ejemplos y luego decidir cuál prefiere. Supongo que también hay
muchas otras formas de hacerlo.
[Fin del ejemplo]
35.2 Ejercicios
Ejercicio 35.2.1. Simulación de Población de Bacterias
tasa de natalidad = bx (35.6)
tasa de mortalidad = px2 (35.7)
217
x˙ = bx − px2 (35.8)
Simularemos el número de bacterias en el frasco después de 1 hora, asumiendo que inicialmente

hay 100 bacterias presentes.
Encuentre el modelo discreto usando el método Euler Forward a mano e implemente y simule
el sistema en Python usando un For Loop.
[Fin del ejemplo]
Ejercicio 35.2.2. Simulación con 2 variables
Dado el siguiente sistema:
dx1
= −x2 (35.9)
_
dx2
= x1 (35.10)
_
Encuentre el sistema discreto y simule el sistema discreto en MATLAB. Resuelva las ecuaciones,
por ejemplo, en el lapso de tiempo [1 1] con valores iniciales [1, 1].
[Fin del ejercicio]
218
capitulo 36
Simulaciones en tiempo real
36.1 Introducción
Por lo general, en una simulación, ejecuta la simulación en un bucle for. Cuando haya
terminado con la simulación, grafique los datos.
Repetimos un ejemplo básico de simulación del capítulo 35.
Ejemplo 36.1.1. Simulación básica de sistema discreto
Simularemos el sistema discreto dado de la siguiente manera:
xk+1 = (1 − Tsa)xk + Tsbuk (36.1)
Establecemos a=0.25, b=2 y u=1 (Puedes explorar con otros valores por tu cuenta)
Comenzamos creando el Python Script para la simulación de este sistema:
1 # Sim ul a ci onofdiscrete model 2 import

4
5 # Parámetros del modelo 6 a = 0.

257b=2
9 # Parámetros de simulación
10 Ts = 0. 1 11
Tstop = 30 12 uk
= 1 # Respuesta de paso 13 xk = 0
14 N = int
( Tstop /Ts ) # Longitud de sim ul a ción 15 datos = [ ] 16
datos . agregar
(xk)
17
18
for k inr an ge (N) : xk1 = ( 1
21 − a Ts ) xk + Ts b uk
219
22 xk = xk1
23 datos . agregar (xk1)
24
25
26 # Trazar los resultados de la sim ul a ción 27 t =

np . organizar ( 0 , Tstop+Ts ,Ts )
28
29 plt. parcela ( t , datos )

30
31 # Formatear la apariencia del Pl ot 32 plt . title ( ' Simulación de

dxdt = −ax + bu ' ) 33 plt . xlabel ( ' t [ s ] ' ) 34 plt . ylabel ( ' ' ) 35 plt .
plt . mostrar ( ) X
, 30, 0, 8])
La simulación da los resultados que se muestran en la Figura 36.1.
Figura 36.1: Simulación de Sistema Discreto usando Python
Como puede ver en el código y cuando se ejecuta el código, los resultados de la simulación
se trazan en una sola operación una vez finalizada la simulación, es decir, después del bucle
for.
[Fin del ejemplo]
A veces queremos trazar un valor a la vez dentro del bucle, las llamadas "simulaciones en
tiempo real". Ese también es el caso si queremos trazar datos de un sensor o un proceso
real.
220
36.2 Introducción al trazado en tiempo real

También puede usar matplotlib para el trazado en tiempo real.
Ejemplo 36.2.1. Introducción al trazado en tiempo real
Aquí hay un ejemplo básico:

3
4 plt. eje ( [ 0 , 10, 0 , 1])

5
6 d el ay = 1 #Segundos
7
8 para i en rango ( 1 0 ) : y = np .
9 aleatorio . aleatorio ( ) plt . dispersión
10 ( i , y ) plt . pausa (d el ay)
11
12
Listado 36.2: Trazado en tiempo real en Python
Obtenemos la siguiente gráfica como se muestra en la Figura 37.1.
Figura 36.2: Trazado en tiempo real con Python
No puede ver el comportamiento real de la gráfica mirando la figura 37.1, por lo que
221
necesita ejecutar el programa Python usted mismo.
Si ejecuta el código, verá que el gráfico se actualiza con un nuevo valor cada segundo, como
se especifica en el código.
[Fin del ejemplo]
¡Nota! Si usa Anaconda y Spider, normalmente necesita cambiar la configuración de cómo se

muestran los gráficos en Spyder.
Seleccione Preferencias en el menú, luego la consola de IPython en la lista de categorías a la

izquierda, luego la pestaña Gráficos en la parte superior y cambie el backend de Gráficos de
En línea a, por ejemplo, Automático o Qt. Consulte la Figura 37.2.
Figura 36.3: Cambiar cómo se muestran los gráficos en el editor de Spyder
Ejemplo 36.2.2. Simulación en tiempo real de un sistema discreto
Cambiemos el ejemplo de simulación discreta presentado al comienzo de este capítulo:
1 # Simulación en tiempo real de un sistema discreto 2 import

numpy as np 3 import mat
plot o tli b . py pl otasplt
4
5 # Parámetros del modelo 6 a = 0.

257b=2
= 0. 1 11 Tstop
= 30 12 uk = 1 #
Respuesta de paso
222
13 xk = 0 14
N = int ( Tstop /Ts ) # Longitud de sim ul a ción 15 data = [ ]
16 data . agregar
(xk)
17
18 plt. eje ( [ 0 , N, 0 , 10])

19
20 para k inr an ge (N) : xk1 =

21 ( 1 − a Ts ) xk + Ts b uk xk = xk1 data .
22 agregar
23 (xk1)
24
25 por favor dispersión , xk1)

26 ( kplt . pausa ( Ts )
27
Listado 36.3: Simulación en tiempo real de un sistema dinámico discreto en Python
La figura 36.4 muestra el gráfico en tiempo real de este ejemplo.
Figura 36.4: Simulación en tiempo real de un sistema discreto
No puede ver el comportamiento real de la gráfica mirando la Figura 36.4, por lo que necesita
ejecutar el programa Python usted mismo.
Si ejecuta el código, verá que el gráfico se actualiza con un nuevo valor cada segundo,
como se especifica en el código.
En este ejemplo, hemos bloqueado la escala utilizando el método del eje. Si eliminamos o
comentamos la línea ”plt.axis([0, N, 0, 10])”, obtenemos un gráfico que escala
automáticamente el eje x y el eje y. Lo mejor depende de si conoce la duración de la
simulación desde el principio y conoce el valor mínimo y máximo de los resultados de la
simulación.
223
La Figura 36.5 muestra el gráfico en tiempo real con escalado automático después de 30
iteraciones para este ejemplo. No puede ver el comportamiento real de la gráfica mirando la
Figura 36.5, por lo que necesita ejecutar el programa Python usted mismo.
Figura 36.5: Simulación en tiempo real de un sistema discreto con escalado automático
Los ejemplos que se muestran muestran el paso de tiempo discreto k en el eje x. Por lo
general, queremos mostrar el tiempo continuo t en su lugar. Algunos pequeños ajustes a los
ejemplos lo hacen posible. Vea el código a continuación:
numpy as np 3 import mat
plot o tli b . py pl otasplt
4
5 # Parámetros del modelo 6 a

= 0. 2 5 7 b = 2
10 Ts = 0. 1
11 Tstop = 30 12
uk = 1 # Respuesta de paso 13 xk
= 0 14 ysc
al emax = 10 15 N = int
( Tstop /Ts ) # Sim ul a tion length 16 data = [ ] 17 data .
agregar (xk)
224
18
19 plt. eje ( [ 0 , N Ts , 0 , ysc al emax ] )

20

23 agregar
24 (xk1)
25
26 t = Ts k
27

29 ( tplt . pausa ( Ts )
30
La figura 36.6 muestra el gráfico final de este ejemplo. No puede ver el comportamiento real
de la gráfica mirando la Figura 36.6, por lo que necesita ejecutar el programa Python usted
mismo.
Figura 36.6: Simulación en tiempo real de un sistema discreto
También podemos agregar algún formato con respecto a la apariencia de la trama (xlabel,
ylabel, título, etc.). El ejemplo de código final se muestra a continuación.
225

numpy as np 3 import mat plot
4
= 0. 1 11 Tstop
= 30 12 uk = 1 #
Respuesta de paso 13 xk = 0 14 ysc
al emax =
10 15 N = int ( Tstop /Ts ) #
Longitud de simulación 16 datos = [ ] 17 datos . agregar (xk)
18
19
20 # Formatear la apariencia del Pl ot 21 plt . title ( ' Simulación

de dxdt = −ax + bu ' ) 22 plt . xlabel ( ' t [ s ] ' ) 23 plt . ylabel ( ' ' ) 24
plt . red ( )
X
25
26 plt. eje ( [ 0 , N Ts , 0 , ysc al emax ] )

27

30 agregar
31 (xk1)
32
33 t = Ts k
34

36 ( tplt . pausa ( Ts )
37
Ejecute el ejemplo y observe la diferencia.
[Fin del ejemplo]
36.3 Trazado en tiempo real con animación

Para gráficos en tiempo real más avanzados, debemos usar el módulo de animación en la
biblioteca matplotlib (matplotlib.animation).
Para crear un gráfico en tiempo real, necesitamos usar el módulo de animación en matplotlib.
Configuramos la figura y los ejes de la forma habitual, pero dibujamos directamente en los
ejes, ax, cuando queremos crear un nuevo cuadro en la animación.
Necesitamos usar la función FuncAnimation:
226
1 a ni = anim a ti on . FuncAnimation ( fig , intervalo =1000) animar , fargs =(xs , ys ) ,
FuncAnimation es una función especial dentro del módulo de animación que nos permite
automatizar la actualización del gráfico. Le pasamos a FuncAnimation() un identificador de la
figura que queremos dibujar, fig, así como el nombre de una función que debe llamarse a
intervalos regulares. Llamamos a esta función animate() y se define justo encima de nuestra
llamada a FuncAnimation().
Todavía en los parámetros de FuncAnimation(), establecemos fargs, que son los argumentos
que queremos pasar a nuestra función de animación (ya que no estamos llamando a animate()
directamente desde nuestro propio código). Luego, establecemos el intervalo, que es el tiempo
que debemos esperar entre las llamadas a animate() (en milisegundos).
Nota: Como argumento para FuncAnimation, observe que animate no tiene paréntesis. Esto es
pasar una referencia a la función y no el resultado de esa función. Si accidentalmente agrega
paréntesis para animar aquí, animar se llamará inmediatamente (solo una vez) y es probable
que obtenga un error
Ejemplo 36.3.1. Trazado en tiempo real con animación
A continuación, encontrará el código de Python para un ejemplo básico en el que usamos el

módulo de animación en matplotlib.
En el ejemplo, actualizamos el gráfico cada segundo configurando el intervalo = 1000 ms como

argumento de entrada para la función FuncAnaimation.
1 importar fecha y hora como dt 2

importar numpy como np 3
importar mat pl o tli b . py pl otasplt 4 import mat pl o tli
b . anim a ción como anim a ción
5
6 # C re a la figura para el trazado 7 fig = plt . cifra ( ) 8 hacha = fig .
gráfico de adición ( 1 9 xs = [ ] 10 ys = [ ]
, 1 , 1)
11
12
13 # Esta función se llama periódicamente de FuncAnimation 14 def animate ( i

, xs , si ):
15
dieciséis
temp c = ronda ( np . aleatorio . aleatorio ( ) , 2)
17
18 # Agregue x y ytolistas xs. append

19 ( dt . date time . now ( ) . strftime ( '%H:%M:%S.% f ' ) ) ys . agregar (temp c)
20
21
22 # Limite tx y yliststo 20 i elemento s xs = xs [ −2 0:] ys =

23 ys [ −2 0:]
24
25
26 # Dibuja x e ylistas ax. claro ( )

27 hacha . parcela
28 ( xs , ys )
227
29
30 # Formatear plot
31 plt . xticks (rotación =45, ha=' derecha' ) plt.
32 subplotsadjust (inferior = 0.30) plt. título ( ' ' )
33 Datos de temperatura
34 plt. ylabel ( 'Temperatura (grados C)' )
35
36 # Configure la función pl ottocall animate ( ) periódicamente 37 a ni = anim a c ión . FuncAnimation (fig, intervalo = 1000) 38 plt.
espectáculo ( )
animar , fargs =(xs , ys ) ,
Listado 36.6: Trazado en tiempo real con animación
La figura 37.3 muestra el gráfico final de este ejemplo. No puede ver el comportamiento
real de la gráfica mirando la Figura 37.3, por lo que necesita ejecutar el programa
Python usted mismo.
Figura 36.7: Trazado en tiempo real con animación
[Fin del ejemplo]
Ejemplo 36.3.2. Simulaciones discretas con animación
Apliquemos esta técnica en nuestro sistema discreto.
Código Python:
228

importar mat pl o tli b . py pl otasplt 4 import mat pl o
tli b . anima ción como anima ción 5 # Crea una figura para trazar 6
fig = plt . cifra ( ) 7 hacha = fig . gráfico de
adición ( 1 8 xs = [ ] 9 ys = [ ]
, 1 , 1)
10
11 xk = 0 # Valor inicial forx

12
13 # Esta función se llama periódicamente de FuncAnimation 14 def sim ul a c ión ( i

, xs , si ):
15
dieciséis
# Parámetros del modelo a =
17 0. 2 5 b = 2
18
19
20 # Parámetros de simulación Ts = 0. 1
21 # Tiempo de muestreo uk = 1 #
22 Respuesta de paso global xk #
23 Como cambiamos xdentro de una función, definimos una variable global
24
25 # Modelo de Sistema D iscreto xk1 = ( 1 −

26 a Ts ) xk + Ts b uk xk = xk1
27
28

30 ( dt . date time . now ( ) . strftime ( '%H:%M:%S.% f ' ) ) ys . agregar (xk1)
31
32
33 N = 60 # Limita tx y ylistas a N i elemento s xs = xs[−N : ] ys =

34 ys[−N : ]
35
36

38 hacha . parcela
39 ( xs , ys )
40
41 # Formatear plot plt .

42 xticks (rotación =45, ha=' derecha' ) plt. subplotsadjust
43 (inferior = 0.30) plt. title ( ' Simulación de dxdt = −ax
44 + bu ' ) plt . xlabel ( ' plt . ylabel ( ' plt . g ri d ( )
45 t [s]')
X
46 ')
47
48
49 # Configure la función pl ottocall animate ( ) periódicamente 50 a ni = anim a c ión . FuncAnimation (fig, intervalo =100) 51 plt.
espectáculo ( ) sim ul a ción , fargs =(xs , ys ) ,
Listado 36.7: Simulación en tiempo real de un sistema dinámico discreto con animación
La figura 36.8 muestra el gráfico final de este ejemplo. No puede ver el comportamiento
real de la gráfica mirando la Figura 36.8, por lo que necesita ejecutar el programa
Python usted mismo.
229
Figura 36.8: Simulación en tiempo real de un sistema dinámico discreto con animación
[Fin del ejemplo]
36.3.1 Acelerando la animación de la trama

Borrar un gráfico y volver a dibujarlo todo puede ser un proceso lento en términos de tiempo
de computadora. Para remediarlo, vamos a utilizar un truco conocido como blitting.
Blitting es una antigua técnica de gráficos por computadora en la que varios mapas de bits
gráficos se combinan en uno. De esta manera, solo era necesario actualizar uno a la vez,
evitando que la computadora tuviera que volver a dibujar toda la escena cada vez.
Matplotlib nos permite habilitar el blitting en FuncAnimation, pero significa que debemos
volver a escribir cómo funciona parte de la función animate(). Para obtener los verdaderos
beneficios del blitting, debemos establecer un fondo estático, lo que significa que los ejes no
se pueden escalar y ya no podemos mostrar marcas de tiempo en movimiento. Esto significa
que tienes que tomar lo bueno con lo malo. Así que tienes que elegir lo que es más importante
para ti en tus simulaciones.
Ejemplo 36.3.3. Trazado en tiempo real con animación con rendimiento mejorado
mance
Código Python:

importar mat pl o tli b . py pl otasplt 3 import mat
pl o tli b . anim a ción como anim a ción
4
5 # Parámetros 6 xlen
= 200 # Número de puntos para mostrar
230
7 yrange = [ 0 , 2 0] # Rango de posibles valores de Y para mostrar

8
9 # C re a la figura para el trazado 10 fig = plt .

cifra ( ) 11 hacha = fig . addsub
plot ( 1 12 xs = list ( r an ge ( 0 2 0 , 1 , 1)
0 ) ) 13 ys = [ 0 ] xlen 14 ax ., setylim
( yrange )
15
dieciséis
17 # Crea una línea en blanco. Actualizaremos linein animate 18 line = ax . parcela ( xs , ys )

,
19
20 # Añadir etiquetas
21 plt. title ( 'Datos de temperatura' ) 22 plt.
xlabel ( 'Muestras' ) 23 plt. ylabel
( 'Temperatura (gradosC)' )
24
25 # Esta función se llama periódicamente de FuncAnimation 26 def animate ( i , ys ) :
27
28 randv al = np. aleatorio . aleatorio ( ) 20 #Generar valores aleatorios entre 0 y 20
29
30 temp c = ronda ( randval al , 2)

31
32 #imprimir (temperatura c)
33
34 # Añadir ytolist ys.

35 agregar (temp c)
36
37 # Lista de límites para establecer el número de elementos

38 s ys = ys[− xlen : ]
39
40 # Actualice la línea con la nueva línea de valores

41 Y. setydata (ys)
42
43 línea de retorno ,
44
45 # Configura la función pl ottocall animate ( ) periódicamente 46 a ni = anim a c ión . FuncAnimation ( fig ,
47 animar
,
48 fargs =(ys , ) ,
49 intervalo =100,
50 blit=True ) 51
plt . espectáculo ( )
La figura 37.4 muestra el gráfico final de este ejemplo. No puede ver el comportamiento real
de la gráfica mirando la Figura 37.4, por lo que necesita ejecutar el programa Python usted
mismo.
[Fin del ejemplo]
Ejemplo 36.3.4. Simulaciones discretas con animación con rendimiento mejorado

mance
231
Código Python:
importar mat pl o tli b . py pl otasplt 3 import mat pl
o tli b . anim a ción como anim a ción
4
5 # Parámetros
6 N = 200 7 xlen = N
# Número de puntos para mostrar

8 yrango = [ 0 , 1 0] # Rango de posibles valores de Y para mostrar
9
10 # C re a la figura para el trazado 11 fig =

plt . figura ( ) 12 hacha = fig .
addsub plot ( 1 13 xs = list ( r an ge , 1 , 1)
( 0 , N) ) 14 ys = [ 0 ] xlen 15 ax .
setylim ( yrange )
dieciséis
17 xk = 0 # Valor inicial forx

18
19 # Crea una línea en blanco. Actualizaremos la línea en animate = ax. trazar ( xs , ys ) 20

, líneas
21
23 plt. title ( ' Simulación de dxdt = −ax + bu ' ) 24 plt . xlabel
( 'Muestras' ) 25 plt. yetiqueta ( ' ' )
X
26
27 # Esta función se llama periódicamente de FuncAnimation 28 def sim ul a c ión ( i , ys ) :
29
30 # Parámetros del modelo a

31 = 0. 2 5 b =
32 2
33
34 # Parámetros de simulación Ts = 0.
35 1 # Tiempo de muestreo uk = 1 #
36 Respuesta de paso
232
37 global xk # Ya que cambiamos xdentro de una función, definimos una variable gob al
38
39 # Modelo de Sistema D iscreto xk1 =

40 ( 1 − a Ts ) xk + Ts b uk xk = xk1
41
42

44 agregar (xk1)
45
46 # Lista de límites para establecer el número de

47 elementos s ys = ys[− xlen : ]
48
49 # Actualice la línea con la nueva línea de

50 valores Y. setydata (ys)
51
53
54 # Configura la función pl ottocall animate ( ) periódicamente 55 a ni = anim a c

ión . FuncAnimation ( fig , sim ul a ti onfargs =(ys , ) ,
56 interval =100, ,
57 blit=True ) 60 plt .
58 espectáculo ( )
59
Listado 36.9: Simulación en tiempo real de un sistema dinámico discreto con animación y mayor
velocidad
La figura 36.10 muestra el gráfico final de este ejemplo. No puede ver el comportamiento real de la
gráfica mirando la Figura 36.10, por lo que necesita ejecutar el programa Python usted mismo.
[Fin del ejemplo]
Para obtener más información acerca de Matplotlib: animaciones:
https://scipycookbook.readthedocs.io/items/MatplotlibAnimations.html
Otros recursos:
https://learn.sparkfun.com/tutorials/graphsensordatawithpythonandmatplotlib/allplot sensordata
https://stackoverflow.com/questions/11874767/howdoiplotinrealtimeinawhile loopusingmatplotlib
233
234
Parte VII
Adquisición de datos
(DAQ) con Python
235
capitulo 37
Trazado de datos del sensor
37.1 Introducción
Por lo general, queremos trazar los datos del sensor. Podemos graficar guardar los datos en
una matriz y luego graficar los datos al final del programa, pero lo más probable es que
queramos graficar un valor a la vez dentro del bucle, lo que se conoce como "graficación en
tiempo real".
En este capítulo solo mostramos cómo puede trazar los datos de cualquier sensor dado
utilizando este enfoque general. En lugar de los datos reales del sensor, solo usamos el
generador aleatorio en Python.
Para leer los datos reales del sensor, normalmente necesita un dispositivo DAQ (Adquisición
de datos) conectado a su PC o, por ejemplo, un dispositivo Raspberry Pi. En todos los casos,
normalmente necesitará instalar un controlador del proveedor del dispositivo DAQ o del
sensor que está utilizando.
37.2 Introducción al trazado en tiempo real

También puede usar matplotlib para el trazado en tiempo real.
Ejemplo 37.2.1. Introducción al trazado en tiempo real
Aquí hay un ejemplo básico:

3
4 plt. eje ( [ 0 , 10, 0 , 1])

5
6 d el ay = 1 #Segundos
7
8 para i en rango ( 1 0 ) : y = np .
9 aleatorio . aleatorio ( ) plt . dispersión
10 ( i , y ) plt . pausa (d el ay)
11
236
12
Listado 37.1: Trazado en tiempo real en Python
Obtenemos la siguiente gráfica como se muestra en la Figura 37.1.
Figura 37.1: Trazado en tiempo real con Python
No puede ver el comportamiento real de la gráfica mirando la Figura 37.1, por lo que necesita ejecutar el
programa Python usted mismo.
Si ejecuta el código, verá que el gráfico se actualiza con un nuevo valor cada segundo, como se
especifica en el código.
[Fin del ejemplo]
¡Nota! Si usa Anaconda y Spyder, normalmente necesita cambiar la configuración de cómo se muestran
los gráficos en Spyder.
Seleccione Preferencias en el menú, luego la consola de IPython en la lista de categorías a la izquierda,

luego la pestaña Gráficos en la parte superior y cambie el backend de Gráficos de En línea a, por
ejemplo, Automático o Qt. Consulte la Figura 37.2.
237
Figura 37.2: Cambiar cómo se muestran los gráficos en el editor de Spyder
37.3 Trazado en tiempo real con animación

Para gráficos en tiempo real más avanzados, debemos usar el módulo de animación en la
biblioteca matplotlib (matplotlib.animation).
Para crear un gráfico en tiempo real, necesitamos usar el módulo de animación en matplotlib.
Configuramos la figura y los ejes de la forma habitual, pero dibujamos directamente en los ejes,
ax, cuando queremos crear un nuevo cuadro en la animación.
Necesitamos usar la función FuncAnimation:
1 a ni = anim a ti on . FuncAnimation ( fig , animar , fargs =(xs , ys ) ,

intervalo =1000)
FuncAnimation es una función especial dentro del módulo de animación que nos permite
automatizar la actualización del gráfico. Le pasamos a FuncAnimation() un identificador de la
figura que queremos dibujar, fig, así como el nombre de una función que debe llamarse a
intervalos regulares. Llamamos a esta función animate() y se define justo encima de nuestra
llamada a FuncAnimation().
Todavía en los parámetros de FuncAnimation(), establecemos fargs, que son los argumentos
que queremos pasar a nuestra función de animación (ya que no estamos llamando a animate()
directamente desde nuestro propio código). Luego, establecemos el intervalo, que es el tiempo
que debemos esperar entre las llamadas a animate() (en milisegundos).
Nota: Como argumento para FuncAnimation, observe que animate no tiene paréntesis. Esto
es pasar una referencia a la función y no el resultado de esa función. Si accidentalmente
agrega paréntesis para animar aquí, animar se llamará inmediatamente (solo una vez) y es
probable que obtenga un error
238
Ejemplo 37.3.1. Trazado en tiempo real con animación
A continuación, encontrará el código de Python para un ejemplo básico en el que usamos el

módulo de animación en matplotlib.
En el ejemplo, actualizamos el gráfico cada segundo configurando el intervalo = 1000 ms como

argumento de entrada para la función FuncAnaimation.

importar mat pl o tli b . py pl otasplt 4 import mat pl o tli
b . anim a ción como anim a ción
5
gráfico de adición ( 1 9 xs = [ ] 10 ys = [ ]
, 1 , 1)
11
12
13 # Esta función se llama periódicamente de FuncAnimation 14 def animate ( i

, xs , si ):
15
dieciséis temp c = ronda ( np . aleatorio . aleatorio ( ) , 2)

17

20
21

23 ys [ −2 0:]
24
25

27 hacha . parcela
28 ( xs , ys )
29

32 (inferior = 0.30) plt. título ( ' ' )
33 Datos de temperatura plt.
34 ylabel ( 'Temperatura(grados C)' )
35
36 # Configure la función pl ottocall animate ( ) periódicamente 37 a ni = anim a c ión . FuncAnimation (fig, intervalo = 1000) 38 plt.
espectáculo ( )
animar , fargs =(xs , ys ) ,
La figura 37.3 muestra el gráfico final de este ejemplo. No puede ver el comportamiento real de
la gráfica mirando la Figura 37.3, por lo que necesita ejecutar el programa Python usted mismo.
[Fin del ejemplo]
239
37.3.1 Aceleración de la animación de la trama

Borrar un gráfico y volver a dibujarlo todo puede ser un proceso lento en términos de tiempo
de computadora. Para remediarlo, vamos a utilizar un truco conocido como blitting.
Blitting es una antigua técnica de gráficos por computadora en la que varios mapas de bits
gráficos se combinan en uno. De esta manera, solo era necesario actualizar uno a la vez,
evitando que la computadora tuviera que volver a dibujar toda la escena cada vez.
Matplotlib nos permite habilitar el blitting en FuncAnimation, pero significa que debemos
volver a escribir cómo funciona parte de la función animate(). Para obtener los verdaderos
beneficios del blitting, debemos establecer un fondo estático, lo que significa que los ejes no
se pueden escalar y ya no podemos mostrar marcas de tiempo en movimiento. Esto significa
que tienes que tomar lo bueno con lo malo. Así que tienes que elegir lo que es más importante
para ti en tus simulaciones.
Ejemplo 37.3.2. Trazado en tiempo real con animación con rendimiento mejorado
mance
Código Python:

importar mat pl o tli b . py pl otasplt 3 import mat
pl o tli b . anim a ción como anim a ción
4
5 # Parámetros 6 xlen
= 200 # Número de puntos para mostrar
7 yrange = [ 0 , 2 0] # Rango de posibles valores de Y para mostrar
8
240
9 # C re a la figura para el trazado 10 fig = plt .

cifra ( ) 11 hacha = fig . addsub
plot ( 1 12 xs = list ( r an ge ( 0 2 0 , 1 , 1)
0 ) ) 13 ys = [ 0 ] xlen 14 ax . ,setylim
( yrange )
15
dieciséis
17 # Crea una línea en blanco. Actualizaremos linein animate 18 line = ax . parcela ( xs , ys )

,
19
21 plt. título ( ' ' ) Datos de temperatura 22
plt. xlabel ( 'Muestras' ) 23 plt. ylabel
( 'Temperatura (grados C)' )
24
25 # Esta función se llama periódicamente de FuncAnimation 26 def animate ( i , ys ) :
27
28 randv al = np. aleatorio . aleatorio ( ) 20 #Generar valores aleatorios entre 0 y 20
29
30 temp c = ronda ( randval al , 2)

31
32 #imprimir (temperatura c)
33

35 agregar (temp c)
36
37 # Lista de límites para establecer el número de elementos

38 s ys = ys[− xlen : ]
39
40 # Actualice la línea con la nueva línea de valores

41 Y. setydata (ys)
42
44
45 # Configura la función pl ottocall animate ( ) periódicamente 46 a ni = anim a c ión . FuncAnimation ( fig , anime fargs =(ys , ) , interval
=100, blit=True ) 51 plt . espectáculo ( )

47 ,
48
49
50
La figura 37.4 muestra el gráfico final de este ejemplo. No puede ver el comportamiento real de la
gráfica mirando la Figura 37.4, por lo que necesita ejecutar el programa Python usted mismo.
[Fin del ejemplo]
Para obtener más información acerca de Matplotlib: animaciones:
https://scipycookbook.readthedocs.io/items/MatplotlibAnimations.html
241
Otros recursos:
https://learn.sparkfun.com/tutorials/graphsensordatawithpythonandmatplotlib/allplot sensordata
https://stackoverflow.com/questions/11874767/howdoiplotinrealtimeinawhile loopusing
matplotlib
242
capitulo 38
Adquisición de datos
(DAQ) con Python
Python es probablemente más adecuado para cálculos numéricos, análisis, simulaciones, etc.
"adhoc", pero puede usarse para muchos otros propósitos, incluso si otros lenguajes de
programación son más adecuados.
38.1 Introducción a DAQ

Para leer los datos del sensor, normalmente necesita un dispositivo DAQ (Adquisición de
datos) conectado a su PC o, por ejemplo, un dispositivo Raspberry Pi. En todos los casos,
normalmente necesitará instalar un controlador del proveedor del dispositivo DAQ o del sensor
que está utilizando.
Un sistema DAQ consta de 4 partes:
• Señales físicas de entrada/salida, sensores
• Dispositivo/hardware DAQ
• Software de controlador
• Su aplicación de software (Software de aplicación) en este caso su Python

solicitud
La Figura 38.1 muestra los diferentes pasos involucrados en un sistema DAQ.
Aquí encontrará más información, recursos, videos y ejemplos sobre DAQ: https://
www.halvorsen.blog/documents/technology/daq/
38.2 Adquisición de datos usando dispositivos NI DAQ

Aquí mostraremos cómo podemos usar Python para recuperar datos del mundo físico usando
un dispositivo DAQ o un módulo de E/S.
243
Figura 38.1: Sistema de adquisición de datos (DAQ)
Usaremos un dispositivo DAQ de National Instruments (NI).
Web:
http://www.ni.com/
Hardware DAQ: Usaremos un dispositivo DAQ NIUSB600x de National Instruments, como:
• NIUSB6001
• NIUSB6008
• NIUSB6009
Son casi idénticos y el precio tampoco está tan mal.
USB6008:
http://www.ni.com/enno/support/model.usb6008.html
La Figura 38.2 muestra el dispositivo DAQ USB6008 de NI.
Transmisión de datos desde dispositivos NI Data Acquisition (DAQmx) a Python: https://

knowledge.ni.com/KnowledgeArticleDetails?id=kA00Z000000P8o0SAC
Suponemos que queremos hacer lo siguiente: Tenemos un sistema DAQ USB de

National Instruments Queremos transmitir datos desde mi hardware a Python para realizar
el procesamiento de datos Nos gustaría registrar datos en un archivo en el disco duro
La mejor manera de hacer esto es usar la API Python NIDAQmx proporcionada por
National Instruments (nidaqmx). La API NIDAQmx Python está alojada en GitHub.
El paquete de Python nidaqmx es un contenedor de la API NIDAQmx C que utiliza la

biblioteca de Python ctypes y solo es compatible con el sistema operativo Windows.
Una API de Python para interactuar con NIDAQmx (GitHub): https://

github.com/ni/nidaqmxpython
244
Figura 38.2: USB6008
Para más información sobre NI DAQ: ni.com/

daq
Para obtener más información acerca de los recursos de Python para hardware y software de
NI: ni.com/python
Otra opción es usar el paquete PyDAQmx Python.

Este paquete permite a los usuarios utilizar hardware de adquisición de datos de National
Instrument con python. Hace una interfaz entre el controlador NIDAQmx y python. Actualmente
solo funciona en Windows. El paquete no es un controlador de código abierto del hardware de
adquisición de NI. Primero necesita instalar el controlador proporcionado por NI.
Web:
https://pypi.org/project/PyDAQmx/
https://pythonhosted.org/PyDAQmx/
38.2.1 NIDAQmx
NIDAQmx es el software que utiliza para comunicarse y controlar su dispositivo de adquisición
de datos (DAQ) de NI.
NIDAQmx solo es compatible con el sistema operativo Windows.
Puede descargar NIDAQmx desde esta ubicación:
https://www.ni.com/download
245
38.2.2 Explorador de automatización de medidas (MAX)

Measurement Automation Explorer (MAX) es un software que puede usar para configurar y
probar el dispositivo DAQ antes de usarlo en Python (u otros lenguajes de programación).
MAX se incluye con el software NIDAQmx.
La Figura 38.3 muestra el Explorador de automatización de medidas (MAX).
Figura 38.3: Explorador de automatización de medidas (MAX)
Con MAX puede asegurarse de que su dispositivo DAQ funcione como se espera antes de
comenzar a usarlo en su programa Python. Puede usar los paneles de prueba para probar
sus canales de entradas y salidas analógicas y digitales.
También puede cambiar el nombre de la unidad, que debe usar en su código de Python.
38.3 NIDAQmx API Python

En esta sección utilizaremos la API Python NIDAQmx proporcionada por National Instruments
(nidaqmx). La API NIDAQmx Python está alojada en GitHub.
El paquete de Python nidaqmx es un contenedor de la API NIDAQmx C que utiliza la

biblioteca de Python ctypes y solo es compatible con el sistema operativo Windows.
246
Una API de Python para interactuar con NIDAQmx (GitHub): https://

github.com/ni/nidaqmxpython
Otros recursos:
Controle el dispositivo NI DAQ con Python y NI DAQmx: https://
knowledge.ni.com/KnowledgeArticleDetails?id=kA00Z0000019Pf1SAE
A continuación se proporcionarán 4 ejemplos básicos:
• Escritura analógica usando el dispositivo NI DAQ
• Lectura analógica usando el dispositivo NI DAQ
• Escritura digital utilizando el dispositivo NI DAQ
• Lectura digital utilizando el dispositivo NI DAQ
Puede ampliar fácilmente estos ejemplos para adaptarlos a sus necesidades. Por lo general, debe incluir
un ciclo while en el que escribe y/o lee desde el dispositivo DAQ dentro del ciclo, por ejemplo, lee
valores de uno o más sensores que están conectados al dispositivo DAQ, es posible que desee crear
un sistema de control que lea el valor del proceso y luego escribir la señal de control calculada (por
ejemplo, utilizando un controlador PID) de vuelta al dispositivo DAQ y al proceso.
38.3.1 Escritura analógica

Ejemplo 38.3.1. Escritura analógica usando un dispositivo NI DAQ
código pitón:
1 importación nidaqmx
2
3 con nidaqmx. Tarea ( ) astarea : tarea .

'
4 aochann el s. addaov ol tagechan ( ' Dev1/ ao0 , ' Mi canal '
, 0 , 5)
5
6 v alor = 3
7 tarea . comenzar
8 tarea . tarea de escritura
9 (v alor). detener
Listado 38.1: Escritura analógica usando un dispositivo NI DAQ
¡Nota! El USB6008 solo puede emitir una señal de voltaje entre 0 y 5V.
[Fin del ejemplo]
38.3.2 Lectura analógica

Ejemplo 38.3.2. Lectura analógica usando el dispositivo NI DAQ
código pitón:
247
2

4 canales de aire agregar ai vol tagechan ( ”Dev1/ ai 1 ” )
5
6 v alor = tarea . read ( ) print

7 ( v alor ) tarea .
8
detener
Listado 38.2: Lectura analógica usando un dispositivo NI DAQ
[Fin del ejemplo]
Ejemplo 38.3.3. Lectura analógica con RSE
código pitón:
2
3 de nidaqmx. importación de constantes (T e

4 rmi n alC on fi gura ti on )
5

7
” ,
canales de aire agregue ai v ol tagechan ( ”Dev1/ ai 0 terminalconfig=T
e rmi n alC on fi gura ti on .RSE)
8

11 detener
Listado 38.3: Lectura analógica con RSE
[Fin del ejemplo]
Ejemplo 38.3.4. Lectura analógica con diferencial
código pitón:
2

5

7 ” ,
canales de aire agregue ai v ol tagechan ( ”Dev1/ ai 0 terminalconfig=T
e rmi n alC on fi gura ti on .DIFFERENTIAL)
8

11 detener
Listado 38.4: Lectura analógica con diferencial
[Fin del ejemplo]
248
38.3.3 Escritura digital

Ejemplo 38.3.5. Escritura digital usando el dispositivo NI DAQ
código pitón:
2

4 dochann el s. agregar do chan ( ”Dev1/ puerto 0 / línea 0 ” )
5
6 v alor = Tarea
7 verdadera.
8 tarea de inicio tarea de
9 escritura (v alor). detener
Listado 38.5: Escritura digital usando un dispositivo NI DAQ
[Fin del ejemplo]
38.3.4 Lectura digital

Ejemplo 38.3.6. Lectura digital usando el dispositivo NI DAQ
código pitón:
2

4 dicanales. agregar di chan ( ”Dev1/ puerto 0 / línea 0 ” )
5
6 tarea . valor de
7 inicio = tarea. read ( ) print ( v
8 alor ) tarea .
9 detener
Listado 38.6: Lectura digital usando un dispositivo NI DAQ
[Fin del ejemplo]
Debe usar las clases "lectores nidaqmx.stream" y escritores nidaqmx.stream para aumentar el
rendimiento de su aplicación, que acepta matrices NumPy preasignadas.
https://nidaqmxpython.readthedocs.io/en/latest/stream readers.html#module nidaqmx.stream

lectores
https://nidaqmxpython.readthedocs.io/en/latest/streamwriters.html#module nidaqmx.stream
escritores
249
38.4 LED de control

En esta sección veremos cómo podemos controlar un LED desde Python.
Necesitaremos el siguiente equipo:
• PC con Python
• Dispositivo de adquisición de datos
• Protoboard
• CONDUJO
• Resistencia (p. ej., 270 ohmios)
• Cables para conectar los componentes y crear el circuito
La Figura 38.4 muestra una descripción general de los LED.
Figura 38.4: Descripción general de LED
Una placa de prueba se utiliza para cablear componentes eléctricos entre sí. La Figura 38.5 muestra
cómo debe cablear un LED utilizando una placa de pruebas.
La Figura 38.6 muestra cómo cablear el LED y conectarlo al dispositivo DAQ.
Código de Python para encender el LED
Ejemplo 38.4.1. Controlando un LED desde Python
Código básico de Python:

2

4 dochann el s. agregar do chan ( ”Dev1/ puerto 0 / línea 0 ” )
5
6 v alor = Tarea
7 verdadera.
8 tarea de inicio tarea de
9 escritura (v alor). detener
Listado 38.7: Enciende un LED usando Python
250
Figura 38.5: Cómo cablear un LED en una placa de pruebas
Figura 38.6: Cablee el LED y conéctelo al dispositivo DAQ
En este ejemplo básico simplemente encendemos el LED.
A continuación, verá un ejemplo en el que encendemos y apagamos el LED dentro de un bucle.
código pitón:
1 importación nidaqmx 2
tiempo de importación
3
5 con nidaqmx. Tarea ( ) astarea : tarea . dochann

6 el s. agregar do chan ( ”Dev1/ puerto 0 / línea 0 ” )
7
8 v alor = Tarea
9 verdadera. comenzar
10
11 i=1
12 mientras e i < 1 0:
13
251
14 tarea . escribir (valor)

15 tiempo. dormir (1)
dieciséis
v alor = sin v alor
17 tarea . escri b ra ( v alor )
18 i = i +1
19
20 tarea . detener
Listado 38.8: Controlando un LED usando Python
[Fin del ejemplo]
38.5 Lectura de datos de sensores de temperatura

En esta sección usaremos Python para leer valores de un sensor de temperatura.
También usaremos Python para trazar datos en tiempo real del sensor.
38.5.1 Lectura de datos del sensor de temperatura TMP36 TMP36 es un sensor de
temperatura pequeño y de bajo costo y cuesta alrededor de $ 1 (puede comprarlo "en cualquier
lugar").
• PC con Python
• Protoboard
• Sensor de temperatura TMP36
La Figura 38.7 muestra el sensor TMP36.
Conectamos el TMP36 a LabVIEW usando un dispositivo DAQ USB de National Instruments, por
ejemplo, USB6001, USB6008 o similar. He usado una placa de prueba para el cableado.
La Figura 38.8 muestra cómo podemos conectar el TMP36 junto con el dispositivo DAQ USB6008.
La Figura 38.9 muestra la hoja de datos de TMP3x.
Necesitamos convertir de Voltaje (V) a grados Celsius.
De la hoja de datos (Figura 38.9) tenemos:
(x1, y1) = (0.75V, 25◦ ) (38.1)
252
Figura 38.7: Sensor de temperatura TMP36
(x2, y2) = (1V, 50◦ ) (38.2)
De la hoja de datos (Figura 38.9) vemos que existe una relación lineal entre el voltaje y los grados
Celsius (38.3):
y = hacha + b (38.3)
Podemos encontrar a y b usando la siguiente fórmula conocida (38.4):
y2 − y1
y y1 = x2 (x − x1) (38.4)
x1
Al poner (38.1) y (38.2) en (38.4) obtenemos:
50 − 25
25 = 1 − (x − 0,75) y − (38.5)
0,75
Luego obtenemos la siguiente fórmula que podemos implementar en nuestro programa de Python:
y = 100x − 50 (38.6)
Ejemplo 38.5.1. Leer datos de temperatura TMP36
código pitón:
253
Figura 38.8: Cableado TMP36 tmp36
1 importación nidaqmx 2
3
4 de nidaqmx. importación de constantes (T e rmi n

5 alC on fi gura ti on )
6

9
canales de aire agregue ai v ol tagechan ( ”Dev1/ ai 0 terminalconfig=T e ” ,
rmi n alC on fi gura ti on .RSE)
10
11 i=0
13
14 voltaje = tarea. leer ( )

15
dieciséis grado sC = 100 tensión − 50

17
18 imprimir ( ”Muestra : i )”
,
19 imprimir ( ” V ol ta je Valor : ” , redondo (voltaje 2))
,
20 imprimir ( ” C elsius Valor : ” , redondo (grados C, 1))
21 imprimir ( ”\n” )
22 tiempo . dormir ( 1 )
23 i = i +1
24
25 tarea . detener
Listado 38.9: Lectura de datos de temperatura TMP36
En el ejemplo, se ha utilizado un ciclo while ordinario en combinación con la función sleep()

para leer un valor nuevo cada segundo.
[Fin del ejemplo]
Ejemplo 38.5.2. Trazado en tiempo real de datos de temperatura
254
Figura 38.9: Hoja de datos de TMP3x
En este ejemplo, trazaremos los datos del sensor utilizando los ejemplos de trazado en tiempo real
que se muestran en el Capítulo 37.
Queremos presentar el valor del sensor en grados Celsius:
1. Lea la señal del dispositivo DAQ (05V)
2. Convierta a grados Celsius usando la información de la hoja de datos
3. Mostrar/trazar valores del sensor
El código de Python se convierte en el siguiente:
1 importar nidaqmx 2
importar hora 3
importar fecha y hora como dt 4
importar mat pl o tli b . py pl otasplt 6 import mat pl
o tli b . anim a ción como anim a ción
7
8 de nidaqmx. importación de constantes (T e rmi

9 n alC on fi gura ti on )
10
11
subparcela ( 1 15 xs = [ ] 16 ys = [ ]
, 1 , 1)
17
18 # Inicializa el dispositivo DAQ 19

tarea = nidaqmx. Tarea ( ) 20 tarea .
”
canales de aire agregue ai v ol tagechan ( ”Dev1/ ai 0 T e rmi n alC on fi , terminalconfig=
gura ti on .RSE)
255
21 tarea. comenzar
22
23
24 # Esta función se llama periódicamente de FuncAnimation 25 def readdaq ( i

xs , si ):
26
,
27 #Lea el valor del dispositivo DAQ v ol tage =
28 task . leer ( )
29
30 #Convertir V ol ta je a grados C elsius grados C = 100 V

31 ol taje − 50 temp c = ronda (grados C , 1 )
32 print ( ” Valor C elsius : , temp c )
33 ”
34

37
38

40 ys [ −2 0:]
41
42

44 hacha . parcela
45 ( xs , ys )
46

49 (inferior = 0.30) plt. title ( 'Datos de temperatura' ) plt.
50 ylabel ( 'Temperatura (grados C)' )
51
52
53
54 # Configure la función pl ottocall readdaq ( ) periódicamente 55 a ni = anim a c ión . FuncAnimation (fig, readdaq,
fargs =(xs , ys ) ,
intervalo =1000) 56 plt.
mostrar ( ) 57 tarea .
detener
Listado 38.10: Trazado en tiempo real de datos de temperatura
[Fin del ejemplo]
38.5.2 Leer datos del termistor

Un termistor es un componente electrónico que cambia la resistencia a la temperatura,
los llamados detectores de temperatura de resistencia (RTD). A menudo se utiliza como
sensor de temperatura.
Ejemplo 38.5.3. Leer datos de temperatura del termistor
• PC con Python
256
• Protoboard
• Termistor de 10kohm
• Resistencia de 10kohm
Nuestro termistor es el llamado NTC (coeficiente de temperatura negativo). En un termistor

NTC, la resistencia disminuye a medida que aumenta la temperatura.
Existe una relación no lineal entre la resistencia y la excitación. Para encontrar la temperatura
podemos usar la siguiente ecuación (ecuación de SteinhartHart):
1
= A + B ln(R) + C(ln(R))3 (38.7)
conocimientos tradicionales
donde A, B y C son constantes con los siguientes valores: A = 0.001129148, B = 0.000234125,

C = 8.76741E − 08
TK es la temperatura en Kelvin.
Queremos resolver la ecuación relativa a la Temperatura:
1
conocimientos tradicionales =
(38.8)
A + B ln(R) + C(ln(R))3
La temperatura en grados centígrados será entonces:
CT = CT − 273,15 (38.9)
Alambrado...
La figura 38.10 muestra cómo conectamos los componentes entre sí.
Figura 38.10: Cableado del termistor
257
Figura 38.11: Divisor de tensión
El cableado se denomina "divisor de tensión".
La figura 38.11 muestra un divisor de tensión general.
Un divisor de voltaje general tiene la siguiente ecuación:
R2
Vsal = Vin (38.10)
R1 + R2
El divisor de voltaje para nuestro sistema se vuelve como se muestra en la figura 38.12.
Figura 38.12: Divisor de voltaje para nuestro sistema
Entonces tenemos la siguiente ecuación:
derecha
Vsal = Vin (38.11)

R0 + Rt
258
donde Rt es nuestro termistor de 10kohm y R0 es una resistencia ordinaria de 10kohm.
Vin en nuestro caso será +5V que obtenemos del dispositivo DAQ USB6008 como se
muestra en el diagrama de cableado.
Vout es el voltaje que leemos usando el dispositivo DAQ.
Como necesitamos encontrar la resistencia Rt, que se usa en la ecuación de Steinhart

Hart, reformulamos la fórmula:
VoutR0
Rt = (38.12)
Vin Vout
No estamos listos para comenzar a hacer el programa Python para este ejemplo.
El programa incluye los siguientes pasos necesarios:
1. Cableamos el circuito en el Breadboard y lo conectamos al dispositivo DAQ
2. Medimos Vout usando el DAQ
3. Calculamos Rt usando la ecuación del divisor de voltaje

VoutR0
Rt = Vin−Vout
4. Usamos la ecuación de SteinhartHart para encontrar la temperatura

1
A+B ln(Rt)+C(ln(Rt))3
conocimientos tradicionales =
5. Finalmente convertimos a grados Celsius

CT = CT − 273,15
El código de Python se convierte entonces en:

1 importar nidaqmx 2
4

7
9 Vin = 5
10 Ro = 10000 # %10k Resistencia

11
12

14 canales de aire agregue ai v ol tagechan ( ”Dev1/ ai 0 terminalconfig=T” ,
e rmi n alC on fi gura ti on .RSE)
15
dieciséis
i=0
18
19 Vout = tarea. leer ( )

20
21 Rt = ( Vout Ro) / ( Vin−Vout ) # Ecuación del divisor de voltaje # Rt=10000;

22 Usado para pruebas. El establecimiento de Rt=10k debería dar TempC=25
23
259
24 # S t ei nhartconstants A = 0. 0 0
25 1 1 2 9 1 4 8 B = 0. 0 0
26 0 2 3 4 1 2 5 C = 0. 0 0
27 00000876741
28
29 # S t ei nhart −Hart Ecuación TempK =

30 1 / (A + (B np . log ( Rt ) ) + (C pow( np . log ( Rt ) , 3 ) )
)
31
32 # Convertir de Kelvin a C elsius TempC = TempK

33 − 2 7 3. 1 5
34
35 imprimir ( ”Muestra : i )” ,
36 imprimir ( ” V ol ta je Valor : ” , ronda ( Vout 2))
37 imprimir ( ” C elsius Valor : ” , ronda (TempC, 1, ) )
38 imprimir ( ”\n” )
39 tiempo . dormir ( 1 )
40 i = i +1
41
42 tarea . detener
Listado 38.11: Leer datos de temperatura del termistor
[Fin del ejemplo]
Ejemplo 38.5.4. Trazado en tiempo real de datos de temperatura del termistor
código pitón:
1 Ver ejemplos anteriores
Listado 38.12: Trazado en tiempo real de datos de temperatura del termistor
[Fin del ejemplo]
38.5.3 Leer Datos Dispositivo de Termopar NI TC01

En este capítulo se han mostrado varios ejemplos usando un dispositivo DAQ combinado
con diferentes sensores y componentes.
Aquí se mostrarán algunos ejemplos usando un sensor de temperatura preestablecido

de National Instruments llamado NI USBTC01. Esta es una temperatura basada en USB
sin necesidad de ningún tipo de cableado, simplemente conéctelo y haga su programa
Python. Dado que el NI USBTC01 es compatible con NIDAQmx, puede programarlo
de la misma manera que otros dispositivos DAQ de NI.
La Figura 38.13 muestra el dispositivo de termopar TC01 de NI.
Ejemplo 38.5.5. Trazado en tiempo real de datos de temperatura del termistor
código pitón:
260
Figura 38.13: Dispositivo Termopar TC01
2
3 tarea = nidaqmx. Tarea ( )

4
5 tarea. canales de aire agregue ai th rm c pl chan ( ”TC01/ ai 0” )

6
7 tarea. comenzar ( )
8
9 v alor = tarea . leer ( ) 10

imprimir ( ronda ( valor 1 ) ) ,
11
12 tarea. parada ( ) 13
tarea . cerca ( )
Listado 38.13: Ejemplo de Python de termopar TC01
Este es solo un ejemplo básico, que puede extender fácilmente usando un ciclo while
o usando algún tipo de trazado, etc.
[Fin del ejemplo]
38.6 Registro de datos

Python tiene varias funciones para crear, leer, actualizar y eliminar archivos.
261
Parte VIII
Base de datos de Python

Desarrollo
262
capitulo 39
Aplicaciones de bases de datos con

Pitón
Aquí aprenderemos cómo podemos usar Python para comunicarnos con un sistema de base de datos
como SQL Server o MySQL. Aprenderemos cómo nos conectamos a una base de datos, cómo
podemos insertar datos en la base de datos y recuperar datos de la base de datos.
Una base de datos es una forma estructurada de almacenar mucha información. La información se
almacena en diferentes tablas. Algunos de los sistemas de bases de datos más populares en la actualidad
son:
• Servidor SQL
• MySQL
• Maria DB
• MongoDB
• etc.
El diagrama ER (diagrama entidadrelación) se utiliza para el diseño y modelado de bases de datos.

Especifica tablas y relación entre ellas (Primary Keys y Foreign Keys)
La figura 39.1 muestra un ejemplo de un diagrama ER que consta de dos tablas de base de datos.
Aquí puede obtener más información sobre los sistemas de bases de datos, descargar ejemplos y
obtener recursos adicionales, ver videos, etc.:
https://www.halvorsen.blog/documents/technology/database/
39.1 Lenguaje de consulta estructurado (SQL)

El lenguaje de consulta estructurado (SQL) es un lenguaje de base de datos compatible con la mayoría de
los sistemas de bases de datos existentes en la actualidad. Usas SQL para interactuar con la base de datos.
263
Figura 39.1: Ejemplo de diagrama ER
sistema, como insertar datos en la base de datos y recuperar datos de la base de datos.
Aquí puede obtener más información sobre SQL, descargar ejemplos y obtener recursos
adicionales, ver videos, etc.:
https://www.halvorsen.blog/documents/technology/database/
39.2 Servidor SQL

Aquí veremos cómo podemos comunicarnos con una base de datos de SQL Server desde
Python.
39.3 mysql
Aquí veremos cómo podemos comunicarnos con una base de datos MySQL desde Python.
39.4 Mongo DB
Aquí veremos cómo podemos comunicarnos con una base de datos MongoDB desde
Python.
MongoDB es una base de datos llamada NoSQL. Uno de los sistemas de bases de datos
NoSQL más populares es MongoDB.
Puede descargar una base de datos MongoDB gratuita

desde: https://www.mongodb.com
264
capitulo 40
MongoDB con Python
Aquí aprenderemos cómo podemos usar Python para comunicarnos con MongDB.
Aprenderemos cómo nos conectamos a una base de datos, cómo podemos insertar datos en la
base de datos y recuperar datos de la base de datos.
40.1 Introducción a MongoDB

Aquí veremos cómo podemos comunicarnos con una base de datos MongoDB desde Python.
MongoDB es una base de datos llamada NoSQL. Uno de los sistemas de bases de datos NoSQL
más populares es MongoDB.
Puede descargar una base de datos MongoDB gratuita desde:

https://www.mongodb.com
40.2 MongoDB con Python

Aquí veremos cómo podemos comunicarnos con una base de datos MongoDB desde Python.
Python necesita un controlador MongoDB para acceder a la base de datos MongoDB. Existen
muchos controladores diferentes, por lo que solo necesita elegir uno.
40.2.1 PyMongo
La distribución PyMongo contiene herramientas para interactuar con la base de datos MongoDB
desde Python
https://pypi.org/proyecto/pymongo/
La instalación se realiza mediante PIP:
265
1 python −m pip instalar pymongo
40.3 Recursos adicionales

Tutoriales:
https://www.w3schools.com/python/pythonmongodbgetstarted.asp
266
Parte IX
Aplicación Python
Desarrollo
267
capitulo 41
Desarrollo de
Aplicaciones con Python
Python es popular dentro de la computación, pero se puede usar dentro de muchas otras
aplicaciones y se puede integrar y usar en combinación con otros lenguajes de
programación, por ejemplo, para el desarrollo de aplicaciones web, etc.
Python es probablemente más adecuado para cálculos numéricos, análisis, simulaciones,

etc. "adhoc", pero puede usarse para muchos otros propósitos, incluso si otros lenguajes
de programación son más adecuados.
Python se puede usar para crear páginas web (en combinación con HTML, CSS,
JavaScript). Por lo general, Python se usa en el lado del servidor, mientras que HTML, CSS
y JavaScript se usan en el lado del cliente.
Un ejemplo es Django, que es un marco Python del lado del servidor que se utiliza para
crear páginas web dinámicas.
Python también se puede utilizar para programar y crear aplicaciones de Raspberry Pi.
En general, Python es un lenguaje de programación multipropósito que se puede usar en

muchas situaciones. Pero no existe un lenguaje de programación que sea mejor en todo
tipo de situaciones, por lo que es importante que conozca y tenga habilidades en diferentes
lenguajes.
Mi lista de recomendaciones:
• Visual Studio y C
• LabVIEW: un lenguaje de programación gráfico muy adecuado para hardware

integración, toma de medidas y registro de datos
• MATLAB Cálculos numéricos y Computación científica
• Python: cálculos numéricos y computación científica, etc.
268
• Programación web, como HTML, CSS, JavaScript y un marco/lenguaje de programación del

lado del servidor como PHP, ASP.NET
• Bases de datos (como SQL Server y MySQL) y el uso de Structured

Lenguaje de consulta (SQL)
• Desarrollo de aplicaciones para las 2 plataformas principales iOS (XCode usando Swift
Lenguaje de programación) y Android (Android Studio usando Java
Lenguaje de programación o lenguaje de programación Kotlin)
Si tiene habilidades en la mayoría de las herramientas, lenguajes de programación y marcos

mencionados anteriormente, está bien preparado para trabajar como programador o ingeniero de
software a tiempo completo.
Un buen recurso o punto de partida para crear Aplicaciones para Python es:
Aplicaciones para Python [18]:

https://www.python.org/about/apps/
41.1 Matemáticas, Ciencias e Ingeniería

Python es probablemente más adecuado para cálculos numéricos, análisis, simulaciones, etc. "ad
hoc". Este tipo de aplicaciones también ha sido el enfoque principal en este libro de texto. Otros
tipos de aplicaciones se tratarán brevemente en este capítulo. Se cubrirán más detalles en
capítulos posteriores y en otros libros de texto en mi serie de libros de texto de Python, que puede
leer más en el Prefacio de este libro de texto.
SciPy es una colección de paquetes para matemáticas, ciencias e ingeniería, que se revisó a
fondo anteriormente en este libro de texto.
41.2 Aplicaciones GUI de escritorio

Python no viene con herramientas integradas para crear aplicaciones de GUI de escritorio
tradicionales, por lo que necesita usar paquetes de GUI externos para este propósito.
En mi opinión, las herramientas como Visual Studio, donde puede crear aplicaciones GUI
profesionales utilizando los lenguajes C o VB.NET en un paquete integrado, son una mejor opción.
Otra buena alternativa es LabVIEW, que tiene potentes características de GUI en combinación
con una amplia integración de hardware.
Otras herramientas (Entornos de programación integrados, IDE) y lenguajes de programación para

aplicaciones GUI os Xcode en macOS, que se pueden usar para crear aplicaciones de escritorio
macOS y aplicaciones para iPhone y iPad.
269
Para el desarrollo de Android tienes Android Studio. Aquí puedes usar lenguajes de
programación como Java y Kotlin.
Dado que este es un libro de texto de Python, volvamos a las opciones que tenemos si
queremos crear aplicaciones GUI de escritorio con Python.
Python tiene diferentes marcos de GUI de escritorio como:
• PyQt
• Tkinter
• WxPython
• PyGUI
• PySide2
• Kivy
Estas son solo algunas de las opciones que tenemos, para una visión general completa de
Los marcos de GUI para Python ven lo siguiente:
https://docs.python.org/3/library/othergui.htmlotrosguipaquetes https://
wiki.python.org/moin/GuiProgramming
PyQt y wxPython, todos tienen una apariencia moderna y más widgets que Tkinter.
Esto también es un pequeño problema cuando se trata del desarrollo de GUI de escritorio
con Python. Tienes tantas opciones y, a veces, es mejor tener una buena opción que
muchas opciones medio buenas.
41.2.1 PyQt
PyQt reúne el marco de aplicación multiplataforma Qt C++ y el lenguaje interpretado
multiplataforma Python. Qt es un conjunto de herramientas GUI multiplataforma.
Qt también incluye Qt Designer, un diseñador de interfaz gráfica de usuario. PyQt puede

generar código Python desde Qt Designer. También es posible agregar nuevos controles
GUI escritos en Python a Qt Designer.
Para más información sobre PyQt:
https://riverbankcomputing.com/software/pyqt/intro
Para obtener más información sobre Qt:
https://www.qt.io
270
Tutoriales de PyQt:
https://likegeeks.com/pyqt5tutorial/
https://buildsystem.fman.io/pyqt5tutorial
41.2.2 PySide2
PySide2 es el módulo oficial de Python del proyecto Qt for Python, que brinda acceso al marco
completo de Qt.
El marco PySide original fue lanzado originalmente por Nokia, entonces propietario de Qt.
Después de que Nokia vendiera Qt en 2011, PySide ya no se mantuvo. Luego PySide2 fue
establecido y mantenido por una comunidad. Finalmente, en 2016, la empresa Qt se comprometió
a apoyar oficialmente el proyecto PySide2.
Básicamente, PySide2 es muy similar a PyQt.
La desventaja de PySide2 (agosto de 2019) es que todavía está en "beta" (vista previa técnica).
Para más información sobre PySide2:
https://pypi.org/proyecto/PySide2/
https://wiki.qt.io/Qtf o Python
41.2.3 Intercambiar
Otro marco GUI popular es Tkinter.
Para más información sobre Tkinter:
https://docs.python.org/2/library/tkinter.html
41.2.4 WxPython
WxPython es un conjunto de herramientas GUI multiplataforma para el lenguaje Python.
Para obtener más información acerca de WxPython:
https://www.wxpython.org
https://wiki.wxpython.org/Getting
271
41.3 Aplicaciones web

Python se puede usar para crear páginas web (en combinación con HTML, CSS, JavaScript).
Por lo general, Python se usa en el lado del servidor, mientras que HTML, CSS y JavaScript se
usan en el lado del cliente.
Un ejemplo es Django, que es un marco Python del lado del servidor que se utiliza para crear
páginas web dinámicas.
Lee más sobre Django aquí:
https://www.djangoproject.com Otros
marcos de aplicaciones web y lenguajes de programación populares son ASP.NET y PHP.
Puede leer más sobre la programación web en general aquí:
https://www.halvorsen.blog/documents/programming/web/
41.4 Aplicaciones de bases de datos

Python se puede utilizar para la comunicación con un sistema de base de datos como SQL
Server o MySQL. Python tiene diferentes paquetes para la comunicación con diferentes
sistemas de bases de datos, tanto bases de datos SQL (p. ej., SQL Server, MySQL, Mari aDB,
etc.) como las denominadas bases de datos NoSQL (p. ej., MongoDB).
Aquí puede obtener más información sobre los sistemas de bases de datos y SQL, descargar
ejemplos y obtener recursos adicionales, ver videos,
etc.: https://www.halvorsen.blog/documents/technology/database/
41.4.1 Servidor SQL

SQL Server es un sistema de base de datos de Microsoft. SQL Server viene en diferentes
ediciones, para uso personal básico, se recomienda SQL Server Express porque es fácil de
usar y es gratuito.
Lea más sobre SQL Server aquí:
https://www.halvorsen.blog/documents/technology/database/sqlserver.php
41.4.2 MySQL
MySQL es un sistema de gestión de bases de datos relacionales (RDBMS) de código abierto y
ampliamente utilizado.
MySQL viene en diferentes ediciones, tanto de pago (Enterprise) como gratuitas (Community).
272
Además de la base de datos en sí, es bueno tener MySQL Workbench.

Herramienta de diseño de bases de datos visuales MySQL Workbench, utilizada para el modelado de
bases de datos, etc. Otra herramienta útil es phpMyAdmin. phpMyAdmin es una herramienta de
software libre escrita en PHP, destinada a manejar la administración de MySQL.
Lea más sobre MySQL aquí:
https://www.halvorsen.blog/documents/technology/database/mysql.php
41.4.3 Maria DB
MariaDB es un derivado del sistema de base de datos MySQL más famoso.
El servidor de base de datos MariaDB se publica como software gratuito y de código abierto.
MariaDB tiene compatibilidad con MySQL en la mayoría de las situaciones. Se dice que MariaDB tiene
un rendimiento ligeramente mejor que MySQL.
Lea más sobre MariaDB aquí:
https://www.halvorsen.blog/documents/technology/database/mariadb.php
41.4.4 Mongo DB
MongoDB es una base de datos distribuida de propósito general, basada en documentos.
MongoDB es un programa de base de datos orientado a documentos multiplataforma. Clasificado

como un programa de base de datos NoSQL.
Puede descargar MongoDB desde: https://

www.mongodb.com
273
capitulo 42
Integración de Python con

Estudio visual
Microsoft Visual Studio es un entorno de desarrollo integrado (IDE) de Microsoft. Se utiliza para
desarrollar programas informáticos, así como sitios web, aplicaciones web, servicios web y
aplicaciones móviles. El lenguaje de programación predeterminado (principal) en Visual Studio es
C, pero se admiten muchos otros lenguajes de programación.
Visual Studio (de Visual Studio 2017), tiene soporte integrado para Python, se llama "Soporte de
Web:
Wikipedia:
Aquí puede obtener más información sobre Visual Studio y C, descargar ejemplos y obtener
recursos adicionales, ver videos, etc.: https://
www.halvorsen.blog/documents/programming/csharp/
Para obtener una introducción a la integración de Python en Visual Studio, consulte el Capítulo 19.
274
capitulo 43
Integración de Python con

LabVIEW
43.1 ¿Qué es LabVIEW?
LabVIEW es un lenguaje de programación gráfico muy adecuado para la integración de

hardware, la toma de medidas y el registro de datos.
Vaya a mi sitio web para aprender más sobre LabVIEW: https://
www.halvorsen.blog
https://www.halvorsen.blog/documents/programming/labview/
Aquí encontrará información sobre LabVIEW, encontrará muchos recursos como material de
capacitación, videos, ejemplos de código, etc.
43.2 Usando Python en LabVIEW

LabVIEW es un lenguaje de programación completamente funcional que puede usar para crear
muchos tipos diferentes de aplicaciones. Además, también se puede integrar con muchos otros
lenguajes de programación como MATLAB y Python.
Web:
http://zone.ni.com/reference/enXX/help/371361R01/glang/python pal/
Utilice las funciones de Python para llamar al código de Python desde LabVIEW. Ver Figura 43.1
¡Nota! LabVIEW admite llamar a Python versión 2.7 y 3.6. Aunque las versiones no compatibles
pueden funcionar con las funciones de Python de LabVIEW, NI recomienda utilizar únicamente
versiones compatibles de Python.
Asegúrese de que el bitness de Python corresponda al bitness de LabVIEW instalado en la

máquina. Esto significa que si tiene LabVIEW de 32 bits, debe usar Python de 32 bits y si tiene
LabVIEW de 64 bits, debe usar Python 64.
275
poco.
Para ejecutar el código de Python, LabVIEW requiere las bibliotecas compartidas de Python
(DLL) en la ruta del sistema.
Para Windows: si instala Python 3.6, agregue el directorio que contiene python36.dll a la ruta del
sistema. Si instala Python 2.7, agregue el directorio que contiene python27.dll a la ruta del sistema.
Para obtener instrucciones detalladas sobre la instalación de Python para llamar al código de
Python: http://www.ni.com/productdocumentation/54295/en/
Funciones de LabVIEW para trabajar con Python: Open Python Session Python
Nodo Cerrar sesión de Python
Figura 43.1: Integración de Python en LabVIEW
El "Nodo de Python" llama directamente a una función de Python.
Aquí presentaré algunos ejemplos de cómo podemos integrar un script de Python existente o una
función de Python.
Ejemplo 43.2.1. Integración de Python en LabVIEW
Queremos usar Python para encubrir entre Ceslius y Fahrenheit (y viceversa).
Tf = (Tc × 9/5) + 32 (43.1)
Tc = (Tf − 32) × (5/9) (43,2)

1 def c 2 f (Tc ) :
2
276
3 Tf = (Tc 9 / 5 ) + 32 vuelta
4 Tf
5
7 def f 2 c ( Vf ) :
8
9 Tc = ( Tf − 3 2 ) (5/9)
10 regresa Tc
Listado 43.1: Funciones de Python
Luego, creamos un script de Python para probar las funciones (testf ahrenheit.py):
1 de fahrenheit importa c 2 f f2c
2
,
3 Tc = 0
4
5 Vf = c 2 f ( Tc )
6
7 letra ( ” Fahrenheit : ” + str ( Tf ) )

8
10 Tf = 32
11
12 Tc = f 2 c ( Tf )
13
14 imprime ( ” C elsius : ” + str ( Tc ) )
Listado 43.2: Probando las funciones
1 Fahrenheit : 3 2 . 0
2 C elsius : 0 . 0
Hagamos el programa de LabVIEW que llame a estas funciones de Python:
En la Figura 43.2 vemos el Panel Frontal.
En la Figura 43.3 vemos el Diagrama de Bloques.
En la Figura 43.4 vemos el código de LabVIEW para llamar a ambas funciones de

Python (c2f y f2c) desde LabVIEW.
[Fin del ejemplo]
277
278
279
capitulo 44
Raspberry Pi y Phyton
44.1 ¿Qué es Raspberry Pi?

La Raspberry Pi es una computadora del tamaño de una tarjeta de crédito que se conecta a
tu televisor y a un teclado. Es una pequeña computadora capaz que se puede usar en
proyectos de electrónica y para muchas de las cosas que hace su PC de escritorio.
Raspberry Pi es muy popular en proyectos y aplicaciones de IoT.
Para obtener más información y recursos sobre Raspberry Pi:
https://www.halvorsen.blog/documents/technology/iot/raspberry pi.php
Otros recursos:
https://learn.sparkfun.com/tutorials/pythonprogrammingtutorialgettingstarted withtheraspberry
pi/programminginpython
Primero, antes de comenzar a programar Python en un dispositivo Raspberry Pi, debe instalar
un sistema operativo como Raspbian. Raspbian es una distribución de Linux hecha a medida
para Raspberry Pi.
Raspbian viene también con Python preinstalado.
Para más información sobre Raspbian:
https://www.raspberrypi.org/downloads/raspbian/
280
capitulo 45
Aprendizaje automático con

Pitón
45.1 Introducción al aprendizaje automático

Aquí puede obtener más información sobre Machine Learning, descargar ejemplos
y obtener recursos adicionales, ver
videos, etc.: https://www.halvorsen.blog/documents/technology/machinelearning/
281
Parte X
Recursos
282
capitulo 46
Python para usuarios de MATLAB
Si está familiarizado con MATLAB, puede cambiar a Python con relativa facilidad.
La mayor parte de la funcionalidad y las funciones en diferentes cajas de herramientas tienen
funciones similares en Python.
Si está buscando recursos de MATLAB, consulte lo siguiente: https://

www.halvorsen.blog/documents/programming/matlab/
He creado muchos recursos de MATLAB, incluidos los siguientes libros de texto:
• Introducción a MATLAB
• Modelado, Simulación y Control en MATLAB
• Simulink y temas avanzados en MATLAB
La figura 46.1 muestra las cubiertas de los libros.
Figura 46.1: Libros de texto de MATLAB
283
46.1 Usar Python dentro de MATLAB

Para llamar a las bibliotecas de Python desde MATLAB, debe instalar la implementación
de referencia para Python (CPython).
Para obtener más información, consulte lo siguiente:
https://se.mathworks.com/help/matlab/empezandoconpython.html
MATLAB y Python también deben tener la misma arquitectura/versión de bits. Si tiene

la versión de MATLAB de 64 bits, necesita Python de 64 bits. Si tiene la versión de
MATLAB de 32 bits, necesita Python de 32 bits.
En MATLAB, comience buscando información sobre el entorno de Python

predeterminado utilizado por MATLAB:
1 >> pyver si on
Esto da lo siguiente en mi computadora con Windows10:

1 > pyver si on
2
3 versión : ' 3. '

4 7 ejecutable: 'C: \ Usuarios \hansha \AppData\ L oc al \Programs\Python\ Python37 64
'
\pythonw . biblioteca exe : 'C:
5 \Usuarios\hansha\AppData\L oc al\Programs\Python\ Python37 64 \python37 . dl l
'
home : 'C: \ U se rs \hansha
6 \AppData\ L oc al \Programs\Python\ Python37 64 isloaded : 1
'
7
Si MATLAB y Python no tienen la misma arquitectura/versión de bits, debe instalar la

versión adecuada de MATLAB o Python. Es posible que también necesite "Agregar
Python a la ruta" como se describe en el Capítulo 3.
Ejemplo 46.1.1. MATLAB Ejemplo de Python
Anteriormente hemos creado un módulo de Python con 2 funciones. La primera función

debe convertir de Celsius a Fahrenheit y la otra función debe convertir de Fahrenheit a
Celsius.
Tf = (Tc × 9/5) + 32 (46.1)
Tc = (Tf − 32) × (5/9) (46.2)
284
1 def c 2 f (Tc ) :
2
3 Tf = (Tc 9 / 5 ) + 32 vuelta
4 Tf
5
7 def f 2 c ( Vf ) :
8
9 Tc = ( Tf − 3 2 ) (5/9)
10 regresa Tc
Listado 46.1: Funciones Fahrenheit
Luego, creamos un script de Python para probar las funciones (testfahrenheit.py):

1 de farenheit importar c 2 f f2c
2
,
3 Tc = 0
4
5 Tf = c 2 f (Tc )
6
7 letra ( ”F ahrenh ei t : ” + str ( Tf ) )

8
10 Tf = 32
11
12 Tc = f 2 c ( Tf )
13
14 imprime ( ” C elsius : ” + cadena (Tc ) )
Listado 46.2: Python Script probando las funciones
1 Fahrenheit : 3 2. 0
2 C elsius : 0. 0
Ahora queremos usar estas funciones dentro del entorno MATLAB.
El código de MATLAB para esto se convierte en:
1 clc
2 Tc = 0 3 Tf
= py . farenheit c 2 f (Tc )
4 Tc = py. farenheit f 2 c ( Tf )
Listado 46.3: Llamando a la biblioteca y funciones de Python desde MATLAB
[Fin del ejemplo]
46.2 Llamar a MATLAB desde Python

La API del motor MATLAB para Python proporciona un paquete para que Python llame a
MATLAB como un motor computacional. El motor admite la implementación de referencia
(CPython).
285
Para obtener más información, consulte lo siguiente:
https://se.mathworks.com/help/matlab/matlabengineforpython.html
286
capitulo 47
Recursos de Python
Aquí encuentras mi página web con recursos de Python [1]:

https://www.halvorsen.blog/documents/programming/python/
Página de inicio de Python

[6]: https://www.python.org
Biblioteca estándar de Python

[19]: https://docs.python.org/3/library/index.html
47.1 Distribuciones de Python

Anaconda:
47.2 Bibliotecas de Python

Biblioteca NumPy:
http://www.numpy.org
Biblioteca SciPy:
https://www.scipy.org
Biblioteca Matplotlib:
https://matplotlib.org
47.3 Editores de Python

Spyder:
287
Código de estudio
visual: https://code.visualstudio.com
Estudio visual:
PyCharm:
Ala:
https://wingware.com
Cuaderno Jupyter:
http://jupyter.org
47.4 Tutoriales de Python

Tutorial de Python w3schools.com [13]:
https://www.w3schools.com/python/
El gurú de Python [20]:

https://thepythonguru.com
Wikilibros Tutorial de Python para principiantes:

https://en.wikibooks.org/wiki/ABeginner
TutorialsPoints Tutorial de Python:

https://www.tutorialspoint.com/python/
La guía del autoestopista de Python:

https://docs.pythonguide.org
Clase Python de Google:

https://developers.google.com/edu/python/
47.5 Python en Visual Studio

Trabaje con Python en Visual Studio
https://docs.microsoft.com/visualstudio/python/
288
Bibliografía
[1] H.P. Halvorsen, "Blog de tecnología: https://www.halvorsen.blog", 2018.
[2] H.P. Halvorsen, “Blog de tecnología https://en.wikipedia.org/wiki/Python(programminglanguage), 20
[3] T. . TP Languages, “Los principales lenguajes de programación de 2018 https://

spectrum.ieee.org/atwork/innovation/the2018top
lenguajes de programación”, 2018.
[4] s. “Encuesta para desarrolladores de desbordamiento de pila 2018

Desbordamiento, https://insights.stackoverflow.com/survey/2018/”, 2018.
[5] stackoverflow.blog, “El increíble crecimiento de python

https://stackoverflow.blog/2017/09/06/incrediblegrowthpython/”, 2018.
[6] python.org, “python.org https://www.python.org,” 2018.
[7] python.org, “El tutorial de Python https://docs.python.org/3.7/tutorial/,”

2018.
[8] python.org, “Documentación de Python 3.7.1 https://docs.python.org/3.7/,”

2018.
[9] scipy.org, "Scipy https://www.scipy.org", 2018.
[10] matplotlib.org, “Matplotlib https://matplotlib.org,” 2018.
[11] pandas, "pandas http://pandas.pydata.org", 2018.
[12] Wingware, "Wingware python ide https://wingware.com", 2018.
[13] w3schools.com, “Tutorial de Python https://www.w3schools.com/python/,”

2018.
[14] Wikipedia, "Depuración https://en.wikipedia.org/wiki/Debugging", 2018.
mejor idea
[15] TechBeamers, la pitón https://www.techbeamers.com/bestpythonide
"Conseguir
pythonprogramming/”, 2018.
[16] Jupyter, “Jupyter https://jupyter.org,” 2018.
[17] JupyterHub, "Jupyterhub http://jupyter.org/hub", 2018.
289

[18] python.org, "Aplicaciones para https://www.python.org/ pitón
about/apps/", 2018.
[19] python.org, “La pitón https://docs.python.org/ estándar biblioteca

3/library/,” 2018.
[20] TP Guru, "El gurú de Python https://thepythonguru.com", 2018.
290
Parte XI
Soluciones a ejercicios
291
Empezar a usar Python
Simulación y Trazado de Sistema Dinámico

Dado el sistema autónomo:
x˙ = hacha (1)
Dónde:
1
un =
T
donde T es la constante de tiempo.
La solución de la ecuación diferencial es:
x(t) = e atx0 (2)
Establecer T=5 y la condición inicial x(0)=1.
Crea un Script en Python (archivo .py) donde trazas la solución x(t) en el intervalo de tiempo:
0 ≤ t ≤ 25
Agregue la cuadrícula y las etiquetas de título y eje adecuadas a la trama.
como mt 2 importar numpy
como np 3 importar mat pl o tli b . py pl otasplt
4
6 # Parámetros del modelo

7T=5
8a = −1/T
9
10 # Parámetros de simulación 11 x0 =
1 12 t = 0
13
14 t inicio = 0
292
15 cucharaditas = 25
dieciséis
17 aum rem ento = 1

18
19 x = [ ] 20 x =
np . ceros ( tstop +1)
21

23
24
25 # Defina la función 26 para k inr

an ge ( tstop ) : x [ k ] = mt . Exp ( un
27 t[k]) x0
28
29
30 # Trazar los resultados de la sim ul a ción 31

, .
plt . parcela ( tx ) 32 plt
title ( 'Sim ul a ció n de un sistema dinámico' ) 33 plt. xlabel ( ' 34 plt .
ylabel ( ' 35 plt . grid ( ) t ' )
36 plt . eje ( [ 0 37 plt . X ')
mostrar ( )
, 25 , 0 , 1])
La simulación da los resultados como se muestra en la Figura 1.
Figura 1: Simulación de Sistema Dinámico
[Fin del ejercicio]
293
Matemáticas en Python
Crear expresiones matemáticas en Python

Cree una función que calcule la siguiente expresión matemática:
z = 3x 2
2+x ln (x)
+y 2+e (3)
Prueba con diferentes valores para x e y.
Creamos un módulo de Python con una función de Python (mymathfunctions.py):

2
3 def calcexpression ( x , y ) :
4
5 z=3 x 2 + metro . raíz cuadrada ( x 2+y 2 ) + metro . exp (mt. log (x))
6 volver z
Luego podemos crear un script de Python para probar la función:

1 importar funciones mymath como mymath
2
3x=24y=2
6 z = mimatemática. calcexpresión ( x , y )
7
8 imprimir (z)
1 1 6. 8 2 8 4 2 7 1 2 4 7 4 6 1 9
[Fin de la solución]
Crear expresiones matemáticas avanzadas en Python

Cree la siguiente expresión en Python:
ln (ax2 + bx + c) − sin(ax2 + bx + c) f(x)

= 4πx2 (4)
+ cos(x − 2)(ax2 + bx + c)
294
Dado a = 1, b = 3, c = 5 Encuentre f(9)

(La respuesta debería ser f(9) = 0.0044)
¡Consejo! Debe dividir las expresiones en diferentes partes, como:
poli = ax2 + bx + c
número = ...
guarida . . .
=f= ...
Esto hace que la expresión sea más fácil de leer y comprender, y minimiza el riesgo de cometer un error al
escribir la expresión en Python.
Cuando obtenga la respuesta correcta, intente cambiar a, por ejemplo, a = 2, b = 8, c = 6
Encuentre f(9)
1...
295
Sistemas discretos
Población de bacterias
tasa de natalidad = bx (5)
tasa de mortalidad = px2 (6)
x˙ = bx − px2 (7)
Simularemos el número de bacterias en el frasco después de 1 hora, asumiendo que inicialmente

hay 100 bacterias presentes.
Encuentre el modelo discreto usando el método Euler Forward a mano e implemente y simule el
sistema en Python usando un For Loop.
Podemos usar, por ejemplo, la aproximación de Euler:
xk+1 − xk x˙
≈ (8)
ts
Ts Intervalo de muestreo
Entonces obtenemos:
296
xk+1 − xk = bxk − px2 k (9)

ts
Esto da la siguiente ecuación diferencial discreta:
xk+1 = xk + Ts(bxk − px2 ) k (10)
Ahora estamos listos para simular el sistema.
1 # Sim ul a ci onof B acte ri a P opul a ti on 2 import
numpy as np 3 import mat pl o
4
5 # Parámetros del modelo 6 b = 1 7 p = 0. 5
10 Ts = 0. 0 1 11
Tstop = 1 12 xk
= 100 13 N =
int ( Tstop /Ts ) # Longitud de sim ul a ción 14 datos = [ ] 15
datos . agregar
(xk)
dieciséis
17
for k inr an ge (N) : xk1 = xk +
20 Ts ( b xk − p xk 2);
21 xk = xk1
22 datos . agregar (xk1)
23
24 # Trazar los resultados de la sim ul a ción 25 t = np . arreglar ( 0 Ts )

, Tstop+Ts ,
26
27 plt. pl ot ( t 28 , datos )
plt . title ( ' Sim ul a ci onof B acte ri a P opul a ti on ' ) 29 plt . xlabel ( ' t [ s ]
' ) 30 plt . ylabel ( ' ' ) 31 plt . g ri
d ( ) 32 plt . eje ( [ 0 33Xplt .
mostrar ( )
, 1, 0 , 100])
297
Figura 2: Simulación de población de bacterias
Simulación con 2 variables

Dado el siguiente sistema:
dx1
= −x2 (11)
_
dx2
= x1 (12)
_
Encuentre el sistema discreto y simule el sistema discreto en Python. Resuelva las ecuaciones,
por ejemplo, en el lapso de tiempo [1 1] con valores iniciales [1, 1].
1 # Sim ul a c ión con 2 V a ri a bl es 2 import
4
5 # Parámetros del modelo 6 b = 1

7 p = 0. 5
9 # Parámetros de simulación 10 Ts = 0. 1 11
T inicio = −1 12
Tparada = 1 13 x1k = 1
14 x2k = 1
15 N = int ( ( Tstop−T start ) /Ts ) # Longitud de sim ul a ción 16 datax1

=[]
298
17 datosx2 = [ ] 18 datosx1 .
agregar (x1k) 19 datosx2. agregar (x2k)
20
21
22 # Sim ul a ti en 23
para k inr an ge (N) : x1k1 = x1k
24 − Ts x2k x2k1 = x2k + Ts
25 x1k
26
27 x1k = x1k1 x2k

28 = x2k1
29 datosx1 . agregar (x1k1)
30 datosx2. agregar (x2k1)
31
32 # Trazar los resultados de la sim ul a ción 33 t = np . organizar (T inicio,
Tstop+Ts, Ts)
34
35 plt. plot ( t datax2 ,) datosx1 , ul a c ió n

36 plt . title, ( t' Sim
con 2 V a ri a bl es ' ) 37 plt . xlabel ( ' t [ s ] ' ) 38 plt . ylabel ( ' ' ) 39
plt . cuadrícula ( ) 40 plt . eje ([ −1
X
41 plt . mostrar ( )
, 1, −1,5 , 1.5])
Figura 3: Ejemplo de simulación con 2 variables
Solución alternativa:
1 # Sim ul a c ión con 2 V a ri a bl es 2 import

numpy as np 3 import mat pl o
4
5 # Parámetros del modelo
299
6b=1
7 p = 0. 5
8
10 Ts = 0. 1 11
T inicio = −1 12 Tstop
= 1 13 N = int
( ( Tstop−T start ) /Ts ) # Longitud simulada 14 x1 = np . ceros (N+2) 15 x2 =
np. ceros (N+2) 16 x1 [ 0 ] = 1 17
x2 [ 0 ] = 1
18
19
20 # Sim ul a ci on 21
para k inr an ge (N+1) : x1 [ k+1] =
22 x1 [ k ] − Ts x2 [ k ] x2 [ k+1] = x2 [ k ] +
23 Ts x1 [ k ]
24
25
26 # Trazar los resultados de la sim ul a ción 27 t = np .

arreglar (T start Ts) , Tstop+2 Ts ,
28
x1 plt
29 plt. parcela ( t x2 ), 30 , . ttitle
, ('
Sim ul a c ión con 2 V a ri a bl es ' ) 31 plt . xlabel ( ' t [ s ] ' ) 32 plt .
ylabel ( ' ' ) 33 plt . cuadrícula ( )
34 plt . eje ([ −1 35 plt . X
mostrar ( )
, 1 , −1,5 , 1 . 5 ] )
Elija el enfoque que más le convenga. También debe verificar el tiempo que toma la
simulación. Para simulaciones más grandes, esta segunda alternativa puede ser mejor.
300
Python para ciencia e ingeniería

Python For Science & Engineering - Traducido

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Python For Science & Engineering - Traducido

Cargado por

Copyright:

Formatos disponibles

Machine Translated by Google

Python es un lenguaje de programación popular y es uno de los lenguajes de programación más

Mi blog/sitio web [1]: https://

Aquí encuentras mi página web con recursos de Python:

Este libro de texto está escrito en LATEX utilizando Overleaf.

LATEX es un sistema de preparación de documentos utilizado para la comunicación y publicación

Para más información sobre LATEX:

Para más información sobre Overleaf: https://

• Programación en Python: este es un libro de texto sobre programación en Python con

• Python para ingeniería de control: este es un libro de texto sobre programación en

• Python para el desarrollo de software: este es un libro de texto sobre programación en

Aquí encontrará muchos recursos de programación: https://

Las principales partes o fases en el proceso de Ingeniería de Software son:

Aquí encontrará muchos recursos de ingeniería de software: https://

Primeros pasos con Python 13

3 Comience a usar Python

3.5.4 Ejecutar secuencias de comandos de Python desde Spyder. . . . . . . . . . . . . . 36

4 Programación básica en Python 4.1 39

5 Programación en Python 5.1

6 Creación de funciones en Python 63 .

6.2 Funciones con múltiples valores de retorno. . . . . . . . . . . . . . sesenta

7 Creación de clases en Python 7.1

8 Creación de módulos de Python

9 Manejo de archivos en Python

10 Manejo de errores en Python 10.1 82

12 Instalación y uso de paquetes de Python 12.1 86

III Entornos y distribuciones de Python 87

13 Introducción a los entornos y distribuciones de Python 88

18 código de estudio visual

IDE Python de 21 alas 111

22 Jupyter Notebook 22.1 113

V Python para aplicaciones matemáticas 116

23 Matemáticas en Python 117

24 Álgebra lineal en Python 24.1

25 números complejos en Python 146

26 Ecuaciones Diferenciales 150

28 Ajuste de curvas ­ Ajuste de modelos a datos

29 Método de mínimos cuadrados 183

30 Derivación numérica 30.1 187

31 Integración numérica 31.1 197

VI Uso de Python para simulaciones 209

33 Introducción a las simulaciones 210

34 Ecuaciones Diferenciales 211

35 Sistemas discretos 213

36 Simulaciones en tiempo real 36.1 219

VII Adquisición de datos (DAQ) con Python 235

37 Trazado de datos del sensor 236

38 Adquisición de datos (DAQ) con Python 38.1

VIII Desarrollo de base de datos Python 262

39 Aplicaciones de bases de datos con Python 263

40 MongoDB con Python 265

IX Desarrollo de aplicaciones Python 267

41 Desarrollo de Aplicaciones con Python 41.1 268

42 Integración de Python con Visual Studio 274

43 Integración de Python con LabVIEW 43.1

44 Raspberry Pi y Python 44.1 ¿Qué 280

45 Aprendizaje automático con Python 281

46 Python para usuarios de MATLAB 283

47 Recursos de Python 287

XI Soluciones a Ejercicios 291

Encontrará recursos adicionales en mi blog/sitio web [1]. https://

Mi sitio web sobre Python es: https://

28 Ajuste de curvas Ajuste de modelos a datos

Figura 1.1: Sitio Web Python

Figura 1.3: Los principales lenguajes de programación Encuesta de desbordamiento de pila

• MATLAB Cálculos numéricos y Computación científica

Figura 2.1: IDLE Editor básico de Python

• NumPy NumPy es el paquete fundamental para la computación científica con Python

• Pandas Biblioteca de análisis de datos Python de Pandas [11]

• El Tutorial oficial de Python https://

• Tutorial de Python (w3schools.com) [13] https://