Les Commandes du Terminal à maîtriser si tu travailles dans la Data

Ce terminal a beau être moche, il est sacrément pratique

Quand on débute avec le terminal, on peut vite se sentir perdu.

L’interface est austère, les commandes sont des abréviations de quelques lettres pas très parlantes, il n’y a pas d’interface graphique.

À se demander pourquoi on s’embête autant avec ce terminal.

La raison est simple : le terminal est une boîte à outils flexible et quasi infinie.

Il est indispensable pour toutes les tâches que l’on souhaite réaliser : lancer une commande, exécuter un script, inspecter des fichiers, effectuer une modification rapide, gérer le contrôle de version, déployer du code, gérer les dépendances d’un projet, les environnements virtuels, etc.

Dans l’édition de cette newsletter, on découvre ensemble :

• Les commandes de base

• Les principaux opérateurs

• Comment utiliser les commandes du terminal dans un script Python

C’est parti !

Les commandes de base

Commençons par le commencement.

Quelles sont les commandes à connaître absolument pour vous en sortir avec votre terminal ? Voici le kit minimal de survie :

• ls (list) → Affiche le contenu (tous les dossiers et fichiers) du répertoire actuel. On peut ajouter des options comme -l (pour obtenir plus de détail) ou -a (affiche tous les fichiers, y compris les fichiers cachés).

  • Exemple : ls -la

• cd (change directory) → Permet de changer de répertoire. Par exemple, pour aller dans un dossier nommé Documents, on peut faire :

  • cd Documents

  • cd .. → Remonte d'un niveau dans la hiérarchie des dossiers (“.” seul représente le dossier actuel)

  • cd ~ ou simplement cd → Va directement au répertoire personnel de l'utilisateur.

• pwd (print working directory) → Affiche le chemin complet du répertoire actuel. Cela permet de connaître son emplacement dans l’arborescence des dossiers.

• mkdir (make directory) → Crée un nouveau dossier. Par exemple, pour créer un dossier appelé NouveauDossier :

  • mkdir NouveauDossier

• rm (remove) → Supprime un fichier (attention, c’est irréversible !)

  • rm fichier.txt

  • rm -r NouveauDossier → Supprime un dossier et tout son contenu de façon récursive.

  • rm -f → Force la suppression sans confirmation.

• cp (copy) → Copie un fichier ou un dossier vers une autre destination.

  • cp fichier.txt /chemin/vers/dossier/copie_fichier.txt

• mv (move) → Déplace ou renomme un fichier ou un dossier.

  • Renommer : mv fichier.txt nouveau_nom.txt

  • Déplacer : mv fichier.txt /chemin/vers/dossier/

• touch : Crée un nouveau fichier vide.

  • touch nouveau_fichier.txt

• cat : Affiche le contenu d'un fichier directement dans le terminal.

  • cat fichier.txt

• echo : Affiche un texte ou une variable.

  • echo "Hello, world!"

Les principaux opérateurs

Imaginons maintenant que l’on veuille réaliser une tâche plus complexe :

Récupérer un fichier sur internet, le filtrer pour en récupérer une sous partie puis enregistrer le résultat final dans un nouveau fichier.

Pour réaliser cela, on va avoir besoin d’une commande permettant de récupérer le fichier (curl), d’une commande pour filtrer (grep) puis de deux opérateurs (| et >) permettant d’enchaîner des commandes et d’enregistrer le résultat dans un nouveau fichier.

Commençons par la commande curl (Client URL) → Elle permet de télécharger des fichiers, récupérer des données (par exemple via HTTP), ou envoyer des requêtes (GET, POST, etc.).

Dans notre exemple, on va télécharger un fichier .txt sur internet comprenant l’intégralité du livre Alice au pays des merveilles :

curl "https://www.gutenberg.org/files/11/11-0.txt"

La commande nous renvoie l’intégralité du livre. Admettons cependant que l’on veuille récupérer uniquement le sommaire pour l’enregistrer dans un nouveau fichier texte. Pour isoler une partie du texte en fonction d’un pattern, on va utiliser grep :

grep " CHAPTER"

La commande va nous permettre de récupérer toutes les lignes qui commencent par “CHAPTER” et donc l’ensemble du sommaire. Pour enchaîner nos deux commandes à la suite, on utilise l’opérateur pipe | :

curl "https://www.gutenberg.org/files/11/11-0.txt" | grep " CHAPTER"

Ça fonctionne parfaitement ! On veut maintenant sauvegarder notre résultat dans un fichier sommaire.txt. Pour se faire, utilisons l’opérateur > :

curl "https://www.gutenberg.org/files/11/11-0.txt" | grep " CHAPTER" > sommaire.txt

Et le tour est joué !

Il existe d’autres opérateurs importants :

• >> (Append) → Ajoute la sortie d'une commande à la fin d'un fichier existant sans l'écraser (contrairement à > qui remplace le contenu).

  • Exemple : echo "Nouveau chapitre" >> sommaire.txt

• && (And) → Exécute une commande seulement si la commande précédente a réussi.

  • Exemple : mkdir nouveau_dossier && cd nouveau_dossier (cd ne s'exécute que si mkdir a réussi)

• || (Or) → Exécute la commande suivante uniquement si la commande précédente a échoué.

  • Exemple : mkdir dossier || echo "Échec de la création du dossier" (Si mkdir échoue, le message d'échec est affiché)

Je vous laisse une liste plus complète avec des exemples sur ce lien.

Comment utiliser les commandes du terminal dans un script Python

On l’a vu, le terminal est un outil puissant et surtout particulièrement flexible.

Ça ne serait pas génial de pouvoir utiliser ces commandes dans un script afin d’utiliser la puissance combinée du terminal et de Python ?

Regardons comment mettre cela en place.

Reprenons notre fichier sommaire.txt créé précédemment. Nous allons écrire un script permettant de compter le nombre d’occurences du mot de notre choix (“CHAPTER” par exemple) dans notre fichier texte.

Regardons le script count.py :

#!/usr/bin/env python

from subprocess import run # run permet de lancer des commandes du terminal
from sys import argv

if __name__ == "__main__":

    _, filename, pattern = argv # arguments vector -> contient les arguments passés

    with open(filename) as f: # lecture du fichier texte
        alice = f.read()

    words = "\n".join(alice.split()) # mise en forme avec python

    grep = run(["grep", "-i", pattern], # on lance la commande avec run
               input = words,
               capture_output=True,
               text=True)

    print(len(grep.stdout.strip().split("\n"))) # on passe par grep.stdout pour accéder au résultat de grep

Puis analysons le :

#!/usr/bin/env python

Cette première ligne spécifie au terminal qu’on exécute un script Python.

_, filename, pattern = argv 

argv représente les arguments que l’on va passer dans le terminal au moment d’exécuter le script. On récupère ici le nom du fichier ainsi que la chaîne de caractères que l’on veut compter.

with open(filename) as f:
        alice = f.read()

words = "\n".join(alice.split()) 

On utilise ici du code Python pour lire notre fichier texte puis récupérer les mots dans une liste words.

    grep = run(["grep", "-i", pattern],
               input = words,
               capture_output=True,
               text=True)

run permet d’exécuter une commande du terminal depuis le script Python. On va ainsi lancer la commande grep -i pattern (-i signifie que le pattern passé n’est pas sensible à la casse : “CHAPTER” ou “chapter” devrait fonctionner).

print(len(grep.stdout.strip().split("\n")))

Enfin, on affiche le résultat. grep.stdout représente la standard output (sortie standard) de la commande grep. C’est à dire le résultat renvoyé par la commande. On mixe ensuite ce résultat avec du code Python : strip().split("\n").

Utiliser ce script est très simple, il suffit d’utiliser la commande suivante dans le terminal :

python count.py sommaire.txt CHAPTER

Vous pouvez bien évidemment remplacer sommaire.txt et CHAPTER par le fichier et le pattern de votre choix.

Conclusion

Le terminal, bien que peu intuitif au départ, se révèle être un outil indispensable pour automatiser, manipuler et analyser efficacement des données. En combinant ses commandes avec Python, on décuple sa puissance et sa flexibilité pour répondre à de nombreuses problématiques.

Il ne reste plus qu’à pratiquer !