Menú ::13 de agosto de 2022
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.
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
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
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!
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:
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.
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
Al escribir el nombre del dataframe en la línea de comandos y presionar la tecla enter, aparecerá un resúmen de nuestro dataframe:
Como verán, aparecerán unos número que nadie creó: 0, 1 y 2. Esos números corresponden al index / índice de nuestro dataframe. El index de un dataframe puede ser un número o una string y nos permitira hacer operaciones con nuestro dataframe.
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.
Para practicar, 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']
}
)
Este es el resultado:
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)
Y este es el resultado:
Como verán, la columna no tiene nombre...
¿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:
De igual forma podemos crear un dataframe a partir de una lista multidimensional , por ejemplo:
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"])
Y este es el resultado:
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)
Y este es el resultado:
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:
Para ello crearemos una list multidimensional a partir de nuestro diccionario con una iteración:
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
Con ello hemos creado una lista multidimensional:
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"])
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()
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" ])
Y el resultado:
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:
Importar datos desde un archivo csv es bastante sencillo. Para ello utilizaremos el comando:
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:
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
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
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.
Para importar ese archivo .pkl y reconstruir nuestro dataframe usaremos el comando:
mi_dataframe = pd.read_pickle("nombre_de_archivo.pkl")
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
Ejemplo:
Y el resultado:
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
Y el resultado:
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:
Agregaremos la columna peso y asignaremos el valor 0 a todos los registros. Para ello usaremos el comando:
mi_dataframe["nombre_columna"] = valor_a_asignar
Ejemplo:
mi_dataframe["peso"] = 0
El resultado es:
Ahora agregaremos la columna nacionalidad y la dejaremos en blanco, sin datos, para todos los registros. Para ello usaremos el comando:
mi_dataframe["nombre_columna"] = ""
Ejemplo:
mi_dataframe["nacionalidad"] = ""
El resultado es:
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
El resultado es:
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
El resultado es:
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]
El resultado es:
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"]))
Y el resultado será:
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:
Para eliminar una o más columnas de un dataframe utilizaremos el comando:
mi_dataframe = mi_dataframe.drop(["columna_a_borrar", "otra_columna"], axis=1)
Ejemplo:
mi_dataframe = mi_dataframe.drop(["telefono", "posicion"], axis=1)
El resultado es:
El parámetro axis=1 le indica a pandas eliminar una columna. El parámetro axis=0 le indica a pandas eliminar un index.
Otra manera de eliminar una columna es utilizar el parámetro columns. Ejemplo:
mi_dataframe = mi_dataframe.drop(columns=["columna_a_borrar", "otra_columna"])
Ejemplo:
mi_dataframe = mi_dataframe.drop(columns=["estatura", "edad"])
El resultado es:
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:
Es posible eliminar una o más filas tomando como referencia su index, para ello usamos el comando
mi_dataframe = mi_dataframe.drop([index_elemento_a_borrar, index_elemento_a_borrar])
Ejemplo:
mi_dataframe = mi_dataframe.drop([0,10]) # eliminaremos el elemento 0 y 10 de nuestro dataframe
El resultado es:
Es posible eliminar una o más filas tomando como referencia el valor en una de las columnas y si cumple o no una condición, para ello usamos el comando
mi_dataframe = mi_dataframe[mi_dataframe.columna condicion]
Ejemplo:
mi_dataframe = mi_dataframe[mi_dataframe.edad == 27] # eliminaremos los registros cuya edad no sea 27
El resultado es:
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:
Ahora queremos eliminar a todos los que tengan una edad de 27. Ejemplo:
mi_dataframe = mi_dataframe[mi_dataframe.edad != 27] # eliminaremos los registros cuya edad sea 27
El resultado es:
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:
Ahora queremos eliminar a todos los que tengan una edad menor de 27. Ejemplo:
mi_dataframe = mi_dataframe[mi_dataframe.edad > 27] # eliminaremos los registros cuya edad sea 27 o menos
El resultado es:
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!
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:
Haremos una iteración en el dataframe y mostraremos el nombre y la edad. Para ello usaremos el comando:
for registro in range(len(mi_dataframe)): print(mi_dataframe.iloc[registro]['nombre']); print(mi_dataframe.iloc[registro]['edad']);
El resultado es:
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
Y el resultado, un dataframe con los datos de todos los archivo de excel en la carpeta:
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']
}
)
Para sumar los valores de una columna en un dataframe utilizaremos el comando:
mi_data_frame[nombre_columna].sum()
Así para sumar la columna población de nuestro dataframe de ejemplo utilizaremos el comando:
estados['poblacion'].sum()
Para obtener el valor máximo de una columna en un dataframe utilizaremos el comando:
mi_data_frame[nombre_columna].max()
Así para obtener el valor máximo de la columna población de nuestro dataframe de ejemplo utilizaremos el comando:
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()]
Para nuesto caso el código a emplear es:
estados.loc[estados['poblacion'].idxmax()]
El mismo resultado lo podemos obtener con el comando:
estados[estados['poblacion']==estados['poblacion'].max()]
Podemos almacenar el resultado en una variable... Y ahí comenzaremos a detectar algunas diferencias. Para el primer código obtenemos una serie, una especie de list:
resultado = estados.loc[estados['poblacion'].idxmax()] type(resultado)
La serie es una especie de list, así que podemos acceder a sus elementos por el índice / posición que ocupa dentro:
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
Mientras que para el segundo código obtenemos un dataframe:
resultado2 = estados[estados['poblacion']==estados['poblacion'].max()] type(resultado2)
Al ser un dataframe podemos acceder a sus elementos por el nombre de la columna:
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()]
Para nuesto caso el código a emplear es:
estados.loc[estados['poblacion'].idxmin()]
El mismo resultado lo podemos obtener con el comando:
estados[estados['poblacion']==estados['poblacion'].min()]
Podemos almacenar el resultado en una variable... Y ahí comenzaremos a detectar algunas diferencias. Para el primer código obtenemos una serie, una especie de list:
resultado = estados.loc[estados['poblacion'].idxmin()] type(resultado)
La serie es una especie de list, así que podemos acceder a sus elementos por el índice / posición que ocupa dentro:
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
Mientras que para el segundo código obtenemos un dataframe:
resultado2 = estados[estados['poblacion']==estados['poblacion'].min()] type(resultado2)
Al ser un dataframe podemos acceder a sus elementos por el nombre de la columna:
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)
Así para ordenar nuestro dataframe de ejemplo a partir de la columna población de manera descendente utilizaremos el comando:
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()
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)
El resultado de este comando es:
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)
El resultado de este comando es:
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)
El resultado de este comando es:
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)
El resultado de este comando es:
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)
El resultado de este comando es:
En este caso inner excluye los dos registros que no existen en los dos dataframes...
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:
import pandas as pd from pandas_datareader import data import datetime as dt import matplotlib.pyplot as plt
Enseguida definimos la acción a consultar y el periodo de tiempo. En este ejemplo se consultara el valor de la acción de Tesla del 25 de julio de 2022 al 29 de julio de 2022. Par ello se utiliza el comando:
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:
El resultado del comando es un data frame:
Y este es el contenido del dataframe:
El dataframe incluye los siguientes datos de la acción
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']
Y el resultado es:
Con ayuda de matplotlib podemos crear una gráfica. Para ello utilizaremos los comandos:
data1.plot(title='Precio de la acción') #creamos la gráfica plt.show() # mostramos la gráfica
Y el resultado se mostrará en la pantalla:
Este ejemplo es parte de un tutorial más completo que puede consultarse:
Comenta y opina este texto Lee mi libro de visitas
© 1997-2024 Alain García
albegago@hotmail.com
Twitter: 
@feesgo
YouTube 
El vínculo a este documento es:
http://www.alaingarcia.net/weird/python_08_pandas.php
Puedes apoyar a este sitio invitándome a comer...
Este sitio utiliza cookies propias y de terceros para mejorar sus servicios. Si continua navegando, entendemos que acepta su uso. Política de Privacidad