[PDF] Cours d’initiation au langage Perl : les variables et fonctions | Cours informatique

(1)

Introduction `

a Perl pour la bioinformatique

M2 bioinformatique

J´erˆome Farinas jerome.farinas@irit.fr

Institut de Recherche en Informatique de Toulouse Universit´e Paul Sabatier

(2)

Pr´

esentation du cours

Le cours est séparé en neuf parties. Détail des parties :

1 _{Introduction (30 mn - Mustapha)}

2 S´equences et chaˆınes de caract`eres (2h30 - Mustapha) 3 Motifs et boucles (3h - Mustapha)

4 Sous-programmes et d´ebogage (3h - Mustapha) 5 _{Exercices (3h - Mustapha)}

6 _{Mutations et nombres al´}_{eatoires (3h - J´}_erˆ_ome) 7 Code génétique (3h - Jérôme)

8 Cartes de restriction et expressions régulières (3h - Jérôme) 9 Exercices et examen écrit (4h - Jérôme)

(3)

Premi`

ere partie I

(4)

Plan de la partie

1 R´ef´erences

2 Premiers pas en Perl

(5)

Plan

1 R´ef´erences

(6)

R´

ef´

erences bibliographiques

1 _{« Introduction `}a Perl pour la bioinformatique », james Tisdall, ´ed.

O’Reilly

I base de ce cours

2 « Introduction `a Perl », Randal L. Swartz et Tom Christiansen, ´ed.

O’Reilly

I tr`es didactique

3 _{« Programmation en Perl », Larry Wall, Tom Christiansen & Jon}

Orwant, ´ed. O’Reilly

I pour aller plus loin avec Perl

4 _{http://www.perl.org/} I le site officiel

(7)

Plan

1 R´ef´erences

(8)

Premiers pas en Perl

Une courbe d’apprentissage basse et longue Avantage de Perl

Versions de Perl

Installation de Perl sur votre ordinateur Comment ex´ecuter des programmes ? ´

Editeurs de texte Obtenir de l’aide

(9)

Plan

1 R´ef´erences

(10)

L’art de la programmation

Différentes approches pour la programmation ´ Edition-exécution-modification Sauvegardes Messages d’erreur Débogage Un vivier de programmes

Les programmes libres (open source) Strat´egies de programmation

(11)

Deuxi`

eme partie II

(12)

Plan de la partie

4 Représentation de données de séquences

5 Un programme pour stocker une s´equence ADN

6 Concat´enation de fragments ADN

7 Transcription : ADN en ARN

8 Calcul du compl´ement inverse d’un brin d’ADN en Perl

9 Prot´eines, fichiers et tableaux

10 Exercices

(13)

Plan

10 Exercices

(14)

Terminologie biologique

Les symboles utilisés en bioinformatique pour représenter les séquences d’ADN et de protéines sont les mêmes que ceux utilisés par les biologistes dans la littérature.

ADN = { 4 nucléotides différents } protéines = { 20 acides aminés } fragments de protéines = peptides

nucléotide + sucre (désoxyribose pour ADN, ribose pour ARN) = nucléosides

nucléosides = { adénosine, guanosine, cytidine, thymidine, uridine } nucléotide + phosphate = nucléotides

nucl´eotides = { acide ad´elinique, guanilique, cytidilique, thymidilique, uridylique }

acide nucléique = suite de nucléotides reliées entre eux par une liaison phosphodiester

peptide = court polym`ere d’acides amin´es

prot´eine = unit´e biologique fonctionnelle faite de un ou plusieurs polypeptides

(15)

Bases nucl´

eotidiques

Code Base nucléotidiques A Adémine C Cytosine G Guanine T Thymine U Uracile M A ou C (amino) R A ou G (purine) W A ou T (liaison faible) S C ou G (liaison forte) Y C ou T (pyrimidine) K G ou T (céto) V A ou C ou G H A ou C ou T D A ou G ou T B C ou G ou T N A ou G ou C ou T

(16)

Code standard IUB/UPAC pour les acides amin´

es I

Code à une lettre Acide aminé Code à trois lettres

L Leucine Leu

A Alanine Ala

B Acide aspartique ou Asparagine Asx

C Cyst´eine Cys

D Acide aspartique Asp

E Acide glutamique Glu

F Ph´enylalanine Phe G Glycine Gly H Histidine His I Idoleucine Ile K Lysine Lys M M´ethionine Met N Asparagine Asn P Proline Pro

(17)

Code standard IUB/UPAC pour les acides amin´

es II

Q Glutamine Gln R Arginine Arg S S´erine Ser T Thr´eonine Thr V Valine Val W Tryptophane Trp X Inconnu Xxx Y Tyrosine Tyr

(18)

Code standard IUB/UPAC pour les acides amin´

es III

Remarque :

Les lettres sont souvent utilisées en minuscules (fréquemment pour ADN, rarement pour des protéines).

La terminologie utilisée en informatique diffère légèrement de celle utilisée en biologie en ce qui concerne les deux précédents tableaux.

Alphabet = ensemble finis de symboles Chaˆıne de caract`eres = suite de symboles

Langage = ensemble (fini ou infni) de chaˆınes de caractères (ici, séquences nucléiques ou protéiques)

(19)

Plan

5 Un programme pour stocker une s´equence ADN 6 Concat´enation de fragments ADN

10 Exercices

(20)

Un programme pour stocker une s´

equence ADN I

Mettons de l’ADN dans l’ordinateur

#!/usr/bin/perl -w #

# Nom du programme : exemple4-1.pl # Auteur : James Tisdall

# But du programme : Stocker de l’ADN dans une variable et l’afficher #

# Stockons le fragment dans une variable appel´ee ADN $ADN = ’ACGGGAGGACGGGAAAATTACTACGGCATTAGC’;

# Affichons la valeur de la variable ADN print $ADN;

# Fin explicite exit;

(21)

Un programme pour stocker une s´

equence ADN II

Remarques sur ce programme :

Contrôle du flux (ordre dans lequel les instructions sont exécutées) Commentaires

Ligne d’invocation Instructions Variables

Chaˆıne de caract`eres Affectation

Affichage

(22)

Plan

6 Concat´enation de fragments ADN 7 Transcription : ADN en ARN

10 Exercices

(23)

Concat´

enation de fragments ADN I

#!/usr/bin/perl -w

#

# But du programme : Concat´ener deux fragments d’ADN et les afficher #

# Stockons les fragments d’ADN dans deux variables ADN1 et ADN2 $ADN1 = ’ACGGGAGGACGGGAAAATTACTACGGCATTAGC’;

$ADN2 = ’ATAGTGCCGTGAGAGTGATGTAGTA’;

# Affichons les fragments d’origine (valeurs des variables ADN1 et ADN2) print "Voici les fragments d’ADN d’origine :\n\n";

print $ADN1, "\n"; print $ADN2, "\n\n";

# Concaténons les fragments d’ADN dans une troisième variable appelée # ADN3 en utilisant l’interpolation des cha^ınes et affichons sa valeur $ADN3 = "$ADN1$ADN2";

(24)

Concat´

enation de fragments ADN II

print "Voici la concat´enation des deux fragments (version 1) :\n\n"; print "$ADN3\n\n";

# Concaténons les fragments d’ADN dans une troisième variable appelée # ADN3 et en utilisant l’opérateur . de concaténation affichons-la $ADN3 = $ADN1 . $ADN2;

print "Voici la concat´enation des deux fragments (version 2) :\n\n"; print "$ADN3\n\n";

# Affichons la concat´enation sans stockage interm´ediaire

print "Voici la concat´enation des deux fragments (version 3) :\n\n"; print $ADN1, $ADN2, "\n\n";

(25)

R´

esultat

Voici les fragments d’ADN d’origine :

ACGGGAGGACGGGAAAATTACTACGGCATTAGC ATAGTGCCGTGAGAGTGATGTAGTA Voici la concaténation des deux fragments (version 1) : ACGGGAGGACGGGAAAATTACTACGGCATTAGCATAGTGCCGTGAGAGTGATGTAGTA Voici la concaténation des deux fragments (version 2) : ACGGGAGGACGGGAAAATTACTACGGCATTAGCATAGTGCCGTGAGAGTGATGTAGTA Voici la concaténation des deux fragments (version 3) : ACGGGAGGACGGGAAAATTACTACGGCATTAGCATAGTGCCGTGAGAGTGATGTAGTA

(26)

Plan

10 Exercices

(27)

Transcription : ADN en ARN I

#! /usr/bin/perl -w

#

# But du programme : Transcrire de l’ADN en ARN #

# Stockons le fragment d’ADN

$ADN = ’ACGGGAGGACGGGAAAATTACTACGGCATTAGC’; # Affichons le fragment d’ADN

print "Voici le fragment d’ADN d’origine :\n\n"; print "$ADN\n\n";

# Transcrivons l’ADN en ARN en substituant tous les T par des U $ARN = $ADN;

$ARN =~ s/T/U/g;

# Affichons le fragment d’ARN

(28)

Transcription : ADN en ARN II

print "$ARN\n"; # Fin explicite exit;

(29)

R´

esultat

Voici le fragment d’ADN d’origine : ACGGGAGGACGGGAAAATTACTACGGCATTAGC

Voici le r´esultat de la transcription de l’ADN en ARN : ACGGGAGGACGGGAAAAUUACUACGGCAUUAGC

(30)

Plan

8 Calcul du compl´ement inverse d’un brin d’ADN en Perl 9 Prot´eines, fichiers et tableaux

10 Exercices

(31)

Calcul du compl´

ement inverse d’un brin d’ADN I

#!/usr/bin/perl -w

#

# But du programme : Calculer le reverse compl´ement d’un brin d’ADN #

# Stockons le fragment d’ADN

$ADN = ’ACGGGAGGACGGGAAAATTACTACGGCATTAGC’;

# Affichons le fragment d’ADN

print "Voici le fragment d’ADN d’origine :\n\n"; print "$ADN\n\n";

# Calculons le compl´ement inverse # ATTENTION : cette tentative va ´echouer #

# Premi`erement, copions l’ADN dans une nouvelle variable $revcom # (raccourci pour REVerse COMpl´ement)

(32)

Calcul du compl´

ement inverse d’un brin d’ADN II

# Remarquez que les noms de variables peuvent utiliser des minuscules # comme "revcom" mais également des majuscules comme "ADN". En fait, # les minuscules sont plus courantes. En revanche, les caractères accentués

# sont interdits. #

# Il importe peu que nous retournions la cha^ıne avant de la compl´ementer # ou que nous la compl´ementions avant de la retourner.

# Si bien que lorsque nous faisons la copie, nous la retournons en meme # temps

#

$revcom = reverse $ADN;

#

# Substituons à présent chaque base par sa base complémentaire # A->T, T->A, G->C, C->G

#

$revcom =~ s/A/T/g; $revcom =~ s/T/A/g; $revcom =~ s/G/C/g;

(33)

Calcul du compl´

ement inverse d’un brin d’ADN III

$revcom =~ s/C/G/g;

# Affichons le compl´ement inverse obtenu print "Voici le compl´ement inverse :\n\n"; print "$revcom\n";

#

# Oh-oh, ¸ca ne marche pas correctement

# Notre compl´ement inverse devrait avoir un peu de toutes les bases # de notre s´equence d’ADN d’origine et pas seulement des A et des G #

# Voyez-vous pourquoi ? #

# Le problème provient des deux premières substitutions qui changent # tous les A en T, puis tous les T en A, il ne reste plus que des A # à la place des A et des T initiaux

# La m^eme chose se produit pour les C et les G #

print "\nL’algorithme est mauvais, le compl´ement inverse incorrect !\n"; print "Essayons encore... \n\n";

(34)

Calcul du compl´

ement inverse d’un brin d’ADN IV

# Stockons une nouvelle copie du fragment d’ADN (vous comprenez pourquoi # nous avons conserv´e l’original)

$revcom = reverse $ADN;

# Voir les explications pour une pr´esentation de la fonction tr/// $revcom =~ tr/ACGTacgt/TGCAtgca/;

# Affichons le compl´ement inverse du fragment d’ADN print "Voici le compl´ement inverse :\n\n";

print "$revcom\n";

print "\nCette fois ¸ca marche !\n\n"; exit;

(35)

R´

esultat

Voici le fragment d’ADN d’origine :

ACGGGAGGACGGGAAAATTACTACGGCATTAGC

Voici le compl´ement inverse : GGAAAAGGGGAAGAAAAAAAGGGGAGGAGGGGA

L’algorithme est mauvais, le compl´ement inverse incorrect ! Essayons encore...

Voici le compl´ement inverse :

GCTAATGCCGTAGTAATTTTCCCGTCCTCCCGT Cette fois ¸ca marche !

(36)

Plan

9 Prot´eines, fichiers et tableaux 10 Exercices

(37)

Lire la s´

equence d’une prot´

eine contenue dans un fichier I

#! /usr/bin/perl -w

#

# But du programme : Lire la s´equence d’une prot´eine contenue dans un # fichier

#

# Le nom du fichier contenant la s´equence de la prot´eine $nom_fichier_proteine = ’NM_021964fragment.pep’;

# Nous devons tout d’abord ouvrir le fichier et lui associer un

# descripteur de fichier qui permet par la suite d’acc´eder facilement au # fichier.

# Nous avons utilis´e FIC_PROTEINE pour plus de lisibilit´e open(FIC_PROTEINE, $nom_fichier_proteine);

(38)

Lire la s´

equence d’une prot´

eine contenue dans un fichier II

# le fichier en utilisant les caract`eres < et > pour lire les # informations depuis le descripteur de fichiers. Nous stockons les donn´ees

# dans notre variable proteine. $proteine = <FIC_PROTEINE>;

# Nous avons nos donn´ees, nous pouvons fermer le fichier close FIC_PROTEINE;

# Affichons la valeur de la variable proteine print "Voici la prot´eine :\n";

print $proteine; exit;

(39)

R´

esultat

Voici la prot´eine :

(40)

Lire la s´

equence d’une prot´

eine contenue dans un fichier

(deuxi`

eme essai) I

#! /usr/bin/perl -w #

# But du programme : Lire la séquence d’une protéine contenue dans un # fichier. Deuxième essai

#

# Nous avons utilis´e FIC_PROTEINE pour plus de lisibilit´e. open(FIC_PROTEINE, $nom_fichier_proteine);

(41)

Lire la s´

equence d’une prot´

eine contenue dans un fichier

(deuxi`

eme essai) II

# le fichier en utilisant les caract`eres < et > pour lire les # informations depuis le descripteur de fichiers.

# Puisque le fichier contient trois lignes et que la lecture retourne # une seule ligne, nous allons devoir lire et afficher une ligne # trois fois de suite

# Premi`ere ligne

$proteine = <FIC_PROTEINE>;

# Affichons la première ligne du fichier contenant la protéine print "\nVoici la première ligne du fichier-protéine :\n\n"; print $proteine;

# Deuxi`eme ligne

(42)

Lire la s´

equence d’une prot´

eine contenue dans un fichier

(deuxi`

eme essai) III

print "\nVoici la deuxi`eme ligne du fichier-prot´eine :\n\n"; print $proteine;

# Troisi`eme ligne

# Affichons la troisième ligne du fichier contenant la protéine print "\nVoici la troisième ligne du fichier-protéine :\n\n"; print $proteine;

(43)

R´

esultat

Voici la premi`ere ligne du fichier-prot´eine :

MNIDDKLEGLFLKCGGIDEMQSSRTMVVMGGVSGQSTVSGELQD

Voici la Deuxi`eme ligne du fichier-prot´eine :

SVLQDRSMPHQEILAADEVLQESEMRQQDMISHDELMVHEETVKNDEEQMETHERLPQ Voici la troisi`eme ligne du fichier-prot´eine :

(44)

Tableaux : lire la s´

equence d’une prot´

eine contenue dans

un fichier (troisi`

eme essai) I

# But du programme : Lire la séquence d’une protéine contenue dans un # fichier. Troisième essai

#

# Nous avons utilis´e FIC_PROTEINE pour plus de lisibilit´e. open(FIC_PROTEINE, $nom_fichier_proteine);

(45)

Tableaux : lire la s´

equence d’une prot´

eine contenue dans

un fichier (troisi`

eme essai) II

# fichier en utilisant les caract`eres < et > pour lire les

# informations depuis le descripteur de fichiers et la stocker dans la # variable tableau @proteine.

@proteine = <FIC_PROTEINE>;

# Affichons le contenu de la variable tableau @proteine

print "\nVoici la s´equence de la prot´eine lue dans le fichier :\n\n"; print @proteine;

(46)

R´

esultat

Voici la s´equence de la prot´eine lue dans le fichier :

MNIDDKLEGLFLKCGGIDEMQSSRTMVVMGGVSGQSTVSGELQD

SVLQDRSMPHQEILAADEVLQESEMRQQDMISHDELMVHEETVKNDEEQMETHERLPQ GLQYALNVPISVKQEITFTDVSEQLMRDKKQIR

(47)

Contexte scalaire et contexte de liste

#! /usr/bin/perl -w

#

# But du programme : D´emonstration des contextes scalaire et liste #

# Le tableau contenant les quatre bases @bases = (’A’, ’C’, ’G’, ’T’);

print "@bases\n";

# La variable $a re¸coit le nombre d’´el´ements du tableau @bases $a = @bases;

print $a, "\n";

# La variable $a re¸coit le premier ´el´ement du tableau @bases ($a) = @bases;

print $a, "\n"; # Fin explicite

(48)

R´

esultat

A C G T 4 A

(49)

Plan

10 Exercices 11 Synth`ese

(50)

Exercices I

1 Cet exercice permet de se rendre compte de la sensibilit´e des langages

de programmation face aux erreurs de syntaxe. Essayez d’enlever le point virgule à la fin de n’importe quelle instruction de l’un de vos programmes et examinez le message d’erreur qu’il en résulte, s’il y en a un. Essayez de changer un autre élément de syntaxe : ajoutez une parenthèse ou un crochet ; écrivez print ou n’importe quel autre mot réservé en faisant une faute d’orthographe ; ajoutez ou retirez ce qu’il vous plait. Les programmeurs sont habitués à répéter ce genre d’erreurs, même en connaissant parfaitement le langage, il est fréquent d’avoir des erreurs de syntaxe au fur et à mesure que l’on ajoute des lignes de code. Remarquez combien une erreur sur une ligne peut mener à plusieurs lignes pour lesquelles les avertissements sont envoyés. Perl indique-t-il avec précision la ligne où se trouve l’erreur ?

2 Ecrivez un programme qui stocke un entier dans une variable et´

(51)

Exercices II

3 Ecrivez un programme qui affiche une s´´ equence ADN (qui pourra ˆetre

en majuscules ou en minuscules à l’origine) en utilisant des lettres minuscules (a,c,g,t). Écrivez-en un autre qui écrit l’ADN en majuscules (A,C,G,T). Utilisez la fonction tr///.

4 _{Faites la mˆ}_{eme chose que l’exercice pr´}_ec´_{edent mais utilisez les}

directives pour les chaˆınes de caract`eres \U pour majuscules (en anglais uppercase), et \L pour les minuscules (en anglais lowercase), au lieu d’utiliser la fonction tr///.

5 _{Parfois l’information circule de l’ARN vers l’ADN. ´}_{Ecrivez un}

programme qui affiche une transcription inverse de lARN en ADN.

6 Lisez deux fichiers de donn´ees et affichez le contenu du premier suivi

du conteu du second.

7 Ecrivez un programme permettant de lire un fichier et d’afficher´

ensuite ses lignes en ordre inverse (la derni`ere ligne en premier). Fonctions pouvant ˆetre utiles : push, pop, shift, unshift, reverse.

(52)

Plan

10 Exercices

(53)

Synth`

ese

A la fin de cette partie, vous avez commencé à écrire des programmes perl qui manipulent des données de séquences biologiques, telles que l’ADN et les protéines.

Avec quelques s´equences dans l’ordinateur il est possible de : transcrire de l’ADN en ARN ;

concat´ener des s´equences ;

produire des s´equences compl´ementaires ;

lire des données de séquences à partir de fichiers. Vous avez manipulé des concepts de base en Perl :

les variables scalaires ; les variables tableaux ;

des opérations sur les chaˆınes de caractères (substitution, traduction) ; la lecture de données à partir de fichiers.

(54)

Troisi`

eme partie III

(55)

Plan de la partie

12 Contrˆole du flux du programme

13 _{Formattage du code} 14 Recherche de motifs

15 Boucle while

16 Boucles do while/until

17 _{Boucle foreach}

18 Gestion interne des nombres et chaˆınes

19 Boucle for

20 Ecriture dans les fichiers´

21 Exercices

(56)

Plan

12 Contrˆole du flux du programme 13 _{Formattage du code}

14 Recherche de motifs

15 Boucle while

19 Boucle for

21 Exercices

(57)

Contrˆ

ole du flux du programme

Contrˆole de flux

Ordre dans lequel les instructions d’un programme sont exécutées. Un programme s’éxécute de la première instruction (au début du programme) à la dernière instruction (en fin de programme), à moins qu’une sortie explicite en décide autrement.

Pour modifier le contrˆole de flux de programme :

I les instructions conditionnelles (if, unless) ;

(58)

L’instruction if

La contruction if prend une expression de contrôle (dont on teste la véracité) et un bloc. Elle peut éventuellement contenir une instruction else suivie elle aussi d’un bloc.

En cours d’éxécution, Perl évalue l’expression de contrôle. Si celle-ci vaut true, le premier bloc est exécuté. Si elle vaut false, c’est le second bloc qui est exécuté.

if (expression) { si-vrai_instruction_1 ; si-vrai_instruction_2 ; } else { si-faux_instruction_1 ; si-faux_instruction_2 ; }

(59)

Bloc d’instructions

D´efinition

Un bloc d’instructions est une suite d’instructions, encadrées par un jeu d’accolades. { première_instruction ; deuxième_instruction ; ... dernière_instruction ; }

Perl exécute chaque instruction à la suite, de la première à la dernière Sur le plan syntaxique, un bloc d’instructions peut remplacer

n’importe quelle instruction individuelle, mais l’inverse n’est pas vrai Le point virgule de terminaison de la dernière instruction est optionnel. Mais pour faciliter l’ajout ultérieur, il est conseillé de n’omettre le point virgule que lorsque le bloc est entièrement sur une ligne.

(60)

Bool´

eens

En Perl, les règles pour représenter true ou false sont légèrement ´

etranges mais produisent le r´esultat attendu. L’expression de contre est ´

evalu´ee comme une valeur de chaˆıne dans un contexte scalaire (s’il s’agit d’une chaˆıne, pas de changement, mais s’il s’agit d’un nombre, il est converti en chaˆıne). Si cette chaˆıne est soit une chaˆıne vide (de longueur nulle), soit la chaˆıne contenant un seul caract`ere 0 (le chiffre zero), la valeur de l’expression est false. Tout le reste est automatiquement true. 0 # se change en "0" donc false

1-1 # se calcule en 0, puis se change en "0", donc false 1 # se change en "1" donc true

"" # chaˆıne vide, donc false "1" # non "" et non "0", donc true

"00" # non "" et non "0", donc true (c’est surprenant, attention) "0.000" # est également true, même raison et même avertissement undef # est évalué en "", donc false

(61)

L’instrcution unless

Pour se passer de la partie then et ne garder que la partie else, il est possible d’utiliser la structure unless (« si l’expression de contrˆole est fausse... »)

print "Quel ^age avez-vous ?" ; $a = <STDIN> ;

chomp($a) ;

unless ($a < 18) {

print "Vous ^etes assez ag´e, allez voter !\n" ; $votant++ ;

}

(62)

L’instruction elsif I

elsif permet d’ajouter des branchements `a une structure if s’il y a plusieurs choix possibles.

if (expression_une) { une_si-vrai_instruction_1 ; une_si-vrai_instruction_2 ; } elsif (expression_deux) { deux_si-vrai_instruction_1 ; deux_si-vrai_instruction_2 ; } elsif (expression_trois) { trois_si-vrai_instruction_1 ; trois_si-vrai_instruction_2 ; } else { autre_si-vrai_instruction_1 ; autre_si-vrai_instruction_2 ; }

(63)

L’instruction elsif II

Chaque expression (ici : expression_un, expression_deux et expression_trois) est calculée à tour de rôle.

Si une expression est vraie, la branche correspondante est exécutée et toutes les expressions de contrôle restantes et les blocs d’instructions correspondants sont sautés.

Si toutes les expressions sont fausses, la branche else est ex´ecut´e (si elle existe).

(64)

Exemple complet I

# But du programme : Les structures conditionnelles if-elsif-else #

$fragment = ’MNIDDKL’;

# Utilisons les structures conditionnelles if-elsif-else if ( $fragment eq ’QSTVSGE’ )

{

print "QSTVSGE\n"; }

elsif ( $fragment eq ’MRQQDMISHDEL’ ) {

print "MRQQDMISHDEL\n"; }

elsif ( $fragment eq ’MNIDDKL’ ) {

(65)

Exemple complet II

print "MNIDDKL : le fragment magique !\n"; }

else {

print "le fragment \"$fragment\" n’est pas trouv´e \n"; }

(66)

Boucles I

# But du programme : Lire les séquences des protéineis contenues dans un # fichier. Quatrième essai.

#

# Le nom du fichier contenant les s´equences des prot´eines $nom_fichier_proteine = ’NM_021964fragment.pep’;

# Nous devons tout d’abord « ouvrir » le fichier et, dans le cas o`u # l’ouverture ´echoue, afficher un message d’erreur et quitter le # programme

unless ( open(FIC_PROTEINE, $nom_fichier_proteine) ) {

print "Impossible d’ouvrir le fichier $nom_fichier_proteine !\n"; exit;

(67)

Boucles II

# Lisons la séquence de la protéine depuis le fichier grâce à une # boucle while affichant les lignes au fur et à mesure de la lecture while( $proteine = <FIC_PROTEINE> )

{

print " ###### Voici la prochaine ligne du fichier :\n"; print $proteine;

}

(68)

Plan

12 Contrˆole du flux du programme 13 _{Formattage du code}

14 Recherche de motifs

15 Boucle while

19 Boucle for

21 Exercices

(69)

Formattage du code I

Une fois que vous avez commencé à utiliser des boucles et des instructions conditionneles, il faut penser sérieusement au format du code que vous allez produire.

De nombreux choix sont possibles. exemple :

I Format A :

while ( $vivante ) {

if ( $besoin_nutriments ) {

print "La cellule a besoin de nutriments\n";

} } I Format B : while ( $vivante ) { if ( $besoin_nutriments ) {

(70)

Formattage du code II

suite exemple : I Format C : while ( $vivante ) { if ( $besoin_nutriments ) {

} }

I Format D :

while ($vivante){if($besoin_nutriments){print "La cellule a besoin de nutriments\n";}}

(71)

Plan

13 _{Formattage du code}

14 Recherche de motifs 15 Boucle while

19 Boucle for

21 Exercices

(72)

Motifs en bioinfo

recherche de motifs : courts segments d’ADN ou de prot´eines pr´esentant un interet particulier

exemple :

I _{recherche des ´}_el´_{ements de r´}_{egulation de l’ADN}

I courtes portions de protéiness qui sont connues pour etre conservées chez de nombreuses espèces

I _{cf. site web PROSITE http://www.expasy.ch/prosite/}

Il peut y avoir des variantes dans les motifs `a rechercher, il peut y avoir des variations de taille

→utilisation d’expressions r´eguli`eres Exemple de traitement : exemple5.3.pl

I lire la s´equence d’une prot´eine depusi un fichier

I organiser la s´equence en une seule chaine de caract`eres pour faciliter la recherche

(73)

Recherche de motifs I

#! /usr/bin/perl -w

#

# But du programme : Rechercher des motifs #

# Demandons à l’utilisateur le nom du fichier # contenant la séquence et lisons la réponse print "Entrer le nom du fichier à ouvrir : "; $nom_fichier_proteine = <STDIN>;

# Retirons le retour-chariot (\n) en fin de r´eponse chomp $nom_fichier_proteine;

(74)

Recherche de motifs II

{

print "Impossible d’ouvrir le fichier $nom_fichier_proteine !\n"; exit;

}

# Nous pouvons à présent lire la séquence de la protéine grâce au descripteur

# de fichier FIC_PROTEINE plac´e entre les caract`eres < et > # Nous la stockons dans la variable tableau @proteine @proteine = <FIC_PROTEINE>;

# Concaténons toutes les lignes pour placer la séquence de la protéine # dans une seule cha^ıne de caractères. Il sera plus simple de rechercher # un motif dans une cha^ıne plutôt que dans un tableau de lignes

# (que se passe-t-il si le motif est `a cheval sur deux lignes ?) $proteine = join(", @proteine);

(75)

Recherche de motifs III

# Retirons les ´eventuels espaces $proteine =~ s/\s//g;

# Dans une boucle, demandons un motif à l’utilisateur d’entrer un motif # Recherchons-le dans la protéine et affichons-le s’il est trouvé # Fin du programme si aucun motif n’est entré

do {

print "Entrer un motif `a rechercher : "; $motif = <STDIN>;

# Retirons le retour-chariot `a la fin de $motif chomp $motif;

# Recherchons le motif if ( $proteine =~ /$motif/ ) {

print "Je l’ai trouv´e !\n\n"; }

(76)

Recherche de motifs IV

{

print "Je ne l’ai pas trouv´e.\n\n"; }

# Sortie de boucle si la cha^ıne est vide }

until ( $motif =~ /^\s*$/ );

(77)

Plan

13 _{Formattage du code} 14 Recherche de motifs 15 Boucle while

19 Boucle for

21 Exercices

(78)

L’instruction while

Perl peut itérer (exécuter de manière répétée un bloc d’instructions) en utilisant l’instruction while : « tant que l’expression est vrai ».

while (expression) { instruction_1 ; instruction_2 ; instruction_3 ; }

Pour exécuter le while, Perl évalue l’expression de contrôle.

Si la valeur est vraie le corps de l’instruction while est ex´ecut´e une fois.

Cela est répété jusqu’à ce que l’expression devienne fausse, moment où Perl se branche sur l’instruction suivant la boucle while.

(79)

Recherche de motifs `

a l’aide de while I

#! /usr/bin/perl -w

#

# Nom du programme : exemple5-3.1pl

# But du programme : Rechercher des motifs `a l’aide de while #

#Définissons une courte séquence protéique $proteine = "ACDEFGHIKLMNYVWTSRQP";

# Préparons la boucle en demandant à l’utilisateur # d’entrer son motif au clavier. En même temps que ce # motif est lu, enlevons le retour-chariot à la fin du motif print "Entrer un motif à rechercher : ";

chomp ($motif = <STDIN>);

# L’instruction while suivante teste si le motif est vide # Si le motif n’est pas vide, la boucle est ex´ecut´ee while ( $motif !~ /^$/ )

(80)

Recherche de motifs `

a l’aide de while II

if ($proteine =~ /$motif/ ) {

print "\nLe motif existe dans la s´equence !\n\n"; } else {

print "\nPas de motif dans la s´equence !\n\n"; }

print "Entrer un motif `a rechercher : "; chomp ($motif = <STDIN>);

} exit;

(81)

Plan

15 Boucle while

16 Boucles do while/until 17 _{Boucle foreach}

19 Boucle for

21 Exercices

(82)

L’instruction do {} while

L’instruction do {} while effectue une it´eration comme while/until, mais teste la condition apr`es chaque boucle.

do {

instruction_1 ; instruction_2 ; instruction_3 ; } while (expression) ;

(83)

L’instruction do {} until

Comme avec while il est possible d’inverser le sens du test : $arrets = 0 ;

do {

$arrets++ ;

print "Prochain arret ? " ; chomp($endroit = <STDIN>) ; }

(84)

Plan

15 Boucle while

16 Boucles do while/until 17 _{Boucle foreach}

19 Boucle for

21 Exercices

(85)

L’instruction foreach I

L’instruction foreach est un autre type d’itération : elle prend une série de valeurs et les assigne l’une après l’autre à une variable scalaire, en exécutant un bloc de code à chaque assignation successive.

Exemple

@a = (1,2,3,4,5) ;

foreach $b (reverse $a) { print $b ;

}

Remarque

La série utilisée par foreach peut être une expression de liste arbitraire, pas seulement une variable tableau.

(86)

L’instruction foreach II

Remarque

Si vous itérez avec une liste constituée de variables réelles au lieu de fonctions renvoyant une valeur de liste, la variable servant à l’itération est en réalité un pointeur de chaque variable de la liste au lieu d’être une simple copie de valeurs. Donc en modifiant la valeur scalaire, vous modifiez également de la liste.

Exemple

@a = (3,5,7,9) ;

foreach $element (@a) { $element *= 3 ;

}

(87)

S´

eparation d’une chaˆıne de caract`

eres en un tableau I

#! /usr/bin/perl -w

#

# But du programme : Compter le nombre d’occurrence de chacune des bases # d’une s´equence d’ADN contenue dans un fichier

#

# Demandons `a l’utilisateur le nom du fichier contenant la s´equence # et lisons ce nom au clavier

print "Entrer le nom du fichier `a ouvrir : "; $nom_fichier_adn = <STDIN>;

# Retirons le retour-charriot de la fin de la r´eponse chomp $nom_fichier_adn;

(88)

S´

eparation d’une chaˆıne de caract`

eres en un tableau II

unless ( open(FIC_ADN, $nom_fichier_adn) )

{

print "Impossible d’ouvrir le fichier $nom_fichier_adn !\n"; exit;

}

# Nous pouvons à présent lire la séquence d’ADN depuis le # fichier en utilisant les caractères < et > pour lire les

# informations depuis le descripteur de fichiers et la stocker dans la # variable tableau @adn.

@adn = <FIC_ADN>;

# Nous avons nos donn´ees, nous pouvons fermer le fichier close FIC_ADN;

# Placons la séquence de la protéine dans une seule cha^ıne de caractères # Il sera plus simple de rechercher un motif dans une cha^ıne plutôt # que dans un tableau de lignes (que se passe-t-il si le motif est à # cheval sur deux lignes ?)

(89)

S´

eparation d’une chaˆıne de caract`

eres en un tableau III

$adn = join(", @adn);

# Retirons les ´eventuels espaces $adn =~ s/\s//g;

# Séparons à présent la séquence d’ADN en un tableau où chaque lettre # de la cha^ıne d’origine est un élément du tableau

# Cela permettra de déterminer facilement la position de chaque base # Remarquez que nous réutilisons @adn à cet effet.

@adn = split(", $adn );

# Initialisons les compteurs.

# Remarquez que nous utilisons des variables scalaires pour conserver # les nombres $nbre_de_A = 0; $nbre_de_C = 0; $nbre_de_G = 0; $nbre_de_T = 0; $nbre_d_erreurs = 0;

(90)

S´

eparation d’une chaˆıne de caract`

eres en un tableau IV

# Nous allons, dans la boucle, inspecter chaque position, d´eterminer quel

# est le nucléotide à cette position et incrémenter le compteur # correspondant

foreach $base (@adn) { if ( $base eq ’A’ ) { ++$nbre_de_A; } elsif ( $base eq ’C’ ) { ++$nbre_de_C; } elsif ( $base eq ’G’ ) { ++$nbre_de_G; } elsif ( $base eq ’T’ )

(91)

S´

eparation d’une chaˆıne de caract`

eres en un tableau V

{ ++$nbre_de_T; } else {

print "!!!!!!!! Erreur - Je ne reconnais pas cette base : $base\n"; ++$nbre_d_erreurs;

} }

# Affichons les r´esultats print "A = $nbre_de_A\n"; print "C = $nbre_de_C\n"; print "G = $nbre_de_G\n"; print "T = $nbre_de_T\n";

print "Erreurs = $nbre_d_erreurs\n";

(92)

Plan

15 Boucle while

18 Gestion interne des nombres et chaˆınes 19 Boucle for

21 Exercices

(93)

Gestion interne des nombres et chaˆınes I

#! /usr/bin/perl -w

#

# But du programme : D´emonstration de la gestion interne des nombres et des

# cha^ınes en Perl #

$nombre = 1234; $chaine = ’1234’;

# Affichons les valeurs des variables nombre et chaine print $nombre, " ", $chaine, "\n";

# Additionnons les variables en tant que nombres $nombre_ou_chaine = $nombre + $chaine;

(94)

Gestion interne des nombres et chaˆınes II

print $nombre_ou_chaine, "\n";

# Concat´enons les variables en tant que cha^ınes $nombre_ou_chaine = $nombre . $chaine;

print $nombre_ou_chaine, "\n"; exit;

(95)

Plan

15 Boucle while

18 Gestion interne des nombres et chaˆınes 19 Boucle for

21 Exercices

(96)

L’instruction for I

for (initial_exp; test_exp; re-init_exp) { instruction_1 ;

instruction_2 ; instruction_3 ; }

C’est identique `a la structure suivante : initial_exp; while(test_exp) { instruction_1 ; instruction_2 ; instruction_3 ; re-init_exp ; }

(97)

L’instruction for II

Afficher les nombres de 1 `a 10 :

Exemple

for ($i = 1 ; $i <= 10 ; $i++) { print "$i " ;

(98)

Comptage de nucl´

eotides (2) I

#! /usr/bin/perl -w

#

# But du programme : Compter le nombre d’occurrence de chacune des bases # d’une s´equence d’ADN contenue dans un fichier.

# Deuxi`eme essai. #

# Demandons à l’utilisateur le nom du fichier contenant la séquence # et récupérons ce nom

# Retirons le retour-chariot de la fin de la r´eponse chomp $nom_fichier_adn;

# Testons si le fichier existe unless ( -e $nom_fichier_adn)

(99)

Comptage de nucl´

eotides (2) II

{

print "Le fichier \"$nom_fichier_adn\" semble ne pas exister !!\n"; exit;

}

unless ( open(FIC_ADN, $nom_fichier_adn) ) {

}

@adn = <FIC_ADN>;

close FIC_ADN;

(100)

Comptage de nucl´

eotides (2) III

# Retirons les espacements

$adn =~ s/\s//g;

# Remarquez que nous utilisons des variables scalaires pour conserver # les nombres $compteur_A = 0; $compteur_C = 0; $compteur_G = 0; $compteur_T = 0; $compteur_erreurs = 0;

# Nous allons, dans la boucle, inspecter chaque position, d´eterminer quel

# est le nucléotide à cette position et incrémenter le compteur # correspondant

for ( $position = 0 ; $position < length $adn ; ++$position ) {

$base = substr($adn, $position, 1); if ( $base eq ’A’ )

(101)

Comptage de nucl´

eotides (2) IV

{ ++$compteur_A; } elsif ( $base eq ’C’ ) { ++$compteur_C; } elsif ( $base eq ’G’ ) { ++$compteur_G; } elsif ( $base eq ’T’ ) { ++$compteur_T; } else {

print "!!!!!!!! Erreur - Je ne reconnais pas cette base : $base\n"; ++$compteur_erreurs;

(102)

Comptage de nucl´

eotides (2) V

}

# Affichons les r´esultats print "A = $compteur_A\n"; print "C = $compteur_C\n"; print "G = $compteur_G\n"; print "T = $compteur_T\n";

print "Erreurs = $compteur_erreurs\n";

(103)

Plan

15 Boucle while

19 Boucle for

20 Ecriture dans les fichiers´ 21 Exercices

(104)

Comptage de nucl´

eotides (3) I

#! /usr/bin/perl -w

#

# But du programme : Compter le nombre d’occurrence de chacune des bases # d’une s´equence d’ADN contenue dans un fichier.

# Troisi`eme essai. #

# Demandons à l’utilisateur le nom du fichier contenant la séquence # et récupérons ce nom

# Retirons le retour-charriot de la fin de la r´eponse chomp $nom_fichier_adn;

# Testons si le fichier existe unless ( -e $nom_fichier_adn)

(105)

Comptage de nucl´

eotides (3) II

{

print "Le fichier \"$nom_fichier_adn\" semble ne pas exister !!\n"; exit;

}

unless ( open(FIC_ADN, $nom_fichier_adn) ) {

}

@adn = <FIC_ADN>;

close FIC_ADN;

(106)

Comptage de nucl´

eotides (3) III

$adn =~ s/\s//g;

# Remarquez que nous utilisons des variables scalaires pour conserver # les nombres

$a = 0; $c = 0; $g = 0; $t = 0; $e = 0;

# Utilisons les expressions r´eguli`eres pour faire cinq boucles et # trouver le nombre d’occurrences de chacune des bases et les erreurs while ( $adn =~ /a/ig ) { $a++ }

while ( $adn =~ /c/ig ) { $c++ } while ( $adn =~ /g/ig ) { $g++ } while ( $adn =~ /t/ig ) { $t++ } while ( $adn =~ /[^acgt]/ig ) { $e++ }

print "A=$a C=$c G=$g T=$t Erreurs=$e\n";

# Affichons le r´esultat de nos recherches dans le fichier nomm´e « compte_bases »

(107)

Comptage de nucl´

eotides (3) IV

$fic_sortie = "compte_bases";

unless ( open(COMPTE_BASES, ">$fic_sortie") ) {

print "Impossible d’ouvrir le fichier \"$fic_sortie\" en sortie !!\n\n"; exit;

}

print COMPTE_BASES "A=$a C=$c G=$g T=$t Erreurs=$e\n";

close(COMPTE_BASES); # Fin explicite exit;

(108)

Plan

15 Boucle while

19 Boucle for

20 Ecriture dans les fichiers´ 21 Exercices

(109)

Exercices I

1 Utilisez une boucle pour ´ecrire un programme qui s’ex´ecute sans fin.

Le test doit être évalué à vrai à chaque tour de boucle. Remarquez que certains systèmes vont se rendre compte que vous êtes dans une boucle infinie et stopper le programme automatiquement. La fa¸con de terminer le programme dépend de votre système d’exploitation : <Ctrl><C> sous Unix et Linux, en mode commandes MS-DOS sous Windows et dans une fenêtre shell de Mac OS X.

2 Demandez `a l’utilisateur d’entrer deux (courtes) s´equences d’ADN.

Concaténez les deux séquences ADN en ajoutant la seconde à la fin de la première à l’aide de l’opérateur d’affectation .=. Affichez ensuite les deux séquences concaténées, ainsi que la seconde séquence en l’alignant sur la fin des séquences concaténées. Par exemple, si les séquences sont AAAA et TTTT, la sortie sera :

AAAATTTT TTTT

(110)

Exercices II

3 _{Ecrivez un programme qui affiche tous les nombres de 1 `}´ _{a 100. Le}

nombre de lignes de votre programme devra être inférieur à 100 !

4 _{Ecrivez un programme qui calcule le compl´}´ _{ement inverse d’un brin}

d’ADN sans utiliser les commandes s/// ou tr///. Utilisez la fonction substr et examinez les bases une par une dans une variable originelle pendant que vous construirez le compl´ement inverse

(astuce : il est plus facile d’examiner la séquence d’origine de droite à gauche plutôt que de gauche à droite, même si les deux sens de parcours sont possibles).

5 _{Ecrivez un programme qui affiche le pourcentage d’acides amin´}´ _es

hydrophobes dans une s´equence de prot´eines.

6 Ecrivez un programme qui teste si deux chaˆınes donn´´ ees en arguments

sont les compléments inverses l’une de l’autre. Utilisez les fonctions Perl intégrées split, pop, shift et l’opérateur de comparaison eq.

7 Ecrivez un programme qui affiche le pourcentage de GC d’une´

(111)

Exercices III

8 Modifiez l’exercice pour trouver non seulement les motifs d´esign´es par

les expressions régulières mais également afficher le motif qui a été trouvé. Par exemple, si vous cherchez (en utilisant une expression régulière) le motif EE.*EE, votre programme devra afficher

EETVKNDEE. Vous pouvez utiliser la variable spéciale $&. Après une recherche de motif réussie, cette variable spéciale contient le motif qui correspond à votre recherche.

9 Ecrivez un programme qui ´´ echange deux bases dans une s´equence

d’ADN à des positions spécifiées (astuce : vous pouvez utiliser les fonctions Perl substr et splice).

10 Ecrivez un programme qui cr´´ ee un fichier temporaire, le remplit de

donn´ees, puis le supprime. La fonction unlink supprime le fichier, par exemple :

unlink "fic_tempo";

(112)

Plan

15 Boucle while

19 Boucle for

(113)

Synth`

ese

Vous devriez maintenant ˆetre capable de :

rechercher des motifs dans des s´equences d’ADN ou de prot´eines ; ´

ecrire un programme interactif ; ´

ecrire des donn´ees dans des fichiers ; utiliser des boucles ;

utiliser des expressions régulières élémentaires

effectuer différentes actions en fonction de tests conditionnels ; examiner les données de séquence en détail en utilisant des chaˆınes de caractères et des tableaux.

(114)

Quatri`

eme partie IV

(115)

Plan

23 Sous-programmes

24 Port´ee et sous-programmes

25 Arguments de la ligne de commande et tableaux

26 Transmission de donn´ees aux sous-programmes

27 Modules et biblioth`eques de sous-programmes

28 Correction de bogues

29 Exercices

(116)

Sous-programmes

Un sous programme est un morceau de code qui peut-etre consid´er´e comme un programme dans le programme

son utilisation ou son invocation est couramment d´enomm´e « appel du sous-programme »

on lui attribue un nom grace auquel le programme peut l’appeler on peut lui transmettre des donn´ees qu’il doit traiter

une fois son exécution terminée, le sous-programme retourne les résultats au programme principal qui peut alors reprendre son cours sous programme = petite portion de code qui exécute une tache bien définie

Il peut etre utilis´e plusieurs fois dans un meme programme ou dans des programmes diff´erents

(117)

Avantages des sous-programmes

Les sous programmes permettent d’´ecrire un programme :

I plus court

I plus rapide `a ´ecrire

I plus facile `a comprendre

I plus r´eutilisable

I plus ´evolutif

I plus facile `a tester

(118)

´

Ecrire un sous-programme I

Exemple de sous-programme devant ajouter ACGT `a une s´equence d’ADN :

I appel :

ajouter_ACGT($adn);

I la valeur de retour est récupéré dans le programme

Dans les versions anciennes de Perl, il fallait précéder le nom de l’appel par le caractère &. Il est toujours possible de la faire. #! /usr/bin/perl -w

#

# But du programme : Un programme contenant un sous-programme permettant

# d’ajouter ACGT `a une s´equence d’ADN # La cha^ıne d’ADN d’origine

(119)

´

Ecrire un sous-programme II

# Appel au sous-programme ajouter_ACGT

# Un argument qui est transmis `a la fonction est stock´e dans $adn, la

# valeur retourn´ee par la fonction est stock´e dans adn_etendu $adn_etendu = ajouter_ACGT($adn);

print "J’ai ajout´e ACGT `a $adn pour obtenir $adn_etendu\n\n"; exit;

######################################################################## #

# Sous-programmes pour l’exemple 6-1 #

# nom du sous-programme : ajouter_ACGT

# but du sous-programme : ajouter ACGT `a la cha^ıne pass´ee en argument

# nombre d’arguments : 1

# nature de l’argument : cha^ıne de caract`eres #

(120)

´

Ecrire un sous-programme III

{

# Récupérons l’argument passé au sous-programme my($adn) = @_;

# Concaténons ACGT à la variable $adn existante. Équivalent à : # $adn = $adn . ’ACGT’;

$adn .= ’ACGT’;

# Retournons la cha^ıne ´etendue return $adn;

}

# Fin des sous-programmes #

(121)

Plan

23 Sous-programmes

29 Exercices

(122)

Port´

ee et sous-programmes I I

la portée d’une variable correspond à la zone de visibilité de la variable dans le programme

Pour limiter la port´ee d’une variable dans un sous-programme on utiliser la d´eclaration my

my($x) ou my $x

Illustration des pi`eges lorsque l’on n’utilise pas my : #! /usr/bin/perl -w

#

# But du programme : Illustrer les pi`eges rencontr´es lorsque nous n’utilisons

# pas les variables my $adn = ’AAAAA’;

(123)

Port´

ee et sous-programmes I II

print "J’ai changé tous les A en T dans $adn et voilà le résultat : ";

print "$resultat\n\n"; exit;

########################################################################## #

# Sous-programme pour l’exemple 6-2 #

# nom du sous-programme : A_en_T

# but du sous-programme : changer tous les A en T dans la cha^ıne pass´ee

# en argument

# nature de l’argument : cha^ıne de caract`eres #

sub A_en_T {

(124)

Port´

ee et sous-programmes I III

$adn = $entree; $adn =~ s/A/T/g; return $adn; } # Fin du sous-programme # ########################################################################

(125)

Plan

23 Sous-programmes

25 Arguments de la ligne de commande et tableaux 26 Transmission de donn´ees aux sous-programmes

29 Exercices

(126)

Arguments de la ligne de commande et tableaux I

# But du programme : Compter le nombre de G pr´esents dans une squence d’ADN pass´ee en argument au programme principal #

use strict;

# R´ecuprons la s´equence d’ADN passe en argument sur la ligne de # commandes (lors de l’appel du programme).

# Si aucun argument n’est donn´e, afficher une aide et terminer. # $0 est une variable spciale qui contient le nom du programme my($USAGE) = "USAGE : $0 fragment_ADN\n\n";

# @ARGV est un tableau contenant tous les arguments de la ligne # de commande. S’il est vide, le test va ´echouer et afficher le # contenu de la variable USAGE et terminer le programme.

unless ( @ARGV ) {

(127)

Arguments de la ligne de commande et tableaux II

print $USAGE; exit;

}

# Lisons la squence d’ADN partir de la ligne de commande my($adn) = $ARGV[0];

# Appelons le sous-programme qui effectue le vrai travail et récupère le résultat

my($nombre_de_G) = compter_G( $adn ); # Affichons le r´esultat

print "\nLa squence d’ADN $adn poss`ede $nombre_de_G G !\n\n"; exit;

########################################################################## #

# Sous-programme pour l’exemple 6-3 #

# nom du sous-programme : compter_G

# but du sous-programme : compter le nombre de G pr´esents dans la chaine pass´ee en argument

(128)

Arguments de la ligne de commande et tableaux III

# nature de l’argument : chaine de caract`eres #

sub compter_G {

# Initialisons les arguments et les variables my($adn) = @_;

my($compte) = 0;

# Utiliser la quatrième méthode pour compter les nucléotides comme cela a été présent dans le chapitre Motifs et boucles $compte = ( $adn =~ tr/Gg// ); return $compte; } # Fin du sous-programme # ########################################################################

(129)

Plan

23 Sous-programmes

26 Transmission de donn´ees aux sous-programmes 27 Modules et biblioth`eques de sous-programmes

29 Exercices

(130)

Passage par valeur

les valeurs des arguments sont copi´ees et transmises aux ss-pg sans que cela les affecte dans le pg principal.

Perl transmet la valeur des arguments au ss-pg dans le tableau @ Exemple :

my $i = 2 ;

print "dans le pg principal, avant appel : \$i vaut $i\n " sous_pg($i) ;

print "dans le pg principal, apr`es appel : \$i vaut $i\n " exit ; ;ajouter_ACGT($adn); # sous_pg sub sous_pg { my($i) = @_ ; $i += 100 ;

print "dans le sous-pg : \$i vaut $i\n " }

(131)

Passage par r´

ef´

erence

Les variables transmises sont modifi´ees par le sous pg et les modif. retransmises au prog. Pricipal.

Perl transmet le nom des arguments au ss-pg dans le tableau @ Exemple :

my @i = (‘1’, ‘2’, ‘3’) ; my @j = (‘a’, ‘b’, ‘c’) ;

print "dans le pg principal, avant appel : \$i vaut @i\n" print "dans le pg principal, avant appel : \$j vaut @j\n" sous_pg_ref(\@i, \@j) ;

print "dans le pg principal, apr`es appel : \$i vaut @i\n" print "dans le pg principal, apr`es appel : \$j vaut @j\n" exit ;

sub sous_pg_ref { my($i, $j) = @_ ;

print "dans le sous-pg : \$i vaut @$i\n " ; print "dans le sous-pg : \$j vaut @$j\n " ; push(@$i, ‘4’) ;

(132)

Plan

23 Sous-programmes

27 Modules et biblioth`eques de sous-programmes 28 Correction de bogues

29 Exercices

(133)

Modules et biblioth`

eques de sous-programmes

Regrouper des sous-pg dans des fichiers .pm (exemple : use IntroPerlBioinfo ;)

Insérer à la fin : 1; (pour indiquer qu’il n’y a pas eu d’erreur et renvoyer une valeur différente de la valeur false)

Ins´erer au d´ebut du pg : use NomModule1 ;

(134)

Plan

23 Sous-programmes

28 Correction de bogues 29 Exercices

(135)

Correction de bogues

Ajout de directives Perl pour am´eliorer les controles :

I use warning ;

I use strict ;

Activer les avertissements :

I en d´ebut de programme : #! /usr/bin/perl -w (-w : active les avertissements)

I ou bien en indiquant : use warning ;

(permet d’activer les avertissements)

En utilisant des commentaires (pour isoler des portions de codes probl´ematiques) et en utilisant l’instruction print (pour afficher le contenu de variables)

(136)

Utilisation du d´

ebogueur

Le débogueur permet de résoudre des cas difficiles à cerner. Lancement :

$ perl -d exemple.pl

I -d pour activer le mode debug

I q : quitter

I _{demander l’aide : h}

(137)

Progresser dans les instructions

Le d´ebogueur indique la ligne qu’il est sur le point d’ex´ecuter : DB <n°ligne>

afficher des valeurs p $adn afficher la variable $ ou @ p

exécuter une instruction s (step) ou n (next) évite d’entrer dans un ss-pg réexécuter la même commande « entrée »

afficher plusieurs instructions w (window) placer un point d’arrêt b numéro ligne continuer jusqu’au point d’arrêt c supprimer tous les points d’arrêt D

(138)

Plan

23 Sous-programmes