BREVE INTRODUCCIÓN A LOS OPERADORES ‘BIT A BIT’ EN PYTHON.

Saludos y bienvenidos una semana más a vuestro blog sobre programación En Python, en una ocasión en las que nos disponemos a realizar un primer acercamiento a los llamados operadores ‘bit a bit’, los cuales, a pesar de ser menos comunes que los operadores aritméticos o lógicos, pueden ser muy útiles en ciertos contextos, especialmente cuando se trabaja con manipulación de bits, codificación de datos o algoritmos de bajo nivel. En este artículo, exploraremos los operadores bit a bit en Python, cómo funcionan y cómo se pueden aplicar en diferentes situaciones.

QUE SON LOS OPERADORES BIT A BIT:

Hemos de empezar diciendo que estos operadores presentan la particularidad de actuar sobre los bits individuales de las representaciones binarias de los valores numéricos. A diferencia de lo que sucede con los operadores aritméticos y lógicos a los que estamos más acostumbrados, en la que las operaciones se realizan sobre los valores completos. En Python tenemos 6 operadores ‘bit a bit’, que listamos a continuación:

• & : AND bit a bit
• | : OR bit a bit
• ^ : XOR bit a bit
• ~ : Complemento bit a bit (NOT)
• << : Desplazamiento a la izquierda
• >> : Desplazamiento a la derecha

A continuación veremos un ejemplo en código Python del uso de cada uno de ellos.

EJEMPLOS EN PYTHON:

AND Bit a Bit (&): Este operador toma dos números y realiza una operación AND bit a bit en cada par de bits correspondientes. El resultado será 1 si ambos bits son 1, de lo contrario, será 0:

OR Bit a Bit (|): Este operador realiza una operación OR bit a bit en cada par de bits correspondientes. El resultado será 1 si al menos uno de los bits es 1:

XOR Bit a Bit (^): Este operador realiza una operación XOR bit a bit en cada par de bits correspondientes. Donde el resultado será 1 si los bits son diferentes, de lo contrario, será 0:

Complemento Bit a Bit (~): Este operador realiza una negación bit a bit, es decir, invierte todos los bits de un número:

Desplazamiento a la Izquierda (<<) y Desplazamiento a la Derecha (>>): Estos operadores desplazan los bits hacia la izquierda o hacia la derecha, respectivamente, en el número dado. Los bits que se desplazan más allá de los límites del número se pierden. En este caso, también especificaremos el número de posiciones en el que deberán desplazarse los bits:

USOS:

Los operadores bit a bit en Python y otros lenguajes de programación son herramientas versátiles con una amplia gama de aplicaciones. Desde la manipulación eficiente de datos hasta la optimización de algoritmos, estos operadores ofrecen diversas utilidades. Por ejemplo, en el campo de la criptografía, se pueden usar para implementar algoritmos de cifrado y descifrado, donde el procesamiento a nivel de bits es esencial para garantizar la seguridad de los datos. En la compresión de datos, los operadores bit a bit permiten la implementación de algoritmos de compresión eficientes, como la codificación de longitud de ejecución (RLE) o la codificación Huffman, que buscan reducir el tamaño de los archivos mediante la manipulación precisa de los bits. Además, en la programación de dispositivos embebidos y sistemas de bajo nivel, los operadores bit a bit son fundamentales para el control y la comunicación con hardware específico, donde cada bit puede representar un estado o una configuración particular. En resumen, los operadores bit a bit son una herramienta poderosa y fundamental en la caja de herramientas de cualquier programador, ofreciendo soluciones eficientes para una amplia variedad de problemas y escenarios de programación.

CONCLUSIÓN:

Para terminar, los operadores ‘bit a bit‘ son una herramienta de gran utilidad para manipular datos a nivel de bits en Python. Al comprender cómo funcionan estos operadores y cómo se aplican, los programadores pueden escribir código más eficiente y efectivo para una gran variedad de aplicaciones. Si bien pueden parecer menos comunes en comparación con otros operadores más tradicionales, su utilidad en ciertos dominios no debe subestimarse.

Saludos.

REPRODUCCIÓN Y GRABACIÓN ASINCRÓNICA DE AUDIO EN PYTHON, CON «sounddevice» Y «soundfile».

A lo largo de entradas anteriores hemos visto el modo de efectuar tanto reproducciones de archivos de audio, así como la grabación de los mismos. No obstante, puede suceder en ocasiones, que queramos realizar dichas acciones, al mismo tiempo que se ejecuta otro código de forma simultanea (reproduciéndose o grabándose audio en segundo plano). Un procedimiento fácil y cómodo de realizar esta acción nos lo proporciona la librería «sounddevice» (que instalaremos previamente con «pip install sounddevice«) que usaremos conjuntamente con «soundfile» («pip install sounfile«) tanto para reproducir audio en segundo plano, así como para grabarlo. El como podemos podemos llevar a cabo ambas acciones lo explicaremos con dos sencillos ejemplos:

REPRODUCCIÓN DE AUDIO.

En esta primera práctica, vamos a hacer que nuestro programa, reproduzca un archivo de audio mientras, al mismo tiempo, muestra una serie de mensajes en pantalla:

El ejemplo sobre estas líneas, se inicia reproduciendo el audio «.wav» que hemos definido en la variable «file» y que pasaremos como argumento para la función «async_playback()» (recuerda que si el archivo a reproducir se encuentra en un carpeta distinta de aquella en la que se ubica nuestro programa, habrá que introducirse la ruta al mismo), dicha función usará la librería «soundfile» para acceder a la información del archivo (mediante el método «.read()«) obteniendo la información que almacenaremos en las variables «data» y «fs«, que a continuación, variables que a continuación pasamos al método «.play()» (usando ahora «sounddevice«) para reproducir el audio.

Como hemos dicho, la particularidad de este ejemplo, usando «sounddevice«, radica en el hecho de que la función «asyn_playback()» va a ejecutarse al mismo tiempo que se ejecuta el siguiente bloque de código, consistente en la muestra (a intervalos de 5 segundos) de una serie de mensajes, y un input que nos permitirá parar la reproducción del audio, mediante «sd.stop()«:

Como ve, se trata de un procedimiento muy sencillo, que nos permite reproducir en segundo plano, un audio sin necesidad de usar «threading» y el cual, podemos parar en cualquier en cualquier momento, evitando las dificultades que presenta la finalización de un hilo. Con respecto a la ejecución simultanea, al igual que la reproducción, «sounddevice» nos permite, también la grabación de un audio, mientras se ejecuta código en segundo plano.

GRABACIÓN DE AUDIO.

A continuación, vamos a ver como podemos, de un modo sencillo, grabar un audio mientras se ejecuta otro código en segundo plano. Para ello volveremos a usar «sounddevice» (que usaremos ahora para registrar el sonido) y «soundfile» (que en esta ocasión, se encargará de crear el archivo de audio).

En esta ocasión definiremos dos funciones: «async_record()» que se encargará de registrar el sonido y almacenarlo en un archivo de nombre «async_record.wav» y la función «printstuff()» que se ejecutará en segundo plano, y que imprimirá los valores del 0 al 15, a intervalos de 1 segundo, mientras se ejecuta la grabación. Para ejecutar el programa, haremos una llamada a la función de grabación «async_record()» a la que pasaremos el nombre del futuro archivo de audio, la duración de la grabación en segundos, el número de frames por segundo y el numero de canales que vamos a usar. La función «async_record()» iniciará la grabación con el método «.rec()«, para a continuación pasar a iniciar la ejecución de la función «printstuff()» pasándole el número de valores a imprimir. Por su parte. usaremos «sd.wait()» para que el programa no pase a la siguiente línea de código hasta que haya acabado de grabar (durante los 20 segundos establecidos). Ahora si, una vez que termina de grabar, usaremos el método «.write()» de «soundfile» para crear el nuevo archivo de audio.

Con esto hemos visto un sencillo procedimiento a través del cual podemos reproducir o grabar un audio, mientras ejecutamos otro código en un segundo plano, empleando las librerías «sounddevice» y «soundfile«, y lo hemos hecho a través de dos ejemplos cuyos códigos podéis consultar en los siguientes enlaces:

Reproducción asincrónica de audio:

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

Grabación asincrónica de audio:

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

Saludos.

CREANDO VIDEO A PARTIR DE IMAGENES, EN PYTHON, CON «opencv».

Hace unas semanas estuvimos viendo el modo de crear una secuencia de imágenes a partir de un archivo de vídeo. Para ello, nos valimos de la librería «opencv» (que podemos instalar mediante el comando «pip install opencv-python«). Al final de dicho artículos hicimos referencia a la posibilidad de usar esa misma librería para realizar la operación inversa, que es precisamente lo que vamos a hacer en esta ocasión, generar un archivo de vídeo a partir de una secuencia de imágenes, las cuales se ubicarán en una carpeta creada al efecto (al final del artículo dejo un enlace al ejemplo completo). Así, empezaremos importando los recursos que vamos a emplear entre los que se encuentra la propia librería «opencv» («cv2«), «numpy» (con la que leeremos la información de cada frame y que deberemos de instalarla igualmente con «pip install numpy») y «os» con el que determinaremos la ruta a la carpeta en la que se encuentra la secuencia de imágenes:

Hechas las importaciones necesarias, pasaremos a definir la función (a la que llamaremos «convertToVideo()«) encargada de generar nuestro vídeo (el cual se creará en la misma carpeta en la que tengamos alojada nuestra secuencia de imágenes):

Tenemos aquí, una función que tomará 4 argumentos: «pathIn«, la ruta al directorio en el que se encuentra nuestra secuencia (aquí hay que mencionar que las imágenes de dicha secuencia, deberán tener el mismo nombre acompañado de un índice (ej: «frame 1.jpg«, «frame 2.jpg«…), el segundo argumento es «pathOut«, que es el directorio en el que se creará nuestro vídeo. El tercer argumento es «fps«, el número de frames por segundo que queremos para nuestro vídeo, finalmente, el argumento «time» determinará el tiempo de duración de cada imágen. Con estos datos, nuestra función irá recorriendo los archivos del directorio, cuyos nombres (y orden) quedarán almacenados en la lista «files«. Un segundo recorrido se efectuará sobre los archivos de dicha lista (con un «for«) en los que uno a uno, se irá por una parte, determinando la altura y anchura del frame con el método «.shape» («height, width, layers = img.shape» donde «img» es el contenido leído del frame («filename«) con «cv2.imread()«). En este punto también procederemos a leer el contenido de los arrays de cada frame y añadiendolo a la lista «frame_array» creada previamente y que será la que finalmente usaremos para «escribir» nuestro vídeo usando la varible «out» que será un objeto que habremos definido previamente mediante el método «VideoWriter()» introduciendo como parámetros el directorio de salida («pathOut«), el codec usado (definido con «VideoWriter_fourcc()«), los frames por segundo («fps» ) y el tamaño de estos (determinado por la tupla de valores «width» y «height«). Finalmente, hecho todo esto, el programa generará nuestro vídeo con la función «release()«.

Visto de forma resumida como actúa nuestra función, vamos a ejecutarla, para que genere un vídeo (que llevará por nombre «video.avi«) en la misma carpeta en la que se encuentra la secuencia de imágenes (que llevarán por nombre «frame 1.jpg«, «frame 2.jpg«….) que conformarán nuestro vídeo:

Secuencia de frames.

Como se ve, como paso previo a la ejecución de nuestro programa, definiremos en primer lugar, el directorio en el que se alojan los 31 frames de nuestro futuro vídeo, el directorio en el que se generará dicho vídeo (que puesto que queremos que se genere junto a los frames haremos «pathOut=pathIn+’video.avi‘», donde «pathIn» es la variable que almacena la colección de imágenes). Finalmente, definiremos también los frames por segundo («fps«) y «time». Pasando estos datos como argumentos de la función creada «convertToVideo()» ejecutaremos, mostrandose lo siguiente en pantalla:

Tal y como se muestra en el código de nuestra función, usamos «print(filename«) para que se mostrara la ubicación y nombre de los archivos, conforme se iban procesando. No obstante, si nos fijamos en el output de nuestro programa, vemos como el orden en el que se han leído/procesado los frames no es el adecuado (cuando se cuenta con archivos numerados de este modo, normalmente se espera que se procesen siguiendo ese orden numérico, sin embargo aquí vemos como se ha pasado directamente del «frame 1» al «frame 10«, del «frame 2» al «frame 20» dejándose para el final los frames 4 al 9. Esto supone que aunque nuestro vídeo se habrá creado sin problemas, no será lo que hayamos esperado (presentará saltos en la escena).

Esta circunstancia implica la necesidad de que introduzcamos una modificación en nuestra función. Puesto que el problema proviene del hecho de que los frames no se han procesado en el orden correcto, solucionaremos dicho problema reordenando el contenido de la lista «files» (que es la que recorre el «for» de nuestro programa) mediante el método «sort()«:

Como se ve en la imagen, procedemos a reordenar la lista «files» mediante el método «sort()» en el que usamos como clave («key«) que es el criterio que vamos a usar para efectuar la ordenación de los elementos de la lista, la parte numérica del nombre de cada archivo de imagen (aislamos dicho valor, aplicando dos funciones «split()» en la que aplicamos «x.split(«.»)[0]» sobre el resultado de «.split(» «)[1]«.Todo ello para quedarnos solo con la parte numérica del nombre del frame, y usar dicho valor (que convertiremos a entero con «int()«) como criterio para reordenar el contenido de la lista «files». Con ello conseguiremos ordenar de modo correcto la lista «files» tomando como criterio los valores numéricos. De tal modo que si ahora volvemos a ejecutar nuestro programa (previa eliminación del vídeo antes creado) obtendremos el siguiente output:

Como se ve en esta ocasión los frames se han procesado en el orden deseado, de modo que el vídeo que aparecerá esta vez en nuestra carpeta «frames» será el esperado desde el principio.

Tenéis el código del ejemplo en el siguiente enlace:

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

Saludos.

EXTRAYENDO INFORMACIÓN DE ARCHIVOS DE VÍDEO, EN PYTHON, CON «ffmpeg».

Sucede en ocasiones, que estamos elaborando alguna aplicación que haga uso o manipule de alguna manera, archivos de vídeo. Siendo a veces, necesario el contar con determinada información sobre el archivo de vídeo usado, como puede ser el tamaño, dimensiones o el «frame rate» del mismo. Pues bien, en esta ocasión , vamos a ver como podemos obtener las características de un vídeo, mediante el software de «ffmpeg» y «ffmpeg-python«. Por su parte, dado que vamos a usar el software de «ffmpeg» deberemos instalarlo previamente en nuestra computadora. Para los que puede ser de ayuda el siguiente vídeo:

Una vez instalado «ffmpeg» pasaremos a instalar, mediante el comando pip, la librería «ffmpeg-python«:

Hecho esto, podemos pasar ya a obtener la información de un archivo de vídeo, mediante un procedimiento muy sencillo:

Como se ve, empezamos importando «ffmpeg» para «python«, para a continuación usar el método «.probe()» para indicar el vídeo cuyas dimensiones queremos extraer (esto lo hacemos introduciendo la ruta al mismo, como puede verse) para, finalmente extraer su información, la cual se almacenará en la variable «video_streams«.

Y ya solo nos resta imprimir la información. Para hacerlo de modo que esta salga ordenada, usaremos «pprint» (importando primero dicho módulo y usando «pprint.pprint()«:

Visualizando, de este modo, toda la información del vídeo que podamos necesitar.

Saludos.

MONITORIZANDO USO DE LA CPU EN TIEMPO REAL, CON «Tkinter» Y «psutil».

Hace algún tiempo, estuvimos viendo el modo de visualizar determinadas características del sistema, haciendo uso de la librería «psutil» (la cual podremos instalar mediante el comando «pip install psutil«). Entre tales características se encontraba la relativa al consumo (sobre el total de la memoria) de la «Unidad central de procesamiento» (de ahora en adelante «CPU«), en la que hoy nos vamos a centrar, para crear un sencillo programa que, mediante una interfaz creada con «Tkinter«, nos muestre, en tiempo real, dicha información:

Como es costumbre, comenzaremos creando la ventana en la que se mostrará la información. No sin antes, haber realizado las importaciones necesarias, de las librerías «Tkinter» y «psutil«:

Como se ve, hemos creado nuestro objeto «ventana«, cuyas dimensiones hemos definido, con el método «.geometry()«, al igual que el título («.tittle()«) y el color de fondo «bg» (con «.configure()«). Obteniendo al ejecutar el siguiente resultado:

Pasemos, acto seguido a introducir los elementos que se hallarán dentro de la ventana. Que en esta ocasión consistirán unicamente, en dos etiquetas (para cuya creación usaremos la función «Label» de «Tkinter«): Una con el texto «CPU Usage:» y otra destinada a mostrar el porcentaje de consumo de la «CPU»:

Como puede verse, hemos empezado creando la etiqueta «cpu_label» (en la que se mostrará el porcentaje de consumo de la CPU) haciendo uso de la función «Label()«, en la que primero introducimos el nombre de la ventana en la que la vamos a ubicar («ventana«), para después, definir el color de fondo («bg=»black»«), el color de los caracteres que en ella se van a mostrar («fg=»green»«), la posición de dichos caracteres en la etiqueta («anchor=NE«), la fuente de dichos caracteres («font=»Arial 30 bold»«) y el ancho de la etiqueta («width=6«). Finalmente la ubicaremos en la ventana, mediante el método «.place()«. El mismo procedimiento usaremos para la etiqueta de texto («digi«) con la particularidad de que en este caso definiremos su texto («text=»CPU Usage:»«). El resultado de estas líneas será el siguiente:

Tenemos la ventana, tenemos las etiquetas, ahora solo nos falta que nos muestre el referido porcentaje de consumo de CPU. Para ello, simplemente usaremos una función (a la que llamaremos «cpu_met()«) que definiremos antes de crear la ventana:

Como se puede apreciar, se trata de una función bien sencilla en la que los primero que se hace es obtener (mediante «psutil.cpu_percent()«) el valor relativo al uso porcentual, de la CPU del dispositivo, almacenándose, el valor obtenido en la variable «cpu_use«. Tras ello, actualizaremos la etiqueta «cpu_label» (mediante «config()«) para que en su texto se muestre dicho valor, acompañado del símbolo «%» («text='{}%.format(cpu_use)«). Este proceso se repetirá de forma constante, actualizando el texto de «cpu_label» con una periodicidad de 200 milisegundos («cpu_label.after(200,cpu_met)«).

Definida la función, ya solo nos resta el hacer la correspondiente llamada a la misma, para su ejecución:

Y con esto ya solo nos queda ejecutar el programa y ver, en tiempo real, la evolución en el consumo de memoria de nuestra CPU:

Código fuente:

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

Saludos.

USO DE CÁMARA WEB Y GRABACIÓN DE IMAGEN, EN PYTHON, CON «opencv».

Bienvenidos una vez más a vuestro página sobre programación en Python en una ocasión en la que nos disponemos a explicar el modo en que podemos hacer uso de la librería «opencv» para mostrar la información de entrada de la cámara de nuestro dispositivo. Puesto que vamos a hacer uso de «opencv«, nos aseguraremos de tener dicha librería instalada en nuestro equipo (de no ser así podemos usar el comando «pip install opencv» para instalarla con el «cmd» ).

MOSTRAR ENTRADA DE CAMARA.

Lo primero que vamos a aprender, es como podemos usar «opencv» para mostrar la imagen captada a través de la cámara de nuestro equipo. En realidad se trata de un procedimiento bien sencillo, que puede efectuarse en pocas líneas:

Como se ve, lo primero que haremos para crear nuestro visor, será importar las librería «opencv«, tras lo cual, procederemos a iniciar nuestra cámara (con el método «VideoCapture()«) creando el objeto «cap» («cap=cv2.VideoCapture(0)«). Una vez, iniciada la cámara, usaremos un «while» en el que el método «cap.read()» irá realizando sucesivas capturas de la imagen captada por la cámara (cada una de estas capturas sucesivas serán asignadas a la variable «frame»). Tras ello, cada una de estas capturas (frames) irán siendo mostradas en pantalla mediante el método «cv2.imshow()» que tomará como argumentos el título de la ventana y la imagen a mostrar (la captura contenida en la variable «frame«). Para finalizar este bucle (con «break«) estableceremos que este se produzca al pulsar «q» en el teclado («if cv2.waitkey(1) & 0xFF=ord(‘q’):«). Para terminar, una vez roto el bucle, finalizaremos la cámara («cap.release()«) y cerraremos la ventana («cv2.destroyAllWindows()«).

Como se puede observar, el método «cap.read()«, además de devolvernos la imagen capturada por la cámara (variable «frame«), también nos devuelve un valor booleano (variable «ret«) que será «True» cuando la cámara este disponible para uso, y «False» en caso contrario. Esto nos servirá para evitar que nos surja un error cuando intentemos ejecutar nuestro código, estando la cámara desactivada o siendo utilizada por otra aplicación:

En este caso hemos hecho que los frames se muestren con su color natural, no obstante, podemos usar distintos métodos y funciones que introduzcan cambios en los mismos (por ej: en el color). Así, podemos mostrar la imagen de salida en una escala de grises. Para ello no tendremos más que aplicar «cv2.COLOR_BGR2GRAY» a cada uno de los frames, guardando el resultado en una variable, a la que hemos llamado «gray» y que finalmente mostraremos en la ventana con «cv2.imshow(‘Visor’,gray)«:

GRABACIÓN DE VÍDEO:

Hasta ahora hemos visto el modo de mostrar en una ventana de «opencv«, el contenido captado por la cámara de nuestro dispositivo. A continuación, emplearemos un procedimiento similar, para guardar nuestra captura en un formato de vídeo:

En este caso, tras iniciar la cámara como en el caso anterior, pasaremos a definir el «codec» que vamos a usar para comprimir los sucesivos «frames«, para crear el vídeo («fourcc=cv2.VideoWriter_fourcc(*’XVID’)«) siendo ‘XVID‘ los caracteres que definirán el «codec» empleado. A continuación, creamos el objeto que albergará el contenido de nuestro vídeo, con el método «VideoWriter()» introduciendo como argumentos, el nombre del futuro archivo, el codec empleado, los «frames» por segundo, y sus dimensiones. Tras ello, iniciaremos el proceso de grabación, siempre que esté activada la cámara, de un modo similar al de los ejemplo anteriores, salvo que, como estamos grabando, usaremos el método «.write()» para añadir el contenido al objeto de vídeo «out«. Terminado el proceso de grabación, finalizaremos la cámara, el objeto de grabación y cerraremos la ventana.

Con esto tendríamos visto, tanto el modo de usar nuestra cámara web con Python, como la manera de efectuar la grabación de la información de entrada de la misma. A partir de este punto, solo nos queda aplicar lo visto, para incorporar el uso de este dispositivo a nuestras aplicaciones.

Saludos.

OBTENIENDO INFORMACIÓN DEL SISTEMA Y DEL HARDWARE EN PYTHON, CON «psutil».

Saludos, programadores, bienvenidos una semana más a «El Programador Chapuzas«, vuestro blog sobre programación en lenguaje Python. En esta ocasión vamos a hablar de «psutil«, una librería perfecta para aquellas labores relacionadas con la monitorización de nuestro sistema y que en esta ocasión vamos a emplear para visualizar una amplia información acerca de aspectos tales como el uso de memoria…etc. Tras ello, crearemos una sencilla interfaz con «Pmw» (el cual también deberemos instalar) con la que podremos seleccionar la información a visualizar.

Antes de empezar, como de costumbre, empezaremos importando los recursos y librerías que vamos a necesitar:

De las cuales, solo vamos a necesitar instalar previamente, «psutil» haciendo uso del comando «pip» que ejecutaremos en el «cmd» («pip install psutil«):

Puesto que vamos a trabajar con información de memoria, medida en «bits«, con frecuencia obtendremos valores de muchos dígitos, los cuales, convendrá escalar en «kilobytes«, «megabytes«, «gigabytes«… Para ello usaremos una función a la que llamaremos «get_size()«:

A partir de este punto, podremos empezar a mostrar la información del hardware y del sistema, haciendo uso de «psutil» y «platform«. Información que iremos organizando en varios bloques que pasamos a enumerar a continuación:

INFORMACIÓN BÁSICA DEL SISTEMA: Para la obtención de este primer bloque de información (en donde se incluye el sistema operativo, versión del mismo, procesador…), vamos a emplear la librería «plattform» (instalada con python), que iniciaremos con el método «uname» («uname = platform.uname()«).

CPU: El segundo bloque mostrará información relativa a la Unidad Central de Procesos («CPU«) de nuestro dispositivo. Dentro de este apartado de mostrará aspectos tales como el número de núcleos (obtenidos con «cpu_count()«), la frecuencia (que se obtendrá con «cpu_freq()«) y el uso que de ella este haciendo el dispositivo (el cual, se mostrará mediante «cpu_percent()«)

MEMORIA: Para este segundo bloque de datos, empezaremos a usar algunas funciones y métodos de «psutil«. En este caso, puesto que vamos a visualizar datos relacionados con la cantidad de memoria (libre, usada y total), haremos uso de la función «get_size()» definida anteriormente.

DISCO DURO: Para obtener los datos de este bloque de información, comenzaremos iniciando el objeto «partitions» con «partitions = psutil.disk_partitions()» y a través del cual podremos obtener información tal como la capacidad del mismo, espacio usado, espacio libre, etc…

REDES: El último bloque de información será el relativo a las redes, entre la que se encontrará la dirección IP de nuestro dispositivo o la cantidad de información, en bytes, recibida («net_io.bytes_recv«) y enviada («net_io.bytes_recv«) a través del mismo:

Ejecutando, conjuntamente los scripts vistos, obtendremos una extensa y detallada información acerca de nuestro sistema y del hardware de nuestro equipo, cuyo output será el siguiente:

USANDO INTERFAZ CON «Pmw».

Como hemos visto, con «platform» y «psutil» hemos conseguido obtener una ingente cantidad de información acerca de la configuración de nuestro sistema y de nuestro equipo. No obstante, puede suceder que queremos, en un momento dado, acceder solo a una parte de la información (por ejemplo, la relativa a la «CPU«). Para ello, podemos crear una sencilla interfaz, en la que a través de unos botones, se vaya añadiendo los bloques de información que vayamos queriendo, en un terminal creado por nosotros.

Para la confección de tal interfaz, vamos a hacer uso de «Pmw» un kit de herramientas a través del cual podemos incrementar las posibilidades que ofrece la librería «tkinter«. Así, para crear nuestra aplicación, importaremos las mismas librerías que veíamos en el ejemplo anterior, además de «Pmw» y «Threading«:

Tras ello, lo siguiente será crear nuestra interfaz, que constará de dos elementos fundamentales: «ScrolledText()» (que hará la función de pantalla) y «ButtonBox()» (donde se alojarán los botones de las distintas opciones de información:

Tal y como se ha señalado, usamos «ScrolledText()» para crear el objeto «display» introduciendo una serie de opciones entre las que podemos destacar el alto y ancho de la pantalla («text_height» y «text_width«), el color de los caracteres y fondo («text_foreground» y «text_background«) o la opción «vscrollmode» que estableciéndola como «dynamic» estamos indicando que queremos que aparezca una pestaña de scrolling cuando la cantidad de texto lo requiera. Por su parte, para la inclusión de los botones, usaremos un procedimiento semejante al que empleamos cuando trabajamos con «Tkinter«, solo que en esta ocasión, añadiremos los botones al megawidget «ButtonBox» mediante el método «.add()«. En este punto invocaremos la primera función («clear()«) que limpiará la pantalla y mostrará un texto indicativo:

Para esta aplicación, volveremos a incluir la función «get_size()» que veíamos antes:

Como se habrá adivinado, las funciones que representarán la información en nuestra pantalla, se corresponderá con cada uno de los bloques que vimos antes. Con la salvedad de que aquí usaremos el método «appendtext()» (en lugar de «print«) y añadiremos un salto de línea («\n«) al final:

Funciones para visualizar en pantalla la información relativa a la memoria, la información básica del sistema y la CPU

Como se podía apreciar en una imagen anterior, cada botón activaba la misma función («inicia()«) proporcionándole un valor. Dicha función se encargará de activar un segundo proceso (mediante «threading.Thread«) en paralelo, que, en cada caso, tendrá como objetivo («target«) la función correspondiente (dentro del diccionario «infos«) con el indice proporcionado en la variable «index«:

Estos subprocesos son los que ejecutarán, en cada caso, las funciones de obtención y visualización de los bloques de datos.

El código completo de la terminal con «Pmw» se encuentra disponible en el siguiente enlace:

https://github.com/antonioam82/System-Info-Console/blob/master/system_info_console.py

En el siguiente enlace puede verse el código completo con el que hemos obtenido la información del primer ejemplo:

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

Saludos.