Comment obtenir la taille du terminal en utilisant Python sous Linux

Lorsqu'on écrit des applications en ligne de commande en Python, il est souvent utile de connaître la taille de la fenêtre du terminal. Connaître les dimensions du terminal permet de formater le texte de manière soignée, de créer des barres de progression qui s'ajustent parfaitement et de concevoir des interfaces utilisateur qui s'adaptent à l'espace disponible. Python fournit une fonction intégrée pour obtenir la taille du terminal, que vous pouvez utiliser pour rendre vos programmes plus réactifs et esthétiquement agréables.

Dans ce guide, nous apprendrons comment obtenir les dimensions du terminal et démontrerons quelques applications pratiques de cette information.

Obtenir la taille de la fenêtre du terminal en utilisant Python

Pour obtenir la taille du terminal sur lequel votre code s'exécute, vous pouvez utiliser les fonctions fournies par des bibliothèques en Python telles que os et shutil. La taille du terminal est généralement représentée par le nombre de lignes et de colonnes (caractères par ligne).

Voici comment vous pouvez le faire en utilisant Python :

1. Utilisation de os.get_terminal_size() : Cette fonction est disponible dans Python 3.3 et les versions ultérieures.
2. Utilisation de shutil.get_terminal_size() : Cette fonction est disponible dans Python 3.3 et versions ultérieures, et elle est plus couramment recommandée.

Voici un exemple de code utilisant 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")

Explication du code :

1. Importer shutil : Ce module fournit une interface de haut niveau pour les opérations sur les fichiers et inclut la fonction get_terminal_size().
2. Définir une fonction pour obtenir la taille du terminal : La fonction shutil.get_terminal_size() renvoie un tuple nommé avec deux attributs : columns et lines.
3. Afficher la taille du terminal : Les valeurs des colonnes et des lignes sont affichées dans le terminal.

Cette méthode est simple et efficace pour obtenir la taille du terminal dans les scripts Python.

Voici la sortie du code Python ci-dessus sur mon système Debian :

Terminal size: 80 columns and 24 rows

Vous pouvez simplifier davantage ce code comme suit :

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}")

La sortie du code ci-dessus est :

Terminal size: 80 x 24

Dans les exemples ci-dessus, j'ai exécuté le code dans la console interactive Python. Parce que le code exemple est plus court et simple.

Vous pouvez également mettre le code dans un fichier texte ou utiliser n'importe quel IDE et l'exécuter en utilisant la commande python.

Pour ce faire, ouvrez votre éditeur de texte ou IDE préféré et créez un nouveau fichier, par exemple terminal_size.py. Copiez l’un des exemples de code fournis ci-dessus et collez-le dans le fichier.

Ouvrez votre terminal et naviguez jusqu'au répertoire où vous avez enregistré terminal_size.py. Exécutez le script en utilisant l'interpréteur Python comme suit.

$ python3 terminal_size.py

Pour des tests rapides et l'apprentissage, la console Python est très utile en raison de son retour immédiat et de son caractère interactif.

Pour les scripts ou projets plus volumineux, organiser le code en fichiers et les exécuter avec la commande python est généralement préférable. Cette méthode favorise une meilleure organisation du code, la réutilisation, la reproductibilité et l'accès à des outils d'édition avancés.

Choisir entre les deux dépend de la complexité de la tâche et de vos besoins spécifiques. Pour les meilleures pratiques en développement logiciel, il est recommandé d'écrire le code dans des fichiers et d'utiliser un bon éditeur de texte ou un IDE.

À l'avenir, je mettrai le code dans un fichier et l'exécuterai en utilisant la commande python.

Quelques exemples pratiques

Connaître la taille du terminal peut être utile dans divers scénarios, surtout lors du développement d'applications en ligne de commande ou de scripts qui interagissent avec l'utilisateur.

Voici quelques cas d'utilisation courants :

1. Mise en forme du texte : S'assurer que la sortie est correctement formatée pour s'adapter à la fenêtre du terminal.

Ceci est utile pour éviter les retours à la ligne et maintenir la lisibilité. Par exemple, pour imprimer du texte centré, utilisez l'exemple de code suivant :

import shutil

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

print_centered("Hello, World!")

Exécutez le code pour afficher le texte au centre de la fenêtre du terminal :

$ python3 terminal_size.py 
                                 Hello, World!

2. Interfaces utilisateur dynamiques : Création d'interfaces utilisateur basées sur du texte (IUT) qui s'ajustent dynamiquement à la taille du terminal.

Ceci est souvent utilisé dans des outils comme les éditeurs de texte, les gestionnaires de fichiers ou les tableaux de bord. Par exemple, le code suivant dessinera une boîte dans votre Terminal :

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()

Exécutez le code avec la commande pour dessiner une boîte :

$ python3 terminal_size.py 

3. Barres de progression : Affichage de barres de progression qui remplissent la largeur de la fenêtre du terminal.

Ceci est utile pour montrer la progression des tâches telles que les téléchargements ou le traitement de fichiers.

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

L'exécution de ce code affichera une barre de progression dans votre fenêtre de Terminal :

4. Journalisation et débogage : Ajuster la sortie du journal pour qu'elle s'adapte à la fenêtre du terminal, ce qui facilite la lecture et la compréhension des journaux pendant le développement ou le débogage.

Exemple de code :

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.")

Sortie du code :

5. Mises en page multi-colonnes : Créer des sorties organisées en plusieurs colonnes qui s'ajustent à la largeur du terminal. Cela est utile pour afficher des listes ou des tableaux.

Exemple de code :

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)

Sortie du code :

Ces exemples simples montrent comment connaître la taille du terminal peut améliorer la fonctionnalité et l'expérience utilisateur des applications en ligne de commande en rendant la sortie plus adaptative et visuellement attrayante.

Dépannage

Si la taille de votre Terminal ne peut pas être interrogée pour une raison quelconque, vous pouvez gérer l'erreur de manière élégante en fournissant une taille de terminal par défaut. Par exemple :

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

Dans ce cas, la fonction get_terminal_size prend un paramètre optionnel fallback, qui prend par défaut la valeur (80, 24) s'il n'est pas fourni.

Questions Fréquemment Posées (FAQ)

Q : Pourquoi aurais-je besoin d'obtenir la taille du terminal en Python ?

A : Connaître la taille du terminal est utile pour formater la sortie, créer des interfaces utilisateur dynamiques, afficher des barres de progression, enregistrer des messages et concevoir des jeux basés sur du texte. Cela aide à garantir que la sortie de votre application s'adapte bien à la fenêtre du terminal de l'utilisateur.

Q : Comment puis-je obtenir la taille du terminal en Python ?

A : Vous pouvez utiliser la fonction shutil.get_terminal_size(), qui renvoie un tuple nommé avec le nombre de colonnes et de lignes dans le terminal.

Q : Quelles versions de Python prennent en charge shutil.get_terminal_size() ?

A : La fonction shutil.get_terminal_size() est disponible dans Python 3.3 et les versions ultérieures.

Q : Puis-je obtenir la taille du terminal dans les anciennes versions de Python ?

A : Oui, mais vous devrez utiliser des méthodes différentes ou des bibliothèques tierces. Par exemple, vous pouvez utiliser le module os avec des commandes spécifiques à la plateforme ou des bibliothèques externes comme blessed.

Q : Quelles sont certaines applications pratiques de la connaissance de la taille du terminal ?

A : Certaines applications pratiques incluent :
- Centrer la sortie de texte
- Créer des interfaces utilisateur dynamiques basées sur le texte
- Afficher des barres de progression qui s'ajustent à la largeur du terminal
- Formater les journaux pour s'adapter à la fenêtre du terminal
- Concevoir des jeux ou des visualisations basés sur le texte

Q : Comment puis-je m'assurer que mon script Python s'adapte aux changements de taille du terminal ?

A : Vous pouvez appeler périodiquement shutil.get_terminal_size() pour vérifier la taille actuelle du terminal et ajuster votre sortie en conséquence. Cela est particulièrement utile dans les scripts ou applications de longue durée où la taille du terminal pourrait changer pendant l'exécution.

Q : Y a-t-il des limitations à l'utilisation de shutil.get_terminal_size() ?

A : La principale limitation est qu'il ne fonctionne que lorsqu'un terminal est attaché. Si vous exécutez le script dans un environnement sans terminal (par exemple, un processus en arrière-plan ou un service), il peut provoquer une OSError.

Q : Que devrais-je faire si shutil.get_terminal_size() génère une erreur ?

A : Vous pouvez gérer l'erreur de manière élégante en fournissant une taille de terminal par défaut. Veuillez consulter la section Dépannage ci-dessus pour plus de détails.

Q : Puis-je personnaliser la taille par défaut en cas d'erreur ?

A : Oui, vous pouvez personnaliser la taille par défaut en modifiant les valeurs dans os.terminal_size((80, 24)) pour les adapter à vos besoins.

Conclusion

Dans ce tutoriel, nous avons appris comment interroger la taille du terminal avec la fonction intégrée de Python sous Linux et ses cas d'utilisation avec quelques exemples pratiques.

Comprendre la taille du terminal vous permet de créer des applications en ligne de commande plus conviviales. En utilisant la fonction shutil.get_terminal_size(), vous pouvez facilement ajuster la sortie de votre programme pour qu'elle s'adapte à la fenêtre du terminal.

Cela rend vos applications plus esthétiques et plus efficaces. Que vous centriez du texte, dessiniez des encadrés, affichiez des barres de progression, enregistriez des messages ou imprimiez des colonnes, connaître la taille du terminal peut considérablement améliorer la conception de votre interface en ligne de commande.

Ressource:

• Documentation de shutil Python 3