FTrovare informazioni sull’hardware e sul sistema in Linux è un compito utile e interessante. Possiamo estrarre i dettagli del sistema operativo, i dettagli dell’utente, i dettagli della memoria, i dettagli della CPU e molto altro utilizzando semplici codici Python su Linux. Sebbene possiamo eseguire molte di queste cose usando il terminale e lo scripting bash, python è molto più interessante.

Come amante di python, vogliamo che ogni attività venga eseguita utilizzando quel linguaggio, quindi estrarre informazioni di sistema e hardware con python è un ottimo compito. Inoltre, possiamo imparare sia Linux che python contemporaneamente. Questo articolo sarà piuttosto lungo, quindi prenditi il ​​tuo tempo per leggere l’intero articolo ed eseguire ogni codice per una migliore comprensione.

Puoi copiare ciascuno dei codici in un IDE python ed eseguirlo. Se non disponi di un IDE python o desideri confrontare l’IDE, consulta la nostra guida sui 10 migliori IDE per Linux. A proposito, sto usando il codice VS come IDE per scrivere codice. È open source e facile da usare. Se vuoi usare Visual Studio Code, consulta la nostra guida sull’installazione del codice VS su Linux.

Estrazione delle informazioni di sistema utilizzando Python

In questo articolo, svilupperemo un programma che estrarrà i seguenti dettagli:

  • Dettagli di base del sistema
  • Dettagli CPU
  • Informazioni sulla memoria
  • Uso del disco
  • Informazioni di rete
  • Altri dettagli hardware

Per ottenere questi dettagli, utilizzeremo i moduli presenti nella libreria standard di Python. Alcuni dei moduli che useremo sono OS, piattaforma, ecc. Ho anche inserito il codice sorgente in Github; puoi vedere una demo del programma scaricando dal mio repository Github ed eseguendolo.

Per seguire questo tutorial, si consiglia di avere l’ultima versione di python installata nel proprio sistema. Puoi seguire la nostra guida sull’installazione di python su Linux.

Requisiti

Molte delle librerie che utilizziamo in questo tutorial sono presenti nella libreria standard python. Abbiamo solo bisogno di installare il pacchetto psutil. Puoi verificarlo importandolo. Se non hai installato psutil, puoi installarlo facilmente usando lo strumento pip. Per installare pip nel nostro sistema, dobbiamo eseguire il seguente comando nel terminale.

pip install psutil

Ottenere i dettagli di base del sistema

Ora che hai installato psutil vediamo come usarlo per raccogliere OS usando python. Stavamo usando il piattaforma modulo presente nella libreria standard python per raccogliere queste informazioni di sistema di base. Devi copiare il codice seguente nel tuo IDE Python preferito ed eseguirlo.

# importing the required modules

import platform

# printing the Architecture of the OS
print("[+] Architecture :", platform.architecture()[0])

# Displaying the machine
print("[+] Machine :", platform.machine())

# printing the Operating System release information
print("[+] Operating System Release :", platform.release())

# prints the currently using system name
print("[+] System Name :",platform.system())

# This line will print the version of your Operating System
print("[+] Operating System Version :", platform.version())

# This will print the Node or hostname of your Operating System
print("[+] Node: " + platform.node())

# This will print your system platform
print("[+] Platform :", platform.platform())

# This will print the processor information
print("[+] Processor :",platform.processor())

Nel codice sopra, abbiamo prima importato il modulo della piattaforma presente nella libreria standard di python. Dopo aver importato il modulo, utilizziamo le funzioni del modulo della piattaforma per ottenere le informazioni richieste. Eseguendo il codice sul mio dispositivo, ho ottenuto il seguente output.

informazioni di sistema di base utilizzando python
informazioni di sistema di base utilizzando python

Come possiamo vedere nell’output, il programma mostra molti dettagli importanti sul sistema operativo come l’architettura del sistema, la piattaforma e molto altro.

Tempo di attività del sistema

Possiamo anche ottenere il tempo di avvio del sistema e il tempo di attività del sistema in python. Dobbiamo usare il file psutil libreria che abbiamo installato in precedenza. Possiamo ottenere il tempo di attività del sistema leggendo il file di tempo di attività presente nella directory proc in Linux.

Copia il seguente codice nel tuo IDE Python preferito ed eseguilo.

from datetime import datetime
import psutil

# Using the psutil library to get the boot time of the system
boot_time = datetime.fromtimestamp(psutil.boot_time())
print("[+] System Boot Time :", boot_time)

Questo codice stamperà l’ora di avvio, ovvero l’ora in cui il sistema è stato avviato. Eseguendo il programma sul mio PC, ho ottenuto il seguente output.

avvio del sistema utilizzando python
tempo di avvio del sistema utilizzando python

Possiamo anche vedere il tempo di attività del sistema, che è il tempo per il quale il sistema è in esecuzione. Dobbiamo leggere il file di uptime della directory proc, come mostrato nel codice seguente.

# getting thesystem up time from the uptime file at proc directory
with open("/proc/uptime", "r") as f:
    uptime = f.read().split(" ")[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")

Ho il seguente output sull’esecuzione del codice.

tempo di attività del sistema utilizzando python
tempo di attività del sistema utilizzando python

Processi

Possiamo anche usare python per ottenere un elenco dei processi attualmente in esecuzione, numero totale di processi. Dobbiamo eseguire il codice seguente.

import os

pids = []
for subdir in os.listdir('/proc'):
    if subdir.isdigit():
        pids.append(subdir)
print('Total number of processes : {0}'.format(len(pids)))

Durante l’esecuzione del codice, ho ottenuto l’output, come mostrato nell’immagine sottostante.

numero totale di processi
numero totale di processi

informazioni utente

Possiamo anche ottenere l’elenco di tutti gli utenti presenti nel nostro dispositivo Linux utilizzando la libreria pwd presente nella libreria standard python. Per fare ciò, devi copiare il seguente codice nel tuo IDE python ed eseguirlo.

import pwd

users = pwd.getpwall()
for user in users:
    print(user.pw_name, user.pw_shell)

Eseguendo il codice sopra, otterrai tutti gli utenti presenti nel tuo dispositivo e le loro shell.

Informazioni sulla CPU

Abbiamo raccolto i dettagli del sistema ora per raccogliere alcune informazioni sulla CPU utilizzata dalla nostra macchina. Possiamo raccogliere informazioni sulla CPU dalla nostra macchina Linux in due modi. Il primo e il modo più semplice è usare il file psutil e il secondo modo è leggere il file / proc / cpuinfo.

Vediamo come possiamo usare la libreria psutil per ottenere le informazioni sulla CPU. Devi copiare il codice seguente nel tuo IDE Python preferito ed eseguirlo.

# importing the required packages
import psutil

# This code will print the number of CPU cores present
print("[+] Number of Physical cores :", psutil.cpu_count(logical=False))
print("[+] Number of Total cores :", psutil.cpu_count(logical=True))
print("n")
# This will print the maximum, minimum and current CPU frequency
cpu_frequency = psutil.cpu_freq()
print(f"[+] Max Frequency : {cpu_frequency.max:.2f}Mhz")
print(f"[+] Min Frequency : {cpu_frequency.min:.2f}Mhz")
print(f"[+] Current Frequency : {cpu_frequency.current:.2f}Mhz")
print("n")
# This will print the usage of CPU per core
for i, percentage in enumerate(psutil.cpu_percent(percpu=True, interval=1)):
    print(f"[+] CPU Usage of Core {i} : {percentage}%")
print(f"[+] Total CPU Usage : {psutil.cpu_percent()}%")

Vediamo cosa sta succedendo nel programma di cui sopra. Nella prima riga abbiamo importato il file psutil modulo, che aiuterà a raccogliere i dettagli della CPU. Nella seconda e terza riga, usiamo il cpu_count () funzione del psutil modulo per contare il numero di core della CPU. Quindi abbiamo utilizzato la funzione cpu_freq () per ottenere la frequenza massima, minima e corrente. Infine, usiamo la funzione cpu_percent di psutil per trovare l’utilizzo della CPU. Durante l’esecuzione del codice nella mia macchina, ho ottenuto il seguente output.

informazioni sulla CPU utilizzando psutil
Informazioni sulla CPU utilizzando psutil

Come possiamo vedere nell’output che tutti i dettagli della CPU sono stati emessi dal programma nel terminale. Possiamo anche ottenere il nome della CPU leggendo il file / proc / cpuinfo usando python. Per fare ciò, dobbiamo eseguire il codice seguente.

# reading the cpuinfo file to print the name of
# the CPU present
with open("/proc/cpuinfo", "r") as f:
    file_info = f.readlines()

cpuinfo = [x.strip().split(":")[1] for x in file_info if "model name" in x]
for index, item in enumerate(cpuinfo):
    print("[+] Processor " + str(index) + " : " + item)

Possiamo anche raccogliere altre informazioni sulla CPU usando il file / proc / cpuinfo. Ho letto solo il nome del modello di CPU, ma puoi aprire il file e vedere le altre informazioni presenti nel file e puoi usarle nel programma. Ecco l’output.

informazioni sulla CPU utilizzando il file cpuinfo
Informazioni sulla CPU utilizzando il file cpuinfo

Raccogliamo alcune informazioni sulla memoria usando python.

Informazioni sulla memoria

Come le informazioni sulla CPU, possiamo anche ottenere informazioni sulla memoria da due posti. Uno sta usando lo strumento psutil e il secondo è leggendo il file proc / meminfo. Per cominciare, iniziamo a raccogliere informazioni sulla memoria usando la libreria psutil. Copia il seguente codice nel tuo IDE Python preferito ed eseguilo.

# importing the requred modules
import psutil

# writing a function to convert bytes to GigaByte
def bytes_to_GB(bytes):
    gb = bytes/(1024*1024*1024)
    gb = round(gb, 2)
    return gb

# Using the virtual_memory() function it will return a tuple
virtual_memory = psutil.virtual_memory()

#This will print the primary memory details
print("[+] Total Memory present :", bytes_to_GB(virtual_memory.total), "Gb")
print("[+] Total Memory Available :", bytes_to_GB(virtual_memory.available), "Gb")
print("[+] Total Memory Used :", bytes_to_GB(virtual_memory.used), "Gb")
print("[+] Percentage Used :", virtual_memory.percent, "%")
print("n")

# This will print the swap memory details if available
swap = psutil.swap_memory()
print(f"[+] Total swap memory :{bytes_to_GB(swap.total)}")
print(f"[+] Free swap memory : {bytes_to_GB(swap.free)}")
print(f"[+] Used swap memory : {bytes_to_GB(swap.used)}")
print(f"[+] Percentage Used: {swap.percent}%")

Vediamo cosa sta succedendo nel codice sopra. Nella prima riga, abbiamo importato la libreria psutil, quindi abbiamo usato la sua funzione virtual_memory (), che restituisce una tupla con informazioni sulla memoria virtuale. Quindi usiamo la funzione swap_memory () per ottenere le informazioni della memoria di swap. Abbiamo anche creato un nome di funzione bytes_to_GB (), che convertirà i byte in GigaByte per una migliore leggibilità. Ho ottenuto il seguente output.

informazioni sulla memoria usando psutil
informazioni sulla memoria usando psutil

Possiamo anche usare il file meminfo presente nella directory proc di Linux per recuperare informazioni sulla memoria come la memoria totale, la memoria utilizzata, ecc. Per fare ciò, esegui il codice seguente.

# Gathering memory information from meminfo file
print("nReading the /proc/meminfo file: n")
with open("/proc/meminfo", "r") as f:
    lines = f.readlines()

print("[+] " + lines[0].strip())
print("[+] " + lines[1].strip())

Ed ecco l’output:

informazioni sulla memoria utilizzando il file meminfo

Informazioni sul disco

Fino ad ora, abbiamo visto alcuni dettagli di sistema di base, dettagli della CPU, dettagli della memoria. Vediamo ora le informazioni sul disco presente nella nostra macchina. Per estrarre le informazioni sul disco, useremo il modulo psutil per semplificare il nostro compito e non abbiamo bisogno di reinventare la ruota. Guarda il codice seguente per vedere un esempio funzionante del codice. Puoi copiare il codice ed eseguirlo nell’IDE del tuo Python preferito.

# importing required modules
import psutil

# accessing all the disk partitions
disk_partitions = psutil.disk_partitions()

# writing a function to convert bytes to Giga bytes
def bytes_to_GB(bytes):
    gb = bytes/(1024*1024*1024)
    gb = round(gb, 2)
    return gb

# displaying the partition and usage information
for partition in disk_partitions:
    print("[+] Partition Device : ", partition.device)
    print("[+] File System : ", partition.fstype)
    print("[+] Mountpoint : ", partition.mountpoint)
    
    disk_usage = psutil.disk_usage(partition.mountpoint)
    print("[+] Total Disk Space :", bytes_to_GB(disk_usage.total), "GB")
    print("[+] Free Disk Space :", bytes_to_GB(disk_usage.free), "GB")
    print("[+] Used Disk Space :", bytes_to_GB(disk_usage.used), "GB")
    print("[+] Percentage Used :", disk_usage.percent, "%")

# get read/write statistics since boot
disk_rw = psutil.disk_io_counters()
print(f"[+] Total Read since boot : {bytes_to_GB(disk_rw.read_bytes)} GB")
print(f"[+] Total Write sice boot : {bytes_to_GB(disk_rw.write_bytes)} GB")

Nel codice abbiamo prima importato la libreria psutil, necessaria per raccogliere le informazioni sul disco. Quindi abbiamo usato il suo disk_partitions () funzione per ottenere l’elenco delle partizioni del disco disponibili con le relative informazioni. Usiamo anche la funzione disk_usage () per ottenere l’utilizzo di queste partizioni. Infine, usiamo il disk_io_counters () funzione per ottenere la lettura / scrittura totale del disco dall’avvio. Ecco un esempio di output.

informazioni sul disco utilizzando python

Potresti ottenere qualche altro output a seconda del tuo disco e delle partizioni.

Informazioni di rete

Possiamo anche raccogliere le informazioni di rete del sistema usando la libreria psutil. Per fare ciò, copia il seguente codice nel tuo IDE python ed eseguilo.

# importing the required modules
import psutil

# writing a function to convert the bytes into gigabytes
def bytes_to_GB(bytes):
    gb = bytes/(1024*1024*1024)
    gb = round(gb, 2)
    return gb

# gathering all network interfaces (virtual and physical) from the system
if_addrs = psutil.net_if_addrs()

# printing the information of each network interfaces
for interface_name, interface_addresses in if_addrs.items():
    for address in interface_addresses:
        print("n")
        print(f"Interface :", interface_name)
        if str(address.family) == 'AddressFamily.AF_INET':
            print("[+] IP Address :", address.address)
            print("[+] Netmask :", address.netmask)
            print("[+] Broadcast IP :", address.broadcast)
        elif str(address.family) == 'AddressFamily.AF_PACKET':
            print("[+] MAC Address :", address.address)
            print("[+] Netmask :", address.netmask)
            print("[+] Broadcast MAC :",address.broadcast)

# getting the read/write statistics of network since boot
print("n")
net_io = psutil.net_io_counters()
print("[+] Total Bytes Sent :", bytes_to_GB(net_io.bytes_sent))
print("[+] Total Bytes Received :", bytes_to_GB(net_io.bytes_recv))

Ecco un esempio di output dal mio PC di prova.

informazioni di rete utilizzando python
informazioni di rete utilizzando python

Altre informazioni sull’hardware

Possiamo anche usare il psutil libreria per ottenere altre informazioni sull’hardware come informazioni sulla batteria, velocità di rotazione delle ventole, informazioni sulla temperatura di vari dispositivi, ecc. Vediamo come possiamo farlo uno per uno.

Se stai usando un laptop, puoi usare il psutil.sensors_battery () per ottenere le informazioni sulla batteria. Per fare ciò, copia ed esegui il seguente codice nel tuo IDE Python.

import psutil

battery = psutil.sensors_battery()
print("[+] Battery Percentage :", round(battery.percent, 1), "%")
print("[+] Battery time left :", round(battery.secsleft/3600, 2), "hr")
print("[+] Power Plugged :", battery.power_plugged)

Nel codice sopra, usiamo il sensori_batteria () funzione per ottenere le informazioni sulla batteria, come la percentuale della batteria, il tempo rimanente, l’alimentazione collegata o meno. Eseguendo il codice nella mia macchina, ho ottenuto il seguente output.

informazioni sulla batteria utilizzando python
informazioni sulla batteria utilizzando python

Possiamo anche usare la libreria psutil per ottenere l’RPM della ventola (Revolutions Per Minute) utilizzando la funzione sensor_fan () mentre la ventola è in funzione. Lo psutil può essere utilizzato anche per ottenere la temperatura di vari dispositivi. Possiamo farlo usando il funzione sensor_temperatures () di psutil. Lascio che tu lo faccia per esercitarti.

Script finale

Ora combiniamo tutti i codici con la creazione di un programma finale per raccogliere tutti i dettagli di sistema e hardware di cui abbiamo discusso. Puoi copiare il seguente programma ed eseguirlo nel tuo IDE python.

# importing the required modules
import platform
from datetime import datetime
import psutil
import os

# First We will print the basic system information
# using the platform module

print("nttt Basic System Informationn")
print("[+] Architecture :", platform.architecture()[0])
print("[+] Machine :", platform.machine())
print("[+] Operating System Release :", platform.release())
print("[+] System Name :",platform.system())
print("[+] Operating System Version :", platform.version())
print("[+] Node: " + platform.node())
print("[+] Platform :", platform.platform())
print("[+] Processor :",platform.processor())

# Using the psutil library to get the boot time of the system
boot_time = datetime.fromtimestamp(psutil.boot_time())
print("[+] System Boot Time :", boot_time)
# getting the system up time from the uptime file at proc directory

with open("/proc/uptime", "r") as f:
    uptime = f.read().split(" ")[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")

# getting the total number of processes currently running
pids = []
for subdir in os.listdir('/proc'):
    if subdir.isdigit():
        pids.append(subdir)
print('Total number of processes : {0}'.format(len(pids)))

# Displaying The CPU information
print("nttt CPU Informationn")

# This code will print the number of CPU cores present
print("[+] Number of Physical cores :", psutil.cpu_count(logical=False))
print("[+] Number of Total cores :", psutil.cpu_count(logical=True))
print("n")

# This will print the maximum, minimum and current CPU frequency
cpu_frequency = psutil.cpu_freq()
print(f"[+] Max Frequency : {cpu_frequency.max:.2f}Mhz")
print(f"[+] Min Frequency : {cpu_frequency.min:.2f}Mhz")
print(f"[+] Current Frequency : {cpu_frequency.current:.2f}Mhz")
print("n")

# This will print the usage of CPU per core
for i, percentage in enumerate(psutil.cpu_percent(percpu=True, interval=1)):
    print(f"[+] CPU Usage of Core {i} : {percentage}%")
    print(f"[+] Total CPU Usage : {psutil.cpu_percent()}%")

# reading the cpuinfo file to print the name of
# the CPU present

with open("/proc/cpuinfo", "r") as f:
    file_info = f.readlines()

cpuinfo = [x.strip().split(":")[1] for x in file_info if "model name" in x]

for index, item in enumerate(cpuinfo):
    print("[+] Processor " + str(index) + " : " + item)

# writing a function to convert bytes to GigaByte
def bytes_to_GB(bytes):
    gb = bytes/(1024*1024*1024)
    gb = round(gb, 2)
    return gb

# Using the virtual_memory() function it will return a tuple
virtual_memory = psutil.virtual_memory()
print("nttt Memory Informationn")
#This will print the primary memory details
print("[+] Total Memory present :", bytes_to_GB(virtual_memory.total), "Gb")
print("[+] Total Memory Available :", bytes_to_GB(virtual_memory.available), "Gb")
print("[+] Total Memory Used :", bytes_to_GB(virtual_memory.used), "Gb")
print("[+] Percentage Used :", virtual_memory.percent, "%")
print("n")

# This will print the swap memory details if available
swap = psutil.swap_memory()
print(f"[+] Total swap memory :{bytes_to_GB(swap.total)}")
print(f"[+] Free swap memory : {bytes_to_GB(swap.free)}")
print(f"[+] Used swap memory : {bytes_to_GB(swap.used)}")
print(f"[+] Percentage Used: {swap.percent}%")

# Gathering memory information from meminfo file

print("nReading the /proc/meminfo file: n")
with open("/proc/meminfo", "r") as f:
    lines = f.readlines()
print("[+] " + lines[0].strip())
print("[+] " + lines[1].strip())

# accessing all the disk partitions
disk_partitions = psutil.disk_partitions()
print("nttt Disk Informationn")

# displaying the partition and usage information
for partition in disk_partitions:
    print("[+] Partition Device : ", partition.device)
    print("[+] File System : ", partition.fstype)
    print("[+] Mountpoint : ", partition.mountpoint)
    
    disk_usage = psutil.disk_usage(partition.mountpoint)
    print("[+] Total Disk Space :", bytes_to_GB(disk_usage.total), "GB")
    print("[+] Free Disk Space :", bytes_to_GB(disk_usage.free), "GB")
    print("[+] Used Disk Space :", bytes_to_GB(disk_usage.used), "GB")
    print("[+] Percentage Used :", disk_usage.percent, "%")

# get read/write statistics since boot
disk_rw = psutil.disk_io_counters()
print(f"[+] Total Read since boot : {bytes_to_GB(disk_rw.read_bytes)} GB")
print(f"[+] Total Write sice boot : {bytes_to_GB(disk_rw.write_bytes)} GB")

# gathering all network interfaces (virtual and physical) from the system
if_addrs = psutil.net_if_addrs()
print("nttt Network Informationn")
# printing the information of eah network interfaces
for interface_name, interface_addresses in if_addrs.items():
    for address in interface_addresses:
        print(f"Interface :", interface_name)
        if str(address.family) == 'AddressFamily.AF_INET':
            print("[+] IP Address :", address.address)
            print("[+] Netmask :", address.netmask)
            print("[+] Broadcast IP :", address.broadcast)
        elif str(address.family) == 'AddressFamily.AF_PACKET':
            print("[+] MAC Address :", address.address)
            print("[+] Netmask :", address.netmask)
            print("[+] Broadcast MAC :",address.broadcast)

# getting the read/write statistics of network since boot
net_io = psutil.net_io_counters()
print("[+] Total Bytes Sent :", bytes_to_GB(net_io.bytes_sent))
print("[+] Total Bytes Received :", bytes_to_GB(net_io.bytes_recv))

# Getting The battery Information
battery = psutil.sensors_battery()
print("nttt Battery Informationn")
print("[+] Battery Percentage :", round(battery.percent, 1), "%")
print("[+] Battery time left :", round(battery.secsleft/3600, 2), "hr")
print("[+] Power Plugged :", battery.power_plugged)

Eseguendo questo codice, otterremo il seguente output.

uno strumento per estrarre informazioni sul sistema e sull'hardware utilizzando python
uno strumento per estrarre informazioni di sistema e hardware utilizzando python

Se vuoi migliorare il programma o vuoi scaricare il codice, puoi farlo dalla mia pagina Github.

Conclusione

Questo è il tutorial completo sulla raccolta di alcune informazioni interessanti sul sistema e sull’hardware usando python. Se hai qualche problema con la copia del codice, puoi anche trovare il codice sorgente completo nel mio repository Github. Potresti anche consultare la nostra guida su come lavorare con il sistema operativo in python per alcune modifiche più interessanti di python.


Ti e piaciuto questo articolo?
Supporta il mio lavoro, facendo una donazione!

Esegui l'accesso per Commentare