Generar mapas con datos estadísticos, con Python y Plotly

Si necesitas representar diferentes datos estadísticos sobre un mapa del mundo o de un continente o zona del planeta determinado, existe una herramienta muy potente que te permite de forma fácil realizar esta tarea.

Con Python y la librería Plotly podrás mostrar tus datos estadísticos sobre diferentes zonas geográficas.

El código es bien sencillo, y es altamente configurable. Para que Plotly ubique los datos en cada país, es necesario incluir el nombre de dicho país en los datos, el nombre debe estar en formato internacional, por ejemplo “Estados Unidos” debe ser “United States of America“.

import funciones_db as db
import plotly.graph_objects as go
import plotly.offline as opy

datos = db.actores_paises()

fig = go.Figure(go.Choropleth(
    locations = datos['pais'],
    locationmode = "country names",
    z = datos['total'],
    text = datos['pais_a'],
    colorscale = 'Hot',
    autocolorscale = False,
    reversescale = True,
    marker_line_color = '#efefef',
    marker_line_width = 0.5,
    colorbar_ticksuffix = '%',
    colorbar_title = 'Actores',
    )
)

fig.update_layout(
    title_text = 'Número de Actores por Países',
    showlegend = False,
    geo = dict(
        scope = 'world',
        resolution = 50,
        projection_type = 'miller',
        showcoastlines = True,
        showocean = True,
        showcountries = True,
        oceancolor = '#eaeaea',
        lakecolor = '#eaeaea',
        coastlinecolor = '#dadada'
    )
)

fig.show()

En el ejemplo los datos se extraen de una base de datos.

  • locations: Indica el país al que pertenece el dato.
  • locationmode = “country names”: Indica la forma en la que se mostrara la información, es este caso por países. Si llos datos son para un determinado país y quieres mostrar los datos por provincias o estados, se debe cambiar este parametro.
  • colorscale: La paleta de colores que mostrará los datos. Algunas de las paletas disponibles; Brwnyl, Agsunset, Sunsetdark, Magenta, Sunset, Purpor, Purp, Tealgrn, Teal, Bluyl, Aggrnyl, Emrld, Darkmint, Blugrn, Mint, Pinkyl, Peach, Oryel, Redor, Burgyl, Burg, tempo, amp, speed, matter, algae, dense, deep, gray, ice, solar, haline, thermal, turbid, YlOrRd, YlOrBr, YlGnBu, YlGn, Reds, RdPu, RdBu, Purples, Greys, Greens, Rainbow. Lista completa, aqui.
  • scope: Es la parte del globo terraqueo que se mostrará. world, para mostrar todos los continentes. Otros valores para cada continente; “usa” | “europe” | “asia” | “africa” | “north america” | “south america”.
  • projection_type: Es el tipo de mapa que se representará. Admite los siguientes valores; equirectangular, mercator, orthographic, natural earth, kavrayskiy7, miller, robinson, eckert4, azimuthal equal area, azimuthal equidistant, conic equal area, conic conformal, conic equidistant, gnomonic, stereographic, mollweide, hammer, transverse mercator, albers usa, winkel tripel, aitoff, sinusoidal.
  • También es posible personalizar y mostrar/ocultar otros datos del mapa, como la separación de los paises o el color de los oceanos.
  • El código genera un archivo en html, que se abre directamente en el navegador por defecto del sistema.

Algunos ejemplos con Plotly, cambiando los parametros; colorscale, scope y projection_type.

Para visualizar los datos de cada país, tan solo debemos pasar el cursor del ratón por encima de dicho país.

Los mapas pueden ser facilmente incluidos en proyecto de dJango, directamento o a través de javascript.

Plotly es una herramienta muy completa, la cual también permite realizar infinidad de graficas estadisticas a parte de los mapas. Más información de esta completa libreria aqui.



Si encuentras esta noticia interesante la puedes compartir en tus redes sociales, a tus seguidores les puede gustar. Utiliza los botones que tienes más abajo.

Share

Crea un log fácilmente para tus proyectos en Python

Un fichero de registro o log nos permite llevar una cronología de lo que va sucediendo en nuestra aplicación. Podemos registrar con facilidad todos aquellos procesos, fallos y errores que consideramos oportunos, esto nos permite poder encontrar fallos y errores presentes en el script que ejecutamos.

Esta utilidad esta presente en el modulo “logging“. Nos permite crear de forma fácil y rápida los archivos log en nuestros proyectos.

Logging dispone de 5 métodos para notificar los diferentes mensajes:

  • Debug. Normalmente se utiliza cuando estamos desarrollando nuestra aplicación, nos permite depurar el proyecto.
  • Info. Mensajes informativos. Pueden indicar que los procesos se realizan de forma correcta.
  • Warning. Utilizado para realizar advertencias, algo puede no ir bien o causar problemas en un futuro proximo.
  • Error. Algo ha salido mal o el resultado no es el esperado.
  • Critical. Posiblemente el programa deje de funcionar o responder.

Podemos configurar logging para que cree un archivo de texto, en el cual se guardarán los mensajes que vamos colocando en el código.

import logging
from datetime import datetime, date, time

ahora = datetime.now()
fecha_log = ahora.strftime('%d-%m-%Y_%H-%M-%S')

logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s : %(levelname)s : %(message)s',
                    filename = fecha_log + '_registro.log',
                    filemode = 'w',)
  • Level. Nivel del mensaje.
  • Format. El formato en el cual serán guardados los mensajes.
  • Filename. El archivo que contendrá el log.
  • Filemode. El modo del archivo.

Ejemplo del formato de salida de los mensajes:

Ahora solo nos queda añadir la salida de los mensajes en los lugares de nuestra aplicación que consideremos más oportunos, propensos a errores, criticos o simplemente informativos.

El formato para los mensajes es el siguiente:

logging.debug('Información detallada, generalmente de interés solo cuando se diagnostican problemas.')
logging.info('Confirmación de que las cosas funcionan como se esperaba.')
logging.warning('Una indicación de que sucedió algo inesperado o indicativo de algún problema en el futuro cercano (por ejemplo, "espacio en disco bajo"). El software sigue funcionando como se esperaba.')
logging.error('Debido a un problema más serio, el software no ha podido realizar alguna función.')
logging.critical('Un error grave que indica que el programa en sí no puede continuar ejecutándose.')

Aqui, puedes encontrar la documentación oficial de logging.



Si encuentras esta noticia interesante la puedes compartir en tus redes sociales, a tus seguidores les puede gustar. Utiliza los botones que tienes más abajo.

Share

Ejecutar con Python una función con determinados periodos de tiempo

Muchas veces utilizamos crontab para programar la ejecución de un determinado script de python en determinadas horas o fechas. Utilizando crontab, el periodo de tiempo más corto para lanzar un script es de un minuto, si necesitamos realizar procesos con periodos de tiempo más cortos debemos utilizar otras técnicas.

Existen multitud de formas para ejecutar un función que lance los procesos de nuestro script, unas más complejas y sofisticadas, otras más sencillas, que no dependen de funcionalidades ni complementos externos.

Este pequeño ejemplo de script de python, ejecuta una función cada 15 segundos:

import time

while True:
    funcion_a_ejecutar()
    time.sleep(15)
    print("Se Ejecuto!!!")

Este proceso crea un bucle infinito. Ejecuta la función “funcion_a_ejecutar()“, y seguidamente espera a que transcurran 15 segundos, e imprime por pantalla el mensaje “Se Ejecuto!!!“. Al ser un bucle infinito, ejecutara este mismo proceso continuamente.

Existen complementos que realizan tareas similares como pueden ser:

  • InterruptableLoop
  • threading
  • Scheduler

Entre otras muchas opciones disponibles con diferentes librerias de python. Hoy hemos propuesto el sistema más sencillo y sin la necesidad de librerias externas.



Si encuentras esta noticia interesante la puedes compartir en tus redes sociales, a tus seguidores les puede gustar. Utiliza los botones que tienes más abajo.

Share

Gráficas de estadísticas en Python

Hoy en día las gráficas nos permiter mostrar los datos de una forma visual, llamativa y directa, para comprender dichos datos de forma rápida y precisa. por ello son fundamentales en nuestro día a día.

Python dispone de un modulo con el que fácil crear gráficas con multitud de formatos. Una herramienta útil con la que mostrar nuestra información de la forma más clara y efectiva.

Los ejemplos de este post estan realizados con datos ficticios, que representan la publicación de DVDs por años y países. Los datos son extraidos de una base de datos de películas que se encuentra almacenada en Postgresql.

Para realizar las gráficas debemos tener instalados los modulos chartify y pandas.

El código del script es el siguiente:

import chartify
import pandas as pd
import sys
sys.path.append("../Actrices/")
import funciones_db as db


ch = chartify.Chart(blank_labels=True, x_axis_type='linear')

ch.set_title("DVDs por Año") 
ch.set_subtitle("Cantidad de DVDs publicados entre el 2000 y el 2020") 

ch.axes.set_xaxis_label("Año") 
ch.axes.set_yaxis_label("DVDs") 
ch.set_source_label("DVDs publicados")

data = db.DvdYears2()

ch.plot.scatter(
    data_frame=data,
    x_column='year',
    y_column='total')

ch.show()

Este pequeño script genera la siguiente gráfica:

La consulta a la base de datos se realiza de la siguiente forma:

import pandas as pd

def ActrizPaisYear():
    try:
        comm = cx.conectar()
        cursor = comm.cursor()

        query = """
                SELECT ...
                """

        df = pd.read_sql(query, comm)
        return df

    finally:
        if(comm):
            cursor.close()
            comm.close()

Otros ejemplos de gráficas soportadas por chartify son:

ch = chartify.Chart(blank_labels=True, x_axis_type='categorical')

ch.plot.bar(
        data_frame=data,
        categorical_columns='year',
        numeric_column='total',
        categorical_order_ascending=True)

ch = chartify.Chart(blank_labels=True, x_axis_type='linear')

ch.plot.area(
    data_frame=data,
    x_column='year',
    y_column='total',
    color_column='pais',
    stacked=False)
#ch = chartify.Chart(blank_labels=True, x_axis_type='categorical') #Vertical
ch = chartify.Chart(blank_labels=True, y_axis_type='categorical') #Horizontal

ch.plot.bar(
        data_frame=data,
        categorical_columns='year',
        numeric_column='total',
        color_column='year')
ch = chartify.Chart(blank_labels=True, x_axis_type='categorical')

ch.plot.bar(
    data_frame=data,
    categorical_columns=['year', 'pais'],
    numeric_column='total',
    color_column='year',
    categorical_order_by='labels',
    categorical_order_ascending=True)
ch.axes.set_xaxis_tick_orientation('vertical')
ch = chartify.Chart(blank_labels=True, layout='slide_100%', y_axis_type='categorical') 

ch.plot.lollipop(
        data_frame=data,
        categorical_columns=['year', 'pais'],
        numeric_column='total',
        color_column='year',
        categorical_order_by='labels')

Las posibilidades son inmesas, existen multitud de gráficas diferentes para mostrar nuestros datos.

Aquí puedes encontar la documentación de chartify, y aquí, multitud de ejemplos para realizar tus gráficas más espectuculares.



Si encuentras esta noticia interesante la puedes compartir en tus redes sociales, a tus seguidores les puede gustar. Utiliza los botones que tienes más abajo.

Share

Obtener datos de la API Open Weather Map con Python

Existen multitud de servicios que nos proporcionan datos meteorológicos actuales, futuros y pasados. Open Weather Map dispone de un servicio Api Rest desde el cual podemos solicitar diferente información:

  • Datos meteorológicos actuales
  • Pronóstico diario para 16 días
  • Buscar datos meteorológicos
  • Datos meteorológicos históricos
  • Previsión climática a 30 días
  • Datos de pronóstico de 5 días / 3 horas

Para poder utilizar la Api de Open Weather Map, debemos registrarnos en su pagina web, aqui. Aunque se trata de un servicio de pago, podemos utilizarlo de forma gratuita, con ciertas limitaciones. Podemos acceder a determinados servicios, tenemos una limitación de usos diarios, la información proporcionada no es en tiempo real, tiene una pequeña demora, pero gran parte de la información que nos proporciona nos puede ser de gran valor.

También nos sirve para pacticar con una API REST, JSON y Python.

Una vez registrados, en el apartado API keys, disponemos de nuestra key, para poder utilizar el servicio.

El siguiente código en Python hace la llamada a la Api, y nos imprime por terminal todos los datos obtenidos en la solicitud.

import requests
import json
import datetime

url = "https://api.openweathermap.org/data/2.5/weather"


querystring = {"lat":"41.383745","lon":"2.046644","appid":"199eef4c322fac3f30f08bedf2956f9","units":"metric","lang":"38"}

headers = {
    'Cache-Control': 'no-cache'
    }

response = requests.request("GET", url, headers=headers, params=querystring)

print(response.text)

data = json.loads(response.content)

hora_UTC = datetime.datetime.fromtimestamp(data['dt'])
amanecer = datetime.datetime.fromtimestamp(data['sys']["sunrise"])
atardecer = datetime.datetime.fromtimestamp(data['sys']["sunset"])


print('')
print('Condiciones climatologicas')
print('Latitud:', data['coord']['lat'])
print('Longitud:', data['coord']['lon'])
print('Temperatura:', data['main']['temp'])
print('Sensación termica:', data['main']['feels_like'])
print('Temperatura minima:', data['main']['temp_min'])
print('Temperatura máxima:', data['main']['temp_max'])
print('Presión atmosferica:', data['main']['pressure'])
print('Humedad:', data['main']['humidity'])
print('Visibilidad:', data['visibility'])
print('Velocidad del viento', data['wind']['speed'])
print('Dirección del viento:', data['wind']['deg'])
print('Abundancia de nubes:', str(data['clouds']['all']) + ' %')
print('Hora cálculo datos:', hora_UTC.strftime('%d-%m-%Y %H:%M:%S'))
print('Código país:', data['sys']['country'])
print('Hora amanecer:', amanecer.strftime('%H:%M:%S'))
print('Hora atardecer:', atardecer.strftime('%H:%M:%S'))
print('Población:', data['name'])
print('Código población:', data['id'])

Obtenemos los siguientes datos:

La key utilizada en el script no es real, la debes sustituir por la tuya.

Con unas simples lineas obtenemos una serie de datos interesantes. La hora atardecer nos puede servir para controlar un dispositivo remotamente que encienda las luces de nuestro hogar, utilizando una Raspberry Pi o Arduino.

También podriamos lanzar el script a determinadas horas del día y que los datos obtenidos nos sean enviados al correo electronico o a un bot de telegram, entre otras muchas opciones.

Las posibilidades son inmesas, todo depende de nuestra imaginación.



Si encuentras esta noticia interesante la puedes compartir en tus redes sociales, a tus seguidores les puede gustar. Utiliza los botones que tienes más abajo.

Share