La commande Linux `seq` facilite la génération de séries numériques. Mais comment exploiter concrètement cette fonctionnalité ? Nous allons vous montrer comment `seq` peut s’avérer utile.
Présentation de la commande `seq`
À première vue, la commande Linux `seq` peut sembler étrange. Elle permet de générer des séquences de nombres rapidement, et c’est tout ! Le mot clé ici, c’est « rapidement ». Vous allez vite comprendre à quel point cette petite commande est efficace.
Quelle que soit la méthode de création, à quoi sert une liste de nombres ? La commande `seq` a été ajoutée à la 8ème édition d’Unix en 1985. Elle a donc su prouver son utilité au fil des années.
La philosophie d’Unix repose sur de petits utilitaires qui exécutent une tâche unique de manière efficace. L’un des principes fondamentaux de cette philosophie est de concevoir des programmes capables de traiter les données provenant d’autres programmes. Cela implique également que ces programmes doivent produire des résultats qui puissent servir d’entrée à d’autres programmes.
La commande `seq` prend tout son sens lorsqu’elle est combinée avec d’autres commandes qui utilisent sa sortie, que ce soit via des pipes ou l’expansion de la ligne de commande.
Génération de listes simples
Si vous lancez `seq` avec un seul nombre comme argument, elle génère une séquence de 1 jusqu’à ce nombre. Les nombres sont affichés dans la fenêtre du terminal, un par ligne, comme suit :
seq 6
Si vous spécifiez deux nombres, le premier est le point de départ et le second est la limite supérieure :
seq 4 10
Vous pouvez également définir un incrément en ajoutant un troisième nombre entre le début et la fin. Par exemple, pour créer une liste commençant à six, finissant à 48 avec un incrément de six, vous écrirez :
seq 6 6 48
Décompte
Il est également possible de demander à `seq` de créer une liste de nombres en ordre décroissant. Pour cela, il faut définir un incrément négatif.
La commande suivante génère une liste décomptant de 24 à 12 par pas de 6, grâce à l’incrément négatif:
seq 24 -6 12
Nombres décimaux
Les nombres de début, de fin et d’incrément peuvent être des nombres décimaux. Si l’un d’eux est un nombre décimal, les autres sont automatiquement traités comme tels. La commande suivante génère une liste avec un incrément de 0.2 :
seq 1 0.2 2
La rapidité de `seq`
`seq` est incroyablement rapide. Le seul délai est le temps que vous mettez à saisir la commande dans la fenêtre du terminal. Pour tester sa vitesse, demandons une liste de 250 000 nombres.
Nous utilisons la commande suivante, en utilisant `time` pour voir combien de temps le processus met à se terminer :
time seq 250000
Les résultats apparaissent sous la liste. Même sur notre PC de test avec des performances moyennes, `seq` s’avère extrêmement rapide.
La liste entière a été générée et affichée à l’écran en environ 1/3 de seconde. Si nous redirigeons la liste vers un fichier, nous pouvons même éviter la surcharge liée à l’affichage dans le terminal.
Pour cela, nous utilisons la commande suivante :
time seq 250000 > numbers.txt
Le temps nécessaire pour générer la liste et créer le fichier est maintenant d’environ 1/7 de seconde.
Utilisation d’un séparateur
Le caractère de saut de ligne est utilisé par défaut pour séparer chaque nombre dans une liste. C’est pourquoi les nombres apparaissent sous forme de liste verticale, chacun sur sa propre ligne. Si vous le souhaitez, vous pouvez spécifier un autre séparateur.
Par exemple, si vous avez besoin de créer une liste délimitée par des virgules, des deux-points, ou tout autre signe de ponctuation ou symbole, le séparateur est en fait une chaîne, vous pouvez donc utiliser plusieurs caractères.
Nous allons utiliser l’option `-s` (séparateur). La commande suivante produit une liste délimitée par des virgules :
seq -s, 6 6 36
Cette commande utilisera un deux-points (`:`) comme séparateur :
seq -s: 6 6 36
Cette commande indique à `seq` d’utiliser deux tirets (`–`) comme séparateur :
seq -s-- 6 6 36
Utilisation de chaînes de format
La commande `seq` prend également en charge les chaînes de format à la manière du langage C. Elles permettent de formater la sortie avec plus de contrôle que la simple spécification d’un séparateur. Pour utiliser une chaîne de format, utilisez l’option `-f` (format).
La commande suivante indique à `seq` d’utiliser des zéros pour compléter la sortie jusqu’à deux caractères :
seq -f "%02g" 6
Il est possible de formater la chaîne avec le texte souhaité et de placer le nombre où l’on veut dans la chaîne, comme suit :
seq -f "Nombre %02g dans une chaîne de format C" 6
Remplissage zéro rapide
Le moyen le plus rapide d’appliquer un remplissage avec des zéros est d’utiliser l’option `-w` (largeur égale). Cela indique à `seq` d’utiliser des zéros pour que tous les nombres aient la même largeur que le plus grand nombre de la liste.
La commande suivante compte de 0 à 1000 par pas de 100, et tous les nombres seront complétés par des zéros :
seq -w 0 100 1000
Le nombre le plus long a quatre caractères, donc tous les autres sont complétés avec des zéros pour atteindre cette largeur (même 0 est complété par quatre zéros).
Utiliser la sortie de `seq` dans `bc`
En définissant le séparateur comme un symbole mathématique et en dirigeant la sortie vers la commande `bc`, il est possible d’évaluer les expressions de la liste.
La commande suivante génère une liste de nombres séparés par des astérisques :
seq -s* 6
commençant à un et se terminant par six :
seq -s* 6 | bc
En redirigeant cette liste vers `bc`, celui-ci évalue l’expression en utilisant les astérisques
seq -s+ 5
comme opérateurs de multiplication :
seq -s+ 5 | bc
Pour rediriger la sortie vers `bc` et évaluer la liste, nous utilisons :
`seq -s * 6` dans une fenêtre de terminal. Création de fichiers avec `seq`
La commande `touch`
touch $(seq -f "fichier-%g.txt" 1 10)
modifie les horodatages des fichiers. Si le fichier n’existe pas, `touch` le crée. Il est possible d’utiliser l’expansion de la ligne de commande avec `touch` et `seq` pour créer un ensemble de fichiers nommés selon un modèle, mais avec une numérotation différente.
ls fichier*
Pour vérifier les fichiers, nous utilisons :
`touch $(seq -f`
Utilisation de `seq` dans les boucles Bash
#!/bin/bash for val in $(seq 5 0.2 6.6); do echo "La valeur est maintenant: $val" done
On peut utiliser `seq` dans les scripts Bash pour gérer les boucles avec des nombres décimaux.
chmod +x boucle.sh
Ensuite, nous utilisons la commande suivante pour rendre notre script exécutable :
./boucle.sh
Lorsque l’on exécute le script, le compteur de boucle est affiché dans la fenêtre du terminal. Nous pouvons ensuite utiliser la commande ci-dessous pour observer l’évolution du compteur décimal à chaque itération de la boucle:
`./boucle.sh` dans une fenêtre de terminal.
N’oubliez pas que `seq` peut également décompter. Il est possible de l’utiliser de la même manière dans les boucles. Simple et efficace Une qualité de `seq` est sa simplicité d’utilisation. Elle possède une
page de manuel
concise et directe, ce qui n’empêche pas de l’utiliser de façon créative.
Pour générer des fichiers de test réalistes avec des tailles adaptées, nous utilisons `seq` avec une chaîne de format. Puis, nous redirigeons la sortie pour créer un fichier contenant le nombre de lignes de données factices que nous souhaitons.