Manipulation de texte avancée (tail -f, grep, cut, wc, sort, uniq, sed, awk...)

Tous les outils décrits dans ce chapitre sont très performants et sont tous "chainables" entre eux avec des PIPES.

La plupart (voire la totalité) acceptent un ou plusieurs fichiers en paramètre mais sont aussi capables de lire l'entrée standard.

Affichage : cat, tail, head, more, less, split, join, paste

affichage et concatenation avec cat

cat est un outil incontournable qui affiche le contenu d'un ou plusieurs fichiers texte.

cat fichier.txt

On peut donc concaténer des fichiers de cette manière :

cat fichier1.txt fichier2.txt fichier3.txt > concatenation.txt

Les pagers more et less

more et less sont des commandes interactives à ne pas utiliser dans un script. Elles permettent d'afficher un fichier texte, de se déplacer, de rechercher etc... more ne permet pas de revenir en arrière alors que less le permet. Je vous conseille d'utiliser less.

tail et head

tail affiche les N dernières lignes d'un contenu et head affiche les N premières lignes d'un contenu. N étant un paramètre.

# affiche les 2 dernières lignes de fichier.txt
tail -n 2 fichier.txt

# affiche les 2 premières lignes de fichier.txt
head -n 2 fichier.txt

# affiche la troisième et quatrième ligne de fichier.txt
head -n 4 fichier.txt | tail -n 2
# est équivalent à
cat fichier.txt | head -n 4 | tail -n 2

# afficher un fichier à partir de la deuxième ligne
tail -n +2 fichier.txt

Watch

La commande watch lance une commande à intervalle régulier et affiche son résultat. Cela peut être utile, par exemple, pour observer l'évolution de la taille d'un fichier :

watch du -sh mon_fichier.txt

Cela peut aussi servir à vérifier en temps réel l'apparition de fichiers de résultat :

watch ls mon_dossier_resultat

Split

Découpage d'un fichier en plusieurs sous fichiers.

split -b 1024k mon_gros_fichier

split va ainsi créer des fichiers nommées xaa, xab, xac[, etc], de tailles égales ou inférieures (pour le dernier) à 1024 Ko.

split -n 10 mon_gros_fichier

split va produire ici 10 fichiers

split -l 4 mon_gros_fichier

split va créer des fichiers de tailles égales ou inférieures (pour le dernier) à 4 lignes.

Join

permet de fusionner les lignes de deux fichiers ayant des champs communs (par défaut la première colonne)


>cat  testfile1
1 India
2 US
3 Ireland
4 UK
5 Canada

>cat testfile2
1 NewDelhi
2 Washington
3 Dublin
4 London
5 Toronto

>join testfile1 testfile2
1 India NewDelhi
2 US Washington
3 Ireland Dublin
4 UK London
5 Canada Toronto

Paste

La commande paste permet de concaténer les lignes des fichiers passés en argument.

>paste testfile1 testfile2
1 India 1 NewDelhi
2 US    2 Washington
3 Ireland   3 Dublin
4 UK    4 London
5 Canada    5 Toronto

Les motifs de texte (expressions régulieres et jokers ou wildcards)

Les motifs de texte sont une notation qui permet d'exprimer de façon claire, sans ambiguïté et concise une ou plusieurs chaines de caractères. Cette notation prend plusieurs formes selon le contexte dans lequel on l'utilise. En théorie elle permet d'exprimer toutes les chaine de caractère et groupes de chaines de caractères possible et imaginable. Ces motifs peuvent être très simples et très compliqués. Ces motifs vont nous être très utiles dans le cadre de :

  • recherche de fichier ou de chaine
  • remplacement de motif complexe
  • manipulation de plusieurs fichiers en même temps (une expression régulière suffit à exprimer plusieurs noms de fichiers à la fois)

Beaucoup d'informations concernant les wildcards et les expressions régulières sont synthétisées dans les cours sur les formations LPI : http://wiki.rotomalug.org/index.php/Certifications_Linux_LPI#Les_cours Sur cette page on trouve aussi de la documentation qui balaye en largeur le BASH, awk, sed, les droits, la recherche etc...

Les wildcards ou jokers

Les wildcards sont une version limitée et syntaxiquement plus courtes des expressions régulières.

Pour en savoir plus sur les wildcards : http://wiki.rotomalug.org/index.php/LPI-101-2-1 http://www.tldp.org/LDP/GNU-Linux-Tools-Summary/html/x11655.htm

Lorsqu'on écrit une expression régulière en BASH pour exprimer des noms de fichier, il s'agit de wildcards ou de jokers. La logique est la même que pour les expressions régulières étendues mais la puissance d'expression est moindre. Un caractère important est '*' . Il signifie n'importe quel caractère, zéro, une ou plusieurs fois. On peut aussi dire "n'importe quelle chaine".

Quelques exemples :

# liste les fichiers dont le nom fini par ".txt"
ls *.txt

# liste les fichiers/répertoires dont le nom commence par "my"
ls my*

# liste les fichiers/répertoires dont le nom contient "my"
ls *my*

# liste les fichiers/répertoires dont le nom ne commence pas par 'a'
ls [^a]*

Les expressions régulieres

Beaucoup plus complètes que les wildcards, les expressions régulières (appelées également expressions rationnelles ou "regex(p)" en abrégé) sont utilisées dans des outils comme sed, awk, grep et dans de nombreux langages... Les expressions régulières sont principalement découpées en 3 catégories : les BRE (basic regular expression), les ERE (extended regular expression) et les PCRE (Perl Compatible Regular Expressions). Toutes les expressions écrites sous forme basiques (BRE) peuvent être comprises par les autres formes. PCRE est l'implémentation la plus complète. La différence entre ERE et BRE est faible; voici un extrait de wikipedia:

ERE adds ?, +, and |, and it removes the need to escape the metacharacters ( ) and { }, which are required in BRE

Tout sur les expressions régulières (en anglais) : http://www.grymoire.com/Unix/Regular.html Ou wikipedia : http://en.wikipedia.org/wiki/Regular_expression

Différence majeure avec les wildcards, par exemple sur le caractère '*' . Il signifie ici : la caractère précédent répété zéro, une ou plusieurs fois.

Les métacaractères

Dans la suite, une chaîne de caractères à rechercher sera appelée pattern. Il y a plusieurs manières de construire un pattern. Plus on est précis, moins il y a de chance qu'une autre chaîne ressemblante soit trouvée.

Pour tous les caractères spéciaux qui suivent, on parle de métacaractères. Afin d'éviter qu'ils soient interprétés, il faut, +selon le contexte, les "échapper" avec le symbole "\" ou bien utiliser des apostrophes (')+ au lieu des guillemets (").

Caractère à chercher:

MOTIF SIGNIFICATION
. n'importe quel caractère
a le caractère "a"
\. le caractère point
\s Un espace
\n Un retour à la ligne
\t Une tabulation
ab la chaîne "ab"
[abc] a ou b ou c
[^abc] ni a ni b ni c
[a-c] a, b ou c

Positionnement:

MOTIF SIGNIFICATION
^a "a" en début de ligne
a$ "a" en fin de ligne

Quantifieurs:

MOTIF SIGNIFICATION
a* "a" répété zéro, une ou plusieurs fois
.* n'importe quel caractère répété zéro, une ou plusieurs fois
a+ "a" répété une ou plusieurs fois (disponible en mode étendu)
? L'élément précédent peut être présent zéro ou une fois (disponible en mode étendu)
{m,n} motif présent de m à n fois. En cas d'absence de m, ça sera jusqu'à n fois. En cas d'absence de n, ça sera, à partir de m fois. (disponible en mode étendu)

Autres opérateurs pour expressions régulières étendues:

MOTIF SIGNIFICATION
( ) groupement pour protection ou réutilisation dans le cadre d'un remplacement
| OU logique

Voir les exemples qui suivent pour vous faire une idée plus précise de l'utilisation des parenthèses ou des pipes dans les expressions régulières

Exemples:

MOTIF SIGNIFICATION
[0-9] Un chiffre
[aeiouy] une voyelle
[aeiouy]* une suite de voyelles qui peut être vide
[aeiouy]+ une suite de voyelles non vide
[a-zA-Z] une lettre majuscule ou minuscule
[a-zA-Z]+ au moins une lettre
\s+[a-zA-Z]+\s+ un mot entouré d'espaces ou de tabulations

quelques exemples

Les exemples donnés ci-dessous sont donnés avec grep car c'est l'outil le plus simple. Si vous utilisez des outils plus avancés, tel que SED, attention à la protection des métacaractères (à échapper éventuellement avec "\" selon les cas).

# filtrer les lignes qui contiennent une chaine qui commence par "ab" et qui sont suivies d'un caractère
grep ab. fichier.txt

# montrer les lignes commentées d'un script BASH
grep ^# script.sh

# montrer les lignes qui commencent par une lettre minuscule
grep ^[a-z] file.txt

#rechercher grey ou gray dans une chaîne de caractère.
echo grey |grep -E "gr(a|e)y"
  est équivalent à
echo grey |grep gr[ae]y

echo graaaaaaaaaaaaaaaaaaaaaaay |grep -E "gra+"
echo grabababaaaaaaaaaaaaay |grep -E "^gr(ae|ab)+.*y$"

Filtrer avec grep

Grep est un des outils les plus utilisés, voir LE plus, en ligne de commande. Il permet d'afficher, parmi les lignes qu'on lui donne en entrée, seulement les lignes correspondant à certains critères.

C'est en grande partie grâce à grep qu'on peut interagir avec un terminal sans avoir à lire une quantité énorme de texte. Filtrer sert la plupart du temps à se concentrer uniquement sur le contenu qui nous intéresse.

Grep accepte des fichiers en paramètre ou peut aussi lire sur sont entrée standard. Le paramètre obligatoire est le motif de filtre.

ATTENTION grep ne filtre pas sur les lignes qui correspondent exactement au motif passé en paramètre. Grep cherche la présence du motif à l'intérieur de chaque ligne.

  • Utilisation simple de grep :
# affiche les lignes de fichier.txt qui contiennent "plop"
grep "plop" fichier.txt
# est équivalent à 
cat fichier.txt | grep "plop"
  • Début et fin de ligne :
# les lignes qui commencent par "bonjour"
grep "^bonjour" fichier.txt
# les lignes qui finissent par "aurevoir"
grep "aurevoir$" fichier.txt
  • Exemples plus complexes :
# lignes qui contiennent "bonjour" et "aurevoir"
grep "aurevoir" fichier.txt | grep "bonjour"

# lignes qui contiennent des lettres, espaces ou virgules entre parenthèses
grep "([a-z ,]*)" fichier.txt
  • Vous pouvez également utiliser grep en mode étendu pour utiliser des expressions régulières plus complexes. Il suffit de rajouter l'option "-E" ou directement "egrep" au lieu de "grep"
# n'affiche pas les lignes commentées et les lignes vides
egrep -v "^#|^$" fichier.txt

Dans l'exemple ci-dessus, nous n'affichons ni les commentaires (les commentaires commencent souvent par '#' dans les fichiers de configuration) ni les lignes vides (combinaison d'une recherche inverse avec l'option "-v" et insertion du "OU logique" avec l'utilisation du symbole "|").

Si vous avez l'habitude des expressions rationnelles en PERL, vous pouvez également utiliser celles-ci en rajoutant l'option "-P" à grep.

Quelques autres options utiles à grep: "-r" (récursif), "-i" (insensitive case), "-AN" où N est un chiffre (N After: affiche N ligne après), "-BN" (idem précédemment mais N Before).


exercices grep

  • Chercher toutes les séquences contenant "Loxodonta" dans omm.fasta

  • Filtrer uniquement les séquences Loxodonta du gène NUDT3

  • Exclure toutes les séquences de l'homme (HOMO)

  • Afficher uniquement les identfiants et les sequences du fichier test.fastq (Dans ce fichier les identifiants commencent par @, les séquences sont formées ici par A, C, G, ou T et les autres lignes contiennent que des nombres)

Outils divers (cut, sort, wc, uniq, diff)

Il existe une tonne d'outils d'analyse de texte en ligne de commande. En voici une liste non exhaustive :

cut

La fonction principale de cut est d'isoler une colonne pour toutes les lignes du contenu données en entrée.

Si on a un fichier de type :

val1A,val1B,val1C
val2A,val2B,val2C
val3A,val3B,val3C

et qu'on veut obtenir le résultat suivant :

val1B
val2B
val3B

on doit taper la commande suivante :

cut -d "," -f 2 fichier.txt

L'option "-d" permet de définir le délimiteur de colonne. L'option "-f" permet de définir quelle colonne on veut sélectionner.

uniq

uniq permet de supprimer les lignes consécutives identiques. Attention uniq ne supprime pas les lignes qui apparaissent plusieurs fois si elles ne sont pas consécutives. L'outil sort, présenté juste après, est donc très souvent complémentaire de uniq.

# soit le fichier suivant :
>cat fichier.txt
un
deux
trois
trois
deux
quatre
quatre

Voila le résultat de uniq :
>cat fichier.txt | uniq
un
deux
trois
deux
quatre

sort

Comme son nom l'indique, sort permet de trier des lignes.

Il dispose d'une option "-u" qui appliquera la commande "uniq" au résultat de sort. De cette manière on supprime les lignes en double même si elles ne sont pas consécutives.

echo "1
10
8
5
7
6
4
2
3
9" > file1;
seq 8 18 > file2;
Exemple Signification
sort file1 file2 | uniq Union of unsorted files
sort file1 file2 | uniq -d Intersection of unsorted files
sort file1 file1 file2 | uniq -u Difference of unsorted files
sort file1 file2 | uniq -u Symmetric Difference of unsorted files

wc

wc est une commande extrêmement utile qui compte le nombre de caractères, de mots ou de lignes d'un texte.

exemple : combien de lignes (sans doublons) comporte un fichier :

sort -u fichier.txt | wc -l

combien de lignes commencent par la lettre "a" :

grep "^a" fichier.txt | wc -l

D'autres outils de comptage peuvent également vous être utile: bc, nl (respectivement calculatrice en ligne de commande et un outil de comptage des lignes d'un fichier).

diff

diff est un outil pour comparer des fichiers ligne par ligne. Il permet de voir d'une manière synthétique et précise les différences entre deux fichiers.

Il est très utilisé dans le développement logiciel pour faciliter la collaboration des programmeurs.

syntaxe :

diff fichier1.txt fichier2.txt

diff permet également de comparer des répertoires avec l'option "-r"

Voir également la commande sdiff !

exercices outils divers

Soit le texte suivant dans un fichier :

ind1,20
ind2,20
ind3,10
ind4,20
ind2,30
ind1,10
ind4,11
ind3,20
  • Combien de valeur différentes existe-t-il dans la première colonne ? dans la deuxième ?

  • Triez les valeurs de la deuxième colonne par fréquence d'apparition. (uniq -c peut être utile)

SED : traitement par ligne

Sed est un outil TRES polyvalent de traitement de texte non-interactif. Comme le dit le titre de sa page de man :

"sed est un éditeur de flux pour filtrer ou transformer du texte."

C'est un outil ultra performant et puissant pour faire du traitement ligne par ligne sur un contenu de type texte. On parlera ici des fonctionnalités principales de sed : le remplacement de motif, l'insertion et les filtres.

Quelques liens de documentation externe :

sed accepte un ou plusieurs fichiers d'entrée en paramètre mais aussi et surtout un flux en entrée standard. On peut donc passer du contenu à sed par un PIPE :

programme_tres_verbeux | sed ...

remplacement de motifs

L'utilisation de loin la plus courante de sed est le remplacement de motifs qui peut faire penser à la fonction "rechercher/remplacer" des éditeurs de texte conventionnels comme OpenOffice.

La syntaxe est la suivante :

sed 's/MOTIF/REMPLACEMENT/OPTIONS' fichier.txt

Quand on applique un remplacement par sed à un fichier, il n'est pas modifié par défaut. Sed va afficher le contenu du fichier en appliquant le remplacement. Si on veut que les modifications soient appliquées directement au fichier il faut utiliser l'option -i de sed. Pour des remplacements complexes utilisant des expressions régulières étendues, nous rajouterons l'option "-r" de sed.

ATTENTION par defaut sed ne remplace que la première occurrence du motif dans chaque ligne. Pour qu'il remplace toutes les occurrences dans chaque ligne, il faut préciser l'option g. Par exemple :

echo "aa bb aa" | sed 's#aa#zz#'
# le résultat est : "zz bb aa"

# alors que si on ajoute l'option g :
echo "aa bb aa" | sed 's|aa|zz|g'
# on obtient "zz bb zz"

# si l'on veut changer uniquement la 2° occurence de aa
echo "aa bb aa" | sed 's/aa/zz/2'

# avec les parenthèses, on peut garder en mémoire un motif s'il a été trouvé et l'utiliser dans la partie droite de la substitution
# dans cet exemple la suite de lettre est représentée par \1
echo abcd123 | sed 's/\([a-z]*\).*/\1/'
# ici on inverse la suite de lettre et la suite de chiffre
# on a deux blocs parenthésés, le premier de lettres et le second de chiffres
echo abcd123 | sed 's/\([a-z]*\)\([0-9]*\)/\2\1/'
echo abcd123 | sed -r 's/([a-z]*)([0-9]*)/\2\1/'
# le résultat est "123abcd"

insertion

Avec sed, on peut insérer du contenu avant ou après un motif précis.

explication simple et courte en français : http://www.commentcamarche.net/faq/6616-sed-insertion-de-texte

Comparaison des solutions d'insertion entre différents outils comme sed, awk... : http://www.theunixschool.com/2012/06/insert-line-before-or-after-pattern.html

suppression ou deletion

On peut supprimer les lignes qui contiennent le motif spécifié avec la commande "d" de sed :

sed '/motif/d'  fichier.txt
Suppression d'une ligne particulière (ici ligne 25)
sed '25d' fichier.txt
Suppression d'une plage de lignes (ici de 3 à 25)
sed '3,25d' fichier.txt

Suppression de la ligne 1 et toutes les 2 lignes après (lignes impaires)
sed  '1~2d' fichier.txt

Suppression des lignes vides:
sed  "/^$/d" fichier.txt

Pour appliquer directement la suppression au fichier, on utilise l'option -i :

sed -i '/motif/d'  fichier.txt
Pour conserver une copie de l'original, on rajoutera le nom de l'extension derrière l'option -i :
sed -i.bak '/motif/d'  fichier.txt

filtres

On peut utiliser sed comme grep avec la command /p (print) et l'option -n (no print) :

sed -n '/^[aeiouy]/p'   file.txt

Cette commande va afficher uniquement les lignes du fichier qui commencent par une voyelle minuscule.


exercices SED

  • Récupérer depuis le shell le fichier des données sur l'Iris : http://mbb.univ-montp2.fr/MBB/uploads/iris.data (utiliser wget)
  • Transformer le séparateur de colonnes (virgule) en tabulation

  • Extraire de ce fichier la colonne 3 (petal length in cm) (utiliser cut )

  • Compter le nombre d'espèces (cut et uniq)

  • Trier par longueur de pétale croissante (regardez les options de sort)

  • Changer le nom du taxon du format genre-espèce en espèce-genre

  • Insérer une ligne d'entête précisant les noms des champs :

1. sepal length in cm, 2. sepal width in cm, 3. petal length in cm, 4. petal width in cm, 5. species

  • Changer toute suite de N en un seul gap (-) dans le fichier omm.fasta

AWK : traitement par enregistrement (ligne) et par colonnes

documentation externe

Documentation :

voila quelques tutoriels en français qui commencent à zéro :

introduction

AWK est l'outil le plus puissant et le plus performant concernant l'édition et le traitement de texte non-interactif. Sed et Awk sont souvent cités ensemble mais sont assez différents. Awk est quasiment un langage de programmation complet adapté au traitement de texte. Il contient les notions de boucle, variables simples, variables tabulaires, table de hashage, expressions régulières etc... Il comporte une infinité de fonctionnalités et de sucres syntaxiques (http://fr.wikipedia.org/wiki/Sucre_syntaxique) assez intuitifs.

AWK s'utilise avec deux paramètres :

  • le texte à analyser
  • le code en langage AWK

AWK accepte le texte en entrée standard c'est à dire par un PIPE.

echo "..." | awk ...

Par defaut, AWK fait du traitement par ligne (comme sed). Cela signifie que le code AWK sera exécuté sur chaque ligne du texte à analyser. Le contexte (état des variables utilisateur entre autres) est conservé entre les lignes.

utilisation basique

Concentrons nous sur cet aide mémoire : http://www.cheat-sheets.org/saved-copy/awk_quickref.pdf

Pour commencer, il faut connaitre la syntaxe globale de AWK.

Un programme AWK est une chaine de caractères entourée d'accolades '{PROG}'. Le séparateur d'instructions est le point-virgule ";".

AWK permet d'accéder aux colonnes de chaque ligne. Par défaut, le séparateur des colonnes est une suite d'espaces ou de tabulations. On peut changer ce séparateur avec l'option -F.

Quelques variables utiles : $0 tout le contenu de la ligne courante $1, $2 .. $NF première, seconde et dernière colonne NF le nombre de colonnes de la ligne courante NR nombre total de lignes déjà lues FNR nombre de lignes déjà lues du fichier courant

utilisation avancée

Les dictionnaires

Les dictionnaires (tableaux indexés par des chaines de caractère) sont disponibles dans awk. On peut les parcourir avec un for et accéder à leurs éléments avec des crochets [].

couleurs["vert"]="green";
couleurs["rouge"]="red";
for (i in couleurs) print couleurs[i]

Les fonctions de subtitution

gsub permet de faire une substitution de texte dans le contenu d'une variable.

transformer

Nous avons vu que les colonnes sont accessibles avec les variables $1, $2, $3 etc... Ces variables sont modifiables. $0 représente l'ensemble des colonnes. Si on ne donne pas de paramètre à la fonction print, elle imprime la ligne complète.

# soit le fichier iris.data vu précédemment

# ajouter le numéro de ligne au début de chaque ligne
awk '{print NR, $0}' iris.data

# affiche la largeur de pétale et le nom de l'espèce
awk '{print $4 " " $5}' iris.data

# affiche la longueur de sepal incrémenté de 2
awk '{$1=$1+2 ; print}' iris.data

# inverse la première et la deuxième colonne
awk '{print $2 " " $1 " " $3 " " $4 " " $5}' iris.data
# ou bien plus simple
awk '{a=$1; $1=$2; $2=a; print}' iris.data

# remplace "setosa" par "SETOSA" dans la 5e colonne
awk '{gsub("setosa","SETOSA",$5); print}' iris.data

compter

Pour des raisons pratiques, les variables numériques sont automatiquement initialisées à 0 si on les manipule alors qu'elles n'existent pas encore.

Calculer le nombre d'individus de chaque taxon:

awk '{a[$5]++} END{for (i in a) print a[i], i}' iris.data

calculer la fréquence d'occurence de chaque taxon

awk '{a[$5]++; tot++} END{for (i in a) print i, a[i]/tot }' iris.data

filtrer

Dans awk, on peut filtrer sur la présence d'un motif, c'est à dire ne traiter que les lignes qui contiennent le motif indiqué :

# afficher les largeurs de sepal pour les lignes contenant "setosa"
awk '/setosa/ {print $2}' iris.data

ou sur une autre condition avec un if :

# afficher les lignes si la longueur de sepal est supérieure à 1.3
awk '{if ($1 > 1.3) {print}}' iris.data

Filtrer uniquement les taxons dont la fréquence est >= 30% :

awk '{occur[$5]++; tot++}
    END{ for (i in occur){
             if (occur[i]/tot > 0.3){
                 print i, occur[i]
             }
         }
    }' iris.data

Jouer avec la notion d enregistrement

On peut aussi changer le séparateur d'enregistrement pour que AWK ne fonctionne plus par ligne mais en découpant avec un autre séparateur. C'est la variable RS qui définit le séparateur d'enregistrement alors que FS définit le séparateur de champs. Exemple : Soit un fichier texte contenant :

robert
groseille
49
--
jacqueline
bobard
12
--
vladimir
plitwick
99

Les enregistrement sont séparés par "\n--\n". Nous allons donc parcourir ce fichier avec AWK en spécifiant un séparateur d'enregistrement ET un séparateur de champs (ici les champs sont séparés par \n):

awk '
BEGIN{FS="\n"; RS="\n--\n"}
{ print "REC:" NR "----------------";
  print
}' test.txt

exercices (AWK)

Field What You Find There
1 readname
2 bitflag -- for SE bt2 mapping, only 0 (pos strand), 4 (unmapped), 16 (neg strand) are relevant
3 chrName/refname
4 1-based start on fwd strand (this is the end if on neg strand)
5 MAPQ
6 CIGAR string rep of alignment (most are 50M which means 50 match+mismatch)
7 chrName/refName of mate if PE; * if SE
8 1 based start of mate; * if SE
9 Inferred fragment length if PE; * if SE
10 the read's sequence
11 the reads base call qualities (Qs)
  • Compter le nombre de reads couvrant chaque contig du fichier resu.sam

  • filtrer uniquement les mapping dont la MAPQ est >= 20

  • Calculer la qualité moyenne du mapping sur chaque contig

  • Sur les Iris data, écrire le nombre d'apparitions du taxon à côté de son nom :

awk '{
    occur[$5]=occur[$5]+1
    data[NR]=$1" "$2" "$3" "$4
    name[NR]=$5
    }

    END{
        for(i=1;i<=NR;i++){
            print name[i]"/"occur[name[i]], data[i]
        }
    }' iris.data
  • Soit un fichier fasta :
    >ID1
    ATGCTGCTAGCTTCGCGGAGAAGAGATCTCT
    GAGAGCTCTGATTAAGGCCT
    GCCTTCCCGGATAAGGCCTTAGCGCCTA
    CGCGATATCGCGTTAGG
    >ID77
    GAGAGCTCTGATTAAGGCCT
    GCCTTCCCGGATAAGGCCTTAGCGCCTA
    ATGCTGCTAGCTTCGCGGAGAAGAGATCTCT
    CGCGATATCGCGTTAGG
    >ID22
    CGCGATATCGCGTTAGG
    GAGAGCTCTGATTAAGGCCT
    GCCTCCGGATAAGGCCTTAGCGCCTA
    ATGCTGCCCTTAGCTTCGCGGAGAAGAGATCTCT
    
  • A l'aide de AWK uniquement, comptez le nombre de séquences (en changeant le "RS") et comparez votre résultat avec le résultat obtenu avec "grep -c" ou avec "grep | wc -l".

  • En reprenant votre précédent script AWK, affichez les identifiants de séquence.

  • Transformez ce fichier fasta pour que chaque séquence soit sur une seule ligne (AWK only).

  • Faites vous même une simplification du fichier fastq en remplaçant les identifiants des séquences par leurs rangs dans le fichier (@blabla en @22). Quel gain de place obtenez-vous ?

  • Trouvez un moyen de garder les identifiants dans un fichier à part en conservant l'association entre chaque nombre et l'identifiant de contig.