Extracción de información de hardware y sistema Linux con Python

Encontrar información de hardware y sistema en Linux es una tarea útil e interesante. Podemos extraer detalles del sistema operativo, detalles del usuario, detalles de la memoria, detalles de la CPU y mucho más usando códigos simples de Python en Linux. Aunque podemos realizar muchas de esas cosas usando scripts de terminal y bash, Python es mucho más interesante.

Como amantes de Python, queremos que todas las tareas se realicen utilizando ese lenguaje, por lo que extraer información del sistema y del hardware con Python es una gran tarea. Además, podemos aprender tanto Linux como Python al mismo tiempo. Este artículo será bastante largo, así que tómate tu tiempo para leer el artículo completo y ejecutar cada código para una mejor comprensión.

Puede copiar cada uno de los códigos en un IDE de Python y ejecutarlo. Si no tiene un IDE de Python o desea comparar entre IDE, consulte nuestra guía sobre los 10 IDE principales para Linux. Por cierto, estoy usando VS Code como un IDE para escribir código. Es de código abierto y fácil de usar. Si desea utilizar Visual Studio Code, consulte nuestra guía sobre la instalación de código VS en Linux.

Extrayendo información del sistema usando Python

En este artículo, desarrollaremos un programa que extraerá los siguientes detalles:

• Detalles básicos del sistema
• Detalles de la CPU
• Información de la memoria
• Uso del disco
• Información de la red
• Otros detalles de hardware

Para obtener estos detalles, usaremos los módulos presentes en la biblioteca estándar de Python. Algunos de los módulos que usaremos son SO, plataforma, etc. También puse el código fuente en Github; puedes ver una demostración del programa descargándolo de mi repositorio de Github y ejecutándolo.

Para seguir este tutorial, se recomienda tener instalada la última versión de Python en su sistema. Puede seguir nuestra guía sobre la instalación de Python en Linux.

Requisitos

Muchas de las bibliotecas que usamos en este tutorial están presentes en la biblioteca estándar de Python. Solo necesitamos instalar el paquete psutil. Puedes comprobarlo importándolo. Si no tiene psutil instalado, puede instalarlo fácilmente con la herramienta pip. Para instalar pip en nuestro sistema, necesitamos ejecutar el siguiente comando en la terminal.

pip instalar psutil

Obtener detalles básicos del sistema

Ahora que ha instalado psutil, veamos cómo usarlo para recopilar el sistema operativo usando python. Estábamos usando el plataforma módulo presente en la biblioteca estándar de Python para recopilar esta información básica del sistema. Debe copiar el siguiente código en su IDE de Python favorito y ejecutarlo.

# importando los módulos requeridos plataforma de importación # imprimiendo la Arquitectura del SO print ("[+] Arquitectura:", plataforma.arquitectura () [0]) # Visualización de la impresión de la máquina ("[+] Máquina:", plataforma.máquina ()) # imprimiendo la información de la versión del sistema operativo print ("[+] Versión del sistema operativo:", plataforma.release ()) # imprime el nombre del sistema que está utilizando actualmente print ("[+] Nombre del sistema:", plataforma.system ()) # Esta línea imprimirá la versión de su sistema operativo print ("[+] Versión del sistema operativo:", plataforma.version ()) # Esto imprimirá el Nodo o nombre de host de su Sistema Operativo print ("[+] Nodo:" + plataforma.node ()) # Esto imprimirá la plataforma de su sistema print ("[+] Plataforma:", plataforma.plataforma ()) # Esto imprimirá la información del procesador print ("[+] Procesador:", plataforma.procesador())

En el código anterior, primero importamos el módulo de plataforma presente en la biblioteca estándar de Python. Después de importar el módulo, usamos las funciones del módulo de la plataforma para obtener la información requerida. Al ejecutar el código en mi dispositivo, obtuve el siguiente resultado.

Como podemos ver en el resultado, el programa muestra muchos detalles importantes sobre el sistema operativo, como la arquitectura del sistema, la plataforma y mucho más.

Tiempo de actividad del sistema

También podemos obtener el tiempo de arranque del sistema y el tiempo de actividad del sistema en Python. Necesitamos usar el psutil biblioteca que hemos instalado anteriormente. Podemos obtener el tiempo de actividad del sistema leyendo el archivo de tiempo de actividad presente en el directorio proc en Linux.

Copie el siguiente código en su IDE de Python favorito y ejecútelo.

from datetime import datetime import psutil # Usando la biblioteca psutil para obtener la hora de arranque del sistema boot_time = datetime.fromtimestamp (psutil.boot_time ()) print ("[+] System Boot Time:", boot_time)

Este código imprimirá la hora de inicio, es decir, la hora en que se inició el sistema. Al ejecutar el programa en mi PC, obtuve el siguiente resultado.

También podemos ver el tiempo de actividad del sistema, que es el tiempo durante el cual el sistema está funcionando. Necesitamos leer el archivo de tiempo de actividad del directorio proc, como se muestra en el siguiente código.

# obtener el tiempo de actividad del sistema desde el archivo de tiempo de actividad en el directorio proc con open ("/ proc / uptime", "r") como f: uptime = f.leer().dividir ("") [0].strip () uptime = int (float (uptime)) uptime_hours = uptime // 3600 uptime_minutes = (uptime% 3600) // 60 print ("[+] System Uptime:" + str (uptime_hours) + ":" + str ( uptime_minutes) + "horas")

Tengo el siguiente resultado al ejecutar el código.

Procesos

También podemos usar Python para obtener una lista de los procesos que se están ejecutando actualmente, el número total de procesos. Necesitamos ejecutar el siguiente código.

import os pids = [] para subdirectorio en os.listdir ('/ proc'): si subdirectorio.isdigit (): pids.append (subdir) print ('Número total de procesos: 0'.formato (len (pids)))

Al ejecutar el código, obtuve el resultado, como se muestra en la imagen de abajo.

informacion del usuario

También podemos obtener la lista de todos los usuarios presentes en nuestro dispositivo Linux utilizando la biblioteca pwd presente en la biblioteca estándar de Python. Para hacer esto, necesita copiar el siguiente código en su Python IDE y ejecutarlo.

importar usuarios de pwd = pwd.getpwall () para el usuario en usuarios: imprimir (usuario.pw_name, usuario.pw_shell)

Al ejecutar el código anterior, obtendrá todos los usuarios presentes en su dispositivo y sus caparazones.

Información de la CPU

Hemos recopilado los detalles del sistema ahora para recopilar cierta información sobre la CPU utilizada por nuestra máquina. Podemos recopilar información de la CPU de nuestra máquina Linux de dos maneras. La primera y más sencilla forma es utilizar el psutil módulo y la segunda forma es leyendo el archivo / proc / cpuinfo.

Veamos cómo podemos usar la biblioteca psutil para obtener la información de la CPU. Debe copiar el siguiente código en su IDE de Python favorito y ejecutarlo.

# importando los paquetes requeridos import psutil # Este código imprimirá el número de núcleos de CPU presentes print ("[+] Número de núcleos físicos:", psutil.cpu_count (lógico = Falso)) print ("[+] Número de núcleos totales:", psutil.cpu_count (logic = True)) print ("\ n") # Esto imprimirá la frecuencia de CPU máxima, mínima y actual cpu_frequency = psutil.cpu_freq () print (f "[+] Frecuencia máxima: cpu_frequency.max:.2f Mhz ") print (f" [+] Frecuencia mínima: cpu_frequency.min:.2f Mhz ") print (f" [+] Frecuencia actual: cpu_frequency.Actual:.2f Mhz ") print (" \ n ") # Esto imprimirá el uso de CPU por núcleo para i, porcentaje en enumerate (psutil.cpu_percent (percpu = True, interval = 1)): print (f "[+] Uso de CPU del núcleo i: porcentaje%") print (f "[+] Uso total de CPU: psutil.cpu_percent ()% ")

Veamos qué está sucediendo en el programa anterior. En la primera línea, importamos el psutil módulo, que ayudará a recopilar los detalles de la CPU. En la segunda y tercera líneas, usamos el cpu_count () función de la psutil módulo para contar el número de núcleos de CPU. Luego usamos la función cpu_freq () para obtener la frecuencia máxima, mínima y actual. Por último, usamos la función cpu_percent fo psutil para encontrar el uso de la CPU. Al ejecutar el código en mi máquina, obtuve el siguiente resultado.

Como podemos ver en la salida, todos los detalles de la CPU han sido emitidos por el programa en el terminal. También podemos obtener el nombre de la CPU leyendo el archivo / proc / cpuinfo usando python. Para hacer esto, necesitamos ejecutar el siguiente código.

# leyendo el archivo cpuinfo para imprimir el nombre # de la CPU presente con open ("/ proc / cpuinfo", "r") como f: file_info = f.readlines () cpuinfo = [x.banda().split (":") [1] para x en file_info si "nombre de modelo" en x] para índice, elemento en enumerate (cpuinfo): print ("[+] Procesador" + str (índice) + ":" + elemento )

También podemos recopilar otra información de la CPU utilizando el archivo / proc / cpuinfo. Solo leo el nombre del modelo de la CPU, pero puede abrir el archivo y ver la otra información presente en el archivo y puede usarlos en el programa. Aquí está la salida.

Recopilemos algo de información sobre la memoria usando Python.

Información de la memoria

Al igual que la información de la CPU, también podemos obtener información de la memoria de dos lugares. Uno está usando la herramienta psutil y el segundo es leyendo el archivo proc / meminfo. Para empezar, comencemos a recopilar información de la memoria usando la biblioteca psutil. Copie el siguiente código en su IDE de Python favorito y ejecútelo.

# importando los módulos requeridos import psutil # escribiendo una función para convertir bytes a GigaByte def bytes_to_GB (bytes): gb = bytes / (1024 * 1024 * 1024) gb = round (gb, 2) return gb # Usando la función virtual_memory () devolverá una tupla virtual_memory = psutil.virtual_memory () # Esto imprimirá los detalles de la memoria primaria print ("[+] Total Memory present:", bytes_to_GB (virtual_memory.total), "Gb") print ("[+] Memoria total disponible:", bytes_a_GB (memoria_virtual.disponible), "Gb") print ("[+] Memoria total utilizada:", bytes_a_GB (memoria_virtual.utilizado), "Gb") print ("[+] Porcentaje utilizado:", virtual_memory.percent, "%") print ("\ n") # Esto imprimirá los detalles de la memoria de intercambio si está disponible swap = psutil.swap_memory () print (f "[+] Memoria de intercambio total: bytes_to_GB (intercambio.total) ") print (f" [+] Memoria de intercambio libre: bytes_to_GB (intercambio.free) ") print (f" [+] Memoria de intercambio usada: bytes_to_GB (intercambio.usado) ") print (f" [+] Porcentaje usado: swap.por ciento%")

Veamos qué está pasando en el código anterior. En la primera línea, importamos la biblioteca psutil, luego usamos su función virtual_memory (), que devuelve una tupla con información de memoria virtual. Luego usamos la función swap_memory () para obtener la información de la memoria de intercambio. También construimos un nombre de función bytes_to_GB (), que convertirá los bytes en GigaBytes para una mejor legibilidad. Tengo la siguiente salida.

También podemos usar el archivo meminfo presente en el directorio proc de Linux para recuperar información de la memoria como la memoria total, la memoria utilizada, etc. Para hacer esto, ejecute el siguiente código.

# Recopilación de información de memoria del archivo meminfo print ("\ nLeyendo el archivo / proc / meminfo: \ n") con open ("/ proc / meminfo", "r") como f: líneas = f.readlines () print ("[+]" + líneas [0].strip ()) print ("[+]" + líneas [1].banda())

Y aquí está la salida:

Información del disco

Hasta ahora, hemos visto algunos detalles básicos del sistema, detalles de la CPU, detalles de la memoria. Ahora veamos la información sobre el disco presente en nuestra máquina. Para extraer información del disco, usaremos el módulo psutil para facilitar nuestra tarea, y no necesitamos reinventar la rueda. Mire el código a continuación para ver un ejemplo funcional del código. Puede copiar el código y ejecutarlo en el IDE de su python favorito.

# importando los módulos requeridos import psutil # accediendo a todas las particiones del disco disk_partitions = psutil.disk_partitions () # escribiendo una función para convertir bytes a Giga bytes def bytes_to_GB (bytes): gb = bytes / (1024 * 1024 * 1024) gb = round (gb, 2) return gb # mostrando la partición y la información de uso para la partición en disk_partitions: print ("[+] Partition Device:", partición.dispositivo) imprimir ("[+] Sistema de archivos:", partición.fstype) print ("[+] Mountpoint:", partición.punto de montaje) disk_usage = psutil.disk_usage (partición.mountpoint) print ("[+] Espacio total en disco:", bytes_to_GB (disk_usage.total), "GB") print ("[+] Espacio libre en disco:", bytes_to_GB (disk_usage.gratis), "GB") print ("[+] Espacio en disco usado:", bytes_to_GB (disk_usage.utilizado), "GB") print ("[+] Porcentaje utilizado:", disk_usage.percent, "%") # obtener estadísticas de lectura / escritura desde el arranque disk_rw = psutil.disk_io_counters () print (f "[+] Lectura total desde el arranque: bytes_to_GB (disk_rw.read_bytes) GB ") print (f" [+] Total Write sice boot: bytes_to_GB (disk_rw.write_bytes) GB ")

En el código, primero hemos importado la biblioteca psutil, que es necesaria para recopilar la información del disco. Entonces usamos su disk_partitions () función para obtener la lista de particiones de disco disponibles con su información. También usamos la función disk_usage () para obtener el uso de estas particiones. Finalmente, usamos el disk_io_counters () función para obtener el total de lectura / escritura del disco desde el arranque.  Aquí hay una salida de ejemplo.

Puede obtener alguna otra salida dependiendo de su disco y particiones.

Información de la red

También podemos recopilar la información de red del sistema utilizando la biblioteca psutil. Para hacerlo, copie el siguiente código en su Python IDE y ejecútelo.

# importando los módulos requeridos import psutil # escribiendo una función para convertir los bytes en gigabytes def bytes_to_GB (bytes): gb = bytes / (1024 * 1024 * 1024) gb = round (gb, 2) return gb # reuniendo todas las interfaces de red ( virtual y físico) desde el sistema if_addrs = psutil.net_if_addrs () # imprimiendo la información de cada interfaz de red para interface_name, interface_addresses en if_addrs.items (): para la dirección en interface_addresses: print ("\ n") print (f "Interface:", interface_name) if str (dirección.familia) == 'DirecciónFamilia.AF_INET ': print ("[+] Dirección IP:", dirección.dirección) print ("[+] Máscara de red:", dirección.netmask) print ("[+] IP de transmisión:", dirección.broadcast) elif str (dirección.familia) == 'DirecciónFamilia.AF_PACKET ': print ("[+] Dirección MAC:", dirección.dirección) print ("[+] Máscara de red:", dirección.netmask) print ("[+] Difusión MAC:", dirección.broadcast) # obteniendo las estadísticas de lectura / escritura de la red desde el arranque print ("\ n") net_io = psutil.net_io_counters () print ("[+] Total de bytes enviados:", bytes_to_GB (net_io.bytes_sent)) print ("[+] Total de bytes recibidos:", bytes_to_GB (net_io.bytes_recv))

Aquí hay un resultado de ejemplo de mi PC de prueba.

Otra información de hardware

También podemos utilizar el psutil biblioteca para obtener otra información de hardware como información de la batería, velocidad de rotación de los ventiladores, información de temperatura de varios dispositivos, etc. Veamos cómo podemos hacer esto uno por uno.

Si está usando una computadora portátil, puede usar el psutil.batería_sensores () función para obtener la información de la batería. Para hacerlo, copie y ejecute el siguiente código en su Python IDE.

importar batería psutil = psutil.Sensores_battery () print ("[+] Porcentaje de batería:", round (batería.porcentaje, 1), "%") imprimir ("[+] Tiempo restante de la batería:", ronda (batería.secsleft / 3600, 2), "hr") print ("[+] Power Plugged:", batería.power_plugged)

En el código anterior, usamos el batería_sensores () función para obtener la información de la batería, como el porcentaje de batería, el tiempo restante, la alimentación enchufada o no. Al ejecutar el código en mi máquina, obtuve el siguiente resultado.

También podemos usar la biblioteca psutil para obtener las RPM (revoluciones por minuto) del ventilador usando la función sensores_fan () mientras el ventilador está funcionando. El psutil también se puede utilizar para obtener la temperatura de varios dispositivos. Podemos hacerlo usando la función sensins_temperatures () de la psutil. Dejo esto para que lo haga usted para practicar.

Guión final

Ahora combinemos todos los códigos con la construcción de un programa final para recopilar todos los detalles del sistema y hardware que discutimos. Puede copiar el siguiente programa y ejecutarlo en su Python IDE.

# importando la plataforma de importación de módulos requeridos desde datetime import datetime import psutil import os # Primero imprimiremos la información básica del sistema # usando el módulo de plataforma print ("\ n \ t \ t \ t Basic System Information \ n") print (" [+] Arquitectura: ", plataforma.arquitectura () [0]) print ("[+] Máquina:", plataforma.machine ()) print ("[+] Versión del sistema operativo:", plataforma.release ()) print ("[+] Nombre del sistema:", plataforma.system ()) print ("[+] Versión del sistema operativo:", plataforma.versión ()) print ("[+] Nodo:" + plataforma.node ()) print ("[+] Plataforma:", plataforma.plataforma ()) imprimir ("[+] Procesador:", plataforma.procesador ()) # Usando la biblioteca psutil para obtener la hora de arranque del sistema boot_time = datetime.fromtimestamp (psutil.boot_time ()) print ("[+] System Boot Time:", boot_time) # obteniendo el tiempo de actividad del sistema desde el archivo de tiempo de actividad en el directorio proc con open ("/ proc / uptime", "r") como f: uptime = F.leer().dividir ("") [0].strip () uptime = int (float (uptime)) uptime_hours = uptime // 3600 uptime_minutes = (uptime% 3600) // 60 print ("[+] System Uptime:" + str (uptime_hours) + ":" + str ( uptime_minutes) + "hours") # obteniendo el número total de procesos actualmente en ejecución pids = [] para subdirectorio en os.listdir ('/ proc'): si subdirectorio.isdigit (): pids.append (subdir) print ('Número total de procesos: 0'.formato (len (pids))) # Visualización de la información de CPU print ("\ n \ t \ t \ t CPU Information \ n") # Este código imprimirá el número de núcleos de CPU presentes print ("[+] Número de núcleos: ", psutil.cpu_count (lógico = Falso)) print ("[+] Número de núcleos totales:", psutil.cpu_count (logic = True)) print ("\ n") # Esto imprimirá la frecuencia de CPU máxima, mínima y actual cpu_frequency = psutil.cpu_freq () print (f "[+] Frecuencia máxima: cpu_frequency.max:.2f Mhz ") print (f" [+] Frecuencia mínima: cpu_frequency.min:.2f Mhz ") print (f" [+] Frecuencia actual: cpu_frequency.Actual:.2f Mhz ") print (" \ n ") # Esto imprimirá el uso de CPU por núcleo para i, porcentaje en enumerate (psutil.cpu_percent (percpu = True, interval = 1)): print (f "[+] Uso de CPU del núcleo i: porcentaje%") print (f "[+] Uso total de CPU: psutil.cpu_percent ()% ") # leyendo el archivo cpuinfo para imprimir el nombre # de la CPU presente con open (" / proc / cpuinfo "," r ") como f: file_info = f.readlines () cpuinfo = [x.banda().split (":") [1] para x en file_info si "nombre de modelo" en x] para índice, elemento en enumerate (cpuinfo): print ("[+] Procesador" + str (índice) + ":" + elemento ) # escribiendo una función para convertir bytes a GigaByte def bytes_to_GB (bytes): gb = bytes / (1024 * 1024 * 1024) gb = round (gb, 2) return gb # Usando la función virtual_memory () devolverá una tupla virtual_memory = psutil.virtual_memory () print ("\ n \ t \ t \ t Memory Information \ n") # Esto imprimirá los detalles de la memoria primaria print ("[+] Total Memory present:", bytes_to_GB (virtual_memory.total), "Gb") print ("[+] Memoria total disponible:", bytes_a_GB (memoria_virtual.disponible), "Gb") print ("[+] Memoria total utilizada:", bytes_a_GB (memoria_virtual.utilizado), "Gb") print ("[+] Porcentaje utilizado:", virtual_memory.percent, "%") print ("\ n") # Esto imprimirá los detalles de la memoria de intercambio si está disponible swap = psutil.swap_memory () print (f "[+] Memoria de intercambio total: bytes_to_GB (intercambio.total) ") print (f" [+] Memoria de intercambio libre: bytes_to_GB (intercambio.free) ") print (f" [+] Memoria de intercambio usada: bytes_to_GB (intercambio.usado) ") print (f" [+] Porcentaje usado: swap.percent% ") # Recopilación de información de memoria del archivo meminfo print (" \ nLeyendo el archivo / proc / meminfo: \ n ") con open (" / proc / meminfo "," r ") como f: líneas = f.readlines () print ("[+]" + líneas [0].strip ()) print ("[+]" + líneas [1].strip ()) # accediendo a todas las particiones del disco disk_partitions = psutil.disk_partitions () print ("\ n \ t \ t \ t Disk Information \ n") # mostrando la partición y la información de uso de la partición en disk_partitions: print ("[+] Partition Device:", partición.dispositivo) imprimir ("[+] Sistema de archivos:", partición.fstype) print ("[+] Mountpoint:", partición.punto de montaje) disk_usage = psutil.disk_usage (partición.mountpoint) print ("[+] Espacio total en disco:", bytes_to_GB (disk_usage.total), "GB") print ("[+] Espacio libre en disco:", bytes_to_GB (disk_usage.gratis), "GB") print ("[+] Espacio de disco usado:", bytes_to_GB (disk_usage.utilizado), "GB") print ("[+] Porcentaje utilizado:", disk_usage.percent, "%") # obtener estadísticas de lectura / escritura desde el arranque disk_rw = psutil.disk_io_counters () print (f "[+] Lectura total desde el arranque: bytes_to_GB (disk_rw.read_bytes) GB ") print (f" [+] Total Write sice boot: bytes_to_GB (disk_rw.write_bytes) GB ") # recopilación de todas las interfaces de red (virtuales y físicas) del sistema if_addrs = psutil.net_if_addrs () print ("\ n \ t \ t \ t Network Information \ n") # imprimiendo la información de las interfaces de red eah para interface_name, interface_addresses en if_addrs.items (): para la dirección en interface_addresses: print (f "Interface:", interface_name) if str (dirección.familia) == 'DirecciónFamilia.AF_INET ': print ("[+] Dirección IP:", dirección.dirección) print ("[+] Máscara de red:", dirección.netmask) print ("[+] IP de transmisión:", dirección.broadcast) elif str (dirección.familia) == 'DirecciónFamilia.AF_PACKET ': print ("[+] Dirección MAC:", dirección.dirección) print ("[+] Máscara de red:", dirección.netmask) print ("[+] Difusión MAC:", dirección.broadcast) # obteniendo las estadísticas de lectura / escritura de la red desde boot net_io = psutil.net_io_counters () print ("[+] Total de bytes enviados:", bytes_to_GB (net_io.bytes_sent)) print ("[+] Total de bytes recibidos:", bytes_to_GB (net_io.bytes_recv)) # Obteniendo la información de la batería battery = psutil.Sensores_battery () print ("\ n \ t \ t \ t Información de la batería \ n") print ("[+] Porcentaje de batería:", redondo (batería.porcentaje, 1), "%") imprimir ("[+] Tiempo de batería restante:", ronda (batería.secsleft / 3600, 2), "hr") print ("[+] Power Plugged:", batería.power_plugged)

Al ejecutar este código, obtendremos el siguiente resultado.

Si quieres mejorar el programa o quieres descargar el código, puedes hacerlo desde mi página de Github.

Conclusión

Este es el tutorial completo sobre cómo recopilar información interesante sobre el sistema y el hardware utilizando Python. Si tiene algún problema para copiar el código, también puede encontrar el código fuente completo en mi repositorio de Github. Es posible que también desee ver nuestra guía sobre cómo trabajar con el sistema operativo en Python para obtener algunos ajustes de Python más interesantes.