Existirá momentos en los que se requiera conocer mas información de un dataframe que permita decir cuántas columnas de tipo entero, fecha, decimal existe en él. Para ello se hace uso de la función info que trae pandas; la sintaxis para su uso es la que se muestra a continuación:

df.info()

¿Cómo se usa?

Bien, mantener el siguiente supuesto: “el csv pruebas” se requiere saber los tipos de columnas que tiene.

En la imagen 1 se puede apreciar que aparece en la terminal el número de indice, se observa una columna con el nombre column donde se indica los nombre de cada una de las columnas que tiene el df (dataframe) y una tercera columna donde se muestra los tipos de datos al que pertenece cada columna del df y finalmente muestra un resumen donde un resumen que indica cuantos columnas de que tipo de dato hay y que espacio esta ocupando en la memoria el df.

El código de ejemplo se encuentra aca en el git

La entrada Pandas y la info del dataframe se publicó primero en Frexus.

df.head(numero_registro)

La sintaxis para mostrar las últimas filas es la que se muestra a continuación:

df.tail(numero_registro)

Usando head y tails

Teniendo un dataframe donde solo se quieren visualizar los primeros cinco registros y los últimas cinco filas. Observe que en la imagen 1, se muestra a la derecha una hoja de calculo 25 registros que se cargaron en el dataframe, pero que al ejecutar la linea

Muestra los primeros cinco registros que coinciden con los que se muestra en la hoja de calculo de la izquierda

df.head(5)

Ahora para mostrar los últimos cinco registros del dataframe se debe de ejecutar lo siguiente:

df.tail(5)

Si se quisiera mostrar los primeros 10 o los últimos 15 solo habrá que cambiar el cinco por 10 y 15 respectivamente, sin olvidar que head es para los primeros y tail para los últimos.

El código fuente de este ejercicio lo encuentras en el git

La entrada Pandas y las primeras – últimos registros se publicó primero en Frexus.

df.rename(columns={'nombre_columna': 'nuevo_nombre_columna', 'nombre_columna2': 'nuevo_nombre_columna2'}, 
                 inplace=True)

No es necesario nombrar a todas las columnas solo a las que se le desea cambiar el nombre, es decir, si se tiene 10 columnas y solo se desea cambiar dos, solo se indica el nombre de la columna, seguido de dos puntos y el nombre nuevo para esa columna. La palabra inplace=True permite que esos cambios se vean reflejado en el dataframe en cuestión.

Suponer que se tiene un dataframe con tres campos en donde tiene por nombre hora, instalados y registrados y se quiere cambiar solo el nombre de registrado a register. Para ello hay que hacer lo siguiente:

1. Leer el csv. Mira aquí para hacerlo.
2. Ejecutar la sintaxis presentada al inicio, quedaría algo así

df.rename(columns= {'registrados': 'register'}, inplace=True

En la imagen uno se pueden observar unas tres cosas:

1. Las lineas de código que se usan para leer un csv y hacer el cambio de nombre de columna.
2. La forma en que se recibe el dataframe con el nombre del campo ‘registrados’ (cuadro superior)
3. La forma en que se realiza la afectación al nombre de la columna del datagrama (cuadro inferior). Ya con el nombre “register”

Notas:

1. Hay que colocar el nombre de la columna que se quiere afectar exactamente cómo se encuentra. Es decir, puede que tenga un espacio en blanco y al ejecutar la función rename de pandas no se vea ningún efecto. O se tenga una letra de más que no se haya visto.

El código fuente de este ejercicio lo encuentras en el git

La entrada Pandas y los renombres se publicó primero en Frexus.

df = pd.read_csv(nombre_fichero)   

Bajo el supuesto de que se quiera leer un archivo con el nombre “pruebas.csv” usando pandas se haría de la siguiente forma:

import pandas as pd
df = pd.read_csv("pruebas.csv")

Con esas dos líneas se tendría el contenido del csv en la variable df. Si al momento de crear el archivo csv se le coloco el separador de la coma (,) o el puto y coma (;), quedaría algo como:

import pandas as pd

df = pd.read_csv('pruebas.csv, sep=',')

df_2 = pd.read_csv('prueba.csv, sep=';')

En la imagen uno se puede observar el uso de una linea donde se incluye el nombre del archivo (hoja de calculo de la izquierda, en formato csv) y el valor de la variable df (a la derecha, a quien se le pasa el contenido del fichero csv) se tiene los mismos datos ahora ya con los valores en la variable df se puede hacer un buen de cosas.

El código fuente de este ejercicio lo encuentras en el git

La entrada Leyendo archivos con pandas en python se publicó primero en Frexus.

¿Qué es eso?

Se debe de recordar que pandas es el nombre de una de las librerías usadas en python que permiten y facilitan la extracción de los datos. Profiling viene ha ser la forma en que se pueden mostrar todos esos resultados. (vea imagen 1).

¿Cómo se uso?

Muy sencillo, bueno desde luego primero hay que instalar la librería y ya después hacer uso de ella.

1. Para instalar panda_profiling has uso del siguiente comando: pip3 install pandas_profiling[notebook,html].
2. Después hay que crear un archivo donde se contenga las siguientes instrucciones:

import numpy as np
from pandas_profiling import ProfileReport
import pandas as pd
df=pd.read_csv('fichero.csv',sep=';')
df.head()
df.describe()
profile=ProfileReport(df)
profile.to_file('Reporte.html')

¿Qué pasa en los import?

Bien, como es costumbre, hay que incluir todas las librerías que se vayan a utilizar, eso es el numpy, pandas y el pandas_profiling.

¿Qué pasa con el read_csv?

Lo que pasa es que se le asigna un nuevo parámetro donde permite hacer uso de los “;” (punto y comas) que regularmente traen los ficheros csv, también se puede hacer uso del parámetro delimiter=”;” el detalle es que en este caso solo lo delimitas hasta donde se encuentre los punto y comas.

¿Qué hace df.head()?

Permite obtener el primer registro del fichero csv, donde se deben de colocar los campos a analizar.

¿Qué hace df.describe()?

Permite hacer un análisis exploratorio muy básico de primera instancia.

¿Para qué sirve el profile=ProfileReport(df)?

Prepara el reporte de todos los datos que hay en el dataframe que se ha pasado al inicio.

¿Qué hace profile.to_file(“Reporte.html”)?

Esta parte de la función permite generar un fichero html, donde mostrará todos las correlaciones entre los campos y datos, así mismo, genera un buen de gráficas e histogramas donde se puede apreciar la aparición de los datos y campos, su interacción y como se puede mezclar.

Conclusiones

Al parecer tiene más ventajas, debido a que genera un fichero html, en el cual es fácil de transportar y compartir con los distintos clientes que requieran un análisis exploratorio más amplio de los datos y mejor uso de las herramientas que tiene, con el fin de aumentar su productividad y la de sus empleados.

En lo particular es una herramienta genial para la generación y presentación rápida de informes o reportes. Permitiendo con un par de lineas de código en python y el dataset (el archivo csv con todos los datos) podan ser apreciados de una mejor manera. Mucho más fácil de manejar / presentar. Y se deja de lado la técnica milenaria de usar una hoja de calculo para su apreciación.

La entrada Python, los pandas y sus profiling se publicó primero en Frexus.

Preparación del ambiente

Para poder agilizar las cosas, es de cierta manera necesario hacer uso de panda una librería escrita para la extracción y análisis de datos. O al menos para esta prueba de concepto se utilizo, también hay que instalar la librería shimoku, desde una terminal ejecutando los siguientes comandos:

sudo apt install python-pip
pip install pandas
pip install shimoku-api-python

Nota: es importante que la versión de python sea superior a la tres. Preferentemente la 3.9.x

La línea sudo apt install python-pip permite instalar las herramientas para hacer más fácil la instalación de librerías de python.

La línea pip install pandas, es la librería para la extracción y análisis de datos.

la línea pip install shimoku-api-python, permite instalar la biblioteca, de shimoku.

Importando las librerías

Las siguientes líneas de código en python permiten la importación de las librerías necesarias, se puede observar que se utiliza shimoku_api_python y se le asigna un alias Shimoku. Lo mismo para pandas con su alias pd, numpy con el alias np. Cabe aclarar que numpy se instala por defecto con la instalación de pandas.

from os import getenv
from typing import Dict, List
import shimoku_api_python as Shimoku
import pandas as pd
import numpy as np

Cargando Datos

En las siguientes líneas de código se puede observar que se hace uso de la función de lectura de un archivo de panda este fichero contiene los datos para la prueba, se calcula los valores mínimos y máximos, se convierten a string para posteriormente mostrarlo como indicadores.

df = pd.DataFrame = pd.read_csv('datos.csv') #cargando datos del archivo
print('cargando datos df') #avisando en la terminal
valorMaximo=df.max() #calculando el máximo
valorMinimo=df.min() #calculando el mínimo
imax= str(valorMaximo[1]) #convirtiendo a string los valores máximos y mínimos de las 
rmax= str(valorMaximo[2]) #columnas instalado y registrado.
imin= str(valorMinimo[1])
rmin= str(valorMinimo[2])

Variables de ambiente para shimoku

html=(
      "<p style='background-color: '#daf4f0';>"
      "<b>Descripcion</b>: Esta grafico permite mostrar los picos de "
      "instalaciones y registros, realizados durante un dia de trabajo.</p>"
     )
env='prod'
menu_path="PruebaConcepto/Reporte"
acces_token  = getenv(env,'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
universe_id: str = getenv(env,'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx')
business_id: str = getenv(env,'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx')

En las líneas anteriores se encuentran las variables que se requiere para que se autentique y se envíen los datos a la API de shimoku.

Configuración

Se observa en las siguientes líneas se muestra la configuración de la comunicación del cliente con shimoku. También se nota el uso de un par de las variables configuradas anteriormente.

shimoku = Shimoku.Client(
    config={'access_token': acces_token},
    universe_id = universe_id,
    environment='production',
)

Creando una gráfica

shimoku.plt.set_business(business_id)
report: Dict = shimoku.plt.bar(
    df,x='hora', y=['instalado','registrados'],
    menu_path=menu_path,
    order=0,
    title='Instalaciones y Registros',
)

Se observa que con las líneas anteriores se genera una gráfica de barra, los datos se obtiene de la variable df, que se cargo con el dataframe, del archivo que se leyó con panda. Se debe de notar que en el eje de las equis, se colocara las horas y en el eje de la (y) los valores mínimos y máximos que se tengan de los servicios instalados o registrados. El menu_path, se refiere a la ubicación donde se encontrará la gráfica o el reporte en cuestión; esta variable fue declarada mas arriba. El valor de order, depende de la posición que se vayan a colocar los elementos (gráficas, indicadores, mas gráficas, html, entre otros.) En el title, va a colocarse el título de la gráfica.

Cargando el html

Para esta prueba de concepto, se quiere hacer uso del html, esto es de la variable que html, donde con el siguiente código se le envía o carga a shimoku. Se debe de observar que, se colocará en el mismo menu_path, lo diferente aquí es que el order, ya esta en la posición 1, que indica que se colocará después de la gráfica. rows_size, indica en que posición de las filas comenzará, lo mismo para cols_size, solo que esté indica las columnas.

shimoku.plt.html(
    html=html,
    menu_path=menu_path,
    order=1, rows_size=2, cols_size=12,
)

Creando indicadores

La siguientes líneas de código muestran la creación de cuatros indicadores, a los que corresponde los máximos y mínimos servicios instalados, así como los registrados. Para todos los casos se le asigno un color, un título, una alineación y un valor, el cual se calculo con la función min y max de panda.

data_=[
    {
       "description":"",
       "title":"Max.Instalado",
       "value":imax,
       "align":"center",
       "color":"red",
    },
   {
       "description":"",
       "title":"Max.Registrado",
       "value":rmax,
       "align":"center",
       "color":"success",
   },
   {
       "description":"",
       "title":"Min.Instalado",
       "value":imin,
       "align":"center",
       "color":"blue",
   },
   {
       "description":"",
       "title":"Min.Registrado",
       "value":rmin,
       "align":"center",
       "color":"orange",
   },
]

Cargando indicadores

En las posteriores líneas de código se muestra la manera en que se cargan o envían los datos de los indicadores a shimoku. Si todo sale bien se habrá creado un reporte en el que se incluye una gráfica de barras interactiva, una descripción de la gráfica en html y cuatro indicadores en diferentes colores.

shimoku.plt.indicator(
    data=data_,
    menu_path=menu_path,
    order=2,
    rows_size=2, cols_size=12,
    value='value',
    header="title",
    footer='description',
    align='align',
    color='color',
)

Finales

Este es el código completo donde se realiza un reporte sencillo, observe la imagen 1 es como se visualiza los datos. Es importante aclarar que las credenciales hay que solicitarla mediante la página shimoku.io. Los archivos originales se encuentran en el github se puede acceder desde aqui

from os import getenv
from typing import Dict, List
import shimoku_api_python as Shimoku
import pandas as pd
import numpy as np
df = pd.DataFrame = pd.read_csv('datos.csv')
print('cargando datos df')
valorMaximo=df.max()
valorMinimo=df.min()
imax= str(valorMaximo[1])
rmax= str(valorMaximo[2])
imin= str(valorMinimo[1])
rmin= str(valorMinimo[2])
# codigo shimoku
html=(
      "<p style='background-color: '#daf4f0';>"
      "<b>Descripcion</b>: Esta grafico permite mostrar los picos de "
      "instalaciones y registros, realizados durante un dia de trabajo.</p>"
     )
env='prod'
menu_path="PruebaConcepto/Reporte"
acces_token  = getenv(env,'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
universe_id: str = getenv(env,'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx')
business_id: str = getenv(env,'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx')
print('Entornos creados')
shimoku = Shimoku.Client(
    config={'access_token': acces_token},
    universe_id = universe_id,
    environment='production',
)
print('Cliente configurado')
shimoku.plt.set_business(business_id)
report: Dict = shimoku.plt.bar(
    df,x='hora', y=['instalado','registrados'],
    menu_path=menu_path,
    order=0,
    title='Instalaciones y Registros',
)
print ('Grafica generada')
shimoku.plt.html(
    html=html,
    menu_path=menu_path,
    order=1, rows_size=2, cols_size=12,
)
print ('Html generado')
data_=[
    {
       "description":"",
       "title":"Max.Instalado",
       "value":imax,
       "align":"center",
       "color":"red",
    },
   {
       "description":"",
       "title":"Max.Registrado",
       "value":rmax,
       "align":"center",
       "color":"success",
   },
   {
       "description":"",
       "title":"Min.Instalado",
       "value":imin,
       "align":"center",
       "color":"blue",
   },
   {
       "description":"",
       "title":"Min.Registrado",
       "value":rmin,
       "align":"center",
       "color":"orange",
   },
]
print ('cargando indicadores')
shimoku.plt.indicator(
    data=data_,
    menu_path=menu_path,
    order=2,
    rows_size=2, cols_size=12,
    value='value',
    header="title",
    footer='description',
    align='align',
    color='color',
)
print ('DataWebApp creada')

El código fue generado con el manual de shimoku, se puede acceder desde aquí

La entrada Shimoku | Prueba de concepto se publicó primero en Frexus.