Université de Ouahigouya

Initiation à la bioinformatique avec Python

Dr Wenddabo Olivier SAWADOGO
Table des matières

I Initiation au langage Python 1

1 Généralités sur le langage python 2

1.1 Programmer ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.1 Qu’est ce qu’un programme ? . . . . . . . . . . . . . . . . . . . . . 2
1.1.2 Langage de programmation . . . . . . . . . . . . . . . . . . . . . . 3
1.1.3 Les différentes phase de production d’un programme de haut niveau 4
[Link] Étape 1 : Définition du problème . . . . . . . . . . . . . . 4
[Link] Étape 2 : Analyse du problème . . . . . . . . . . . . . . . 4
[Link] Étape 3 : Écriture d’un algorithme avec un langage de des-
cription algorithmique . . . . . . . . . . . . . . . . . . . . 4
[Link] Étape 4 : Traduction de l’algorithme dans un langage de
programmation . . . . . . . . . . . . . . . . . . . . . . . . 4
[Link] Étape 5 : Traduction en langage machine : compilation . . 4
[Link] Étape 6 : Exécution et test . . . . . . . . . . . . . . . . . 5
1.2 Présentation du langage python . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3 les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3.2 Entrée et sortie conversationnelles . . . . . . . . . . . . . . . . . . . 6
[Link] Affichage de données à l’écran . . . . . . . . . . . . . . . . 7
1.3.3 Lecture de données au clavier . . . . . . . . . . . . . . . . . . . . . 7
1.3.4 Les opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4 Les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4.1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4.2 Opérations sur les listes . . . . . . . . . . . . . . . . . . . . . . . . 9

i
 [Link] Concaténation de deux listes . . . . . . . . . . . . . . . . 9
[Link] ajout d’un élément à la fin . . . . . . . . . . . . . . . . . . 9
[Link] Longueur d’une liste . . . . . . . . . . . . . . . . . . . . . 9
1.5 Les chaı̂nes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.5.1 Lecture d’une chaı̂ne de caractère . . . . . . . . . . . . . . . . . . . 9
1.5.2 Opération sur les chaı̂nes de caractères . . . . . . . . . . . . . . . . 10
[Link] Concaténation . . . . . . . . . . . . . . . . . . . . . . . . 10
[Link] Multiplication . . . . . . . . . . . . . . . . . . . . . . . . . 10
[Link] Longueur d’une chaı̂ne . . . . . . . . . . . . . . . . . . . . 10
1.5.3 Majuscule,minuscule . . . . . . . . . . . . . . . . . . . . . . . . . . 11
[Link] Découpage d’une chaı̂ne de caractères . . . . . . . . . . . 11
[Link] Décompte . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.6 Les structures de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.6.1 Les structures conditionnelles . . . . . . . . . . . . . . . . . . . . . 12
[Link] La structure de contrôle if . . . . . . . . . . . . . . . . . . 12
[Link] Les opérateurs de comparaison . . . . . . . . . . . . . . . 13
[Link] Connecteurs logiques . . . . . . . . . . . . . . . . . . . . . 13
[Link] Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.6.2 La structure de contrôle if ... else . . . . . . . . . . . . . . . . . . . 13
[Link] Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
[Link] Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.7 Les structures répétitives . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.7.1 Définitions et terminologie . . . . . . . . . . . . . . . . . . . . . . . 14
1.7.2 La structure while . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
[Link] Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
[Link] Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.7.3 La structure for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
[Link] Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
[Link] Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.8 Les fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.8.1 Lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
[Link] Méthode readlines() . . . . . . . . . . . . . . . . . . . . . 18
[Link] Itérations directe sur le fichier . . . . . . . . . . . . . . . . 18
 Initiation à la bioinformatique avec Python

1.8.2 Ecriture dans un fichier . . . . . . . . . . . . . . . . . . . . . . . . . 18

[Link] Méthode write() . . . . . . . . . . . . . . . . . . . . . . . 18
1.9 La programmation structurée : les fonctions . . . . . . . . . . . . . . . . . 19
1.10 Notion de fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.10.1 Définition et terminologie . . . . . . . . . . . . . . . . . . . . . . . 20
1.10.2 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.11 La programmation modulaire . . . . . . . . . . . . . . . . . . . . . . . . . 22
[Link] La factorisation du code . . . . . . . . . . . . . . . . . . . 22
[Link] La fragmentation du code . . . . . . . . . . . . . . . . . . 22
[Link] Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

2 Applications 25
2.1 Transcription-Traduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.1.1 La transcription . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.1.2 La traduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.2 Calculs du pourcentage de GC et de la température de fusion Tm . . . . . 29

Dr W. O. SAWADOGO iii Année académique 2023-2024

 Première partie

Initiation au langage Python

1
Chapitre 1

Généralités sur le langage python

1.1 Programmer ?

1.1.1 Qu’est ce qu’un programme ?

Un programme informatique réalise en général trois choses :
— Il lit des données en entrée. Le programme doit en effet savoir à partir de quoi
travailler. Pour cela, on utilise souvent un clavier, mais le programme peut aussi
tirer les données d’un disque dur ou encore d’un autre ordinateur via un réseau
ou autre.
— Il effectue des calculs. À partir des données en entrée, le programme va appliquer
automatiquement des méthodes pour traiter ces données et produire un résul-
tat. Les méthodes que sont capables d’effectuer les ordinateurs s’appellent des
algorithmes.
— Il écrit des données en sortie. Lorsque le programme a obtenu un résultat, il
doit écrire ce résultat quelque part pour qu’on puisse l’utiliser. Par exemple, une
calculatrice va afficher un résultat à l’écran ou stocker le résultat en mémoire.
Le travail d’un programmeur consiste à créer des programmes informatiques. Le
programmeur doit pour cela expliquer à l’ordinateur dans un certain langage,
appelé langage de programmation, quelles sont les données et quelles sont les
méthodes à appliquer pour traiter ces données.

2
 Initiation à la bioinformatique avec Python

1.1.2 Langage de programmation

Un langage de programmation est, d’un point de vue mathématique, un langage
formel, c’est-à-dire un ensemble de suites (appelés mots) de symboles choisis dans un en-
semble donné (appelé alphabet) qui vérifient certaines contraintes spécifiques au langage
(syntaxe).
Un programme est un mot du langage, c’est-à-dire une suite de symboles vérifiant les
contraintes dictées par la syntaxe du langage.
Le but d’un langage de programmation est de se faire comprendre de la machine et il existe
plusieurs possibilités :
— soit on utilise un langage de bas niveau : on écrit un programme directement
dans le langage machine (langage binaire) compréhensible par le processeur, mais
rarement intelligible puisque rares sont les personnes qui parlent le binaire cou-
ramment.
— soit on utilise un langage de haut niveau : on écrit un programme dans un langage
inintelligible pour le processeur, qui sera ensuite ”traduit” en langage machine afin
que le processeur l’exécute.
Ces langages, plus sympathique pour l’homme, permettent en quelques sorte de
d’écrire des taches sans se soucier des détails sur la manière dont la machine
l’exécute.
Deux stratégies sont utilisées pour les langages de haut niveau. La différence réside dans
la manière dont on traduit le programme, qui est à l’origine dans un ou plusieurs fichiers
texte appelés fichiers source ou code source :
— soit on écrit un programme dans un langage interprété. Le code source sera traduit
mot à mot ou instruction par instructions, dans le langage machine propre au
processeur par un programme auxiliaire : l’interpréteur.
Parmi ces langages, on peut citer : Matlab, python, scilab, maple, etc..
— soit on écrit un programme dans un langage compilé. Le code source sera traduit
(une bonne fois pour toute) dans le langage machine propre au processeur par un
programme appelé compilateur. Chaque langage à son compilateur.
Contrairement aux interpréteurs, les compilateurs lisent entièrement le code source
avant de le traduire, détermine la stratégie d’exécution de toutes les instructions,
puis génère un fichier binaire exécutable : le fichier produit n’a plus besoin d’être

Dr W. O. SAWADOGO 3 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

lancé par un autre programme, il est autonome. Cela permet de garantir la sécurité
du code source mais chaque modification nécessite une recompilation.
Dans cette catégorie on peut citer : C, C ++ , java, etc..

1.1.3 Les différentes phase de production d’un programme de haut ni-

veau
Nous résumons ici les étapes à suivre pour mettre en oeuvre programme informatique.

[Link] Étape 1 : Définition du problème

Il s’agit de déterminer toutes les informations disponibles et la forme des résultats

désirés.

[Link] Étape 2 : Analyse du problème

Elle consiste à trouver le moyen de passer des données aux résultats. Dans certains
cas, on peut être amené à faire une étude théorique. Il s’agit en fait de trouver la démarche
logique à suivre pour aboutir à la solution du problème. Le résultat de l’étape d’analyse
est un algorithme. Sachez aussi qu’il existe des problèmes pour lesquels on ne peut trouver
une solution et par conséquent il est impossible de donner l’algorithme correspondant.

[Link] Étape 3 : Écriture d’un algorithme avec un langage de description algorithmique

Une fois qu’on trouve le moyen de passer des données aux résultats, il faut être capable
de rédiger une solution claire et non ambiguë.

[Link] Étape 4 : Traduction de l’algorithme dans un langage de programmation

Les étapes 1, 2 et 3 se font sans le recours de la machine. Si on veut rendre l’algorithme

pratique, il faudrait le traduire dans un langage de programmation. On obtient le code
source du programme dans le langage choisi.

[Link] Étape 5 : Traduction en langage machine : compilation

En réalité la machine est incapable de comprendre le code source, il faut donc tra-
duire le traduire en langage machine : c’est la compilation à l’aide d’un programme appelé

Dr W. O. SAWADOGO 4 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

compilateur (chaque langage de programmation possède son compilateur). C’est au cours

de cette étape, que le compilateur corrige l’orthographe, c’est ce qu’on appellera syntaxe
dans le jargon de la programmation.

[Link] Étape 6 : Exécution et test

On demande à la machine d’exécuter le programme : c’est la phase d’exécution. Deux

cas peuvent se présenter lorsque la machine traduit le sens exprimé par le programme :
1. Nous obtenons les résultats obtenus sont ceux attendus, la mise au point du pro-
gramme se termine ;
2. nous n’obtenons pas de résultats, on dira que qu’il y a existence des erreurs de
logique. Le programme peut nous répondre comme suit :
— aucun résultat ;
— des résultats inattendus ;
— une partie des résultats. Dans ce cas, il faut revoir en priorité si l’algorithme
a été bien traduit, ou encore est-ce qu’il y a eu une bonne analyse.
Ce dernier cas est considéré comme grave car il faut tout refaire, c’est à dire
la révision de l’étape d’analyse pour la réécriture de l’algorithme ainsi que sa
traduction.
Quand vous programmez, gardez ceci à l’esprit : la machine fait tout ce qu’on lui dit de
faire et non ce qu’on veux qu’elle fasse !

1.2 Présentation du langage python

Le langage de programmation Python a été créé en 1989 par Guido van Rossum,
aux Pays-Bas. Le nom Python vient d’un hommage à la série télévisée Monty Python’s
Flying Circus dont G. van Rossum est fan. La première version publique de ce langage a
été publiée en 1991.
La Python Software Foundation est l’association qui organise le développement de Python
et anime la communauté de développeurs et d’utilisateurs. Ce langage de programmation
présente de nombreuses caractéristiques :
— Il est multiplateforme. C’est-à-dire qu’il fonctionne sur de nombreux systèmes
d’exploitation : Windows, Mac OS X, Linux, Android, iOS et les supercalculateurs.

Dr W. O. SAWADOGO 5 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

— Il est gratuit.
— C’est un langage de haut niveau. Il demande relativement peu de connaissance
sur le fonctionnement d’un ordinateur pour être utilisé.
— C’est un langage interprété. Un script Python n’a pas besoin d’être compilé pour
être exécuté, contrairement à des langages comme le C ou le C++.
— Il est orienté objet. C’est-à-dire qu’il est possible de concevoir en Python des
entités qui miment celles du monde réel (une cellule, une protéine, un atome, etc.)
avec un certain nombre de règles de fonctionnement et d’interactions.
— Il est relativement simple à prendre en main

1.3 les variables

1.3.1 Définition
Une instruction machine effectue des opérations sur des valeurs repérées par leur
adresse. Les langages de programmation représente une telle adresse par un nom.
En python la déclaration d’une variable et son initialisation se font en même temps.
nom var=valeur ;
Remarque 1 :
On peut initialiser plusieurs variables en même temps

i , j = 25 ,17;

affecte 25 à i et 17 à j.

1.3.2 Entrée et sortie conversationnelles

Généralement, pour qu’un programme présente un intérêt pratique, il devra pouvoir
nous communiquer un certain nombre d’informations (résultats), par l’intermédiaire
d’un périphérique de sortie, en général l’écran. Ce sera le rôle l’instruction d’écriture ou
d’affichage (terme plus approprié à l’écran).
De même, nous serons amenés, dans la plupart des cas, à transmettre des informations
(données) à notre programme, toujours par l’intermédiaire d’un périphérique de com-

Dr W. O. SAWADOGO 6 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

munication appelé entrée, en général le clavier. Cela sera réalisé par l’instruction de lecture.

[Link] Affichage de données à l’écran

print (nomvar) ;

Exemple :

— Pour afficher un message ;

p r i n t ( ’ message ’ )

— Affichage de plusieurs variable.

j =9;
m= ’ j a n v i e r ’ ;
a =2020;
p r i n t ( ’ Nous sommes au ’ , j , m, a ) ;

— Affichage formaté
j =9;
m= ’ j a n v i e r ’ ;
a =2020;
p r i n t ( ”Nous sommes au {} {} {} ” . format ( j , m, a ) ) ;

— Fixer le nombre de chiffres après la virgule

d=2/3;
p r i n t ( ”La v a l e u r de d e s t { : . 2 f } ” . format ( d ) )

1.3.3 Lecture de données au clavier

La syntaxe est

nomVar=type(input());

Exemple

Dr W. O. SAWADOGO 7 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

p r i n t ( ”Donner l e j o u r : ”)
j=i n t ( i n p u t ( ) ) ;
p r i n t ( ”Donner l e mois : ”)
m=s t r ( i n p u t ( ) ) ;
p r i n t ( ”Annee : ” ) ;
a=i n t ( i n p u t ( ) ) ;
p r i n t ( ’ Nous sommes au ’ , j , m, a ) ;

1.3.4 Les opérateurs

Ce sont des opérateurs qui agissent sur deux éléments. Ce sont :

+ addition
− soustraction
∗ produit
/ quotient
% modulo
// quotient de la division euclidienne
∗∗ puissance

Les règles de calculs sont les mêmes qu’en mathématiques. Quand deux opérateurs sont
de même priorité le parenthésage implicite est fait le plus à gauche possible, on dit que
ces opérateurs sont associatifs à gauche. On pourra utiliser des parenthèses () pour forcer
la priorité de certaines opérations.

1.4 Les listes

1.4.1 Généralités
Une liste est une structure de données qui contient une série de valeurs. Python
autorise la construction de liste contenant valeurs de types différents (par exemple entier
et chaı̂ne de caractères). Une liste se déclare pratiquement de la même manière qu’en
Matlab c’est à dire que ses éléments sont séparés par des virgules (pas des espaces), et le
tout encadré par des crochets.

Dr W. O. SAWADOGO 8 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

Exemple :

u=[5 ,9 ,8 ,96];

nom=[ ’OUEDRAOGO’ , ’SANOU ’ , ’SAM ’ ]

e =[25 , ’OUEDRAOGO’ , ’ Moussa ’ ]

On accède à un élément d’une liste de la même manière qu’en C. C’est à dire en donnant
le nom de la liste et l’indice entre crochet. Le premier élément ayant l’indice 0 et le dernier
n-1 si la liste contient n éléments. Par exemple
nom [ 0 ]

donnera OUEDRAOGO

1.4.2 Opérations sur les listes

[Link] Concaténation de deux listes

si l1 et l2 sont des listes alors l1+l2 permet de créer une liste contenant les éléments
des deux listes. Par exemple
l=u+e

donnera [5, 9, 8, 96, 25, ’OUEDRAOGO’, ’Moussa’]

[Link] ajout d’un élément à la fin

[Link](valeur)

[Link] Longueur d’une liste

len(nomListe)

1.5 Les chaı̂nes de caractères

1.5.1 Lecture d’une chaı̂ne de caractère

Une chaı̂ne de caractères est considérée comme une liste.

Dr W. O. SAWADOGO 9 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

animal=”Eléphant ”

crée une variable animal contenant la valeur Eléphant.

On accède à un caractère en précisant la position du caractère dans la chaine.
Par exemeple
p r i n t ( animal [ 0 ] )

affiche le caractère E.
On peut lire la chaı̂ne à partir du clavier
animal=s t r ( i n p u t ( ”Donner l e nom de l ’ animal : ” ) )
p r i n t ( animal [ 0 ] )

1.5.2 Opération sur les chaı̂nes de caractères

[Link] Concaténation

Elle consiste à joindre deux chaı̂nes de caractères. Elle s’effectue en utilisant l’opéra-
teur +. Par exemple
nom=”OUEDRAOGO”+” ”+”Gomnoaga ”
p r i n t (nom)

mettra dans la variable nom la valeur OUEDRAOGO Gomnoaga.

Il faut indiquer explicitement là où vous voulez que des espaces apparaissent, en les mettant
eux aussi entre des guillemets simples.

[Link] Multiplication

Elle permet d’effectuer plusieurs copies d’une chaı̂ne de caractère.

ch1 = ’ b o n j o u r ’ ∗ 2
ch2 = ’ l e monde ’
p r i n t ( ch1 + ch2 )

[Link] Longueur d’une chaı̂ne

len(nomchaine)
donne le nombre de caractère de la chaı̂ne y compris les espaces blancs.

Dr W. O. SAWADOGO 10 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

1.5.3 Majuscule,minuscule
Mettre une chaine en majuscule
[Link]()
Mettre une chaine en minuscule
[Link]()
Mettre en majuscule la première lettre
[Link]()

[Link] Découpage d’une chaı̂ne de caractères

La méthode .split() découpe une chaı̂ne de caractères en plusieurs éléments appelés

champs, en utilisant comme séparateur n’importe quelle combinaison d’espace blanc.
nom= ” OUEDRAOGO Koudougou Gomnoaga S a l i f o u Z a c h a r i e ”
f o r ch i n nom . s p l i t ( ) :
p r i n t ( ch )

[Link] Décompte

Soient ch1 et ch2. L’instruction [Link](ch1, ch2) indique le nombre d’occurrences

de ch2 dans ch1.

Exemple 1 Soit la séquence d’ADN ATATACGGATCGGCTGTTGCCTGCG-

TAGTAGCGT. Calculer la fréquence de chaque nucléotide A, T, C et G dans cette
séquence et afficher le résultat à l’écran.
s e q u e n c e=”ATATACGGATCGGCTGTTGCCTGCGTAGTAGCGT”
nbA=s t r . c o u n t ( s e q u e n c e , ’A ’ )
nbT=s t r . c o u n t ( s e q u e n c e , ’T ’ )
nbC=s t r . c o u n t ( s e q u e n c e , ’C ’ )
nbG=s t r . c o u n t ( s e q u e n c e , ’G ’ )
p r i n t ( ”Nombre N u c l é o t i d e A: ” , nbA )
p r i n t ( ”Nombre N u c l é o t i d e T : ” , nbT )
p r i n t ( ”Nombre N u c l é o t i d e C : ” , nbC )
p r i n t ( ”Nombre N u c l é o t i d e G: ” , nbG )

Dr W. O. SAWADOGO 11 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

1.6 Les structures de contrôle

— d’effectuer des choix dans le traitement réalisé ;
— de répéter plusieurs fois les mêmes instructions.
Tous les langages de programmation permettent de réaliser les choix et les répétitions
évoqués ci-dessus.
En définitive, nous pouvons dire qu’un programme comporte deux sortes d’instructions
— les instructions de base : elles réalisent une certaine action : affectation, lecture,
écriture ;
— les instructions de structuration du programme : elles servent à préciser comment
doivent s’enchaı̂ner chronologiquement ces instructions de base. On les nomme
également instructions structurées ou instructions de contrôle ou encore structures
de contrôle.
Dans ce chapitre nous verrons les instructions conditionnelles et les instructions répétitives.

1.6.1 Les structures conditionnelles

[Link] La structure de contrôle if

syntaxe

if (condition):

{
suite d’instruction;

Si la condition est vraie, c’est à dire si la valeur est différente de 0, alors la suite d’instruction
sera exécutée. Si la valeur est 0, la suite d’instructions sera ignorée et le programme se
poursuit.
La formulation d’une condition se fait souvent à l’aide des opérateurs de comparaison. Mais
on peut utiliser toute expression scalaire quelconque. Remarque : s’il n’y a qu’une seule
instruction, les accolades sont facultatives.

Dr W. O. SAWADOGO 12 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

[Link] Les opérateurs de comparaison

Les opérateurs de comparaison fréquemment utilisés sont :

égalité ==
différent !=
inférieur à <
inférieur ou égal à <=
supérieur à >
supérieur ou égal à >=

[Link] Connecteurs logiques

On formule des conditions davantage élaborées en utilisant des connecteurs.

Opérateurs python
OU or
ET and

[Link] Exemple

1.6.2 La structure de contrôle if ... else

[Link] Syntaxe

if (condition):

suite d’instructions 1;

else:

suite d’instructions 2;

Dr W. O. SAWADOGO 13 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

Si condition est vraie, la suite d’instructions 1 est exécutée, sinon c’est la suite d’exécutions
2 qui est vérifiée.

[Link] Exemples

Exemple 1
Par exemple ce code permet de déterminer le complémentaire d’une nucléotide d’une ADN
nuc =[ ’A ’ , ’T ’ , ’G ’ , ’C ’ ]
n=s t r ( i n p u t ( ”Donner l a n u c l é o t i d e : ” ) )
i f n i n nuc :
i f n==’A ’ :
c p l = ’T ’
e l i f n==’T ’ :
c p l= ’A ’
e l i f n==’G ’ :
c p l= ’C ’
e l i f n==’C ’ :
c p l= ’G ’
p r i n t ( ”Le c o m p lé m e n t a i r e e s t : ” , c p l )
else :
p r i n t ( ”Ce n ’ e s t pas une n u c l é o t i d e ”)

1.7 Les structures répétitives

1.7.1 Définitions et terminologie

Une boucle permet d’exécuter plusieurs fois de suite une même séquence d’instruc-
tions. Cette ensemble d’instructions s’appelle le corps de la boucle. Chaque exécution du
corps d’une boucle s’appelle une itération.

— while
— for

Dr W. O. SAWADOGO 14 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

1.7.2 La structure while

[Link] Syntaxe

L’instruction while permet d’exécuter un bloc d’instructions tant qu’une condition

est vraie. La syntaxe est la suivante

while (condition):
instructions

Les instructions du corps de la boucle sont délimitées par des accolades. La condition est
évaluée avant chaque passage dans la boucle, à chaque fois qu’elle est vérifiée, on exécute
les instructions de la boucle.
Une fois que la condition n’est plus vérifiée, l’exécution se poursuit après l’accolade
fermante.

[Link] Exemple

Ecrire un code python qui permet de calculer le nombre de chaque nucléotide contenue
dans une séquence d’ADN
s e q u e n c e=s t r ( i n p u t ( ”Donner l a sé q u e n c e d ’ADN: ” ) )
nbA=0;
nbT=0;
nbG=0;
nbC=0;
n=l e n ( s e q u e n c e )
i =0
while ( i < n ) :
i f s e q u e n c e [ i ]== ’A ’ :
nbA+=1;
i f s e q u e n c e [ i ]== ’T ’ :
nbT+=1;
i f s e q u e n c e [ i ]== ’G ’ :
nbG+=1;
i f s e q u e n c e [ i ]== ’C ’ :

Dr W. O. SAWADOGO 15 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

nbC+=1;
i+=1
p r i n t ( ”Nombre n u c l é o t i d e A: ” , nbA)
p r i n t ( ”Nombre n u c l é o t i d e T : ” , nbT)
p r i n t ( ”Nombre n u c l é o t i d e G: ” , nbG)
p r i n t ( ”Nombre n u c l é o t i d e C : ” , nbC)

1.7.3 La structure for

[Link] Syntaxe

En général, la structure d’une itération while est de la forme :

initialisation;
while (condition):

série d’instructions;
progression;

Si le nombre d’itérations est connu à l’avance, il plus commode d’utiliser la boucle

for qui a la forme suivante :

for cpt in range(n,m,p):

instructions;

[Link] Exemple

Reprenons l’exemple ci-dessus avec la boucle for

s e q u e n c e=s t r ( i n p u t ( ”Donner l a sé q u e n c e d ’ADN: ” ) )
nbA=0;
nbT=0;
nbG=0;
nbC=0;

Dr W. O. SAWADOGO 16 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

n=l e n ( s e q u e n c e )
f o r i i n range ( n ) :
i f s e q u e n c e [ i ]== ’A ’ :
nbA +=1;
i f s e q u e n c e [ i ]== ’T ’ :
nbT+=1;
i f s e q u e n c e [ i ]== ’G ’ :
nbG+=1;
i f s e q u e n c e [ i ]== ’C ’ :
nbC+=1;
p r i n t ( ”Nombre n u c l é o t i d e A: ” , nbA)
p r i n t ( ”Nombre n u c l é o t i d e T : ” , nbT)
p r i n t ( ”Nombre n u c l é o t i d e G: ” , nbG)
p r i n t ( ”Nombre n u c l é o t i d e C : ” , nbC)

Les trois instructions répétitives présentées ci-dessus sont équivalentes. Voici quelques consi-
dérations qui peut aider à choisir laquelle utiliser selon la nature du bloc qu’on souhaite
programmer :
— Lorsque le nombre d’itérations dépend d’un paramètre dont les valeurs initiale et
finale et l’incrémentation sont connus avant l’exécution de la boucle, on utilise
plutôt une boucle for.
— Dans le cas où le test de sortie, et donc le nombre d’itérations, dépendent d’un
calcul fait dans le corps de la boucle ou que celui-ci ne peut s’apparenter à une
incrémentation simple, on utilisera un boucle while plutôt qu’une boucle for.
Exercice
Ecrire un code python qui prend une séquence d’ADN et qui renvoie la séquence complé-
mentaire. On rappelle la séquence complémentaire s’obtient en remplaçant A par T, T par
A, C par G et G par C.

1.8 Les fichiers

Une grande partie de l’information en biologie est stockée sous forme de texte dans
des fichiers. Pour traiter cette information, on doit le plus souvent lire ou écrire dans un ou

Dr W. O. SAWADOGO 17 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

plusieurs fichiers. Dans cette partie, nous verrons quelques méthodes en python permettant
de manipuler les fichiers.

1.8.1 Lecture
[Link] Méthode readlines()

La syntaxe est la suivante :

file=open(nomfichier,”mode”) : ouverture ;
[Link]() : lecture
f i l e =open ( ”animaux . t x t ” , ”r ”)# Ouverture en mode l e c t e u r e s e u l e m e n t
l i g n e s= f i l e . r e a d l i n e s ( ) #l e c t u r e du contenu
for ligne in l i g n e s :
print ( ligne )
f i l e . c l o s e ( )# Fermeture du f i c h i e r

Avec le mot-clé with, l’ouverture et la fermeture se font de manière efficace. Voici l’exemple
précédent
with open ( ”animaux . t x t ” , ’ r ’ ) a s f i l e :
lignes = f i l e . readlines ()
for ligne in l i g n e s :
print ( ligne )

[Link] Itérations directe sur le fichier

Il est possible de parcourir directement le fichier sans utiliser readline() ou readlines()

with open ( ”animaux . t x t ” , ”r ”) a s f i l i n :
for ligne in f i l i n :
print ( ligne )

1.8.2 Ecriture dans un fichier

[Link] Méthode write()

Cette méthode permet d’écrire dans un fichier vide.

Dr W. O. SAWADOGO 18 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

animaux2 =[ ”Lion ” , ”Hyene ” , ” A n t i l o p e ” , ”S i n g e ” ]

with open ( ”animaux2 . t x t ” , ”w”) a s f i l o u t :
f o r animal i n animaux :
f i l o u t . w r i t e ( animal )

Ligne 1. Création d’une liste de chaı̂nes de caractères animaux2.

Ligne 2. Ouverture du fichier [Link] en mode écriture, avec le caractère w

pour write.

Ligne 3. Parcours de la liste animaux2 avec une boucle for.

Ligne 4. À chaque itération de la boucle, nous avons écrit chaque élément de la liste
dans le fichier. La méthode .write() s’applique sur l’objet filout.

Si nous ouvrons le fichier [Link] avec un éditeur de texte, nous obtenons :

LionHyeneAntilopeSinge Ce n’est pas exactement le résultat attendu car implicitement
nous voulions le nom de chaque animal sur une ligne. Nous avons oublié d’ajouter le
caractère fin de ligne après chaque nom d’animal.
animaux2 =[ ”Lion ” , ”Hyene ” , ” A n t i l o p e ” , ”S i n g e ” ]
with open ( ”animaux2 . t x t ” , ”w”) a s f i l o u t :
f o r animal i n animaux :
f i l o u t . w r i t e ( f ”{ animal }\n ”)

1.9 La programmation structurée : les fonctions

Lorsqu’un programme comprend de nombreuses lignes de code, il est difficile, voire
impossible de mettre toutes les instructions les unes à la suite des autres dans le programme
principal. Le programme serait illisible, comprendrait trop de variables, etc.. Pour cette
raison, on décompose les problèmes en sous-problèmes et le programme en sous-programmes
qui résolvent les sous-problèmes.
En effet tout langage de programmation offre un moyen de découper un programme en
unités indépendantes qui peuvent partager des données communes et s’appeler les unes les

Dr W. O. SAWADOGO 19 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

autres. En langage python, ces unités sont appelées fonctions.

on dit que la fonction est récursive).

1.10 Notion de fonction

1.10.1 Définition et terminologie

En mathématiques, une fonction scalaire f de n variables associe à chaque n-uplet
(x1 , x2 , . . . , xn ) appartenant une partie E d’un ensemble produit E1 × E2 × . . . × En un et
un seul élément d’un autre ensemble F , appelé ensemble d’arrivée. Cet élément est noté
en général f (x1 , x2 , . . . , xn ).
L’ensemble E est appelé domaine de définition et F est appelé ensemble d’arrivée. La
définition de la fonction f se résume en langage mathématiques comme suit :
f : E → F x 7→ f (x1 , x2 , . . . , xn )
Dans un langage de programmation comme le python, le principe est le même. Pour définir
une fonction, on a besoin de :
— son nom ;
— son ensemble d’arrivée ;
— l’algorithme qui permet de calculer l’élément de l’ensemble d’arrivée associé à un
élément du domaine de définition.
En python une fonction a la structure suivante :

def nom(var1, var2, ..., varn):

instruction;
...
return resultat;

La première ligne : def nom( var1, var2, ..., varn) est appelée en-tête de la fonction. Elle
comprend :

Dr W. O. SAWADOGO 20 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

— le nom de la fonction : Nom fonction ;

— les arguments formels de la fonction. Leurs identificateurs n’ont d’importante
qu’à l’intérieur même de la fonction.
Le bloc d’instruction qui suit l’en-tête de la fonction est appelé corps de la fonction. C’est
là qu’est explicité l’algorithme qui permet de calculer la valeur de retour de la fonction, en
fonction des arguments. Le corps de la fonction débute éventuellement par la déclaration
de variables dites locales pour stocker la valeur à retourner et si on a besoin de variables
annexes autres que les arguments.
Il doit se terminer par une instruction de retour à la fonction appelante qui utilise le mot-clé
return. Sa syntaxe est

return resultat

La valeur de resultat est la valeur que retournera la fonction Nom fonction à la fonction
qui a fait appel à elle.

1.10.2 Exemples
Dans cet exemple, nous écrivons une fonction python qui calcule la somme de deux
entiers.

d e f sommeEntier ( a , b ) :

r=a+b ;

return r ;
# Programme p r i n c i p a l
x=i n t ( i n p u t ( ”Donner l a v a l e u r de x : ” ) ) ;
y=i n t ( i n p u t ( ”Donner l a v a l e u r de y : ” ) ) ;
s=sommeEntier ( x , y ) ; # a p p e l de l a f o n c t i o n
p r i n t ( ”La somme de ” , x , ” e t de ” , y , ” e s t ” , s )

L’appel à la fonction sommeEntier() fonctionne en plusieurs étapes :

— On appelle la fonction sommeEntier() qui prend en arguments la valeur de x et
la valeur de y. x et y sont appelés arguments effectifs ;

Dr W. O. SAWADOGO 21 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

— ces valeurs sont copiées dans les variables a et b définies dans l’en-tête de la
fonction ;
— la fonction calcule et retourne la valeur de r ;
— on revient dans le main(). La fonction est remplacée par la valeur qu’elle retourne.
Cette valeur est mise dans s.

1.11 La programmation modulaire

Dès que l’on écrit un programme de taille importante ou destiné à être utilisé, il
est indispensable de se fixer un certain nombre de règles d’écriture. En particulier, il est
nécessaire de fractionner le programme en plusieurs fichiers sources, que l’on compile
séparément.
Ces règles d’écriture ont pour objectifs de rendre un programme lisible, portable, réutili-
sable mais surtout facile à maintenir et à modifier.

[Link] La factorisation du code

Le but est d’éviter les duplications de code. La présence d’une même portion de
code à plusieurs endroits du programme est un obstacle à d’éventuelles modifications. Les
fonctions doivent donc être systématiquement utilisées pour éviter la duplication de code.
Il ne faut pas craindre de définir une multitude de fonctions de petite taille.

[Link] La fragmentation du code

Pour des raisons de lisibilité, il est pertinent de découper un programme en plusieurs

fichiers. En plus, cette règle permet de réutiliser facilement une partie du code pour d’autres
applications.
On sépare alors le programme en modules, chaque module implémentant des fonctions sur
un thème similaire.

[Link] Exemple

Nous allons créer un programme python qui permet d’effectuer la somme et le produit
de deux nombres réels. Nous créerons :

Dr W. O. SAWADOGO 22 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

#f o n c t i o n . py
d e f somme ( a , b ) :

r e t u r n a+b
def produit ( a , b ) :

r e t u r n ( a ∗b ) ;

#t e s t . py
import f o n c t i o n a s op

a=i n t ( i n p u t ( ”Donner l a v a l e u r de a : ” ) )
b=i n t ( i n p u t ( ”Donner l a v a l e u r de b : ” ) ) ;
s=op . somme ( a , b ) ;
p=op . p r o d u i t ( a , b ) ;

p r i n t ( ” l a somme de ” , a , ” e t de ” , b , ” e s t : ” , s ) ;
p r i n t ( ” l e p r o d u i t de ” , a , ” e t de ” , b , ” e s t : ” , p ) ;

Exercice1

1. Ecrire une fonction qui prend en paramètre une sequence d’ADN et une nucléotide
et donne le nombre de cette nucléotide
2. Ecrire une fonction qui prend en paramètre une nucléotide et renvoie le complé-
mentaire de cette nucléotide
3. Ecrire une fonction qui en paramètre une séquence d’ADN et renvoie son complé-
mentaire
Exercice 2

Dr W. O. SAWADOGO 23 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

1. Ecrire une fonction qui prend en paramètre une chaine de caracteres et renvoie
True si la chaine est une séquence ADN et False sinon.
Rappel : une séquence ADN ne contient que les caractères A, T, C et G.
2. Ecrire une fonction qui lit une chaine de caracteres. Si la chaine lue est une
séquence ADN, elle affiche la longueur de la chaine et renvoie la chaine entrée.
Sinon, elle redemande a entrer une séquence ADN.
3. Ecrire une fonction qui calcule le poids moléculaire d’une séquence ADN passée
en parametre. Chaque lettre a un poids donné : A et T pesent 260 ug/umol ; G
et C pesent 245 ug/umol. Le poids total est la somme du poids des lettres de la
séquence.
4. Créer un module [Link] contenant les fonctions prcédentes. Dans un nouveau
script, demander a l’utilisateur de rentrer en entrée standard une chaine ADN
puis afficher son poids moléculaire.

Dr W. O. SAWADOGO 24 Année académique 2023-2024

Chapitre 2

Applications

2.1 Transcription-Traduction

2.1.1 La transcription
La transcription d’une séquence d’ADN en une sequence d’ARN s’obtient en
remplacant A par U, T par A, C par G et G par C.

def t r a n s c r i r e ( sequence ) :
t r a n s c r i t = ””
fo r nu cle o tide in sequence :
i f n u c l e o t i d e == ”A” :
t r a n s c r i t += ”U”
e l i f n u c l e o t i d e == ”T” :
t r a n s c r i t += ”A”
e l i f n u c l e o t i d e == ”G” :
t r a n s c r i t += ”C”
e l i f n u c l e o t i d e == ”C” :
t r a n s c r i t += ”G”
return t r a n s c r i t
#F o n c t i o n p r i n c i p a l e
s e q u e n c e=s t r ( i n p u t ( ”Donner l a séquence d ’ADN: ” ) )
t r a n s c r i t=t r a n s c r i r e ( s e q u e n c e )
p r i n t ( ”ADN: ” , sequence , ” ARNm: ” , t r a n s c r i t )

25
 Initiation à la bioinformatique avec Python

2.1.2 La traduction

def t r a d u i r e ( sequence ) :
t r a n s c r i t = ””
t r a d u i t = ””

# ∗∗∗∗ Boucle pour t r a n s c r i r e l a séquence ∗∗∗∗

fo r nu cle o tide in sequence :
i f n u c l e o t i d e == ”A” :
t r a n s c r i t += ”U”
e l i f n u c l e o t i d e == ”T” :
t r a n s c r i t += ”A”
e l i f n u c l e o t i d e == ”G” :
t r a n s c r i t += ”C”
e l i f n u c l e o t i d e == ”C” :
t r a n s c r i t += ”G”

# Code g \ ’ en \ ’ e t i q u e
a l a = [ ”GCU” , ”GCC” , ”GCA” , ”GCG” ]
a r g = [ ”CGU” , ”CGC” , ”CGA” , ”CGG” , ”AGA” , ”AGG” ]
asn = [ ”AAU” , ”AAC” ]
asp = [ ”GAU” , ”GAC” ]
c y s = [ ”UGU” , ”UGC” ]
g l n = [ ”CAA” , ”CAG” ]
g l u = [ ”GAA” , ”GAG” ]
g l y = [ ”GGU” , ”GGC” , ”GGA” , ”GGG” ]
h i s = [ ”CAU” , ”CAC” ]
i l e = [ ”AUU” , ”AUC” , ”AUA” ]
l e u = [ ”UUA” , ”UUG” , ”CUU” , ”CUC” , ”CUA” , ”CUG” ]
l y s = [ ”AAA” , ”AAG” ]
met = [ ”AUG” ]
phe = [ ”UUU” , ”UUC” ]
pro = [ ”CCU” , ”CCC” , ”CCA” , ”CCG” ]
s e r = [ ”UCU” , ”UCC” , ”UCA” , ”UCG” , ”AGU” , ”AGC” ]

Dr W. O. SAWADOGO 26 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

t h r = [ ”ACU” , ”ACC” , ”ACA” , ”ACG” ]

t r p = [ ”UGG” ]
t y r = [ ”UAU” , ”UAC” ]
v a l = [ ”GUU” , ”GUC” , ”GUA” , ”GUG” ]
s t o p = [ ”UAG” , ”UGA” , ”UAA” ]

# ∗∗∗∗ Boucle pour t r o u v e r l e codon i n i t i a t e u r ( s ’ i l y en a un ) ∗∗∗∗

numero = 0
numbis = 0
w h i l e numero < l e n ( t r a n s c r i t ) −2:
i f t r a n s c r i t [ numero : numero +3] == ”AUG” :
numbis = numero
break
numero += 1

# ∗∗∗∗ Boucle pour t r a d u i r e l a séquence apr ès l e codon i n i t i a t e u r ∗∗∗∗

i f numbis :
w h i l e numbis < l e n ( t r a n s c r i t ) −2:
i f t r a n s c r i t [ numbis : numbis +3] i n a l a :
t r a d u i t += ”Ala−”
e l i f t r a n s c r i t [ numbis : numbis +3] i n a r g :
t r a d u i t += ”Arg−”
e l i f t r a n s c r i t [ numbis : numbis +3] i n asn :
t r a d u i t += ”Asn−”
e l i f t r a n s c r i t [ numbis : numbis +3] i n c y s :
t r a d u i t += ”Cys−”
e l i f t r a n s c r i t [ numbis : numbis +3] i n g l n :
t r a d u i t += ”Gln−”
e l i f t r a n s c r i t [ numbis : numbis +3] i n g l u :
t r a d u i t += ”Glu−”
e l i f t r a n s c r i t [ numbis : numbis +3] i n g l y :
t r a d u i t += ”Gly−”
e l i f t r a n s c r i t [ numbis : numbis +3] i n h i s :
t r a d u i t += ”His−”
e l i f t r a n s c r i t [ numbis : numbis +3] i n i l e :

Dr W. O. SAWADOGO 27 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

t r a d u i t += ” I l e −”
e l i f t r a n s c r i t [ numbis : numbis +3] i n l e u :
t r a d u i t += ”Leu−”
e l i f t r a n s c r i t [ numbis : numbis +3] i n l y s :
t r a d u i t += ”Lys−”
e l i f t r a n s c r i t [ numbis : numbis +3] i n met :
t r a d u i t += ”Met−”
e l i f t r a n s c r i t [ numbis : numbis +3] i n phe :
t r a d u i t += ”Phe−”
e l i f t r a n s c r i t [ numbis : numbis +3] i n pro :
t r a d u i t += ”Pro−”
e l i f t r a n s c r i t [ numbis : numbis +3] i n s e r :
t r a d u i t += ”Ser−”
e l i f t r a n s c r i t [ numbis : numbis +3] i n t h r :
t r a d u i t += ”Thr−”
e l i f t r a n s c r i t [ numbis : numbis +3] i n t r p :
t r a d u i t += ”Trp−”
e l i f t r a n s c r i t [ numbis : numbis +3] i n t y r :
t r a d u i t += ”Tyr−”
e l i f t r a n s c r i t [ numbis : numbis +3] i n v a l :
t r a d u i t += ”Val−”
e l i f t r a n s c r i t [ numbis : numbis +3] i n asp :
t r a d u i t += ”Asp−”
e l i f t r a n s c r i t [ numbis : numbis +3] i n s t o p :
t r a d u i t += ”Stop ”
break
numbis += 3

return tr a d u it

else :
p r i n t ( ” I l n ’ y a pas de codon i n i t i a t e u r ”)
return
#F o n c t i o n p r i n c i p a l
s e q u e n c e = ”ATTGCCTTACAAGTATACGGGTTACTAAA”

Dr W. O. SAWADOGO 28 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

t r a d u i t=t r a d u i r e ( s e q u e n c e )
p r i n t ( ”A c i d e s amines o b t e n u e s : ” , t r a d u i t )

2.2 Calculs du pourcentage de GC et de la température de

fusion Tm
La stabilité thermique des doubles brins d’ADN dépend de la proportion de leurs
paires [A − T ] (deux liaisons hydrogene) et [G − C] (trois liaisons hydrogene). Cette
stabilité thermique (traduite par la température de fusion T m ) est déterminante pour les
expériences qui s’appuient sur une étape de séparation des brins de l’ADN .
Le pourcentage de GC ,noté %GC , est la proportion de guanine ( G ) et de cytosine (
C ) d’une séquence d’ADN . La température de dénaturation de l’ADN (dénotée T m)
est la température á laquelle 50% des liaisons établies entre les nucléotides appariés des
deux brins de l’ADN sont rompues. Le pourcentage de GC est donc l’un des parametres
qui influencent la valeur de T m et á l’inverse, la teneur en GC peut être estimée en
mesurant cette valeur. Le pourcentage de GC est le reflet de la température T m : c’est
donc un indicateur de la stabilité thermique de l’acide nucléique (parametre capital pour
les réactions de PCR , par exemple). Soient nombreAT le nombre de nucléotides A ou T
dans la séquence et nombreGC le nombre de nucléotides G ou C :

— si la longueur de la séquence est strictement inférieure á 13 nucléotides alors on

utilise la formule de Thein et Wallace (1986) :

T m = 2 × nombreAT + 4xnombreGC

— si la longueur de la séquence est de 13 nucléotides ou plus alors on utilise la formule

de Marmur et Doty (1962) :

nombreGC − 16.4
T m = 64.9 + 41 ×
nombreGC + nombreAT

s e q u e n c e=s t r ( i n p u t ( ’ Donner l a s e q u e n c e : ’ ) )
s e q u e n c e = s e q u e n c e . upper ( ) # transformation Majuscule

Dr W. O. SAWADOGO 29 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

nba=s t r . count ( sequence , ’A ’ )

nbt=s t r . count ( sequence , ’T ’ )
nbg=s t r . count ( sequence , ’G ’ )
nbc=s t r . count ( sequence , ’C ’ )
nb gc = nbg+ nbc
n b a t = nba+nbt
n b n u c l e o t i d e s = nb gc + n b a t

p c t g c = 100∗ nb gc / n b n u c l e o t i d e s
i f nb nucleotides < 13:
tm val = ( 2 ∗ n b a t ) + ( 4 ∗ nb gc )
else :
tm val = 6 4 . 9 + 4 1 . 0 ∗ ( nb gc − 1 6 . 4 ) / ( nb gc+n b a t )

p r i n t ( ”Nombre n u c l e o t i d e s : ” , n b n u c l e o t i d e s , ”\n ”)
p r i n t ( ”Po u rce nta g e GC: ” , p c t g c , ”\n ”)
p r i n t ( ”Temperature Tm: ” , tm val )

Dr W. O. SAWADOGO 30 Année académique 2023-2024

 Initiation à la bioinformatique avec Python

Dr W. O. SAWADOGO 31 Année académique 2023-2024