Manejo y análisis de datos con Pandas

Pandas es una librería de python que nos permite analizar grandes cantidades  de datos, nos permite hacer análisis de bigdata. Con Pandas es posible realizar tareas que ni en sueños podríamos hacer en hojas de cálculo como excel u openoffice calc o en motores de bases de datos como mysql o sql. Cuando excel colapsa o se tarda demasiado, es la hora de pandas.

Pandas fué creado por Wes McKinney para hacer análisis cuantitativo en el sector financiero, sector en el  que él trabaja.

Pandas y python son software libre y gratuito.

Contenido

Instalación de Pandas en Ubuntu

Instalación de Pandas en Windows

Iniciar Pandas desde python

Los dataframes

Creación de dataframe de forma manual

Crear un dataframe a partir de una list

Crear un dataframe a partir de un dictionary

Copiar y pegar para crear un dataframe

Creación un dataframe desde un archivo de excel

Creación de dataframe desde un archivo csv

Creación de dataframe desde un archivo de open office calc

Creación de dataframe desde una base de datos mysql

Guardar un dataframe en disco

Exportar un dataframe a excel

Agregar columnas en un dataframe

Eliminar columnas en un dataframe

Eliminar filas en un dataframe

Eliminar duplicados

Hacer una iteración en un dataframe

Concatenar dataframes

Funciones aritméticas y estadísticas de pandas

Merge, combinar, dataframes

Extraer datos de acciones de la bolsa de valores

Instalación de Pandas en Ubuntu

Para trabajar con Pandas, primero tenemos que instalarlo. En python para instalar librerías utilizaremos el programa pip. 

Versiones recientes de Ubuntu  vienen con dos versiones python preinstaladas: la 3 y la 2.7.

En Ubuntu pip para python 3 no viene instalado, por lo que hay que instalarlo. Para instalarlo utilizaremos  en la línea de comandos el comando:

sudo apt install python3-pip

Tras instalarlo es recomendable actualizarlo, para ello utilizaremos  en la línea de comandos el comando:

sudo pip3 install --upgrade pip

Una vez instalado pip, debemos instalar Pandas, para ello utilizaremos  en la línea de comandos el comando:

sudo pip3 install pandas

Es recomendable instalar también Numpy (una librería para hacer análisis matemático), para ello utilizaremos  en la línea de comandos el comando:

sudo pip3 install numpy

Si queremos crear gráficas, podríamos instalar también la lbrería Matplotlib, para ello utilizaremos  en la línea de comandos el comando:

sudo pip3 install matplotlib

Instalación de Pandas en Windows

En windows para instalar pandas en la línea de comandos usaremos el comando:

pip install pandas

Es recomendable instalar también Numpy (una librería para hacer análisis matemático), para ello utilizaremos  en la línea de comandos el comando:

pip install numpy

Si queremos crear gráficas, podríamos instalar también la lbrería Matplotlib, para ello utilizaremos  en la línea de comandos el comando:

pip install matplotlib

Iniciar Pandas desde python

Una vez instalado pandas, procederemos a abrir python 3.  Ubuntu viene desde fábrica con python 2.7 y 3 instalados...  Para iniciar python 3 utilizaremos  en la línea de comandos el comando:

python3

En windows no viene pre-instalado python, por lo que   debemos instalarlo. Una vez instalado  para  iniciarlo  utilizaremos  en la línea de comandos el comando:

python

Una vez  iniciado python, procederemos a importar la librería pandas desde python con el comando:

import pandas as pd

Si no marca error, es una buena señal. En caso de que no esté instalado Pandas, aparecerá un mensaje de error señalando que el módulo no está instalado:

Para importar la librería numpy utilizaremos el comando:

import numpy as np

Para importar la librería matplotlib utilizaremos los comandos:

import matplotlib 
import matplotlib.pyplot as plt

¡Estamos listos para comenzar a trabajar con Pandas!

Los dataframes

Para trabajar con Pandas regularmente utilizaremos dataframes.

Un  dataframe nos permite almacenar datos. El dataframe es como un array (matriz), una hoja de cálculo, una base datos, un dictionary multidimensional o una list multidimensional.

Un dataframe almacena registros en filas o tuples como en la bases de datos . Y cada registro puede tener diferentes atributos, que se almacena en columnas. En las columnas de un dataframe podemos almacenar números enteros, números decimales, strings, lists, dictionaries, sets, objetos, arrays, otros dataframes...

Suponamos que queremos registrar la información de jugadores de fútbol. Para cada jugador se registrará estos datos:

• número de camiseta
• nombre
• edad
• posición
• peso
• estatura

La información de cada jugador se almacenará en filas, tuples,  y  cada atributo en columnas. Gráficamente se puede representar esta información así:

¡Como una hoja de cálculo! Podemos tener registros prácticamente infinitos y cada registro puede tener atributos prácticamente infinitos.

Hay varias formas de crear dataframes. Veamos algunas a continuación.

Creación de dataframe de forma manual

Podemos crear un dataframe vacío con el comando:

mi_dataframe = pd.DataFrame()

¡Hemos creado nuestro primer dataframe! Podemos verificar que es un datraframe con el comando:

type(mi_dataframe)

Un dataframe vacío no sirve de mucho... Podemos crear un dataframe con datos almacenados en  filas y columnas  con este comando:

nombre_dataframe = pd.DataFrame(
{
'columna_01': [10, 20, 30],

'columna_02':[100, 200, 300]
})


# nombre_dataframe es el nombre de la variable que almacenará mi dataframe
# pd.DataFrame() creara un dataframe
# entre llaves {} estarán las filas  y columnas de nuestro datrafame
# 'columna_01' crea una columna con el nombre  columna_01
# con :[] definimos los valores a guardar en la columna
# en este caso almacenamos los valores 10,20 y 30
# cada columna creada la separamos con una  ,
# 'columna_02' crea una columna con el nombre  columna_02
# con :[] definimos los valores a guardar en la columna
# en este caso almacenamos los valores 100,200 y 300    

Un comando muy útil para analizar el contenido de nuestro dataframe es info()

nombre_dataframe.info()

El comando info  nos mostará la cantidad de columnas que tiene nuestro dataframe, el tipo de datos que almacena cada columna, la cantidad de registros almacenados y el tamaño en memoria que ocupa nuestro dataframe.

estados = pd.DataFrame( 
{ 
'nombre':['Aguascalientes',
'Baja California',
'Baja California Sur',
'Campeche',
'Chiapas',
'Ciudad de México',
'Chihuahua',
'Coahuila de Zaragoza',
'Colima',
'Durango',
'Guanajuato',
'Guerrero',
'Hidalgo',
'Jalisco',
'México',
'Michoacán de Ocampo',
'Morelos',
'Nayarit',
'Nuevo León',
'Oaxaca',
'Puebla',
'Querétaro de Arteaga',
'Quintana Roo',
'San Luis Potosí',
'Sinaloa',
'Sonora',
'Tabasco',
'Tamaulipas',
'Tlaxcala',
'Veracruz',
'Yucatán',
'Zacatecas'],
 
'capital':['Aguascalientes',
'Mexicali',
'La Paz',
'Campeche',
'Tuxtla Gutiérrez',
'Ciudad de México',
'Chihuahua',
'Saltillo',
'Colima',
'Durango',
'Guanajuato',
'Chilpancingo',
'Pachuca',
'Guadalajara',
'Toluca',
'Morelia',
'Cuernavaca',
'Tepic',
'Monterrey',
'Oaxaca',
'Puebla',
'Querétaro',
'Chetumal',
'San Luis Potosí',
'Culiacán',
'Hermosillo',
'Villahermosa',
'Ciudad Victoria',
'Tlaxcala',
'Xalapa',
'Mérida',
'Zacatecas'],
 
'superficie':[5618,
71446,
73922,
57924,
73289,
1495,
247455,
151563,
5625,
123451,
30608,
63621,
20846,
78599,
22357,
58643,
4893,
27815,
64220,
93793,
34290,
11684,
42361,
60983,
58200,
179503,
24738,
80175,
3991,
71820,
39612,
75539],
 
'poblacion':[1184996,
3155070,
637026,
822441,
4796580,
8918653,
3406465,
2748391,
650555,
1632934,
5486372,
3388768,
2665018,
7350682,
15175862,
4351037,
1777227,
1084979,
4653458,
3801962,
5779829,
1827937,
1325578,
2585518,
3216000,
2662480,
2238603,
3268554,
1169936,
7643194,
1955577,
1490668],
 
'fecha':['1857-02-05',
'1952-01-16',
'1974-10-08',
'1863-04-29',
'1824-09-14',
'2016-01-29',
'1824-07-06',
'1824-05-07',
'1856-09-12',
'1824-05-22',
'1823-12-20',
'1849-10-27',
'1869-01-16',
'1823-12-23',
'1823-12-20',
'1823-12-22',
'1869-04-17',
'1917-01-26',
'1824-05-07',
'1823-12-21',
'1823-12-21',
'1823-12-23',
'1974-10-08',
'1823-12-22',
'1830-10-14',
'1824-01-10',
'1824-02-07',
'1824-02-07',
'1856-12-09',
'1823-12-22',
'1823-12-23',
'1823-12-23'] 
} 
) 

Crear un dataframe a partir de una list

Es también posible crear un dataframe a partir de una list unidimensional.

Para ello usaremos el comando:

mi_dataframe = pd.DataFrame(mi_lista)

Ejemplo:

#creamos una list
mi_lista = [ 
"Andres", 
"Manuel", 
"Lopez", 
"Obrador" 
] 
#creamos una dataframe a partir de una list
mi_dataframe = pd.DataFrame(mi_lista)

¿Cómo ponerle nombre a la columna? Usando el parámetro columns

mi_dataframe = pd.DataFrame(mi_lista, columns=["nombres"])

Y este es el resultado:

mi_lista = [ 
 ["Jorge Campos",34,1.63,"Palo Alto ","044-55-28-43-76-28"], 
["Cuauhtémoc Blanco",32,1.68,"Jesús María ","044-55-28-43-76-27"], 
["Joel Sánchez Ramos",28,1.92,"Pabellón de Arteaga ","044-55-28-43-76-26"], 
["Duilio Davino",38,1.80,"Rincón de Romos ","044-55-28-43-76-25"], 
["Alberto García Aspe",27,1.94,"San Francisco de los Romo ","044-55-28-43-76-24"], 
["Raúl Rodrigo Lara",32,1.90,"San José de Gracia ","044-55-28-43-76-23"], 
["Jaime Ordiales",35,1.73,"Tepezalá ","044-55-28-43-76-22"], 
["Germán Villa",27,1.94,"Xpujil ","044-55-28-43-76-21"], 
["Pável Pardo",22,1.84,"Calkiní ","044-55-28-43-76-20"], 
["Francisco Palencia",32,1.86,"Campeche ","044-55-28-43-76-19"], 
["Jesús Arellano",19,1.97,"Candelaria ","044-55-28-43-76-18"], 
["Luis Hernández",37,1.63,"Ciudad del Carmen ","044-55-28-43-76-17"], 
["Ramón Ramírez",26,1.70,"Champotón ","044-55-28-43-76-16"], 
["Claudio Suárez",25,1.62,"Escárcega ","044-55-28-43-76-15"] 
] 

mi_dataframe = pd.DataFrame(mi_lista, columns=["nombre","edad","estatura","lugar_nacimiento", "telefono"])

Crear un dataframe a partir de un dictionary

Es también posible crear un dataframe a partir de un dictionary multidimensional .

Para ello usaremos el comando:

mi_dataframe = pd.DataFrame(mi_dictionary)

Ejemplo:

mi_diccionario = { 
'portero':["Jorge Campos",34,1.63,"Palo Alto ","044-55-28-43-76-28"], 
'lateral_izquierdo':["Joel Sánchez Ramos",28,1.92,"Pabellón de Arteaga ","044-55-28-43-76-26"], 
'contencion':["Duilio Davino",38,1.80,"Rincón de Romos ","044-55-28-43-76-25"], 
'defensa_central':["Claudio Suárez",25,1.62,"Escárcega ","044-55-28-43-76-15"], 
'lateral_derecho':["Raúl Rodrigo Lara",32,1.90,"San José de Gracia ","044-55-28-43-76-23"], 
'mediocampo':["Alberto García Aspe",27,1.94,"San Francisco de los Romo ","044-55-28-43-76-24"], 
'volante_derecho':["Germán Villa",27,1.94,"Xpujil ","044-55-28-43-76-21"], 
'volante_izquierdo':["Pável Pardo",22,1.84,"Calkiní ","044-55-28-43-76-20"], 
'volante_de_enganche':["Ramón Ramírez",26,1.70,"Champotón ","044-55-28-43-76-16"], 
'delantero':["Cuauhtémoc Blanco",32,1.68,"Jesús María ","044-55-28-43-76-27"], 
'extremo_derecho':["Francisco Palencia",32,1.86,"Campeche ","044-55-28-43-76-19"], 
'extremo_izquierdo':["Luis Hernández",37,1.63,"Ciudad del Carmen ","044-55-28-43-76-17"] 
}

mi_dataframe = pd.DataFrame(mi_diccionario)

Si el resultado no nos satisface, podemos hacer una iteración en nuestro dictionary para reorganizarlo y acomodarlo acorde a nuestras necesidades. 

En este ejemplo reorganizaremos este dictionary para que quede de esta manera:

nueva_lista =  [] 
# creamos una list vacia 
# sera una list multidimensional 
# cada elemento de la list sera otra list con los datos de cada jugador 

#haremos una iteración en el dictionary 
for i in mi_diccionario: 
 lista_temporal = [] 
 # creamos una list con los datos de cada jugador 
 lista_temporal.append(mi_diccionario[i][0]) 
 # extraemos el nombre y lo almacenamos en la list 
 lista_temporal.append(mi_diccionario[i][1]) 
 # extraemos la edad y la almacenamos en la list 
 lista_temporal.append(mi_diccionario[i][2]) 
 # extraemos la estatura y la almacenamos en la list 
 lista_temporal.append(mi_diccionario[i][3]) 
 # extraemos la ciudad y la almacenamos en la list 
 lista_temporal.append(mi_diccionario[i][4]) 
 # extraemos el telefono y lo almacenamos en la list 
 lista_temporal.append(i) 
 # extraemos la posición y la almacenamos en la list 
 nueva_lista.append(lista_temporal) 
 # agregamos los datos del jugador a nuestra lista

Y como hemos visto anteriormente podemos convertir una lista multidimensional  en un dataframe con el comando:

mi_dataframe = pd.DataFrame(mi_lista)

Ejemplo:

mi_dataframe = pd.DataFrame(nueva_lista, 
columns=["nombre","edad","estatura","lugar_nacimiento", "telefono", "posicion"])

Copiar y pegar para crear un dataframe

Es posible crear también un dataframe copiando y pegando datos separados por tabulaciones, como cuando se copian datos desde un archivo de excel, un archivo de open office o un archivo de texto.

Para ello utilizaremos el comando:

mi_dataframe = pd.read_clipboard()

Creación un dataframe desde un archivo de excel

Es posible crear también un dataframe a partir de un archivo de excel 2007 (archivos .xlsx).  Para ello es necesario instalar la librería openpyxl .

En Ubuntu para instalar la librería openpyxl para python3 utilizaremos el comando:

pip3 install openpyxl 

En Windows para instalar la librería openpyxl utilizaremos el comando:

pip install openpyxl 

Importar datos desde excel es bastante sencillo. Para ello utilizaremos el comando:

mi_dataframe = pd.read_excel("nombre_archivo.xlsx")

¡Con sólo una línea de código!

Para este ejemplo usaremos el archivo jugadores.xlsx

Y lo importaremos con el comando:

mi_dataframe = pd.read_excel("jugadores.xlsx")

El resultado es:

Automáticamente pandas toma la primera fila del archivo de excel como el nombre de nuestras columnas. Podemos desactivar esa opción con el parámetro  header=None

Ejemplo:

mi_dataframe = pd.read_excel("jugadores.xlsx", header=None)

Como podemos ver, la primera fila la considera como una fila más de datos.

Como hemos visto anteriormente podemos rebautizar el nombre de las columnas. Pero al importar desde excel debemos utilizar el parámetro names. 

Ejemplo:

mi_dataframe = pd.read_excel("jugadores.xlsx", names=["nombre", "edad", "estatura", "ciudad", "telefono", "posicion" ])

Creación de dataframe desde un archivo csv

Los archivos csv son archivos de texto que almacenan información que se exporta desde una hoja de cálculo o una base de datos. Permiten el intercambio de datos. Actualmente muchas instituciones y órganos del gobierno intercambian información con archivos .csv. Este es un ejemplo de un archivo csv:

mi_dataframe = pd.read_csv("nombre_archivo.csv")

¡Con sólo una línea de código!

Para este ejemplo usaremos el archivo jugadores.csv

Y lo importaremos con el comando:

mi_dataframe = pd.read_csv("jugadores.csv")

El resultado es:

Creación de dataframe desde un archivo de open office calc

Extrañamente, pese a ser software libre, no se pueden importar archivos .ods de open office calc...

¿La solución? Para ello podemos copiar y pegar los datos para crear un dataframe o exportar el archivo .ods como un archivos .csv

Creación de dataframe desde una base de datos mysql

Python se puede conectar a una base de datos mysql y extaer datos y almacenarlos en un dataframe. Para ello se utiliza el comando:

mi_dataframe = pd.read_sql_query(sql, cnx)

Previamente debimos establecer una conexión a la base de datos y hacer una consulta.

El código completo es:

import mysql.connector
#importamos la librería para hacer la conexión a mysql

cnx = mysql.connector.connect(user='root', password='escribe_tu_contrasena', host='127.0.0.1',database='jugadores')
#creamos una conexión a la base de datos

sql = """SELECT 

nombre,
edad,
estatura,
lugar_nacimiento,
telefono,
posicion,

FROM

seleccion_mexicana
"""
# escribimos nuestra consulta

mi_dataframe = pd.read_sql_query(sql, cnx)
# ejectuamos la consulta en la base de datos
# el resultado de nuesta consulta lo almacenamos en un dataframe

Guardar un dataframe en disco

Una vez que hemos construído nuestro dataframe, si cerramos la línea de comandos nuestro dataframe desaparecerá para siempre... Si apagamos la computadora nuestro dataframe desaparecerá para siempre...

Pero podemos guardar en disco a nuestro dataframe para continuar trabajando en él posteriormente. Para ello usaremos el comando:

mi_dataframe.to_pickle("nombre_de_archivo.pkl")

Ejemplo:

mi_dataframe.to_pickle("nombre_de_archivo.pkl")

Tras ejecutar ese comando se creará un archivo .pkl en nuestra computadora.

mi_dataframe = pd.read_pickle("nombre_de_archivo.pkl")

Exportar un dataframe a excel

Es posible exportar un dataframe a un archivo de excel 2007 (archivos .xlsx).

Para ello utilizaremos los comandos:

mi_archivo_de_excel = pd.ExcelWriter("nombre_archivo.xlsx")
#creamos nuestro archivo de excel y lo bautizamos

mi_dataframe.to_excel(mi_archivo_de_excel)
# exportamos el dataframe a excel

mi_archivo_de_excel.save()
#guardamos el archivo

Como podemos ver, el index del dataframe también se exportó. ¿Como eliminarlo? Con el parámetro index=False en la función to_excel()

Ejemplo:

mi_archivo_de_excel = pd.ExcelWriter("nombre_archivo.xlsx")
#creamos nuestro archivo de excel y lo bautizamos

mi_dataframe.to_excel(mi_archivo_de_excel, index=False)
# exportamos el dataframe a excel

mi_archivo_de_excel.save()
#guardamos el archivo

Agregar columnas en un dataframe

Es posible modificar un dataframe para agregarle una columna. La columna puede estar vacía, con datos o  puede alimentarse a partir de datos en el propio dataframe o una lista.

Para este ejemplo usaremos el archivo jugadores.xlsx

Y lo importaremos con el comando:

mi_dataframe = pd.read_excel("jugadores.xlsx")

El resultado es:

mi_dataframe["nombre_columna"] = valor_a_asignar

mi_dataframe["peso"] = 0 

mi_dataframe["nombre_columna"] = ""

mi_dataframe["nacionalidad"] = ""

Ahora agregaremos la columna peso y usaremos una list  para alimentar los datos de esa columna.  Para ello usaremos  el comando:

mi_dataframe["nombre_columna"] = mi_lista

Ejemplo:

mi_lista = [72,74,70,84,69,69,85,70,77,79,78,87]

mi_dataframe["peso"] = mi_lista

Como puede verse los valores se asignaron a cada registro acorde a su posición en la list.

Supongamos que necesitamos agregar una columna con el peso de los jugadores en libras... Tenemos que agregar una columna que se alimente a partir de datos en el propio dataframe.

 Para ello usaremos  el comando:

mi_dataframe["peso_libras"] = mi_dataframe["peso"]  / .453592

Otro ejemplo  de agregar una columna que se alimente a partir de datos en el propio dataframe: en México se modificó la marcación a teléfonos celulares, por lo que el prefijo 044 ya no es necesario. Actualizaremos ahora nuestro dataframe para eliminar el prefijo 044.

 Para ello usaremos  el comando:

mi_dataframe["nuevo_telefono"] =  mi_dataframe["telefono"].str[:-13]

Supongamos que ahora necesitamos agregar el índice de masa corporal... Ese valor será resultado del valor de dos columnas que existen en nuestro dataframe:  peso y estatura.

 Para ello usaremos  el comando:

mi_dataframe["imc"] = mi_dataframe["peso"]  / (mi_dataframe["estatura"]*(mi_dataframe["estatura"]))

Eliminar columnas en un dataframe

Es posible eliminar una o más columnas de un dataframe. 

Para este ejemplo usaremos el archivo jugadores.xlsx

Y lo importaremos con el comando:

mi_dataframe = pd.read_excel("jugadores.xlsx")

El resultado es:

mi_dataframe = mi_dataframe.drop(["columna_a_borrar", "otra_columna"], axis=1)

mi_dataframe =  mi_dataframe.drop(["telefono",  "posicion"], axis=1)

mi_dataframe = mi_dataframe.drop(columns=["columna_a_borrar", "otra_columna"])

mi_dataframe =  mi_dataframe.drop(columns=["estatura",  "edad"])

Eliminar filas en un dataframe

Es posible eliminar una o más filas de un dataframe. 

Para este ejemplo usaremos el archivo jugadores.xlsx

Y lo importaremos con el comando:

mi_dataframe = pd.read_excel("jugadores.xlsx")

El resultado es:

mi_dataframe =  mi_dataframe.drop([index_elemento_a_borrar, index_elemento_a_borrar])

mi_dataframe =  mi_dataframe.drop([0,10])
# eliminaremos el elemento 0 y 10 de nuestro dataframe

mi_dataframe = mi_dataframe[mi_dataframe.columna condicion]

mi_dataframe = mi_dataframe[mi_dataframe.edad == 27]
# eliminaremos los registros cuya edad no sea 27

Reconstruyamos nuestro dataframe para poner otro ejemplo. Para este ejemplo usaremos el archivo jugadores.xlsx

Y lo importaremos con el comando:

mi_dataframe = pd.read_excel("jugadores.xlsx")

El resultado es:

mi_dataframe = mi_dataframe[mi_dataframe.edad != 27]
# eliminaremos los registros cuya edad sea 27

Reconstruyamos nuestro dataframe para poner otro ejemplo.Para este ejemplo usaremos el archivo jugadores.xlsx

Y lo importaremos con el comando:

mi_dataframe = pd.read_excel("jugadores.xlsx")

El resultado es:

mi_dataframe = mi_dataframe[mi_dataframe.edad > 27]
# eliminaremos los registros cuya edad sea 27 o menos

Eliminar duplicados

Es posible eliminar eliminar registros duplicados en un dataframe.  Para ello utilizaremos el comando:

mi_dataframe = mi_dataframe.drop_duplicates()

Sí. ¡Con una línea de código!

Hacer una iteración en un dataframe

Es posible hacer una iteración en un dataframe. Para ello usaremos el comando:

for registro in range(0, len(mi_dataframe)): 
 print mi_dataframe.iloc[registro]['columna_a_mostrar']; 
 print mi_dataframe.iloc[registro]['columna_a_mostrar_02']; 

Para este ejemplo usaremos el archivo jugadores.xlsx

Y lo importaremos con el comando:

mi_dataframe = pd.read_excel("jugadores.xlsx")

El resultado es:

for registro in range(len(mi_dataframe)): 
 print(mi_dataframe.iloc[registro]['nombre']); 
 print(mi_dataframe.iloc[registro]['edad']);

Concatenar dataframes

Es muy común que datos los tengamos dispersados en varias hojas de excel, bases de datos, archivos csv, etc.

Es posible importar cada uno de esos archivos en un dataframe y luego concatenarlos en un dataframe que tenga la información de TODOS LOS ARCHIVOS para su posterior análisis...

Supongamos que tenemos varios archivos de excel con el registro de la ventas de varios productos por mes para cada año:

Los archivos de excel para este ejemplo pueden descargarse aquí

Una opción es copiar y pegar los datos... Pero es posible que se cometan errores.

Mejor podemos invocar al poder de python y pandas para hacerlo. Más aún, usaremos una iteración que busque todos los archivos de excel, cree un dataframe a partir de cada archivo de excel y finalmente  los concatene en un dataframe que contenga toda la información.

Para ello podemos usar el siguiente código:

mi_dataframe_final = pd.DataFrame() 
# creamos un dataframe donde almacenaremos la información de todos los archivos de excel 

import os 
# importamos la librería os para tener acceso al file system 

#hacemos una iteración en el directorio actual 
for archivo in os.listdir("."): 
 # buscamos archivos de excel 
 if archivo.endswith(".xlsx"): 
 print(archivo) 
 # mostramos en pantalla el nombre del archivo que importaremos 
 mi_dataframe_temporal = pd.DataFrame() 
 # creamos un dataframe vacio 
 mi_dataframe_temporal = pd.read_excel(archivo) 
 # creamos un dataframe a partir del archivo de excel 
 mi_dataframe_final = mi_dataframe_final.append(mi_dataframe_temporal, ignore_index=True) 
 # concatenemos el dataframe al datraframe final

Funciones aritméticas y estadísticas de pandas

Bueno... hasta ahora casi no hemos visto nada fuera de lo común y extraordinario... Nada que no podamos hacer con una hoja de excel.  Comencemos a ver algunas de las funciones aritméticas y estadísticas que pandas tiene incluidas.

Para ello vamos a crear un dataframe de forma manual que almacene los nombres de los Estados de México, con el nombre de su capital, su población, su superficie territorial y la fecha en que se incorporaron a la federación:

estados = pd.DataFrame( 
{ 

'nombre':['Aguascalientes','Baja California','Baja California Sur','Campeche','Chiapas',
'Ciudad de México','Chihuahua','Coahuila de Zaragoza','Colima','Durango','Guanajuato','Guerrero',
'Hidalgo','Jalisco','México','Michoacán de Ocampo','Morelos','Nayarit','Nuevo León','Oaxaca',
'Puebla','Querétaro de Arteaga','Quintana Roo','San Luis Potosí','Sinaloa','Sonora','Tabasco',
'Tamaulipas','Tlaxcala','Veracruz','Yucatán','Zacatecas'], 

'capital':['Aguascalientes','Mexicali','La Paz','Campeche','Tuxtla Gutiérrez','Ciudad de México',
'Chihuahua','Saltillo','Colima','Durango','Guanajuato','Chilpancingo','Pachuca','Guadalajara',
'Toluca','Morelia','Cuernavaca','Tepic','Monterrey','Oaxaca','Puebla','Querétaro','Chetumal',
'San Luis Potosí','Culiacán','Hermosillo','Villahermosa','Ciudad Victoria','Tlaxcala','Xalapa',
'Mérida','Zacatecas'], 

'superficie':[5618,71446,73922,57924,73289,1495,247455,151563,5625,123451,30608,63621,20846,
78599,22357,58643,4893,27815,64220,93793,34290,11684,42361,60983,58200,179503,24738,80175,3991,
71820,39612,75539], 

'poblacion':[1184996,3155070,637026,822441,4796580,8918653,3406465,2748391,650555,1632934,
5486372,3388768,2665018,7350682,15175862,4351037,1777227,1084979,4653458,3801962,5779829,
1827937,1325578,2585518,3216000,2662480,2238603,3268554,1169936,7643194,1955577,1490668], 

'fecha':['1857-02-05','1952-01-16','1974-10-08','1863-04-29','1824-09-14','2016-01-29',
'1824-07-06','1824-05-07','1856-09-12','1824-05-22','1823-12-20','1849-10-27','1869-01-16',
'1823-12-23','1823-12-20','1823-12-22','1869-04-17','1917-01-26','1824-05-07','1823-12-21',
'1823-12-21','1823-12-23','1974-10-08','1823-12-22','1830-10-14','1824-01-10','1824-02-07',
'1824-02-07','1856-12-09','1823-12-22','1823-12-23','1823-12-23'] 
} 
) 

mi_data_frame[nombre_columna].sum()

estados['poblacion'].sum()

mi_data_frame[nombre_columna].max()

estados['poblacion'].max()

Pero... ¿a que estados pertenecen esos datos? ¿Cómo podemos recuperar el Estado con la mayor población junto con su nombre?

En python la misma tarea se puede hacer de diferentes formas... con diferentes funciones. Por ejemplo para la tarea arriba referida podemos usar los comandos:

mi_dataframe.loc[mi_dataframe['columna_a_buscar'].idxmax()]

# o también podemos usar:

mi_dataframe[mi_dataframe['columna_a_buscar']==mi_dataframe['columna_a_buscar'].max()]

estados.loc[estados['poblacion'].idxmax()]

estados[estados['poblacion']==estados['poblacion'].max()]

resultado = estados.loc[estados['poblacion'].idxmax()]
type(resultado)

resultado[0]
# muestra la primera columna, el nombre del Estado
resultado[1]
# muestra la segunda columna, el nombre de la capital
resultado[2]
# muestra la tercera columna, la superficie
resultado[3]
# muestra la cuarta columna, la población

resultado2 = estados[estados['poblacion']==estados['poblacion'].max()]
type(resultado2)

resultado2['nombre']
# muestra la primera columna, el nombre del Estado
resultado2['capital']
# muestra la segunda columna, el nombre de la capital
resultado2['superficie']
# muestra la tercera columna, la superficie
resultado2['poblacion']
# muestra la cuarta columna, la población

Misma lógica usaremos para obtener el valor mínimo de una columna. Para ello en  un dataframe utilizaremos el comando:

mi_data_frame[nombre_columna].min()

Así para obtener el valor mínimo de la columna población  de nuestro dataframe de ejemplo utilizaremos el comando:

estados['poblacion'].min()

Pero... ¿a que estados pertenecen esos datos? ¿Cómo podemos recuperar el Estado con la menor población junto con su nombre?

Por ejemplo para la tarea arriba referida podemos usar los comandos:

mi_dataframe.loc[mi_dataframe['columna_a_buscar'].idxmin()]

# pero también podemo usar:

mi_dataframe[mi_dataframe['columna_a_buscar']==mi_dataframe['columna_a_buscar'].min()]

estados.loc[estados['poblacion'].idxmin()]

estados[estados['poblacion']==estados['poblacion'].min()]

resultado = estados.loc[estados['poblacion'].idxmin()]
type(resultado)

resultado[0]
# muestra la primera columna, el nombre del Estado
resultado[1]
# muestra la segunda columna, el nombre de la capital
resultado[2]
# muestra la tercera columna, la superficie
resultado[3]
# muestra la cuarta columna, la población

resultado2 = estados[estados['poblacion']==estados['poblacion'].min()]
type(resultado2)

resultado2['nombre']
# muestra la primera columna, el nombre del Estado
resultado2['capital']
# muestra la segunda columna, el nombre de la capital
resultado2['superficie']
# muestra la tercera columna, la superficie
resultado2['poblacion']
# muestra la cuarta columna, la población

Para obtener el promedio de una columna en  un dataframe utilizaremos el comando:

mi_data_frame[nombre_columna].mean()

Así para obtener el promedio de la columna población  de nuestro dataframe de ejemplo utilizaremos el comando:

estados['poblacion'].mean()

Así para obtener el promedio de la columna superficie  de nuestro dataframe de ejemplo utilizaremos el comando:

estados['superficie'].mean()

Para obtener la desviación standard de una columna en  un dataframe utilizaremos el comando:

mi_data_frame[nombre_columna].std()

Así para obtener la desviación standard de la columna población  de nuestro dataframe de ejemplo utilizaremos el comando:

estados['poblacion'].std()

Así para obtener la desviación standard de la columna superficie  de nuestro dataframe de ejemplo utilizaremos el comando:

estados['superficie'].std()

Para obtener la varianza  de una columna en  un dataframe utilizaremos el comando:

mi_data_frame[nombre_columna].var()

Así para obtener la varianza de la columna población  de nuestro dataframe de ejemplo utilizaremos el comando:

estados['poblacion'].var()

Así para obtener la varianza  de la columna superficie  de nuestro dataframe de ejemplo utilizaremos el comando:

estados['superficie'].var()

Podemos ordenar nuestro dataframe de manera ascendente o descendente en relación a cualquier columa. Para ello usaremos el comando:

mi_data_frame.sort_values(by=['nombre_columna'], ascending=False/True)

Así para ordenar nuestro dataframe de ejemplo  a partir de la columna población de manera ascendente utilizaremos el comando:

estados.sort_values(by=['poblacion'], ascending=False)

estados.sort_values(by=['poblacion'], ascending=True)

Para analizar un dataframe y detectar cuantos valores únicos hay en una columna y su frecuencia, cantidad de veces que ocurren, podemos utilizar el comando:

mi_data_frame[nombre_columna].value_counts()

Así para detectar cuantos valores únicos hay en la columna fecha y su frecuencia, cantidad de veces que ocurren,   en nuestro dataframe de ejemplo utilizaremos el comando:

estados['fecha'].value_counts()

Actualmente México es una federación de 31 Estados y la Ciudad de México. Descubrimos ahora que al inicio, el 20 de septiembre de 1823,  sólo había 2 Estados miembros de la federación... y con el paso de los días y años se fueron incorporando nuevos Estados.

¿Cómo fue esa incorporación? Podemos verlo con el comando:

estados.sort_values(by=['fecha'], ascending=True)

Y el resultado es:

Podemos obtener también la suma acumulada de una columna en  un dataframe, para ello utilizaremos el comando:

mi_data_frame[nombre_columna].cumsum()

Así para obtener la suma acumulada de la columna población  de nuestro dataframe de ejemplo utilizaremos el comando:

estados['poblacion'].cumsum()

Merge, combinar, dataframes

Podemos concatenar dos o más dataframes. Pero también podemos combinarlos / merge y compararlos para detectar que valores están presentes en uno u otro dataframe. Una vez combinados, podemos realizar el análisis de nuestro dataframe.

Para ello ulilizaremos el comando:

merge()

Para este ejemplo vamos a crear dos dataframes de forma manual que almacene los nombres de los Estados de México y su población en dos diferentes años 2010 y 2020:

estados_2010 = pd.DataFrame( 
{ 
'nombre':['Aguascalientes','Baja California','Baja California Sur','Campeche','Chiapas',
'Distrito Federal','Chihuahua','Coahuila','Colima','Durango','Guanajuato','Guerrero',
'Hidalgo','Jalisco','México','Michoacán','Morelos','Nayarit','Nuevo León','Oaxaca','Puebla',
'Querétaro','Quintana Roo','San Luis Potosí','Sinaloa','Sonora','Tabasco','Tamaulipas','Tlaxcala',
'Veracruz','Yucatán','Zacatecas'], 

'poblacion':[1184996,3155070,637026,822441,4796580,8918653,3406465,2748391,650555,1632934,5486372,
3388768,2665018,7350682,15175862,4351037,1777227,1084979,4653458,3801962,5779829,1827937,1325578,
2585518,3216000,2662480,2238603,3268554,1169936,7643194,1955577,1490668]
} 
) 

estados_2020 = pd.DataFrame( 
{ 
'nombre':['Aguascalientes','Baja California','Baja California Sur','Campeche','Chiapas',
'Chihuahua', 'Ciudad de México','Coahuila','Colima','Durango','Guanajuato','Guerrero',
'Hidalgo','Jalisco','México','Michoacán','Morelos','Nayarit','Nuevo León','Oaxaca','Puebla',
'Querétaro','Quintana Roo','San Luis Potosí','Sinaloa','Sonora','Tabasco','Tamaulipas','Tlaxcala',
'Veracruz','Yucatán','Zacatecas'], 
'poblacion':[1425607,3769020,798447,928363,5543828,3741869,9209944,3146771,731391,1832650,6166934,
3540685,3082841,8348151,16992418,4748846,1971520,1235456,5784442,4132148,6583278,2368467,1857985,
2822255,3026943,2944840,2402598,3527735,1342977,8062579,2320898,1622138]
} 
) 

Si los concatenaramos, tendríamos un dataframe con 64 filas... Pero nosotros queremos crear un dataframe con 32 filas, una para cada estado, y una columna con la población en el año 2010 y una columna con la población en el año 2020.

Para ello usaremos el comando merge()

estados_2010_vs_2020 = estados_2010.merge(estados_2020,on=['nombre'], how="left", indicator=True)

Con este código creamos un nuevo dataframe llamado estados_2010_vs_2020 que combinará los dos dataframes.

Usaremos como punto de partida y referencia para nuesta combinación el dataframe  estados_2010 y sobre ese dataframe vaciaremos los datos almacenados en el dataframe  estados_2020

Con el parámetro on definimos las columnas que utilizaremos como referencia para realizar la combinación, en este ejemplo combinaremos los dataframes a partir de la columna nombre, que almacena el nombre del estado. Pandas permite utilizar una o varias columnas  como referencia para realizar la combinación.

Con el parámetro how definimos como se combinarán los dataframes. El parámetro how tiene varios posibles valores:

left:  para este ejemplo utiliza como punto de partida y referencia para nuesta combinación el dataframe  estados_2010 y sobre ese dataframe vaciaremos los datos almacenados en el dataframe  estados_2020. Si hay datos  en el dataframe  estados_2020 que no existen en el  dataframe  estados_2010, no se mostrarán en el resultado final.

right: para este ejemplo utiliza como punto de partida y referencia para nuesta combinación el dataframe  estados_2020 y sobre ese dataframe vaciaremos los datos almacenados en el dataframe  estados_2010. Si hay datos  en el dataframe  estados_2010 que no existen en el  dataframe  estados_2020, no se mostrarán en el resultado final.

outter: para este ejemplo utiliza como punto de partida y referencia para nuesta combinación el dataframe  estados_2010 y sobre ese dataframe vaciaremos los datos almacenados en el dataframe  estados_2020. Si hay datos  en el dataframe  estados_2020 que no existen en el  dataframe  estados_2010, SÍ se mostrarán en el resultado final.

inner: para este ejemplo utiliza como punto de partida y referencia para nuesta combinación el dataframe  estados_2010 y sobre ese dataframe vaciaremos los datos almacenados en el dataframe  estados_2020. Si hay datos  en el dataframe  estados_2020 que no existen en el  dataframe  estados_2010, NO se mostrarán en el resultado final.

Con el parámetro indicator=True especificamos que pandas cree una columna que nos indique el resultado de la combinación, para detectar si hay datos que no existen en un dataframe

Bien dicen que una imagen vale más que mil palabras, así que ilustremos mejor el resultado del parámetro how.

Un ejemplo con left:

estados_2010_vs_2020 = estados_2010.merge(estados_2020,on=['nombre'], how="left", indicator=True)

Como podemos ver el registro con el estado Ciudad de México que existe en el dataframe estados_2020 no aparece en el resultado de la combinación (Nota en el año 2016 el Distrito Federal cambió de nombre, su nuevo nombre es Ciudad de México).

Y la columna _merge nos indica que ese registro sólo existe en uno de los dataframes.

Un ejemplo con right:

estados_2010_vs_2020 = estados_2010.merge(estados_2020,on=['nombre'], how="right", indicator=True)

Como podemos ver el registro con el estado Distrito Federal que existe en el dataframe estados_2010 no aparece en el resultado de la combinación (Nota en el año 2016 el Distrito Federal cambió de nombre, su nuevo nombre es Ciudad de México).

Y la columna _merge nos indica que ese registro sólo existe en uno de los dataframes.

Un ejemplo con outer:

estados_2010_vs_2020 = estados_2010.merge(estados_2020,on=['nombre'], how="outer", indicator=True)

En este caso outer nos indica los dos registros que no existen en los dos dataframes... Y más aún los incluye en el resultado final.  Así tenemos un registro para Ciudad de México y otro para Distrito Federal (Nota en el año 2016 el Distrito Federal cambió de nombre, su nuevo nombre es Ciudad de México).

Y la columna _merge nos indica en que dataframe está cada uno de ellos.

Un ejemplo con inner:

estados_2010_vs_2020 = estados_2010.merge(estados_2020,on=['nombre'], how="inner", indicator=True)

En este caso inner excluye  los dos registros que no existen en los dos dataframes...

Extraer datos de acciones de la bolsa de valores

Wes McKinney creó pandas para hacer análisis cuantitativo en el sector financiero. Consecuentemente podemos consultar los valores de las acciones en la bolsa de valores con ayuda de pandas y hacer el análisis correspondiente.

También es posible consultar los datos abiertos del Banco Mudial (World Bank) la OCDE (OECD) o las estadísticas oficiales de la Unión Europea vía Eurostat.

 Para facilitar la consulta, es necesario instalar la librería pandas_datareader.

En windows la librería pandas_datareader  se instala con el comando:

pip install pandas_datareader

En Ubuntu con python 3 la librería pandas_datareader  se instala con el comando:

pip3 install pandas_datareader

Para crear una gráfica con la información, usaremos la libería matplotlib.

Una vez instaladas las librerías pandas_datareader y  matplotlib iniciamos python e importamos las librerías:

• pandas
• pandas_datareader
• datetime
• matplotlib

import pandas as pd 
from pandas_datareader import data 
import datetime as dt 
import matplotlib.pyplot as plt

data1 = data.DataReader(name='TSLA', data_source='yahoo', start='2022-07-25', end='2022-07-29') 
# hacemos la consulta del valor de la acciòn
# el parámetro name define la acción a consultar por sus siglas, acorde al NYSE
# TSLA son las acciones de Tesla
# el parámetro source define el servidor que consultaremos
# en este ejemplo utilizamos los servidores de yahoo para descargar el valor de las acciones
# el parámetro start define la fecha inicial de la consulta
# en este caso 25 de julio de 2022
# el parámetro end define la fecha final de la consulta
# en este caso 29 de julio de 2022

Algunas siglas de acciones de empresas famosas:

• Facebook: FB
• Google: GOOGL 
• Amazon: AMZ 
• Boeing: BA 
• Walmart: WMT  
• AT&t: T 
• Tesla: TSLA
• AAPL: Apple
• MSFT Microsoft

El resultado del comando es  un data frame:

El dataframe incluye los siguientes datos de la acción

• fecha
• precio más alto durante el día
• precio más bajo durante el día
• el precio al inicio de las operaciones del mercado
• el precio al final de las operaciones del mercado
• el volumen de acciones negociadas en el día
• el precio ajustado al final de las operaciones del mercado

Con ayuda de una list podemos extraer el valor de varias acciones simultáneamente y elegir una de las columnas. En este ejemplo seleccionaremos varias acciones y solo extraeremos el precio al final de las operaciones del mercado

data1 = data.DataReader(name=['AAPL', 'GOOGL', 'AMZN', 'MSFT'], data_source='yahoo', start='2022-07-25', end='2022-07-29')['Close']

data1.plot(title='Precio de la acción') 
#creamos la gráfica 
plt.show() 
# mostramos la gráfica

Este ejemplo es parte de un tutorial más completo que puede consultarse:

• Instalando Python en ubuntu y windows
• Variables, cadenas de texto / strings y operaciones aritméticas en Python
• Listas / Lists en Python
• Dictionaries en Python
• Sets en Python
• Tuples en Python
• Funciones de control de flujo / flow control en Python
• Funciones / functions en Python
• Creando y leyendo archivos con Python
• Creando y leyendo archivos de excel con Python
• Conexión a base de datos mysql con python
• Manejo y análisis de datos con Pandas
• Controlar un navegador web con selenium
• Controlar el ratón y el teclado de una computadora con pyautogui
• Crear animaciones con Python en Blender
• Crear una paleta de materiales / colores para el grease pencil de blender 2.8 con python

Sitios de interés

Sitio oficial de Python