EJECUTANDO CÓDIGO ‘R’ EN PYTHON, CON ‘rpy2’.

‘R’ es un lenguaje de programación, de código abierto, orientado al análisis estadístico, muy popular en la comunidad académica y de investigación, así como en la industria para el análisis de datos y la modelización estadística y que cuenta con una gran cantidad de paquetes y bibliotecas para una variedad de tareas analíticas. Pues bien, hoy vamos a ver un sencillo ejemplo de como utilizar este potente lenguaje dentro de nuestro código Python, haciendo uso de la librería ‘rpy2‘, creada para ser un puente de comunicación entre ambos lenguajes.

Ejemplo de código escrito en ‘R’.

Pero antes de continuar, deberemos asegurarnos de tener instalados todos lo recursos necesarios. Dado que, tal y como ya hemos señalado, ‘rpy2‘ es una librería que conecta nuestro código Python con los recursos y utilidades del lenguaje ‘R‘, tendremos que tener también instalado este último (al final del artículo dejaremos la dirección de la página desde la que realizar la descarga). Por lo que a la librería ‘rpy2‘ se refiere, haremos la instalación por el procedimiento habitual para las librerías de Python:

Instalación de ‘rpy2’ con ‘pip’.

EJEMPLO DE COMO USAR ‘R’ EN PYTHON:

Veamos ahora un sencillo ejemplo en el que nos proponemos realizar un análisis de regresión lineal simple sobre el conjunto de datos ‘mtcars‘ en ‘R‘ ajustando un modelo lineal que predice la eficiencia del combustible (‘mpg‘) en función del peso del automóvil (‘wt‘) visualizando el correspondiente gráfico de dispersión y línea de regresión mediante la librería ‘ggplot2‘ de ‘R‘.

Así, empezaremos creando un nuevo archivo Python en el que, naturalmente, empezaremos importando las librerías y recursos de los que vamos a hacer uso:

Tras ello, procederemos a activar la conversión automática entre ‘pandas‘ y ‘R‘ e instalar los paquetes de ‘R‘ que vamos a usar en el ejemplo. Entre el que se encuentra el paquete ‘base‘ que es el que nos proporciona la tabla de ejemplo ‘mtcars‘ de la extraeremos nuestra información:

Tras ello procederemos a cargar los datos de muestra correspondientes a cada uno de los modelos de vehículos cuya información se recoge en ‘mtcars‘. Para luego, aplicar el modelo de regresión lineal utilizando ‘mpg‘ y ‘wt‘ como variables dependiente e independiente, respectivamente. Esta operación la definiremos usando la sintaxis de ‘R‘ (‘ linear_model <- lm(mpg ~ wt, data = mtcars)‘). Aplicado el modelo, obtendremos los datos resumidos del mismo mediante la función ‘summary()‘ (también en ‘R‘):

Como se puede apreciar, una vez hecha la regresión, volveremos a convertir los datos obtenidos en un dataframe de pandas de modo que podamos imprimirlos en nuestro editor de Python mediante la función ‘print()‘:

Finalmente, pasaremos a mostrar la relación (inversa en este caso) entre ambas variables mediante un gráfico de dispersión al que incorporaremos la línea de regresión. Dicho grafico lo generaremos, usando nuevamente, la sintaxis de ‘R‘ y su librería para graficas ‘ggplot2‘:

OUTPUT:

Relación entre la eficacia del combustible (mpg) y el peso del vehículo (wt).

CONCLUSIÓN:

Para terminar, el uso de ‘R‘ en combinación con Python a través de la interfaz ‘rpy2‘ ofrece una herramienta de gran utilidad para el análisis de datos y su visualización. En este artículo, hemos demostrado cómo cargar datos, realizar un análisis de regresión lineal y generar gráficos de dispersión con líneas de regresión utilizando el conjunto de datos ‘mtcars‘. Por su parte, la capacidad de integrar funciones estadísticas y de visualización de ‘R‘ con la flexibilidad y facilidad de uso de Python abre un amplio abanico de posibilidades para investigadores y analistas de datos, permitiéndoles aprovechar lo mejor de ambos mundos para abordar sus problemas de análisis de datos de manera eficiente y efectiva.

Enlace a la pagina oficial de ‘R’:

https://www.r-project.org

Saludos.

INTRODUCCIÓN AL APRENDIZAJE AUTOMATICO CON ‘SCIKIT-LEARN’ EN PYTHON.

El aprendizaje automático es una rama de la inteligencia artificial, la cual, se ha convertido en una herramienta esencial en la resolución de problemas y la toma de decisiones en una amplia variedad de campos. Desde la detección de fraudes hasta la recomendación de productos y la visión por computadora, el aprendizaje automático desempeña un papel crucial en la automatización de tareas complejas. Python, con su rica colección de bibliotecas, es uno de los lenguajes más populares para trabajar en aprendizaje automático, y ‘scikit-learn‘ es una de las bibliotecas más destacadas en este campo.

En este artículo, exploraremos los conceptos básicos del aprendizaje automático y cómo puedes comenzar a usar ‘scikit-learn‘ para crear tus propios modelos de aprendizaje automático en Python.

¿QUE ES EL APRENDIZAJE AUTOMATICO?

El aprendizaje automático es una disciplina que se enfoca en el desarrollo de algoritmos y modelos que permiten a las computadoras mejorar su rendimiento en tareas específicas a través de la experiencia. En lugar de programar reglas explícitas para realizar una tarea, el aprendizaje automático permite a las máquinas aprender de los datos y hacer predicciones o tomar decisiones basadas en esa experiencia. Este proceso suele constar de una serie de pasos que, a continuación, pasamos a enumerar:

1- Recopilación de datos: Reunir un conjunto de datos que contenga ejemplos y etiquetas. Los ejemplos son las entradas, y las etiquetas son las salidas deseadas.

2- Preprocesamiento de datos: Limpiar, normalizar y transformar los datos para que sean adecuados para su uso en modelos de aprendizaje automático.

3- Selección del modelo: Elegir el tipo de modelo de aprendizaje automático adecuado para la tarea, como regresión, clasificación o clustering.

4- Entrenamiento del modelo: Utilizar los datos de entrenamiento para ajustar los parámetros del modelo y permitir que «aprenda» de estos.

5- Evaluación del modelo: Probar el modelo en un conjunto de datos de prueba para evaluar su rendimiento.

6- Predicción y toma de decisiones: Utilizar el modelo entrenado para hacer predicciones o tomar decisiones en función de nuevos datos.

EJEMPLO DE USO DE ‘SCIKIT-LEARN’.

scikit-learn, a menudo abreviado como ‘sklearn‘, es una biblioteca de código abierto ampliamente utilizada en la comunidad de Python para el aprendizaje automático. Proporciona una amplia gama de algoritmos y herramientas para tareas comunes de aprendizaje automático, como clasificación, regresión, clustering y reducción de dimensionalidad. A continuación, veremos cómo comenzar a trabajar con ‘scikit-learn‘.

Para poder empezar a trabajar con ‘scikit-learn‘ antes deberemos realizar la oportuna instalación de esta librería en nuestro sistema:

Una vez hecha la instalación pasaremos a ver un sencillo ejemplo en el que nos propondremos a crear un modelo para clasificar flores, para el cual usaremos el conjunto de datos ‘Iris‘ y el algoritmo ‘K-Nearest Neighbors (KNN)‘. Para ello, empezaremos importando los recursos de ‘scikit-learn‘ que vamos a necesitar. Donde ‘datasets‘ contiene conjuntos de datos de ejemplo, ‘train_test_split‘ se utiliza para dividir los datos en conjuntos de entrenamiento y prueba, y ‘KNeighborsClassifier‘ es una implementación del algoritmo de ‘K-Nearest Neighbors (KNN)‘ para clasificaciones:

Tras ello, pasamos a cargar el conjunto de datos ‘Iris‘ (el cual, se utiliza habitualmente en ejemplos de aprendizaje automático). En este conjunto, ‘iris.data‘ contendrá las características (o atributos) de las flores, e ‘iris.target‘ contendrá las etiquetas (las clases) que nos indican a que especie de flor pertenece cada conjunto de atributos. Estos datos se almacenarán en la variable ‘X‘ y las etiquetas en la variable ‘y‘:

Una vez que tenemos los datos con los que vamos a trabajar, el siguiente paso será dividir estos datos en un conjunto de entrenamiento (‘X_train‘ e ‘y_train‘) y otro para probar el modelo entrenado (‘X_test‘ e ‘y_test‘). Para establecer esta división usaremos el método ‘train_test_split()‘ en donde mediante el argumento ‘test_size = 0.2‘ estaremos indicando que queremos emplear el 20% de los datos como datos de prueba ( y por tanto, el 80% como datos de entrenamiento ):

A partir de esta división de los datos en conjuntos de entrenamiento y prueba, podemos proceder a la creación entrenamiento y prueba de nuestro modelo:

Para ello, empezamos creando un clasificador ‘KNN‘ (que guardamos en la variable ‘knn‘) con un valor de ‘n_neighbors‘ igual a 3. Indicándole al algoritmo ‘KNN‘ que considere los tres vecinos más cercanos para tomar una decisión de clasificación. Tras ello, usaremos el método ‘fit‘ del clasificador ‘KNN‘ para entrenar el modelo a partir del conjunto de datos de entrenamiento. De esta forma, el modelo aprenderá a asignar los datos de entrada ‘X_train‘ a las etiquetas correspondientes de ‘y_train‘.

Una vez que nuestro modelo esté entrenado, pasaremos a realizar las predicciones. Para ello, podremos utilizar el método ‘predict()‘ que realizará las predicciones en el conjunto de prueba ‘X_test‘, almacenándose estas en la variable ‘predictions‘:

OUTPUT:

Finalmente, calculamos la precisión del modelo comparando las predicciones con las etiquetas reales de prueba ‘y_test‘, mediante el método ‘.score()‘. Mostrándose el grado de precisión:

OUTPUT:

CONCLUSION:

‘scikit-learn‘ es una muy útil librería para el aprendizaje automático en Python, la cual, permite crear modelos de manera sencilla y eficaz. Este artículo ha proporcionado una introducción básica al aprendizaje automático y cómo empezar a trabajar con ‘scikit-learn‘. A medida que explores más, descubrirás que esta librería ofrece una amplia gama de algoritmos y herramientas para abordar una variedad de problemas de aprendizaje automático. ¡Así que no dudes en sumergirte en el emocionante mundo del aprendizaje automático con Python y scikit-learn!

Saludos

FINANZAS CON PYTHON: OBTENER DATOS INTRADIARIOS, CON ‘ALPHA VANTAGE’.

Los datos financieros intradiarios, también conocidos como datos intradía, son una fuente crucial de información para los inversores y traders. Estos datos proporcionan información sobre los movimientos de los precios de las acciones, divisas, criptomonedas y otros instrumentos financieros durante el transcurso de un día de negociación. ‘Alpha Vantage‘ es un servicio en línea que proporciona acceso a datos financieros intradiarios y una variedad de otros datos de la misma naturaleza. En este artículo, exploraremos cómo obtener tales datos, utilizando ‘Alpha Vantage‘ en Python.

Antes de comenzar, necesitaremos una clave de API gratuita de ‘Alpha Vantage’. Lo que nos permitirá acceder a los datos financieros proporcionados por la API. Para ello, podremos registrarnos en el sitio web de Alpha Vantage y obtener su clave de API gratuita.

Una vez que estemos registrados y tengamos nuestra clave, pasaremos a realizar la instalación de la correspondiente librería para Python, empleando el gestor de paquetes de Python, ‘pip‘:

Una vez hecho esto, ya podremos empezar a recopilar datos intradiarios. Para ello crearemos un nuevo archivo al que llamaremos ‘intraday.py‘ en el que después de realizar la pertinente importación de la librería, iniciaremos el objeto encargado de obtener la serie temporal de datos (al que en este ejemplo hemos dado el nombre de ‘ts‘) introduciendo la clave de API, que hayamos obtenido al registrarnos en el servicio:

Una vez que lo tengamos todo correctamente configurado, estaremos en condiciones de empezar a obtener datos intradiarios de cualquier activo. Así, imaginemos que queremos obtener la evolución de los precios de ‘Apple‘, y una periodicidad de actualización de 1 minuto:

OUTPUT:

Hemos de destacar que, al contrario de lo que estábamos acostumbrados cuando trabajábamos con series de datos por días, aquí los datos actualizados se van agregando por la parte superior de la tabla. Siendo por ello que para mostrar los datos más recientes, hemos utilizado la función «.head()» (que muestra las 5 primeras filas de la tabla) y «.tail()» (para mostrar las 5 últimas filas) para ver los 5 registros más antiguos (que en este caso se remontan al 25 de septiembre).

Antes, cuando hemos usado el método ‘get_intraday()‘ para obtener los datos, la información retornada por este ha sido almacenada en dos variables: ‘data’, en la que se ha guardado la serie temporal y ‘meta_data‘, en donde se guardan los metadatos de la serie, con las información por columnas que incluye:

OUTPUT:

Esta información nos puede ser de gran utilidad en el supuesto en que queramos acceder a un dato determinado de forma aislada. Por ejemplo, imaginemos que queremos elaborar una gráfica (utilizando ‘matplotlib‘) a partir de los datos antes obtenidos, mostrando solo el precio de cierre a lo largo de las últimas horas del pasado día:

OUTPUT:

Para concluir: ‘Alpha Vantage‘ es una fuente confiable y gratuita de datos financieros intradiarios que puede utilizar para sus análisis y estrategias de inversión. Con esta librería de Python, es fácil acceder y utilizar estos datos para tomar decisiones informadas en el mercado financiero.

Recuerda que ‘Alpha Vantage‘ ofrece una amplia variedad de datos financieros, no solo datos intradiarios. Pudiéndose explorar sus servicios y bibliotecas adicionales para obtener información más detallada sobre los mercados financieros.

Saludos.

ENCONTRANDO ARCHIVOS DUPLICADOS EN EL SISTEMA, CON «hashlib».

Hace unas semanas estuvimos hablando del módulo «hashlib«, con el que podíamos calcular, (pudiendo elegir entre varios algoritmos) el «hash» de un determinado archivo (el cual hace las veces de identificador único de dicho archivo). También hicimos una lista de posibles utilidades que al uso de dichas claves podíamos dar. Uno de aquellos usos era el de identificar archivos duplicados (entendiendo tales como aquellos que contienen idéntica información) en una base de datos o en un sistema. Así hoy, nos proponemos mostrar un sencillo ejemplo de como localizar dichos archivos duplicados usando «hashlib«.

Para ello, solamente vamos a hacer uso de la librería «hashlib» (con la que iremos calculando el valor «hash» de cada archivo) y el módulo «os» con el que iremos realizando (a partir de un directorio base que deberemos especificar) el recorrido de las carpetas y subcarpetas del sistema.

Así, nuestro script (al que daremos el nombre de «encuentra_duplicados.py«) constará basicamente de dos funciones: Una a la que llamaremos «encontrar_duplicados()» que, tomando como argumento el directorio base, a partir del cual, queremos que se efectúe la búsqueda por todas las subcarpetas, irá guardando todas las direcciones (y sus correspondientes valores «hash») en el diccionario «hash_dict» que definiremos previamente. De modo que si en el recorrido encuentra otro archivo con un «hash» ya almacenado en dicho diccionario, este será incluido en la lista «duplicados» (también definida con anterioridad):

Que duda cabe que para poder hacer la separación entre archivos duplicados y no duplicados en base al valor «hash» del archivo, la función hace una llamada a «calcular_hash_sha256()«. La otra función de nuestro script, encargada de calcular el valor «hash» del archivo, usando en este caso el algoritmo «sha256«:

Como hemos dicho, esta función irá realizando el calculo del valor «hash» de cada archivo (almacenado en la variable «nombre_archivo«) mediante la lectura del mismo en bloques de 64KB y retornando su valor «hash» con «sha256.hexdigest()«.

Finalmente, para que nuestro script funcione, tendremos que iniciarlo, estableciendo el directorio base a partir del cual queremos que se realice la búsqueda (variable «directorio_busqueda«) y la llamada a la función encargada de realizar la búsqueda. Finalmente utilizaremos un condicional para mostrar los resultados en pantalla, listando las rutas de archivos (con su respectivo «hash») que haya encontrado duplicados:

OUTPUT:

Y con esto quedaría visto este sencillo ejemplo de uso práctico del módulo «hashlib» en Python, cuyo código completo podéis examinar en el siguiente enlace:

https://github.com/antonioam82/ejercicios-python/blob/master/encuentra_duplicados.py

Saludos.

USANDO ARBOLES DE DECISIÓN EN PYTHON.

Un «árbol de decisión» consiste en un método de clasificación, ampliamente utilizado en el ámbito del «aprendizaje automático» que nos permite la predicción y clasificación de una variable categórica a través de la construcción de un diagrama en arbol (de donde viene su nombre). Así, en el artículo de hoy vamos a construir nuestro propio arbol de decisión, usando varias librerías («numpy«, «pandas«, «matplotlib» y «sklearn«) siendo esta última la que contiene los métodos y funciones tanto para generar el mismo como para realizar el proceso de clasificación y comprobación de su precisión. Y que como el resto de librerías, deberemos instalar previamente en nuestro equipo (aunque en este caso utilizaremos la plataforma «Google Colab» para la ejecución de nuestros scripts):

Así, lo que nos proponemos a hacer en este ejercicio es, a partir de los datos médicos de una serie de pacientes y de su edad, almacenados en un «csv», determinar que pacientes van a desarrollar una enfermedad. Por ello, lo primero que haremos será cargar la información para ver que contiene. Para la lectura de nuestro archivo «csv» (que lleva por nombre «Pacientes2.csv«) usaremos la función «read_csv()» de la librería «pandas«:

Como puede verse en la imagen, obtenemos un dataset con la información de una serie de pacientes, identificados por un número, de los que se indican la presencia o no (representadas por ‘0’ y ‘1’ respectivamente) de determinadas características (hipertensión, hiperglucemia, si es fumador…), el sexo (codificado nuevamente con ‘0’ y ‘1’) y edad. Finalmente en la columna «Enfermedad» se registra si dicho paciente a registrado o no alguna enfermedad (siendo esta variable la que nos disponemos a predecir).

De este modo lo nos proponemos a hacer es construir un «arbol de decisión» que nos sirva para clasificar (o predecir) la posibilidad o no de desarrollar una enfermedad a partir de unos datos de entrenamiento. Hecho esto, pasaremos a evaluar la precisión del mismo.

A continuación, utilizaremos la función «.info()» para obtener algunos datos generales acerca de nuestro dataset como pueden ser el tipo de dato para cada columna, el número de estas y el número de filas:

Vemos así, que nuestra tabla consta de un total de 11 columnas y 985 filas. Esta información es importante de cara a establecer cuales van a ser nuestras variables predictoras, las filas que vamos a utilizar para entrenar el modelo y las filas que usaremos para testearlo. Empezaremos definiendo las variables predictoras y la variable a predecir:

Para ello, creamos dos objetos (‘X‘ e ‘Y‘) en los que almacenamos las variables predictoras (las cuales definimos con la función «.iloc()» pasándole el rango correspondiente a estas) y la variable a predecir (columna 0). Finalmente usamos «.head()» para mostrar las primeras filas de las variables predictoras (lo mismo podemos hacer para la variable a predecir).

También haremos la división entre los datos de entrenamiento y los datos de testeo. Para lo cual, utilizaremos el módulo «train_test_split» de la librería «sklearn«. Estableciendo a su vez, que emplearemos el 80% de los datos para entrenar el modelo (usando el 20% restante para probarlo):

Usando la función «.info()» aplicada a la variable «X_train» (en la que hemos almacenado los datos de entrenamiento) podemos ver como esta se compone de 788 registros. A continuación, pasaremos a usar estos registros para entrenar el modelo, usando la función «fit()» a la que pasaremos las variables predictoras («X_train«) y la variable a predecir («Y_train«) de nuestros datos de entrenamiento:

Esto nos generará el correspondiente arbol de decisión, el cual, podremos representar gráficamente con la ayuda de la librería «matplotlib» y en el que se muestra el proceso de clasificación de los datos seguido para la creación del modelo predictivo:

OUTPUT:

Por su parte podemos guardar nuestra gráfica como un archivo de imagen, mediante la función «savefig()«:

Viendo la figura generada, se ve como esta se compone de una serie de nodos que a su vez se ramifican en otros. Cada uno de dichos nodos viene representado por una caja en la que se muestra información sobre el mismo:

En cada una de las cajas veremos reflejada en primer lugar, la condición concreta que se ha aplicado en la clasificación del nodo (en el caso de la imagen, si el valor de la variable «hiperglucemia» es menor o igual a 0.5), el índice «gini«, que mide el grado de pureza del nodo (como de ordenados están los datos), el número de pacientes incluidos en el nodo, el número de valores «NO» y «SI«, y la categoría predominante («NO» en este caso).

A su vez, podemos ver las predicciones realizada acerca de la variable dependiente (que recordemos era la correspondiente a la columna «Enfermedad«) para el conjunto de datos de prueba:

Una vez generado el modelo y realizada las predicciones sobre los datos de prueba, pasaremos a comprobar la efectividad y grado de acierto de nuestro modelo, mediante la comparación entre los valores predichos para la variable «Enfermedad» y los datos reales para esta misma. Para esto último usaremos la función «confusion_matrix()» de «sklearn.metrics«:

Obtenemos una matriz en cuyas filas superior e inferior se muestran el numero de filas cuya etiqueta real es ‘NO‘ y ‘SI‘ respectivamente (es decir: que tenemos 150 individuos cuyo valor real es ‘NO‘ y 47 cuyo valor real es ‘SI‘). A su vez en cada columna se muestra los valores predichos como ‘NO‘ y ‘SI‘. Con lo que se deduce que los valores predichos acertadamente por el modelo son los correspondientes a la diagonal principal, los cuales suman 190, mientras que la otra diagonal se correspondería con las predicciones incorrectas (7 en total).

Finalmente, haciendo uso de «numpy» podemos hacer el cálculo, tanto de la precisión global del modelo, así como de la precisión para cada categoría:

Obteniendo así, el valor de precisión (entre 0 y 1) tanto a nivel global, así como para cada una de las clases «SI» y «NO«.

Saludos.

ACCEDIENDO A DATOS METEOROLOGICOS EN PYTHON, CON «meteostat».

Saludos y bienvenidos una semana más a este blog sobre programación en lenguaje Python. En el día de hoy, vamos a hablar de «meteostat» una interesante librería mediante la cual, podremos acceder a los datos meteorológicos recogidos por distintas estaciones alrededor del mundo.

Pero lo primero es lo primero, y antes de empezar a practicar con ella, deberemos proceder a su instalación en nuestro equipo, utilizando el procedimiento que acostumbramos:

Una vez que tenemos instalada la librería en nuestro sistema, podemos comenzar a obtener datos climáticos basados en la información recogida por distintas estaciones meteorológicas en función del área que estemos estudiando. Por ejemplo, digamos que queremos obtener la evolución por días (en una gráfica) de las temperaturas máxima, mínima y media, en el área de París durante el año 2022. Para ello empezaremos importando las librerías de las que nos vamos a valer para ello:

Se ve como, junto a los métodos «Point» (para establecer las coordenadas deseadas) y «Daily» (pues queremos obtener datos diarios) de la librería «meteostat«, realizamos también la importación de «matplotlib» (para graficar los datos), «datetime» (para fijar el periodo de tiempo a estudiar) y «geopy» para obtener las coordenadas del área de estudio. Tras ello, empezaremos utilizando esta última para obtener la latitud y longitud en la que se ubica la ciudad en cuestión:

Como se ve, empezamos creando un objeto («loc«) mediante el cual, vamos a proceder a geolocalizar la ciudad de nuestro interés. Cuya latitud y longitud obtendremos mediante los métodos «latitude» y «longitude» respectivamente. Valores estos que almacenaremos en las variables «lat» y «long«. La segunda información que vamos a determinar es el periodo de tiempo de nuestra serie histórica diaria. Como dijimos, en este caso vamos a mostrar los datos para el año 2022, usando «datetime» para fijar el inicio y el final de la serie temporal, almacenando tales datos en las variables «start» y «end» respectivamente:

Con esta información ya estamos en disposición de obtener nuestros datos meteorológicos para la villa de París. Esto lo haremos utilizando primero el método «Point()» (al que pasaremos la latitud y la longitud antes obtenidas) para fijar el punto concreto cuyos datos climáticos queremos obtener y en segundo lugar, el método «Daily()» (pasándole el punto obtenido, el inicio de la serie temporal y su final) para obtener los datos climáticos diarios para dicho punto en ese intervalo de tiempo:

Obtendremos así, una tabla resumida (con las 5 primeras y 5 últimas filas de la serie) con datos climáticos tales como temperaturas, lluvias, nieve, presión atmosférica, vientos. Para nuestra representación gráfica, vamos a quedarnos solamente con la información referente a las temperaturas media, mínima y máxima (las tres primeras columnas) que pasaremos en una lista como argumento de la función «plot()» de «matplotlib«:

OUTPUT:

Evolución diaria de la temperatura media, mínima y máxima para el área de París durante el año 2022.

Obtendremos de este modo, una visualización de las temperaturas diarias para el periodo especificado.

Con esto hemos visto la manera en que podemos extraer los datos históricos del clima de una región, para un tiempo determinado. Sin embargo, en ocasiones, resulta útil obtener información acerca de las estaciones que hemos utilizado para obtener los datos. Es por ello que «meteostat» incluye un módulo llamado «Stations» mediante el cual, podremos obtener dicha información:

Se nos muestra un tabla con las 12 estaciones cercanas del área de interés (12 por que es el número que hemos introducido como argumento en la función «fetch()«). Hemos de notar que en este caso y por motivos de espacio, la tabla solo muestra 3 de las 16 columnas que la componen (el identificador ID, el nombre de la estación y la distancia). En el siguiente cuadro se muestran el nombre de las 16 columnas que componen las tablas:

No obstante, siempre podemos acceder a la información de cualquiera de las columnas utilizando el procedimiento que conocemos para acceder a las columnas de cualquier dataframe:

Y hasta aquí esta breve presentación de «meteostat» una librería que sin duda nos será de gran utilidad a la hora de recopilar información meteorológica de cualquier parte del mundo, para la realización de cualquier proyecto, estudio o incluso elaboración de modelos predictivos para clima, en Python.

Saludos.

CREACIÓN, MODIFICACIÓN Y CONSULTA DE BASES DE DATOS CON PYTHON Y «SQLITE3».

Bienvenidos, otra semana más, a vuestro blog sobre programación en lenguaje Python. En el día de hoy nos disponemos a aprender la manera de crear, modificar y realizar consultas sobre bases de datos relacionales, usando la librería estándar (lo que quiere decir que no será preciso instalarla en nuestro ordenador) «sqlite3«.

Empezando por lo más básico, lo primero (claro está, después de importar el módulo «sqlite3«) será emplear la función «connect()» para conectar con nuestra base de datos o crearla de no existir esta (como es nuestro caso):

En este caso nos disponemos a crear una base de datos de nombre «new_database.db» que se compondrá de una sola tabla a la que llamaremos «articulos«:

Para la creación de dicha tabla usaremos la función «excute» en la que introduciremos el comando «create table» seguido del nombre de la tabla que queremos crear. Tras esto, crearemos las columnas (que llevarán por nombres «codigo«,descripcion» y «precio«) de la misma, especificando el tipo de dato reservado para cada una. Todo ello lo haremos dentro de una sentencia «try» para evitar que el programa falle en el caso que hallamos cometido algún error. Uno de los cuales puede consistir en intentar crear una tabla ya existente.

No obstante podemos evitar este último error indicando que dicha tabla se cree únicamente en el caso en que no se haya creado aún (para ello añadiremos «if not exists» al comando visto antes):

De modo que de producirse cualquier fallo que nos muestre el mensaje de error, podremos descartar el intento de crear una tabla ya existente, como causa del mismo.

Una vez creada nuestra base de datos y la tabla «articulos» con sus correspondientes filas pasaremos a introducir una serie de valores para los campos «codigo«, «descripcion» y «precio» antes creados :

Como se ve, empezamos creando la conexión con la base de datos (variable «conexion«) a la que luego aplicamos la función «execute» para insertar unos valores a los campos «descripcion» y «precio«, dentro de la tabla «articulos» tal y como se ve en la imagen. Tras ello empleamos «commit()» para actualizar la tabla para finalmente (habiendo terminado) cerrar la conexión con la base de datos.

Si en un momento posterior, queremos tener acceso a los elementos guardados en nuestra tabla «articulos» dentro de la base de datos «new_database.db» con la que estamos trabajando, podemos valernos de un «for» que vaya recorriendo las filas de dicha tabla y vaya mostrando la información almacenada:

Para ello, volvemos a establecer la conexión con la base de datos en la que se encuentra nuestra tabla, y utilizamos la función «execute» para seleccionar la información de las filas «codigo«, «descripcion» y «precio«, sin olvidarnos de especificar la tabla en la que se encuentran («articulos«). Tras ello, usaremos el «for» para mostrar cada uno de los elementos de cada fila mediante la función «print«:

Aquí hemos visto como mostrar toda la información de todos los elementos de la tabla. No obstante, también podemos seleccionar que información mostrar en función de determinados criterios que podemos establecer nosotros. Por ejemplo, el siguiente script nos muestra la información relativa a la descripción y precio de un producto en función del código que introduzcamos en un input:

Como se ve, después de establecer conexión con la base de datos en la que se encuentra la tabla de la que queremos realizar la consulta, usamos la variable «codigo» («where codigo=?»,(codigo, ))«)que usará nuestro programa para seleccionar la descripción y precio del producto correspondiente dentro de nuestra tabla «articulos» («select descripcion, precio from articulos..«). Tras ello, la función «fetchone()» seleccionará la información obtenida y la almacenará en la variable «fila» que luego se mostrará en pantalla con «print()«. Aquí también puede suceder que se introduzca un código que no se encuentre a la tabla. En ese caso «fila=None» y se mostrará el mensaje correspondiente:

De la misma manera, también podemos mostrar la información relativa a varias filas ,de una tabla, que cumplan algún/os requisitos. Así, el siguiente programa muestra el código y descripción de aquellos productos cuyo precio sea inferior al introducido por el usuario:

En este caso llamamos a la función ‘fetchall()‘ de la clase «cursor» que nos devolverá una lista con todas las filas de la tabla que cumplen la condición de tener un precio inferior al ingresado:

Por otra parte, si ninguno de los precios de la tabla es inferior al ingresado por el usuario, (en cuyo caso «len(filas)=0«) se mostrará el correspondiente mensaje que queramos que se muestre:

Veremos más ejemplos sobre manejo y consulta de bases de datos en futuros articulos.

Saludos.