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

Enviar por Telegram textos en HTML o Markdown

Se pueden enviar textos con formato HTML o Markdown, pero con muchas limitaciones.

La API de telegram nos indica que los Bots admiten el formato básico de los mensajes. Puede utilizar texto en negrita, cursiva, subrayado y tachado, así como enlaces en línea y código preformateado en los mensajes de sus bots. Los clientes de Telegram los renderizarán en consecuencia. Puede utilizar formato de estilo Markdown o HTML.

Las etiquetas soportadas actualmente son:

<b>bold</b>, <strong>bold</strong>
<i>italic</i>, <em>italic</em>
<u>underline</u>, <ins>underline</ins>
<s>strikethrough</s>, <strike>strikethrough</strike>, <del>strikethrough</del>
<b>bold <i>italic bold <s>italic bold strikethrough</s> <u>underline italic bold</u></i> bold</b>
<a href="http://www.example.com/">inline URL</a>
<a href="tg://user?id=123456789">inline mention of a user</a>
<code>inline fixed-width code</code>
<pre>pre-formatted fixed-width code block</pre>
<pre><code class="language-python">pre-formatted fixed-width code block written in the Python programming language</code></pre>

Este código Python envía un mensaje a un bot de telegram con etiquetas HTML soportadas actualmente por la Api.

import requests
import json
import datetime
import funciones_telegram as ft

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

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

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

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

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"])

Latitud = str(data['coord']['lat'])
Longitud = str(data['coord']['lon'])
Nubes = data['weather'][0]['main']
Descripcion = data['weather'][0]['description']
Temperatura = str(data['main']['temp'])
Sensacion_termica = str(data['main']['feels_like'])
Temperatura_minima = str(data['main']['temp_min'])
Temperatura_maxima = str(data['main']['temp_max'])
Presion_atmosferica = str(data['main']['pressure'])
Humedad = str(data['main']['humidity'])
Visibilidad = str(data['visibility'])
Velocidad_viento = str(data['wind']['speed'])
Direccion_viento = str(data['wind']['deg'])
Abundancia_nubes = str(data['clouds']['all']) + ' %'
Hora_datos = hora_UTC.strftime('%d-%m-%Y %H:%M:%S')
Codigo_pais = data['sys']['country']
Hora_amanecer = amanecer.strftime('%H:%M:%S')
Hora_atardecer = atardecer.strftime('%H:%M:%S')
Poblacion = data['name']
Codigo_poblacion = str(data['id'])

m = '<b>Condiciones climatologicas</b>' + '\n'
m += '<b>Latitud: </b>' + Latitud + '\n'
m += '<b>Longitud: </b>' + Longitud + '\n'
m += '<b>Nubes: </b>' + Nubes + '\n'
m += '<b>Descripción: </b>' + Descripcion + '\n'
m += '<b>Temperatura: </b>' + Temperatura + '\n'
m += '<b>Sensación termica: </b>' + Sensacion_termica + '\n'
m += '<b>Temperatura minima: </b>' + Temperatura_minima + '\n'
m += '<b>Temperatura máxima: </b>' + Temperatura_maxima + '\n'
m += '<b>Presión atmosferica: </b>' + Presion_atmosferica + '\n'
m += '<b>Humedad: </b>' + Humedad + '\n'
m += '<b>Visibilidad: </b>' + Visibilidad + '\n'
m += '<b>Velocidad del viento: </b>' + Velocidad_viento + '\n'
m += '<b>Dirección del viento: </b>' + Direccion_viento + '\n'
m += '<b>Abundancia de nubes: </b>' + Abundancia_nubes + '\n'
m += '<b>Hora cálculo datos: </b>' + Hora_datos + '\n'
m += '<b>Código país: </b>' + Codigo_pais + '\n'
m += '<b>Hora amanecer: </b>' + Hora_amanecer + '\n'
m += '<b>Hora atardecer: </b>' + Hora_atardecer + '\n'
m += '<b>Población: </b>' + Poblacion + '\n'
m += '<b>Código población: </b>' + Codigo_poblacion + '\n'


ft.aviso_mensaje_html(m)

Este código llama a la Api de Open Weather Map y devuelve información meteorologica de las coordenadas enviadas.

Y la función que realiza en envío al bot de telegram:

def aviso_mensaje_html(Mensaje):
    r =requests.post('https://api.telegram.org/bot9987543:CCH0rnTYm3dEp3ryCWTMVXXkxcGemycBgxg/sendMessage',
              data={'chat_id': chat_id, 'text': Mensaje, 'parse_mode' : 'HTML'})
    print(r.text)

Para mensajes en HTML, “parse_mode” debe ser “HTML” y “Markdown” para formatos de texto en Markdown.

En la Api de telegram podrás encontrar más información de los formatos y etiquetas soportados actualmente, enlace.



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