Come ottenere la dimensione del terminale usando Python in Linux

Quando si scrivono applicazioni da riga di comando in Python, è spesso utile conoscere la dimensione della finestra del terminale. Conoscere le dimensioni del terminale permette di formattare l'output del testo in modo ordinato, creare barre di progresso che si adattano perfettamente e progettare interfacce utente che rispondono allo spazio disponibile. Python fornisce una funzione integrata per ottenere la dimensione del terminale, che puoi usare per rendere i tuoi programmi più reattivi e visivamente accattivanti.

In questa guida, impareremo come ottenere le dimensioni del terminale e mostreremo alcune applicazioni pratiche di queste informazioni.

Ottieni la dimensione della finestra del terminale usando Python

Per ottenere la dimensione del terminale su cui il tuo codice è in esecuzione, puoi utilizzare le funzioni fornite dalle librerie in Python come os e shutil. La dimensione del terminale è solitamente rappresentata dal numero di righe (linee) e colonne (caratteri per linea).

Ecco come puoi farlo usando Python:

1. Usando os.get_terminal_size(): Questa funzione è disponibile in Python 3.3 e versioni successive.
2. Utilizzando shutil.get_terminal_size(): Questa funzione è disponibile in Python 3.3 e versioni successive, ed è più comunemente raccomandata.

Ecco un esempio di codice che utilizza shutil.get_terminal_size():

import shutil

def get_terminal_size():
    size = shutil.get_terminal_size()
    return size.columns, size.lines

columns, rows = get_terminal_size()
print(f"Terminal size: {columns} columns and {rows} rows")

Spiegazione del codice:

1. Importa shutil: Questo modulo fornisce un'interfaccia di alto livello per le operazioni sui file e include la funzione get_terminal_size().
2. Definire una funzione per ottenere la dimensione del terminale: La funzione shutil.get_terminal_size() restituisce una tupla nominata con due attributi: columns e lines.
3. Stampa la dimensione del terminale: I valori per colonne e righe vengono stampati sul terminale.

Questo metodo è semplice ed efficace per ottenere la dimensione del terminale negli script Python.

Ecco l'output del codice Python sopra nel mio sistema Debian:

Terminal size: 80 columns and 24 rows

Puoi semplificare ulteriormente questo codice come segue:

import shutil

# Get the terminal size
terminal_size = shutil.get_terminal_size()

# Print the terminal size
print(f"Terminal size: {terminal_size.columns} x {terminal_size.lines}")

L'output del codice sopra è:

Terminal size: 80 x 24

Negli esempi sopra, ho eseguito il codice all'interno della console interattiva di Python. Perché il codice degli esempi è più breve e semplice.

Puoi anche mettere il codice in un file di testo o usare qualsiasi IDE ed eseguirlo usando il comando python.

Per fare ciò, apri il tuo editor di testo o IDE preferito e crea un nuovo file, ad esempio terminal_size.py. Copia uno degli esempi di codice forniti sopra e incollalo nel file.

Apri il terminale e naviga nella directory in cui hai salvato terminal_size.py. Esegui lo script utilizzando l'interprete Python come di seguito.

$ python3 terminal_size.py

Per test rapidi e apprendimento, la console di Python è molto utile grazie al suo feedback immediato e alla natura interattiva.

Per script o progetti più grandi, organizzare il codice in file ed eseguirlo con il comando python è generalmente meglio. Questo metodo supporta una migliore organizzazione del codice, riutilizzabilità, riproducibilità e accesso a strumenti di modifica avanzati.

Scegliere tra i due dipende dalla complessità del compito e dalle tue esigenze specifiche. Per le migliori pratiche nello sviluppo software, è consigliato scrivere codice in file e utilizzare un buon editor di testo o IDE.

Andando avanti, metterò il codice in un file e lo eseguirò usando il comando python.

Alcuni esempi pratici

Conoscere la dimensione del terminale può essere utile in vari scenari, soprattutto quando si sviluppano applicazioni da riga di comando o script che interagiscono con l'utente.

Ecco alcuni casi d'uso comuni:

1. Formattazione del testo: Garantire che l'output sia correttamente formattato per adattarsi alla finestra del terminale.

Questo è utile per evitare l'andata a capo e mantenere la leggibilità. Ad esempio, per stampare testo centrato, usa il seguente esempio di frammento:

import shutil

def print_centered(text):
    columns, _ = shutil.get_terminal_size()
    print(text.center(columns))

print_centered("Hello, World!")

Esegui il codice per stampare il testo al centro della finestra del terminale:

$ python3 terminal_size.py 
                                 Hello, World!

2. Interfacce utente dinamiche: Creazione di interfacce utente basate su testo (TUI) che si adattano dinamicamente alle dimensioni del terminale.

Questo viene spesso utilizzato in strumenti come editor di testo, gestori di file o cruscotti. Ad esempio, il seguente codice disegnerà un riquadro nel tuo Terminale:

import shutil

def draw_box():
    columns, rows = shutil.get_terminal_size()
    print("+" + "-" * (columns - 2) + "+")
    for _ in range(rows - 2):
        print("|" + " " * (columns - 2) + "|")
    print("+" + "-" * (columns - 2) + "+")

draw_box()

Esegui il codice con il comando per disegnare una scatola:

$ python3 terminal_size.py 

3. Barre di progresso: Visualizzazione di barre di progresso che riempiono la larghezza della finestra del terminale.

Questo è utile per mostrare i progressi di attività come download o elaborazione di file.

import shutil
import time

def show_progress_bar(progress, total):
    columns, _ = shutil.get_terminal_size()
    bar_length = columns - 20
    filled_length = int(bar_length * progress // total)
    bar = '█' * filled_length + '-' * (bar_length - filled_length)
    print(f'\rProgress: |{bar}| {progress}/{total}', end='\r')

total = 100
for i in range(total + 1):
    show_progress_bar(i, total)
    time.sleep(0.1)
print()  # Move to the next line after completion

Eseguendo questo codice verrà visualizzata una barra di avanzamento nella finestra del Terminale:

4. Registrazione e Debug: Regolare l'output dei log per adattarlo alla finestra del terminale, rendendo più facile leggere e comprendere i log durante lo sviluppo o il debug.

Esempio di codice:

import shutil

def log_message(message):
    columns, _ = shutil.get_terminal_size()
    if len(message) > columns:
        message = message[:columns - 3] + '...'
    print(message)

log_message("This is a log message that will be truncated if it is too long for the terminal window.")

Output del codice:

5. Layout a più colonne: Creare output organizzati in più colonne che si adattano alla larghezza del terminale. Questo è utile per visualizzare elenchi o tabelle.

Esempio di codice:

import shutil

def print_columns(items, col_width=20):
    columns, _ = shutil.get_terminal_size()
    num_cols = columns // col_width
    for i in range(0, len(items), num_cols):
        print("".join(item.ljust(col_width) for item in items[i:i+num_cols]))

items = ["Item1", "Item2", "Item3", "Item4", "Item5", "Item6", "Item7", "Item8", "Item9"]
print_columns(items)

Output del codice:

Questi semplici esempi mostrano come conoscere la dimensione del terminale possa migliorare la funzionalità e l'esperienza utente delle applicazioni a riga di comando rendendo l'output più adattabile e visivamente attraente.

Risoluzione dei problemi

Se le dimensioni del tuo Terminale non possono essere interrogate per qualsiasi motivo, puoi gestire l'errore in modo appropriato fornendo una dimensione predefinita del terminale. Ad esempio:

import shutil

def get_terminal_size():
    try:
        size = shutil.get_terminal_size()
    except OSError:
        size = os.terminal_size((80, 24))  # Default size (80 columns, 24 rows)
    return size.columns, size.lines

In questo caso, la funzione get_terminal_size prende un parametro opzionale fallback, che per impostazione predefinita è (80, 24) se non fornito.

Domande Frequenti (FAQ)

D: Perché avrei bisogno di ottenere la dimensione del terminale in Python?

A: Conoscere le dimensioni del terminale è utile per formattare l'output, creare interfacce utente dinamiche, visualizzare barre di progresso, registrare messaggi e progettare giochi basati su testo. Aiuta a garantire che l'output della tua applicazione si adatti bene alla finestra del terminale dell'utente.

D: Come posso ottenere la dimensione del terminale in Python?

A: Puoi usare la funzione shutil.get_terminal_size(), che restituisce una tupla nominata con il numero di colonne e righe nel terminale.

D: Quali versioni di Python supportano shutil.get_terminal_size()?

A: La funzione shutil.get_terminal_size() è disponibile in Python 3.3 e versioni successive.

D: Posso ottenere la dimensione del terminale nelle versioni più vecchie di Python?

A: Sì, ma dovrai usare metodi diversi o librerie di terze parti. Ad esempio, puoi usare il modulo os con comandi specifici per la piattaforma o librerie esterne come blessed.

D: Quali sono alcune applicazioni pratiche della conoscenza delle dimensioni del terminale?

A: Alcune applicazioni pratiche includono:
- Centrare l'output del testo
- Creare interfacce utente basate su testo dinamiche
- Visualizzare barre di avanzamento che si adattano alla larghezza del terminale
- Formattare i log per adattarli alla finestra del terminale
- Progettare giochi o visualizzazioni basate su testo

D: Come posso assicurarmi che il mio script Python si adatti ai cambiamenti delle dimensioni del terminale?

A: Puoi chiamare periodicamente shutil.get_terminal_size() per controllare la dimensione attuale del terminale e regolare di conseguenza l'output. Questo è particolarmente utile in script o applicazioni a lunga esecuzione dove la dimensione del terminale potrebbe cambiare durante l'esecuzione.

D: Ci sono limitazioni nell'utilizzo di shutil.get_terminal_size()?

A: La principale limitazione è che funziona solo quando è collegato un terminale. Se esegui lo script in un ambiente senza terminale (ad esempio, un processo in background o un servizio), potrebbe generare un OSError.

D: Cosa dovrei fare se shutil.get_terminal_size() genera un errore?

A: Puoi gestire l'errore in modo corretto fornendo una dimensione del terminale predefinita. Consulta la sezione Risoluzione dei problemi sopra per i dettagli.

D: Posso personalizzare la dimensione predefinita in caso di errore?

A: Sì, puoi personalizzare la dimensione predefinita modificando i valori in os.terminal_size((80, 24)) per adattarli alle tue esigenze.

Conclusione

In questo tutorial, abbiamo imparato come interrogare la dimensione del terminale con la funzione integrata di Python in Linux e i suoi casi d'uso con alcuni esempi pratici.

Capire le dimensioni del terminale ti permette di creare applicazioni da riga di comando più user-friendly. Usando la funzione shutil.get_terminal_size(), puoi facilmente adattare l'output del tuo programma alla finestra del terminale.

Questo rende le tue applicazioni più belle e più efficienti. Che tu stia centrando il testo, disegnando caselle, mostrando barre di progresso, registrando messaggi o stampando colonne, conoscere la dimensione del terminale può migliorare significativamente il design della tua interfaccia a riga di comando.

Risorsa:

• Documentazione di Python 3 shutil