---
# System prepended metadata

title: Bidouillons ensemble 26/03/2020

---

# Bidouillons ensemble 26/03/2020

par Benjamin Brachi

Utilisation du terminal pour gérer des fichiers ou **quelques commandes de bases en bash**

## Garder le PAD OUVERT

## Téléchargement des données pour les exercices:

On pourra apprendre à télécharger les fichiers en lignes de commande, mais pour ne pas perdre de temps, vous pouvez les obtenirs avec fileSender: [ICI](https://filesender.renater.fr/?s=download&token=54da400d-feb0-e162-910a-d9d3effaa32f)

Ou à partir de ma Dropbox:

- un GFF: [Qrob_H2.3_Genes_v2.2_20151214.gff](https://www.dropbox.com/s/ke10qvv982awxo8/Qrob_H2.3_Genes_v2.2_20151214.gff)
- un fastq.gz: [exemple2.fastq.gz](https://www.dropbox.com/s/hsobckgwmdu413q/exemple2.fastq.gz?dl=0)

**Ne pas décomprésser le fichier!!! On va le faire en ligne de commande!!!**

## Mis en place sur Windows 10.

Le plus simple est d'installer Ubuntu depuis le Microsoft Store. 

Voir [ce lien](https://ubuntu.com/tutorials/tutorial-ubuntu-on-windows#3-install-ubuntu-for-windows-10). 


Si ça ne marche pas il faut suivre:
[ce tutoriel](https://www.zebulon.fr/astuces/divers/executer-linux-sous-windows-10.html)


Moi j'ai suivi le tutoriel suivant:

**source: [itsfoss.com](https://itsfoss.com/install-bash-on-windows/)**

- recherchez _powershell_ dans la barre de recherche
- cliquez sur _executer en temps qu'administrateur_

![](https://i2.wp.com/itsfoss.com/wp-content/uploads/2016/08/Powershell-Ubuntu-install.jpeg?w=800&ssl=1)

- Collez la ligne suivante à l'invite de commande:

```shell
Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows Subsystem-Linux
```

- dans le windows store cherchez _Exécutez linux sous windows_
- cliquez puis choisir d'installer Ubuntu.

ensuite il suffit de chercher la _commande_ "ubuntu" dans la barre windows.

Une fenêtre de terminal s'ouvre, ce qui lance l'installation.

Il vous faudra choisir un nom d'utilisateur pour Ubuntu et un mot de passe.

## Si vraiment ça ne marche pas dans windows ou que vous n'êtes pas sous Windows10

Ayant téléchargé les fichiers manuellement vous pouvez utiliser un terminal virtuel  dispo ici: [https://bellard.org/jslinux/](https://bellard.org/jslinux)

Cliquez sur le lien "click here" dans la colonne "Startup Link" à la ligne "Linux 4.15.0 (Fedora 29)" "Console" (avant dernière ligne)

Chargez les fichiers (gff et fastq.gz) un cliquant sur ![](https://bellard.org/jslinux/images/upload-icon.png) sous le terminal.

## Utilisateur Ubuntu

Ouvrez simplement le terminal.

**Si vous ne savez pas où il est vous pouvez utiliser la touche "windows" de votre clavier et taper "terminal"**

ou utiliser le raccourci clavier *ctl+alt+t*


## Rejoindre la réunion sur RENATER

Vous trouverez ici in lien pour vous connecter
(Firefox ou chrome, pas internet explorer ou edge!!!):

Ben is inviting you to a meeting.

Join the meeting:
[https://rdv1.rendez-vous.renater.fr/1a4lj-oxvsm-g911v](https://rdv1.rendez-vous.renater.fr/1a4lj-oxvsm-g911v)

**Coupez votre vidéo et votre micro.
Favorisez l'utilisation de la messagerie instantanée pour vous exprimer ou demander la parole (on lève le doigt!!! ;) .**


## Petite note sur l'organisation

Donc une fois que vous avez rejoins la conférence, je vous suggére d'organizer trois fenêtres sur votre plan de travail.

- votre terminal
- la visio avec mon terminal et le chat éventuellement
- ce document partagé

Je vais le remplir au fur et à mesure de la séance avec des instructions et des commentaires et des commandes.

En théorie, même si vous entendez pas ce que je dis, je vais tout mettre ici.


## Terminal ouvert? C'est bon alors naviguons!

Pour se déplacer l'arborescence de vos dossiers d'abord il faut savoir où on est.

Taper la commande:

```sh
pwd
```
Vous devriez avoir une sortie du type

> /home/ton_nom


Ce dossier est ce qu'on appel votre "home"

J'imagine que ce n'est pas forcement là que vous voulez travailler pour ce bidouillons.

Pour ce déplacer dans les dossiers, on utilise la commande "cd"

Par exemple, je voudrais travailler dans le dossier Documents de mon ordi.

Pour y aller je vais faire (vous remplacer tjrs "benjamin" par votre nom d'utilisateur)

```terminal
cd /home/benjamin/Documents/
```


**Pour les utilisateurs windows10**:

Votre sous-sytème Ubuntu "monte" votre disque C:
dans /mnt/c/  

Du coup, sur un ordi Windows10 normalement constitué, où mon nom d'utilisateur est aussi "benjamin", je vais pouvoir aller dans mon dossier Documents en faisant:

```bash
cd /mnt/c/Users/benjamin/Documents
```

Noté que l'intégration est bien faite, puisque l'on utilise les "/" et non les "\" (à la c..) des commandes Windows habituelles.  

**Win parenthèse terminée

## Création de notre répertoire de travail

Je vais travailler dans le dossier existant `/home/benjamin/data/bidouillons_ens` parce que c'est comme ça que je suis organisé. À vous de voir. Vous pouvez travailler dans `/home/you/Documents/` et dans le cas d'utilisateurs `/mnt/c/Users/you/Documents`

Donc on va dans notre dossier.

```bash
cd /home/benjamin/data/bidouillons_ens
```

Comme on voudrait pas tout mélanger et être organisé (dédicace), on va créer un dossier spécial pour cet exercice.

```bash
mkdir ./bash_basics
```

Donc on a utiliser la fonction `mkdir` qui veut dire "make directory" pour créer un dossier. le `./` veut dire qu'on a créé ce dossier courant (là où on est).

Dans mon cas, c'est donc dans `/home/benjamin/data/bidouillons_ens`

Si vous n'êtes plus sûr la commande `pwd` permet de "print working directory", donc de donner le chemin du répertoire où vous vous situez.

Maintenant on voudrait aller dans notre répertoire de travail:

```bash
cd ./bash_basics
```

On peut en sortir en faisant

```bash
cd ../
```

les deux points nous font remonter d'un niveau dans l'arborescence des dossiers.

On y retourne...

```bash
cd ./bash_basics

pwd
```

> /home/benjamin/data/bidouillons_ens/bash_basics


## Téléchargement des fichiers nécessaires à l'exercice (en ligne de commande!)

**Ne cliquez pas dessus!!!**
Une commande permet de télécharger des fichiers à partir d'un URL. Ici j'ai mis un fastq issu du séquençage low coverage d'un chêne et le gff de tous les gènes du chêne dans mon dossier dropbox avec une URL publique.

```bash
wget https://www.dropbox.com/s/hsobckgwmdu413q/exemple2.fastq.gz
```

et un autre:

```bash
wget https://www.dropbox.com/s/ke10qvv982awxo8/Qrob_H2.3_Genes_v2.2_20151214.gff
```

*Pour mac, on utilisera probablement plutôt `curl` que `wget` mais si je me souviens bien ça marche pareil.*

Pour ceux qui ont télécharger les fichiers à la main, on va les déplacer dans notre répertoire de travail.

Disons que les fichiers sont... dans le dossier `Téléchargement`

```bash
mv ~/Téléchargement/Qrob_H2.3_Genes_v2.2_20151214.gff ./

mv ~/Téléchargement/exemple2.fastq.gz ./
```

Ici `mv` est la commande pour déplacer (ou renommer) des fichiers.

- `~/` est synonyme de `/home/you/`
- `./` est synonyme de `ici` (dans le répertoire courant)

On a bien télé-charger les fichiers?

```bash
ls
```



Oui! Mais ça ne nous donne pas beaucoup d'info...
ls peut nous en donner plus. Il suffit de savoir quelles options ajouter!

Pour savoir quelles arguments et options sont disponibles, toutes les commandes unix dispose d'un manuel accessible directement dans votre terminal par la commande `man`

```bash
man ls
```

On quitte avec `q`, comme indiqué

Donc

```bash
ls -l
```

`-l` permet d'avoir une liste avec plus de détail

Personnellement je ne connais pas toutes les options, mais je sais que je tape souvent

```bash
ls -lth
```

`-t` permet de trier par date de modification, le plus récent d'abord
`-h` "human readable" pour que l'on puisse lire plus facilement la taille des fichiers

## copier/déplacer/renommer des fichiers

Dans bash on peut:

- copier des fichiers...

```bash
mkdir ./test
cp ./exemple2.fastq.gz ./test/
```

- Les copier en changeant le nom.

```bash
cp exemple2.fastq.gz ./ex2.fastq.gz
ls -l
ls -l ./test

```

- supprimer des fichiers

```bash
rm ./ex2.fastq.gz
```

- supprimer des dossier avec `-r`
*(attention à l'utilisation de `rm -r` à le potentiel de supprimer votre répertoire utilisateur en entier, voir plus... sans possibilité de récupération à ma connaissance, sauf si vous avez un bon backup...)*

```bash
rm -r ./test
```

- les déplacer ou les renommer

Par exemple le nom du fichier "Qrob_H2.3_Genes_v2.2_20151214.gff" est un peu long pour être très pratique pour cet exercice, on va le raccourcir un peu.

```bash
mv ./Qrob_H2.3_Genes_v2.2_20151214.gff ./Qrob.gff
ls -l
```

## Travailler avec des fichiers (texte)

Quand on aborde un fichier, on peut vouloir compter son nombre de ligne par exemple, histoire de savoir à quoi on a affaire.  

Ici on va d'abord travailler avec le gff

On utilise la fonction `wc`, pour word count, qui sait compter les caractères.

**Je vous laisse consulter le manuel pour trouver l'option qui permet de compter le nombre de ligne!!**

```bash
wc -l ./Qrob.gff
```
Combien? ça fait quand même beaucoup... l'afficher en entier poserai problème.

On va maintenant regarder comment on peut ce fichier un peu

- regarder le haut

```bash
head Qrob.gff
```

`head` permet d'afficher les premières lignes du fichier. Par défault 10... mais je peux en afficher plus.

```bash
head -n 20 Qrob.gff
```

- on peut regarder la fin du fichier

```bash
tail -n 5 Qrob.gff
```

- On peut regarder une seule colonne!

```bash
cut -f 1 ./Qrob. gff
```
Wowho ça défile!

Donc cut permet de récupérer toutes les lignes d'un fichier, mais seulement une colonne (c'est plus compliqué
et flexible que ça mais pour le moment passons)

`-f 1` indique que je veux récuper le premier "champs"

Le déliminateur de "champs" (~colonne) est "TAB" par défaut mais je peu en préciser un autre si je veux.

```bash
cut -f 2 -d "_" ./Qrob.gff
```
Wowho ça défile encore!! Bon c'est pas pratique...

Bon faisons une parenthèse, ou profiton de l'occasion pour parler.... **PIPE**!!

## Les pipes

Les "pipes" sont symbolyser par le symbols "|".
(pour les super novices: Alt Gr + 6 sur un clavier normale. Mac users... débrouillez vous, je sais plus!

Avec les pipes vous pouvez enchaîner plusieurs commandes.

Si on reprend notre exemple, je voudrais extraire les 3 premières colonnes du gff mais seulement regarder les 15 premières lignes.

```bash
cut -f 1-3 Qrob.gff | head -n 15
```

Comment ça marche?

En gros on peut lire le `|` comme "puis".

Quand `cut` nous fait défiler toute les lignes du fichier dans la console, en fait on dit qu'il ecrit dans le STDOUT (lire "standard output").

Les `|` permet d'envoyer ce STDOUT directement dans la prochaine commande!

C'est très, très performant, et vous allez voir, on va s'en servir dans pratiquement tous les exemples suivants!

## grep pour filter des fichiers

En utilisant les PIPEs on va pouvoir combiner les commande pour "filtrer" notre fichier.

Une fonction très utile pour filtrer... c'est `grep`

`grep` permet de filter des fichier texte en cherchant un "string" ou une expression régulière (cf bidouillons_ens expression régulière)

Par exemple, dans le gff, je voudrais ne garder que les lignes correspondant à des exons! (Un peu comme dans le bidouillons de Arthur)

On va utiliser la fonction de base `cat`.

- `cat` fait comme `head` mais lit tout le fichier.
- `grep` ne garde que les lignes contenant "exon"
- on met quand même `head` à la fin pour ne pas afficher toute les lignes

```bash
cat Qrob.gff | grep -e "exon" | head
```

Hum... on est pas assez spécifique...

Il va falloir l'être un peu plus... avec un expression régulière.

```bash
cat Qrob.gff | grep -P -e "[\s]exon[\s]" | head
```

_Explication:_
- On lit le fichier en entier avec  `cat`
- puis grep sélectionne les lignes qui incluent du texte correspondant à l'expression régulière ""[\s]exon[\s]"
- grep à besoin de l'option `-P` pour comprendre cette expression régulière car elle est au style de Perl. C'est le plus courant... donc si vous utilisez une expression régulière dans grep: utiliser `-P`
- l'expression régulière indique qu'on cherche "exon" avec un espace blanc (tab ou autre) avant et après.
- `head` permet de ne regarder que les 10 premières lignes.

Maintenant on va peut-être vouloir stocker le résultat de notre ligne de commande dans un fichier.

On a dit que nos lignes de commande écrive dans le "STDOUT".

On va utiliser une commande toute simple  `>` pour rediriger le "STDOUT" vers un autre fichier.

```bash
cat Qrob.gff | grep -P -e "[\s]exon[\s]" > Qrob_exons.gff
```
On peut vérifier:

```bash
ls -lht

head Qrob_exons.gff
```



## Level 2!

Maintenant on va regarder l'autre fichier.

```bash
ls -l
```

Ah mince... c'est un fichier compressé!

Un fichier compressé à l'avantage d'être plus petit.
Ce n'est pas juste une question de prendre de la place sur votre disque.
En terme de calcul, il rend les opération sur le fichier plus rapide car les lectures/écritures sont plus longues si le fichier est grand:

Il y a plusieurs solution. La plus simple implique d'utiliser `cat` pour lire le fichier.

Ici on va utiliser
- `cat` pour lire le fichier compressé
- `gzip -d`, décompressé, et regarder les 4 premières lignes! (parce que c'est un fastq)

*(NB: on peut utiliser `gzip -c` à la fin d'un pipe pour compresser le résultats, puis rediriger vers un fichier avec `>`!)*

```bash
cat exemple2.fastq.gz | gzip -d | head -n 4
```

Wow trop d'ADN...

La séquence est longue. On va prendre les 200 premier caractères de chaque lignes.

```bash
cat exemple2.fastq.gz | gzip -d | head -n 4 | cut -c 1-200
```

Pour les non initiés... un fastq est un fichiers issu du séquençage.

Chaque lecture (read) prend 4 lignes.
- Une ligne d'identification
- Une ligne de séquences
- une "+"
- et une ligne qui indique la qualité de chaque base de la séquence

Maintenant on voudrait...

- compter le nombre de séquence?

On sait qu'on peut juste diviser le nombre de ligne par 4...

```bash
cat exemple2.fastq.gz | gzip -d | wc -l
```

Mais on peut aussi filtrer les lignes pour ne garder que les identifiants.

On va utiliser grep.

```bash
cat exemple2.fastq.gz | gzip -d | grep -P "^@" | head
```

- compter le nombre de base (ATCG) pour les 20 premières séquences.

Pour ça on va:
- filtrer les lignes qui nous intéresse avec la commande `grep` (comme tout à l'heure) pour récuperer les lignes de séquences seulements...


```bash
cat exemple2.fastq.gz | gzip -d | grep -m 20 -A 1 -P "^@" |cut -c 1-100
```
- l'option `-A 1` permet de récupérer la ligne qui match, et 1 ligne après!  
- l'option `-m 20` de s'arrêter après avoir trouvé 20 "match"

Bon c'est cool mais `grep` sépare les "groupes" par des "--" et c'est pas pratique pour nous.

Dans le manuel je vois pas d'option pour l'empêcher de faire ça... du coup bah on va les enlever avec un autre `grep`

Et faudrait aussi que je me débarrasse des identifiant de séquence... bah `grep` aussi

- l'option `-v` de grep permet d'inverser son effet: garder les lignes qui ne "match" pas!
- avec `-e` on peut "matcher" plusieurs expression à la fois!

```bash
cat exemple2.fastq.gz | gzip -d | head -n 80 | grep -A 1 -P "^@" | grep -v -e "@" -e "--" | cut -c 1-100
```

Bon... mais il reste le problème de compter...

Là il va falloir aller voir du côté d'un autre "bidouillons"... sur `awk`! (mais un cas facile)

````bash
cat exemple2.fastq.gz | gzip -d | grep -m 20 -A 1 -P "^@" | grep -v -e "@" -e "--" | awk '{print length}'
```



Enregister les commandes de sa sessions:

```bash
history > history_CMD.txt
```


Lien vers pdf interessant 

[filtres](http://www-inf.it-sudparis.eu/cours/UNIX/Shell/FILTRES.pdf
12:21)

