BANCO CENTRAL DE RESERVA

DEL PERÚ

Programación con Python

Nivel Básico
Aplicado a Finanzas

Yessenia Portal Machuca

[email protected]

Enero, 2020
 PROGRAMACIÓN EN PYTHON
Nivel Básico

Índice
1. Acerca de Python 6
1.1. ¿Qué es Python? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2. Características de Python . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3. Breve historia de Python . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2. Acerca de Anaconda y los IDE para Pyhton 9

2.1. ¿Como instalar Anaconda? . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2. Iniciando en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.3. Comando de Navegación en Pyhton . . . . . . . . . . . . . . . . . . . . 22
2.4. Pyflakes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3. Identificadores de Python 24
3.1. Reglas para escribir identificadores . . . . . . . . . . . . . . . . . . . . . 24
3.2. Algunas consideraciones . . . . . . . . . . . . . . . . . . . . . . . . . . 24

4. Operadores 25
4.1. ¿Qué son los operadores? . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.2. Operadores aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.3. Operadores de comparación (relacionales) . . . . . . . . . . . . . . . . . 26
4.4. Operadores lógicos (booleanos) . . . . . . . . . . . . . . . . . . . . . . 27
4.5. Operadores de Asignación . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.6. Operadores Especiales . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.6.1. Operador de identidad . . . . . . . . . . . . . . . . . . . . . . . 28
4.6.2. Operador de Membresía . . . . . . . . . . . . . . . . . . . . . . 28

5. Tipos de Datos 30
5.1. Indexación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5.2. Números . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5.3. Secuencias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
5.3.1. Cadenas (Strings) . . . . . . . . . . . . . . . . . . . . . . . . . 32
5.3.2. Lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.3.3. Tupla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.4. Conjuntos (Set) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.5. Diccionario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.6. Conversión entre tipos de datos . . . . . . . . . . . . . . . . . . . . . . 42

6. Entrada y Salida 43
6.1. Función Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
6.2. Entrada de archivos: importación . . . . . . . . . . . . . . . . . . . . . 43
6.3. Salida usando la función print() . . . . . . . . . . . . . . . . . . . . . 44
6.4. Salida de archivos: exportación . . . . . . . . . . . . . . . . . . . . . . 46

7. Sentencia, indentado y comentarios 47

7.1. Sentencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
7.1.1. Declaración multilínea . . . . . . . . . . . . . . . . . . . . . . . 47
7.2. Indentación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
7.3. Comentarios de Python . . . . . . . . . . . . . . . . . . . . . . . . . . 48

Yessenia Portal Machuca 2 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

7.3.1. Comentarios multilínea . . . . . . . . . . . . . . . . . . . . . . . 49

7.3.2. Docstring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

8. Sentencias de Control 50
8.1. Sentencias selectivas: If, If-Else y If-Elif-Else . . . . . . . . . . . . . . . 50
8.1.1. Sentencia Selectiva if . . . . . . . . . . . . . . . . . . . . . . . 50
8.1.2. Sentencia Selectiva if...else . . . . . . . . . . . . . . . . . . . . 50
8.1.3. Sentencia if...elif...else . . . . . . . . . . . . . . . . . . . . . . . 51
8.1.4. Sentencias if anidadas . . . . . . . . . . . . . . . . . . . . . . . 51
8.1.5. Operador ternary . . . . . . . . . . . . . . . . . . . . . . . . . . 52
8.2. Sentencias iterativas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
8.2.1. Sentencia Iterativa for . . . . . . . . . . . . . . . . . . . . . . . 53
8.2.2. Sentencia Iterativa while . . . . . . . . . . . . . . . . . . . . . . 54

9. Funciones 56
9.1. ¿Qué es una función en Python? . . . . . . . . . . . . . . . . . . . . . 56
9.2. Tipos de funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
9.2.1. Función convencional . . . . . . . . . . . . . . . . . . . . . . . 56
9.2.2. ¿Cómo llamar a una función? . . . . . . . . . . . . . . . . . . . 57
9.2.3. La sentencia return . . . . . . . . . . . . . . . . . . . . . . . . 57
9.2.4. Tipos de argumentos de una función . . . . . . . . . . . . . . . 58
9.2.5. Funciones Lambda . . . . . . . . . . . . . . . . . . . . . . . . . 60
9.3. Docstring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
9.4. Ámbito y vida útil de las variables . . . . . . . . . . . . . . . . . . . . . 61
9.5. Almacenamiento de sus funciones en Módulos . . . . . . . . . . . . . . 62

10.Clases y objetos 63
10.0.1. ¿Qué es un Objeto? . . . . . . . . . . . . . . . . . . . . . . . . 63
10.0.2. ¿Qué es una Clase? . . . . . . . . . . . . . . . . . . . . . . . . 63

11.Paquetes 65
11.1. ¿Qué son los paquetes? . . . . . . . . . . . . . . . . . . . . . . . . . . 65
11.2. El Stack Científico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
11.3. ¿Qué son los módulos en Python? . . . . . . . . . . . . . . . . . . . . . 67
11.4. ¿Cómo importar módulos en Python? . . . . . . . . . . . . . . . . . . . 67
11.5. Sentencia import . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
11.6. Importar con cambio de nombre . . . . . . . . . . . . . . . . . . . . . . 68
11.7. Sentencia from ... import ... . . . . . . . . . . . . . . . . . . . . . . . . 69
11.8. Importar todas las funciones . . . . . . . . . . . . . . . . . . . . . . . . 69
11.9. Búsqueda de módulo de Python . . . . . . . . . . . . . . . . . . . . . . 70
11.10.Recargando un módulo . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
11.11.La función intertna dir() . . . . . . . . . . . . . . . . . . . . . . . . . 71

12.Librería Numpy 73
12.1. ¿Qué es Numpy? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
12.2. ¿Cómo puedo crear un array? . . . . . . . . . . . . . . . . . . . . . . . 73
12.3. Combinar array y tipos de datos en NumPy . . . . . . . . . . . . . . . . 76
12.4. Operaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
12.5. Broadcasting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

Yessenia Portal Machuca 3 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

12.6. Funciones agregadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

12.7. Indexación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
12.7.1. Basic slicing (rebanado básico). . . . . . . . . . . . . . . . . . . 80
12.7.2. Indexación Avanzada. . . . . . . . . . . . . . . . . . . . . . . . 81
12.8. Conjuntos estructurados . . . . . . . . . . . . . . . . . . . . . . . . . . 82

13.Pandas 84
13.1. ¿Qué es Pandas? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
13.2. Series . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
13.2.1. Creación e indexación de Series . . . . . . . . . . . . . . . . . . 85
13.2.2. Tamaño, forma y conteo de valores . . . . . . . . . . . . . . . . 88
13.2.3. Alineación mediante etiquetas de índice . . . . . . . . . . . . . . 89
13.3. El DataFrame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
13.3.1. Creación de un DataFrame . . . . . . . . . . . . . . . . . . . . 90
13.3.2. Selección de columnas de un DataFrame . . . . . . . . . . . . . 93
13.3.3. Selección de filas de un DataFrame mediante el índice . . . . . . 94
13.3.4. Selección de líneas mediante la selección Boolean . . . . . . . . . 97
13.3.5. Aritmética en un DataFrame . . . . . . . . . . . . . . . . . . . 98
13.4. Reindexación de los objetos Series y DataFrame . . . . . . . . . . . . 99
13.5. Manipulación de DataFrame aplicado a Finanzas. . . . . . . . . . . . . . 103
13.5.1. Reorganización y reestructuración de datos . . . . . . . . . . . . 104
13.5.2. Agrupación y agregación . . . . . . . . . . . . . . . . . . . . . . 115

14.Matplotlib 122
14.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
14.2. Pyplot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
14.3. Multiples figuras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
14.4. Elementos del gráfico . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
14.4.1. Texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
14.4.2. Cuadrícula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
14.4.3. Leyenda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
14.5. Tipos de gráficos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
14.5.1. Gráficos de líneas . . . . . . . . . . . . . . . . . . . . . . . . . 132
14.5.2. Gráficos de líneas con pandas . . . . . . . . . . . . . . . . . . . 134
14.5.3. Histogramas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
14.5.4. Gráficos de barras . . . . . . . . . . . . . . . . . . . . . . . . . 136
14.5.5. Gráficos de barras horizontales . . . . . . . . . . . . . . . . . . 138
14.5.6. Gráficos de barras multiseries con Dataframe de pandas . . . . . 140
14.5.7. Gráficos de barras apiladas de multiseries . . . . . . . . . . . . . 141
14.5.8. Gráficos de barras apilados con un Dataframe de pandas . . . . . 142
14.5.9. Otras Representaciones de Gráficos de Barras . . . . . . . . . . . 143
14.5.10.Gráficos de Pie . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
14.5.11.Gráficos de tarta con un Dataframe de pandas . . . . . . . . . . 147
14.5.12.Gráficos avanzados: Polares . . . . . . . . . . . . . . . . . . . . 147
14.6. Gráficos 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
14.6.1. Superficies 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
14.6.2. Gráficos de barras en 3D . . . . . . . . . . . . . . . . . . . . . . 150
14.7. Gráficos Multi-Panel . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
14.7.1. Visualizar subplots dentro de otras subplots . . . . . . . . . . . . 151

Yessenia Portal Machuca 4 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

14.7.2. Cuadrículas de subplots . . . . . . . . . . . . . . . . . . . . . . 152

15.Paquetes para aplicaciones financieras 153

15.1. Statsmodels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
15.2. Visualize Wealth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

Yessenia Portal Machuca 5 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

1. Acerca de Python
1.1. ¿Qué es Python?
Python es un lenguaje de programa-
ción multiplataforma (es decir, se eje-
cuta en múltiples plataformas como
Windows, Mac OS X, Linux, Unix e
incluso se ha adaptado a las máqui-
nas virtuales Java y .NET.)
Python está disponible para todos los
principales sistemas operativos, como
Windows, Linux / Unix, OS / 2 y
Mac. Es un lenguaje fácil de apren-
der y entender, la mayoría de las libre-
rías/módulos y herramientas disponi-
bles son de código abierto y general-
mente vienen con licencias libres.
La mejora continua del lenguaje Pyt-
hon ha sido posible gracias a un gru-
po de personas dedicadas y compro-
metidas a apoyar la causa de propor-
cionar el servicio.

1.2. Características de Python

A continuación se describen las caracteristicas más importantes de Python:

1. Fácil: El código, en Python, es conciso y efectivo y por lo tanto comprensible y

manejable.

2. Escribir y Ejecutar: En Python, un código se puede ejecutar fácilmente, creando

y ejecutando scripts. Python también proporciona al usuario un entorno interactivo
en el que se pueden ejecutar comandos independientes.

3. Sintaxis: La sintaxis de Python es sencilla, esto hace que el aprendizaje y la

comprensión del proceso sea fácil. De acuerdo a la mayoría de los autores, las tres
características principales que hacen atractivo a Python son: es simple, pequeño,
flexible.

4. Emsamblaje: Python permite integrar otros lenguajes de programación, con el

módulo Scipy.

5. Escritura dinámica: Python tiene su propia manera de gestionar la memoria

asociada a los objetos. Cuando se crea un objeto en Python, la memoria se le
asigna dinámicamente. Cuando el ciclo de vida del objeto termina, la memoria se
recupera de él. Esta gestión de memoria de Python hace que los programas sean
más eficientes.

Yessenia Portal Machuca 6 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

6. Tipo de objetos generados: Python ha construido tipos de objetos. Esto hace

que la tarea a realizar sea fácil y manejable.

7. Numerosas librerías y herramientas: La tarea a realizar se vuelve fácil, dado

debe a que la mayoría de las tareas comunes (de hecho, no tan comunes también)
ya han sido programadas en Python.

8. Portable: Un programa escrito en Python puede ejecutarse en casi todas las

plataformas conocidas, ya sea Windows, Linux o Mac.

9. Libre: Python no es un software de propiedad, es posible descargar de varias

opciones disponibles. Además, no se conocen problemas legales relacionados con
la distribución de Python.

1.3. Breve historia de Python

La historia del lenguaje de programación Python 1 se remonta hacia finales de los 80s
y principio de los 90s1, su implementación comenzó en diciembre de 1989 cuando en
Navidad, Guido Van Rossum 2 que trabajaba en el CWI (un centro de investigación ho-
landés de carácter oficial que) decidió empezar el proyecto como un pasatiempo dándole
continuidad al lenguaje de programación ABC del que había formado parte del equipo de
desarrollo en el CWI, dicho lenguaje se enfocaba en ser fácil de usar y aprender mante-
niendo potencia en su desempeño pero el hardware disponible en la época de su creación
hacía difícil su uso y el proyecto no trascendió como se esperaba. Van Rossum es por
tanto el autor principal de Python 3 y continúa ejerciendo un rol central, decidiendo
la dirección del lenguaje; en la comunidad de Python se le conoce como Benevolente
Dictador Vitalicio.
Python tiene aplicaciones en:

Desarrollo de interfaz gráfica de usuario (GUI)

Páginas web

Programación de base de datos

Juego de azar

Programación basada en componentes

El análisis científico

Machine Learning, entre otros.

1
El nombre del lenguaje viene del espectáculo de la BBC “Monty Python’s Flying Circus” (el circo
ambulante de Monty Python) y no tiene nada que ver con desagradables reptiles.
2
Guido van Rossum es un científico de computación de la Universidad de Amsterdam. En el año
2001 recibió el FSF Award for the Advancement of Free Software por haber inventado e implementado
el lenguaje de programación Python. En diciembre de 2005 fue contratado como desarrollador por la
empresa estadounidense Google, y luego de siete años, a principios de diciembre de 2019, anuncia su
retirada de la empresa norteamericana para incorporarse en enero de 2013 a la compañía Dropbox.
3
El continuo papel central de Guido van Rossum en la dirección de Python se refleja en el título
que la comunidad de Python le dió, "El Dictador Benevolente de por vida", (BDFL, por sus siglas en
inglés).

Yessenia Portal Machuca 7 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Figura 1: Algunas aplicaciones de Python

Python
applications

Web GUI Software Scientific

Finance
development development development applications

Numpy, Pandas,
Django Kivi Scions Scipy, Matplotlib, Numpy.lib.financial,
statsmodels pandas_datareader,
yahoo-finance,
Python_finance,
finance, economics.

Muchos ambientes de desarrollo y editores están disponibles para Python. Algunos

de ellos son los siguientes:

1. Spyder

2. Jupyter Notebook

3. Jupyter Lab

4. PyDev with Eclipse

5. Emacs

6. Vim

7. Gedit

8. Idle

9. PIDA (Linux)(VIM based)

10. BlueFish (Linux)

Yessenia Portal Machuca 8 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

2. Acerca de Anaconda y los IDE para Pyhton

Anaconda Navigator es una interfaz gráfica de usuario (GUI) de libre distribución
de los lenguajes Pyhton y R, que permite iniciar aplicaciones y administrar fácilmente
paquetes, entornos y canales sin usar comandos. Navigator puede buscar paquetes en
Anaconda Cloud o en un repositorio local de Anaconda. Está orientado a simplificar el
despliegue y administración de los paquetes, y está disponible para Windows, macOS y
Linux.

2.1. ¿Como instalar Anaconda?

Para instalar Anaconda debe seguir los siguientes pasos:

Paso 1: ir a https://docs.anaconda.com/anaconda/install/hashes/win-3-64/

Yessenia Portal Machuca 9 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Paso 2: Ejecutar el archivo .exe descargado para comenzar con la instalación.

- Clic en: “I Agree”.

Yessenia Portal Machuca 10 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

-Seleccionar “Just Me”, si solo quieren que se instale para su usuario de Windows.

- Elegir la carpeta donde se instalará el programa.

Yessenia Portal Machuca 11 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

- Clic en “Install”.

- Clic en Next.

Yessenia Portal Machuca 12 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

- Clic en “Finish”.

2.2. Iniciando en Python

Existen varias formas de iniciar Python: 1) en modo inmediato, o 2) A partir de un
IDE. En este curso se explora los IDE: JupyterLab, Jupyter Notebook y Spyder.

Yessenia Portal Machuca 13 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

1. Modo inmediato

Python 3.7.4 (última versión a la fecha) puedes descargarlo desde el link:

https://www.python.org/downloads/

Podemos escribir directamente expresiones de Python y presionar enter para

obtener la salida.
>>>

es el prompt de Python, el cual indica que el intérprete está listo iniciar.

Para salir de este tipo de modo se debe digitar exit() o quit() y presionar
enter.
Este prompt se puede utilizar como una calculadora. En Python se puede
sumar, restar, multiplicar, dividir y realizar en la línea de comandos.
∗ La multiplicación se puede hacer usando el archivo *
∗ La división se puede realizar utilizando el operador /
∗ La exponenciación se puede hacer usando el operador ** y
∗ El módulo se puede encontrar usando el comando %. El operador del
módulo encuentra el resto si el primer número es mayor que el otro, de
lo contrario devuelve el primer número como salida.

Yessenia Portal Machuca 14 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Los resultados de las operaciones se muestran a continuación:

2. En un Entorno de Desarrollo Integrado (IDE)

El uso de un IDE puede eliminar tareas redundantes y disminuir significativa-

mente el tiempo requerido para el desarrollo de aplicaciones.
El IDE es una pieza de software que proporciona funciones útiles como su-
gerencias de código, resaltado y comprobación de sintaxis, exploradores de
archivos, etc. para facilitar al programador el desarrollo de aplicaciones.
Se utiliza un IDE para ejecutar un programa Python escrito en un archivo.
Tal archivo se llama un script.
Los scripts se pueden guardar en el disco para su uso futuro. Es importante
mencionar que para escribir un archivo script de Python se puede usar cual-
quier software de edición de texto. Solo se debe guardar con la extensión
.py.
A continuación se describen tres IDE (gratuitos) que se explorará en el curso:

a) Modo Script Spyder

∗ Spyder es un entorno de desa-

rrollo integrado (IDE) multi-
plataforma de código abierto
para programación científica en
el lenguaje Python, que se pu-
blica bajo la licencia MIT. Ini-
cialmente creado y desarrolla-
do por Pierre Raybaut en 2009.
Está disponible multiplatafor-
ma a través de Anaconda, en
Windows, en macOS a través
de MacPorts y en las principa-
les distribuciones de Linux.

Yessenia Portal Machuca 15 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

∗ La ventana predeterminada de Spyder tiene tres paneles: el panel de

IPython, el panel de edición y el panel de ayuda.

∗ El panel IPython (IPython Pane) es la forma principal que in-

teractúes con Python. Puede utilizarse para ejecutar programas de
ordenador Python, probar fragmentos de código Python, navegar por
los directorios de archivos del ordenador y realizar tareas de sistema
como crear, mover y eliminar archivos y directorios. El indicador de
entrada predeterminado del panel de IPython tiene este aspecto:
In [1]:
Este aviso significa que Spyder está ejecutando el shell de IPython.
∗ El Panel de edición (Editor Pane) permite escribir y editar progra-
mas Python (o scripts), que son simplemente secuencias de coman-
dos Python (código) almacenados en un archivo en su ordenador.
∗ El Panel de Ayuda (Help Pane) en Spyder da ayuda en los coman-
dos de Python. Una característica interesante del IDE de Spyder es
que si coloca el cursor al lado o dentro del nombre de una función
y presiona Ctrl+I, la documentación web de la función se muestra
en el Panel de Ayuda. Otra forma de obtener información de una
función, es ejecutando el comando help, seguido del nombre de la
función entre paréntesis, así por ejemplo:
In [1]: help(range)

∗ Estos paneles en la ventana de Spyder son reconfigurables y des-

montables, es posible ajustar el tamaño total de la ventana para
que se adapte a la pantalla de su ordenador. Puede encontrar más
información sobre Spyder en https://www.spyder-ide.org/.

Importante: Python distingue entre mayúsculas y minúsculas.

Por lo tanto, dos palabras deletreadas de la misma manera pero
con letras mayúsculas diferentes son tratadas como nombres
diferentes en Python.

Yessenia Portal Machuca 16 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

∗ En la siguiente figura se visualiza un ejemplo de ejecución en modo

scripts (trabajo.py) y ejecución desde el interprete.

Ejecución modo Script

Ejecución desde el
intérprete

∗ Para crear un archivo script siga los siguientes pasos:

– Paso 1. Ir a Nuevo archivo (Ctrl+N)
– Paso 2. Guardar el archivo como calc.py
– Paso 3. Escribir el código Python en el archivo
print(2+3)
print(2*3)
print(2**3)
print(2/3)
print(2 %3)
print(3/2)

– Paso 4. Dar clic en el boton ejecutar del IDE Spyder. Se visuali-

zará la siguiente salida.

Yessenia Portal Machuca 17 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

b) Modo Notebook Jupyter

Permite trabajar de forma interacti-

va, almacenar y ejecutar programas
en un cuaderno Jupyter tal como
se haría dentro del IDE Spyder. Un
cuaderno Jupyter, es excelente pa-
ra registrar un trabajo en Python,
y muy útil en un entorno de labora-
torio para leer, registrar y analizar
datos, entregar tareas, documentar
y probar el software.

Para iniciar en Jupyter Notebook, ejecute el software en el panel de

Anaconda y esto hará que inicie la aplicación web Jupyter, mostrando
Jupyter Notebook Dashboard como página en su navegador web prede-
terminado.

En la parte inferior izquierda del panel de control hay una lista de carpetas
(y archivos) del directorio predeterminado. Puede navegar a la carpeta
donde desea almacenar su trabajo, o crear una carpeta nueva, haciendo
clic en el botón Nuevo situado en la parte superior derecha del panel y
seleccionando Carpeta. Finalmente, para crear un nuevo cuaderno Jupy-
ter, vaya al menú desplegable Nuevo en el lado derecho de la página y
seleccione Python 3.

Cuando se abre un nuevo cuaderno Jupyter, un IPython interactivo apa-

rece con el mensaje:
In[ ]:
En este celda puede escribir el código como lo harías en el panel IPython
del IDE Spyder. Por ejemplo, escribiendo en la celda
5+5
y para ejecutar presionar Shift+Enter.

Yessenia Portal Machuca 18 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Cuaderno Jupyter
∗ Los cuadernos Jupyter son aplicaciones web que se ejecutan local-
mente y que contienen código Pyhton, código LaTeX y texto Mark-
down. El lenguaje estándar es Python, sin embargo, tenga en cuenta
que una variedad de alternativas son compatibles, como por ejemplo
R.
∗ Un cuaderno Jupyter será más fácil de entender si incluye anotacio-
nes que expliquen lo que está ejecutando en el cuaderno. Además de
registrar las entradas y salidas de los cálculos, los cuadernos Jupyter
permiten al usuario insertar encabezados, notas explicativas, expre-
siones matemáticas e imágenes.

∗ Encabezados y texto: Supongamos, por ejemplo, que queremos

tener un título en la parte superior de la ventana de diálogo Jupyter
con el que hemos estado trabajando, y queremos incluir el nombre
del autor de la sesión. Para hacer esto, desplazamos el Jupyter hasta
la parte superior y colocar el cursor en la primera celda, insertamos
una nueva celda y seleccionamos tipo de celda Markdown, inmedia-
tamente desaparece el indicador
In [ ]:
indicando que esta casilla ya NO es para ejecutar código Python.
A continuación, escriba # ingrese texto. Recuerde que cada #
adicional disminuye el tamaño de la fuente.

∗ Expresiones matemáticas: También es posible incluir expresiones

matemáticas, en una celda de un cuaderno de Jupyter. De igual
forma se debe elegir el tipo de celda Markdown y digitar la expresión
matemática usando el lenguaje LaTeX (puede obtener información
al respecto en http://en.wikibooks.org/wiki/LaTeX/Mathematics).
\begin{align}
x = \int_0^T v(t)\, dt
\end{align}

Yessenia Portal Machuca 19 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

∗ Insertar imágenes: para incluir en su cuaderno Jupyter imágenes,

como JPEG y PNG, utilice la clase de imagen del módulo display
del paquete IPython. Por ejemplo, ejecutando el siguiente código
muestra la siguiente salida.
from IPython.display import Image
Image(url=’http://python.org/images/python-logo.gif’)

∗ Insertando videos de YouTube: el módulo lib.display del pa-

quete IPython contiene una función YouTubeVideo, donde puede
insertar vídeos alojados externamente en YouTube. Por ejemplo, eje-
cute el siguiente código:
from IPython.lib.display import YouTubeVideo

# Video como instalar Anaconda.

YouTubeVideo(’52h3r_lROGY’)

El video se verá debajo del código, como se muestra en la figura

anterior.

Yessenia Portal Machuca 20 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

∗ Editar y volver a ejecutar un cuaderno Jupyter: Al trabajar con

un cuaderno Jupyter, es posible que desee mover algunas celdas, o
eliminar algunas celdas, o simplemente cambiar algunas de ellas.
Todas estas tareas puede hacerde desde el menú edición, en tanto
que para volver a ejecutar el código de un cuaderno puede hacerlo
desde el menú kernel seleccionando “Run All”.
– Salir de un cuaderno Jupyter: Cuando esté listo para dejar de
trabajar con un cuanderno Jupyter, haga clic en el elemento cerrar
y detener del menú Archivo. Se cerrará la pestaña del navegador
y volverá al panel de control de Jupyter. Finalmente, cierre la pes-
taña IPython Notebook Dashboard en su navegador para finalizar
la sesión.
– Trabajar con un portátil Jupyter existente: Inicie el Dash-
board de Jupyter donde debería ver una lista de todos los cuader-
nos Jupyter en ese directorio. Haga clic en el nombre del cuaderno
que desea abrir. Para inicializar todos los objetos del fichero, debe
volver a ejecutar el fichero.

c) Modo JupyterLab
JupyterLab es un entorno de desarrollo interactivo basado en la web para
código y datos Jupyter. Si bien JupyterLab permite el uso de cuadernos
Jupyter, va más allá del clásico Jupyter Notebook al proporcionar una
aplicación web flexible y extensible con un conjunto de componentes
reutilizables.
∗ JupyterLab es flexible: se debe configurar y organizar la interfaz de
usuario para soportar una amplia gama de flujos de trabajo en ciencia
de datos, computación científica y Matching Learning.
∗ JupyterLab es extensible y modular: escriba plugins que añadan nue-
vos componentes e integren con los ya existentes.

Bloomberg recientemente ha incorporado la plataforma BQuant,

utilizando cuadernos Jupyter, permitiendo la escritura de códigos
Python que hacen uso de bibliotecas Python y la biblioteca finan-
ciera de Bloomberg (PyBQL) con las que se puede crear cuadernos
informáticos interactivos para realizar y documentar los análisis fi-
nancieros, sin salir del terminal.

Yessenia Portal Machuca 21 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

2.3. Comando de Navegación en Pyhton

IPython reconoce varios comandos de navegación comunes que se usan bajo los
sistemas operativos Unix/Linux. Los siguientes comandos funcionan en Macs, Win-
dows y Linux.

Para establecer su ordenador en el directorio de inicio por default, utilice el siguiente

código:
In [1]: %cd ~
/Users/Yessenia

Para mostrar la ruta del directorio actual del ordenador, se puede utilizar el código:
In [2]: %pwd
Out[2]: ’/Users/Yessenia’

Para crear una carpeta dentro de su directorio de documentos, escriba el código %ls
para listar los archivos y directorios en su directorio raíz, luego escriba %mkdir
programas y se creará esta nueva carpeta en su directorio. Finalmente, para validar
que se ha creado la nueva carperta, ejecute %ls.
In [7]: %cd ~
/Users/pine
In [8]: %ls
Applications/ Library/ Pictures/
Desktop/ Movies/ Public/
Documents/ Music/
Downloads/ News/

In [9]: %mkdir programs

In [10]: %ls
Applications/ Library/ Pictures/
Desktop/ Movies/ Public/
Documents/ Music/ programs/
Downloads/ News/

Para configurar su directorio a una ruta en especifico, ejecute el siguiente código:

import os
os.chdir(’C:\\Users\Yessenia\Downloads’)

Para limpiar el terminal IPython escriba el comando %clear o cls, lo que le dará
una nueva ventana del interprete.

Yessenia Portal Machuca 22 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

2.4. Pyflakes
Una forma de evitar errores es utilizar un verificador de sintaxis. Afortunadamente,
el IDE de Spyder incluye un verificador de sintaxis, denominado Pyflakes que se
ejecuta en segundo plano cuando se está editando un programa Python usando
Spyder. Si hay un error en su código, Pyflakes marca el error.

El Editor Spyder, proporciona resaltado de sintaxis, que codifica palabras clave, co-
mentarios y otras características de la sintaxis de Python de acuerdo a su función, y
por lo tanto facilita la lectura del código y la detección de errores de programación.
El Editor ortográfico también proporciona la comprobación de la sintaxis, como un
corrector ortográfico en un programa de procesamiento de textos, que identifica
muchos errores de codificación. Esto puede acelerar enormemente el proceso de
codificación.

En Spyder, un círculo rojo aparece a la izquierda de la línea donde Pyflakes cree

que el error ocurre. Un triángulo amarillo aparece a la izquierda de la línea donde
Pyflakes piensa que el estilo de codificación no se ajusta al estándar PEP 84 ; esto
no es un error, sólo una violación del estilo de codificación, que puedes ignorar
o tener en cuenta. Al pasar el puntero del ratón sobre el icono rojo o amarillo,
aparece un cuadro de análisis de código con un breve mensaje que describe el error
o la infracción de estilo.

4
Es un documento guía de estilo para Pyhton, que no es de seguimiento obligatorio, pero es altamente
recomendable. Puede encontrar mayor información en: https://www.python.org/dev/peps/pep-0008/

Yessenia Portal Machuca 23 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

3. Identificadores de Python
Un identificador es el nombre asignado a entidades como clase, funciones, variables,
etc; ayudando a diferenciar una entidad de otra.

3.1. Reglas para escribir identificadores

1. Los identificadores pueden ser una combinación de letras en minúsculas (de la a a
la z) o en mayúsculas (de la A a la Z) o en los dígitos (de 0 a 9) o un subrayado
(_).
Nombres como miClase, var_1y y imprimir_en_pantalla, son ejemplos váli-
dos.
2. Un identificador no puede comenzar con un dígito. 1variable no es válido, pero
variable1 está perfectamente bien.
3. Las palabras clave no se pueden utilizar como identificadores.
>>> global = 1
File "<interactive input>", line 1
global = 1
^
SyntaxError: invalid syntax

4. No podemos usar símbolos especiales como !, @, #, $, %, etc. en nuestro identifi-

cador.
>>> a@ = 0
File "<interactive input>", line 1
a@ = 0
^
SyntaxError: invalid syntax

5. El identificador puede ser de cualquier longitud.

3.2. Algunas consideraciones

Recordemos que Python es un lenguaje case-sensitive (distingue entre mayúscu-
las y minúsculas); esto es, Variable y variable no son lo mismo.
Es siempre conveniente nombrar identificadores que guarden sentido;
Por ejemplo c=10 es válido, pero escribir contador=10 tendría más sentido y sería
más fácil si se tratara de crear una variable que se encarga de llevar una operación
de conteo.
Las palabras múltiples pueden ser escrita en forma separada:
∗ usando un guión, esta_es_una_larga_variable, o
∗ usando el estilo tipo camello, esto es, poner en mayúscula cada prime-
ra letra de la palabra, excepto la primera, y sin separarlas; por ejemplo:
ejemploCasoCamello.

Yessenia Portal Machuca 24 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

4. Operadores
4.1. ¿Qué son los operadores?
Los operadores son símbolos especiales en Python que realizan cálculos aritméticos
o lógicos.

El valor en el que opera el operador se llama operando.

Por ejemplo:
>>> 2+3
5

Aquí, + es el operador que realiza la suma, 2 y 3 son los operandos y 5 es la salida

de la operación.

4.2. Operadores aritméticos

Los operadores aritméticos se utilizan para realizar operaciones matemáticas como
suma, resta, multiplicación, etc.

Operador Significado Ejemplo

Agrega dos operandos x+y
+
o un más unario +2
Resta el operando derecho de la izquierdo x-y
-
o menos unario -2
* Multiplicar dos operandos x*y
Dividir el operando izquierdo por el derecho
/ x/y
(siempre resulta en float)
Módulo - resto de la división del o x %y
%
perando izquierdo por el derecho (resto de x/y)
División de piso: división que resulta en un número
// x//y
entero ajustado a la izquierda en la recta numérica
Exponente - operando izquierdo x**y
**
elevado a la potencia del operador derecho (x a la potencia y )

Ejemplo: Operadores Artiméticos

∗ Se tiene el siguiente código x * y

x = 15
y = 4 # Output Div:
x / y
# Output sum:
x + y # Output Div_p:
x // y
# Output dif:
x - y # Output Potencia:
x ** y
# Output mult:

Yessenia Portal Machuca 25 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

∗ Luego de ejecutarse línea a línea se Out[9]: 60

obtiene la siguiente salida x / y
x + y Out[10]: 3.75
Out[7]: 19 x // y
x - y Out[11]: 3
Out[8]: 11 x ** y Out[12]: 50625
x * y

4.3. Operadores de comparación (relacionales)

Los operadores de comparación son usados para comparar valores. Retornan True
o False según la condición.

Operador Significado Ejemplo

Mayor que
> x>y
True si el operador izquierdo es mayor que el derecho
Menor que
< x<y
True si el operador derecho es mayor que el izquierdo
Identico a
== x==y
True si ambos operandos son iguales
Diferente de
!= x!=y
True si ambos operandos son diferentes
Mayor o igual que
>= x>=y
True si el operador izquierdo es mayor o igual que el derecho
Menor o igual que
<= x<=y
True si el operador derecho es mayor o igual que el izquierdo

Ejemplo: Operadores de Comparación

x = 10
y = 12

# Output: x > y es False

x>y

# Output: x < y es True

x<y

# Output: x == y es False
x==y

# Output: x != y es True
x!=y

# Output: x >= y es False

x>=y

# Output: x <= y es True

x<=y

Yessenia Portal Machuca 26 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

4.4. Operadores lógicos (booleanos)

Los operadores lógicos son los operadores and, or y not

Operador Significado Ejemplo

and Verdadero si ambos son verdaderos x*y
or Verdadero si al menos uno de los operandos es verdadero x*y
not Verdadero si el operador es falso (complementa el operando) (resto de x/y)

En muchos casos la ejecución de un bloque depende del valor real de más de una
sentencia. En estos casos, los operadores " and " ( " & ") y " or " ( "|") acuden
en nuestro rescate. La primera (’and’) se utiliza cuando la salida es ’verdadera’,
cuando ambas condiciones son ’verdaderas’. La segunda (’or’) se utiliza si la salida
es ’verdadera’, si alguna de las condiciones es ’verdadera’.
Ejemplo: Operadores Lógicos
x = True
y = False

# Output: x and y is False

x and y

# Output: x or y is True
x or y

# Output: not x is False

not x

4.5. Operadores de Asignación

Operador Ejemplo Equvalente a

= x = 5 x = 5
+= x += 5 x = x + 5
/= x -= 5 x = x - 5
%= x %= 5 x = x %5
//= x //= 5 x = x//5
**= x **= 5 x = x**5
&= x &= 5 x = x&5
|= x |= 5 x = x|5
^= x ^= 5 x = x^5
>>= x >>= 5 x = x>>5
<<= x <<= 5 x = x<<5

4.6. Operadores Especiales

El lenguaje Python ofrece un tipo especial de operadores como el operador de
identidad o el operador de membresía.

Yessenia Portal Machuca 27 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

4.6.1. Operador de identidad

is e is not son operadores de identidad. Se utilizan para verificar si dos valores
(o variables) están ubicados en la misma parte de la memoria.

Dos variables que son iguales no implican que sean idénticas.

Operador Significado Ejemplo

True si los operandos son idénticos
is x es True
(referencian al mismo objeto)
True si los operandos no son idénticos
is not x no es True
(no referencian al mismo objeto)

Ejemplo: Operadores de identidad

x1 = 5
y1 = 5
x2 = ’Hello’
y2 = ’Hello’
x3 = [1,2,3]
y3 = [1,2,3]

# Output: False
x1 is not y1

# Output: True
x2 is y2

# Output: False
x3 is y3

En el ejemplo Operadores de Identidad:

∗ Se visualiza que x1 y y1 son números enteros de los mismos valores, por lo

que son iguales e idénticos. Lo mismo ocurre con x2 y y2 (cadenas).
∗ Sin embargo x3 y y3 son listas. Son iguales pero no idénticos. Es porque el
intérprete los ubica por separado en la memoria aunque son iguales.

4.6.2. Operador de Membresía

in y not in son los operadores de membresía en Python. Se utilizan para probar
si un valor o variable se encuentra en una secuencia ( cadena, lista, tupla, conjunto
y diccionario ).

En un diccionario solo podemos probar la presencia de una clave, no el valor.

Operador Significado Ejemplo

True si se el valor/variable
in 5 in x
se encuentra en la secuencia
True si se el valor/variable
is not 5 not in x
no se encuentra en la secuencia

Yessenia Portal Machuca 28 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Ejemplo: Operadores de Membresía

x = ’Hello world’
y = {1:’a’,2:’b’}

# Output: True
’H’ in x

# Output: True
’hello’ not in x

# Output: True
1 in y

# Output: False
’a’ in y

Yessenia Portal Machuca 29 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

5. Tipos de Datos
Python permite al usuario manipular variables para almacenar valores, y cada valor
en Python tiene un tipo de dato (no necesitan ser declaros) .

Los objetos en Python tienen identidad, un tipo y un valor (dado por el usuario
/ o un valor por defecto). La identidad, en Python, se refiere a la dirección y no
cambia. El tipo de dato puede ser cualquiera de los siguientes.

1. Ninguno: Esto representa la ausencia de un valor.

2. Números: Python tiene tres tipos de números:

a) Enteros: No tiene ninguna parte fraccionaria.

b) Float: Puede almacenar un número con una parte fraccionaria.
c) Complejos: Puede almacenar partes reales e imaginarias.

3. Secuencias: Son colecciones ordenadas de elementos. Hay tres tipos de secuencias

en Python:

a) Cadenas (string)
b) Tuplas (tuples)
c) Listas (list)

4. Sets: Se trata de una colección de elementos desordenados.

a) Conjuntos
b) Diccionarios

5.1. Indexación
En Python el operador de indice[] permite acceder a un elemento de una
secuencia.

El índice del elemento al que se desea acceder debe ser un número entero.

La sintaxis del operador [] es la siguiente.

<nombre_sencuencia>[index]

En Python el primer elemento está en la posición 0, no en la posición 1.

El siguiente gráfico ilustra los tipos de indexación.

>>> +---+---+---+---+
>>> |-4 |-3 |-2 |-1 | <= negative indexes
>>> +---+---+---+---+
>>> | A | B | C | D | <= sequence elements
>>> +---+---+---+---+
>>> | 0 | 1 | 2 | 3 | <= positive indexes
>>> +---+---+---+---+

Yessenia Portal Machuca 30 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Cada objeto almacenado en una secuencia tiene un número de índice asociado po-
sitivo, cero indexado y que comienza desde la izquierda, y el negativo que comienza
en -1 desde la derecha.

En Python los tipos de secuencias fundamentales son: String, listas, tuplas.

5.2. Números
La categoría numérica está compuesta por los números enteros, los números de
punto flotante y los números complejos. Se definen las clases int, float y
complex en Python.

La función type() permite consultar a qué tipo de dato pertenece una variable
o un valor; y la función isinstance() para verificar si un objeto pertenece a un
tipo de dato en particular.
a = 5
type(a)

b = 2.0
type(b)

c = 1+2j
isinstance(c,complex)

Un numero entero pueden ser de cualquier longitud, solo está limitado por la
memoria disponible.

Ejemplos de operaciones matemáticas:

>>> 2 + 3
5
>>> 3 - 2
1
>>> 2 * 3
6
>>> 3 / 2
1.5

Los enteros y punto flotante están separados por puntos decimales. 1 es entero,
1.0 es numero de punto flotante.

Python llama a cualquier número con punto decimal: un número de punto flo-
tante. Este término se utiliza en la mayoría de los lenguajes de programación, y
se refiere al hecho de que un punto decimal puede aparecer en cualquier posición
de un número. Este tipo de dato es exacto hasta 15 decimales.

Los números complejos se escriben en la forma, x + yj donde x es la parte real

e y es la parte imaginaria.

Yessenia Portal Machuca 31 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Ejemplos.
a = 1234567890123456789
a
1234567890123456789

b = 0.1234567890123456789
b
0.12345678901234568

c = 1+2j
c
(1+2j)

Observe que la variable float b fue truncada.

5.3. Secuencias
5.3.1. Cadenas (Strings)
En Python una cadena es un objeto predefinido que contiene una serie de carac-
teres.

Se usa comillas simples o dobles para representar cadenas. Las cadenas de varias
líneas se pueden denotar mediante comillas triples, ”’ o """.
s = "Esto es una cadena"
s = ’’’una
multilinea’’’

"This is a string."
’This is also a string.’

Esta flexibilidad permite utilizar comillas y apóstrofes dentro de las strings:

’Puedo decir, "¡Python es mi idioma favorito!"’
"El lenguaje ’Python’ se llama así por Monty Python."
"Uno de los puntos fuertes de Python es su comunidad diversa y solidaria".

Se puede crear una variable que contenga como valor un dato del tipo cadena,
usando el operador de asignación igual (=). Por ejemplo:
name = ’Harsh’

El valor de esta cadena se puede mostrar simplemente escribiendo el nombre del

objeto en la línea de comandos. o usando la función print().
>>>name Harsh
print(name)

Yessenia Portal Machuca 32 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Concatenar String: Para concatenar cadenas Python usa el símbolo más +. Y el

operador *, concatena una cadena dada el número de veces. Por ejemplo, 3*nombre
daría "harsharshharsharsharsharsh."Por ejemplo:
name = name + ’arsh’
print(name)
Harsharsh

3*name
"HarshHarshHarsh"

Espacios en blanco o nueva líneas: para añadir un espacio en blanco se puede

abrir y cerrar comillas " ", para añadir sandría al texto se usa el comando \t, y
para añadir una nueva línea en una string utilice \n. Ejemplos:
>>> print("Languages:\n\tPython\n\tC\n\tJavaScript")
Languages:
Python
C
JavaScript

Python puede buscar espacios en blanco adicionales en los lados derecho e izquierdo
de una string. Para asegurarse de que no existe ningún espacio en blanco en el
extremo derecho de una string, utilice el método rstrip().
>>> favorite_language = ’python ’
>>> favorite_language
’python ’
>>> favorite_language.rstrip()
’python’
>>> favorite_language
’python ’

También puede eliminar los espacios en blanco del lado izquierdo de una cadena
utilizando el método lstrip() o eliminar los espacios en blanco de ambos lados a la
vez utilizando strip():
>>> favorite_language = ’ python ’
>>> favorite_language.rstrip()
’ python’
>>> favorite_language.lstrip()
’python ’
>>> favorite_language.strip()
’python’

Yessenia Portal Machuca 33 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Indexación: el valor de una ubicación particular de una cadena se puede mostrar

mediante indexación, la cual tiene la siguiente sintaxis.
<name of the String>[index]

Por ejemplo, si queremos conocer el primer caracter de la cadena, se debe escribir

el siguiente código:
print(name[0])
H

Indexación negativa: en una cadena se refiere al carácter presente en la enésima

posición comenzando desde el final. Ejemplo:
print(name[-2])
s

Longitud de una cadena: esta se puede encontrar utilizando la función len(),

que devuelve la longitud de la cadena.
len(name)
5

Cortar una cadena: se refiere a quitar alguna parte de la cadena. Por ejemplo:
>>>name = ’Sonam’
>>>name
’Sonam’

Para extraer la parte después de la primera letra, o después de las dos primeras
letras podemos escribir:
>>> name1=name[1:]
>>> name1
’onam’

>>>name = name[2:]
>>>name
’nam’

La cadena en Python no es mutable; es decir, una vez definida, el valor de una

cadena no puede ser cambiado. Así como con la lista y la tupla, el operador corte
[] se puede utilizar con una cadena. Las cadenas son inmutables.
s = ’Hello world!’

# s[4] = ’o’
print("s[4] = ", s[4])

# s[6:11] = ’world’
print("s[6:11] = ", s[6:11])

# Generación de error
# Las cadena son immutables en Python
s[5] =’d’

Yessenia Portal Machuca 34 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Evitando Errores de Tipo con la Función str(): Python sabe que la variable
podría representar el valor numérico 23 o los caracteres 2 y 3. Cuando usas núme-
ros enteros dentro de strings como esta, necesitas especificar explícitamente que
quieres que Python use el número entero como una string de caracteres. Puede
hacer esto envolviendo la variable en la función str(), que le dice a Python que
represente valores que no sean strings como strings. Ejemplo:
age = 23
message = "Happy " + str(age) + "rd Birthday!"
print(message)

5.3.2. Lista
Una lista es una secuencia ordenada de elementos. Es uno de los tipos de datos
más utilizados en Python y es muy flexible. No es necesario que todos los elementos
de una lista sean del mismo tipo.
Declarar una lista es bastante sencillo. Los elementos separados por comas se
incluyen entre corchetes [].
>>> a = [1, 2.2, ’python’]

∗ Una lista puede ser una colección de elementos homogéneos, por ejemplo:
[1, 2, 3].
∗ Puede contener diferentes elementos (heterogéneos), por ejemplo: [1, "abc,"
2.4].
∗ Una lista puede estar vacía []
∗ Finalmente una lista también puede contener una lista.

Indexación: se usa el operador corchetes [] para extraer un elemento o un rango

de elementos de una lista. Escriba el nombre de la lista seguido del índice del
elemento entre corchetes. Por ejemplo, si la lista denominada A contiene [1, 2,
3], entonces la lista A[1] contiene al elemento "2" y la lista A[-1] contiene al
elemento "3".

Recuerde: En Python el índice comienza desde 0.

Por ejemplo.
a = [5,10,15,20,25,30,35,40]

# a[2] = 15
print("a[2] = ", a[2])

# a[0:3] = [5, 10, 15]

print("a[0:3] = ", a[0:3])

# a[5:] = [30, 35, 40]

print("a[5:] = ", a[5:])

Yessenia Portal Machuca 35 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Utilización de valores individuales de una lista: Se puede utilizar valores

individuales de una lista como lo haría con cualquier otra variable. Por ejemplo, se
puede utilizar la concatenación para crear un mensaje basado en un valor de una
lista. Ejemplo:
bicycles = [’trek’, ’cannondale’, ’redline’, ’specialized’]
message = "My first bicycle was a " + bicycles[0].title() + "."
print(message)

Las listas son mutables, esto es, el valor de los elementos de una lista puede
modificarse.
>>> a = [1,2,3]
>>> a[2]=4
>>> a
[1, 2, 4]

Modificación de elementos de una lista: la sintaxis para modificar un elemento

es similar a la sintaxis para acceder a un elemento de una lista. Para cambiar un
elemento, utilice el nombre de la lista seguido del índice del elemento que desea
cambiar y, a continuación, proporcione el nuevo valor que desea que tenga ese
elemento. Por ejemplo:
motorcycles = [’honda’, ’yamaha’, ’suzuki’]
print(motorcycles)

motorcycles[0] = ’ducati’
print(motorcycles)

La salida muestra que el primer elemento se ha modificado y que el resto de la

lista sigue siendo el mismo:
[’honda’, ’yamaha’, ’suzuki’]
[’ducati’, ’yamaha’, ’suzuki’]

Puede modificar el valor de cualquier elemento de una lista, no sólo el primer

elemento.

Añadir elementos a una lista: Es posible agregar un nuevo elemento a una lista
usando la función append(). Al añadir un elemento a una lista, el nuevo elemento
se añade al final de la lista.
motorcycles = [’honda’, ’yamaha’, ’suzuki’]

motorcycles.append(’ducati’)
print(motorcycles)

[’honda’, ’yamaha’, ’suzuki’, ’ducati’]

Yessenia Portal Machuca 36 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Si requiere añadir un nuevo elemento en cualquier posición de la lista utilizando

la función insert(). Esto se hace especificando el índice del nuevo elemento y el
valor de la nueva posición. Ejemplo:
motorcycles = [’honda’, ’yamaha’, ’suzuki’]
motorcycles.insert(0, ’ducati’)
print(motorcycles)

[’ducati’, ’honda’, ’yamaha’, ’suzuki’]

Eliminar elementos de una lista: puede utilizar la función del, si conoce la

posición del elemento que desea eliminar de una lista. Ejemplo:
motorcycles = [’honda’, ’yamaha’, ’suzuki’]
print(motorcycles)

del motorcycles[0]
print(motorcycles)

Si desea eliminar el último elemento de la lista, puede utilizar la función pop(),

que además le permite trabajar con ese elemento después de eliminarlo.
motorcycles = [’honda’, ’yamaha’, ’suzuki’]

popped_motorcycle = motorcycles.pop()
print(motorcycles)

print(popped_motorcycle)

La salida muestra que el valor del último elemento fue eliminado del final de la
lista y ahora está almacenado en la variable popped_motorcycle.
[’honda’, ’yamaha’]
suzuki

Puede utilizar pop() para eliminar un elemento de una lista en cualquier posición
incluyendo entre paréntesis el índice del elemento que desea eliminar.
motorcycles = [’honda’, ’yamaha’, ’suzuki’]
first_owned = motorcycles.pop(0)

Si no conoces la posición del valor que quieres eliminar de una lista, puede utilizar
el método remove(). Esta función elimina sólo la primera aparición del valor
especificado.
motorcycles = [’honda’, ’yamaha’, ’suzuki’, ’ducati’]

too_expensive = ’ducati’
motorcycles.remove(too_expensive)

Yessenia Portal Machuca 37 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Ordenando una lista

Se puede ordenar una lista temporalmente con el método sort().Por ejemplo:
ordenar en alfabeticamente.
cars = [’bmw’, ’audi’, ’toyota’, ’subaru’]
cars.sort()
print(cars)
[’audi’, ’bmw’, ’subaru’, ’toyota’]

Esta función también puede ordenar al inverso, usando el argumento reverse =

True al método sort(). Por ejemplo:
cars = [’bmw’, ’audi’, ’toyota’, ’subaru’]
cars.sort(reverse=True)
print(cars)
[’toyota’, ’subaru’, ’bmw’, ’audi’]

Una vez ejecutada la función, el orden de la lista cambia permanentemente. Sin

embargo, si se requiere un orden temporal, puede usar la función sorted(). Por
ejemplo:
cars = [’bmw’, ’audi’, ’toyota’, ’subaru’]
print("Here is the original list:")
print(cars)
Here is the original list:
[’bmw’, ’audi’, ’toyota’, ’subaru’]
print("\nHere is the sorted list:")
print(sorted(cars))
Here is the sorted list:
[’audi’, ’bmw’, ’subaru’, ’toyota’]

La función sorted() también puede aceptar un argumento reverse = True si

desea mostrar una lista en orden alfabético inverso.

Yessenia Portal Machuca 38 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

5.3.3. Tupla
Una tupla es una secuencia ordenada de elementos como en una lista. La única
diferencia es que las tuplas son inmutables, esto es, una vez creadas no pueden
ser modificadas.

Las tuplas se utilizan para proteger los datos contra la escritura y suelen ser más
rápidas que las listas, ya que no pueden cambiarse dinámicamente.

Una tupla también puede contener elementos heterogéneos.

Se define entre paréntesis () donde los elementos están separados por comas.
>>> t = (5, ’programa’, 1+3j)

Se usa el operador corchetes [] para extraer elementos, pero no podemos cambiar

su valor.
t = (5, ’programa’, 1+3j)

# Aqui se genera un error porque las tuplas son immutables

t[0] = 10

El operador "+" en una tupla concatena dos tuplas. Por ejemplo:

tup1= (1,2)
tup2=(3,4)
tup3= tup1+tup2

tup3
(1, 2, 3, 4)

Las tuplas son extremadamente útiles en operaciones como el intercambio, etc. El

intercambio en Python es tan simple como asignar (a, b) a (b, a).

Por Ejemplo:
num1= 2
num2= 3

print(’\nThe numbers entered are ’,num1,’ & ’,num2)

(num1, num2) = (num2, num1)

print(’\nThe numbers now are ’,num1,’ & ’,num2)

Output

The numbers entered are 2&3

The numbers now are 3&2
>>>

Yessenia Portal Machuca 39 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Tuplas y listas multidimensionales

Se puede hacer listas (listas de listas) y tuplas multidimensionales. Por ejemplo,
una lista conformada por tres listas.
In [40]: a = [[3, 9], [8, 5], [11, 1]]

Tales construcciones pueden ser útiles para hacer tablas y otras estructuras. Se
puede acceder a los distintos elementos de una lista con una extensión directa del
esquema de indexación que hemos estado utilizando.

Ejemplos:

El primer elemento de la lista es:

In [46]: a[0]
Out[46]: [3, 9]

El segundo es: que es 8, como se ilustra a continuación:

In [47]: a[1]
Out[47]: [8, 5]

El primer elemento del segundo elemento de la lista es:

In [48]: a[1][0]
Out[48]: 8

El segundo elemento del tercer elemento de la lista es:

In [49]: a[2][1]
Out[49]: 1

Las tuplas multidimensionales funcionan exactamente igual que las listas mul-
tidimensionales, excepto que son inmutables.

5.4. Conjuntos (Set)

Un conjunto es una colección no ordenada de items únicos. Un conjunto está
definido por valores separados por comas dentro de llaves {}. Los items en un
conjunto no se ordenan.
a = {5,2,3,1,4}

# Impresión de la variable conjunto

print("a = ", a)

Podemos realizar operaciones de conjuntos como unión e intersección de conjuntos.

Un conjunto tiene valores únicos. Ellos eliminan los duplicados.
>>> a = {1,2,2,3,3,3}
>>> a
{1, 2, 3}

Yessenia Portal Machuca 40 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Dado que, el conjunto es una colección desordenada, la indexación no tiene signi-

ficado. Por lo tanto, el operador corchetes [] no funciona.
>>> a = {1,2,3}
>>> a[1]
Traceback (most recent call last):
File "<string>", line 301, in runcode
File "<interactive input>", line 1, in <module>
TypeError: ’set’ object does not support indexing

5.5. Diccionario
Un diccionario es una colección desordenada de pares clave-valor.

Generalmente se usa cuando tenemos una gran cantidad de datos. Los diccionarios
están optimizados para recuperar datos. Debemos conocer la clave para recuperar
el valor.

En Python, los diccionarios se definen entre llaves {} y cada elemento es un par

de la forma clave:valor. Clave y valor pueden ser de cualquier tipo.
d = {1:’value’, ’key’:2}

Se usa la clave para recuperar el valor respectivo. Pero no al revés.

print("d[1] = ", d[1])
d[1] = value

Un par clave-valor es un conjunto de valores asociados entre sí. Cada valor está
conectado a su valor por dos puntos, y los pares clave-valor individuales están
separados por comas.

Añadir nuevos pares clave-valor: los diccionarios son estructuras dinámicas y

puede agregar nuevos pares clave-valor a un diccionario en cualquier momento. Por
ejemplo, para añadir un nuevo par, se debe dar el nombre del diccionario seguido
de la nueva clave entre corchetes junto con el nuevo valor.

A Python no le importa el orden en el que almacena cada par clave-valor; sólo le

importa la conexión entre cada clave y su valor.

Iniciar con un diccionario vacío: para empezar a llenar un diccionario vacío,

defina un diccionario con un conjunto de llaves vacías y luego añada cada par
clave-valor en su propia línea. Por ejemplo, aquí está cómo construir el diccionario
colores_0 usando este enfoque:
colors_0 = {}
colors_0[’color’] = ’green’
colors_0[’points’] = 5
print(colores_0)

Yessenia Portal Machuca 41 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Modificación de valores en un diccionario: para modificar un valor en un

diccionario, dé el nombre del diccionario con la clave entre corchetes y luego el
nuevo valor que desea asociar a esa clave. Por ejemplo:
colors_0 = {’color’: ’green’}
colors_0[’color’] = ’yellow’

Eliminación de pares de valores clave: cuando ya no necesite un fragmento de

información almacenado en un diccionario, se puede utilizar la sentencia del para
eliminar por completo un par clave-valor. Todo lo que necesita es el nombre del
diccionario y la clave que desea eliminar. Por ejemplo,
colors_0 = {’color’: ’green’, ’points’: 5}
del colors_0[’points’]

5.6. Conversión entre tipos de datos

Podemos convertir entre diferentes tipos de datos mediante el uso de diferentes
funciones de conversión como: int(), float(), str(), etc.
>>> float(5)
5.0

La conversión de float a int truncará el valor (lo acercará a cero).

>>> int(10.6)
10
>>> int(-10.6)
-10

La conversión hacia y desde la cadena debe contener valores compatibles.

>>> float(’2.5’)
2.5
>>> str(25)
’25’

Incluso podemos convertir una secuencia a otra.

>>> set([1,2,3])
{1, 2, 3}
>>> tuple({5,6,7})
(5, 6, 7)
>>> list(’hello’)
[’h’, ’e’, ’l’, ’l’, ’o’]

Para convertir a diccionario, cada elemento debe ser un par

>>> dict([[1,2],[3,4]])
{1: 2, 3: 4}
>>> dict([(3,26),(4,44)])
{3: 26, 4: 44}

Yessenia Portal Machuca 42 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

6. Entrada y Salida
Python proporciona 2 formas de entrada: desde el teclado de la computadora y
el archivo de datos de entrada, asimismo hay dos formas de salida: la pantalla de
ordenador y el archivo de datos de salida. Se revisará cada una de estas formas de
entrada y salida.

6.1. Función Input

La función input() se utiliza para obtener entradas del usuario y asignarle un
valor a una variable, es útil para tomar la entrada del usuario

La sintaxis de input() es:

strname = input("prompt")

donde prompt es la cadena que queremos mostrar en la pantalla. Cuando se ejecuta

la función de entrada, imprime en la pantalla del ordenador el texto de las comillas
y espera la entrada del usuario. El usuario escribe una cadena de caracteres.
num = input(’Enter a number: ’)
Enter a number: 10

num
’10’

Aquí, se visualiza que el valor introducido 10 es una cadena, no un número. Para

convertir esto en un número podemos usar las funciones int() o float().
int(’10’)
10

float(’10’)
10.0

6.2. Entrada de archivos: importación

Hay varias formas de leer datos en Pyhton desde un archivo externo. La forma
más simple para leer un archivo de texto o csv. es usar la función loadtxt() del
paquete NumPy. Se ilustra un ejemplo a continuación, donde se lista los nombres
de las columnas a la izquierda del operador asignación "=".
import numpy as np
dataPt, time, height, error = np.loadtxt("mydata.txt", skiprows=5,
unpack=True)

Yessenia Portal Machuca 43 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

La función loadtxt() tiene como principales argumentos:

∗ fname es el nombre del archivo a leer.
∗ skiprows, indica el nro. de líneas a omitir en la parte superior del archivo,
a veces llamado el encabezado.
∗ unpack, indica si los datos pueden ser leídos directamente en los arrays
(desempaquetar los datos).
∗ usecols, se puede indicar las columnas que se desea leer, escribiendo la
posición de las mismas.
∗ delimiter, indica si las columnas estan separadas por comas en el caso de
archivos csv. o por espacios en blanco en el caso de archivos txt.
Para que este código se ejecute correctamente, el archivo a importar debe estar en
el directorio de trabajo actual del interprete de IPython, de lo contrario, se necesita
especificar la ruta del directorio con el nombre del archivo.
Cuando se importan archivo con extensión csv, se debe configurar el argumento
delimiter=’,’, tal como se muestra a continuación:
dataPt, time, height, error = np.loadtxt("mydata.csv",skiprows=5,
unpack=True,delimiter=’,’)

6.3. Salida usando la función print()

Se usa la función print() para enviar datos al dispositivo de salida estándar
(pantalla).
La sintaxis completa de la función print() es
print(*objects, sep=’ ’, end=’\n’, file=sys.stdout, flush=False)

donde:
∗ objects es el (los) valor(es) a imprimir.
∗ separador sep se utiliza entre los valores. Por defecto se convierte en un
carácter de espacio.
∗ Una vez impresos todos los valores, se imprime end. Esto por default establece
una nueva línea.
∗ file es el objeto donde se imprimen los valores y su valor predeterminado
es sys.stdout (pantalla).

Ejemplo:
print(’This sentence is output to the screen’)
# Output: This sentence is output to the screen

a = 5
print(’The value of a is’, a)
# Output: The value of a is 5

Yessenia Portal Machuca 44 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Ejemplos de configurar el argumento sep de a función:

print(1,2,3,4)
# Output: 1 2 3 4

print(1,2,3,4,sep=’*’)
# Output: 1*2*3*4

print(1,2,3,4,sep=’#’,end=’&’)
# Output: 1#2#3#4&

Formato de salida: el método str.format() nos permitirá formatear una salida

para que se vea atractiva.

Este método es visible para cualquier objeto de cadena.

x = 5; y = 10
print(’El valor de x es {} y el de y es {}’.format(x,y))
El valor de x es 5 y el de y es 10

Aquí las llaves {} se utilizan como marcadores de posición.

Podemos especificar el orden en el que se imprime utilizando números (índice de

tupla).
print(’Me gusta {0} con {1}’.format(’pan’,’mantequilla’))
# Output: Me gusta pan con mantequilla

Incluso podemos usar argumentos de palabras clave para dar formato a la cadena.
print(’Hola {name}, {greeting}’.format(greeting = ’Buenos dias’, name = ’Miguel’))
Hola Miguel, Buenos dias

Incluso podemos dar formato a cadenas como el viejo estilo sprintf() usado en
el lenguaje de programación C. Usamos el operador % para lograr esto.
x = 12.3456789
print(’El valor de x es %3.2f’ %x)
El valor de x es 12.35

print(’El valor de x es %3.4f’ %x)

El valor de x es 12.3457

Yessenia Portal Machuca 45 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

6.4. Salida de archivos: exportación

Al igual que en la importación, existe muchas funciones para exportar datos en
Pyhton. No obstante, la forma más simple para escribir archivos de datos en
formato texto o csv, es usar la función savetxt() de NumPy. La sintaxis general
de es:
savetxt(filename, array, fmt=" %0.18e",
delimiter=" ", newline=" \n", header="",
footer="", comments="#")

Donde,

∗ filename, indica el nombre del archivo de datos a crear, el cual se debe

crear entre comillas. Si ya existe el nombre del archivo, se sobreescribirá.
∗ array, indicar la lista de los nombres de las columas de los datos a exportar,
usar la función zip, si se desea empaquetar las columnas en como uno solo.
∗ fmt, es un argumento opcional donde se puede configurar el número de
dígitos decimales en notación exponencial (e) o en notación float (f).
∗ delimiter, por default se deja un espacio en blanco cuando se trata de
archivos txt. y se debe configurar una coma, cuando se trata de archivos csv.
∗ header, es una variable de cadena que le permite escribir el texto de cabecera
sobre los datos.

Ejemplo de como exportar en un archivo de texto.

import numpy as np
np.savetxt("mydatawritten.txt",list(zip(dataPt, time, height, error)),
fmt=" %12.1f")

Ejemplo de como exportar en un archivo csv.

np.savetxt(’mydataout.csv’,
list(zip(dataPt, time, height, error)),
fmt=" %0.1f", delimiter=",")

Yessenia Portal Machuca 46 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

7. Sentencia, indentado y comentarios

7.1. Sentencia
Las instrucciones que puede ejecutar un intérprete de Python se llaman sentencias
o instrucciones (statements).
Por ejemplo

∗ a=1 es una sentencia de asignación.

∗ La sentencia if, la sentencia for, la sentencia while, etc. son sentencias
de control.

7.1.1. Declaración multilínea

El final de una declaración está marcado por un carácter de nueva línea (newline).
Sin embargo, podemos hacer que una declaración se extienda sobre varias líneas
con el carácter de continuación de línea (\), esto es, llevar a cabo una continuación
de línea explícita. Por ejemplo:
a = 1 + 2 + 3 + \
4 + 5 + 6 + \
7 + 8 + 9

Una continuación de la línea es implícita dentro de paréntesis (), corchetes []

y llaves {}. Por ejemplo, podemos implementar la declaración multilínea anterior
como
a = (1 + 2 + 3 +
4 + 5 + 6 +
7 + 8 + 9)

así también
colors = [’red’,
’blue’,
’green’]

Podemos colocar varias declaraciones en una sola línea usando punto y coma (;)
a = 1; b = 2; c = 3

7.2. Indentación
En programación, indentación significa mover un bloque de texto hacia la dere-
cha insertando espacios o tabuladores, para así separarlo del margen izquierdo y
distinguirlo mejor del texto adyacente; en el ámbito de la imprenta, este concepto
siempre se ha denominado sangrado o sangría.

La mayoría de los lenguajes de programación como C, C ++, Java usan llaves {}

para definir un bloque de código. Python utiliza indentación.

Yessenia Portal Machuca 47 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Un bloque de código (cuerpo de una función, bucle, etc.) comienza con una sangría
y termina con la primera línea sin sangrar. La cantidad de sangría depende del
programador, sin embargo, debe ser consistente en todo el bloque.

En general, se utilizan 4 espacios en blanco para la sangría y se prefiere a los tabs.

Aquí hay un ejemplo.
for i in range(1,11):
print(i)
if i == 5:
break

La aplicación de sangría hace que el código se vea limpio y ordenado. Esto da

como resultado programas que se ven similares y consistentes.

La sangría puede ser ignorada en la continuación de la línea; sin embargo, es una

buena idea indentar siempre, ello hace que el código sea más legible.
Por ejemplo:
if True:
print(’Hola’)
a = 5

y
if True: print(’Hola’); a = 5

ambos son válidos y hacen lo mismo; sin embargo, el primer estilo es más claro.

Una indentación incorrecta dará lugar a IndentationError.

En Python, la indentación se utiliza para detectar la presencia de bucles; los bucles

en Python no comienzan o terminan con delimitadores o palabras clave.

7.3. Comentarios de Python

Los comentarios permiten describir lo que está sucediendo dentro de un programa,
a medida que sus programas se hacen más largos y complicados, debe agregar
notas dentro de sus programas que describan su enfoque general del problema que
está resolviendo, de modo que sirve por lo general 1) a una persona que mira el
código fuente no tenga dificultad en entenderlo, y 2) al quien contruyó el programa,
cuando posiblemente olvide los detalles clave del programa que escribió en un mes.

En Python se usa el símbolo hash (#) para iniciar a escribir un comentario, lo que
escriba despues de una marca hash en su código, es ignorada por el intérprete de
Python.

Ejemplo:
# Este es un comentario
# Impresión de Hola
print(’Hola’)

Yessenia Portal Machuca 48 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

7.3.1. Comentarios multilínea

Una forma de crear comentarios que se extienden en varias líneas, es mediante un
hash (#) al inicio de cada línea. Por ejemplo:
# Este es un comentario largo
# y se extiende
# a multiples líneas

Otra forma de hacer esto es usar comillas triples, ya sea ”’ o """.

Estas comillas triples se utilizan generalmente para cadenas de varias líneas, asi
como para comentarios de varias líneas. A menos que no sean docstrings, no
generan ningún código adicional.
""" Este es tambien un
ejemplo perfecto de
comentarios multi-línea"""

7.3.2. Docstring
Docstring es la abreviatura de cadena de documentación.

Un docstring es una cadena que aparece como la primera declaración en un módulo,

función, clase o definición de método. En ella se debe escribir lo que hace una
función/clase.

Las comillas triples se utilizan al escribir docstrings.

def double(num):
"""Función que retorna un valor double"""
return 2*num

Docstring nos permite el uso del atributo __doc__ de la función.

print(double.__doc__)
Función que retorna un valor double

Todos los objetos documentables (módulos, clases, métodos y funciones) cuentan

con un atributo __doc__ el cual contiene su respectivo comentario de documen-
tación.

Yessenia Portal Machuca 49 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

8. Sentencias de Control
8.1. Sentencias selectivas: If, If-Else y If-Elif-Else
Las sentencias selectivas forman parte integral de la programación, para la toma
de decisiones. Python reconoce un bloque de programación a través de la indentación.
La Indentación decide el comienzo y el final de un bloque en Python. Por lo tanto, es
importante tener cuidado con la Indentación, de lo contrario se obtendra un error en la
salida del código.
La sentencia if <condition> es seguida por dos puntos.

No hay necesidad de paréntesis para esta condición de prueba. Aunque incluir la

prueba entre paréntesis no dará lugar a un error.

Un "if" puede tener cualquier número de "if" anidados dentro.

La condición de la sentencia selectiva debe resultar en un Verdadero o Falso.

8.1.1. Sentencia Selectiva if

Sintaxis.
if expresion_de_prueba:
sentencia(s)

Ejemplo
# Si el numero es positivo, se imprime el mensaje apropiado

num = 3
if num > 0:
print(num, "es un numero positivo.")
print("Esto se imprime siempre.")

num = -1
if num > 0:
print(num, "es un numero positivo.")
print("Esto también se imprime siempre.")

El ejecutar el programa, la salida es:

3 es un numero positivo
Esto se imprime siempre.
Esto también se imprime siempre.

8.1.2. Sentencia Selectiva if...else

Sintaxis
if expresion_de_prueba:
sentencia(s)1
else:
sentencia(s)2

Yessenia Portal Machuca 50 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Ejemplo.
# Programa que verifica que el numero es positivo o negativo
# Y muestra un mensaje apropiado

num = 3

# Intente estas dos variantes también

# num = -5
# num = 0

if num >= 0:
print("Numero Positivo o Cero")
else:
print("Numero Negativo")

8.1.3. Sentencia if...elif...else

Si hay múltiples condiciones y los resultados deciden la acción, entonces se puede
utilizar una la sentencia if...elif...else.

Sintaxis
if expresion_de_prueba1:
sentencia(s)1
elif expresion_de_prueba2:
sentencia(s)2
else:
sentencia(s)3

8.1.4. Sentencias if anidadas

Ejemplo.
# En este programa, se ingresa un número se verifica
# Si el número es positivo,negativo o cero
# Y se visualiza un mensaje apropiado
# Esta vez se usa if anidados

num = float(input("Enter a number: "))

if num >= 0:
if num == 0:
print("Zero")
else:
print("Positive number")
else:
print("Negative number")

Yessenia Portal Machuca 51 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

8.1.5. Operador ternary

Las declaraciones condicionales explicadas en la sección anterior son importantes
para escribir cualquier programa que contenga condiciones. Sin embargo, el código
puede reducirse aún más usando las declaraciones ternarias proporcionadas por
Python. El operador ternario realiza la misma tarea que la construcción if-else.

Ejemplo: Encuentre el mayor de los tres números digitados por el usuario, utilizando
un operador ternary.
# Operador Ternary
a = int(input(’Ingresa el primer número\t:’))
b = int(input(’Ingresar el segundo número \t:’))
c = int(input(’Enter the third number\t:’))

big = (a if (a>c) else c) if (a>b) else (b if (b>c) else c)

print(’El mayor de los tres números es ’+str(big))

8.2. Sentencias iterativas

Muchas situaciones requieren que repitamos una tarea determinada muchas veces,
como calcular el valor de una función, para imprimir un patrón o simplemente para
repetir algo.

Looping significa repitiendo una serie de declaraciones hasta que una condición
sea verdadera.

En general, la repetición de un bloque requiere lo siguiente:

Decidir qué se va a repetir: el conjunto de

declaraciones.

Se repetirá la condición de prueba o el

número de veces que se repita el
conjunto de declaraciones.

Casos especiales en los que el bucle

se rompe o continúa, escapando de
ciertas sentencias.

Yessenia Portal Machuca 52 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Python ofrece dos tipos de bucles: for y while.

While es la construcción de bucles más común en Python.
For se utiliza generalmente para procesar listas, tuplas, matrices, etc.
Rango (n) significa valores de 0 a (n - 1).
Rango (m, n) significa todos los valores de m a (n - 1).

8.2.1. Sentencia Iterativa for

Sintaxis
for val in secuencia:
sentencia(s)

Por ejemplo
# Programa que encuentra la suma de todos los numeros en una lista
# Lista de numeros
numeros = [6, 5, 3, 8, 4, 2, 5, 4, 11]

# variable que almacenara la suma (acumulador)

sum = 0

# iteracion sobre la lista

for val in numeros:
sum = sum + val

# Output: La suma is 48 encontrarán algunas de estas librerías

# extremadamente útiles y fáciles de usar.
print("La suma es ", sum)

Ejecución del programa

La suma es 48

La función range()
Ejemplo 1.
# Output: range(0, 10)
print(range(10))

# Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(range(10)))

# Output: [2, 3, 4, 5, 6, 7]
print(list(range(2, 8)))

# Output: [2, 5, 8, 11, 14, 17]

print(list(range(2, 20, 3)))

Yessenia Portal Machuca 53 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Ejemplo 2.
# Programa para iterar a través de una lista usando indexación

genre = [’pop’, ’rock’, ’jazz’]

# itera sobre la lista usando un indice

for i in range(len(genre)):
print("Me gusta el ", genre[i])

Ejecución del programa

Me gusta el pop
Me gusta el rock
Me gusta el jazz

Bucle for con else

Por ejemplo.
digits = [0, 1, 5]
for i in digits:
print(i)
else:
print("No quedan items.")

Ejecución del programa

0
1
5
No quedan items.

8.2.2. Sentencia Iterativa while

Sintaxis
while test_expression:
sentencia(s)

Por ejemplo.
# Programa que suma los números naturales del 1 al n
# sum = 1+2+3+...+n
# A ser ingresado por el usuario. n = int(input("Ingrese n: "))
n = 10
# inicializa sum y el contador
sum = 0
i = 1
while i <= n:
sum = sum + i
i = i+1 # actualiza el contador
# imprime la suma
print("La suma es ", sum)

Yessenia Portal Machuca 54 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Output.
Ingrese n: 10
La suma es 55

Sentencia while con else

Por Ejemplo.
# Ejemplo para ilustrar
# el uso de la sentencia else
# con el bucle while

counter = 0

while counter < 3:

print("Dentro del bucle")
counter = counter + 1
else:
print("Dentro del else")

Output.
Dentro del bucle
Dentro del bucle
Dentro del bucle
Dentro del else

Yessenia Portal Machuca 55 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

9. Funciones
9.1. ¿Qué es una función en Python?
En Python, una función es un grupo de sentencias relacionadas que realizan una
tarea específica.

Las funciones ayudan a dividir nuestro programa en partes más pequeñas y mo-
dulares. A medida que nuestro programa crece más y más, las funciones lo hacen
más organizado y manejable.

Además, evita la repetición y hace que el código sea reutilizable.

9.2. Tipos de funciones

Básicamente, podemos dividir funciones en los siguientes dos tipos:

1. Funciones internas (built-in):

Funciones incorporadas en Python.
2. Funciones definidas por el usuario:
Funciones definidas por los propios usuarios. De las cuales pueden ser fun-
ciones convencionales o funciones Lambda.

9.2.1. Función convencional

Sintáxis:
def nombre_funcion (argumentos):
"""cadena de documentación"""
sentencia(s)

donde:

1. La palabra clave def marca el inicio del encabezado de la función, e informa

a Pyhton que se esta definiendo una función.
2. El nombre de la función permite identificarlo de forma única.5
3. Argumentos, a través de los cuales pasamos valores a una función y se
declaran entre paréntesis. Pueden ser obligatorios u opcionales.
4. El signo dos puntos (:) denota el fin del encabezado de la función.
5. La cadena de documentación (docstring) es opcional para describir lo que
hace la función. Las Docstrings se declaran entre comillas triples y debería
aparecer inmediatamente después de la definición de la función.
6. El cuerpo de la función está conformado por una o más sentencias. Las decla-
raciones deben tener el mismo nivel de sangría (generalmente 4 espacios).
7. La sentencia return (opcional) permite que la función devuelva un valor.

5
La denominación de funciones sigue las mismas reglas de escritura de identificadores en Python.

Yessenia Portal Machuca 56 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Si especifica un valor propuesto para un parámetro, no se debe utilizar ningún

espacio a ambos lados del signo igual.
def function_name(parameter_0, parameter_1=’default value’)

La misma convención debería usarse para los argumentos keyword, al invocar la

función.
function_name(value_0, parameter_1=’value’)

Ejemplo de una función: ’nombre’

def greet(name):
"""Esta función saluda
a la persona que es pasada
como parametro"""
print("Hola, " + name + ". Buenos dias!")

9.2.2. ¿Cómo llamar a una función?

Una vez que hayamos definido una función, podemos llamarla desde otra función,
programa o en el interprete de Python.
Para llamar a una función, simplemente escribimos el nombre de la función con
los argumentos apropiados entre paréntesis, lo que le dice a Python que ejecute el
código de la función.
Ejemplo: utilizar la función ’nombre’
>>> greet(’Paul’)
Hola, Paul. Buenos dias!

Los errores de argumentación se producen cuando se proporcionan menos o más

argumentos de los que una función necesita para realizar su trabajo.

9.2.3. La sentencia return

La sentencia return permite forzar una salida inmediata de la función en que se
encuentra, es decir, se utiliza para salir de una función y volver al lugar desde
donde se llamó la función.
El siguiente esquema ilustra como trabaja una función en Python

Yessenia Portal Machuca 57 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Sintáxis
return [lista_expresion]

Esta declaración puede contener una expresión que se evalúa y se devuelve el valor.
Si no hay una expresión en la declaración o la sentencia return no está presente,
la función devolverá el objeto None.

Por ejemplo:
def absolute_value(num):
"""Esta función retorna el valor
absoluto del numero ingresado"""
if num >= 0:
return num
else:
return -num

# Output: 2
print(absolute_value(2))
# Output: 4
print(absolute_value(-4))

9.2.4. Tipos de argumentos de una función

Argumentos posicionales: Cuando se llama una función en Python, debe hacer
coincidir cada argumento de la función con un parámetro de la definición que se
realizó de la función. La forma más sencilla de hacerlo se basa en el orden de los
argumentos proporcionados. Los valores emparejados de esta manera se denominan
argumentos posicionales.
def tipo_derivados(tipo,subtipo)
"""Información acerca de derivados financieros"""
print("\nUno de los tipos de activos derivados es: "+ tipo +".")
print("Se tiene como subtipos: "+subtipo+".")

tipo_derivados(’Opciones’,’Europeas’)

Argumentos Keyword: Un argumento keyword es un par nombre-valor que se

declara en una función. Se asocia directamente el nombre y el valor dentro del
argumento, de modo que cuando se indica el argumento a la función, no hay
confusión. Cuando utilice argumentos de keyword, asegúrese de utilizar los nombres
exactos de los parámetros en la definición de la función.
def tipo_derivados(tipo,subtipo)
"""Información acerca de derivados financieros"""
print("\nUno de los tipos de activos derivados es: "+ tipo +".")
print("Se tiene como subtipos: "+subtipo+".")

tipo_derivados(tipo=’Opciones’,subtipo=’Europeas’)

Yessenia Portal Machuca 58 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Argumentos Default: Al escribir una función, puede definir un valor por default
para cada parámetro. Si se proporciona un valor para un argumento al invocar la
función, Python utiliza el valor del argumento. Si no es así, utiliza el valor por
default del argumento. La utilización de los valores propuestos puede simplificar
la utilización de la función y aclarar las formas en que se utilizan normalmente
las funciones. Cuando utilice valores predeterminados, cualquier argumento con
un valor predeterminado debe aparecer después de todos los argumentos que no
tienen valores predeterminados. Esto permite a Python continuar interpretando
correctamente los argumentos posicionales.
def tipo_derivados(subtipo,tipo=’Opciones’)
"""Información acerca de derivados financieros"""
print("\nUno de los tipos de activos derivados es: "+ tipo +".")
print("Se tiene como subtipos: "+subtipo+".")

tipo_derivados(subtipo=’Europeas’)

Argumentos opcionales: A veces tiene sentido hacer que un argumento sea op-
cional para que quienes utilizan la función, puedan elegir proporcionar información
adicional sólo si así lo desean. Puede utilizar valores default para hacer que un
argumento sea opcional.

Ejemplo:
Definimos la función formato de nombre, donde el segundo nombre es opcional.
def get_formatted_name(first_name, last_name, middle_name=’’):
"""Return a full name, neatly formatted."""
if middle_name:
full_name = first_name + ’ ’ + middle_name + ’ ’ + last_name
else:
full_name = first_name + ’ ’ + last_name
return full_name.title()

musician = get_formatted_name(’jimi’, ’hendrix’)

print(musician)

musician = get_formatted_name(’john’, ’hooker’, ’lee’)

print(musician)

Para hacer que el segundo nombre sea opcional, se asignó al argumento middle_name
un valor default vacío y lo que hace que se ignore el argumento a menos que el
usuario proporcione un valor.

Yessenia Portal Machuca 59 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

9.2.5. Funciones Lambda

Son funciones anónimas (sin nombre) que se crean de manera rápida y simple,
cuando realizar acciones ligeras que solo requieren un pequeño cálculo.
Se diferencian de las funciones convencionales, porque el contenido de una función
lambda debe ser una única expresión y NO un bloque de acciones.
Toda función lambda puede ser expresada como una función convencional, pero
no viceversa.
Sintaxis de la función Lambda.
lambda argumentos: resultado

# o también

f = lambda argumentos: resultados

# Equivalente a una función lambda

def f(argumentos):
return resultado

Ejemplo.
f= lambda a,b,c=1: (4*a-b)/c

# Su equivalente como una función convencional

def f(a,b,c=1):
return (4*a-b)/c

9.3. Docstring
La primera cadena después del encabezado de la función se denomina docstring y
es la abreviatura de cadena de documentación. Se utiliza para explicar brevemente,
lo que hace una función.
Aunque opcional, la documentación es una buena práctica de programación. A
menos que pueda recordar lo que comió la semana pasada, siempre documente su
código.
En el ejemplo anterior, tenemos una cadena de documentos inmediatamente debajo
del encabezado de la función.
Por lo general, se usan comillas triples para que la cadena de documentación
pueda extenderse hasta varias líneas. Esta cadena está disponible como el atributo
__doc__ de la función.
Por ejemplo:
print(greet.__doc__)
Esta función saluda
a la persona que es pasada
como parametro

Yessenia Portal Machuca 60 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

9.4. Ámbito y vida útil de las variables

El alcance de una variable es la parte de un programa donde se reconoce la
variable.

∗ Los parámetros y las variables definidas dentro de una función no son visibles
desde afuera. Por lo tanto, tienen un alcance local.

La vida útil de una variable es el período durante el cual la variable sale de la

memoria.

∗ La vida útil de las variables dentro de una función es siempre que la función
se ejecute.
∗ Se destruyen una vez que regresamos de la función. Por lo tanto, una función
no recuerda el valor de una variable de sus llamadas anteriores.

Aquí hay un ejemplo para ilustrar el alcance de una variable dentro de una función.
def my_func():
x = 10
print("Valor dentro de la función:",x)

x = 20
my_func()
print("Valor fuera de la función:",x)

Salida
Valor dentro de la función: 10
Valor fuera de la función: 20

Respecto del ejemplo anterior:

∗ Podemos ver que el valor de x es 20 inicialmente. Aunque la función my_func()

cambió el valor de x a 10, no afectó el valor fuera de la función.
∗ Esto se debe a que la variable x dentro de la función es diferente (local a la
función) de la que está fuera. Aunque tienen los mismos nombres, son dos
variables diferentes con un alcance diferente.
∗ Por otro lado, las variables fuera de la función son visibles desde dentro.
Tienen un alcance global.
∗ Podemos leer estos valores desde dentro de la función, pero no podemos
cambiarlos (escribirlos). Para modificar el valor de las variables fuera de la
función, deben declararse como variables globales utilizando la palabra clave
global.

Yessenia Portal Machuca 61 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

9.5. Almacenamiento de sus funciones en Módulos

Una de las ventajas de las funciones es la forma en que separan los bloques de
código de su programa principal. Al usar nombres descriptivos para sus funciones,
su programa principal será más fácil de seguir. Es posible almacenar sus funciones
en un archivo separado llamado módulo y luego importar el módulo en su programa
principal.

Una sentencia de importación le dice a Python que ponga disponible el código de

un módulo, en el archivo de programa que se está ejecutando actualmente.

Almacenar sus funciones en un archivo separado: permite ocultar los detalles del
código de su programa y centrarse en su lógica de nivel superior. También, permite
reutilizar funciones en muchos programas diferentes.

¿Cómo crear un módulo?

∗ Un módulo es un archivo que termina en .py y que contiene el código que

desea importar a su programa. En la siguiente sección se describirá a mayor
los módulos.
∗ Se crea un módulo que contenga la función make_pizza(), guardándolo en
el archivo pizza.py

pizza.py
def make_pizza(size, *toppings):
"""Summarize the pizza we are about to make."""
print("\nMaking a " + str(size) +
"-inch pizza with the following toppings:")
for topping in toppings:
print("- " + topping)

programa_principal.py
import pizza

pizza.make_pizza(16, ’pepperoni’)
pizza.make_pizza(12, ’mushrooms’, ’green peppers’, ’extra cheese’)

∗ Cualquier función definida en el archivo pizza.py estará disponible en:

programa_principal.py una vez el módulo ha sido importado.
∗ Para invocar una función desde un módulo importado, escriba el nombre del
módulo que ha importado, seguido del nombre de la función, separado por
un punto. La sintaxis es la siguiente:
module_name.function_name()

∗ Esta primera aproximación a la importación, hace que todas las funciones del
módulo estén disponibles en su programa.

Yessenia Portal Machuca 62 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

10. Clases y objetos

En el paradigma orientado a objetos, el programa gira alrededor de un objeto y por
lo tanto el tipo de programación se denomina programa orientado a objetos.

10.0.1. ¿Qué es un Objeto?

Un objeto es una instancia de una clase. Los objetos interactúan entre sí y realizan
el trabajo.
Generalmente, una clase puede tener cualquier número de objetos, y es posible
formar una serie de objetos.

10.0.2. ¿Qué es una Clase?

Una clase es una entidad, que tiene relevancia para el problema en cuestión y tiene
límites físicos. La selección de atributos decidirá los límites físicos de la clase.
Se puede percibir una clase como un prototipo, que tiene atributos y compor-
tamiento. Los atributos generalmente almacenan datos y el comportamiento se
implementa mediante funciones.
Los atributos representan las características de la entidad que los concierne.
Las funciones implementan el comportamiento de una clase. En una clase puede
haber cualquier número de funciones, cada una de las cuales realiza una tarea en
particular.
Definición de una clase: en Python, una clase puede ser definida usando la
palabra clave class, que es seguido por el nombre de la clase. Así como en las
funciones, se debe tener en cuenta el Indentado al definir una clase. La sintaxis es
la siguiente:
class <nombre_la_clase>:
def <nombre_función>(<argumento>):
...
<miembros>

A continuación un ejemplo de una clase (película) y objetos (tres películas).

Movie
Class

The fault in
Love actually Sarat
our stars

Objects

Yessenia Portal Machuca 63 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

A continuación se ejemplifica a detalle los atributos y comportamiento de una

clase. se muestra dos funciones: getdata() y putdata(). La función getdata()
pide los valores de las variables al usuario y la función putdata() mostrará los
datos.

movie
name
Name year
genre
director
producer Class
Attributes actors
music_director
story_writer
getdata()
Behaviour putdata()

Ejemplo: Clase Opciones Europeas

class BinomialEuropeanOption(StockOption):

def __setup_parameters__(self):
""" Required calculations for the model """
self.M = self.N + 1 # Number of terminal nodes of tree
self.u = 1 + self.pu # Expected value in the up state
self.d = 1 - self.pd # Expected value in the down state
self.qu = (math.exp((self.r-self.div)*self.dt) -
self.d) / (self.u-self.d)
self.qd = 1-self.qu

def _initialize_stock_price_tree_(self):
# Initialize terminal price nodes to zeros
self.STs = np.zeros(self.M)

# Calculate expected stock prices for each node

for i in range(self.M):
self.STs[i] = self.S0*(self.u**(self.N-i))*(self.d**i)

def _initialize_payoffs_tree_(self):
# Get payoffs when the option expires at terminal nodes
payoffs = np.maximum(
0, (self.STs-self.K) if self.is_call
else(self.K-self.STs))

return payoffs

Yessenia Portal Machuca 64 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

11. Paquetes
11.1. ¿Qué son los paquetes?
Normalmente no almacenamos todos nuestros archivos en nuestra computadora en
la misma ubicación. Utilizamos una jerarquía de directorios bien organizada para
facilitar el acceso.

Los archivos similares se guardan en el mismo directorio, por ejemplo, podemos

mantener todas las canciones en el directorio "música". Al igual que esto, Python
tiene paquetes (es a directorios) y módulos (es a archivos).

A medida que nuestro programa de aplicación crece en tamaño con muchos módu-
los, colocamos módulos similares en un paquete y diferentes módulos en paquetes
diferentes. Esto hace que un proyecto (programa) sea fácil de gestionar y concep-
tualmente claro.

Similar, como un directorio puede contener subdirectorios y archivos, un paquete

de Python puede tener subpaquetes y módulos.

Un directorio debe contener un archivo nombrado __init__.py para que Python

lo considere como un paquete. Este archivo se puede dejar vacío, pero general-
mente colocamos el código de inicialización para ese paquete en este archivo.

Por ejemplo, suponga que se desarrolla un juego, una posible organización de

paquetes y módulos podría ser la que se muestra en la siguiente figura.

Yessenia Portal Machuca 65 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

11.2. El Stack Científico

Hay un cierto conjunto de paquetes que se denominan colectivamente el stack
científico. A continuación se describen estos paquetes:

1. NumPy: proporciona un objeto array multidimensional para almacenar da-

tos homogéneos o heterogéneos; también proporciona funciones/métodos
optimizados para crear y manipular (indexación, operaciones lógicas, arit-
méticas, trigonométricas, entre otras) este objeto array, así como una am-
plia colección de funciones especiales, funciones estadísticas y generadores
de números aleatorios. Puede encontrar más información sobre NumPy en
http://docs.scipy.org/doc/numpy/reference/index.html.

2. Pandas: este paquete se basa en NumPy y proporciona un potente con-

junto de herramientas de análisis de datos; está estrechamente integrado
con matplotlib para el trazado y PyTables para el almacenamiento y
recuperación de datos. Puede encontrar más información sobre Pandas en
http://pandas.pydata.org/.

3. SciPy: proporciona un amplio espectro de funciones matemáticas y rutinas

numéricas para Python. SciPy hace un uso extensivo de los array NumPy,
por lo que cuando importe SciPy, siempre deberá importar también NumPy.
Además de proporcionar funciones matemáticas básicas, SciPy proporciona
"envolturas" Python para software numérico escrito en otros idiomas, como
Fortran, C o C++. Una "envoltura" proporciona una interfaz Python trans-
parente y fácil de usar. SciPy extiende enormemente el poder de Python y le
ahorra la molestia de escribir software en Python que otra persona ya ha es-
crito y optimizado en algún otro lenguaje de programación. Puede encontrar
más información sobre SciPy en http://docs.scipy.org/doc/scipy/reference/.

4. matplotlib: es el paquete estándar de Python para hacer gráficos bidi-

mensionales (2D) y tridimensionales (3D), que hace un uso extensivo de
los arreglos NumPy. Puede encontrar más información sobre matplotlib en
http://matplotlib.sourceforge.net/.

5. PyTables: PyTables es un contenedor popular para la biblioteca de alma-

cenamiento de datos HDF5. Es una biblioteca para implementar operacio-
nes de E/S basadas en disco optimizadas en una base de datos / formato
de archivo jerárquico. Puede encontrar más información sobre matplotlib en
https://www.pytables.org/

6. statsmodels: es un paquete que proporciona clases y módulos para la

estimación de modelos y pruebas estadísticas. Para mayor detalle revisar en
https://www.statsmodels.org/stable/index.html.

Yessenia Portal Machuca 66 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

11.3. ¿Qué son los módulos en Python?

Los módulos se refieren a un archivo que contiene sentencias y definiciones Python.

Un archivo que contiene código Python, por ejemplo: example.py, se llama mó-
dulo y su nombre de módulo sería example.

Usamos módulos para dividir grandes programas en pequeños archivos manejables

y organizados. Además, los módulos proporcionan reutilización de código.

Podemos definir nuestras funciones más utilizadas en un módulo e importarlo, en

lugar de copiar sus definiciones en diferentes programas.

Veamos otro ejemplo de como crear un módulo. Escribimos lo siguiente y lo guar-

damos como example.py.
# Python Modulo ejemplo
def add(a, b):
"""Este programa suma dos numeros y retorna el resultado"""
result = a + b
return result

∗ Hemos definido una función add() dentro de un módulo llamado example.

∗ La función toma dos números y devuelve su suma.

11.4. ¿Cómo importar módulos en Python?

Podemos importar las definiciones dentro de un módulo a otro módulo o al intér-
prete interactivo en Python.

Usamos la palabra clave import para hacer esto.

Para importar nuestro módulo example previamente definido, escribimos lo si-

guiente en el prompt
>>> import example

Usando el nombre del módulo podemos acceder a la función usando la operación

de punto (.). Por ejemplo:
>>> example.add(4,5.5)
9.5

Python tiene una gran cantidad de módulos estándar disponibles.

∗ Puede consultar la lista completa de módulos estándar de Python y para

qué sirven. Estos archivos se encuentran en el directorio Lib dentro de la
ubicación donde instaló Python.
∗ Los módulos estándar se pueden importar de la misma manera que importa-
mos nuestros módulos definidos por el usuario.

Hay varias formas de importar módulos. Las que se describen a continuación:

Yessenia Portal Machuca 67 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

11.5. Sentencia import

Podemos importar un módulo usando la sentencia import y acceder a las defi-
niciones dentro de él usando el operador punto como se describió anteriormente.
Por ejemplo:
# Ejemplo de uso de sentencia import
# para importar el modulo math

import math
print("El valor de pi es", math.pi)

Cuando ejecute el programa, la salida será:

El valor de pi es 3.141592653589793

11.6. Importar con cambio de nombre

Puede proporcionar un alias para el nombre de un módulo. Dar a un módulo un alias
corto, le permite llamar a las funciones del módulo más rápidamente. Redirecciona
su atención desde el nombre del módulo y le permite centrarse en los nombres
descriptivos de sus funciones.

Si el nombre de una función que está importando puede entrar en conflicto con
un nombre existente en el programa o si el nombre de la función es largo, puede
utilizar un sobrenombre corto y único.

La palabra clave as renombra un módulo o función usando el sobrenombre que se

proporciona.

La sintaxis general para proporcionar un sobrenombre a un módulo es:

import module_name as mn

La sintaxis general para proporcionar un sobrenombre a una función es:

from module_name import function_name as fn

Ejemplo de alias a un módulo.

# Importación de módulo con renombre

import math as m
print("El valor de pi es", m.pi)

Hemos cambiado el nombre del módulo math por m. Esto nos puede ahorrar tiempo
de escritura en algunos casos.

Tenga en cuenta que el nombre math no está reconocido en nuestro alcance; por
lo tanto, math.pi es inválido, m.pi es la implementación correcta.

Yessenia Portal Machuca 68 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

11.7. Sentencia from ... import ...

Podemos importar nombres específicos de un módulo sin importar el módulo en
su totalidad. La sintaxis general es:
from module_name import function_name

Además puede importar tantas funciones como desee de un módulo, separando el

nombre de cada función con una coma. La sintaxis es:
from module_name import function_0, function_1, function_2

Con esta sintaxis, no es necesario utilizar la notación por puntos cuando se llama
a una función.

Ejemplo.
# importando solo pi del modulo math

from math import pi

print("El valor de pu es", pi)

Como importamos solo el atributo pi del módulo. No utilizamos el operador punto.

Ejemplo de como importar de forma múltiple varias funciones.

from math import pi, e
pi
3.141592653589793

e
2.718281828459045

11.8. Importar todas las funciones

Se puede importar todas las funciones de un módulo usando el operador asterisco
(*). La sintaxis general es la siguiente.
from module_name import *

El asterisco en la sentencia de importación le dice a Python que copie cada función

desde el módulo al archivo de programa actual. Y dado que todas las funciones se
importan, puede llamar a cada función por su nombre sin utilizar la notación por
puntos.

Ejemplo.
# import todos los nombres del modulo estandar math

from math import *

print("El valor de pi es", pi)

Yessenia Portal Machuca 69 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Importamos todas las definiciones del módulo matemático. Esto hace que todos
los nombres, excepto los que comienzan con un guión bajo, sean visibles en nuestro
alcance.
Importar todo con el símbolo asterisco (*) no es una buena práctica de progra-
mación. Esto puede llevar a definiciones duplicadas para un identificador. También
dificulta la legibilidad de nuestro código.
El mejor enfoque es importar la función o funciones que desee, o importar el
módulo completo y utilizar la notación por puntos. Esto conduce a un claro código
que es fácil de leer y entender.

11.9. Búsqueda de módulo de Python

Al importar un módulo, Python mira varios lugares. El intérprete primero busca
un módulo incorporado y luego (si no lo encuentra) en una lista de directorios
definidos en sys.path. La búsqueda está en este orden.
∗ El directorio actual.
∗ PYTHONPATH (una variable de entorno con una lista de directorio).
∗ El directorio predeterminado dependiente de la instalación.
>>> import sys
>>> sys.path [’’,
’C:\\Python33\\Lib\\idlelib’,
’C:\\Windows\\system32\\python33.zip’,
’C:\\Python33\\DLLs’,
’C:\\Python33\\lib’,
’C:\\Python33’,
’C:\\Python33\\lib\\site-packages’]

Podemos agregar modificar esta lista para agregar nuestra propia ruta.

11.10. Recargando un módulo

El intérprete de Python importa un módulo solo una vez durante una sesión. Esto
hace que las cosas sean más eficientes. Ejemplo.
Supongamos que tenemos el siguiente código en un módulo llamado my_module.
# Este modulo muestra el efecto
# de varias importaciones y recargas

print("Este codigo se ha ejecutado")

Ahora vemos el efecto de las importaciones múltiples.

>>> import my_module
Este codigo se ha ejecutado

>>> import my_module

>>> import my_module

Yessenia Portal Machuca 70 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Podemos ver que nuestro código fue ejecutado solo una vez. Esto quiere decir que
nuestro módulo fue importado una sola vez.

Ahora bien, si nuestro módulo cambió durante el curso del programa, tendríamos
que volver a cargarlo. Una forma de hacerlo es reiniciar el intérprete. Pero esto no
ayuda mucho.

Python proporciona una forma limpia de hacer esto. Podemos usar la función
reload() dentro del módulo imp para recargar un módulo.
>>> import imp
>>> import my_module
Este codigo se ha ejecutado

>>> import my_module

>>> imp.reload(my_module)
Este codigo se ha ejecutado

<module ’my_module’ from ’.\\my_module.py’>

11.11. La función intertna dir()

Podemos usar la función dir() para averiguar los nombres que están definidos
dentro de un módulo.

Por ejemplo, hemos definido una función add() en el módulo example que que
se mencionó anteriormente.
>>> dir(example)
[’__builtins__’,
’__cached__’,
’__doc__’,
’__file__’,
’__initializing__’,
’__loader__’,
’__name__’,
’__package__’,
’add’]

Aquí, podemos ver una lista ordenada de nombres (junto con add). Todos los
demás nombres que comienzan con un guión bajo son atributos predeterminados
de Python asociados con el módulo (no los definimos nosotros mismos).

Por ejemplo, el atributo __name__ contiene el nombre del módulo.

>>> import example
>>> example.__name__
’example’

Yessenia Portal Machuca 71 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Todos los nombres definidos en nuestro espacio de nombres actual se pueden

encontrar utilizando la función dir() sin ningún argumento.
>>> a = 1
>>> b = "hola"
>>> import math
>>> dir()
[’__builtins__’, ’__doc__’, ’__name__’, ’a’, ’b’, ’math’, ’pyscripter’]

Yessenia Portal Machuca 72 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

12. Librería Numpy

12.1. ¿Qué es Numpy?
NumPy es un paquete de Python, que
significa Python numérico. NumPy
contiene objetos array multidimensio-
nales y las rutinas que procesan estos
array. El paquete fue creado por Tra-
vis Oliphant.
Una de las mayores ventajas de
NumPy (cuando se usa junto con
SciPy y MATPLOTLIB) es su capaci-
dad para realizar operaciones simila-
res a las de MATLAB.

Algunas de sus características más importantes incluyen:

∗ Se usa para operaciones matemáticas, lógicas y operaciones relacionadas con

el álgebra lineal.
∗ Numpy es bueno para indexar
∗ La estructura de datos más simple es un array, este consiste en elementos
homogéneos en ubicaciones de memoria consecutivas.

Los array pueden ser mulltidimensionales.

12.2. ¿Cómo puedo crear un array?

Recordemos que antes de iniciar con NumPy, se debe importar el paquete, y de
preferencia asignarle un alias, por convención np.
import numpy as np

Se tienen varias formas de crear un array, Numpy ofrece distintos comando de

acuerdo al tipo de array que se desea crear. A continuación se muestran los co-
mandos más importantes para crear un array.

Yessenia Portal Machuca 73 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Comando array(), se utiliza para convertir objetivos en array, por ejemplo listas
y tuplas.
mylist = [1, 2, 3]
myarray = np.array(mylist)
myarray

array([1, 2, 3])

El comando resize() cambia la forma y el tamaño del array.

myarray.resize(3,3)
myarray

array([[1, 2, 3],
[0, 0, 0],
[0, 0, 0]])

Con el comando array(), se puede crear una matriz usando una lista con repeti-
ciones.
np.array([1, 2, 3] * 3)

array([1, 2, 3, 1, 2, 3, 1, 2, 3])

Otra forma de repetir los elementos de una matriz es usar el comando repeat.
np.repeat([1, 2, 3], 3)

array([1, 1, 1, 2, 2, 2, 3, 3, 3])

El comando ones() devuelve un nuevo array donde sus elementos son valor 1, se
debe indicar el número de filas y el número de columnas.
np.ones((3, 2))

array([[1., 1.],
[1., 1.],
[1., 1.]])

El comando zeros() devuelve una nueva matriz donde sus elementos son ceros.
np.zeros((2, 3))

array([[0., 0., 0.],

[0., 0., 0.]])

El comando eye() devuelve una matriz con valor 1 en la diagonal y ceros en las
demás posiciones.
myarray = np.eye(3)

array([[1., 0., 0.],

[0., 1., 0.],
[0., 0., 1.]])

Yessenia Portal Machuca 74 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

El comando diag() extrae una diagonal o construye una matriz diagonal.

np.diag(myarray)

array([1, 1, 1])

La función arange() ayuda a grabar una secuencia, que tiene algún valor inicial
(start), algún valor final (stop), la diferencia entre los términos consecutivos (step)
y el tipo de datos (dtype).
numpy.arange(start, stop, step, dtype)

∗ Start: El valor inicial de la secuencia

∗ Stop: El valor hasta el cual se genera la secuencia (no se induce el valor en
sí mismo).
∗ Step: La diferencia entre los valores consecutivos
∗ dtype: El tipo de datos

a=np.arange(3,25,2, int)

a
array([3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23])

La función linspace() divide el rango dado en un número específico de elementos

y devuelve la secuencia así formada. La función toma los siguientes parámetros:
∗ start: El primer valor de la secuencia
∗ stop: El último valor (incluido hasta el punto final = Falso)
∗ num: El número de objetos
∗ endpoint: Si el endpoint es False entonces el valor "stop" no está incluido
en la secuencia.
∗ retstep: Si esto es True, se devuelve el tamaño del step.
∗ dtype: El tipo de datos de los elementos de la secuencia; si no se especifica,
entonces el tipo de datos es inferido por los valores de start y stop.
d=np.linspace(11, 27, 11)

d
array([11., 12.6, 14.2, 15.8, 17.4, 19., 20.6, 22.2, 23.8,
25.4, 27.])

En la secuencia generada dividiendo el rango 11-26 en 12 partes, el último argu-

mento del resultado es el step (1,454545454545454546).
f=np.linspace(11, 27, 11, endpoint=False, retstep=True)

f
(array([11., 12.45454545, 13.90909091, 15.36363636,
16.01010102, 18.27272727, 19.72727273, 21.10101010,
22.63636364, 24.09090909, 25.54545455]), 1.4545454545454546)

Yessenia Portal Machuca 75 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

A continuación se describe algunas de las principales funciones de para modificar

array.

Nombre Descripción
append() Añadir un elemento al final
insert() Añadir el elemento en la posición especificada. La función
tiene dos argumentos: el primero es el elemento y el
segundo es la posición
count() Esto cuenta el número de veces que se repite el argumento
pop() Elimina el elemento superior del array
remove() Elimina el elemento de una posición determinada
reverse() Invierte el orden de los elementos en el array
tostring() Convierte el array dado en una cadena

12.3. Combinar array y tipos de datos en NumPy

Ejemplo. Creamos una array de valores uno, de 2 por 3.
p = np.ones([2, 3], int)

Usar el comando vstack para combinar las matrices en secuencia vertical.

np.vstack([p, 2*p])

Usar el comando hstack para combinar las matrices en secuencia horizontal.

np.hstack([p, 2*p])

Para ver el tipo de datos de los elementos en la matriz usamos el comando dtype.
p.dtype
dtype(’int32’)

Para convertir a un tipo específico de datos, se utiliza astype.

z = p.astype(’f’)
z.dtype

dtype(’float32’)

Yessenia Portal Machuca 76 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

En la siguiente tabla se muestra los tipos de datos de NumPy.

Tipo de dato Descripción

int8 Byte (-128 a 127)
int16 Entero (-32768 to 32767)
int32 Entero (-2147483648 to
2147483647)
int64 Entero
(-9223372036854775808 to
9223372036854775807)
unit8 Entero sin signo (0 to 255)
unit64 Entero sin signo
float32 (0 to 65535)
float64 Número de punto flotante
que ocupa 64 bits de
almacenamiento
complex64 Número complejo de 64 bits

12.4. Operaciones
Recordemos que los operadores aritméticos son: +, −,∗,/ y ∗∗, para realizar sumas,
restas, multiplicaciones, divisiones y potencias a nivel de elementos. A continuación
algunos ejemplos de operaciones con array.
x=np.array([1, 2, 3])
y=np.array([4, 5, 6])

print(x + y) # Suma
[5 7 9]

print(x - y) # Resta
[-3 -3 -3]

print(x * y) # multiplicación
[1 2 3] * [4 5 6] = [4 10 18]

print(x / y) # división
[1 2 3] / [4 5 6] = [0.25 0.4 0.5]

print(x**2) # potenciación
[1 4 9]

r = x.dot(y) # dot product 1*4 + 2*5 + 3*6

r
32

Yessenia Portal Machuca 77 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Se usa el comando transpose para transponer una matriz .

array([[ 4, 5, 6],
[16, 25, 36]])

np.transpose

array([[ 4, 16],
[ 5, 25],
[ 6, 36]])

12.5. Broadcasting
Python aplica las operaciones elemento por elemento no sólo en suma o resta,
sino también en el caso de multiplicación y división, tal como se mostró en la
sección 12.4, entonces surge la pregunta ¿Qué pasa si se suman dos arrays de
diferentes dimensiones? Python tiene una forma de lidiar con tales situaciones:
es se denomina Broadcasting.

Si se desea suma un array A de 4 por 1, con un array B de 1 por 3, se emplea

brodcasting.

El array A array bidimensional copiando los elementos de la primera columna en

todas las demás columnas necesarias, este caso 2 columnas adicionales, para igual
el número de columnas de array B. Del mismo modo, el array B de columnas tam-
bién se convierte en un array bidimensional copiando los elementos de la primera
fila en todas las demás filas, en ese ejemplo se requiere 3 filas adicionales. Por
tanto, el array A y el array B, tienen la misma dimensión.

Yessenia Portal Machuca 78 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

12.6. Funciones agregadas

El módulo NumPy contiene muchas funciones agregadas. A continuación se men-
ciona algunas funciones estatidísticas.

∗ numpy.sum() encuentra la suma de los elementos del argumento.

∗ numpy.prod() encuentra el producto de los elementos del argumento.
∗ numpy.mean() encuentra la media de los elementos del argumento.
∗ numpy.std() encuentra la desviación estándar de los elementos del argu-
mento.
∗ numpy.var() encuentra la varianza de los elementos del argumento.
∗ numpy.max() encuentra el elemento máximo del argumento. En en el caso
de un array 2D el eje en el que se desea el elemento máximo también se
puede mencionar axis=0 indica columnas y axis=1 indica filas.
∗ numpy.min() encuentra el elemento mínimo del argumento. De la misma
forma que en a función anterior, se puede elegir el eje en el que se desea el
elemento mínimo.
∗ numpy.argmin() encuentra la posición (índice) del elemento máximo.
∗ numpy.argmax() encuentra la posición del elemento mínimo.
∗ numpy.median() encuentra la mediana de los elementos del argumento.
∗ numpy.percentile() encuentra el percentil de los elementos del argumento.

Veamos algunos ejemplos de funciones matemáticas integradas:

Se tiene el siguiente array "m", con la que se aplicaran distintas funciones mate-
máticas.
m = np.array([-4, -2, 1, 3, 5])

Función suma.
m.sum()

In[1]: 3

Función máximo
m.max()
In[2]: 5

Función mínimo
m.min()
In[3]:-4

Función promedio
m.mean()
In[4]: 0.6

Yessenia Portal Machuca 79 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Función desviación estándar

m.std()
In[5]: 3.2619012860600183

Para mayor detalle y exploración de las funciones agregadas que tiene NumPy,
ingresar al link https://www.numpy.org/devdocs/reference/index.html#reference

12.7. Indexación
La sintaxis estandar de indexación en Pyhton es: x[obj], donde x es la matriz
y obj la selección de elementos. Se tienen 3 tipos de indexación disponible: basic
slicing, advanced indexing y field access,

12.7.1. Basic slicing (rebanado básico).

Este tipo de indexación se usa para objetivo slice, enteros, listas o tuplas.

Se extiende el concepto de indexación de Python [i:j:k] a N dimensiones; donde

i es el índice inicial, j el índice de detención, y k el step (k 6= 0). Esto selecciona
los m elementos.

Ejemplo 1: Se tiene la siguiente array “myarray”.

myarray = np.arange(13)**2
myarray

array([ 0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144])

Recordemos que la indexación comienza en 0. Si no se proporciona j, el valor

predeterminado es n (nro. elementos en el array) para k > 0 y -n-1 para k < 0 .
Si no se da k, su valor predeterminado es 1. Además tener en cuenta que :: es lo
mismo que : y significa seleccionar todos los índices a lo largo de este eje.

Si no se indica el inicio o fin de la indexación, se establecerá de forma predetermi-

nada el inicio / final de la matriz.
myarray[1:5]
array([ 1, 4, 9, 16])

Para contar de derecha a izquierda, se usa los números negativos.

myarray[-4:]
array([ 81, 100, 121, 144])

myarray[-5::-2]
array([64, 36, 16, 4, 0])

Yessenia Portal Machuca 80 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Ejemplo 2. Se tiene la siguiente matriz r.

r = np.arange(36)
r.resize((6, 6))

array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11],
[12, 13, 14, 15, 16, 17],
[18, 19, 20, 21, 22, 23],
[24, 25, 26, 27, 28, 29],
[30, 31, 32, 33, 34, 35]])

La sintaxis de indexación con corchetes y comas es: nombre_array [fila, columna].

r[2, 2]
14

Usamos la combinación de coma y dos puntos para seleccionar un rango de filas

o columnas.
r[3, 3:6]

array([21, 22, 23])

r[:2, :-1]
array([[ 0, 1, 2, 3, 4],
[ 6, 7, 8, 9, 10]])

También podemos realizar indexación condicional. Por ejemplo, seleccionar los

valores de la matriz r que son mayores de 30.
r[r > 30]
array([31, 32, 33, 34, 35])

12.7.2. Indexación Avanzada.

Esta indexación se activa cuando el objeto de selección obj es un objeto de se-
cuencia. Se tiene dos tipos de indexación avanzada: entero y booleana.

La indexación de array entero permite la selección de elementos arbitrarios en el

array en función de su índice. De cada fila se debe selecionar un elemento, y el
índice de la columna especifica el elemento a elegir para cada columna.

Ejemplo.
t = np.array([[1,2],[3,4],[5,6]])
x[[0,1,2],[0,1,0]]
array([1,4,5])

Yessenia Portal Machuca 81 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Indexación booleana, se usa cuando el objeto es del tipo booleano, el resultado es

devuelto por los operadores de comparación.

Ejemplo.
x = np.array([1., -1., -2., 3])
x[x < 0] += 20
x

array([ 1., 19., 18., 3.])

12.8. Conjuntos estructurados

Los array estructurados nos ayudan a crear un array con una estructura como
elemento.

El siguiente código muestra un ejemplo de creación de una array estructurado.

import numpy as np

name=[’Harsh’,’Naved’,’Aman’,’Lovish’]
age=[100,70,24,18]
salary=[75500.00,65500.00,55500.00,45500.00]

data=np.zeros(4,dtype={’names’:(’name’,’age’,’salary’),
’formats’:(’U10’,’i4’,’f8’)})

data[’name’]=name
data[’age’]=age
data[’salary’]=salary

print(data)

#Output

[(’Harsh’, 100, 75500.0) (’Naved’, 70, 65500.0) (’Aman’, 24,

55500.0)
(’Lovish’, 18, 45500.0)]

Yessenia Portal Machuca 82 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Una vez que se ha creado un array estructurado, se puede acceder a los datos de
la forma habitual. Por ejemplo, para mostrar el valor de un atributo en particular,
podemos simplemente mencionar el nombre del atributo en comillas simples dentro
de los corchetes.
data[’name’]

#Output
data[’name’]
array([’Harsh’, ’Naved’, ’Aman’, ’Lovish’], dtype=’<U10’)

data[’age’]
array([100, 70, 24, 18])

data[’salary’]
array([ 75500., 65500., 55500., 45500.])

data[1]
(’Naved’, 70, 65500.0)

El paquete Numpy ayuda al programador a manejar los arreglos multidimensionales

de la manera más sofisticada.

Yessenia Portal Machuca 83 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

13. Pandas
13.1. ¿Qué es Pandas?
Pandas es un paquete que proporciona un conjunto completo de estructuras de
datos para explorar, limpiar y manipular datos, además de realizar diversos análisis
estadísticos y financieros.

Algunas de las tareas que se pueden

realizar son las siguientes:
∗ Lectura/escritura de muchos
formatos de datos diferentes.
∗ Selección de subconjuntos de
datos.
∗ Cálculo entre filas y columnas.
∗ Aplicación de operaciones a
grupos independientes de datos.
∗ Transformación de datos.
∗ Combinación de varios conjun-
tos de datos.
∗ Funcionalidad avanzada de se-
ries de tiempo.
∗ Visualización a través de mat-
plotlib y seaborn.

Para utilizar las funciones de Pandas, se requiere importar el paquete en su entorno

IPython:
import pandas as pd
import numpy as np

Las dos principales estructuras de datos en Pandas son: Series y DataFrame.

13.2. Series
Series es el principal componente de Pandas y representa un array etiquetado
unidimensional basado en ndarray de NumPy. Series amplía la funcionalidad
del ndarray NumPy añadiendo un conjunto de etiquetas asociadas que se utilizan
para indexar los elementos del array.

Este etiquetado añade un poder significativo para acceder a los elementos de

Series sobre un array NumPy. En lugar de acceder simplemente a los elementos
por posición, un objeto Series permite acceso a los artículos a través de las etique-
tas de índice asociadas. El índice ayuda también en una característica de Pandas
denominada alineación, donde las operaciones entre dos Series son aplicadas a
valores con etiquetas idénticas.

Yessenia Portal Machuca 84 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

13.2.1. Creación e indexación de Series

Se puede crear un objeto Series declarando un valor escalar, un array NumPy o
un diccionario/lista Python a la función pd.Series().

Por ejemplo, el siguiente comando crea un objeto Series de 100 números aleatorios
normalmente distribuidos.
In [1]:
np.random.seed(1)
s = pd.Series(np.random.randn(100))
s

Out[1]:
0 1.624345
1 -0.611756
2 -0.528172
3 -1.072969
...
96 -0.343854
97 0.043597
98 -0.620001
99 0.698032
Length: 100, dtype: float64

Los elementos individuales de un Series se pueden extraer usando el operador []

del objeto Series. Por ejemplo, extraer el elemento con la etiqueta de índice 2.
In [2]:
s[2]

Out[2]:
-0.528171752263

Se pueden recuperar múltiples valores usando un array de valores etiqueta como

se muestra a continuación:
In [3]:
s[[2, 5, 20]]

Out[3]:
2 -0.528172
5 -2.301539
20 -1.100619
dtype: float64

Yessenia Portal Machuca 85 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Series soporta el rebanado (slicing) utilizando la notación rebanada (slice) : .

El siguiente comando recupera los elementos de Series donde las etiquetas son
mayores que 3 pero menores que 8.
In [4]:
s[3:8]
Out[4]:
3 -1.072969
4 0.865408
5 -2.301539
6 1.744812
7 -0.761207
dtype: float64

Tenga en cuenta que slicing no sólo devuelve los valores sino también cada ele-
mento (etiqueta de índice y valor) de la serie con las etiquetas especificadas.

La funciones .head() y .tail() son proporcionados por Pandas para examinar

sólo los primeros o últimos registros de una serie. Por defecto, devuelven las pri-
meras o últimas cinco filas, respectivamente, pero puede utilizar el parámetro n o
simplemente escribir un número entero para especificar el número de filas:
In [5]:
s.head()
0 1.624345
1 -0.611756
2 -0.528172
3 -1.072969
4 0.865408
dtype: float64

In [7]:
s.tail()
Out[5]:
95 0.077340
96 -0.343854
97 0.043597
98 -0.620001
99 0.698032
dtype: float64

Yessenia Portal Machuca 86 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Un Series consiste de un índice y una secuencia de valores. El índice se puede

recuperar usando la propiedad .index:
In [6]:
s.index
Out[6]:
Int64Index([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
95, 96, 97, 98, 99], dtype=’int64’)

Cuando se crea un objeto Series y no se establecen explícitamente los valores

de la etiqueta de índice mediante la función pd.Series, Pandas asignarán va-
lores enteros secuenciales a partir de 0. Para especificar etiquetas de índice no
predeterminadas, utilice el argumento index de la función o asígnelos utilizando
la propiedad .index después de la crear la serie.
In [7]:
s2 = pd.Series([1, 2, 3, 4], index=[’a’, ’b’, ’c’, ’d’])
s2

Out[7]:
a 1
b 2
c 3
d 4 dtype: int64

Un Series puede ser creada directamente desde un diccionario Python. Las claves
del diccionario se utilizan como etiquetas de índice para Series:
In [8]:
s2 = pd.Series({’a’: 1, ’b’: 2, ’c’: 3, ’d’: 4, ’e’: 5})
s2

Out[8]:
a 1
b 2
c 3
d 4
e 5
dtype: int64

Yessenia Portal Machuca 87 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

13.2.2. Tamaño, forma y conteo de valores

El número de elementos de un objeto Series también puede determinarse me-
diante la función len():
In [9]:
s = pd.Series([10, 0, 1, 1, 2, 3, 4, 5, 6, np.nan])
len(s)

Out[9]:
10

El número de elementos de una serie también puede determinarse utilizando la

propiedad .shape, que devuelve una tupla que contiene la dimensionalidad de la
serie. Dado que un objeto Series es unidimensional, sólo se proporciona el valor
de longitud en la tupla:
In [10]:
s.shape
Out[10]:
(10,)

El número de filas de un objeto Series que no tienen un valor de NaN se puede

determinar con la función .count(). La función np. nan, crea un valor NaN.
In [11]:
s.count()

Out[11]:
9

Para determinar todos los valores únicos de un Series, Pandas proporciona la

función.unique():
In [12]:
s.unique()
Out[12]:
array([5., 0., 1., 2., 3., 4., 5., 6., nan])
dtype: int64

El conteo de cada uno de los elementos únicos de un objeto Series se puede

obtener usando .value_counts().
In [13]:
s.value_counts()
Out[13]:
5 2
1 2
6 1
4 1
3 1
2 1
0 1
dtype: int64

Yessenia Portal Machuca 88 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

13.2.3. Alineación mediante etiquetas de índice

El proceso de añadir dos objetos Series difiere de un array ya que primero alinea
los datos basándose en los valores de la etiqueta de índice en lugar de simplemente
aplicar la operación a elementos en la misma posición. Esto se vuelve significati-
vamente poderoso cuando se usa Series de Pandas para combinar datos basados
en etiquetas en lugar de tener que pedir primero el datos manualmente.

El resultado que se obtiene en Series es muy diferente al que se obtendría si se

añadiera un ndarray NumPy puro. A ndarray NumPy añadiría los elementos en
posiciones idénticas de cada array.

Por ejemplo, se tienen dos objetos Series:

In [14]:
s3 = pd.Series([1, 2, 3, 4], index=[’a’, ’b’, ’c’, ’d’])
s3

Out[14]:
a 1
b 2
c 3
d 4
dtype: int64

In [15]:
s4 = pd.Series([4, 3, 2, 1], index=[’d’, ’c’, ’b’, ’a’])
s4

Out[15]:
d 4
c 3
b 2
a 1
dtype: int64

El resultado de sumar las dos series se muestra a continuación:

In [15]:
s3 + s4

Out[15]:
a 2
b 4
c 6
d 8
dtype: int64

Yessenia Portal Machuca 89 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

13.3. El DataFrame
Series es la base para la representación y manipulación de datos en Pandas,
pero como sólo puede asociar un único valor con cualquier etiqueta de índice
dada, termina teniendo una capacidad limitada para modelar múltiples variables
de datos en cada etiqueta de índice.

El DataFrame Pandas resuelve este problema al proporcionar la capacidad de

gestionar sin problemas varias Series, en las que cada una de las Series
representa una columna del DataFrame y también alinea automáticamente los
valores de cada columna a lo largo de las etiquetas de índice del DataFrame.

En cierto modo, un DataFrame puede ser considerado como un diccionario conte-

nedor de uno o más objetos Series, como una tabla de base de datos relacional.
Una buena manera de pensar en un DataFrame es que unifica dos o más series en
una sola estructura de datos.

Un DataFrame tiene dos ejes, horizontal y vertical. Las funciones de los Pandas se
pueden aplicarse a cualquiera de los dos ejes, en esencia, indicando que se aplica
a todos los valores de las filas seleccionadas o a todos los ítems de las columnas
específicadas.

13.3.1. Creación de un DataFrame

Hay varias maneras de crear un DataFrame. Probablemente, el más sencillo es
crearlo desde una array NumPy, con la función DataFrame().
In [16]:
pd.DataFrame(np.array([[10, 11], [20, 21]]))

Out[16]:
0 1
0 10 11
1 20 21

Cada fila del array forma una fila en el DataFrame. Como no especificamos un
índice, Pandas crea un índice int64 por defecto de la misma manera que un
Series. Como tampoco especificamos los nombres de columna, Pandas también
asigna los nombres para cada columna con una serie entera basada en cero.

Un DataFrame también se puede inicializar a partir de una lista de objetos Series:

In [17]:
df1 = pd.DataFrame([pd.Series(np.arange(10, 15)),
pd.Series(np.arange(15, 20))])
df1

Out[17]:
0 1 2 3 4
0 10 11 12 13 14
1 15 16 17 18 19

Yessenia Portal Machuca 90 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Las dimensiones de un DataFrame se pueden determinar utilizando su propiedad

.shape. Un DataFrame es siempre bidimensional. La forma nos informa con el
primer valor el número de filas y con el segundo el número de columnas:
In [18]:
df1.shape
Out[18]:
(2, 5)

Los nombres de columna se pueden especificar en el momento de crear el

DataFrame utilizando el argumento columns de la función DataFrame() . Por
ejemplo:
In [19]:
df = pd.DataFrame(np.array([[10, 11], [20, 21]]),
columns=[’a’, ’b’])
df

Out[19]:
a b
0 10 11
1 20 21

Asimismo, se puede acceder o cambiar el nombre de las columnas de un DataFrame

con la propiedad .columns. Por ejemplo:
In [20]:
df.columns

Out[20]:
Index([u’a’, u’b’], dtype=’object’)

In [21]:
df.columns = [’c1’, ’c2’]
df
Out[26]:
c1 c2
0 10 11
1 20 21

También se pueden asignar las etiquetas de índice utilizando el argumento index

de la función DataFrame()o asignando una lista directamente a la propiedad
.index:
In [22]:
df = pd.DataFrame(np.array([[0, 1], [2, 3]]),
columns=[’c1’, ’c2’],
index=[’r1’, ’r2’])
df

Out[22]:
c1 c2
r1 0 1
r2 2 3

Yessenia Portal Machuca 91 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

También se puede crear un DataFrame declarando un diccionario que contenga

uno o más objetos Series, donde las claves del diccionario contienen los nombres
de las columnas y cada serie es una columna de datos:
In [23]:
s1 = pd.Series(np.arange(1, 6, 1))
s2 = pd.Series(np.arange(6, 11, 1))
pd.DataFrame({’c1’: s1, ’c2’: s2})

Out[23]:
c1 c2
0 1 6
1 2 7
2 3 8
3 4 9
4 5 10

Un DataFrame también realiza la alineación automática de los datos para ca-

da Series indicada por un diccionario. Como demostración, el siguiente coman-
do añade una tercera columna en la creación del DataFrame. Este tercer objeto
Series contiene dos valores y especificará su índice. Cuando se crea el DataFrame,
todas las series del diccionario se alinean entre sí mediante la etiqueta de índice a
medida que se agrega al DataFrame:
In [24]:
s3 = pd.Series(np.arange(12, 14), index=[1, 2])
pd.DataFrame({’c1’: s1, ’c2’: s2, ’c3’: s3})
Out[24]:
c1 c2 c3
0 1 6 NaN
1 2 7 12
2 3 8 13
3 4 9 NaN
4 5 10 NaN

En el ejemplo anterior se aprecia que los dos primeros objetos Series no tenían un
índice especificado por lo que ambos fueron indexados con 0 a 4. El tercer Series
tiene valores de índice; por lo tanto, los valores para esos índices se colocan en
el DataFrame en la fila con el índice correspondiente de las columnas anteriores.
Entonces, Pandas completa automáticamente con NaN para los valores que no
fueron suministrados.

Otra forma de crear un DataFrame es importar datos de un archivo csv. Excel, para
esto se utiliza la función read_csv() o read_excel() respectivamente. Para ex-
portar archivo externos en otras extensiones revisar el link https://pandas.pydata.org/pandas-
docs/stable/reference/io.html.

Yessenia Portal Machuca 92 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Por ejemplo, crear un DataFrame a partir de un archivo .csv

In [25]:
sp500 = pd.read_csv("sp500.csv",
index_col=’Symbol’,
usecols=[0, 2, 3, 7])

Out[25]:
Sector Price Book Value
Symbol
MMM Industrials 141.14 26.668
ABT Health Care 39.60 15.573
ABBV Health Care 53.95 2.954
ACN Information Technology 79.79 8.326
ACE Financials 102.91 86.897

13.3.2. Selección de columnas de un DataFrame

Para seleccionar columnas de un se usa el operador [], se debe indicar el índice
de las columnas a seleccionar separado por comas.

Por ejemplo considerando DataFrame el sp500, obtenemos las 3 primeras filas de

la columna 1 y 2.
In [26]:
sp500[[1, 2]].head(3)

Out[26]:
Price Book Value
Symbol
MMM 141.14 26.668
ABT 39.60 15.573
ABBV 53.95 2.954

También se pueden seleccionar multiples columnas por el nombre de la columnas.

Por ejemplo:
In [27]:
sp500[[’Price’, ’Sector’]]

Out[27]:
Price Sector
Symbol
MMM 141.14 Industrials
ABT 39.60 Health Care
ABBV 53.95 Health Care
ACN 79.79 Information Technology
... ... ...
YUM 74.77 Consumer Discretionary
ZMH 101.84 Health Care
ZION 28.43 Financials
ZTS 30.53 Health Care
[500 rows x 2 columns]

Yessenia Portal Machuca 93 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Finalmente, las columnas también se pueden extraer utilizando lo que se conoce

como acceso de atributo. Cada columna en un DataFrame agrega dinámica-
mente una propiedad al DataFrame para cada columna donde el nombre de la
propiedad es el nombre de la columna. Es decir, al seleccionar una sola columna,
el valor resultante es un objeto Series. Por ejemplo:
In [28]:
sp500.Price

Out[28]:
Symbol
MMM 141.14
ABT 39.60
ABBV 53.95
ACN 79.79
...
YUM 74.77
ZMH 101.84
ZION 28.43
ZTS 30.53
Name: Price, dtype: float64

13.3.3. Selección de filas de un DataFrame mediante el índice

La selección de filas mediante index en un DataFrame se desglosa en las siguentes
categorías generales de operaciones:
- Indexación con el operador [].
- Búsqueda basada en etiquetas o ubicaciones utilizando .loc, .iloc y .ix
- Búsqueda escalar por etiqueta o ubicación usando .at y .iat

1. Slicing (rebanar) con el operador []

Rebanar un DataFrame a través de su índice es idéntico a rebanar un Series. La
rebanada se realiza tanto con las posiciones como con las etiquetas.

Ejemplos:

In [29]:
sp500[:3]
Out[29]:
Sector Price Book Value
Symbol
MMM Industrials 141.14 26.668
ABT Health Care 39.60 15.573
ABBV Health Care 53.95 2.954

Yessenia Portal Machuca 94 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

In [30]:
sp500[’XYL’:’YUM’]
Out[30]:
Sector Price Book Value
Symbol
XYL Industrials 38.42 12.127
YHOO Information Technology 35.02 12.768
YUM Consumer Discretionary 74.77 5.147

2. Selección de filas por la etiqueta del índice o ubicación

Las filas se puede extraer utilizando .loc[], indicando el valor de la etiqueta

del índice. Por ejemplo:
In [31]:
sp500.loc[[’MMM’, ’MSFT’]]

Out[31]:
Sector Price Book Value
Symbol
MMM Industrials 141.14 26.668
MSFT Information Technology 40.12 10.584

Las filas también se pueden extraer indicando la ubicación del índice usando
.iloc[]:
In [32]:
sp500.iloc[[0, 2]]

Out[32]:
Sector Price Book Value
Symbol
MMM Industrials 141.14 26.668
ABBV Health Care 53.95 2.954

Es posible buscar la ubicación del índice de un valor de etiqueta específico,

que puede utilizarse para recuperar la(s) fila(s):
In [33]:
i1 = sp500.index.get_loc(’MMM’)
i2 = sp500.index.get_loc(’A’)
i1, i2

Out[33]:
(0, 10)

In [34]:
sp500.iloc[[i1, i2]]
Out[34]:
Sector Price Book Value
Symbol
MMM Industrials 141.14 26.668
A Health Care 56.18 16.928

Yessenia Portal Machuca 95 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

3. Selección de filas por la etiqueta de índice y/o ubicación

Un DataFrame también contiene una propiedad .ix[] que puede ser usada
para buscar filas ya sea por la etiqueta de índice o por la ubicación, esencial-
mente combinando .loc y .iloc en una.
Por ejemplo:
In [35]:
sp500.ix[[’MSFT’, ’ZTS’]]

Out[35]:
Sector Price Book Value
Symbol
MSFT Information Technology 40.12 10.584
ZTS Health Care 30.53 2.150

La búsqueda basada en la ubicación se puede realizar con el siguiente código.

In [36]:
sp500.ix[[10, 200, 450]]

Out[36]:
Sector Price Book Value
Symbol
A Health Care 56.18 16.928
GIS Consumer Staples 53.81 10.236
TRV Financials 92.86 73.056

4. Búsqueda escalar por etiqueta o ubicación

Los valores escalares se pueden buscar por etiqueta usando .at[] indicando
la etiqueta de la fila y luego el nombre/valor de la columna:
In [37]:
sp500.at[’MMM’, ’Price’]

Out[37]:
141.14

Los valores escalares también pueden ser buscados por ubicación usando
.iat[] indicando la ubicación de la fila como de la columna. Este es el
método preferido para acceder a los valores y resultados individuales.
In [38]:
sp500.iat[0, 1]

Out[38]:
141.14

Yessenia Portal Machuca 96 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

13.3.4. Selección de líneas mediante la selección Boolean

Las filas también se pueden seleccionar utilizando selección Booleana con un array
calculado a partir del resultado de aplicar una condición lógica a los valores de
cualquiera de las columnas. Esto nos permite crear selecciones más complicadas
que las basadas simplemente en etiquetas de índice o posiciones.

Por ejemplo, seleccionar todas las compañías que tienen un precio por debajo de
100.0
In [39]:
sp500.Price < 100

Out[39]:
Symbol
MMM False
ABT True
ABBV True
ACN True
...
YUM True
ZMH False
ZION True
ZTS True
Name: Price, Length: 500, dtype: bool

Esto arroja un Series que puede ser usados para seleccionar filas donde el valor
es True:
In [40]:
sp500[sp500.Price < 100]

Out[40]:
Sector Price Book Value
Symbol
ABT Health Care 39.60 15.573
ABBV Health Care 53.95 2.954
ACN Information Technology 79.79 8.326
ADBE Information Technology 64.30 13.262
... ... ... ...
YHOO Information Technology 35.02 12.768
YUM Consumer Discretionary 74.77 5.147
ZION Financials 28.43 30.191
ZTS Health Care 30.53 2.150

[407 rows x 3 columns]

Yessenia Portal Machuca 97 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Se pueden juntar múltiples condiciones usando paréntesis y al mismo tiempo se-

leccionar sólo un subconjunto de las columnas. El siguiente comando recupera los
símbolos y el precio de todas las acciones con un precio inferior a 10 y superior a
0:

In [41]:
sp500[(sp500.Price < 10) & (sp500.Price > 0)] [[’Price’]]

Out[41]:
Symbol Price
FTR 5.81
HCBK 9.80
HBAN 9.10
SLM 8.82
WIN 9.38

13.3.5. Aritmética en un DataFrame

Las operaciones aritméticas que utilizan valores escalares se aplicarán a cada ele-
mento de un DataFrame.

Por defecto, cualquier operación aritmética se aplicará a todas las filas y columnas
de un DataFrame y devolverá un nuevo DataFrame con los resultados (dejando el
original sin cambios).

Al realizar una operación entre un DataFrame y un Series, Pandas alineará el

índice de Series a lo largo de las columnas del DataFrame, lo que se denomina
transmisión en fila.

Por ejemplo:
In [42]:
np.random.seed(123456)
df = pd.DataFrame(np.random.randn(5, 4),
columns=[’A’, ’B’, ’C’, ’D’])

In [42]:
df - df.iloc[0]

Una operación aritmética entre dos objetos DataFrame se alineará con las etique-
tas de las columnas y de los índices.

Yessenia Portal Machuca 98 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Por ejemplo: extrae una pequeña porción de un DataFrame y sustraer de DataFrame.

El resultado demuestra que los valores alineados se restan a 0, mientras que los
otros se ajustan a NaN:
In [43]:
subframe = df[1:4][[’B’, ’C’]]
subframe

Out[43]:
B C
1 -0.173215 0.119209
2 -2.104569 -0.494929
1 -0.706771 -1.039575

In [44]:
df subframe
Out[44]:
A B C D
0 NaN NaN NaN NaN
1 NaN 0 0 NaN
2 NaN 0 0 NaN
3 NaN 0 0 NaN
4 NaN NaN NaN NaN

Se puede obtener un control adicional de una operación aritmética utilizando los

métodos aritméticos proporcionados por el objeto DataFrame. Estos métodos pro-
porcionan la especificación de un eje en particular. El siguiente comando muestra la
resta a lo largo del eje de una columna utilizando el objeto DataFrame; el método
.sub() resta la columna A de cada columna:
In [45]:
a_col = df[’A’]
df.sub(a_col, axis=0)

13.4. Reindexación de los objetos Series y DataFrame

La reindexación en Pandas es un proceso que hace que los datos de un objeto
Series o DataFrame coincida con un conjunto dado de etiquetas a lo largo de un
eje en particular. Este es el núcleo de la funcionalidades de Pandas ya que permite
la alineación de etiquetas a través de múltiples objetos.

El proceso de realizar una reindexación hace lo siguiente:

∗ Reordena los datos existentes para que coincidan con un conjunto de etique-
tas.
∗ Inserta marcadores NaN donde no existen datos para una etiqueta.
∗ Rellena los datos faltantes para una etiqueta utilizando un tipo de lógica (por
default añadir NaNs).

Yessenia Portal Machuca 99 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Reindexación de un objeto Series. Por ejemplo, la siguiente serie tiene un índice

con valores numéricos, y el índice es modificado a alfabético mediante una simple
asignación de una lista de caracteres a la propiedad .index, haciendo que los
valores puedan ser accesibles mediante las etiquetas de caracteres en el nuevo
índice.
In [46]:
np.random.seed(1)
s = pd.Series(np.random.randn(5))
s
Out[46]:
0 1.624345
1 -0.611756
2 -0.528172
3 -1.072969
4 0.865408

dtype: float64

In [47]: s.index = [’a’, ’b’, ’c’, ’d’, ’e’]

s

Out[47]:
a 1.624345
b -0.611756
c -0.528172
d -1.072969
e 0.865408
dtype: float64

Se proporciona una mayor flexibilidad en la creación de un nuevo índice utilizando

el método .reindex(). Si hay una etiqueta de índice creada para la cual Series
no tenía una etiqueta existente, se le asignará el valor NaN.

Un ejemplo de flexibilidad de .reindex() sobre la asignación directa de la propie-

dad .index es que la lista proporcionada a .reindex() puede tener una longitud
diferente que el número de filas en Series:
In [48]:
s2 = s.reindex([’a’, ’c’, ’e’, ’g’])
s2[’a’] = 0
s2

Out[48]:
a 0.000000
c -0.528172
e 0.865408
g NaN
dtype: float64

Yessenia Portal Machuca 100 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

La reindexación también es útil cuando se desea alinear dos series para realizar una
operación de emparejamiento entre de los elementos de cada serie, pero por alguna
razón, los dos series tenían etiquetas de índice que no se alinearon inicialmente.

Por ejemplo, el primer objeto Series tiene índices como números enteros secuen-
ciales, pero el segundo tiene una representación de cadena de lo que sería números
enteros secuenciales. La adición de ambos Series tiene el siguiente resultado,
donde todos son NaNs y se tiene valores de etiqueta repetidos:
In [49]:
s1 = pd.Series([0, 1, 2], index=[0, 1, 2])
s2 = pd.Series([3, 4, 5], index=[’0’, ’1’, ’2’])
s1 + s2

Out[49]:
0 NaN
1 NaN
2 NaN
0 NaN
1 NaN
2 NaN
dtype: float64

En este caso, Pandas primero intentan alinearse con los índices y al no encontrar
coincidencias, copia las etiquetas de los índices del primer objeto Series e intentan
añadir los índices del segundo objeto Series. Pero como son de otro tipo, se
vuelve a establecer por defecto una secuencia entera basada en cero, lo que da
como resultado valores duplicados. Y finalmente, todos los valores resultantes son
NaN porque la operación intenta añadir el ítem de la primera serie con la etiqueta
entera 0, que tiene el valor 0 pero no puede encontrar el ítem de la otra serie
con la etiqueta entera 0; por lo tanto, el resultado es NaN. Este inconveniente se
soluciona con la reindexación de la segunda serie, convirtiendo los valores a int:
In [50]:
s2.index = s2.reindex.values.astype(int)
s1 + s2

Out[50]:
0 3
1 5
2 7
dtype: int64

La acción por defecto de insertar NaN como un valor omitido durante .reindex()
puede ser cambiada usando el argumento fill_value, que completa con ceros
en lugar de NaN:

Yessenia Portal Machuca 101 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

In [52]:
s2 = s.copy()
s2.reindex([’a’, ’f’], fill_value=0)

Out[51]:
a 1.624345
f 0.000000
dtype: float64

Cuando se realiza un reindex sobre datos ordenados, como una serie de tiempo, es
posible realizar interpolación o rellenado de valores. Para demostrar el concepto,
usemos el siguiente objeto Series:
In [52]:
s3 = pd.Series([’red’, ’green’, ’blue’], index=[0, 3, 5])
s3

Out[52]:
0 red
3 green
5 blue
dtype: object

El siguiente código muestra el llenado hacia adelante, al que a menudo se

hace referencia como el último valor conocido. El objeto Series es reindexado
para crear un índice entero contiguo y usando el parámetro method=’ffill’,
cualquier nueva etiqueta de índice se le asigna un valor previamente visto a lo
largo de Series.
In [53]:
s3.reindex(np.arange(0,7), method=’ffill’)

Out[53]:
0 red
1 red
2 red
3 green
4 green
5 blue
6 blue
dtype: object

Por el contrario, cuando se llena hacia atrás se utiliza tilizando el parámetro

method=’bfill’.
In [54]:
s3.reindex(np.arange(0,7), method=’bfill’)

Out[54]:
0 red
1 green
2 green
3 green 4 blue 5 blue 6 NaN dtype: object

Yessenia Portal Machuca 102 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

13.5. Manipulación de DataFrame aplicado a Finanzas.

Antes de iniciar a explorar las funciones para manipular DataFrame importaremos
algunas paquetes previos.
import Pandas as pd
import numpy as np
import datetime
import matplotlib.pyplot as plt

# Configurar paquete matplotlib

%matplotlib inline
pd.set_option(’display.notebook_repr_html’, False)
pd.set_option(’display.max_columns’, 15)
pd.set_option(’display.max_rows’, 8)
pd.set_option(’precision’, 3)

Importamos información de acciones de MSFT y AAPL del año 2019 extraídos de

Yahoo! Finance, para ejemplificar los conceptos que se explorarán en esta sección
de Pandas.

El siguiente comando puede utilizarse para cargar la información de acciones di-

rectamente desde la Web:
import pandas.io.data as web
start = datetime.datetime(2019, 1, 1)
end = datetime.datetime(2019, 12, 30)
msft = web.DataReader("MSFT", ’yahoo’, start, end)
aapl = web.DataReader("AAPL", ’yahoo’, start, end)

# Guardar la información en archivos csv.

# msft.to_csv("msft.csv")
# aapl.to_csv("aapl.csv")

Recordemos que para importar datos de archivos csv. usamos la función pd.read_csv().
Y se extraen parte de los datos del DataFrame para fines de los ejemplos.
In [1]:
msft = pd.read_csv("msft.csv", index_col=0, parse_dates=True)
aapl = pd.read_csv("aapl.csv", index_col=0, parse_dates=True)

In [2]:
msft[:3]

In [3]:
aapl[:3]

Yessenia Portal Machuca 103 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

13.5.1. Reorganización y reestructuración de datos

Cuando se trabaja con información financiera, a menudo ocurre que los datos
recuperados de casi cualquier fuente de datos no estarán en el formato que se
necesita para realizar los análisis que se desean. O quizás, igual de probable, los
datos de una fuente específica pueden estar incompletos y requerir la recolección
de datos de otra fuente, en cuyo momento, los datos deben ser concatenados o
fusionados a través de operaciones conjuntas entre los datos.

Incluso si los datos están completos o después de combinarlos de varias fuentes,

pueden estar organizados de una manera que no conduzca a un tipo específico de
análisis. Por lo tanto, es necesario reestructurarla.

Pandas ofrecen una gran variedad de funciones para concatenar, fusionar y resstruc-
turar los datos. Estas secciones siguientes nos llevan a través de varios escenarios
comunes de cada uno, utilizando datos de acciones (ejemplos: MSFT y AAPL).

1. Concatenación de múltiples objetos DataFrame

La concatenación en Pandas es el proceso de crear un nuevo objeto Pandas

combinando datos de dos (o más) objetos Pandas en un nuevo objeto Pandas
a lo largo de un único eje especificado de los dos objetos. La concatenación
con datos de acciones es útil para combinar valores tomados en diferentes
períodos de tiempo, para crear columnas adicionales que representen otras
mediciones en una fecha y hora determinadas para una acción en específico,
o para añadir una columna para la misma medición de una acción diferente
pero para el mismo período de tiempo.
Los objetos DataFrame son concatenados por Pandas a lo largo de un eje
específico: los dos ejes son las etiquetas de índice de las filas y las columnas.
Esto se hace primero extrayendo las etiquetas de los dos índices de objetos
DataFrame a lo largo del eje especificado, usando ese conjunto como índice
del nuevo DataFrame, y luego copiando los valores a lo largo del otro eje en
el resultado de una manera ordenada, es decir, desde el primer DataFrame y
luego desde el segundo DataFrame.
El resultado de una concatenación siempre contiene la unión del número de
elementos en ambos objetos a lo largo del eje específico. Esto es diferente
de una fusión o unión que podría resultar en que el número resultante de
ítems no sea necesariamente equivalente a la unión del número de ítems en
los objetos DataFrame de origen.
La parte difícil de la concatenación es cómo los Pandas tratan con los objetos
a lo largo del otro eje durante la concatenación. El conjunto de valores, ya
sean filas al concatenar a lo largo de las columnas o columnas al concatenar
a lo largo de filas, se define usando álgebra relacional en los valores del índice
de ese eje.

Yessenia Portal Machuca 104 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Por ejemplo:
In [4]:
msftA01 = msft[’2019-01’][[’Adj Close’]]
msftA02 = msft[’2019-02’][[’Adj Close’]]
msftA01[:3]

Out[4]:

Date Adj Close

2019-01-03 24.42
2019-01-04 25.00
2019-01-05 25.25

In [5]:
msftA02[:3]

Out[5]:
Date Adj Close
2019-02-01 27.27
2019-02-02 27.32
2019-02-03 27.59

Para combinar ambos conjuntos de datos en un solo DataFrame, se realiza

una concatenación, usando la función .concat().
In [6]:
pd.concat([msftA01.head(3), msftA02.head(3)])

Out[6]:

Date Adj Close

2019-01-03 24.42
2019-01-04 25.00
2019-01-05 25.25
2019-02-01 27.27
2019-02-02 27.32
2019-02-03 27.59

El siguiente ejemplo concatena los primeros cinco valores de cierre ajustados

en enero tanto para MSFT como para AAPL. Éstos tienen etiquetas de índice
idénticas y dan como resultado etiquetas de índice duplicadas en el nuevo
DataFrame. Durante una concatenación a lo largo del eje de la fila, los Pandas
no alinearán las etiquetas de índice. Se copiarán y esto puede crear etiquetas
de índice duplicadas e idénticas:

Yessenia Portal Machuca 105 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

In [7]:
aaplA01 = aapl[’2019-01’][[’Adj Close’]]
withDups = pd.concat([msftA01[:3], aaplA01[:3])
withDups

Out[7]:

Date Adj Close

2019-01-03 24.42
2019-01-04 25.00
2019-01-05 25.25
2019-01-03 55.41
2019-01-04 55.71
2019-01-05 56.33

Se utiliza el argumento keys de la función .concat(), para añadirán un

nivel adicional al índice (creando un MultiIndex), que luego se puede utilizar
para identificar el DataFrame de origen. Por ejemplo:
In [8]:
closes = pd.concat([msftA01[:3], aaplA01[:3]],keys=[’MSFT’, ’AAPL’])
closes

Out[8]:
Date Adj Close
MSFT 2019-01-03 24.42
2019-01-04 25.00
2019-01-05 25.25
AAPL 2019-01-03 55.41
2019-01-04 55.71
2019-01-05 56.33

Utilizando este nuevo MultiIndex, es posible extraer los valores de cualquiera

de las acciones de este nuevo DataFrame utilizando únicamente las etiquetas
de índice. Por ejemplo:
In [9]:
closes.ix[’MSFT’][:3]

Out[9]:

Date Adj Close

2019-01-03 24.42
2019-01-04 25.00
2019-01-05 25.25

La concatenación a lo largo del eje de la fila también se puede realizar

utilizando objetos DataFrame con múltiples columnas. De igual forma si
no se utiliza el argumento keys, se tendrán filas duplicadas.

Yessenia Portal Machuca 106 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

In [10]:
msftAV = msft[[’Adj Close’, ’Volume’]]
aaplAV = msft[[’Adj Close’, ’Volume’]]
pd.concat([msftAV, aaplAV])

Out[10]:

Date Adj Close Volume

2019-01-03 24.42 64731500
2019-01-04 25.00 80516100
2019-01-05 25.25 56081400
2019-01-06 25.64 99455500
... ... ...
2019-12-24 70.72 43938300
2019-12-26 69.74 75609100
2019-12-27 70.02 113780100
2019-12-28 69.28 88569600
[498 rows x 2 columns]

Los objetos DataFrame de una concatenación pueden tener distintas colum-

nas. Por ejemplo:
In [11]:
aaplA = aapl[[’Adj Close’]]
pd.concat([msftAV, aaplA])

Out[11]:
Date Adj Close Volume
2019-01-03 24.42 64731500
2019-01-04 25.00 80516100
2019-01-05 25.25 56081400
2019-01-06 25.64 99455500
... ... ...
2019-12-24 70.72 NaN
2019-12-26 69.74 NaN
2019-12-27 70.02 NaN
2019-12-28 69.28 NaN
[498 rows x 2 columns]

Dado que las filas que se originan desde el DataFrame aaplA no tienen la
columna Volumen, los Pandas insertan NaN en la columna de Volumen para
esas filas.
El conjunto de columnas que resulta de una concatenación a lo largo del eje
de la fila es el resultado del álgebra relacional a través de los nombres de las
columnas. En este escenario por defecto, la columna resultante es la unión
de los nombres de las columnas de cada DataFrame. Esto se puede cambiar
a una intersección utilizando el parámetro de join. Por ejemplo:

Yessenia Portal Machuca 107 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

In [12]:
pd.concat([msftAV, aaplA], join=’inner’)

Out[12]:
Date Adj Close
2019-01-03 24.42
2019-01-04 25.00
2019-01-05 25.25
2019-01-06 25.64
... ...
2019-12-24 70.72
2019-12-26 69.74
2019-12-27 70.02
2019-12-28 69.28
[498 rows x 1 columns]

Para realizar concatenación de columnas se puede especificar el eje, usan-

do axis=1.
In [13]:
msftA = msft[[’Adj Close’]]
closes = pd.concat([msftA, aaplA], axis=1)
closes[:3]

Out[13]:

Date Adj Close Adj Close

2019-01-03 24.42 55.41
2019-01-04 25.00 55.71
2019-01-05 25.25 56.33

También es posible concatenar con múltiples columnas donde los objetos

DataFrame no tienen el mismo conjunto de etiquetas de índice. Por ejemplo:
In [14]:
pd.concat([msftAV[:5], aaplAV[:3]], axis=1,keys=[’MSFT’, ’AAPL’])

Out[14]:
MSFT AAPL
Date Adj Close Volume Adj Close Volume
2019-01-03 24.42 64731500 55.41 75555200
2019-01-04 25.00 80516100 55.71 65005500
2019-01-05 25.25 56081400 56.33 67817400
2019-01-06 25.64 99455500 NaN NaN
2019-01-09 25.31 59706800 NaN NaN

Esto da como resultado nombres de columnas duplicados, por lo que se utiliza

el parámetro keys para crear MultiIndex para las columnas. Cuando se tiene
etiquetas de índice de filas que no se encuentran en, Pandas llena las filas
con NaN.

Yessenia Portal Machuca 108 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Al igual que con la concatenación a lo largo del eje de la fila, el tipo de

unión realizada por pd.concat() se puede cambiar utilizando el parámetro
de join. El siguiente comando realiza una unión interna en lugar de una
externa, lo que resulta en la intersección de las etiquetas de índice de fila:
In [15]:
pd.concat([msftA[:5], aaplA[:3]], axis=1,
join=’inner’, keys=[’MSFT’, ’AAPL’])

Out[15]:
Date Adj Close Adj Close
2019-01-03 24.42 55.41
2019-01-04 25.00 55.71
2019-01-05 25.25 56.33

El DataFrame resultante sólo tiene tres filas porque esas etiquetas de índice
eran las únicas comunes en los dos objetos DataFrame concatenados.
Si desea ignorar índices en el resultado de pd.concat(), puede utilizar el
parámetro ignore_index=True, que no considerará el índice y creará un
índice entero basado en cero por defecto, como se muestra aquí:
In [16]:
pd.concat([msftA[:3], aaplA[:3]], ignore_index=True)

Out[16]:
Adj Close
0 24.42
1 25.00
2 25.25
3 55.41
4 55.71
5 56.33

Yessenia Portal Machuca 109 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

2. Fusión de objetos DataFrame

La combinación de objetos Pandas está permitida mediante operaciones de

unión de base de datos relacional, mediante la función pd.merge().
La fusión en Pandas difiere de la concatenación porque la función pd.merge()
combina datos basados en los valores de los datos en una o más co-
lumnas en lugar de usar los valores de la etiqueta de índice a lo largo de un
eje específico.
El proceso por default que utiliza pd.merge() es identificar primero las co-
lumnas cuyos datos serán usados en la fusión, y luego realizar una unión
interna basada en esa información. Las columnas utilizadas en el empalme se
seleccionan, por defecto, como las de ambos objetos DataFrame con nombres
comunes.
Por ejemplo:
In [17]:
msftAR = msftA.reset_index()
msftVR = msft[[’Volume’]].reset_index()
msftAR[:3]

Out[17]:
Date Adj Close
0 2019-01-03 24.42
1 2019-01-04 25.00
2 2019-01-05 25.25

In [18]: msftVR[:3]

Out[18]:
Date Volume
0 2019-01-03 64731500
1 2019-01-04 80516100
2 2019-01-05 56081400

En lugar de usar Fecha como índice, éstos tienen Fecha como columna para
que se pueda utilizar en la fusión. Nuestro objetivo es crear un DataFrame
que contenga una columna Date y las columnas AdjClose y Volume. Esto se
puede lograr con el siguiente código.
In [19]:
msftCVR = pd.merge(msftAR, msftVR)
msftCVR[:5]

Out[19]:
Date Adj Close Volume
0 2019-01-03 24.42 64731500
1 2019-01-04 25.00 80516100
2 2019-01-05 25.25 56081400
3 2019-01-06 25.64 99455500
4 2019-01-09 25.31 59706800

Yessenia Portal Machuca 110 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

La columna en común es Date; por lo tanto, Pandas realizan una unión

interna sobre los valores de esa columna en ambos objetos DataFrame. Una
vez calculado ese conjunto, Pandas copia en los valores apropiados para cada
fila de ambos objetos DataFrame.
Los tipos de uniones soportados por pd.merge() son similares a los diferentes
tipos de uniones soportadas en bases de datos relacionales. Estas son: left,
right, outer e inner.
Para los ejemplos se usará los siguientes DataFrame.
In [20]:
msftAR0_5 = msftAR[0:5]
msftAR0_5

Out[20]:
Date Adj Close
0 2019-01-03 24.42
1 2019-01-04 25.00
2 2019-01-05 25.25
3 2019-01-06 25.64
2019-01-09 25.31

In [21]:
msftVR2_4 = msftVR[2:4]
msftVR2_4

Out[21]:
Date Volume
2 2019-01-05 56081400
3 2019-01-06 99455500

Unión interna (inner): ya que sólo hay dos filas con fechas coincidentes,
el resultado sólo tiene dos filas y fusiona los objetos DataFrame donde los
valores de Fecha son comunes.
In [22]:
pd.merge(msftAR0_5, msftVR2_4)

Out[22]:
Date Adj Close Volume
0 2019-01-05 25.25 56081400
1 2019-01-06 25.64 99455500

Yessenia Portal Machuca 111 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Esto puede cambiarse por una unión externa con how=’outer’. Se devuel-
ven todas las filas del DataFrame externo (msftAR0_5), y los valores que
no se encuentran en el DataFrame interno (msftVR2_4) se sustituyen por
NaN:
In [23]:
pd.merge(msftAR0_5, msftVR2_4, how=’outer’)

Out[23]:
Date Adj Close Volume
0 2019-01-03 24.42 NaN
1 2019-01-04 25.00 NaN
2 2019-01-05 25.25 56081400
3 2019-01-06 25.64 99455500
4 2019-01-09 25.31 NaN

3. Pivot
Los datos financieros se almacenan a menudo en un formato en el que los
datos no están normalizados y, por lo tanto, tienen valores repetidos en mu-
chas columnas o valores que lógicamente deberían existir en otras tablas. Un
ejemplo de esto sería el siguiente, donde los precios históricos para múlti-
ples acciones se representan en un único DataFrame utilizando una columna
Symbol. El siguiente código crea este esquema.
In [24]:
msft.insert(0, ’Symbol’, ’MSFT’)
aapl.insert(0, ’Symbol’, ’AAPL’)
combined = pd.concat([msft, aapl]).sort_index()
s4p = combined.reset_index();
s4p[:5]

Out[24]:
Date Symbol Open High Low Close Volume Adj Close
0 2019-01-03 MSFT 26.55 26.96 26.39 26.77 64731500 24.42
1 2019-01-03 AAPL 409.40 412.50 409.00 411.23 75555200 55.41
2 2019-01-04 MSFT 26.82 27.47 26.78 27.40 80516100 25.00
3 2019-01-04 AAPL 410.00 414.68 409.28 413.44 65005500 55.71
4 2019-01-05 MSFT 27.38 27.73 27.29 27.68 56081400 25.25

Si se requiere extraer un nuevo DataFrame indexado por fecha y con columnas

que representen el valor de AdjClose para todos los valores listados en la
columna Símbolo. Esto se puede realizar utilizando la función .pivot().
In [25]:
closes = s4p.pivot(index=’Date’, columns=’Symbol’,
values=’Adj Close’)
closes[:3]

Out[25]:
Date AAPL MSFT
2019-01-03 55.41 24.42
2019-01-04 55.71 25.00
2019-01-05 56.33 25.25

Yessenia Portal Machuca 112 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Esta función toma todos los valores distintos de la columna Símbolo, los
gira en columnas en el nuevo DataFrame, y luego incluye los valores en esas
columnas desde el valor AdjClose para el símbolo específico del DataFrame
original.

4. Apilado (stack) y desapilado (unstack)

Las funciones similares en funcionamiento a la función pivote son .stack()

y .unstack().
La función .stack() desplaza las etiquetas de las columnas a otro nivel del
índice. Por ejemplo:
In [26]:
stackedCloses = closes.stack()
stackedCloses

Out[26]:
Date Symbol
2019-01-03 AAPL 55.41
MSFT 24.42
2019-01-04 AAPL 55.71
MSFT 25.00
...
2019-12-27 AAPL 70.02
MSFT 25.29
2019-12-28 AAPL 69.28
MSFT 24.91
dtype: float64

Esto ha creado un nuevo índice con un nivel adicional llamado Símbolo. Cada
fila es entonces indexada por Fecha y Símbolo, y para cada nivel único de
Fecha y Símbolo, Pandas ha insertado el valor de AdjClose apropiado.
El resultado de esto permite la búsqueda eficiente de cualquier valor de
AdjClose utilizando el índice. Por ejemplo
In [27]:
stackedCloses.ix[’2019-01-03’, ’AAPL’]

Out[27]:
55.41

Usando un MultiIndex, también es posible buscar valores para una fecha

específica:
In [28]:
stackedCloses.ix[’2019-01-03’]

Out[28]:
Symbol
AAPL 55.41
MSFT 24.42
dtype: float64

Yessenia Portal Machuca 113 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Para un Símbolo específico, el código es:

In [29]:
stackedCloses.ix[:, ’MSFT’]

Out[29]:
Date
2019-01-03 24.42
2019-01-04 25.00
2019-01-05 25.25
2019-01-06 25.64
...
2019-12-24 25.38
2019-12-26 25.20
2019-12-27 25.29
2019-12-28 24.91
dtype: float64

La función.unstack() realiza la función opuesta; es decir, hace pivotar un

nivel de un índice en una columna de un nuevo DataFrame. El siguiente
comando desactiva el último nivel del MultiIndex y resulta en un DataFrame
equivalente al original.
In [30]:
unstackedCloses = stackedCloses.unstack()
unstackedCloses[:3]

Out[30]:

Date AAPL MSFT

2019-01-03 55.41 24.42
2019-01-04 55.71 25.00
2019-01-05 56.33 25.25

5. Melting

Melting es el proceso de transformar un DataFrame en un formato en el que

cada fila representa una combinación única de variables de id-variable.
El siguiente código muestra el proceso melting del DataFrame s4p en una
combinación id-variable que consiste en las columnas Fecha y Símbolo
como ID y las otras columnas son asignada a la columna variable.
In [31]:
melted = pd.melt(s4p, id_vars=[’Date’, ’Symbol’])
melted[:5]

Out[31]:
Date Symbol variable value
0 2019-01-03 MSFT Open 26.55
1 2019-01-03 AAPL Open 409.40
2 2019-01-04 MSFT Open 26.82
3 2019-01-04 AAPL Open 410.00
4 2019-01-05 MSFT Open 27.38

Yessenia Portal Machuca 114 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Durante el proceso melting, las columnas especificadas por el parámetro

id_vars permanecen como columnas (en este caso Fecha y Símbolo). Todas
las demás columnas tienen sus nombres asignados a los valores de la columna
de variable.
Esta organización de datos es útil para seleccionar información basados en
una variable ID específica. Por ejemplo.
In [32]:
melted[(melted.Date==’2019-01-03’) & (melted.Symbol==’MSFT’)]

Out[32]:
Date Symbol variable value
0 2019-01-03 MSFT Open 26.55
498 2019-01-03 MSFT High 26.96
996 2019-01-03 MSFT Low 26.39
1494 2019-01-03 MSFT Close 26.77
1992 2019-01-03 MSFT Volume 64731500.00
2490 2019-01-03 MSFT Adj Close 24.42

13.5.2. Agrupación y agregación

Los datos de los Pandas pueden dividirse fácilmente en grupos y luego resumirse
utilizando diversos cálculos estadísticos y cuantitativos. Este proceso en la nomen-
clatura de los Pandas se conoce a menudo como el patrón de combinación de
aplicación dividida.

1. Dividir

Los objetos en Pandas se dividen en grupos usando el método .groupby().

Previamente reorganizamos los datos del DataFrame s4g.
In [33]:
s4g = combined[[’Symbol’, ’AdjClose’]].reset_index()
s4g.insert(1, ’Year’, pd.DatetimeIndex(s4g[’Date’]).year)
s4g.insert(2, ’Month[:5]’,pd.DatetimeIndex(s4g[’Date’]).month)

s4g[:5]

Out[33]:
Date Year Month Symbol Adj Close
0 2019-01-03 2019 1 MSFT 24.42
1 2019-01-03 2019 1 AAPL 55.41
2 2019-01-04 2019 1 MSFT 25.00
3 2019-01-04 2019 1 AAPL 55.71
4 2019-01-05 2019 1 MSFT 25.25

Estos datos difieren de los anteriores, ya que sólo se utiliza el valor de AdjClose
y la columna Date se divide en otras dos columnas, Year y Month. Esta
división de la fecha se hace para poder proporcionar la capacidad de agrupar
los datos por Mes y Año para cada variable de Símbolo.

Yessenia Portal Machuca 115 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Estos datos consisten en cuatro variables categóricas y una variable continua,

AdjC Close. En Pandas, es posible agrupar por cualquier variable categórica
indicando su nombre en la función .groupby(). Por ejemplo:
In [34]:
s4g.groupby(’Symbol’)

Out[34]:
<Pandas.core.groupby.DataFrameGroupBy object at 0x7ffaeeb49a10>

El resultado de llamar a .groupby() en un DataFrame no son los datos

agrupados actuales sino un objeto DataFrame GroupBy. La agrupación aún
no se ha realizado, ya que se trata de un proceso de agrupación diferido en
los Pandas.
Este resultado de .groupby() es una subclase de un objeto GroupBy y es
una descripción provisional de la agrupación que se va a realizar. Esto permite
a los Pandas validar en primer lugar que la descripción de agrupación que se
le ha proporcionado es válida en relación con los datos antes de que se inicie
el procesamiento.
Hay varias propiedades útiles en un objeto GroupBy. La propiedad .groups
devolverá un diccionario Python cuyas claves representan el nombre de cada
grupo (si se especifican varias columnas, es una tupla), y los valores son
una matriz de las etiquetas de índice contenidas dentro de cada grupo. Por
ejemplo:
In [35]:
grouped = s4g.groupby(’Symbol’)
type(grouped.groups)

Out[35]:
dict

In [36]:
grouped.groups

Out[36]:
{u’AAPL’: [1, 3, 5, 7, 9, 11, 13, 14, 16, 18, 20, 23, 25, 27, 29,
30, 33, 34, 37, 38, 41, 43, 45, 46, 48, 50, 53, 54, 56, 58, 61,
63, 64, 67, 69, 71, 72, 75, 77, 79, 81, 82, 84, 89, 91, 92, 94,
...
452, 455, 456, 458, 460, 463, 464, 466, 468, 471, 472, 474, 476,
478, 480, 482, 484, 487, 488, 490, 492, 494, 497]
’MSFT’: [0, 2, 4, 6, 10, 12, 15, 17, 19, 21, 22, 24, 26, 28, 31, 32,
...
477, 479, 481, 483, 485, 486, 489, 491, 493, 495, 496]}

Yessenia Portal Machuca 116 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

La función Python len() puede usarse para devolver el número de grupos

que resultarán de la agrupación. También puede usar la propiedad .ngroups:
In [37]:
len(grouped), grouped.ngroups

Out[37]:
(2, 2)

La división no se realiza hasta que se realiza algún tipo de acción sobre el

objeto GroupBy. Sin embargo, es posible iterar sobre varias propiedades del
objeto para ver cómo se agruparán los datos (lo que obliga a agruparlos).
In [38]:
def print_groups (groupobject):
for name, group in groupobject:
print (name)
print (group.head())

In [39]:
print_groups(grouped)

Out[39]:
AAPL
Date Year Month Symbol Adj Close
1 2019-01-03 2019 1 AAPL 55.41
3 2019-01-04 2019 1 AAPL 55.71
5 2019-01-05 2019 1 AAPL 56.33
7 2019-01-06 2019 1 AAPL 56.92
9 2019-01-09 2019 1 AAPL 56.83
MSFT
Date Year Month Symbol Adj Close
0 2019-01-03 2019 1 MSFT 24.42
2 2019-01-04 2019 1 MSFT 25.00
4 2019-01-05 2019 1 MSFT 25.25
6 2019-01-06 2019 1 MSFT 25.64
8 2019-01-09 2019 1 MSFT 25.31

Se puede crear, para cada valor distinto en la columna Símbolo del DataFrame
original, un grupo que consiste en un DataFrame. Luego copia las columnas
y los datos no agrupados en cada uno de esos objetos DataFrame y luego
utiliza el comando de las columnas especificadas como nombre de grupo.
La función.size() del objeto da un buen resumen del tamaño de todos los
grupos:
In [40]:
grouped.size()

Out[40]:
Symbol
AAPL 249
MSFT 249
dtype: int64

Yessenia Portal Machuca 117 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Si desea los datos de los elementos de un grupo determinado, puede utilizar

la propiedad .get_group(). Por ejemplo: recuperar el grupo MSFT.
In [41]:
grouped.get_group(’MSFT’)

Out[41]:
Date Year Month Symbol Adj Close
0 2019-01-03 2019 1 MSFT 24.42
2 2019-01-04 2019 1 MSFT 25.00
4 2019-01-05 2019 1 MSFT 25.25
6 2019-01-06 2019 1 MSFT 25.64
.. ... ... ... ... ...
491 2019-12-24 2019 12 MSFT 25.38
493 2019-12-26 2019 12 MSFT 25.20
495 2019-12-27 2019 12 MSFT 25.29
496 2019-12-28 2019 12 MSFT 24.91
[249 rows x 5 columns]

El agrupamiento se puede realizar en varias columnas pasando una lista de

nombres de columnas. El siguiente comando agrupa los datos por las variables
Símbolo, Año y Mes:
In [42]:
mcg = s4g.groupby([’Symbol’, ’Year’, ’Month’])
print_groups(mcg)

Out[42]:
Date Year Month Symbol Adj Close
1 2019-01-03 2019 1 AAPL 55.41
3 2019-01-04 2019 1 AAPL 55.71
5 2019-01-05 2019 1 AAPL 56.33
7 2019-01-06 2019 1 AAPL 56.92
9 2019-01-09 2019 1 AAPL 56.83

Date Year Month Symbol Adj Close

41 2019-02-01 2019 2 AAPL 61.47
43 2019-02-02 2019 2 AAPL 61.33
45 2019-02-03 2019 2 AAPL 61.94
46 2019-02-06 2019 2 AAPL 62.52
48 2019-02-07 2019 2 AAPL 63.18
(’AAPL’, 2019, 3)
...

Dado que se especificaron varias columnas, el nombre de cada grupo es ahora

una tupla con el valor de Símbolo, Año y Mes que representa al grupo.
Los ejemplos hasta ahora han utilizado un DataFrame sin ninguna indexación
específica. Este tipo de datos sería realmente muy adecuado para un índice
jerárquico, que puede ser utilizado directamente para agrupar los datos basa-
dos en la(s) etiqueta(s) del índice. Para demostrar esto, el siguiente comando
crea un nuevo DataFrame con un MultiIndex que consiste en las columnas
Símbolo, Año y Mes originales.

Yessenia Portal Machuca 118 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

In [43]:
mi = s4g.set_index([’Symbol’, ’Year’, ’Month’])
mi

Out[43]:

Symbol Year Month Date Adj Close

MSFT 2019 1 2019-01-03 24.42
AAPL 2019 1 2019-01-03 55.41
MSFT 2019 1 2019-01-04 25.00
AAPL 2019 1 2019-01-04 55.71
... ... ...
12 2019-12-27 70.02
MSFT 2019 12 2019-12-27 25.29
12 2019-12-28 24.91
AAPL 2019 12 2019-12-28 69.28
[498 rows x 2 columns]

Ahora se puede realizar la agrupación utilizando los niveles del índice jerár-
quico. Los siguientes grupos por el nivel de índice 0.
In [44]:
mig_l1 = mi.groupby(level=0)
print_groups(mig_l1)

Out[44]:
Symbol Year Month Date Adj Close
AAPL 2019 1 2019-01-03 55.41
1 2019-01-04 55.71
1 2019-01-05 56.33
1 2019-01-06 56.92
1 2019-01-09 56.83

Symbol Year Month Date Adj Close

MSFT 2019 1 2019-01-03 24.42
1 2019-01-04 25.00
1 2019-01-05 25.25
1 2019-01-06 25.64
1 2019-01-09 25.31

Yessenia Portal Machuca 119 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

La agrupación por múltiples niveles puede realizarse indicando múltiples ni-

veles a .groupby(). Además, si el MultiIndex tiene nombres especificados,
entonces esos nombres pueden ser usados en lugar de los enteros para los
niveles. Por ejemplo:
In [45]:
mig_l12 = mi.groupby(level=[’Symbol’, ’Year’, ’Month’])
print_groups(mig_l12)

Out[45]:
Symbol Year Month Date Adj Close
AAPL 2019 1 2019-01-03 55.41
1 2019-01-04 55.71
1 2019-01-05 56.33
1 2019-01-06 56.92
1 2019-01-09 56.83
...

Symbol Year Month Date Adj Close

MSFT 2019 12 2019-12-03 24.79
12 2019-12-04 24.74
12 2019-12-05 25.02
12 2019-12-06 25.07
12 2019-12-07 24.82

2. Agregar

La agregación se realiza usando la función .aggregate(), o en resumen

.agg(), del objeto GroupBy. Por ejemplo:
In [46]:
mig_l12.agg(np.mean)

Out[46]:

Symbol Year Month Adj Close

AAPL 2019 1 57.75
2 67.05
3 77.82
4 81.66
... ...
MSFT 2019 9 28.64
10 27.04
11 26.00
12 25.31
[24 rows x 1 columns]

Yessenia Portal Machuca 120 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

El resultado de la agregación tendrá un índice idéntico al de los datos origina-

les. Si no desea que esto suceda, puede utilizar la opción as_index=False
de .groupby() para especificar que no se duplique la estructura del índice.
In [47]:
s4g.groupby([’Symbol’, ’Year’, ’Month’],
as_index=False).agg(np.mean)[:5]

Out[47]:

Symbol Year Month Adj Close

0 AAPL 2019 1 57.75
1 AAPL 2019 2 67.05
2 AAPL 2019 3 77.82
3 AAPL 2019 4 81.66
4 AAPL 2019 5 76.09

Es posible aplicar múltiples funciones de agregación a cada grupo en un solo

bloque de código de .agg() indicando una lista. Por ejemplo:
In [48]:
mig_l12.agg([np.mean, np.std])

Out[48]:
Symbol Year Month mean std
AAPL 2019 1 57.75 1.80
2 67.05 3.57
3 77.82 4.16
4 81.66 3.06
... ... ...
MSFT 2019 9 28.64 0.43
10 27.04 0.67
11 26.00 1.00
12 25.31 0.36
[24 rows x 2 columns]

Yessenia Portal Machuca 121 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

14. Matplotlib
14.1. Introducción
Matplotlib es un paquete para realizar gráficos y visualizar los datos. La arquitectura
de matplotlib está estructurada en tres capas, que son colocadas en tres niveles diferentes.
La comunicación es unidireccional, es decir, cada capa puede comunicarse con la capa
subyacente.

Backend Layer: la capa que funciona en el nivel más bajo es la capa de fondo.
Esta capa contiene las API matplotlib y un conjunto de clases que juegan el rol
de implementación de los elementos gráficos en un nivel bajo.
Artist Layer: en esta capa se tiene a todos los elementos que conforman un
gráfico, como el título, etiquetas de ejes, marcadores, etc. Cada elemento de un
gráfico corresponde a esta capa artística.

Scripting Layer (pyplot): para fines de cálculo, y en particular para el análisis

y visualización de datos, la capa de interfaz llamada pyplot es la mejor. Estas
funciones proveen a los programadores de Python capacidades similares a las de
MATLAB.

Pylab y Pyplot.
Pylab es un módulo que se instala junto con matplotlib, mientras que pyplot es
un módulo interno de matplotlib. Pylab combina la funcionalidad de pyplot con las
capacidades de NumPy y, por lo tanto, no necesita importar NumPy por separado. El
paquete pyplot proporciona la interfaz clásica de Python, tiene su propio espacio de
nombres y requiere la importación de NumPy por separado.

Yessenia Portal Machuca 122 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

14.2. Pyplot
El módulo pyplot es un conjunto de funciones que le permiten utilizar matplotlib de
forma muy parecida a MATLAB.
Se iniciará con un gráfico sencillo, importando el módulo pyplot, que en general
se renombra como plt. Por lo tanto, puede simplemente pasar los valores que desea
representar como una secuencia de números enteros y estos se asocian a la secuencia
natural de valores del eje x: 0,1,2,3.... Ver el siguiente ejemplo:

In [1]: import matplotlib.pyplot as plt

In [2]: plt.plot([1,2,3,4])
In [3]: plt.show()

Finalmente, se utiliza la función show(), para mostrar una ventana de gráfico, repre-
sentado éste dentro de ella; esta ventana se caracteriza por una barra de herramientas,
en la parte superior con un conjunto de botones, que se describen a continuación:

Icono Descripción

Restablece la lista original

Va a la vista anterior / siguiente
Pantalla completa
Zoom rectangular
Configuración de subgráficos
Guardar Figura
Editar los ejes

Yessenia Portal Machuca 123 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Generalmente un gráfico representa pares de valores (x,y), por lo que para definir
un gráfico correctamente, debe definir dos matrices: la primera que contenga los valores
en el eje x y la segunda que contenga los valores en el eje y. En el gráfico generado, el
eje x tendrá valores de 0 a (n-1) y el eje y tendrá los valores de la lista dada.
Las propiedades del gráfico son:

El tamaño de los ejes se ajusta perfectamente al rango de los datos de entrada.

Se dibuja el trazo que conecta los puntos

Se puede incluir un título, etiquetas de ejes, leyendas, etc.

Los objetos que forman un gráfico tienen muchos atributos que los caracterizan. Todos
los atributos son valores predeterminados, pero se pueden configurar mediante el uso de
argumentos, a menudo referidos como kwargs. Estas palabras clave se definen como
argumentos a las funciones. Ejemplo de un gráfico lineal.

matplotlib.pyplot.plot(*args, **kwargs)
In [4]: plt.plot([1,2,4,2,1,0,1,2,1,4],linewidth=2.0)

14.3. Multiples figuras

Matplotlib le permite manejar múltiples figuras simultáneamente, y dentro de un
mismo espacio de tiempo, cada figura ofrece la posibilidad de ver diferentes gráficos
definidos como subgráficos. Por lo tanto, al usar pyplot, siempre se debe tener en cuenta
el concepto de la figura actual y los ejes actuales. La función subplot(), además de
subdividir la figura en diferentes áreas de dibujo, se usa para enfocar los comandos en
un subplot específico.
El argumento declarado en la función subplot() establece el modo de subdivisión
y determina cuál es el subgráfico actual. Este subgráfico será la única área que se verá
afectada por los comandos. El argumento de la función subplot() es compuesto de
tres números enteros: el primer número define en cuántas partes se divide la figura
en forma vertical , el segundo número define en cuántas partes se divide en forma
horizontalmente, la tercera selecciona cuál es el subgráfico actual sobre la que se
puede ejecutar los comandos.

Yessenia Portal Machuca 124 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Ejemplo de subgráficos.
In [5]: t = np.arange(0,5,0.1)
y1 = np.sin(2*np.pi*t)
y2 = np.sin(2*np.pi*t)
In [6]: plt.subplot(211)
plt.plot(t,y1,’b-.’)
plt.subplot(212)
plt.plot(t,y2,’r--’)
Out[6]: [<matplotlib.lines.Line2D at 0xd47f518>]

Se puede hacer los mismo dividiendo la figura en dos subgráficos horizontales. La

sentencia y argumentos son los siguientes:
In [7]: t = np.arange(0.,1.,0.05)
y1 = np.sin(2*np.pi*t)
y2 = np.cos(2*np.pi*t)
In [8]: plt.subplot(121)
plt.plot(t,y1,’b-.’)
plt.subplot(122)
plt.plot(t,y2,’r--’)
Out[8]: [<matplotlib.lines.Line2D at 0xed0c208>]

Yessenia Portal Machuca 125 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

14.4. Elementos del gráfico

Para que un gráfico sea más informativo, se requieren elementos adicionales para
enriquecerlo, a continuación se detallan los más útilizados.

14.4.1. Texto
Para incluir el título a un gráfico se utiliza la función title().

Para añadir las etiquetas de los ejes es posible mediante el uso de otras dos funcio-
nes específicas: xlabel() e ylabel(). Estas funciones toman como argumento
una cadena, que será el texto mostrado.

Ejemplo de gráfico con título y nombre de los ejes.

In [9]: plt.axis([0,5,0,20])
plt.title(’My first plot’)
plt.xlabel(’Counting’)
plt.ylabel(’Square values’)
plt.plot([1,2,3,4],[1,4,9,16],’ro’)
Out[9]: [<matplotlib.lines.Line2D at 0x990f3c8>]

Yessenia Portal Machuca 126 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

También es posible modificar el color de las etiquetas de los ejes, modificar el título
cambiando la fuente y aumentando el tamaño de los caracteres para acentuar el título
del gráfico, como se muestra a continuación:

In [10]: plt.axis([0,5,0,20])
plt.title(’My first plot’,fontsize=20,fontname=’Times New Roman’)
plt.xlabel(’Counting’,color=’gray’)
plt.ylabel(’Square values’,color=’gray’)
plt.plot([1,2,3,4],[1,4,9,16],’ro’)
Out[10]: [<matplotlib.lines.Line2D at 0x11f17470>]

Además, matplotlib no se limita a esto: pyplot le permite añadir texto a cualquier

posición dentro de un gráfico. Esta característica es realizada por la función llamada
text(). La sintaxis es la siguiente:

text(x,y,s, fontdict=None, **kwargs)

Los dos primeros argumentos son las coordenadas de la ubicación donde se desea
colocar el texto, s es la cadena de texto que se añadirá, y fontdict (opcional) es la
fuente que se desea utilizar. Finalmente, puede añadir las palabras clave que añaden
la etiqueta a cada punto del gráfico. Debido a que los dos primeros argumentos de la
función text() son las coordenadas del gráfico, se tiene que usar las coordenadas de
los cuatro puntos del gráfico desplazados ligeramente sobre el eje y.

Yessenia Portal Machuca 127 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Ejemplo de gráfico con etiquetas.

In [11]: plt.axis([0,5,0,20])
plt.title(’My first plot’,fontsize=20,fontname=’Times New Roman’)
plt.xlabel(’Counting’,color=’gray’)
plt.ylabel(’Square values’,color=’gray’)
plt.text(1,1.5,’First’)
plt.text(2,4.5,’Second’)
plt.text(3,9.5,’Third’)
plt.text(4,16.5,’Fourth’)
plt.plot([1,2,3,4],[1,4,9,16],’ro’)
Out[11]: [<matplotlib.lines.Line2D at 0x10f76898>]

Como se puede apreciar en la figura anterior, cada punto del gráfico tiene una eti-
queta. Además se puede incluir expresiones en LaTeX, por lo tanto permite insertar
expresiones matemáticas en el gráfico. Para ello, se puede añadir una expresión LaTeX
al texto entre dos caracteres $. Generalmente hay que preceder a la cadena que contiene
expresiones LaTeX con una r, que indica texto sin procesar, para evitar secuencias de
escape no intencionadas. Por lo tanto, a modo de ejemplo, se puede añadir la fórmula
que describe la tendencia seguida por el punto del gráfico del ejemplo anterior y ser
encerrado en un cuadro delimitador de color.
Ejemplo de gráfico con texto LaTeX.
In [12]: plt.axis([0,5,0,20])
plt.title(’My first plot’,fontsize=20,fontname=’Times New Roman’)
plt.xlabel(’Counting’,color=’gray’)
plt.ylabel(’Square values’,color=’gray’)
plt.text(1,1.5,’First’)
plt.text(2,4.5,’Second’)
plt.text(3,9.5,’Third’)
plt.text(4,16.5,’Fourth’)
plt.text(1.1,12,r’$y = x^2$’,fontsize=20,bbox={’facecolor’:’yellow’,
’alpha’:0.2})
plt.plot([1,2,3,4],[1,4,9,16],’ro’)
Out[12]: [<matplotlib.lines.Line2D at 0x13920860>]

Yessenia Portal Machuca 128 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

14.4.2. Cuadrícula
Otro elemento que puede agregar a una gráfica es una cuadrícula. A menudo, su
adición es necesaria para comprender mejor la posición que tiene cada punto en el
gráfico. Agregar una cuadrícula se puede hacer mediante a la función grid () con el
argumento True.
Ejemplo de gráfico con cuadrícula.
In [13]: plt.axis([0,5,0,20])
plt.title(’My first plot’,fontsize=20,fontname=’Times New Roman’)
plt.xlabel(’Counting’,color=’gray’)
plt.ylabel(’Square values’,color=’gray’)
plt.text(1,1.5,’First’)
plt.text(2,4.5,’Second’)
plt.text(3,9.5,’Third’)
plt.text(4,16.5,’Fourth’)
plt.text(1.1,12,r’$y = x^2$’,fontsize=20,
bbox={’facecolor’:’yellow’, ’alpha’:0.2})
plt.grid(True)
plt.plot([1,2,3,4],[1,4,9,16],’ro’)
Out[13]: [<matplotlib.lines.Line2D at 0x10f76898>]

Yessenia Portal Machuca 129 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

14.4.3. Leyenda
Otro componente muy importante que debe estar presente en cualquier gráfico es
la leyenda. pyplot también proporciona la función legend() para añadir una leyenda
al gráfico y una cadena que indique las palabras con las que desea que se muestren las
series.
Por ejemplo, se asigna el nombre de “First series” a los datos gráficados.
In [14]: plt.axis([0,5,0,20])
plt.title(’My first plot’,fontsize=20,fontname=’Times New Roman’)
plt.xlabel(’Counting’,color=’gray’)
plt.ylabel(’Square values’,color=’gray’)
plt.text(2,4.5,’Second’)
plt.text(3,9.5,’Third’)
plt.text(4,16.5,’Fourth’)
plt.text(1.1,12,’$y =x^2$’,fontsize=20,bbox={’facecolor’:’yellow’,
’alpha’:0.2})
plt.grid(True)
plt.plot([1,2,3,4],[1,4,9,16],’ro’)
plt.legend([’First series’])
Out[14]: <matplotlib.legend.Legend at 0x16377550>

Como se aprecia en la figura anterior, la leyenda se incluye en la esquina superior

derecha por defecto. Si se desea cambiar este comportamiento se debe añadir algunos
kwargs. La posición ocupada por la leyenda se establece asignando números del 0 al 10
al kwarg de bloqueo. Cada uno de estos números caracteriza una de las esquinas del
gráfico. Un valor de 1 es el valor por defecto, es decir, la esquina superior derecha. A
continuación la tabla de localización para configurar la posición de la leyenda.

Yessenia Portal Machuca 130 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Código Localización en cadena de texto

0 best
1 upper-right
2 upper-left
3 lower-right
4 lower-left
5 right
6 center-left
7 center-right
8 lower-center
9 upper-center
10 center

En el siguiente ejemplo, se gráfican varias series, cada una caracterizada por la función
plot() y el orden en que se definen corresponden al orden de las etiquetas de texto
definidas como argumento en la función legend ().

In [15]: import matplotlib.pyplot as plt

plt.axis([0,5,0,20])
plt.title(’My first plot’,fontsize=20,fontname=’Times New Roman’)
plt.xlabel(’Counting’,color=’gray’)
plt.ylabel(’Square values’,color=’gray’)
plt.text(1,1.5,’First’)
plt.text(2,4.5,’Second’)
plt.text(3,9.5,’Third’)
plt.text(4,16.5,’Fourth’)
plt.text(1.1,12,’$y = x^2$’,fontsize=20,
bbox={’facecolor’:’yellow’, ’alpha’:0.2})
plt.grid(True)
plt.plot([1,2,3,4],[1,4,9,16],’ro’)
plt.plot([1,2,3,4],[0.8,3.5,8,15],’g^’)
plt.plot([1,2,3,4],[0.5,2.5,4,12],’b*’)
plt.legend([’First series’,’Second series’,’Third series’],loc=2)
Out[15]: <matplotlib.legend.Legend at 0x1828d7b8>

Yessenia Portal Machuca 131 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

14.5. Tipos de gráficos

A continuación se describen y desarrollan ejemplos de distintos tipos de gráficos que
se pueden realizar con el paquete Matplotlib, comenzando desde los más comunes,
como gráficos lineales, gráficos de barras y gráficos circulares, hasta un discusión sobre
algunos que son más sofisticados y se usan comúnmente.

14.5.1. Gráficos de líneas

Entre todos los tipos de gráficos, el gráfico lineal es el más simple. Un gráfico de
líneas es una secuencia de puntos de datos conectados por una línea, cada punto de
datos consiste en un par de valores (x,y), que serán reportados en el gráfico de acuerdo
a la escala de valores de los dos ejes (x e y).
A modo de ejemplo, se realiza un gráfico para la siguiente función matemática ge-
nérica:

y = sin(3 ∗ x)/x

Por lo tanto, se crea dos Matrices numéricas.

Matriz que contiene los valores de x: para definir una secuencia de valores cre-
cientes se utilizará la función np.arange(), y dado que la función mátematica es
sinusoidal, se debe hacer referencia a valores que son múltiplos y submúltiplos del
pi griego (np.pi).

Matriz que contiene los valores de y: se puede obtener los valores de y, aplicando
la función np.sin() directamente a estos valores.
Finalmente, se realiza el gráfico con la función plot().
In [16]: import matplotlib.pyplot as plt
import numpy as np
x = np.arange(-2*np.pi,2*np.pi,0.01)
y = np.sin(3*x)/x
plt.plot(x,y)
Out[16]: [<matplotlib.lines.Line2D at 0x22404358>]

Yessenia Portal Machuca 132 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Como otro ejemplo, se puede ampliar el caso de la función mátematica, a la siguiente

ecuación:

y = sin(n ∗ x)/x

Ejemplo de gráfico multiseries, variando el parámetro n.

In [17]: import matplotlib.pyplot as plt
import numpy as np
x = np.arange(-2*np.pi,2*np.pi,0.01)
y = np.sin(3*x)/x
y2 = np.sin(2*x)/x
y3 = np.sin(3*x)/x
plt.plot(x,y)
plt.plot(x,y2)
plt.plot(x,y3)

En el siguiente gráfico, se aprecia que se asigna automáticamente un color diferente a

cada serie de datos. Todos los gráficos están representados en la misma escala; es decir,
los puntos de datos de cada serie se refieren al mismo eje x y al mismo eje y. Esto se
debe a que cada llamada de la función plot() tiene en cuenta las llamadas anteriores
a la misma función, por lo que el gráfico aplica los cambios manteniendo la memoria de
los comandos anteriores hasta que gráfico no se muestre.
Recuerde que para mostrar el gráfico, debe usar la función show().

Yessenia Portal Machuca 133 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

14.5.2. Gráficos de líneas con pandas

Ahora se detalla como aplicar el paquete matplotlib a los DataFrame de datos del
paquete de pandas. La visualización de los datos como un gráfico lineal es una operación
muy sencilla, simplemente se debe indicar los datos del DataFrame como argumento a
la función plot() para obtener un gráfico lineal multiserie.

Ejemplo de gráfico multiseries.

In [18]: import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
data = {’series1’:[1,3,4,3,5],
’series2’:[2,4,5,2,4],
’series3’:[3,2,3,1,3]}
df = pd.DataFrame(data)
x = np.arange(5)
plt.axis([0,5,0,7])
plt.plot(x,df)
plt.legend(data, loc=2)

Yessenia Portal Machuca 134 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

14.5.3. Histogramas
Un histograma consiste en rectángulos adyacentes en el eje x, divididos en intervalos
discretos llamados "bins", y con un área proporcional a la frecuencia de las ocurren-
cias. Para representar un histograma, pyplot proporciona una función especial llamada
hist(). Esta función gráfica tiene una característica que otras funciones no tienen. La
función hist(), además de dibujar el histograma, devuelve una tupla de valores que son
los resultados del cálculo del histograma. La función hist() puede realizar el cálculo
del histograma, es decir, es suficiente con proporcionar una serie de muestras de valores
como argumento y el número de ubicaciones en las que se debe dividir, y la función se
encargará de dividir el rango de muestras en muchos intervalos, y luego se calculará las
ocurrencias para cada "bins".
Ejemplo: Se genera un array de 100 valores aleatorios de 0 a 100 usando la función
aleatoria randint(), y se divide en 20 "bins". Si no se especifica los "bins", el valor
predeterminado es 10.

In [19]: import matplotlib.pyplot as plt

import numpy as np
pop = np.random.randint(0,100,100)
pop
Out[19]:
array([32, 14, 55, 33, 54, 85, 35, 50, 91, 54, 44, 74, 77, 6, 77, 74, 2,
54, 14, 30, 80, 70, 6, 37, 62, 68, 88, 4, 35, 97, 50, 85, 19, 90,
65, 86, 29, 99, 15, 48, 67, 96, 81, 34, 43, 41, 21, 79, 96, 56, 68,
49, 43, 93, 63, 26, 4, 21, 19, 64, 16, 47, 57, 5, 12, 28, 7, 75,
6, 33, 92, 44, 23, 11, 61, 40, 5, 91, 34, 58, 48, 75, 10, 39, 77,
70, 84, 95, 46, 81, 27, 6, 83, 9, 79, 39, 90, 77, 94, 29])
In [20]: n,bins,patches = plt.hist(pop,bins=20)

Yessenia Portal Machuca 135 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

14.5.4. Gráficos de barras

Otro tipo de gráfico muy común es el gráfico de barras. Es muy similar a un histo-
grama, pero en este caso el eje x no se utiliza para referenciar valores numéricos sino
categorías. La realización del gráfico de barras es muy simple con matplotlib, usando la
función bar().
Ejemplo de un gráfico de barras.
In [21]: import matplotlib.pyplot as plt
index = [0,1,2,3,4]
values = [5,7,3,4,6]
plt.bar(index,values)
Out[21]: <Container object of 5 artists>

En el gráfico anterior se aprecia que los índices están dibujados en el eje x, en la

ventana de diálogo inicio de cada barra. En realidad, debido a que cada barra corresponde
a una categoría, sería ser mejor si se especifican las categorías a través de la etiqueta de
verificación, definida por una lista de cadenas de texto con la función xticks().
In [22]: import numpy as np
index = np.arange(5)
values1 = [5,7,3,4,6]
plt.bar(index,values1)
plt.xticks(index+0.4,[’A’,’B’,’C’,’D’,’E’])

Yessenia Portal Machuca 136 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Se tienen muchas opciones para para refinar más el gráfico de barras. Cada uno
de estos detalles se configuran añadiendo un kwarg específico como argumento en la
función bar().
Por ejemplo, se puede añadir los valores de la desviación estándar de la barra a través
del yerr kwarg junto con una lista que contenga las desviaciones estándar. Este kwarg
suele combinarse con otro kwarg llamado error_kw, que, a su vez, acepta otros kwarg
especializados para representar barras de error. Dos kwargs muy específicos utilizados
en este caso son eColor, que especifica el color de las barras de error, y capsize, que
define el ancho de las líneas transversales que marcan los extremos de las barras de error.

Otro kwarg que puede utilizar es el alfa, que indica el grado de transparencia de la
barra de color, alfa es un valor que va de 0 a 1. Cuando este valor es 0, el objeto es
completamente transparente para hacerse gradualmente más significativo con el aumento
del valor, hasta llegar a 1. Como de costumbre, se recomienda el uso de una leyenda,
por lo que en este caso se debe utilizar el kwarg legend() para identificar la serie que
se está representando.
Ejemplo de un gráfico de barras con barras de error.
In [23]: import numpy as np
index = np.arange(5)
values1 = [5,7,3,4,6]
std1 = [0.8,1,0.4,0.9,1.3]
plt.title(’A Bar Chart’)
plt.bar(index,values1,yerr=std1,error_kw={’ecolor’:’0.1’,
’capsize’:6},alpha=0.7,label=’First’)
plt.xticks(index+0.4,[’A’,’B’,’C’,’D’,’E’])
plt.legend(loc=2)

Yessenia Portal Machuca 137 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

14.5.5. Gráficos de barras horizontales

También se tienen gráficos de barras orientados horizontalmente. Este modo es imple-
mentado por una función especial llamada barh(). Los argumentos y los kwargs válidos
para la función bar() siguen siendo los mismos para esta función. El único cambio que
hay que tener en cuenta es que los roles de los ejes están invertidos. Ahora, las categorías
se representan en el eje y, y los valores numéricos se muestran en el eje x.
Ejemplo de un gráfico de barras horizontal.
In [24]: import matplotlib.pyplot as plt
import numpy as np
index = np.arange(5)
values1 = [5,7,3,4,6]
std1 = [0.8,1,0.4,0.9,1.3]
plt.title(’A Horizontal Bar Chart’)
plt.barh(index,values1,xerr=std1,error_kw={’ecolor’:’0.1’,
’capsize’:6},alpha=0.7,label=’First’)
plt.yticks(index+0.4,[’A’,’B’,’C’,’D’,’E’])
plt.legend(loc=5)

Como gráficos de líneas, los gráficos de barras también se utilizan generalmente para
mostrar simultáneamente series más grandes de valores. Pero en este caso es necesario
hacer algunas aclaraciones sobre cómo estructurar un gráfico de barras multiserie. En
este caso, se tiene varias barras que deben compartir la misma categoría. Un enfoque
utilizado para superar este problema es dividir el espacio ocupado por un índice (por
conveniencia su ancho es 1) en tantas partes como las barras que comparten ese índice
y, que queremos mostrar. Además, es aconsejable añadir espacio, que servirá para separar
una categoría con respecto a la siguiente.

Yessenia Portal Machuca 138 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Ejemplo de gráfico de barras multiserie vertical.

In [25]: import matplotlib.pyplot as plt
import numpy as np
index = np.arange(5)
values1 = [5,7,3,4,6]
values2 = [6,6,4,5,7]
values3 = [5,6,5,4,6]
bw = 0.3
plt.axis([0,5,0,8])
plt.title(’A Multiseries Bar Chart’,fontsize=20)
plt.bar(index,values1,bw,color=’b’)
plt.bar(index+bw,values2,bw,color=’g’)
plt.bar(index+2*bw,values3,bw,color=’r’)
plt.xticks(index+1.5*bw,[’A’,’B’,’C’,’D’,’E’])

Con respecto al gráfico de barras multiserie horizontal, el código es muy similar, solo
se debe reemplazar la función bar() por la correspondiente función barh() y no olvidar
reemplazar la función xticks() por la función yticks(). Es necesario invertir el rango
de valores que cubren los ejes en la función axis().
Ejemplo de gráfico de barras multiserie horizontal.
In [26]: import matplotlib.pyplot as plt
import numpy as np
index = np.arange(5)
values1 = [5,7,3,4,6]
values2 = [6,6,4,5,7]
values3 = [5,6,5,4,6]
bw = 0.3
plt.axis([0,8,0,5])
plt.title(’A Multiseries Horizontal Bar Chart’,fontsize=20)
plt.barh(index,values1,bw,color=’b’)
plt.barh(index+bw,values2,bw,color=’g’)
plt.barh(index+2*bw,values3,bw,color=’r’)
plt.yticks(index+0.4,[’A’,’B’,’C’,’D’,’E’])

Yessenia Portal Machuca 139 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

14.5.6. Gráficos de barras multiseries con Dataframe de pandas

Para gráficar directamente los datos de un DataFrame se puede usar la función
plot() aplicada al objeto DataFrame y especificar dentro de un kwarg llamado kind,
el tipo de gráfico que se requiere representar.
Ejemplo de un gráfico de barras multiserie.
In [27]: import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
data = {’series1’:[1,3,4,3,5],
’series2’:[2,4,5,2,4],
’series3’:[3,2,3,1,3]}
df = pd.DataFrame(data)
df.plot(kind=’bar’)

Con respecto al gráfico de barras horizontal, se pueden aplicar las mismas reglas,
solo recuerde establecer barh() como el valor del tipo kwarg.

Yessenia Portal Machuca 140 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

14.5.7. Gráficos de barras apiladas de multiseries

Otra forma de representar un gráfico de barras multiserie es en la forma apilada,
en la que las barras se apilan una sobre la otra. Esto es especialmente útil cuando se
desea mostrar el valor total obtenido por la suma de todas las barras. Para transformar
un simple gráfico de barras multiserie en uno apilado, añada el kwarg bottom a cada
función bar(). Cada serie debe asignarse al kwarg bottom correspondiente. Al final
obtendrá el gráfico de barras apilado. Por ejemplo:

In [28]: import matplotlib.pyplot as plt

import numpy as np
series1 = np.array([3,4,5,3])
series2 = np.array([1,2,2,5])
series3 = np.array([2,3,3,4])
index = np.arange(4)
plt.axis([-0.5,3.5,0,15])
plt.title(’A Multiseries Stacked Bar Chart’)
plt.bar(index,series1,color=’r’)
plt.bar(index,series2,color=’b’,bottom=series1)
plt.bar(index,series3,color=’g’,bottom=(series2+series1))
plt.xticks(index+0.4,[’Jan18’,’Feb18’,’Mar18’,’Apr18’])

Yessenia Portal Machuca 141 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Para crear el gráfico de barras apilado horizontal equivalente, se debe reemplazar la

función bar() por la función barh(), teniendo en cuenta cambiar también los demás
parámetros. De hecho, la función xticks() debería ser reemplazada por la función
yticks(), ya que las etiquetas de las categorías ahora deben ser reportadas en el eje y.

Después de hacer todos estos cambios, obtendrá el gráfico de barras horizontal api-
lado como se muestra a continuación, como ejemplo:
In [29]: import matplotlib.pyplot as plt
import numpy as np
index = np.arange(4)
series1 = np.array([3,4,5,3])
series2 = np.array([1,2,2,5])
series3 = np.array([2,3,3,4])
plt.axis([0,15,-0.5,3.5])
plt.title(’A Multiseries Horizontal Stacked Bar Chart’)
plt.barh(index,series1,color=’r’)
plt.barh(index,series2,color=’g’,left=series1)
plt.barh(index,series3,color=’b’,left=(series1+series2))
plt.yticks(index+0.4,[’Jan18’,’Feb18’,’Mar18’,’Apr18’])

14.5.8. Gráficos de barras apilados con un Dataframe de pandas

Con respecto a los gráficos de barras apilados, es muy sencillo representar direc-
tamente los valores contenidos en un objeto DataFrame utilizando la función plot().
Sólo tiene que añadir como argumento el kwarg stacked configurado con el argumento
True.

Yessenia Portal Machuca 142 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Asi por ejemplo:

In [31]: import matplotlib.pyplot as plt
import pandas as pd
data = {’series1’:[1,3,4,3,5],
’series2’:[2,4,5,2,4],
’series3’:[3,2,3,1,3]}
df = pd.DataFrame(data)
df.plot(kind=’bar’, stacked=True)
Out[31]: <matplotlib.axes._subplots.AxesSubplot at 0xcda8f98>

14.5.9. Otras Representaciones de Gráficos de Barras

Otro tipo de representación muy útil es el gráfico de barras para la comparación, en
el que se comparan dos series de valores que comparten las mismas categorías colocando
las barras en direcciones opuestas a lo largo del eje y. Para ello, se debe tener los valores
y de una de las dos series de forma negativa.
Para colorear el color interior de las barras de una manera diferente se puede hacerlo
configurando los dos colores diferentes en el kwarg: facecolor. Además, ese puede
añadir el valor y con una etiqueta en la ventana de diálogo extremo de cada barra,
usando un bucle for en el que la función text().
Finalmente se puede ajustar la posición de la etiqueta con los kwargs denominados
ha y va, que controlan la alineación horizontal y vertical, respectivamente.

Yessenia Portal Machuca 143 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

A continuación se muestra un ejemplo.

In [32]: import matplotlib.pyplot as plt
x0 = np.arange(8)
y1 = np.array([1,3,4,6,4,3,2,1])
y2 = np.array([1,2,5,4,3,3,2,1])
plt.ylim(-7,7)
plt.bar(x0,y1,0.9,facecolor=’r’)
plt.bar(x0,-y2,0.9,facecolor=’b’)
plt.xticks(())
plt.grid(True)
for x, y in zip(x0, y1):
plt.text(x + 0.4, y + 0.05, ’ %d’ % y, ha=’center’, va= ’bottom’)

for x, y in zip(x0, y2):

plt.text(x + 0.4, -y - 0.05, ’ %d’ % y, ha=’center’, va= ’top’)

14.5.10. Gráficos de Pie

Una forma alternativa de mostrar datos es el gráfico circular, que se puede obtener
fácilmente usando la función pie(). Incluso para este tipo de función, se pasa como
argumento principal una lista que contiene los valores que se deben visualizar. La función
pie() será la que calcule inherentemente el porcentaje que ocupa cada valor.
También con este tipo de representación, es necesario definir algunas características
clave haciendo uso de los kwargs. Por ejemplo, si se desea definir la secuencia de los
colores, que se asignarán a la secuencia de valores de entrada de forma correspondiente,
debe utilizar kwarg: colors. Por lo tanto, debe asignar una lista de cadenas, cada una
de las cuales contiene el nombre del color deseado.
Otra característica importante es añadir etiquetas a cada parte del pie, para lo cual
debe utilizar las etiquetas kwarg a las que asignará una lista de cadenas que contengan
las etiquetas que se visualizarán en secuencia. Además, para dibujar el gráfico circular de
forma perfectamente esférica, hay que añadir la función axis() al final de la sentencia,
especificando la cadena igual como argumento.

Yessenia Portal Machuca 144 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Se tiene el siguiente ejemplo.

In [33]: import matplotlib.pyplot as plt
labels = [’Nokia’,’Samsung’,’Apple’,’Lumia’]
values = [10,30,45,15]
colors = [’yellow’,’green’,’red’,’blue’]
plt.pie(values,labels=labels,colors=colors)
plt.axis(’equal’)

Para añadir complejidad al gráfico circular, puede dibujarlo con una parte extraída del
pie. Para ello, existe un kwarg especial llamado explode. No es más que una secuencia
de valores de 0 o 1, donde 1 corresponde a la porción completamente extendida y 0
corresponde a las partes completas en el pie. También se puede ajustar el ángulo de
rotación de la figura añadiendo el kwarg: startangle, que toma un valor entero entre
0 y 360, que son los grados de rotación con precisión, donde 0 es el valor por defecto.
Ejemplo de gráfico pie con una parte de extraída.
In [34]: import matplotlib.pyplot as plt
labels = [’Nokia’,’Samsung’,’Apple’,’Lumia’]
values = [10,30,45,15]
colors = [’yellow’,’green’,’red’,’blue’]
explode = [0.3,0,0,0]
plt.title(’A Pie Chart’)
plt.pie(values,labels=labels,colors=colors,explode=explode,
startangle=180)
plt.axis(’equal’)

Yessenia Portal Machuca 145 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Además se puede utilizar el kwarg: autopct, que añade al centro de cada parte del
gráfico una etiqueta de texto que muestra el valor correspondiente. Finalmente, se puede
añadir una sombra el Kwarg: shadow configurandolo en True. Asi por ejemplo:
In [35]: import matplotlib.pyplot as plt
labels = [’Nokia’,’Samsung’,’Apple’,’Lumia’]
values = [10,30,45,15]
colors = [’yellow’,’green’,’red’,’blue’]
explode = [0.3,0,0,0]
plt.title(’A Pie Chart’)
plt.pie(values,labels=labels,colors=colors,explode=explode,
shadow=True,autopct=’ %1.1f % %’,startangle=180)
plt.axis(’equal’)

Yessenia Portal Machuca 146 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

14.5.11. Gráficos de tarta con un Dataframe de pandas

Para gráficar datos de un objeto DataFrame, en este caso, se puede representar sólo
una serie a la vez. Debe especificar el tipo de gráfico que desea representar a través del
kwarg: kind, en la función plot(), que en este caso es pie.
Por ejemplo:
In [36]: import matplotlib.pyplot as plt
import pandas as pd
data = {’series1’:[1,3,4,3,5],’series2’:[2,4,5,2,4],
’series3’:[3,2,3,1,3]}
df = pd.DataFrame(data)
df[’series1’].plot(kind=’pie’,figsize=(6,6))
Out[36]: <matplotlib.axes._subplots.AxesSubplot at 0xe1ba710>

14.5.12. Gráficos avanzados: Polares

Se tiene una gran variedad de gráficos alternativos avanzadas que se pueden pro-
gramar usando Matplotlib6 , sin embargo, a continuación se muestra solo un ejemplo de
gráficos Polares. Este tipo de gráfico se caracteriza por una serie de sectores que se ex-
tienden radialmente; cada una de estas áreas ocupan un cierto ángulo; de este modo, se
pueden visualizar dos valores diferentes asignándolos a los magnitudes que caracterizan
a este gráfico: la extensión del radio r y el ángulo θ ocupada por el sector. Estas son las
coordenadas (r,θ), un camino alternativo de representación de funciones en los ejes de
coordenadas.

Este es un gráfico que tiene características tanto del gráfico circular como del gráfico
de barras. De hecho, como el gráfico circular, el ángulo de cada sector da información
porcentual representada por esa categoría con respecto al total. En cuanto al gráfico de
barras, el gráfico radial es el valor numérico de esa categoría.
6
Para mayor detalle revisar:
https://matplotlib.org/tutorials/index.html
https://pypi.org/project/jupyter-plotly-dash/

Yessenia Portal Machuca 147 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Para obtener un gráfico polar se debe usar la función bar() e indicar la lista que
contiene los ángulos θ y una lista de la extensión radial de cada sector.

Es importante recordar, que se puede definir el color del gráfico con una lista de
valores de cadena que contengan códigos RGB en el formato #rrggbb correspondientes
a los colores que se deseen.

A continuación un ejemplo de gráfico polar.

In [37 ]: import matplotlib.pyplot as plt
import numpy as np
N = 8
theta = np.arange(0.,2 * np.pi, 2 * np.pi / N)
radii = np.array([4,7,5,3,1,5,6,7])
plt.axes([0.025, 0.025, 0.95, 0.95], polar=True)
colors = np.array([’#4bb2c5’, ’#c5b47f’, ’#EAA228’, ’#579575’,
’#839557’, ’#958c12’, ’#953579’, ’#4b5de4’])
bars = plt.bar(theta, radii, width=(2*np.pi/N), bottom=0.0,
color=colors)

Yessenia Portal Machuca 148 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

14.6. Gráficos 3D
El módulo mplot3d usa también el objeto Figure, sólo que en lugar de los ejes definirá
un nuevo tipo de objeto, llamado Axes3D. Por lo tanto, es necesario importar este módulo
para usar el objeto Axes3D.
from mpl_toolkits.mplot3d import Axes3D

14.6.1. Superficies 3D
Con el paquete mplot3D, las superficies se pueden dibujar directamente en 3D. Por
ejemplo, se gráfica la función z = f (x, y), y se puede ver la superficie con la función
plot_surface().
In [39]: from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
fig = plt.figure()
ax = Axes3D(fig)
X = np.arange(-2,2,0.1)
Y = np.arange(-2,2,0.1)
X,Y = np.meshgrid(X,Y)
def f(x,y):
return (1 - y**5 + x**5)*np.exp(-x**2-y**2)
ax.plot_surface(X,Y,f(X,Y), rstride=1, cstride=1)

Una superficie 3D se destaca más al cambiar el mapa de color, por ejemplo, se puede
establecer la opción kwarg cmap. También se puede rotar la superficie usando la función
view_init(). De hecho, este ajusta el punto de vista desde el que se ve la superficie,
cambiando los kwargs: elev y azim. A través de su combinación se puede obtener la
superficie mostrada desde cualquier ángulo. El primer kwarg ajusta la altura a la que se
ve la superficie, mientras que el segundo ajusta el ángulo de rotación de la superficie.

Yessenia Portal Machuca 149 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

A continuación un ejemplo.
In [40]: from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
fig = plt.figure()
ax = Axes3D(fig)
X = np.arange(-2,2,0.1)
Y = np.arange(-2,2,0.1)
X,Y = np.meshgrid(X,Y)
def f(x,y): return (1 - y**5 + x**5)*np.exp(-x**2-y**2)
ax.plot_surface(X,Y,f(X,Y), rstride=1, cstride=1, cmap=plt.cm.hot)
ax.view_init(elev=30,azim=125)

14.6.2. Gráficos de barras en 3D

Otro tipo de gráfico 3D ampliamente utilizado en el análisis de datos es el gráfico de
barras 3D. También en este caso, se utiliza la función bar() aplicada al objeto Axes3D.
Si se define varias series, se puede acumular varias llamadas a la función bar() en la
misma visualización 3D. Así por ejemplo:
In [41]: import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
x = np.arange(8)
y = np.random.randint(0,10,8)
y2 = y + np.random.randint(0,3,8)
y3 = y2 + np.random.randint(0,3,8)
y4 = y3 + np.random.randint(0,3,8)
y5 = y4 + np.random.randint(0,3,8)
clr = [’#4bb2c5’, ’#c5b47f’, ’#EAA228’, ’#579575’, ’#839557’,
’#958c12’, ’#953579’, ’#4b5de4’]
fig = plt.figure()
ax = Axes3D(fig)

Yessenia Portal Machuca 150 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

ax.bar(x,y,0,zdir=’y’,color=clr)
ax.bar(x,y2,10,zdir=’y’,color=clr)
ax.bar(x,y3,20,zdir=’y’,color=clr)
ax.bar(x,y4,30,zdir=’y’,color=clr)
ax.bar(x,y5,40,zdir=’y’,color=clr)
ax.set_xlabel(’X Axis’)
ax.set_ylabel(’Y Axis’)
ax.set_zlabel(’Z Axis’)
ax.view_init(elev=40)

14.7. Gráficos Multi-Panel

14.7.1. Visualizar subplots dentro de otras subplots
La capacidad de ver gráficos dentro de otros, encerrados dentro de marcos, es ne-
cesario separar los ejes principales (es decir, el gráfico general) del marco que se quiere
añadir, que será otra instancia de ejes. Para ello, se utiliza la función figures() para
obtener el objeto sobre el que se definirán dos objetos de ejes diferentes utilizando la
función add_axes(). Por ejemplo:
In [43]: import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.add_axes([0.1,0.1,0.8,0.8])
inner_ax = fig.add_axes([0.6,0.6,0.25,0.25])
x1 = np.arange(10)
y1 = np.array([1,2,7,1,5,2,4,2,3,1])
x2 = np.arange(10)
y2 = np.array([1,3,4,5,4,5,2,6,4,3])
ax.plot(x1,y1)
inner_ax.plot(x2,y2)
Out[43]: [<matplotlib.lines.Line2D at 0x14acf6d8>]

Yessenia Portal Machuca 151 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

14.7.2. Cuadrículas de subplots

La función GridSpec() permite dividir el área de dibujo en una cuadrícula de subzo-
nas, a la que se le puede asignar una o más de ellas a cada subplots, de forma que al final
se pueden obtener subplots con diferentes tamaños y orientaciones. Se puede utilizar el
objeto Axes por cada función add_subplot() para llamar a la función plot() y dibujar
el gráfico correspondiente. Así por ejemplo:
In [45]: import matplotlib.pyplot as plt
import numpy as np
gs = plt.GridSpec(3,3)
fig = plt.figure(figsize=(6,6))
x1 = np.array([1,3,2,5])
y1 = np.array([4,3,7,2])
x2 = np.arange(5)
y2 = np.array([3,2,4,6,4])
s1 = fig.add_subplot(gs[1,:2])
s1.plot(x,y,’r’)
s2 = fig.add_subplot(gs[0,:2])
s2.bar(x2,y2)
s3 = fig.add_subplot(gs[2,0])
s3.barh(x2,y2,color=’g’)
s4 = fig.add_subplot(gs[:2,2])
s4.plot(x2,y2,’k’)
s5 = fig.add_subplot(gs[2,1:])
s5.plot(x1,y1,’b^’,x2,y2,’yo’)

Yessenia Portal Machuca 152 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

15. Paquetes para aplicaciones financieras

15.1. Statsmodels
Es un paquete que proporciona modelos estadísticos muy utilizados, que se centra
más en las estadísticas y diagnósticos subyacentes a los modelos que en los modelos
más avanzados o predictivos. Este paquete tiene dependencias de los paquetes NumPy,
pandas, scipy y Cython los que deben estar instalados. Para instalar este paquete
debe ejecutar la siguiente sentencia en la consola Anaconda Prompt.
pip install statsmodels

El paquete statsmodels contiene los siguientes módulos7 .

Linear Regression Methods for Survival and Duration

Analysis
Generalized Linear Models Statistics stats

Generalized Estimating Equations Nonparametric Methods nonparame-

tric

Generalized Additive Models (GAM) Generalized Method of Moments

gmm
Robust Linear Models Contingency tables

Multiple Imputation with Chained

Linear Mixed Effects Models
Equations

Regression with Discrete Dependent Multivariate Statistics multivariate

Variable
Empirical Likelihood emplike

Generalized Linear Mixed Effects Mo- Other Models miscmodels

dels
Distributions

ANOVA Graphics Input-Output iolib

Tools
Time Series analysis tsa
The Datasets Package

Time Series Analysis by State Space Sandbox

Methods statespace
Working with Large Data Sets

Vector Autoregressions tsa.vector_ar Optimization

Se revisará algunos de los módulos de este paquete a manera de ejemplos.

7
Para mayor detalle ver https://www.statsmodels.org/stable/

Yessenia Portal Machuca 153 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

1. Estadísticas descriptivas
Este paquete tiene un conjunto funciones para las estadísticas descriptivas, co-
mo parte de la exploración de datos. A continuación se tiene un listado de las
principales funciones:

Funciones Descripción
stattools.acovf(x[, unbiased, demean, fft, . . . ]) Autocovarianza para 1D
stattools.acf(x[, unbiased, nlags, qstat, . . . ]) Función de autocorrelación para arreglos 1d.
stattools.pacf(x[, nlags, method, alpha]) Autocorrelación parcial estimada
stattools.pacf_ols(x[, nlags, efficient, . . . ]) Calcular autocorrelaciones parciales mediante
OLS
stattools.ccf(x, y[, unbiased]) función de correlación cruzada para 1d
stattools.periodogram(X) Devuelve el periodograma para la frecuencia
natural de X
stattools.adfuller(x[, maxlag, regression, . . . ]) Prueba de raíz de la unidad Dickey-Fuller
aumentada
stattools.kpss(x[, regression, lags, store]) Prueba de estacionariedad de
Kwiatkowski-Phillips-Schmidt-Shin
stattools.coint(y0, y1[, trend, method, . . . ]) Prueba de no cointegración de una ecuación
univariada
stattools.q_stat(x, nobs[, type]) Estadística de Return’s Ljung-Box Q
stattools.levinson_durbin(s[, nlags, isacov]) Recursividad de Levinson-Durbin para
procesos autorregresivos
stattools.innovations_algo(acov[, nobs, rtol]) Algoritmo de innovaciones para convertir
autocovarianzas a parámetros MA
stattools.levinson_durbin_pacf(pacf[, nlags]) Algoritmo Levinson-Durbin que devuelve los
coeficientes acf y ar
stattools.arma_order_select_ic(y[, max_ar, . . . ]) Devuelve los criterios de información para
muchos modelos ARMA

2. Interpolación
statsmodels.tsa.interp.denton.dentonm es un método que se usa para con-
vertir datos de baja frecuencia a alta frecuencia. El método de Denton minimiza
la distancia dada por la función de penalización, con de mínimos cuadrados, entre
la serie de referencia desconocida y la serie de indicadores sujeta a la condición
de que la suma de la serie de referencia sea igual a la referencia. Si no se dispone
de ningún punto de referencia para las últimas observaciones de los indicadores,
la extrapolación se realiza utilizando el último ratio indicador de referencia del
período anterior.
Matemáticamente se tiene:

X[t]/I[t] − X[t − 1]/I[t − 1]) ∗ ∗2

Minimiza la suma

sum(X) = A

Yessenia Portal Machuca 154 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Para cada período, donde X es la serie de referencia, I es el indicador y A es el

punto de referencia.

Este método tiene los siguientes parámetros.

Indicador: Una serie de indicadores de baja frecuencia. Es decir, los primeros

indicadores se alinean con el primer punto de referencia.
Punto de referencia: El punto de referencia de mayor frecuencia.
Freq: str {"aq", "qm", "other"} la frecuencia de conversión
∗ aq": Comparación de una serie anual a trimestral.
∗ "mq": Benchmarking de una serie trimestral a mensual.
Kwargs: k el número de observaciones de alta frecuencia que se suman para
hacer una observación agregada de baja frecuencia. k se usa con freq ==
"other".

Ejemplo:
indicator = [50,100,150,100] * 5
benchmark = [500,400,300,400,500]
benchmarked = dentonm(indicator, benchmark, freq="aq")

3. Análisis de series temporales

El módulo statsmodels.tsa contiene funciones que son útiles para el análisis
de series temporales. Los modelos básicos incluyen modelos autorregresivos univa-
riados (AR), modelos vectoriales autorregresivos (VAR) y modelos univariados de
media móvil autorregresiva (ARMA). Los modelos no lineales incluyen la regresión
dinámica de conmutación de Markov y la autorregresión. También incluye méto-
dos para trabajar con polinomios de media autorregresiva y móvil. Además, están
disponibles pruebas estadísticas relacionadas. La estimación se hace por probabili-
dad máxima exacta o condicional o por mínimos cuadrados condicionales, ya sea
usando el Filtro Kalman o filtros directos.

La estructura del módulo es:

stattools: propiedades y pruebas empíricas, acf, pacf, granger-causality, adf

unit root test, kpss test, bds test, ljung-box test y otros.
ar_model: proceso autorregresivo univariante, estimación con probabilidad
máxima condicional y exacta, y mínimos cuadrados condicionales.
arima_model: proceso univariante ARMA, estimación con probabilidad má-
xima condicional y exacta y mínimos cuadrados condicionales.
vector_ar, var: procesos autorregresivos vectoriales (VAR) y modelos de
corrección de errores vectoriales, estimación, análisis de impulso-respuesta,
descomposición de la varianza y herramientas de visualización de datos.
kalmanf: clases de estimación para ARMA y otros modelos con MLE exacto
usando filtro de Kalman.

Yessenia Portal Machuca 155 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

arma_process: propiedades de los procesos ARMA con parámetros dados,

esto incluye herramientas para convertir entre representación ARMA, MA y
AR así como acf, pacf, densidad espectral y función de impulso-respuesta.
tsatools: funciones de ayuda adicionales, para crear matrices de variables
rezagadas, construir regresores para tendencias y similares.
regime_switching: Markov cambia los modelos de regresión dinámica y
autoregresión.

4. statsmodels.multivariate.pca.PCA
Este módulo de Análisis de componentes principales tiene los siguientes paráme-
tros:

data (array-like): Variables en columnas, observaciones en filas

ncomp (int, optional): Número de componentes a devolver.
standardize (bool, optional): Indicador que indica que se deben utilizar da-
tos estandarizados con una media de 0 y varianza unitaria. El uso de datos
estandarizados es equivalente a calcular los componentes principales de la
matriz de correlación de datos.
demean (bool, optional): Indicador que indica si se deben degradar los da-
tos antes de calcular los componentes principales. degradar se ignora si la
estandarización es True.
normalize (bool , optional): Indica si se normalizan los factores para tener
unidad interna de producto.
weights (array, optional): Pesos en serie a utilizar después de transformar
los datos de acuerdo a la estandarización o degradación al computar los
componentes principales.
gls (bool, optional): Indicador que indica la implementación de un estimador
GLS de dos pasos donde en el primer paso se usan los componentes principales
para estimar los residuos, y luego la varianza residual inversa se usa como un
conjunto de ponderaciones para estimar los componentes principales finales.
method (str, optional): Establece la rutina de álgebra lineal utilizada para
calcular los vectores propios ’svd’ utiliza una descomposición de valor sin-
gular (por defecto), ’eig’ utiliza una descomposición de valores propios de
una forma cuadrática, ’nipals’ usa el algoritmo NIPALS.
missing (string): Método para los datos que faltan.

Las opciones predeterminadas realizan el análisis de componentes principales en

la versión de datos degradada y de varianza unitaria. Una vez transformados los
datos, las siguientes relaciones se mantienen cuando el número de componentes
(ncomp) es el mismo que el número mínimo del número de observación o el número
de variables.

Yessenia Portal Machuca 156 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Ejemplo

a) PCA básico utilizando la matriz de correlación de los datos.

import numpy as np
from statsmodels.multivariate.pca import PCA
x = np.random.randn(100)[:, None]
x = x + np.random.randn(100, 100)
pc = PCA(x)

Nótese que los componentes principales se calculan usando SVD y por lo

tanto la matriz de correlación nunca se construye, a menos que se use el
método ’eig’.

b) PCA utilizando la matriz de covarianza de los datos

pc = PCA(x, standardize=False)

Limitar el número de factores devueltos a 1, cálculo usando NIPALS

pc = PCA(x, ncomp=1, method=’nipals’)
pc.factors.shape (100, 1)

Métodos Descripción
plot_rsquare([ncomp, ax]) Gráficos de caja de la serie individual
R-cuadrado contra el número de PCs
plot_scree([ncomp, log_scale, cumulative, ax]) Diagrama de los valores propios
ordenados
project([ncomp, transform, unweight]) Serie de proyectos en un número
específico de factores

5. Gráficos
A continuación se tiene un resumen de las principales funciones del paquete stat-
models, para realziar distintos tipos de gráficos.

a) Bondad de ajuste

Métodos Descripción
gofplots.qqplot(data[, dist, distargs, a, . . . ]) Gráfico Q-Q de los cuantiles de x
frente a los cuantiles/ppf de una
distribución
gofplots.qqline(ax, line[, x, y, dist, fmt]) Traza una línea de referencia para un
qqplot.
gofplots.qqplot_2samples(data1, data2[, . . . ]) Q-Q Gráfico de los cuantiles de dos
muestras.
gofplots.ProbPlot(data[, dist, fit, . . . ]) Clase para la construcción
conveniente de gráficos Q-Q, P-P y
de probabilidad.

b) Boxplots

Yessenia Portal Machuca 157 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Métodos Descripción
boxplots.violinplot(data[, ax, labels, . . . ]) Gráfica de violín de cada conjunto de datos en
la secuencia de datos.
boxplots.beanplot(data[, ax, labels, . . . ]) Gráfica bean de cada conjunto de datos en la
secuencia de datos.

c) Gráficos de correlación

Métodos Descripción
correlation.plot_corr(dcorr[, xnames, . . . ]) Trazar la correlación de muchas variables en
una cuadrícula de colores ajustada.
correlation.plot_corr_grid(dcorrs[, titles, . . . ]) Cree una tabla de gráficos de correlación.
plot_grids.scatter_ellipse(data[, level, . . . ]) Crea una cuadrícula de gráficos de
dispersión con elipses de confianza.

d) Gráficos funcionales

Métodos Descripción
functional.hdrboxplot(data[, ncomp, alpha, . . . ]) Boxplot de la región de alta densidad
functional.fboxplot(data[, xdata, labels, . . . ]) Gráfico funcional.
functional.rainbowplot(data[, xdata, depth, . . . ]) Crea una trama de arco iris para un
conjunto de curvas.
functional.banddepth(data[, method]) Calcular la profundidad de la banda para
un conjunto de curvas funcionales.

e) Gráficos de regresión

Métodos Descripción
regressionplots.plot_fit(results, exog_idx) Gráfica de ajuste de regresión
regressionplots.plot_regress_exog(results, . . . ) Grafica los resultados de regresión contra un
regresor.
regressionplots.plot_partregress(endog, . . . ) Gráfica de regresión parcial para un solo
regresor
regressionplots.plot_partregress_grid(results) Gráfica de regresión parcial para un
conjunto de regresores.
regressionplots.plot_ccpr(results, exog_idx) CCPR contra un regresor.
regressionplots.plot_ccpr_grid(results[, . . . ]) Generar gráficas del CCPR contra un
conjunto de regresores, gráficas en
cuadrícula.
regressionplots.plot_ceres_residuals(. . . [, . . . ]) Produce un gráfico CERES (Conditional
Expectation Partial Residuals) para un
modelo de regresión ajustado.
regressionplots.abline_plot([intercept, . . . ]) Traza una línea dada una intercepción y una
pendiente.
regressionplots.influence_plot(results[, . . . ]) Trama de influencia en la regresión.
regressionplots.plot_leverage_resid2(results) Estadísticas de apalancamiento de gráficos.

Yessenia Portal Machuca 158 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

f ) Gráficos de series cronológicas

Métodos Descripción
tsaplots.plot_acf(x[, ax, lags, alpha, . . . ]) Trazar la función de autocorrelación
tsaplots.plot_pacf(x[, ax, lags, alpha, . . . ]) Trazar la función de autocorrelación parcial
tsaplots.month_plot(x[, dates, ylabel, ax]) Gráfico estacional de los datos mensuales
tsaplots.quarter_plot(x[, dates, ylabel, ax]) Gráfico estacional de los datos trimestrales

g) Otros gráficos

Métodos Descripción
factorplots.interaction_plot(x, trace, response) Gráfico de interacción para
estadísticas de nivel de factor.
mosaicplot.mosaic(data[, index, ax, . . . ]) Crea una gráfica de mosaico a partir
de una tabla de contingencia.
agreement.mean_diff_plot(m1, m2[, sd_limit, . . . ]) Gráfico de diferencia de medias.

15.2. Visualize Wealth

Este es un paquete para construir, realizar backtesting, analizar y evaluar portafolios,
y sus benchmarks. Este paquete tiene las siguientes dependencias: NumPy & scipy,
pandas, tables, urllib2. Para instalar este paquete siga las siguientes instrucciones:

1. Clonar el repositorio (carpeta donde se ha guardado el paquete).

$ cd ~/Downloads
$ git clone https://github.com/benjaminmgross/wealth-viz

2. Cambiar el directorio
$ cd wealth-viz

3. Instalar el paquete
$ python setup.py install

4. Comprobar la instalación, importando el paquete

import visualize_wealth

Este paquete contempla la construcción de portafolios de tres métodos:

1. El método blotter.

2. Método de asignación de pesos.

3. Método de asignación inicial y rebalanceo.

Para mayor detalle del paquete ver https://github.com/benjaminmgross/visualize-wealth

Yessenia Portal Machuca 159 [email protected]

 PROGRAMACIÓN EN PYTHON
Nivel Básico

Referencias
[1] H. Bhasin. Python Basics A Self-Teaching Introduction. Mercury, 2019.
[2] David Jamieson Bolder. Credit-Risk Modelling: Theoretical Foundations, Diagnostic
Tools, Practical Examples, and Numerical Recipes in Python. Springer International
Publishing, 1st ed. edition, 2018.
[3] Claus Fuher. Computing With Python: An Introduction to Python for Science &
Engineering. Pearson Education Limited, 2013.
[4] Alex Galea. Applied Data Science with Python and Jupyter. Packt Publishing,
2018.
[5] Veena A. Gowrishankar S. Introduction to Python Programming. CRC, 2019.
[6] Magnus Lie Hetland. Beginning Python: From Novice to Professional. Apress, 3rd
ed. edition, 2017.
[7] Michael Heydt. Mastering pandas for Finance: Master pandas, an open source
Python Data Analysis Library, for financial data analysis. Packt Publishing, 2015.
[8] Yves Hilpisch. Derivatives Analytics with Python: Data Analysis, Models, Simula-
tion, Calibration and Hedging. Wiley, 2015.
[9] Yves Hilpisch. Python for Finance: Mastering Data-Driven Finance. O’Reilly Media,
2nd edition, 2019.
[10] Yves J Hilpisch. Python for Finance: Analyze Big Financial Data. O’Reilly Media,
first edition edition, 2015.
[11] Pawel Lachowicz. Python for Quants, volume 1. QuantAtRisk, 2015.
[12] Eric Matthes. Python Crash Course A Hands-On, Project-Based Introduction to
Programming. No Starch Press, 2016.
[13] Bhaskar N. Das Mohit. Learn Python in 7 days : get up-and-running with Python.
Packt Publishing - ebooks Account, 2017.
[14] Fabio Nelli. Python Data Analytics with Pandas, NumPy and Matplotlib [2nd ed.].
Apress, 2018.
[15] Ajay Ohri. Python for R users : a data science approach. Wiley, 2018.
[16] David J. Pine. Introduction to Python for Science and Engineering. Series in
Computational Physics. CRC Press, 2019.
[17] Christopher Gardner Shayne Fletcher. Financial Modelling in Python (The Wiley
Finance Series). Wiley, 2009.
[18] Ben Stephenson. The Python Workbook: A Brief Introduction with Exercises and
Solutions. Texts in Computer Science. Springer, 2 edition, 2019-08.
[19] James Ma Weiming. Mastering Python for Finance. Packt Publishing, 2015.
[20] Yuxing Yan. Python for Finance. Packt Publishing, 2nd edition, 2017.

Yessenia Portal Machuca 160 [email protected]