TRABAJANDO CON ZONAS HORARIAS EN PYTHON.

Hola y bienvenidos nuevamente a este blog sobre programación en lenguaje Python. En el día de hoy nos disponemos a ver como podemos obtener la hora actual, no solo en nuestra región, sino también en otras zonas regiones del mundo, para lo cual necesitaremos instalarnos una librería externa de nombre ‘pytz‘. Visto esto, aplicaremos lo aprendido a un caso práctico en el que programaremos un reloj que además de la hora local, pueda mostrarnos la hora correspondiente a otras zonas horarias:

Como hemos señalado, lo primero será instalar ‘pytz‘, librería que nos permitirá ver la fecha y hora de distintas franjas horarias:

Pero antes, empezaremos viendo como podemos usar esta librería para mostrar la hora actual correspondiente a una región determinada. Para empezar empezaremos recordando como obtener la hora local, para lo cual, nos basta con usar el módulo ‘datetime‘ incluido en Python y su función «now()«:

Como se ve, mediante este método obtenemos tanto la fecha (en formato «YYYY-MM-DD») como la hora actual representada en horas, minutos y segundos. Ahora para obtener esa misma información, usaremos la librería ‘pytz‘ que acabamos de instalar:

Como se ve, empezamos usando nuevamente la función «now()» del módulo «datetime» solo que en este caso, pasandole un método «.timezone()» en el que hemos indicado la región concreta cuya hora y fecha queremos conocer. Lo que nos devolverá la fecha y hora (junto a su diferencia con respecto a la hora global «UTC«) de la región en cuestión.

Una vez, que sabemos como obtener la hora (y fecha) actual correspondiente a otras zonas horarias) estamos en condiciones para crear nuestro reloj capaz de mostrar, además de la hora local, la correspondiente a otras regiones. Para agilizar el proceso, partiremos del código que usamos en su momento para crear un reloj digital con ‘tkinter‘ (y cuyo artículo también podéis consultar) al que hemos introducido algunas modificaciones, siendo la primera de ellas, la de importar la librería ‘pytz‘ además de las usadas en su momento:

Tras ello declararemos la clase «WorldClock» que contendrá nuestra aplicación y sus métodos. En este punto también definiremos el diccionario «self.locations()» en el que emparejaremos cada ubicación con su correspondiente zona horaria. Diccionario a partir del cual generaremos el contenido de la lista desplegable de regiones con la que contará nuestra interfaz, usando la función «set_locations()» :

Finalmente, definiremos la función «time()» que obtendrá y mostrará la hora actual actualizándose cada 200 milisegundos (0,2 segundos), usando ‘datetime‘ y ‘pytz‘ (en el caso en que esté seleccionada una ubicación distinta de la local):

En el siguiente enlace podéis consultar el código completo de la aplicación:

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

A su vez, aquí podéis ver el articulo referente a la creación del reloj digital, original tomado como base para este ejercicio:

RELOJ DIGITAL EN PYTHON, CON «time» Y «tkinter»

Saludos.

INVERSIÓN DE IMAGEN EN VÍDEOS CON PYTHON Y FFMPEG.

FFmpeg es una excelente herramienta a través de la cual podemos efectuar un amplio abanico de acciones relativas a la manipulación y edición de archivos de vídeo y audio, y aunque ya hemos hablado de esta en artículos anteriores, aún son muchas las posibilidades que ofrece y que nos queda por cubrir. Por ello, hoy vamos a ver como podemos usarla para invertir la imagen (tanto en horizontal como en vertical) de un archivo de vídeo. Para nuestro ejercicio, usaremos como ejemplo el archivo «traffic.mp4» y la implementación en Python de «FFmpeg» que deberemos instalar previamente en nuestra computadora:

INVERSIÓN HORIZONTAL.

La primera operación que vamos a realizar es la es el de cambiar la orientación horizontal de la imagen de nuestro video. FFmpeg, nos permite hacer esto en tan solo unas pocas líneas de código, usando «hflip()» para realizar la inversión:

OUTPUT:

INVERSIÓN VERTICAL.

Del mismo modo podemos también, invertir verticalmente la imagen del video. Para ello seguiremos la misma secuencia que en el caso anterior solo que en este caso, usando la función «vflip()«:

OUTPUT:

INVERSIÓN CON AUDIO.

Cuando trabajamos con videos en los que haya audio, para conservar este, debemos especificar una variable a parte en la que se almacenará dicho audio (la extracción del audio la realizaremos con el método «.audio«) de modo que incorporemos dicho audio, al final del proceso, cuando usamos la función «.output()«. En este caso, almacenaremos la información relativa al audio y al video, por separado, en las variables «audio» y «stream» respectivamente:

Lo que nos generará un video de imagen invertida, solo que esta vez, conservando su correspondiente audio.

Tal y como señalamos al comienzo de este artículo, son muchas las posibilidades que, en materia de manipulado de archivos de video y audio, las que ofrece «FFmpeg«, las cuales, iremos desarrollando en futuras entradas del blog.

Saludos.

EXTRAER TEXTO DE ARCHIVO DE VIDEO, CON PYTHON.

Hola y bienvenidos nuevamente a este, vuestro blog sobre programación en Python, en una ocasión en la que nos disponemos a realizar un sencillo ejercicio consistente en la extracción de texto desde un archivo de vídeo. Para lo que vamos a necesitar las librerías ‘moviepy‘ y ‘speechrecognition‘ (de las que ya hablamos en sus respectivos artículos) y que deberemos empezar importando a nuestro archivo ‘.py‘:

A continuación pasaremos a realizar la extracción del texto en dos fases: En la primera de ellas usaremos la librería ‘moviepy‘ para llevar a cabo la lectura de nuestro vídeo, incluyendo la extracción del audio del mismo (que guardaremos en un archivo de audio) para, a continuación realizar el reconocimiento del texto que pueda haber endicho audio, mediante la librería ‘speechrecognition‘, texto reconocido que finalmente guardaremos en un archivo de texto:

Por lo tanto, lo primero que haremos será cargar el vídeo(llamado ‘my_video.mp4‘) para su lectura, cuyo objeto guardaremos en la variable «clip» tal y como se ve en la imagen:

A continuación utilizaremos los métodos ‘.audio‘ (para extraer el audio del vídeo) y ‘write_audiofile()‘ para crear un archivo con dicho audio (al que llamaremos ‘extracted_audio.wav‘):

Hasta aquí el proceso de extracción del audio de nuestro vídeo, en el que hemos usado los recursos y métodos de ‘moviepy‘. A continuación, pasaremos a usar ‘speechrecognition‘ para detectar el texto presente en el archivo de audio generado. Para ello comenzaremos iniciando el reconocedor de texto del siguiente modo:

Una vez definido nuestro identificador de texto, pasaremos a cargar nuestro recién creado archivo de audio ‘extracted_audio.wav‘ usando el método ‘.AudioFile()‘ para a continuación realizar la lectura de su contenido empleando ‘.adjust_for_ambient_noise()‘ para eliminar el ruido de fondo o sonido no traducible a texto, que pueda contener:

Hecho este paso intermedio, que en el que hemos recopilado la información del audio (eliminando ruido de fondo) en la variable ‘audio_file‘, pasaremos a usar el método ‘recognize_google()‘ para leer el texto del mismo, especificando el idioma del mismo («language=’es_ES’«), guardando dicho texto en una nueva variable (‘result‘):

Y finalmente, generaremos nuestro archivo de texto a partir de la información guardada en ‘result‘:

Escrito nuestro código, pasaremos a su ejecución:

Lo que nos generará en nuestro directorio de ejecución, un nuevo archivo de texto ‘recognized_text.txt‘ con el texto detectado durante la ejecución:

Saludos.

OBTENIENDO TIPOS DE CAMBIO CON PYTHON.

Saludos y bienvenidos una vez más a vuestro blog sobre programación en lenguaje Python, en una ocasión en la que nos disponemos a escribir un código (que podéis ver completo en el enlace que proporcionamos al final) mediante a partir de una divisa y cantidad de entrada, podemos obtener la conversión de dicha cantidad a las principales monedas mundiales. Para nuestro objetivo usaremos la información actualizada que nos brinda la página «x-rates.com» a la que podéis acceder desde el siguiente enlace:

https://www.x-rates.com/

Como vamos a tener que usar información alojada en la web, empezaremos importando una serie de módulos y librerías de Python que nos permitan acceder y leer dicha información. A su vez, también importaremos «pprint» que nos permitirá visualizar los datos de salida de un modo más atractivo:

A continuación crearemos la función mediante la que accederemos a nuestros datos de interés. Dicha función tomará dos argumentos: La divisa que queremos convertir y la cantidad (que estableceremos en 1). Partiendo de dichos argumentos, usaremos «requests.get()» para acceder a la información deseada:

Tras ello, iniciaremos «BeautifulSoup» y obtendremos las cifras de cambio actualizadas:

Finalmente procederemos a leer la tabla proporcionada por la página, no sin antes definir el diccionario «exchanges_rates» en el que almacenaremos los pares formados por la divisa y el valor de cambio con respecto a la variable «currency«:

Así nuestra función nos devolverá, por una parte, la fecha de última actualización de los valores (‘price_datetime’) y por otra el el cambio actual para cada divisa (‘exchanges_rates‘). Para realizar nuestra consulta, solo nos queda hacer la llamada a la función, especificando tanto la divisa base (que en nuestro ejemplo será el EURO (‘EUR’)) y la cantidad que será de 1€, usando ‘print‘ para mostrar la fecha de última actualización y ‘pprint‘ para mostrar la lista de cambios con respecto al EURO:

Output:

En el siguiente enlace tenéis el código completo del ejercicio, para que podáis crear vuestra propia aplicación para obtener el tipo de cambio de cualquier divisa:

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

Saludos.

PIXELANDO IMAGEN EN PYTHON, CON «PIL».

A lo largo de las numerosas entradas que acumula este blog, hemos ido viendo distintas operaciones y efectos que podemos aplicar sobre imágenes haciendo uso de librerías tales como opencv o PIL. Siguiendo con esa costumbre, hoy veremos como usar esta última para aplicar, en pocas líneas de código, un efecto de pixelado sobre la siguiente imagen:

Para ello, empezaremos importando la librería PIL (que deberemos tener previamente instalada en nuestro equipo) y cargando la imagen en cuestión, mediante Image.open() introduciendo la ruta al archivo. A su vez, podemos emplear el método .size() para obtener las dimensiones de la misma:

Output:

Tras ello, procederemos a generar una versión reducida (de16x16 pixeles) de la imagen original empleando el método resize() y el método BILINEAL tal y como se muestra a continuación:

Almacenada la versión reducida en imgSmall volvemos a redimensionar dicha imagen a su dimensiones originales (img.size) usando en este caso el método NEAREST, obteniendo el efecto deseado que guardaremos mediante el método .save():

Output:

A su vez, podemos cambiar la resolución del resultado, modificando las dimensiones que introducimos como primer argumento en la función resize() a la hora de crear la versión reducida de la original. Así, veamos que resultados obtenemos al aplicar redimensionados al 32×32, 8×8 y 2×2:

Otro aspecto que se verá afectado por la dimensiones que escojamos en el redimensionado, es la relación alto ancho de las celdas (o pixeles) de la imagen resultante ya que, en el caso de que ambos valores sean iguales (como en los ejemplos anteriores) la relación ancho alto de las celdas será la misma que el ancho alto de la imagen global original. No obstante, si aplicamos un redimensionado en el que dichos valores no son iguales, por ejemplo de 20×400 obtendremos un resultado como este:

Output:

Hemos visto así, una sencilla manera en la que podemos aplicar efectos de pixelado sobre una imagen, haciendo uso de la librería PIL y que podremos usar en nuestros proyectos de edición de imagen con Python.

Saludos.

NUEVOS EJERCICIOS CON ARRAYS EN «numpy».

Hace ya algún tiempo estuvimos viendo el manejo del módulo «numpy» para realizar operaciones básicas con arrays en Python. Hoy seguiremos aquella línea para extraer determinadas informaciones que pueden sernos de utilidad para el análisis de series de datos dispuestos en filas y columnas.

Para ello, recordar que debemos tener instalada la librería «numpy» en nuestro dispositivo. De no tenerla, podemos usar el comando «pip install» en Windows:

GENERACIÓN DE ARRAYS:

Instalado numpy podemos empezar nuestras practicas creando un sencillo array que conste únicamente de una lista de elementos:

Podemos crear arrays más complejos compuestos por más de una fila de elementos. Para ello usaremos una estructura que ya conocemos, como argumento, las tuplas:

A su vez, podemos crear arrays de valores no incializados (arrays vacíos) con el método «empty» pasando como argumento una tupla con el número de filas y columnas que queremos que tenga este:

Además de arrays no iniciados, existen otros métodos, como «zeros()» y «ones()» con los que podemos generar arrays compuestos únicamente de ceros y unos respectivamente (tanto en un caso como ene el otro, usaremos la tupla de dos valores para indicar el número de filas y columnas, tal y como hacíamos en el ejemplo anterior):

Tal y como se ve en el ejemplo, los valores del array se nos devuelve, por defecto, en formato decimal. No obstante, podemos usar el atributo «dtype» para cambiarlo:

Hemos visto como generar arrays de un único valor y arrays vacíos, pero «numpy» también cuenta con un método «random» que nos permite crear arrays de valores aleatorios entre0 y 1, especificando como viene siendo habitual, el número de filas y columnas:

A su vez, podemos usar «.randint» para generar un array aleatorio de valores dentro de un rango especificado por nosotros:

MÉTODOS CON ARRAYS:

Vistos algunos de los métodos para generar arrays con «numpy«, podemos pasar a ver algunas operaciones que podemos realizar con los elementos, distribuidos en filas y columnas, que los componen. Para nuestro ejemplo partiremos de un array de 5 filas y 6 columnas, compuestos por valores entre 0 y 10:

Una de las primeras y más básicas operaciones que podemos realizar es la suma total de los valores que componen nuestro array. Para lo que usaremos el método «sum()» sin necesidad de introducir ningún argumento:

Por otra parte, también podemos obtener la suma de los valores de cada columna. En este caso al método anterior le añadiremos la variable «axis» con valor igual a 0, para obtener una lista con la suma de valores de cada columna:

Lo mismo podemos hacer para obtener la suma por filas, solo que en este caso, el valor de «axis» será igual a 1:

Otra información interesante que podemos obtener son los valores máximo (con el método «max()» y mínimo (método «min()«), por filas y columnas, en combinación con los respectivos valores de «axis«:

En ocasiones, lo que nos interesará será almacenar dichos valores máximo/mínimo, en alguna variable. Razón por la que nos será útil obtener la posición de estos dentro del array, usando los métodos «argmax()» y «argmin()«:

Otro computo interesante que podemos efectuar por filas, columnas y para todo el array, es el cálculo de la media. Para ello usaremos el método «mean()«. Este cálculo, aplicado al array anterior se podría ver así:

Además de la media, también podemos obtener la lista de valores del array que están por encima y por debajo de dicha media:

El mismo procedimiento podemos emplear para obtener la desviación estandar (o típica). Solo que en este caso usaremos el método «std()«:

Y hasta aquí este repaso a algunos de los métodos que podemos usar, para extraer información útil de series de datos dispuestos en filas y columnas, los cuales, pueden sernos de gran ayuda a la hora de efectuar análisis para nuestros proyectos.

Saludos.

DIBUJANDO LOGO DE «Windows 10» CON PYTHON Y TURTLE.

Bienvenidos una vez más a vuestro blog sobre programación en lenguaje Python, en una ocasión en la que vamos a ver, paso a paso, como podemos recrear la ventana del logo de ‘Windows 10‘ usando el módulo de dibujo ‘turtle‘:

Para ello, lo primero será importar el módulo ‘turtle‘ para luego iniciarlo y crear nuestra área de dibujo con ‘.Turtle‘ y ‘.Screen‘:

Output:

Creada nuestra área de dibujo, con su correspondiente puntero, empezaremos a trazar nuestra figura, no sin antes establecer el color del fondo y la velocidad a la que se moverá el puntero:

Output:

Pasemos ahora a trazar nuestra primera línea, estableciendo la dirección de nuestro puntero hacia arriba (‘t.penup()‘), el punto dentro del área al que queremos movernos, (con ‘t.goto()‘) y el color de la línea a trazar definido en formato hexadecimal:

Output:

A continuación lo que haremos será dibujar los contornos del logo, para luego rellenarlo de azul. Para ello, antes de dibujarlos, usaremos ‘begin_fill()‘ para indicarle a nuestro programa que vamos a crear una figura que luego rellenaremos (de azul en este caso) con ‘end_fill()‘:

Output:

Creada la figura a rellenar, practicaremos el rellenado usando ‘end_fill()‘ tal y como dijimos:

Output:

A continuación, desplazaremos nuevamente al puntero para después trazar una línea (cambiando el color a negro) con un grosor de 10 (que estableceremos mediante el método ‘.width()‘):

Output:

El mismo proceso utilizaremos para trazar la línea horizontal, completando así nuestro logo:

Output:

En el siguiente enlace tenéis el código completo del ejercicio:

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

Saludos.

ALGORITMOS EN PYTHON: BUSQUEDA BINARIA.

En programación no son pocas la ocasiones en las que podemos necesitar que en un momento dado, nuestro programa realice la búsqueda de un elemento dentro de una lista ordenada (piénsese en una aplicación web en la que el nombre de usuario introducido he de buscarse en una base de datos). Este es un proceso que, para el caso de listas de pocos elementos, puede efectuarse con una simple búsqueda lineal (recorriendo la lista elemento a elemento). el problema surge cuando debemos hacer dicha búsqueda en listas extensas (de centenares, miles..de elementos) en el que dicho método de búsqueda se revela ineficiente, al hacer más lento (y con un mayor consumo de recursos) la ejecución de nuestro programa. Siendo en estos casos, más adecuados otros procedimientos como la «búsqueda binaria» del que hoy vamos a hablar e implementar en Python.

QUE ÉS Y COMO FUNCIONA:

También llamada «búsqueda de intervalo medio» o «búsqueda logarítmica«, la «búsqueda binaria« es un algoritmo que se emplea para localizar un elemento dentro de una lista o array, ordenada en el que se empieza tomando el valor del punto medio de la misma, comparándolo con el valor buscado, de modo que si ambos no coinciden se determina en cual de las dos mitades puede encontrarse el valor, desechándose aquella en la que no puede estar y repitiendo el proceso con la otra, hasta dar con dicho valor o concluir que este no se encuentra en la lista.

Veamos un sencillo ejemplo, para ilustrarlo mejor, en el que nos proponemos buscar un valor (en este caso, el 6) dentro de una lista de 7 valores numéricos ordenados de menor a mayor, cuyas posiciones se cuentan de 0 a 6:

Para la búsqueda de dicho valor daremos, en este caso, tres pasos:

1- Realizamos la comparación entre el valor buscado (2) y el elemento que ocupa la posición central dentro de la lista (8). Viéndose que este es mayor que dicho elemento buscado, lo que significa (en una lista ordenada de menor a mayor) que dicho valor (de encontrarse en la lista) estará entre los valores posicionados a la izquierda del valor central.

2- Se repite el proceso anterior con los valores de la izquierda, tomándose su elemento central (ahora el 4) y repitiéndose la misma comparación viéndose que 2<4 con lo que este tendrá que estar, otra vez, a la izquierda del valor central.

3- Finalmente llegamos al punto en al que solo queda un valor, que es (viendo el resultado de la comparación) precisamente, el buscado (2=2) con lo que queda así verificada su existencia en la lista, e identificada su posición (0).

Es posible que más de uno piense que este caso concreto podría haberse resuelto de modo más rápido mediante una búsqueda lineal al darse la doble circunstancia de tratarse de una lista de pocos elementos y hallarse el valor buscado, en la primera posición de la lista (de hecho habría bastado con un solo paso. Sin embargo no hay que olvidar que se trata de un sencillo ejemplo para ilustrar el método que emplearemos cuando tengamos que trabajar con listas extensas, en donde el elemento a buscar podrá en cada ocasión estar en cualquier posición de la misma.

Nota: En este artículo nos centramos en la búsqueda de valores numéricos, no obstante hay que recordar que este procedimiento podría aplicarse a la búsqueda de palabras en una lista, pues lo valores de comparación valen igualmente para caracteres alfabéticos. Lo importante es que nuestra lista esté ordenada.

IMPLEMENTACIÓN EN PYTHON:

A continuación vamos a ver un sencillo ejemplo de implementación de este algoritmo, usando la sintaxis de Python. En esta ocasión vamos a trabajar con una lista de 20 valores (con posiciones de 0 a 19) en la que (a diferencia del caso anterior) vamos a contemplar el peor escenario posible, en el que el valor a buscar será precisamente el ubicado al final de la lista. De todos modos, empezaremos empleando la búsqueda lineal para luego compararla con la binaria:

Output:

Tenemos aquí una sencilla función que ha recorrido la lista proporcionada como argumento, comparando cada valor con el valor buscado (20). Imprimiéndose en la salida la posición en el que este ha sido encontrado (19) y el número de comparaciones (o pasos) que se han tenido que efectuar (20 pasos).

Pasemos ahora a realizar la misma búsqueda empleado la «búsqueda binaria» objeto de esta entrada:

Output:

En este caso estamos traduciendo el procedimiento de «búsqueda binaria» a código Python, aplicándolo al mismo caso anterior, obteniendo la misma posición, pero en este caso en tan solo 5 pasos (frente a los 20 del caso anterior) lo que supone un nada despreciable ahorro de pasos en la búsqueda, ahorro que será más significativo en aquellos casos en los que necesitemos trabajar con grandes cantidades de información, que requieran una mayor optimización de recursos.

Saludos.

APLICANDO EFECTO DE «SKETCHING» SOBRE IMÁGENES CON PYTHON Y OPENCV.

Tal y como ya hemos podido comprobar en numerosas ocasiones. Podemos usar la librería «opencv» para aplicar toda clase de efectos y filtros sobre imágenes de un a manera rápida y sencilla. En el día de hoy, vamos a volver a usar dicha librería para, con tan solo 7 líneas de código, aplicar un efecto de «sketching» (o bosquejado) sobre la siguiente imagen:

Para ello, empezaremos importando nuestra librería «opencv«, la cual deberemos tener previamente instalada. Una vez hecho esto, usaremos el método «imread()» para cargar nuestra imagen, cuya información quedará almacenada en la variable «image«:

A continuación, tal y como suele hacerse para facilitar el procesado de imágenes, procederemos a convertir esta a una escala de grises mediante el método «cvt.Color()» con el que ya hemos trabajado en ocasiones anteriores:

De este modo obtendríamos una versión en escala de grises como esta:

Acto seguido pasaremos a invertir los valores de la imagen en escala de grises («gray_image«) para después generar una versión difuminada de la misma (versión que almacenaremos en la variable «blurred«) aplicando el método de filtrado «GaussianBlur()» con el que también hemos trabajado en el pasado:

Y finalmente, tras invertir nuevamente los valores de esta última versión, usaremos el método «.divide()» para obtener la versión bosquejada de nuestra imagen (que guardamos en la variable «pencilsketcht«). La cual guardaremos utilizando el método «.imwrite()» que tantas veces hemos empleado:

A continuación se muestra el código completo de nuestra práctica para mayor comodidad del lector:

Saludos.

ACORTANDO «URL» EN PYTHON, CON «pyshorteners».

Bienvenidos una vez más a este blog centrado en la programación en lenguaje Python, en una ocasión en la que vamos a ver como podemos acortar la longitud de una URL (práctica que nos puede ser muy útil cuando queremos incluir enlaces en paginas que, como Twitter, limitan la extensión que pueden tener los mismos). Para este propósito, existe en Python, una librería llamada «pyshorteners» que nos permitirá hacer esto de un modo sencillo y rápido. Librería la cual, podremos instalar en nuestro equipo usando el comando «pip» que ya hemos usado en repetidas ocasiones:

Una vez que tenemos instalada nuestra librería e importada a nuestro proyecto, crearemos la variable «URL» en la que introduciremos la «url» que queremos acortar:

Hecho esto, usaremos el método «tinyurl.short()» al que pasaremos como argumento la variable que usamos para almacenar la versión larga de nuestra «url» (variable «URL» en nuestro caso):

Ejecutado el método, simplemente tendremos que usar «print» para mostrar en pantalla nuestra url acortada y perfectamente válida (almacenada en la variable «shorter_url» en nuestro caso):

De este modo, haciendo uso de esta librería, nunca más tendremos problemas a la hora de insertar enlaces en páginas e las que se limite la longitud de los mensajes que podamos escribir.

Saludos.