8 commandes shell utiles pour la data science

Il existe de nombreuses situations où vous devez analyser, modifier et traiter rapidement un grand nombre de fichiers, parfois volumineux. Or, ces fichiers sont souvent des fichiers texte au format CSV (Comma Separated Values). Les ouvrir avec des tableurs classiques, comme Excel, LibreOffice ou OpenOffice, sature la mémoire de la machine. De même, le traitement par lots d’un grand nombre de fichiers échoue souvent au bout de quelques heures à cause d’une anomalie inattendue dans l’un d’eux.

Résultat : vous perdez un temps précieux entre écrans figés, redémarrages et longues attentes.

Pourtant, la plupart de ces tâches peuvent être réalisées en quelques lignes de code. En vous familiarisant avec quelques commandes shell simples, vous gagnerez beaucoup de temps et réduirez la frustration.

Cet article propose un aperçu de commandes shell que j’utilise presque tous les jours. J’espère qu’elles vous seront utiles.

Notes rapides

Notez qu’il existe différents types de shell (bash, zsh, ...). Bash est le plus répandu, car il s’agit du shell par défaut sur OS X et la plupart des distributions Linux. Zsh (et Oh My Zsh) est une alternative populaire et puissante. Les commandes shell présentées dans cet article ont été testées avec bash sur OS X (macOS) et devraient fonctionner avec d’autres shells et environnements.

Tous les exemples ci-dessous s’appuient sur le jeu de données adult du dépôt UCI Machine Learning, aussi connu sous le nom de jeu de données « Census Income », disponible ici. Il est couramment utilisé pour prédire si un revenu dépasse 50 000 $ par an à partir de données de recensement. Avec 48 842 lignes et 14 attributs, ce n’est pas un grand jeu de données, mais il suffit pour illustrer les exemples. Bien que l’extension soit .data, il s’agit d’un CSV bien formaté. N’hésitez pas à le télécharger pour suivre pas à pas !

Compter avec wc

Avec un nouveau fichier texte, vous voulez savoir combien de lignes il contient. Utilisez pour cela la commande de comptage wc -l :

$ wc -l adult.data
  32562 adult.data

Ce qui vous indique que le fichier adult.data contient 32 562 lignes. L’option -l demande à wc de compter les lignes. Vous pouvez aussi compter les mots avec l’option -w.

$ wc -w adult.data
  488415 adult.data

Le fichier adult.data contient près de 500 000 mots.

La commande wc permet aussi de compter le nombre de fichiers dans un répertoire en utilisant la sortie d’un simple ls -l comme entrée de wc. Le fait d’utiliser la sortie d’une commande comme entrée d’une autre grâce au symbole de pipe | est un motif utile du shell appelé pipelining. Vous le verrez à plusieurs reprises dans cet article.

Imaginons maintenant que vous ayez un dossier avec de nombreux fichiers. La commande suivante vous indique exactement combien il en contient :

$ ls -l <folder> | wc -l
 508

Il existe de nombreuses autres utilisations de wc en ajoutant des jokers et des sous-dossiers.

Revenons à votre fichier adult.data et regardons les premières lignes avec la commande head. Par défaut, head affiche 10 lignes ; vous pouvez limiter la sortie aux 2 premières lignes avec l’option -n.

$ head -n 2 adult.data
39, State-gov, 77516, Bachelors, 13, Never-married, Adm-clerical, Not-in-family, White, Male, 2174, 0, 40, United-States, <=50K
50, Self-emp-not-inc, 83311, Bachelors, 13, Married-civ-spouse, Exec-managerial, Husband, White, Male, 0, 0, 13, United-States, <=50K

Vous remarquez que le fichier n’a pas de ligne d’en-tête : les noms de colonnes ne figurent pas dans le fichier. Vous pouvez l’ajouter en concaténant deux fichiers avec la commande cat.

Concaténer des fichiers avec cat

La commande cat affiche le contenu d’un fichier sur la sortie standard (votre terminal). Elle permet aussi de concaténer plusieurs fichiers. La commande cat file_1.csv file_2.csv > target_file.csv fusionne le contenu de file_1.csv et file_2.csv dans target_file.csv, en ajoutant file_2.csv à la suite de file_1.csv.

Le fichier d’en-tête n’existe pas dans le jeu de données d’origine, vous devez le créer. Pour ce faire, vous envoyez avec echo la liste des noms de colonnes séparés par des virgules dans un fichier header.csv.

$ echo "age,workclass,fnlwgt,education,education-num,marital-status,occupation,relationship,race,sex,capital-gain,capital-loss,native-country,class" > header.csv

Dans cet exemple, vous utilisez la redirection > du shell pour déverser la sortie de cat dans le fichier adult.csv. L’opérateur > crée le fichier ou remplace entièrement son contenu s’il existe déjà. En le doublant >>, vous ajoutez le nouveau contenu à la fin d’un fichier existant sans écraser ce qu’il contient.

Ajoutons maintenant le fichier header.csv au début de adult.data. Au passage, renommez adult.data en adult.csv puisqu’il s’agit, après tout, d’un fichier au format CSV.

$ cat header.csv adult.data > adult.csv

Vérifiez que la première ligne de adult.csv contient bien les noms de colonnes :

$ head -n 1 adult.csv
age,workclass,fnlwgt,education,education-num,marital-status,occupation,relationship,race,sex,capital-gain,capital-loss,native-country,class
39, State-gov, 77516, Bachelors, 13, Never-married, Adm-clerical, Not-in-family, White, Male, 2174, 0, 40, United-States, <=50K

Modifier un fichier avec sed

Autre scénario fréquent en data : un fichier corrompu ou mal formaté, par exemple avec des caractères non UTF‑8 ou une virgule mal placée. Vous pouvez corriger le fichier sans l’ouvrir grâce à la commande sed.

Le motif générique sed est :

$ sed "s/<string to replace>/<string to replace it with>/g" <source_file> > <target_file>.

Le jeu de données adult.csv utilise le caractère ? pour indiquer une valeur manquante. Vous pouvez le remplacer par une valeur par défaut plus adaptée avec sed. Une chaîne vide est préférable pour indiquer une valeur manquante : elle sera interprétée comme NaN lors du chargement des données dans un DataFrame Pandas.

$ grep ", ?," adult.csv | wc -l
2399

Cela vous donne 2 399 lignes comportant au moins une colonne avec une valeur manquante notée ?. La commande suivante remplace toutes les colonnes contenant ? par une chaîne vide. Toutes les cellules ne contenant que ?, suivi d’un espace, seront désormais réellement vides.

$ sed "s/, ?,/,,/g" adult.csv >  adult.csv

Notez l’usage du délimiteur de colonnes , dans les chaînes source et cible pour éviter de remplacer des points d’interrogation légitimes présents ailleurs dans le jeu de données.

Extraire un sous-ensemble d’un gros fichier

Imaginez maintenant un fichier de plus de 30 millions de lignes. Pendant que vous élaborez votre script Python ou R, vous préférerez tester votre flux de travail sur un échantillon plutôt que de charger l’intégralité du jeu de données en mémoire. Vous pouvez combiner head et tail pour créer un sous-échantillon du jeu de données d’origine.

• head affiche le début d’un fichier ;
• tail affiche la fin d’un fichier.

Comme vu précédemment, ces commandes acceptent l’option -n (équivalente à --lines) pour limiter le nombre de lignes affichées. tail accepte aussi -f (pour --follow) qui affiche les nouvelles lignes au fur et à mesure qu’elles sont ajoutées en fin de fichier. C’est particulièrement pratique pour surveiller des fichiers journaux pendant l’exécution de vos scripts avec tail -f <logfile>.

En combinant le pipe | avec head et tail, vous pouvez extraire un certain nombre de lignes depuis une position donnée et exporter le tout vers un fichier d’échantillon. Par exemple, pour extraire 20 lignes à partir de la ligne 100 :

$ head -n 120 adult.csv | tail -n 20 > adult_sample.csv

Notez que vous récupérez d’abord first_line + number_of_lines avec head, puis vous appliquez tail sur number_of_lines. La commande générique est :

$ head -n <total_lines> <source_file> | tail -n <number_of_lines> > <target_file>

où total_lines = first_line + number_of_lines. Cependant, votre échantillon ne contient plus la ligne d’en-tête. Nous savons déjà comment la réintégrer : concaténez le sous-fichier et le header.csv créé précédemment avec cat :

$ cat adult_sample.csv header.csv > adult_sample_with_header.csv

Remarquez que vous n’avez pas réutilisé adult\_sample.csv comme nom de sortie, mais créé un nouveau fichier adult\_sample\_with\_header.csv. Utiliser cat avec un nom de fichier identique parmi les sources et comme cible produit un contenu inattendu. Il est préférable de créer un nouveau fichier en sortie de cat.

Trouver les doublons avec uniq

Avec la commande uniq, vous pouvez trouver les lignes répétées adjacentes dans un fichier. uniq accepte plusieurs options utiles :

• uniq -c : ajoute le nombre de répétitions à chaque ligne ;
• uniq -d : n’affiche que les lignes dupliquées ;
• uniq -u : n’affiche que les lignes uniques.

Toutefois, uniq n’est pas « intelligent » : il ne détecte pas les répétitions si les lignes ne sont pas adjacentes. Il faut donc d’abord sort le fichier. La commande suivante compte le nombre de lignes dupliquées dans adult.csv :

$ sort adult.csv | uniq -d | wc -l
23

et montre qu’il y a 23 doublons. La commande suivante ajoute le nombre de répétitions à chaque ligne, trie en ordre inverse et affiche les 3 doublons les plus fréquents :

$ sort adult.csv | uniq -c | sort -r | head -n 3
3 25, Private, 195994, 1st-4th, 2, Never-married, ...
2 90, Private, 52386, Some-college, 10, Never-married, ...
2 49, Self-emp-not-inc, 43479, Some-college, 10, Married-civ-spouse, ...

Il existe de nombreuses options puissantes en combinant sort et uniq avec différents indicateurs. Utilisez man sort et man uniq pour explorer ces commandes.

Sélectionner des colonnes avec cut

L’avantage des fichiers CSV et des commandes shell est que vous pouvez aussi travailler au niveau des colonnes avec cut. cut prend deux options principales : -d pour spécifier le délimiteur de colonnes et -f pour indiquer les colonnes à traiter. Dans l’exemple suivant, vous utilisez cut pour trouver le nombre de valeurs uniques prises par la variable catégorielle workclass (colonne 2).

Commencez par sélectionner la colonne workclass et envoyez le résultat à head pour vérifier que c’est la bonne :

$ cut -d "," -f 2 adult.csv | head -3
workclass
State-gov
Self-emp-not-inc

Pour compter les valeurs uniques, triez ensuite la sortie de cut et passez-la à uniq -c :

$  cut -d "," -f 2 adult.csv | sort | uniq -c
1837
 960  Federal-gov
2093  Local-gov
   7  Never-worked
22696  Private
1116  Self-emp-inc
2541  Self-emp-not-inc
1298  State-gov
  14  Without-pay
   1 workclass

On voit par exemple qu’il y a 1 837 valeurs nulles, et que la classe principale est de loin Private avec 22 969 occurrences.

La ligne de commande ci-dessus est similaire à la méthode value_counts() appliquée à une série issue d’un DataFrame contenant les données de adult.csv.

Boucler

Jusqu’ici, vous avez surtout travaillé sur un seul fichier. Pour renommer, traiter ou transférer un grand nombre de fichiers, ajoutez des boucles à votre boîte à outils shell. Le format générique d’une boucle en bash est :

while true; do
    _do something_ ;
done

Passons à la pratique. Imaginez 1 000 fichiers dont le nom contient des espaces, et vous souhaitez remplacer chaque espace par un underscore « _ ».

replace_source=' '
replace_target='_'
for filename in ./*.csv; do
    new_filename=${filename//$replace_source/$replace_target}
    mv "$filename" "$new_filename"
done

Dans cet exemple :

• vous déclarez deux variables : replace_source et replace_target pour l’espace et l’underscore ;
• vous bouclez sur tous les fichiers *.csv du dossier courant ;
• pour chaque filename, vous créez un new_filename en remplaçant chaque espace par un underscore ;
• et vous renommez le fichier avec mv en passant de l’ancien au nouveau nom.

Vous avez ainsi non seulement bouclé sur des fichiers dans un répertoire, mais aussi utilisé des variables.

Variables

Terminons cette introduction aux commandes shell avec les variables. Déclarer une variable en shell se fait simplement ainsi :

$ varname='<a string>'
$ varname=a number

Par exemple :

$ varname='Hello world'
$ varname=123.4

Notez qu’il n’y a pas d’espace autour du signe « = ». var = '<a string>' ne fonctionnerait pas. Pour afficher la valeur d’une variable, utilisez simplement echo :

$ echo $varname
123.4

Et, pour l’utiliser dans un script, encapsulez-la entre guillemets comme vu précédemment :

$ mv "$filename" "$new_filename"

Écrire des boucles et utiliser des variables ouvre la voie à des manipulations de fichiers plus complexes et constitue une porte d’entrée vers le scripting shell, au-delà de cette introduction. Le scripting shell reste toutefois abordable si vous commencez petit et progressez à mesure que votre confiance grandit.

Conclusion

Les lignes de commande shell sont extrêmement utiles au quotidien pour les data scientists. Les exemples et cas d’usage sont nombreux. Et, bien souvent, il existe différentes façons d’obtenir un même résultat via un large éventail de commandes et d’options. Dans tous les cas, la simplicité reste la meilleure stratégie.

Nous espérons que ces exemples vous aideront à intégrer les commandes shell à votre boîte à outils de traitement de données. Contactez-moi et partagez vos astuces shell sur Twitter : @alexip.

Découvrez aussi notre tutoriel Configurer un environnement data science sur votre ordinateur.