Cours Python

Cours de Python
http://www.dsimb.inserm.fr/~fuchs/python/
Patrick Fuchs et Pierre Poulain

prnom [point] nom [arobase] univ-paris-diderot [point] fr
version du 26 aot 2015
Universit Paris Diderot-Paris 7, Paris, France

Institut Jacques Monod (CNRS UMR 7592) et DSIMB (INSERM UMR_S 665)
Ce document est sous licence Creative Commons BY-SA

http://creativecommons.org/licenses/by-sa/2.0/fr/
Bienvenue au cours de Python !
Ce cours a t conu lorigine pour les tudiants dbutants en programmation Python des
filires biologie et biochimie de lUniversit Paris Diderot - Paris 7 ; et plus spcialement pour
les tudiants du master Biologie Informatique.
Ce cours est bas sur la version 2.7 de Python, version que lon trouve par dfaut dans les
distributions Linux actuelles (comme Ubuntu 14.04 ou Fedora 22). Le cours sera mis jour vers
la version 3.x de Python dans les prochains mois (ds que python 3 sera le standard dans les
distributions Linux). Nous avons ajout un paragraphe dans lintroduction traitant des princi-
pales diffrences entre python 2 et python 3 .
Si vous relevez des erreurs la lecture de ce document, merci de nous les signaler.
Le cours est disponible en version HTML et PDF.
Remerciements
Un grand merci Sander du CMBI de Nijmegen pour la premire version de ce cours.
Merci galement tous les contributeurs, occasionels ou rguliers : Jennifer Becq, Virginie
Martiny, Romain Laurent, Benoist Laurent, Benjamin Boyer, Hubert Santuz, Catherine Lesourd,
Philippe Label, Rmi Cuchillo, Cdric Gageat, Philibert Malbranche, Mikal Naveau, Amlie
Bacle. Nous remercions aussi Denis Mestivier de qui nous nous sommes inspirs pour certains
exercices.
Enfin, merci vous tous, les curieux de Python, qui avez t nombreux nous envoyer des
retours sur ce cours, nous suggrer des corrections et nous signaler des coquilles.
De nombreuses personnes nous ont aussi demand les corrections des exercices. Nous ne
les mettons pas sur le site afin dviter la tentation de les regarder trop vite, mais vous pouvez
nous crire et nous vous les enverrons.
2 Cours de Python / Universit Paris Diderot - Paris 7 / UFR Sciences du Vivant

Table des matires Table des matires
Table des matires

1 Introduction 6
1.1 Avant de commencer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2 Premier contact avec Python sous Linux . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3 Premier programme Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.4 Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.5 Sparateur dinstructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.6 Notion de bloc dinstructions et dindentation . . . . . . . . . . . . . . . . . . . . 8
1.7 Python 2 ou Python 3 ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2 Variables 11
2.1 Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Nommage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3 Oprations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3 criture 14
3.1 criture formate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.2 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4 Listes 17
4.1 Dfinition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.2 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.3 Opration sur les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.4 Indiage ngatif et tranches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.5 Fonctions range et len . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.6 Listes de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.7 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5 Boucles et comparaisons 21
5.1 Boucles for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.2 Comparaisons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.3 Boucles while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
5.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
6 Tests 28
6.1 Dfinition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
6.2 Tests plusieurs cas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
6.3 Tests multiples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
6.4 Instructions break et continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
6.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
7 Fichiers 33
7.1 Lecture dans un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
7.2 criture dans un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
7.3 Mthode optimise douverture et de fermeture de fichier . . . . . . . . . . . . . . 36
7.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
8 Modules 38
8.1 Dfinition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
8.2 Importation de modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
8.3 Obtenir de laide sur les modules imports . . . . . . . . . . . . . . . . . . . . . . 39
8.4 Modules courants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Cours de Python / Universit Paris Diderot - Paris 7 / UFR Sciences du Vivant 3

8.5 Module sys : passage darguments . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

8.6 Module os . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
8.7 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
9 Plus sur les chanes de caractres 44

9.1 Prambule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
9.2 Chanes de caractres et listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
9.3 Caractres spciaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
9.4 Mthodes associes aux chanes de caractres . . . . . . . . . . . . . . . . . . . . . 45
9.5 Conversion de types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
9.6 Conversion dune liste de chanes de caractres en une chane de caractres . . . 47
9.7 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
10 Plus sur les listes 50

10.1 Proprits des listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
10.2 Test dappartenance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
10.3 Copie de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
10.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
11 Dictionnaires et tuples 54
11.1 Dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
11.2 Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
11.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
12 Fonctions 57
12.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
12.2 Dfinition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
12.3 Passage darguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
12.4 Porte des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
12.5 Porte des listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
12.6 Rgle LGI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
12.7 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
13 Expressions rgulires et parsing 64

13.1 Dfinition et syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
13.2 Module re et fonction search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
13.3 Exercices : extraction des gnes dun fichier genbank . . . . . . . . . . . . . . . . . 68
14 Cration de modules 69
14.1 Cration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
14.2 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
14.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
15 Autres modules dintrt 71

15.1 Module urllib2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
15.2 Module pickle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
15.2.1 Codage des donnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
15.2.2 Dcodage des donnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
15.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

16 Modules dintrt en bioinformatique 74

16.1 Module numpy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
16.1.1 Objets de type array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
16.1.2 Un peu dalgbre linaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
16.1.3 Un peu de transforme de Fourier . . . . . . . . . . . . . . . . . . . . . . . 78
16.2 Module biopython . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
16.3 Module matplotlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
16.4 Module rpy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
16.5 Exercice numpy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
16.6 Exercice rpy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
17 Avoir la classe avec les objets 86

17.1 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
18 Gestion des erreurs 87
19 Trucs et astuces 90
19.1 Shebang et /usr/bin/env python . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
19.2 Python et utf-8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
19.3 Vitesse ditration dans les boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
19.4 Liste de comprhension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
19.5 Sauvegardez votre historique de commandes . . . . . . . . . . . . . . . . . . . . . 92

1 Introduction
1 Introduction
1.1 Avant de commencer
Avant de dbuter ce cours, voici quelques indications gnrales qui pourront vous servir
pour la suite.
Familiarisez-vous avec le site www.python.org. Il contient normment dinformations et
de liens sur Python et vous permet en outre de le tlcharger pour diffrentes plateformes
(Linux, Mac, Windows). La page dindex des modules est particulirement utile (ici la
mme page pour python 3.*).
Pour aller plus loin avec Python, Grard Swinnen a crit un trs bon livre intitul Ap-
prendre programmer avec Python et tlchargeable gratuitement. Les ditions Eyrolles
proposent galement la version papier de cet ouvrage.
Ce cours est bas sur une utilisation de Python sous Linux mais il est parfaitement trans-
posable aux systmes dexploitation Windows et Mac.
Lapprentissage dun langage informatique comme Python va ncessiter dcrire des lignes
de codes laide dun diteur de texte. Si vous tes dbutants, nous vous conseillons vive-
ment dutiliser gedit ou nedit, qui sont les plus proches des diteurs que lon peut trouver
sous Windows (notepad). Des diteurs comme emacs et vi sont trs puissants mais nces-
sitent un apprentissage particulier.
1.2 Premier contact avec Python sous Linux

Python est un langage interprt, cest--dire que chaque ligne de code est lue puis inter-
prte afin dtre excute par lordinateur. Pour vous en rendre compte, lancez la commande :
python
Celle-ci va dmarrer linterprteur Python. Vous devriez obtenir quelque chose de ce style :
[fuchs@opera ~]$ python

Python 2.5.1 (r251:54863, Jul 10 2008, 17:25:56)
[GCC 4.1.2 20070925 (Red Hat 4.1.2-33)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>
Le bloc [fuchs@opera ~]$ reprsente linvite de commande de votre shell sous Linux.
Le triple chevron >>> est linvite de Python (prompt en anglais), ce qui signifie que Python
attend une commande. Tapez par exemple linstruction
print "Hello world !"
puis validez votre commande avec la touche Entre.

Python a excut la commande directement et a affich le texte Hello world !. Il attend
ensuite votre prochaine instruction en affichant linvite de linterprteur Python (>>> ). En r-
sum, voici ce qui a du apparatre sur votre cran :
>>> print "Hello world !"

Hello world !
>>>
Vous pouvez refaire un nouvel essai en vous servant cette fois de linterprteur comme
dune machine calculer.

1.3 Premier programme Python 1 Introduction
>>> 1 + 1
2
>>>
ce stade, vous pouvez entrer une autre commande ou bien quitter linterprteur laide
des touches Ctrl-D. Finalement linterprteur Python est un systme interactif dans lequel vous
pouvez entrer des commandes, que Python excutera sous vos yeux (au moment o vous vali-
derez la commande en tapant sur Entre).
Il existe de nombreux autres langages interprts tels que Perl ou R. Le gros avantage est
que lon peut directement tester une commande laide de linterprteur, ce qui est trs utile
pour dbugger (cest--dire corriger les ventuelles erreurs dun programme). Gardez bien en
mmoire cette proprit de Python qui pourra parfois vous faire gagner un temps prcieux !
1.3 Premier programme Python

Bien sr, linterprteur prsente vite des limites ds lors que lon veut excuter une suite
dinstructions plus complexe. Comme tout langage informatique, on peut enregistrer ces ins-
tructions dans un fichier, que lon appelle communment un script Python.
Pour reprendre lexemple prcdent, ouvrez un diteur de texte (par exemple gedit ou nedit)
et entrez le code suivant.
print 'Hello World !'
Ensuite enregistrez votre fichier sous le nom test.py, puis quittez lditeur de texte. Lexten-
sion standard des scripts Python est .py. Pour excuter votre script, vous avez deux moyens.
1. Soit donner le nom de votre script comme argument la commande Python :
[fuchs@opera ~]$ python test.py

Hello World !
[fuchs@opera ~]$
2. Soit rendre votre fichier excutable. Pour cela deux oprations sont ncessaires :
Prcisez au shell la localisation de linterprteur Python en indiquant dans la premire
ligne du script :
#!/usr/bin/env python
Dans notre exemple, le script test.py contient alors le texte suivant :

Rendez votre script Python excutable en tapant :
chmod +x test.py
Pour excuter votre script, tapez son nom prcd des deux caractres ./ (afin de prciser
au shell o se trouve votre script) :
[fuchs@opera ~]$ ./test.py

Hello World !
[fuchs@opera ~]$

1 Introduction 1.4 Commentaires
1.4 Commentaires
Dans un script, tout ce qui suit le caractre # est ignor par Python jusqu la fin de la ligne
et est considr comme un commentaire. Une exception notable est la premire ligne de votre
script qui peut tre #!/usr/bin/env python et qui a alors une signification particulire
pour Python.
Les commentaires sont indispensables pour que vous puissiez annoter votre code. Il faut
absolument les utiliser pour dcrire les principales parties de votre code dans un langage hu-
main.
# votre premier script Python

# d'autres commandes plus utiles pourraient suivre
1.5 Sparateur dinstructions

Python utilise lespace comme sparateur dinstructions. Cela peut sembler vident, mais il
est tout de mme important de le prciser. Par exemple :
>>> print 1
1
>>> print1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'print1' is not defined
Omettre lespace entre linstruction print et le chiffre 1 renvoie une erreur.
1.6 Notion de bloc dinstructions et dindentation

Pour terminer ce chapitre dintroduction, nous allons aborder ds maintenant les notions
de bloc dinstructions et dindentation.
En programmation, il est courant de rpter un certain nombre de choses (avec les boucles,
voir chapitre 5) ou de faire des choix (avec les tests, voir chapitre 6).
Par exemple, imaginez que vous souhaitiez rpter 10 fois 3 instructions diffrentes, les
unes la suite des autres. Regardez lexemple suivant en pseudo-code :
instruction_qui_indique__Python_de_rpter_10_fois_ce_qui_suit:
sous-instruction1
sous-instruction2
sous-instruction3
instruction_suivante
La premire ligne correspond une instruction qui va indiquer Python de rpter 10 fois
dautres instructions (il sagit dune boucle, on verra le nom de la commande exacte plus tard).
Dans le pseudo-code ci-dessus, il y a 3 instructions rpter, nommes sous-instruction1
sous-instruction3.
Notez bien les dtails de la syntaxe. La premire ligne indique que lon veut rpter une ou
plusieurs instructions, elle se termine par :. Ce symbole : indique Python quil doit attendre
un bloc dinstructions, cest--dire un certains nombres de sous-instructions rpter. Python

1.7 Python 2 ou Python 3 ? 1 Introduction
reconnat un bloc dinstructions car il est indent. Lindentation est le dcalage dun ou plu-
sieurs espaces ou tabulations des instructions sous-instruction1 sous-instruction3,
par rapport
instruction_qui_indique__Python_de_rpter_10_fois_ce_qui_suit:.
Pratiquement, lindentation en Python doit tre homogne (soit des espaces, soit des tabula-
tions, mais pas un mlange des deux). Une indentation avec 4 espaces est le style dindentation
le plus traditionnel et celui qui permet une bonne lisibilit du code.
Enfin, la ligne instruction_suivante sera excute une fois que le bloc dinstructions
sera termin.
Si tout cela vous semble un peu fastidieux, ne vous inquitez pas. Vous allez comprendre
tous ces dtails, et surtout les acqurir, en continuant ce cours chapitre par chapitre.
1.7 Python 2 ou Python 3 ?

Important : pour les dbutants, nous vous conseillons de sauter la lecture de ce paragraphe
(retenez seulement que ce cours est en python 2.7, donc installez puis lancez python 2.7 pour
les futurs exercices).
Vous tes nombreux nous demander la mise jour du cours vers Python 3. Nous avons
dcid deffectuer cette mise jour au moment o python 3 deviendra standard dans les dis-
tributions Linux. En effet pour linstant sur mon Ubuntu 12.04, lorsque je lance linterprteur
cest bien python 2.7 qui est lanc (il en est de mme pour la dernire Ubuntu 14.04) :
[fuchs@rome cours_python]$ python

Python 2.7.3 (default, Jun 22 2015, 19:33:41)
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>
Toutefois, dans les futures versions dUbuntu (e.g. la 15.04), python 3 deviendra le standard.
Alors quelles sont les diffrences majeures entre python 2 et python 3 ? Une documentation
exhaustive est disponible ici, mais pour ce qui nous intresse dans le cadre de ce cours, quatre
diffrences mritent dtre cites :
1. la fonction print : en python 3, la fonction print utilise des parenthses comme tout
autre fonction python, par exemple : print("Bonjour"). Par consquent, la syntaxe
print "Bonjour" renverra une erreur.
2. le formattage de chaine de caractres : bien que cela existe depuis python 2, la mthode
format() - plus lgante - est vivement conseille pour formatter les chaines de carac-
tres :
>>> print("{0:7.3f}".format(2.0/3.0))
0.667
>>>
Lancienne syntaxe "%7.3f" % (2.0/3.0) reste toutefois encore fonctionnelle.
3. la division dentier : en python 3, une division dentier comme 3/5 renverra un float :
>>> 3/5
0.6
>>>
On pourra noter que cela tait dj possible en python 2, en utilisant le module __future__ :

1 Introduction 1.7 Python 2 ou Python 3 ?
>>> 2/4
0
>>> from __future__ import division
>>> 2/4
0.5
>>>
4. la fonction range : en python 3, range() se comporte comme xrange() en python
2, cest dire quil sagit dun itrateur (plus efficace en mmoire) plutt quun simple
gnrateur de liste. Si on veut gnrer une liste, il suffit dutiliser la fonction list() :
>>> range(10)
range(0, 10)
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
Vous avez maintenant quelques pointeurs vers les nouvelles fonctionnalits de python 3
avant que nous mettions jour le cours, nous vous souhaitons un bon codage en Python !

2 Variables
2 Variables
Une variable est une zone de la mmoire dans laquelle une valeur est stocke. Aux yeux
du programmeur, cette variable est dfinie par un nom, alors que pour lordinateur, il sagit en
fait dune adresse (i.e. une zone particulire de la mmoire).
En Python, la dclaration dune variable et son initialisation (c.--d. la premire valeur que
lon va stocker dedans) se fait en mme temps. Pour vous en convaincre, regardez puis testez
les instructions suivantes aprs avoir lanc linterprteur :
>>> x = 2
>>> x
2
Dans cet exemple, nous avons dclar, puis initialis la variable x avec la valeur 2. Linter-
prteur nous a ensuite permis de regarder le contenu de la variable juste en tapant son nom.
Retenez ceci car cest une spcificit de linterprteur Python, trs pratique pour chasser les
erreurs (debug) dans un programme. Par contre, la ligne dun script Python qui contient seule-
ment le nom dune variable (sans aucune autre fonction) naffichera pas la valeur de la variable
lcran.
2.1 Types
Le type dune variable correspond la nature de celle-ci. Les trois types principaux dont
nous aurons besoin sont les entiers, les rels et les chanes de caractres. Bien sr, il existe
de nombreux autres types (par exemple, les nombres complexes), cest dailleurs un des gros
avantages de Python (si vous ntes pas effrays, vous pouvez vous en rendre compte ici).
Dans lexemple prcdent, nous avons stock un nombre entier (int) dans la variable x,
mais il est tout a fait possible de stocker des nombres rels (float) ou des chanes de caractres
(string) :
>>> y = 3.14
>>> y
3.1400000000000001
>>> a = "bonjour"
>>> a
'bonjour'
>>> b = 'salut'
>>> b
'salut'
>>> c = '''girafe'''
>>> c
'girafe'
Vous remarquez que Python reconnat certains types de variable automatiquement (en-
tier, rel). Par contre, pour une chane de caractres, il faut lentourer de guillemets (simples,
doubles voire triples) afin dindiquer Python le dbut et la fin de la chane.
Vous vous posez sans doute une question concernant lexemple du rel. Si vous avez entr le
chiffre 3.14, pourquoi Python limprime-t-il finalement avec des zros derrire (3.1400000000000001) ?
Un autre exemple :
>>> 1.9
1.8999999999999999
>>>

2 Variables 2.2 Nommage
Cette fois-ci, Python crit 1.9 sous la forme 1.8 suivi de plusieurs 9 ! Sans rentrer dans les
dtails techniques, la manire de coder un rel dans lordinateur est rarement exacte. Jusquaux
versions 2.6 Python ne nous le cache pas et le montre lorsquil affiche ce nombre.
noter : partir des versions 2.7 et suprieures, cet affichage redevient "cach" par Python :
>>> 3.14
3.14
>>>
2.2 Nommage
Le nom des variable en Python peut-tre constitu de lettres minuscules (a z), de lettres
majuscules (A Z), de nombres (0 9) ou du caractre soulign (_).
Nanmoins, un nom de variable ne doit pas dbuter ni par un chiffre, ni par _ et ne peut
pas contenir de caractre accentu. Il faut absolument viter dutiliser un mot rserv par
Python comme nom de variable (par ex. : print, range, for, from, etc.).
Python est sensible la casse, ce qui signifie que les variables TesT, test ou TEST sont
diffrentes. Enfin, nutilisez jamais despace dans un nom de variable puisque celui-ci est le
sprateur dinstructions.
2.3 Oprations
Les quatre oprations de base se font de manire simple sur les types numriques (nombres
entiers et rels) :
>>> x = 45
>>> x + 2
47
>>> y = 2.5
>>> x + y
47.5
>>> (x * 10) / y
180.0
Remarquez toutefois que si vous mlangez les types entiers et rels, le rsultat est renvoy
comme un rel (car ce type est plus gnral).
Loprateur puissance utilise le symbole ** et pour obtenir le reste dune division entire,
on utilise le symbole modulo % :
>>> 2**3
8
>>> 3 % 4
3
>>> 8 % 4
0
Oprations sur les chanes de caractres

Pour les chanes de caractres, deux oprations sont possibles, laddition et la multiplica-
tion :
>>> chaine = "Salut"

>>> chaine
'Salut'

2.3 Oprations 2 Variables
>>> chaine + " Python"

'Salut Python'
>>> chaine * 3
'SalutSalutSalut'
Loprateur daddition + permet de concatner (assembler) deux chanes de caractres et

loprateur de multiplication * permet de dupliquer plusieurs fois une chane.
Oprations illicites
Attention ne pas faire dopration illicite car vous obtiendriez un message derreur :
>>> 'toto' + 2
File "<stdin>", line 1, in ?
TypeError: cannot concatenate 'str' and 'int' objects
Notez que Python vous donne le maximum dindices dans son message derreur. Dans
lexemple prcdent, il vous indique que vous ne pouvez pas mlanger des objets de type str
(string, donc des chanes de caractres) avec des objets de type int (donc des entiers), ce qui
est assez logique.
Fonction type()
Si vous ne vous souvenez plus du type dune variable, utilisez la fonction type qui vous le
rappelle.
>>> x = 2
>>> type(x)
<type 'int'>
>>> x = 2.0
>>> type(x)
<type 'float'>
>>> x = '2'
>>> type(x)
<type 'str'>
Faites bien attention, pour Python, la valeur 2 (nombre entier) est diffrente de 2.0 (nombre
rel), de mme que 2 (nombre entier) est diffrent de '2' (chane de caractres).

3 criture
3 criture
Nous avons dj vu au chapitre prcdent la fonction print qui permet dafficher une
chane de caractres. Elle permet en plus dafficher le contenu dune ou plusieurs variables :
>>> x = 32
>>> nom = 'John'
>>> print nom , ' a ' , x , ' ans'
John a 32 ans
Python a donc crit la phrase en remplaant les variables x et nom par leur contenu. Vous
pouvez noter galement que pour crire plusieurs blocs de texte sur une seule ligne, nous avons
utilis le sparateur , avec la commande print. En regardant de plus prs, vous vous apere-
vrez que Python a automatiquement ajout un espace chaque fois que lon utilisait le spara-
teur ,. Par consquent, si vous voulez mettre un seul espace entre chaque bloc, vous pouvez
retirer ceux de vos chanes de caractres :
>>> print nom , 'a' , x , 'ans'

John a 32 ans
Pour imprimer deux chanes de caractres lune ct de lautre sans espace, vous devrez
les concatner :
>>> ani1 = 'chat'

>>> ani2 = 'souris'
>>> print ani1, ani2
chat souris
>>> print ani1 + ani2
chatsouris
3.1 criture formate

Imaginez que vous vouliez calculer puis afficher la proportion de GC dun gnome. Notez
que la proportion de GC sobtient comme la somme des bases Guanine (G) et Cytosine (C)
divise par le nombre total de bases. Sachant que lon a 4500 bases G, 2575 bases C pour un
total de 14800 bases, vous pourriez faire comme suit (notez bien lutilisation des parenthses
pour grer les priorits des oprateurs) :
>>> propGC = (4500.0 + 2575)/14800

>>> print "La proportion de GC est", propGC
La proportion de GC est 0.478040540541
Remarquez que si vous aviez fait le calcul avec (4500 + 2575)/14800, vous auriez ob-
tenu 0 car tous les nombres sont des entiers et le rsultat aurait t, lui aussi, un entier. Lintro-
duction de 4500.0 qui est un rel rsoud le problme, puisque le calcul se fait alors sur des
rels.
Nanmoins, le rsultat obtenu prsente trop de dcimales (onze dans le cas prsent). Pour
pouvoir crire le rsultat plus lisiblement, vous pouvez utiliser loprateur de formatage %.
Dans votre cas, vous voulez formater un rel pour lafficher avec deux puis trois dcimales :
>>> print "La proportion de GC est %.2f" % propGC

Le proportion de GC est 0.48
>>> print "La proportion de GC est %.3f" % propGC
La proportion de GC est 0.478

3.1 criture formate 3 criture
Le signe % est appel une premire fois (%.2f) pour

1. dsigner lendroit o sera place la variable dans la chane de caractres ;
2. prciser le type de la variable formater, ici f pour float donc pour un rel ;
3. prciser le formatage voulu, ici .2 soit deux chiffres aprs la virgule.
Le signe % est rappel une seconde fois (% propGC) pour indiquer les variables formater.
Notez que les rels ainsi formats sont arrondis et non tronqus.
Vous pouvez aussi formatez des entiers avec %i (i comme integer)
>>> nbG = 4500

>>> print "Le gnome de cet exemple contient %i guanines" % nbG
Le gnome de cet exemple contient 4500 guanines
ou mettre plusieurs nombres dans une mme chane de caractres.
>>> nbG = 4500

>>> nbC = 2575
>>> print "Ce gnome contient %i G et %i C, soit une prop de GC de %.2f" \
... % (nbG,nbC,propGC)
Ce gnome contient 4500 G et 2575 C, soit une prop de GC de 0.48
Remarque :
1. Dans lexemple prcdent, nous avons utilis le symbole % pour formater des variables.
Si vous avez besoin dcrire le symbole pourcentage % sans quil soit confondu avec celui
servant pour lcriture formate, il suffit de le doubler. Toutefois, si lcriture formate
nest pas utilise dans la mme chane de caractres o vous voulez utilisez le symbole
pourcent, cette opration nest pas ncessaire. Par exemple :
>>> nbG = 4500

>>> nbC = 2575
>>> percGC = propGC * 100
>>> print "Ce gnome contient %i G et %i C, soit un %%GC de %.2f" \
... % (nbG,nbC,percGC) ,"%"
Ce gnome contient 4500 G et 2575 C, soit un %GC de 47.80 %
2. Le signe \ en fin de ligne permet de poursuivre la commande sur la ligne suivante. Cette
syntaxe est pratique lorsque vous voulez taper une commande longue.
Enfin, il est possible de prciser sur combien de caractres vous voulez quun rsultat soit
crit. Dans la portion de code suivant, le caractre ; sert de sparateur entre les instructions sur
une mme ligne :
>>> print 10 ; print 100 ; print 1000

10
100
1000
>>> print "%4i" % 10 ; print "%4i" % 100 ; print "%4i" % 1000
10
100
1000
>>>
Ceci est galement possible sur les chanes de caractres (avec %s, s comme string) :

3 criture 3.2 Exercices
>>> print "atom HN" ; print "atom HDE1"

atom HN
atom HDE1
>>> print "atom %4s" % "HN" ; print "atom %4s" % "HDE1"
atom HN
atom HDE1
Vous voyez tout de suite lnorme avantage de lcriture formate. Cela permet dcrire en
colonnes parfaitement alignes. Nous verrons que ceci est trs pratique si lon veut crire les
coordonnes des atomes dune molcule au format PDB.
Alternative :
Il existe une autre faon dcrire du texte format : la mthode format().
>>> x = 32
>>> nom = 'John'
>>> print "{0} a {1} ans".format(nom,x)
John a 32 ans
>>> nbG = 4500

>>> nbC = 2575
>>> propGC = (4500.0 + 2575)/14800
>>> print "On a {0} G et {1} C -> prop GC = {2:.2f}".format(nbG,nbC,propGC)
On a 4500 G et 2575 C -> prop GC = 0.48
La syntaxe est lgrement diffrente :
1. .format(nom,x) est utilis pour indiquer les variables (nom et x) afficher ;
2. {0} et {1} dsigne lendroit o seront places les variables. Les chiffres indiquent la
position de la variable dans format (0=nom et 1=x) ;
3. Pour le 2me exemple, on prcise la position de la variable (2) et le formatage voulu,
ici .2f soit deux chiffres aprs la virgule pour un rel. Notez quun : est ajout pour
signifier lajout de rgles de formatage.
Cette mthode vous est prsente titre dinformation car elle deviendra standard dans la
version Python 3.
3.2 Exercices
Conseil : utilisez linterprteur Python pour les exercices 2 5.
1. Ouvrez linterprteur Python et tapez 1+1. Que se passe-t-il ? crivez la mme chose dans
un script test.py. Excutez ce script en tapant python test.py dans un shell. Que se
passe-t-il ? Pourquoi ?
2. Calculez le pourcentage de GC avec le code
percGC = ((4500 + 2575)/14800)*100
puis affichez le rsultat. Que se passe-t-il ? Comment expliquez-vous ce rsultat ? Corrigez
linstruction prcdente pour calculer correctement le pourcentage de GC. Affichez cette
valeur avec deux dcimales de prcision.
3. Gnrez une chane de caractres reprsentant un oligonuclotide polyA (AAAA...) de 20
bases de longueurs, sans taper littralement toutes les bases.
4. Suivant le modle du dessus, gnrez en une ligne de code un polyA de 20 bases suivi
dun polyGC rgulier (GCGCGC...) de 40 bases.
5. En utilisant lcriture formate, affichez en une seule ligne les variables a, b et c dont les
valeurs sont respectivement "salut", 102 et 10.318.

4 Listes
4 Listes
4.1 Dfinition
Une liste est une structure de donnes qui contient une srie de valeurs. Python autorise
la construction de liste contenant des valeurs de type diffrent (par exemple entier et chane
de caractres), ce qui leur confre une grande flexibilit. Une liste est dclare par une srie de
valeurs (ne pas oublier les guillemets, simples ou doubles, sil sagit de chanes de caractres)
spares par des virgules, et le tout encadr par des crochets. En voici quelques exemples :
>>> animaux = ['girafe','tigre','singe','souris']

>>> tailles = [5, 2.5, 1.75, 0.15]
>>> mixte = ['girafe', 5, 'souris', 0.15]
>>> animaux
['girafe', 'tigre', 'singe', 'souris']
>>> tailles
[5, 2.5, 1.75, 0.15]
>>> mixte
['girafe', 5, 'souris', 0.15]
Lorsque lon affiche une liste, Python la restitue telle quelle a t saisie.
4.2 Utilisation
Un des gros avantages dune liste est que vous pouvez appeler ses lments par leur posi-
tion. Ce numro est appel indice (ou index) de la liste.
liste : ['girafe', 'tigre', 'singe', 'souris']

indice : 0 1 2 3
Soyez trs attentifs au fait que les indices dune liste de n lments commence 0 et se
termine n-1. Voyez lexemple suivant :

>>> animaux[0]
'girafe'
>>> animaux[1]
'tigre'
>>> animaux[3]
'souris'
Par consquent, si on appelle llment dindice 4 de notre liste, Python renverra un message
derreur :
>>> animaux[4]
Traceback (innermost last):
IndexError: list index out of range
Noubliez pas ceci ou vous risqueriez dobtenir des bugs inattendus !
4.3 Opration sur les listes

Tout comme les chanes de caractres, les listes supportent loprateur + de concatnation,
ainsi que loprateur * pour la duplication :

4 Listes 4.4 Indiage ngatif et tranches
>>> ani1 = ['girafe','tigre']

>>> ani2 = ['singe','souris']
>>> ani1 + ani2
>>> ani1 * 3
['girafe', 'tigre', 'girafe', 'tigre', 'girafe', 'tigre']
4.4 Indiage ngatif et tranches

La liste peut galement tre indexe avec des nombres ngatifs selon le modle suivant :
liste : ['girafe', 'tigre', 'singe', 'souris']

indice positif : 0 1 2 3
indice ngatif : -4 -3 -2 -1
ou encore :
liste : ['A','C','D','E','F','G','H','I','K','L']
indice positif : 0 1 2 3 4 5 6 7 8 9
indice negatif : -10 -9 -8 -7 -6 -5 -4 -3 - 2 -1
Les indices ngatifs reviennent compter partir de la fin. Leur principal avantage est
que vous pouvez appeler le dernier lment dune liste laide de lindice -1 sans pour autant
connatre la longueur de la liste.

>>> animaux[-4]
'girafe'
>>> animaux[-2]
'singe'
>>> animaux[-1]
'souris'
Un autre avantage des listes est la possibilit de slectionner une partie en utilisant un
indiage construit sur le modle [m:n+1] pour rcuprer tous les lments, du mime au
nime (de llment m inclus llment n+1 exclus). On dit alors quon rcupre une tranche
de la liste, par exemple :
>>> animaux = ['girafe', 'tigre', 'singe', 'souris']

>>> animaux[0:2]
['girafe', 'tigre']
>>> animaux[0:3]
['girafe', 'tigre', 'singe']
>>> animaux[0:]
>>> animaux[:]
>>> animaux[1:]
['tigre', 'singe', 'souris']
>>> animaux[1:-1]
['tigre', 'singe']
Remarquez que lorsquaucun indice nest indiqu gauche ou droite du symbole : ,

Python prend par dfaut tous les lments depuis le dbut ou tous les lments jusqu la fin
respectivement.

4.5 Fonctions range et len 4 Listes
Dans les versions rcentes de Python, on peut aussi prciser le pas en ajoutant un : suppl-
mentaire et en indiquant le pas par un entier.

>>> animaux[0:3:2]
['girafe', 'singe']
>>> x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x[::1]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x[::2]
[0, 2, 4, 6, 8]
>>> x[::3]
[0, 3, 6, 9]
>>> x[1:6:3]
[1, 4]
Finalement, on voit que laccs au contenu dune liste avec des crochets fonctionne sur le
modle liste[dbut:fin:pas].
4.5 Fonctions range et len

Linstruction range() vous permet de crer des listes dentiers (et dentiers uniquement)
de manire simple et rapide. Voyez plutt :
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(0,5)
[0, 1, 2, 3, 4]
>>> range(15,20)
[15, 16, 17, 18, 19]
>>> range(0,1000,200)
[0, 200, 400, 600, 800]
>>> range(2,-2,-1)
[2, 1, 0, -1]
Linstruction range() fonctionne sur le modle range([dbut,] fin[, pas]). Les

arguments entre crochets sont optionnels.
Linstruction len() vous permet de connatre la longueur dune liste, ce qui parfois est bien
pratique lorsquon lit un fichier par exemple, et que lon ne connat pas a priori la longueur des
lignes. Voici un exemple dutilisation :

>>> len(animaux)
4
>>> len(range(10))
10
4.6 Listes de listes

Pour finir, sachez quil est tout--fait possible de construire des listes de listes. Cette fonc-
tionnalit peut tre parfois trs pratique. Par exemple :

4 Listes 4.7 Exercices
>>> enclos1 = ['girafe', 4]

>>> enclos2 = ['tigre', 2]
>>> enclos3 = ['singe', 5]
>>> zoo = [enclos1, enclos2, enclos3]
>>> zoo
[['girafe', 4], ['tigre', 2], ['singe', 5]]
Dans cet exemple, chaque sous-liste contient une catgorie danimal et le nombre danimaux
pour chaque catgorie. Pour accder un lment de la sous-liste, on utilise un double indiage.
>>> zoo[1]
['tigre', 2]
>>> zoo[1][0]
'tigre'
>>> zoo[1][1]
2
On verra un peu plus loin quil existe en Python les dictionnaires qui sont trs pratiques
pour faire ce genre de choses. On verra aussi quil existe un module nomm numpy permet-
tant de grer des listes ou tableaux de nombres (vecteurs et matrices), ainsi que de faire des
oprations dessus.
4.7 Exercices
Conseil : utilisez linterprteur Python.
1. Constituez une liste semaine contenant les 7 jours de la semaine. partir de cette liste,
comment rcuprez-vous seulement les 5 premiers jours de la semaine dune part, et ceux
du week-end dautre part (utilisez pour cela lindiage) ? Cherchez un autre moyen pour
arriver au mme rsultat (en utilisant un autre indiage).
2. Trouvez deux manires pour accder au dernier jour de la semaine.
3. Inversez les jours de la semaine en une commande.
4. Crez 4 listes hiver, printemps, ete et automne contenant les mois correspondant
ces saisons. Crez ensuite une liste saisons contenant les sous-listes hiver, printemps,ete
et automne. Prvoyez ce que valent les variables suivantes, puis vrifiez-le dans linter-
prteur :
saisons[2]
saisons[1][0]
saisons[1:2]
saisons[:][1]
Comment expliquez-vous ce dernier rsultat ?
5. Affichez la table des 9 en une seule commande avec linstruction range().
6. Avec Python, rpondez la question suivante en une seule commande. Combien y a-t-il
de nombres pairs dans lintervalle [2 , 10000] inclus ?

5 Boucles et comparaisons
5 Boucles et comparaisons
5.1 Boucles for
Imaginez que vous ayez une liste de quatre lments dont vous voulez afficher les lments
les uns aprs les autres. Dans ltat actuel de vos connaissances, il faudrait taper quelque chose
du style :
animaux = ['girafe','tigre','singe','souris']
print animaux[0]
print animaux[1]
print animaux[2]
print animaux[3]
Si votre liste ne contient que quatre lments, ceci est encore faisable mais imaginez quelle
en contienne 100 voire 1000 ! Pour remdier cela, il faut utiliser les boucles. Regardez lexemple
suivant :

>>> for animal in animaux:
... print animal
...
girafe
tigre
singe
souris
En fait, la variable animal va prendre successivement les diffrentes valeurs de la liste

animaux chaque itration de la boucle. Notez bien les types de variable : animaux est une
liste sur laquelle on itre, et animal est une chane de caractre qui chaque itration de la
boucle prendra les valeurs successives de la liste animaux (car les lments de la liste sont des
chanes de caractre, mais on verra plus loin que cela est valable pour nimporte quel type de
variable).
Dores et dj, remarquez avec attention lindentation. Vous voyez que linstruction print animal
est dcale par rapport linstruction for animal in animaux:. Outre une meilleure li-
sibilit, ceci est formellement requis en Python. Toutes les instructions que lon veut rpter
constituent le corps de la boucle (ou un bloc dinstructions) et doivent tre indentes dun(e)
ou plusieurs espace(s) ou tabulation(s). Dans le cas contraire, Python vous renvoie un message
derreur :

... print animal
File "<stdin>", line 2
print animal
^
IndentationError: expected an indented block
Notez galement que si le corps de votre boucle contient plusieurs instructions, celles-ci
doivent tre indentes de la mme manire (e.g. si vous avez indent la premire instruction
avec deux espaces, vous devez faire de mme avec la deuxime instruction, etc).
Remarquez galement un autre aspect de la syntaxe, une instruction for doit absolument
se terminer par le signe deux-points:.
Il est aussi possible dutiliser une tranche dune liste :

5 Boucles et comparaisons 5.1 Boucles for

>>> for animal in animaux[1:3]:
... print animal
...
tigre
singe
On a vu que les boucles for pouvaient utiliser une liste contenant des chanes de carac-
tres, mais elles peuvent tout aussi bien utiliser des listes numriques. En utilisant linstruction
range on peut facilement accder une liste dentiers.
>>> for i in range(4):

... print i
...
0
1
2
3
Notez ici que nous avons choisi le nom i pour la variable ditration. Ceci est un stan-
dard en informatique et indique en gnral quil sagit dun entier (le nom i vient sans doute
du mot indice). Nous vous conseillons de toujours suivre cette convention afin dviter les
confusions, si vous itrez sur les indices vous pouvez appeler la variable i (par exemple dans
for i in range(4):), si vous itrez sur une liste comportant des chanes de caractres, met-
tez un nom explicite pour la variable ditration (par exemple for prenom in ['Joe','Bill']:).
Revenons notre liste animaux. Nous allons maintenant parcourir cette liste, mais cette
fois par une itration sur ses indices :
... print animaux[i]
...
girafe
tigre
singe
souris
La variable i prendra les valeurs successives 0, 1, 2 et 3 et on accdera chaque lment de
la liste animaux par son indice (i.e. animaux[i])
Sur ces diffrentes mthodes de parcours de liste, quelle est la la plus efficace ? La mthode
utiliser pour parcourir avec une boucle for les lments dune liste est celle qui ralise les
itrations directement sur les lements.

... print animal
...
girafe
tigre
singe
souris
Si vous avez besoin de parcourir votre liste par ses indices, prfrez la fonction xrange()
qui sutilise de la mme manire que range() mais qui ne construit pas de liste et qui est donc

5.2 Comparaisons 5 Boucles et comparaisons
beaucoup plus rapide. La fonction range() ne sera donc employe que pour crer des listes
dentiers.

>>> for i in xrange(4):
... print animaux[i]
...
girafe
tigre
singe
souris
Enfin, si vous avez besoin de lindice dun lment dune liste et de llment lui-mme, la
fonction enumerate() est pratique.

>>> for i, ani in enumerate(animaux):
... print i, ani
...
0 girafe
1 tigre
2 singe
3 souris
5.2 Comparaisons
Avant de passer une autre sorte de boucles (les boucles while), nous abordons tout de
suite les comparaisons. Celles-ci seront reprises dans le chapitre des tests. Python est capable
deffectuer toute une srie de comparaisons entre le contenu de diffrentes variables, telles que :
syntaxe Python signification
== gal
!= diffrent de
> suprieur
>= suprieur ou gal
< infrieur
<= infrieur ou gal
Observez lexemple suivant sur des nombres entiers.
>>> x = 5
>>> x == 5
True
>>> x > 10
False
>>> x < 10
True
Python renvoie la valeur True si la comparaison est vraie et False si elle est fausse. True
et False sont des boolens.
Faites bien attention ne pas confondre loprateur daffectation = qui donne une valeur
une variable et loprateur de comparaison == qui compare les valeurs de deux variables.
Vous pouvez galement effectuer des comparaisons sur des chanes de caractres.

5 Boucles et comparaisons 5.3 Boucles while
>>> animal = "tigre"

>>> animal == "tig"
False
>>> animal != "tig"
True
>>> animal == 'tigre'
True
Dans le cas des chanes de caractres, a priori seuls les tests == et != ont un sens. En fait,
on peut aussi utiliser les oprateurs <, >, <= et >=. Dans ce cas lordre alphabtique est pris en
compte, par exemple :
>>> "a" < "b"
True
"a" est infrieur "b" car il est situ avant dans lordre alphabtique. En fait, cest lordre ASCII
des caractres qui est pris en compte (i.e. chaque caractre est affect un code numrique), on
peut donc comparer aussi des caractres spciaux (comme # ou ~) entre eux. On peut aussi
comparer des chanes plus dun caractre.
>>> "ali" < "alo"
True
>>> "abb" < "ada"
True
Dans ce cas, Python compare caractre par caractre de la gauche vers la droite (le premier
avec le premier, le deuxime avec le deuxime, etc). Ds quun caractre est diffrent entre
lune et lautre des chanes, il considre que la chane la plus petite est celle qui prsente le
caractre ayant le plus petit code ASCII (les caractres suivants de la chane sont ignors dans
la comparaison), comme dans notre test "abb" < "ada" ci-dessus.
5.3 Boucles while

Une autre alternative linstruction for couramment utilise en informatique est la boucle
while. Le principe est simple. Une srie dinstructions est excute tant quune condition est
vraie. Par exemple :
>>> i = 1
>>> while i <= 4:
... print i
... i = i + 1
...
1
2
3
4
Remarquez quil est encore une fois ncessaire dindenter le bloc dinstructions. Une boucle
while ncessite trois lments pour fonctionner correctement :
1. linitialisation de la variable de test avant la boucle ;
2. le test de la variable associ linstruction while ;
3. lincrmentation de la variable de test dans le corps de la boucle.
Faites bien attention aux tests et lincrmentation que vous utilisez car une erreur mne
souvent des boucles infinies qui ne sarrtent pas. Vous pouvez nanmoins toujours stopper
lexcution dun script Python laide de la combinaison de touches Ctrl-C.

5.4 Exercices 5 Boucles et comparaisons
5.4 Exercices
Conseil : pour ces exercices, crivez des scripts dans des fichiers, puis excutez-les dans un
shell.
1. Soit la liste ['vache','souris','levure','bacterie']. Affichez lensemble des

lments de cette liste (un lment par ligne) de trois manires diffrentes (deux avec for
et une avec while).
2. Constituez une liste semaine contenant les 7 jours de la semaine. crivez une srie dins-
tructions affichant les jours de la semaine (en utiliser une boucle for), ainsi quune autre
srie dinstructions affichant les jours du week-end (en utilisant une boucle while).
3. Avec une boucle, affichez les nombres de 1 10 sur une seule ligne.
4. Soit impairs la liste de nombres [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21].
crivez un programme qui, partir de la liste impairs, construit une liste pairs dans
laquelle tous les lments de impairs sont incrments de 1.
5. Voici les notes dun tudiant [14, 9, 6, 8, 12]. Calculez la moyenne de ces notes.
Utilisez lcriture formate pour afficher la valeur de la moyenne avec deux dcimales.
6. Soit la liste X contenant les nombres entiers de 0 10. Calculez le produit des nombres
conscutifs deux deux de X en utilisant une boucle. Exemple pour les premires itra-
tions :
0
2
6
12
7. Triangle. crivez un script qui dessine un triangle comme celui-ci :
*
**
***
****
*****
******
*******
********
*********
**********
8. Triangle invers. crivez un script qui dessine un triangle comme celui-ci :
**********
*********
********
*******
******
*****
****
***
**
*
9. Triangle gauche. crivez un script qui dessine un triangle comme celui-ci :

5 Boucles et comparaisons 5.4 Exercices
*
**
***
****
*****
******
*******
********
*********
**********

5.4 Exercices 5 Boucles et comparaisons
10. Triangle isocle. crivez un script qui dessine un triangle comme celui-ci :
*
***
*****
*******
*********
***********
*************
***************
*****************
*******************
11. Exercice +++. Suite de Fibonacci. La suite de Fibonacci est une suite mathmatique qui
porte le nom de Leonardo Fibonacci, un mathmaticien italien du XIIIe sicle. Initiale-
ment, cette suite a t utilise pour dcrire la croissance dune population de lapins mais
elle est peut galement tre utilise pour dcrire certains motifs gomtriques retrouvs
dans la nature (coquillages, fleurs de tournesol...).
Par dfinition, les deux premiers termes de la suite de Fibonacci sont 0 et 1. Ensuite, le
terme au rang n est la somme des nombres aux rangs n - 1 et n - 2. Par exemple, les 10
premiers termes de la suite de Fibonacci sont 0, 1, 1, 2, 3, 5, 8, 13, 21, 34.
crivez un script qui construit la liste des 20 premiers termes de la suite de Fibonacci puis
laffiche.

6 Tests
6 Tests
6.1 Dfinition
Les tests sont un lment essentiel tout langage informatique si on veut lui donner un peu
de complexit car ils permettent lordinateur de prendre des dcisions si telle ou telle condi-
tion est vraie ou fausse. Pour cela, Python utilise linstruction if ainsi quune comparaison que
nous avons aborde au chapitre prcdent. En voici un exemple :
>>> x = 2
>>> if x == 2:
... print "Le test est vrai !"
...
Le test est vrai !
>>> x = "souris"
>>> if x == "tigre":
...
Plusieurs remarques concernant ces deux exemples :

Dans le premier exemple, le test tant vrai, linstruction print "Le test est vrai !"
est excute. Dans le second exemple, le test est faux et rien nest affich.
Les blocs dinstruction dans les tests doivent forcment tre indents comme les boucles
for et while. Lindentation indique la porte des instructions excuter si le test est
vrai.
Linstruction if se termine comme les instructions for et while par le caractre :.
6.2 Tests plusieurs cas

Parfois, il est pratique de tester si la condition est vraie ou si elle est fausse dans une mme
instruction if. Plutt que dutiliser deux instructions if, on peut se servir de if et de else :
>>> x = 2
>>> if x == 2:
... else:
... print "Le test est faux !"
...
Le test est vrai !
>>> x = 3
>>> if x == 2:
... else:
... print "Le test est faux !"
...
Le test est faux !
On peut utiliser une srie de tests dans la mme instruction if, notamment pour tester
plusieurs valeurs dune mme variable. Par exemple, on se propose de tirer au sort une base
dADN puis dafficher le nom de cette dernire. Dans le code suivant, nous utilisons lintruction
random.choice(liste) qui renvoie un lment choisi au hasard dans une liste. Linstruc-
tion import random sera vue plus tard, admettez pour le moment quelle est ncessaire.
>>> import random

6.3 Tests multiples 6 Tests
>>> base = random.choice(["a", "t", "c", "g"])

>>> if base == "a":
... print "choix d'une adnine"
... elif base == "t":
... print "choix d'une thymine"
... elif base == "c":
... print "choix d'une cytosine"
... elif base == "g":
... print "choix d'une guanine"
...
choix d'une cytosine
Dans cet exemple, Python teste la premire condition, puis, si et seulement si elle est fausse,
teste la deuxime et ainsi de suite... Le code correspondant la premire condition vrifie est
excut puis Python sort du if.
Remarque De nouveau, faites bien attention lindentation dans ces deux derniers exemples !
Vous devez tre trs rigoureux ce niveau l. Pour vous en convaincre, excutez ces deux
scripts dans linterprteur Python :
Script 1 :
nombres = [4, 5, 6]
for nb in nombres:
if nb == 5:
print "Le test est vrai"
print "car la variable nb vaut", nb
Script 2 :
nombres = [4, 5, 6]
for nb in nombres:
if nb == 5:
print "Le test est vrai"
print "car la variable nb vaut", nb
Comment expliquez-vous ce rsultat ?
6.3 Tests multiples

Les tests multiples permettent de tester plusieurs conditions en mme temps en utilisant
des oprateurs boolens. Les deux oprateurs les plus couramment utiliss sont le OU et le ET.
Voici un petit rappel du mode de fonctionnement de ces oprateurs :
Condition 1 Oprateur Condition 2 Rsultat
Vrai OU Vrai Vrai

Vrai OU Faux Vrai
Faux OU Vrai Vrai
Faux OU Faux Faux
Vrai ET Vrai Vrai

Vrai ET Faux Faux
Faux ET Vrai Faux
Faux ET Faux Faux
En Python, on utilise le mot rserv and pour loprateur ET et le mot rserv or pour
loprateur OU. Respectez bien la casse, and et or scrivent en minuscule. En voici un exemple
dutilisation :

6 Tests 6.4 Instructions break et continue
>>> x = 2
>>> y = 2
>>> if x == 2 and y == 2:
... print "le test est vrai"
...
le test est vrai
Notez que le mme rsulat serait obtenu en utilisant deux instructions if imbriques :
>>> x = 2
>>> y = 2
>>> if x == 2:
... if y == 2:
... print "le test est vrai"
...
le test est vrai
Vous pouvez aussi tester directement leffet de ces oprateurs laide de True et False
(attention respecter la casse).
>>> True or False

True
Enfin, on peut utiliser loprateur logique de ngation not qui inverse le rsultat dune
condition :
>>> not True

False
>>> not False
True
>>> not (True and True)
False
6.4 Instructions break et continue

Ces deux instructions permet de modifier le comportement dune boucle (for ou while)
avec un test.
Linstruction break stoppe la boucle.
... if i > 2:
... break
... print i
...
0
1
2
Linstruction continue saute litration suivante.
... if i == 2:
... continue
... print i

6.5 Exercices 6 Tests
...
0
1
3
4
6.5 Exercices
shell.
1. Constituez une liste semaine contenant les sept jours de la semaine. En utilisant une
boucle, crivez chaque jour de la semaine ainsi que les messages suivants :
Au travail sil sagit du lundi au jeudi
Chouette c'est vendredi sil sagit du vendredi
Repos ce week-end sil sagit du week-end.
(Les messages ne sont que des suggestions, vous pouvez laisser aller votre imagination.)
2. La liste ci-dessous reprsente une squence dADN :
["A","C","G","T","T","A","G","C","T","A","A","C","G"]
crivez un script qui transforme cette squence en sa squence complmentaire. Rappel :
la squence complmentaire sobtient en remplaant A par T, T par A, C par G et G par C.
3. La fonction min() de Python, renvoie llment le plus petit dune liste. Sans utiliser cette
fonction, crivez un script qui dtermine le plus petit lment de la liste [8, 4, 6, 1, 5].
4. La liste ci-dessous reprsente une squence dacides amins
["A","R","A","W","W","A","W","A","R","W","W","R","A","G","A","R"]
Calculez la frquence en alanine (A), arginine (R), tryptophane (W) et glycine (G) dans
cette squence.
5. Voici les notes dun tudiant [14, 9, 13, 15, 12]. crivez un script qui affiche la
note maximum (fonction max()), la note minimum (fonction min()) et qui calcule la
moyenne. Affichez la valeur de la moyenne avec deux dcimales. Affichez aussi la men-
tion obtenue sachant que la mention est passable si la moyenne est entre 10 inclus et 12
exclus, assez-bien entre 12 inclus et 14 exclus et bien au-del de 14.
6. Faites une boucle qui parcourt les nombres de 0 20 et qui affiche les nombres pairs
infrieurs ou gaux 10 dune part, et les nombres impairs strictement suprieur 10
dautre part. Pour cet exercice, vous pourrez utiliser loprateur modulo % qui retourne le
reste de la division entire entre deux nombres.
7. Exercice +++. Conjecture de Syracuse.
La conjecture de Syracuse est une conjecture mathmatique qui reste improuve ce jour
et qui est dfinie de la manire suivante.
Soit un entier positif n. Si n est pair, alors le diviser par 2. Si il est impair, alors le multiplier
par 3 et lui ajouter 1. En rptant cette procdure, la suite de nombres atteint la valeur 1
puis se prolonge indfiniment par une suite de trois valeurs triviales appele cycle trivial.
Jusqu prsent, la conjecture de Syracuse, selon laquelle depuis nimporte quel entier
positif la suite de Syracuse atteint 1, na pas t mise en dfaut.
Par exemple, les premiers lments de la suite de Syracuse pour un entier de dpart de
10 sont : 10, 5, 16, 8, 4, 2, 1...
crivez un script qui, partant dun entier positif n, cre une liste des nombres de la suite de
Syracuse. Avec diffrents points de dpart (n), la conjecture de Syracuse est-elle toujours
vrifie ? Quels sont les nombres qui constituent le cycle trivial ?

6 Tests 6.5 Exercices
Remarque 1 : pour cet exercice, vous avez besoin de faire un nombre ditrations inconnu
pour que la suite de Syracuse atteigne 1 puis entame son cycle trivial. Vous pourrez tester
votre algorithme avec un nombre arbitraire ditrations, typiquement 20 ou 100, suivant
votre nombre n de dpart.
Remarque 2 : un nombre est pair lorsque le reste de sa division entire (oprateur modulo
%) par 2 est nul.
8. Exercice +++. Attribution simple de structure secondaire.
Les angles didres phi/psi dune hlice alpha parfaite ont une valeur de -57 degrs et
-47 degrs respectivement. Bien sr, il est trs rare que lon trouve ces valeurs parfaites
dans une protine, par consquent il est couramment accept de tolrer une dviation de
+/- 30 degrs sur celles-ci. Ci-dessous vous avez une liste de listes contenant les valeurs
de phi/psi de la premire hlice de la protine 1TFE. laide de cette liste, crivez un
programme qui teste, pour chacun des rsidus, sils sont ou non en hlice.
[[48.6,53.4],[-124.9,156.7],[-66.2,-30.8],[-58.8,-43.1], \
[-73.9,-40.6],[-53.7,-37.5],[-80.6,-16.0],[-68.5,135.0], \
[-64.9,-23.5],[-66.9,-45.5],[-69.6,-41.0],[-62.7,-37.5], \
[-68.2,-38.3],[-61.2,-49.1],[-59.7,-41.1],[-63.2,-48.5], \
[-65.5,-38.5],[-64.1,-40.7],[-63.6,-40.8],[-66.4,-44.5], \
[-56.0,-52.5],[-55.4,-44.6],[-58.6,-44.0],[-77.5,-39.1], \
[-91.7,-11.9],[48.6,53.4]]
9. Exercice +++. Dtermination des nombres premiers infrieurs 100.
Voici un extrait de larticle sur les nombres premiers tir de lencyclopdie en ligne wiki-
pdia.
Un nombre premier est un entier naturel qui admet exactement deux diviseurs distincts entiers
et positifs (qui sont alors 1 et lui-mme). Cette dfinition exclut 1, qui na quun seul diviseur
entier positif. Par opposition, un nombre non nul produit de deux nombres entiers diffrents de 1
est dit compos. Par exemple 6 = 2 3 est compos, tout comme 21 = 3 7, mais 11 est premier
car 1 et 11 sont les seuls diviseurs de 11. Les nombres 0 et 1 ne sont ni premiers ni composs.
Dterminez les nombres premiers infrieurs 100. Combien y a-t-il de nombres premiers
entre 0 et 100 ? Pour vous aider, nous vous proposons deux mthodes.
Mthode 1 (peu optimale mais assez intuitive)

Pour chaque nombre de 2 100, calculez le reste de la division entire (avec loprateur
modulo %) depuis 1 jusqu lui-mme. Si cest un nombre premier, il aura exactement
deux nombres pour lesquels le reste de la division entire est gal 0 (1 et lui-mme). Si
ce nest pas un nombre premier, il aura plus de deux nombres pour lesquels le reste de la
division entire est gal 0.
Mthode 2 (plus optimale et plus rapide, mais un peu plus complique)

Vous pouvez parcourir tous les nombres de 2 100 et vrifier si ceux-ci sont composs,
cest--dire quils sont le produit de deux nombres premiers. Pratiquement, cela consiste
vrifier que le reste de la division entire (oprateur modulo %) entre le nombre considr
et nimporte quel nombre premier est nul. Le cas chant, ce nombre nest pas premier.

7 Fichiers
7 Fichiers
7.1 Lecture dans un fichier
Dans la plupart des travaux de programmation, on doit lire ou crire dans un fichier. Python
possde pour cela tout un tas doutils qui vous simplifient la vie. Avant de passer un exemple
concret, crez un fichier dans un diteur de texte que vous enregistrerez dans votre rpertoire
avec le nom zoo.txt, par exemple :
girafe
tigre
singe
souris
Ensuite, testez cet exemple :
>>> filin = open('zoo.txt', 'r')
>>> filin
<open file 'zoo.txt', mode 'r' at 0x7f8ea16efc00>
>>> filin.readlines()
['girafe\n', 'tigre\n', 'singe\n', 'souris\n']
>>> filin.close()
>>> filin
<closed file 'zoo.txt', mode 'r' at 0x7f8ea16efc00>
La premire commande ouvre le fichier zoo.txt en lecture seule (ceci est indiqu avec
la lettre r). Remarquez que le fichier nest pas encore lu, mais simplement ouvert (un peu
comme lorsquon ouvre un livre, mais quon ne la pas encore lu). Lorsquon affiche la valeur
de la variable filin, vous voyez que Python la considre comme un objet de type fichier
<open file 'zoo.txt', mode 'r' at 0x7f8ea16efc00>
Et oui, Python est un langage orient objet. Retenez seulement que lon peut considrer
chaque variable comme un objet sur lequel on peut appliquer des mthodes.
propos de mthode, on applique la mthode readlines() sur lobjet filin dans
linstruction suivante (remarquez la syntaxe du type objet.mthode). Ceci nous retourne
une liste contenant toutes les lignes du fichier (dans notre analogie avec un livre, ceci corres-
pondrait lire les lignes du livre).
Enfin, on applique la mthode close() sur lobjet filin, ce qui vous vous en doutez,
va fermer le fichier (ceci correspondrait bien sr fermer le livre). On pourra remarquer que
ltat de lobjet a chang
<closed file 'zoo.txt', mode 'r' at 0x7f8ea16efc00>
Vous navez bien-sr pas retenir ces concepts dobjets pour pouvoir programmer avec
Python, nous avons juste ouvert cette parenthse pour attirer votre attention sur la syntaxe.
Remarque : nutilisez jamais le mot file comme nom de variable pour un fichier car file
est un mot rserv de Python.
Voici maintenant un exemple complet de lecture dun fichier avec Python.

>>> lignes = filin.readlines()
>>> lignes
['girafe\n', 'tigre\n', 'singe\n', 'souris\n']
>>> for ligne in lignes:
... print ligne
...

7 Fichiers 7.1 Lecture dans un fichier
girafe
tigre
singe
souris
>>> filin.close()
Vous voyez quen cinq lignes de code, vous avez lu et parcouru le fichier.
Remarques :
Notez que la liste lignes contient le caractre \n la fin de chacun de ses lments.
Ceci correspond au saut la ligne de chacune dentre elles (ceci est cod par un caractre
spcial que lon symbolise par \n). Vous pourrez parfois rencontrer galement la notation
octale \012.
Remarquez aussi que lorsque lon affiche les diffrentes lignes du fichier laide de la
boucle for et de linstruction print, Python saute chaque fois une ligne.
Mthode read()
Il existe dautres mthodes que readlines() pour lire (et manipuler) un fichier. Par exemple,
la mthode read() lit tout le contenu dun fichier et renvoie une chane de caractres unique.

>>> filin.read()
'girafe\ntigre\nsinge\nsouris\n'
>>> filin.close()
Mthode readline()
La mthode readline() (sans s) lit une ligne dun fichier et la renvoie sous forme dune
chane de caractres. chaque nouvel appel de readline(), la ligne suivante est renvoye.
Associe la boucle while, cette mthode permet de lire un fichier ligne par ligne.

>>> ligne = filin.readline()
>>> while ligne != "":
... print ligne
... ligne = filin.readline()
...
girafe
tigre
singe
souris
>>> filin.close()

7.2 criture dans un fichier 7 Fichiers
Mthodes seek() et tell()

Les mthodes seek() et tell() permettent respectivement de se dplacer au nime carac-
tre (plus exactement au nime octet) dun fichier et dafficher o en est la lecture du fichier,
cest--dire quel caractre (ou octet) est en train dtre lu.

>>> filin.readline()
'girafe\n'
>>> filin.tell()
7
>>> filin.seek(0)
>>> filin.tell()
0
>>> filin.readline()
'girafe\n'
>>> filin.close()
On remarque qu louverture dun fichier, le tout premier caractre est considr comme le
caractre 0 (tout comme le premier lment dune liste). La mthode seek() permet facilement
de remonter au dbut du fichier lorsque lon est arriv la fin ou lorsquon en a lu une partie.
Itrations directement sur le fichier

Python essaie de vous faciliter la vie au maximum. Voici un moyen la fois simple et lgant
de parcourir un fichier.

>>> for ligne in filin:
... print ligne
...
girafe
tigre
singe
souris
>>> filin.close()
La boucle for va demander Python daller lire le fichier ligne par ligne. Privilgiez cette
mthode par la suite.
7.2 criture dans un fichier

crire dans un fichier est aussi simple que de le lire. Voyez lexemple suivant :
>>> animaux2 = ['poisson', 'abeille', 'chat']
>>> filout = open('zoo2.txt', 'w')
>>> for animal in animaux2:
... filout.write(animal)
...
>>> filout.close()

7 Fichiers 7.3 Mthode optimise douverture et de fermeture de fichier
Le contenu du fichier zoo2.txt est poissonabeillechat.

Quelques commentaires sur cet exemple :
Aprs avoir initialis la liste animaux2, nous avons ouvert un fichier mais cette fois-ci en
mode criture (avec le caractre w).
Ensuite, on a balay cette liste laide dune boucle. chaque itration, nous avons crit
chaque lment de la liste dans le fichier. Remarquez nouveau la mthode write() qui
sapplique sur lobjet filout.
Enfin, on a ferm le fichier avec la mthode close().
Vous voyez quil est extrmement simple en Python de lire ou dcrire dans un fichier.
Remarque. Si votre programme produit uniquement du texte, vous pouvez lcrire sur la
sortie standard (avec linstruction print). Lavantage est que dans ce cas lutilisateur peut
bnficier de toute les potentialits dUnix (redirection, tri, parsing...). Sil veut crire le rsultat
du programme dans un fichier, il pourra toujours le faire en redirigeant la sortie.
7.3 Mthode optimise douverture et de fermeture de fichier

Depuis la version 2.5, Python introduit le mot-cl with qui permet douvrir et fermer un
fichier de manire commode. Si pour une raison ou une autre louverture conduit une er-
reur (problme de droits, etc), lutilisation de with garantit la bonne fermeture du fichier (ce
qui nest pas le cas avec lutilisation de la mthode open() invoque telle quelle). Voici un
exemple :
>>> with open('zoo.txt', 'r') as filin:

... for ligne in filin:
... print ligne
...
girafe
tigre
singe
souris
>>>
Vous remarquez que with introduit un bloc dindentation. Cest lintrieur de ce bloc que
nous effectuons toutes les oprations sur le fichier. Une fois sorti, Python fermera automatique-
ment le fichier. Vous navez donc plus besoin dinvoquer la fonction close().
Pour ceux qui veulent appronfondir, la commande with est plus gnrale et utilisable dans
dautres contextes (mthode compacte pour grer les exceptions).
7.4 Exercices
Conseil : pour les exercices 1 et 2, utilisez linterprteur Python. Pour les exercices suivants,
crivez des scripts dans des fichiers, puis excutez-les dans un shell.
1. Dans lexemple 'girafe', 'tigre', etc, ci-dessus, comment expliquer vous que Python
saute une ligne chaque itration ? Rcrivez les instructions ad-hoc pour que Python
crive le contenu du fichier sans sauter de ligne.

7.4 Exercices 7 Fichiers
2. En reprenant le dernier exemple sur lcriture dans un fichier, vous pouvez constater que
les noms danimaux ont t crits les uns la suite des autres, sans retour la ligne.
Comment expliquez-vous ce rsultat ? Modifiez les instructions de manire crire un
animal par ligne.
3. Dans cet exercice, nous allons utiliser une sortie partielle de DSSP (Define Secondary Struc-
ture of Proteins), qui est un logiciel dextraction des structures secondaires. Ce fichier
contient 5 colonnes correspondant respectivement au numro de rsidu, lacide amin,
sa structure secondaire et ses angles phi/psi.
Tlchargez le fichier first_helix_1tfe.txt sur le site de notre cours et sauvegardez-le
dans votre rpertoire de travail (jetez-y un oeil en passant).
Chargez les lignes de ce fichier en les plaant dans une liste puis fermez le fichier.
crivez chaque ligne lcran pour vrifier que vous avez bien charg le fichier.
crivez dans un fichier output.txt chacune des lignes. Noubliez pas le retour la
ligne pour chaque acide amin.
crivez dans un fichier output2.txt chacune des lignes suivies du message line checked.
Encore une fois, noubliez pas les retours la ligne.

8 Modules
8 Modules
8.1 Dfinition
Les modules sont des programmes Python qui contiennent des fonctions que lon est amen
rutiliser souvent (on les appelle aussi bibliothques ou libraries). Les dveloppeurs de Python
ont mis au point de nombreux modules qui effectuent une quantit phnomnale de tches.
Pour cette raison, prenez le rflexe de vrifier si une partie du code que vous souhaitez crire
nexiste pas dj sous forme de module. La plupart de ces modules sont dj installs dans
les versions standards de Python. Vous pouvez accder une documentation exhaustive pour
python 2.7 sur le site de Python (ici pour python 3.*). Surfez un peu sur ce site, la quantit de
modules est impressionante.
8.2 Importation de modules

Jusqu maintenant, nous avons rencontr une fois cette notion de module lorsque nous
avons voulu tirer un nombre alatoire.
>>> import random

>>> random.randint(0,10)
4
Regardons de plus prs cet exemple :

Linstruction import permet daccder toutes les fonctions du module random
Ensuite, nous utilisons la fonction (ou mthode) randint(a,b) du module random. At-
tention cette fonction renvoie un nombre entier alatoirement entre a inclus et b inclus
(contrairement range() par exemple). Remarquez la notation objet random.randint()
o la fonction randint() peut tre considre comme une mthode de lobjet random.
Il existe un autre moyen dimporter une ou des fonctions dun module :
>>> from random import randint

>>> randint(0,10)
7
laide du mot-cl from, vous pouvez importer une fonction spcifique dun module
donn. Remarquez que dans ce cas il est inutile de rpter le nom du module, seul le nom
de ladite fonction est requis.
On peut galement importer toutes les fonctions dun module :
>>> from random import *

>>> x = [1, 2, 3, 4]
>>> shuffle(x)
>>> x
[2, 3, 1, 4]
>>> shuffle(x)
>>> x
[4, 2, 1, 3]
>>> randint(0,50)
46
>>> uniform(0,2.5)
0.64943174760727951

8.3 Obtenir de laide sur les modules imports 8 Modules
Comme vous lavez devin, linstruction from random import * importe toutes les fonc-
tions du module random. On peut ainsi utiliser toutes ses fonctions directement, comme par
exemple shuffle(), qui permute une liste alatoirement.
Dans la pratique, plutt que de charger toutes les fonctions dun module en une seule fois
(from random import *), nous vous conseillons de charger le module (import random)
puis dappeler explicitement les fonctions voulues (random.randint(0,2)).
Enfin, si vous voulez vider de la mmoire un module dj charg, vous pouvez utiliser
linstruction del :
>>> import random

2
>>> del random
NameError: name 'random' is not defined
Vous pouvez constater quun rappel dune fonction du module random aprs lavoir vid de
la mmoire retourne un message derreur.
Enfin, il est galement possible de dfinir un alias (un nom plus court) pour un module :
>>> import random as rand

>>> rand.randint(1, 10)
6
Dans cet exemple, les fonctions du module random sont accessibles via lalias rand.
8.3 Obtenir de laide sur les modules imports

Pour obtenir de laide sur un module rien de plus simple, il suffit dinvoquer la commande
help() :
>>> import random

>>> help(random)
...
On peut se promener dans laide avec les flches ou les touches page-up et page-down
(comme dans les commandes Unix man, more ou less). Il est aussi possible dinvoquer de
laide sur une fonction particulire dun module de la manire suivante help(random.randint).
La commande help() est en fait une commande plus gnrale permettant davoir de laide
sur nimporte quel objet charg en mmoire.
>>> x = range(2)
>>> help(x)
Help on list object:
class list(object)
| list() -> new list
| list(sequence) -> new list initialized from sequence's items
|

8 Modules 8.4 Modules courants
| Methods defined here:

|
| __add__(...)
| x.__add__(y) <==> x+y
|
...
Enfin, si on veut connatre en seul coup doeil toutes les mthodes ou variables associes
un objet, on peut utiliser la commande dir :
>>> import random

>>> dir(random)
['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemR
'TWOPI', 'WichmannHill', '_BuiltinMethodType', '_MethodType', '__all__', '__built
'__doc__', '__file__', '__name__', '_acos', '_ceil', '_cos', '_e', '_exp', '_hexl
'_inst', '_log', '_pi', '_random', '_sin', '_sqrt', '_test', '_test_generator',
'_urandom', '_warn', 'betavariate', 'choice', 'expovariate', 'gammavariate', 'gau
'getrandbits', 'getstate', 'jumpahead', 'lognormvariate', 'normalvariate',
'paretovariate', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate',
'shuffle', 'uniform', 'vonmisesvariate', 'weibullvariate']
>>>
8.4 Modules courants
Il existe une srie de modules que vous serez probablement amens utiliser si vous pro-
grammez en Python. En voici une liste non exhaustive. Pour la liste complte, reportez-vous
la page des modules sur le site de Python :
math : fonctions et constantes mathmatiques de base (sin, cos, exp, pi...).
sys : passage darguments, gestion de lentre/sortie standard...
os : dialogue avec le systme dexploitation (e.g. permet de sortir de Python, lancer une
commande en shell, puis de revenir Python).
random : gnration de nombres alatoires.
time : permet daccder lheure de lordinateur et aux fonctions grant le temps.
calendar : fonctions de calendrier.
profile : permet dvaluer le temps dexcution de chaque fonction dans un programme
(profiling en anglais).
urllib2 : permet de rcuprer des donnes sur internet depuis python.
Tkinter : interface python avec Tk (permet de crer des objets graphiques ; ncessite dins-
taller Tk).
re : gestion des expressions rgulires.
pickle : criture et lecture de structures Python (comme les dictionnaires par exemple).
Nous vous conseillons vivement daller surfer sur les pages de ces modules pour dcouvrir
toutes leurs potentialits.
Vous verrez plus tard comment crer votre propres modules lorsque vous tes amens
rutiliser souvent vos propres fonctions.
Enfin, notez quil existe de nombreux autres modules qui ne sont pas installs de base dans
Python mais qui sont de grand intrt en bioinformatique (au sens large). Citons-en quelques-
uns : numpy (algbre linaire, transforme de Fourier), biopython (recherche dans les banques
de donnes biologiques), rpy (dialogue R/Python)...

8.5 Module sys : passage darguments 8 Modules
8.5 Module sys : passage darguments

Le module sys contient (comme son nom lindique) des fonctions et des variables spci-
fiques au systme, ou plus exactement linterprteur lui-mme. Par exemple, il permet de
grer lentre (stdin) et la sortie standard (stdout). Ce module est particulirement intressant
pour rcuprer les arguments passs un script Python lorsque celui-ci est appel en ligne
de commande. Dans cet exemple, oublions linterprteur et crivons le script suivant que lon
enregistrera sous le nom test.py (noubliez pas de le rendre excutable) :
import sys
print sys.argv
Ensuite lancez test.py suivi de plusieurs arguments. Par exemple :
poulain@cumin> python test.py salut girafe 42

['test.py', 'salut', 'girafe', '42']
Dans lexemple prcdent, poulain@cumin> reprsente linvite du shell, test.py est le

nom du script Python, salut, girafe et 42 sont les arguments passs au script.
La variable sys.argv est une liste qui reprsente tous les arguments de la ligne de com-
mande, y compris le nom du script lui mme quon peut retrouver dans sys.argv[0]. On
peut donc accder chacun de ces arguments avec sys.argv[1], sys.argv[2]...
On peut aussi utiliser la fonction sys.exit() pour quitter un script Python. On peut don-
ner comme argument un objet (en gnral une chane de caractres) qui sera renvoy au mo-
ment ou Python quittera le script. Par exemple, si vous attendez au moins un argument en ligne
de commande, vous pouvez renvoyer un message pour indiquer lutilisateur ce que le script
attend comme argument :
import sys
if len(sys.argv) != 2:
sys.exit("ERREUR : il faut exactement un argument.")
#
# suite du script
#
Puis on lexcute sans argument :
poulain@cumin> python test.py

ERREUR : il faut exactement un argument.
Notez quici on vrifie que le script possde deux arguments car le nom du script lui-mme
est le premier argument et file.txt constitue le second.
8.6 Module os
Le module os gre linterface avec le systme dexploitation.
Une fonction pratique de ce module permet de grer la prsence dun fichier sur le disque.

8 Modules 8.7 Exercices
>>> import sys

>>> import os
>>> if os.path.exists("toto.pdb"):
... print "le fichier est prsent"
... else:
... sys.exit("le fichier est absent")
...
le fichier est absent
Dans cet exemple, si le fichier nest pas prsent sur le disque, on quitte le programme avec
la fonction exit() du module sys.
La fonction system() permet dappeler nimporte quelle commande externe.
>>> import os
>>> os.system("ls -al")
total 5416
drwxr-xr-x 2 poulain dsimb 4096 2010-07-21 14:33 .
drwxr-xr-x 6 poulain dsimb 4096 2010-07-21 14:26 ..
-rw-r--r-- 1 poulain dsimb 124335 2010-07-21 14:31 1BTA.pdb
-rw-r--r-- 1 poulain dsimb 4706057 2010-07-21 14:31 NC_000913.fna
-rw-r--r-- 1 poulain dsimb 233585 2010-07-21 14:30 NC_001133.fna
-rw-r--r-- 1 poulain dsimb 463559 2010-07-21 14:33 NC_001133.gbk
0
La commande externe ls -al est introduite comme une chane de caractres la fonction
system().
8.7 Exercices
Conseil : pour les trois premiers exercices, utilisez linterprteur Python. Pour les exercices
suivants, crivez des scripts dans des fichiers, puis excutez-les dans un shell.
1. Affichez sur la mme ligne les nombres de 10 20 (inclus) ainsi que leur racine carre
avec 3 dcimales (module math). Exemple :
10 3.162
11 3.317
12 3.464
13 3.606
2. Calculez le cosinus de pi/2 (module math).
3. Affichez la liste des fichiers du rpertoire courant avec le module os. Nutilisez pas la
fonction os.system() mais la fonction os.listdir() (lisez la documentation pour
comprendre comment lutiliser).
4. crivez les nombres de 1 10 avec 1 seconde dintervalle (module time).
5. Gnrez une squence alatoire de 20 chiffres, ceux-ci tant des entiers tirs entre 1 et 4
(module random).
6. Gnrez une squence alatoire de 20 bases de deux manires diffrentes (module ran-
dom).
7. Dterminez votre jour (lundi, mardi...) de naissance (module calendar).
8. Exercice +++. valuation du nombre par la mthode Monte Carlo.
Soit un cercle de rayon 1 (en rouge) inscrit dans un carr de cot 2 (en bleu).

8.7 Exercices 8 Modules
Laire du carr vaut (2R)2 soit 4. Laire du cercle vaut R2 soit .

En choississant N points alatoires ( laide dune distribution uniforme) lintrieur du
carr, la probabilit que ces points se trouvent aussi dans le cercle est
aire du cercle
p= =
aire du carr 4
Soit n, le nombre points effectivement dans le cercle, il vient alors
n
p= = ,
N 4
do
n
=4 .
N
Dterminez une approximation de par cette mthode. Pour cela, vous allez, pour N it-
rations, choisir alatoirement les coordonnes dun point entre -1 et 1 (fonction uniform()
du module random), calculer la distance entre le centre du cercle et ce point et dtermi-
ner si cette distance est infrieure au rayon du cercle. Le cas chant, le compteur n sera
incrment.
Que vaut lapproximation de pour 100 itrations ? 500 ? 1000 ?
Conseil : pour les premiers exercices, utilisez linterprteur Python.

9 Plus sur les chanes de caractres
9 Plus sur les chanes de caractres

9.1 Prambule
Nous avons dj abord les chanes de caractres dans le chapitre variables et criture. Ici
nous allons un peu plus loin notamment avec les mthodes associes aux chanes de carac-
tres. Notez quil existe un module string mais qui est maintenant considr comme obsolte
depuis la version 2.5 de Python.
9.2 Chanes de caractres et listes

Les chanes de caractres peuvent tre considres comme des listes.
>>> animaux = "girafe tigre"

>>> animaux
'girafe tigre'
>>> len(animaux)
12
>>> animaux[3]
'a'
Nous pouvons donc utiliser certaines proprits des listes comme les tranches :
>>> animaux[0:4]
'gira'
>>> animaux[9:]
'gre'
>>> animaux[:-2]
'girafe tig'
A contrario des listes, les chanes de caractres prsentent toutefois une diffrence notable,
ce sont des listes non modifiables. Une fois dfinie, vous ne pouvez plus modifier un de ses
lments. Le cas chant, Python renvoie un message derreur :
>>> animaux[4]
'f'
>>> animaux[4] = "F"
TypeError: 'str' object does not support item assignment
Par consquent, si vous voulez modifier une chane, vous tes obligs den construire une
nouvelle. Pour cela, noubliez pas que les oprateurs de concatnation (+) et de duplication (*)
(cf chapitre variables et criture) peuvent vous aider. Vous pouvez galement gnrer une liste,
qui elle est modifiable, puis revenir une chane.
9.3 Caractres spciaux

Il existe certains caractres spciaux comme le \n que nous avons dj vu (pour le retour la
ligne). Le \t vous permet dcrire une tabulation. Si vous voulez crire un guillemet simple ou
double (et que celui-ci ne soit pas confondus avec les guillemets de dclaration de la chane de
caractres), vous pouvez utiliser \' ou \" ou utiliser respectivement des guillements doubles
ou simple pour dclarer votre chane de caractres.

9.4 Mthodes associes aux chanes de caractres 9 Plus sur les chanes de caractres
>>> print "Un retour a la ligne\npuis une tabulation\t, puis un guillemet\""

Un retour a la ligne
puis une tabulation , puis un guillemet"
>>> print 'J\'imprime un guillemet simple'
J'imprime un guillemet simple
>>> print "Un brin d'ADN"
Un brin d'ADN
>>> print 'Python est un "super" langage'
Python est un "super" langage
Lorsquon souhaite crire un texte sur plusieurs lignes, il est trs commode dutiliser les
guillemets triples permettant de conserver le formatage (notamment les retours la ligne) :
>>> x = '''souris
... chat
... abeille'''
>>> x
'souris\nchat\nabeille'
>>> print x
souris
chat
abeille
9.4 Mthodes associes aux chanes de caractres

Voici quelques mthodes spcifiques aux objets de type string :
>>> x = "girafe"
>>> x.upper()
'GIRAFE'
>>> x
'girafe'
>>> 'TIGRE'.lower()
'tigre'
Les fonctions lower() et upper() passent un texte en minuscule et en majuscule respecti-

vement. On remarque que lutilisation de ces fonctions naltrent pas la chane de dpart mais
renvoie la chane transforme.
Pour mettre en majuscule la premire lettre seulement, vous pouvez faire :
>>> x[0].upper() + x[1:]

'Girafe'
ou encore plus simple avec la fonction Python adquate :
>>> x.capitalize()
'Girafe'
Il existe une mthode associe aux chanes de caractres qui est particulirement pratique,
la fonction split() :
>>> animaux = "girafe tigre singe"

>>> animaux.split()

9 Plus sur les chanes de caractres 9.4 Mthodes associes aux chanes de caractres
>>> for animal in animaux.split():

... print animal
...
girafe
tigre
singe
La fonction split() dcoupe la ligne en champs, en utilisant comme sparateur les es-
paces ou les tabulations. Il est possible de modifier le sparateur de champs, par exemple :
>>> animaux = "girafe:tigre:singe"

>>> animaux.split(":")
La fonction find() recherche une chane de caractres passe en argument.
>>> animal = "girafe"

>>> animal.find('i')
1
>>> animal.find('afe')
3
>>> animal.find('tig')
-1
Si llment recherch est trouv, alors lindice du dbut de llment dans la chane de
caractres est renvoy. Si llment nest pas trouv, alors la valeur -1 est renvoye.
Si llment recherch est trouv plusieurs fois, seul lindice de la premire occurence est
retourn :

>>> animaux.find("i")
1
On trouve aussi la fonction replace(), qui serait lquivalent de la fonction de substitu-

tion de la commande Unix sed :

>>> animaux.replace("tigre", "singe")
'girafe singe'
>>> animaux.replace("i", "o")
'gorafe togre'
Enfin, la fonction count() compte le nombre doccurences dune chane de caractres pas-
se en argument :

>>> animaux.count("i")
2
>>> animaux.count("z")
0
>>> animaux.count("tigre")
1

9.5 Conversion de types 9 Plus sur les chanes de caractres
9.5 Conversion de types

Dans tout langage de programmation, on est souvent amen convertir les types, cest--
dire passer dun type numrique une chane de caractres ou vice-versa. En Python, rien de
plus simple avec les fonctions int(), float() et str(). Pour vous en convaincre, regardez
ces exemples :
>>> i = 3
>>> str(i)
'3'
>>> i = '456'
>>> int(i)
456
>>> float(i)
456.0
>>> i = '3.1416'
>>> float(i)
3.1415999999999999
Ces conversions sont essentielles lorsquon lit ou crit des nombres dans un fichier. En effet,
les nombres dans un fichier sont considrs comme du texte par la fonction readlines(), par
consquent il faut les convertir si on veut effectuer des oprations numriques dessus.
9.6 Conversion dune liste de chanes de caractres en une chane de caractres

La conversion dune liste de chanes de caractres en une chane de caractres est un peu
particulire puisquelle fait appelle la fonction join().
>>> seq = ["A", "T", "G", "A", "T"]

>>> seq
['A', 'T', 'G', 'A', 'T']
>>> "-".join(seq)
'A-T-G-A-T'
>>> " ".join(seq)
'A T G A T'
>>> "".join(seq)
'ATGAT'
Les lments de la liste initiale sont concatns les uns la suite des autres et intercals par
un sparateur qui peut tre nimporte quelle chane de caractres (ici, nous avons utilis un
tiret, un espace et rien).
Attention, la fonction join() ne sapplique qu une liste de chanes de caractres.
>>> maliste = ["A", 5, "G"]

>>> " ".join(maliste)
TypeError: sequence item 1: expected string, int found
Nous esprons quaprs ce petit tour dhorizon vous serez convaincu de la richesse des
mthodes associes aux chanes de caractres. Pour avoir une liste exhaustive de lensemble
des mthodes associes une variable particulire, vous pouvez utiliser la commande dir().

9 Plus sur les chanes de caractres 9.7 Exercices
>>> dir(animaux)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__g
'__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__',
'__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__n
'__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__',
'__setattr__', '__str__', 'capitalize', 'center', 'count', 'decode', 'encode',
'endswith', 'expandtabs', 'find', 'index', 'isalnum', 'isalpha', 'isdigit', 'islo
'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition',
'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split',
'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper',
'zfill']
Pour linstant vous pouvez ignorer les mthodes qui commencent et qui se terminent par
deux tirets bas (underscores) __ .
Vous pouvez ensuite accder laide et la documentation dune fonction particulire avec
help() :
>>> help(animaux.split)
Help on built-in function split:
split(...)
S.split([sep [,maxsplit]]) -> list of strings
Return a list of the words in the string S, using sep as the

delimiter string. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator.
(END)
9.7 Exercices
shell.
1. Soit la liste ['girafe', 'tigre', 'singe', 'souris']. Avec une boucle, affichez
chaque lment ainsi que sa taille (nombre de caractres).
2. Soit la squence nuclique ATATACGGATCGGCTGTTGCCTGCGTAGTAGCGT. Calculez la fr-
quence de chaque base dans cette squence.
3. Soit la squence protique ALA GLY GLU ARG TRP TYR SER GLY ALA TRP. Trans-
formez cette squence en une chane de caractres en utilisant le code une lettre pour les
acides amins.
4. Distance de Hamming.
La distance de Hamming mesure la diffrence entre deux squences de mme taille en
sommant le nombre de positions qui, pour chaque squence, ne correspondent pas au
mme acide amin. Calculez la distance de Hamming pour les squences AGWPSGGASAGLAIL
et IGWPSAGASAGLWIL.
5. Palindrome.
Un palindrome est un mot ou une phrase dont lordre des lettres reste le mme si on le lit
de gauche droite ou de droite gauche. Par exemple, ressasser et Engage le jeu que
je le gagne sont des palindromes.
crivez un script qui dtermine si une chane de caractres est un palindrome. Pensez
vous dbarasser des majuscules et des espaces. Testez si les expressions suivantes sont des
palindromes : Radar , Never odd or even , Karine alla en Iran , Un roc si biscornu .

9.7 Exercices 9 Plus sur les chanes de caractres
6. Mot composable.
Un mot est composable partir dune squence de lettres si la squence contient toutes
les lettres du mot. Comme au Scrabble, chaque lettre de la squence ne peut tre utilise
quune seule fois. Par exemple, coucou est composable partir de uocuoceokzefhu.
crivez un script qui permet de savoir si un mot est composable partir dune squence
de lettres. Testez le avec diffrents mots et squences.
Remarque : dans votre script, le mot et la squence de lettres seront des chanes de carac-
tres.
7. Alphabet et pangramme.
Les codes ASCII des lettres minuscules de lalphabet vont de 97 (lettre a) 122 (lettre z).
La fonction chr() prend en argument un code ASCII sous forme dune entier et renvoie
le caractre correspondant. Ainsi chr(97) renvoie 'a', chr(98) renvoie 'b' et ainsi
de suite.
crivez un script qui construit une chane de caractres contenant toutes les lettres de
lalphabet.
Un pangramme est une phrase comportant au moins une fois chaque lettre de lalphabet.
Par exemple, Portez ce vieux whisky au juge blond qui fume est un pangramme.
Modifiez le script prcdent pour dterminer si une chane de caractres est un pan-
gramme ou non. Pensez vous dbarasser des majuscules le cas chant. Testez si les
expressions suivantes sont des pangrammes : Monsieur Jack vous dactylographiez bien
mieux que votre ami Wolf , Buvez de ce whisky que le patron juge fameux .
8. Tlchargez le fichier pdb 1BTA dans votre rpertoire. Faites un script qui rcupre seule-
ment les carbones alpha et qui les affiche lcran.
9. En vous basant sur le script prcdent, affichez lcran les carbones alpha des deux
premiers rsidus. Toujours avec le mme script, calculez la distance inter atomique entre
ces deux atomes.
10. En vous basant sur le script prcdent, calculez les distances entre carbones alpha cons-
cutifs. Affichez ces distances sous la forme
numero_calpha_1 numero_calpha_2 distance
la fin du script, faites galement afficher la moyenne des distances. La distance inter
carbone alpha dans les protines est trs stable et de lordre de 3,8 angstrms. Observez
avec attention les valeurs que vous avez obtenues. Expliquez lanomalie dtecte.

10 Plus sur les listes
10 Plus sur les listes

10.1 Proprits des listes
Jusqu maintenant, nous avons toujours utilis des listes qui taient dj remplies. Nous
savons comment modifier un de ses lments, mais il est aussi parfois trs pratique den re-
manier la taille (e. g. ajouter, insrer ou supprimer un ou plusieurs lments, etc.). Les listes
possdent cet effet des mthodes qui leurs sont propres. Observez les exemples suivants :
append() pour ajouter un lment la fin dune liste.
>>> x = [1,2,3]
>>> x.append(5)
>>> x
[1, 2, 3, 5]
qui est quivalent
>>> x = [1,2,3]
>>> x = x + [5]
>>> x
[1, 2, 3, 5]
insert() pour insrer un object dans une liste avec un indice dtermin.
>>> x.insert(2,-15)
>>> x
[1, 2, -15, 3, 5]
del pour supprimer un lment dune liste une indice dtermin.
>>> del x[1]
>>> x
[1, -15, 3, 5]
remove() pour supprimer un lment dune liste partir de sa valeur
>>> x.remove(5)
>>> x
[1, -15, 3]
sort() pour trier une liste.
>>> x.sort()
>>> x
[-15, 1, 3]
reverse() pour inverser une liste.
>>> x.reverse()
>>> x
[3, 1, -15]
count() pour compter le nombre dlments (pass en argument) dans une liste.
>>> l=[1, 2, 4, 3, 1, 1]
>>> l.count(1)
3
>>> l.count(4)
1
>>> l.count(23)
0
Remarque 1 : attention, une liste remanie nest pas renvoye ! Pensez-y dans vos utilisa-
tions futures des listes.
Remarque 2 : attention, certaines fonctions ci-dessus dcalent les indices dune liste (par
exemple insert(), del etc).

10.2 Test dappartenance 10 Plus sur les listes
La mthode append() est particulirement pratique car elle permet de construire une liste
au fur et mesure des itrations dune boucle. Pour cela, il est commode de dfinir pralable-
ment une liste vide de la forme maliste = []. Voici un exemple o une chane de caractres
est convertie en liste :
>>> seq = 'CAAAGGTAACGC'

>>> seq_list = []
>>> seq_list
[]
>>> for base in seq:
... seq_list.append(base)
...
>>> seq_list
['C', 'A', 'A', 'A', 'G', 'G', 'T', 'A', 'A', 'C', 'G', 'C']
Remarquez que vous pouvez directement utiliser la fonction list() qui prend nimporte
quel objet squentiel (liste, chane de caractres, tuples, etc.) et qui renvoie une liste :
>>> seq = 'CAAAGGTAACGC'

>>> list(seq)
['C', 'A', 'A', 'A', 'G', 'G', 'T', 'A', 'A', 'C', 'G', 'C']
Cette mthode est certes plus simple, mais il arrive parfois que lon doive utiliser les boucles
tout de mme, comme lorquon lit un fichier.
10.2 Test dappartenance

Linscription in permet de tester si un lment fait partie dune liste.
liste = [1, 3, 5, 7, 9]
>>> 3 in liste
True
>>> 4 in liste
False
>>> 3 not in liste
False
>>> 4 not in liste
True
La variation avec not permet, a contrario, de vrifier quun lement nest pas dans une liste.
10.3 Copie de listes

Il est trs important de savoir que laffectation dune liste ( partir dune liste prexistante)
cre en ralit une rfrence et non une copie :
>>> x = [1,2,3]
>>> y = x
>>> y
[1, 2, 3]
>>> x[1] = -15
>>> y
[1, -15, 3]

10 Plus sur les listes 10.3 Copie de listes
Vous voyez que la modification de x modifie y aussi. Rappelez-vous de ceci dans vos futurs
programmes car cela pourrait avoir des effets dsastreux ! Techniquement, Python utilise des
pointeurs (comme dans le langage C) vers les mmes objets et ne cre pas de copie moins que
vous nen ayez fait la demande explicitement. Regardez cet exemple :
>>> x = [1,2,3]
>>> y = x[:]
>>> x[1] = -15
>>> y
[1, 2, 3]
Dans lexemple prcdent, x[:] a cr une copie la vole de la liste x. Vous pouvez
utiliser aussi la fonction list() qui renvoie explicitement une liste :
>>> x = [1,2,3]
>>> y = list(x)
>>> x[1] = -15
>>> y
[1, 2, 3]
Attention, les deux techniques prcdentes ne fonctionnent que pour les listes une dimen-
sion, autrement dit les listes qui ne contienent pas elles-mmes dautres listes.
>>> x = [[1,2],[3,4]]
>>> x
[[1, 2], [3, 4]]
>>> y = x[:]
>>> y[1][1] = 55
>>> y
[[1, 2], [3, 55]]
>>> x
[[1, 2], [3, 55]]
>>> y = list(x)
>>> y[1][1] = 77
>>> y
[[1, 2], [3, 77]]
>>> x
[[1, 2], [3, 77]]
La mthode de copie qui marche tous les coups consiste appeler la fonction deepcopy()
du module copy.
>>> import copy

>>> x = [[1,2],[3,4]]
>>> x
[[1, 2], [3, 4]]
>>> y = copy.deepcopy(x)
>>> y[1][1] = 99
>>> y
[[1, 2], [3, 99]]
>>> x
[[1, 2], [3, 4]]

10.4 Exercices 10 Plus sur les listes
10.4 Exercices
shell.
1. Soit la liste de nombres [8, 3, 12.5, 45, 25.5, 52, 1]. Triez les nombres de
cette liste par ordre croissant, sans utiliser la fonction sort() (les fonctions min(), append()
et remove() vous seront utiles).
2. Gnrez alatoirement une squence nuclique de 20 bases en utilisant une liste et la
mthode append().
3. Transformez la squence nuclique TCTGTTAACCATCCACTTCG en sa squence compl-
mentaire inverse. Noubliez pas que la squence complmentaire doit tre inverse, pen-
sez aux mthodes des listes !
4. Soit la liste de nombres [5, 1, 1, 2, 5, 6, 3, 4, 4, 4, 2]. Enlevez les dou-
blons de cette liste, triez-l et affichez-l.
5. Gnrez alatoirement une squence nuclique de 50 bases contenant 10 % de A, 50 % de
G, 30 % de T et 10 % de C.
6. Exercice +++. Triangle de Pascal
Voici le dbut du triangle de Pascal :
1
11
121
1331
14641
...
Comprenez comment une ligne est construite partir de la prcente. partir de lordre
1 (ligne 2, 11), gnrez lordre suivant (121). Vous pouvez utiliser une liste pralable-
ment gnre avec range(). Gnralisez laide dune boucle. crivez dans un fichier
pascal.out les lignes du triangle de Pascal de lordre 1 jusqu lordre 10.

11 Dictionnaires et tuples
11 Dictionnaires et tuples
11.1 Dictionnaires
Les dictionnaires se rvlent trs pratiques lorsque vous devez manipuler des structures
complexes dcrire et que les listes prsentent leurs limites. Les dictionnaires sont des col-
lections non ordonnes dobjets, c--d quil ny a pas de notion dordre (i. e. pas dindice).
On accde aux valeurs dun dictionnaire par des cls. Ceci semble un peu confus ? Regardez
lexemple suivant :
>>> ani1 = {}
>>> ani1['nom'] = 'girafe'
>>> ani1['taille'] = 5.0
>>> ani1['poids'] = 1100
>>> ani1
{'nom': 'girafe', 'poids': 1100, 'taille': 5.0}
>>> ani1['taille']
5.0
En premier, on dfinit un dictionnaire vide avec les symboles {} (tout comme on peut le
faire pour les listes avec []). Ensuite, on remplit le dictionnaire avec diffrentes cls auxquelles
on affecte des valeurs (une par cl). Vous pouvez mettre autant de cls que vous voulez dans
un dictionnaire (tout comme vous pouvez ajouter autant dlments que vous voulez dans
une liste). Pour rcuprer la valeur dune cl donne, il suffit dutiliser une syntaxe du style
dictionnaire['cle'].
Mthodes keys() et values()

Les mthodes keys() et values() renvoient, comme vous vous en doutez, les cls et les
valeurs dun dictionnaire (sous forme de liste) :
>>> ani1.keys()
['nom', 'poids', 'taille']
>>> ani1.values()
['girafe', 1100, 5.0]
On peut aussi initialiser toutes les cls dun dictionnaire en une seule opration :
>>> ani2 = {'nom':'singe', 'poids':70, 'taille':1.75}
Liste de dictionnaires
En crant une liste de dictionnaires possdant les mmes cls, on obtient une structure qui
ressemble une base de donnes :
>>> animaux = [ani1, ani2]

>>> animaux
[{'nom': 'girafe', 'poids': 1100, 'taille': 5.0}, {'nom': 'singe', 'poids': 70, '
>>>
>>> for ani in animaux:
... print ani['nom']
...
girafe
singe

11.2 Tuples 11 Dictionnaires et tuples
Existence dune clef

Enfin, pour vrifier si une cl existe, vous pouvez utiliser la proprit has_key() :
>>> if ani2.has_key('poids'):
... print "La clef 'poids' existe pour ani2"
...
La clef 'poids' existe pour ani2
Python permet mme de simplifier encore les choses :
>>> if "poids" in ani2:
... print "La clef 'poids' existe pour ani2"
...
La clef 'poids' existe pour ani2
Vous voyez que les dictionnaires permettent de grer des structures complexes de manire
plus explicite que les listes.
11.2 Tuples
Les tuples correspondent aux listes la diffrence quils sont non modifiables. On a vu
la section prcdente que les listes pouvaient tre modifies par des rfrences ; les tuples vous
permettent de vous affranchir de ce problme. Pratiquement, ils utilisent les parenthses au
lieu des crochets :
>>> x = (1,2,3)
>>> x
(1, 2, 3)
>>> x[2]
3
>>> x[0:2]
(1, 2)
>>> x[2] = 15
Traceback (innermost last):
TypeError: object doesn't support item assignment
Laffectation et lindiage fonctionne comme avec les listes, mais si lon essaie de modifier un
des lments du tuple, Python renvoie un message derreur. Si vous voulez ajouter un lment
(ou le modifier), vous devez crer un autre tuple :
>>> x = (1,2,3)
>>> x + (2,)
(1, 2, 3, 2)
Remarquez que pour utiliser un tuple dun seul lment, vous devez utiliser une syntaxe
avec une virgule (element,), ceci pour viter une ambigut avec une simple expression.
Autre particularit des tuples, il est possible den crer de nouveaux sans les parenthses, ds
lors que ceci ne pose pas dambigut avec une autre expression :
>>> x = (1,2,3)
>>> x
(1, 2, 3)
>>> x = 1,2,3
>>> x
(1, 2, 3)

11 Dictionnaires et tuples 11.3 Exercices
Toutefois, nous vous conseillons dutiliser systmatiquement les parenthses afin dviter
les confusions.
Enfin, on peut utiliser la fonction tuple(sequence) qui fonctionne exactement comme la
fonction list, c--d quelle prend en argument un objet squentiel et renvoie le tuple corres-
pondant :
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> tuple(range(10))
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> tuple("ATGCCGCGAT")
('A', 'T', 'G', 'C', 'C', 'G', 'C', 'G', 'A', 'T')
Remarque : les listes, dictionnaires, tuples sont des objets qui peuvent contenir des collec-
tions dautres objets. On peut donc construire des listes qui contiennent des dictionnaires, des
tuples ou dautres listes, mais aussi des dictionnaires contenant des tuples, des listes, etc.
11.3 Exercices
shell.
1. En utilisant un dictionnaire et la fonction has_key(), dterminez le nombre doccu-
rences de chaque acide amin dans la squence AGWPSGGASAGLAILWGASAIMPGALW. Le
dictionnaire ne doit contenir que les acides amins prsents dans la squence.
2. Soit la squence nuclotidique suivante :
ACCTAGCCATGTAGAATCGCCTAGGCTTTAGCTAGCTCTAGCTAGCTG
En utilisant un dictionnaire, faites un programme qui rpertorie tous les mots de 2 lettres
qui existent dans la sequence (AA, AC, AG, AT, etc.) ainsi que leur nombre doccurences
puis qui les affiche lcran.
3. Faites de mme avec des mots de 3 et 4 lettres.
4. En vous basant sur les scripts prcdents, extrayez les mots de 2 lettres et leur occu-
rence sur le gnome du chromosome I de la levure du boulanger Saccharomyces cerevisiae
NC_001133.fna. Attention, le gnome complet est fourni au format fasta.
5. Crez un script extract-words.py qui prend en arguments un fichier genbank suivi
dun entier compris entre 1 et 4. Ce script doit extraire du fichier genbank tous les mots
(ainsi que leur nombre doccurences) du nombre de lettres passes en option.
6. Appliquez ce script sur le gnome dEscherichia coli : NC_000913.fna (au format fasta).
Cette mthode vous parat-elle efficace sur un gnome assez gros comme celui dE. Coli ?
Comment pourrait-on en amliorer la rapidit ?
7. partir du fichier PDB 1BTA, construisez un dictionnaire qui contient 4 cls se rfrant
au premier carbone alpha : le numro du rsidu, puis les coordonnes x, y et z.
8. Sur le mme modle que ci-dessus, crez une liste de dictionnaires pour chacun des car-
bones alpha de la protine.
9. laide de cette liste, calculez les coordonnes x, y et z du barycentre de ces carbones
alpha.

12 Fonctions
12 Fonctions
12.1 Principe
En programmation, les fonctions sont trs utiles pour raliser plusieurs fois la mme opra-
tion au sein dun programme. Elles permettent galement de rendre le code plus lisible et plus
clair en le fractionnant en blocs logiques.
Vous connaissez dj certaines fonctions Python, par exemple math.cos(angle) du mo-

dule math renvoie le cosinus de la variable angle exprime en radian. Vous connaissez aussi
des fonctions internes Python comme range() ou len(). Pour linstant, une fonction est
vos yeux une sorte de bote noire :
laquelle vous passez une (ou zero ou plusieurs) valeur(s) entre parenthses. Ces valeurs
sont appeles arguments.
Qui effectue une action. Par exemple random.shuffle() permute alatoirement une
liste.
Et qui renvoie ventuellement un rsultat.
Par exemple si vous appelez la fonction range() en lui passant la valeur 5 (range(5)), celle-
ci vous renvoie une liste de nombres entiers de 0 4 ([0, 1, 2, 3, 4]).
Au contraire, aux yeux du programmeur une fonction est une portion de code effectuant
une action bien particulire. Avant de dmarrer sur la syntaxe, revenons sur cette notion de
bote noire :
1. Une fonction effectue une tche. Pour cela, elle reoit ventuellement des arguments et
renvoie ventuellement un rsultat. Ce qui se passe en son sein nintresse pas directe-
ment lutilisateur. Par exemple, il est inutile de savoir comment la fonction math.cos()
calcule un cosinus, on a juste besoin de savoir quil faut lui passer en argument un angle
en radian et quelle renvoie le cosinus de cet angle. Ce qui se passe au sein de la fonction
ne regarde que le programmeur (cest--dire vous dans ce chapitre).
2. Chaque fonction effectue en gnral une tche unique et prcise. Si cela se complique,
il est plus judicieux dcrire plusieurs fonctions (qui peuvent ventuellement sappeler
les unes les autres). Cette modularit amliore la qualit gnrale et la lisibilit du code.
Vous verrez quen Python, les fonctions prsentent une grande flexibilit.
12.2 Dfinition
Pour dfinir une fonction, Python utilise le mot-cl def et si on veut que celle-ci renvoie
une valeur, il faut utiliser le mot-cl return. Par exemple :
>>> def carre(x):

... return x**2
...
>>> print carre(2)
4
Remarquez que la syntaxe de def utilise les : comme les boucles for, while ainsi que
les tests if, un bloc dinstrutions est donc attendu. De mme que pour les boucles et les tests,
lindentation de ce bloc dinstructions (i.e. le corps de la fonction) est obligatoire.
Dans lexemple prcdent, nous avons pass un argument la fonction carre() qui nous
a retourn une valeur que nous avons affiche lcran. Que veut dire valeur retourne ? Et
bien cela signifie que cette dernire est stockable dans une variable :

12 Fonctions 12.3 Passage darguments
>>> res = carre(2)

>>> print res
4
Ici, le rsultat renvoy par la fonction est stocke dans la variable res. Notez quune fonc-
tion ne prend pas forcment un argument et ne renvoie pas forcment une valeur, par exemple :
>>> def hello():

... print "bonjour"
...
>>> hello()
bonjour
Dans ce cas la fonction hello() se contente dimprimer la chane de caractres "hello"

lcran. Elle ne prend aucun argument et ne renvoie aucun rsultat. Par consquent, cela na
pas de sens de vouloir rcuprer dans une variable le rsultat renvoy par une telle fonction .
Si on essaie tout de mme, Python affecte la valeur None qui signifie rien en anglais :
>>> x = hello()
bonjour
>>> print x
None
12.3 Passage darguments

Le nombre dargument(s) que lon peut passer une fonction est variable. Nous avons vu
ci-dessus des fonctions auxquelles on passait 0 ou 1 argument. Dans les chapitres prcdentes,
vous avez vu des fonctions internes Python qui prenaient au moins 2 arguments, pour rappel
souvenez-vous de range(1,10) ou encore range(1,10,2). Le nombre dargument est donc
laiss libre linitiative du programmeur qui est en train de dvelopper une nouvelle fonction.
Une particularit des fonctions en Python est que vous ntes pas oblig de prciser le type
des arguments que vous lui passez, ds lors que les oprations que vous effectuez avec ces
arguments sont valides. Python est en effet connu comme tant un langage au typage dyna-
mique, cest--dire quil reconnat pour vous le type des variables au moment de lexcution,
par exemple :
>>> def fois(x,y):

... return x*y
...
>>> fois(2,3)
6
>>> fois(3.1415,5.23)
16.430045000000003
>>> fois('to',2)
'toto'
Loprateur * reconnait plusieurs types (entiers, rels, chanes de caractres), notre fonction
est donc capable deffectuer plusieurs tches !
Un autre gros avantage de Python est que ses fonctions sont capables de renvoyer plusieurs
valeurs la fois, comme dans cette fraction de code :
>>> def carre_cube(x):

... return x**2,x**3
...

12.4 Porte des variables 12 Fonctions
>>> carre_cube(2)
(4, 8)
Vous voyez quen ralit Python renvoie un objet squentiel qui peut par consquent conte-
nir plusieurs valeurs. Dans notre exemple Python renvoie un objet tuple car on a utilis une
syntaxe de ce type. Notre fonction pourrait tout autant renvoyer une liste :
>>> def carre_cube2(x):

... return [x**2,x**3]
...
>>> carre_cube2(3)
[9, 27]
Enfin, il est possible de passer un ou plusieurs argument(s) de manire facultative et de leur

attribuer une valeur par dfaut :
>>> def useless_fct(x=1):

... return x
...
>>> useless_fct()
1
>>> useless_fct(10)
10
Notez que si on passe plusieurs arguments une fonction, le ou les arguments facultatifs
doivent tre situs aprs les arguments obligatoires. Il faut donc crire def fct(x, y, z=1):.
12.4 Porte des variables

Il est trs important lorsque lon manipule des fonctions de connatre la porte des variables.
Premirement, on peut crer des variables au sein dune fonction qui ne seront pas visibles
lextrieur de celle-ci ; on les appelle variables locales. Observez le code suivant :
>>> def mafonction():

... x = 2
... print 'x vaut',x,'dans la fonction'
...
>>> mafonction()
x vaut 2 dans la fonction
>>> print x
NameError: name 'x' is not defined
Lorsque Python excute le code de la fonction, il connait le contenu de la variable x. Par contre,
de retour dans le module principal (dans notre cas, il sagit de linterprteur Python), il ne la
connat plus do le message derreur. De mme, une variable passe en argument est consid-
re comme locale lorsquon arrive dans la fonction :
>>> def mafonction(x):

... print 'x vaut',x,'dans la fonction'
...
>>> mafonction(2)
x vaut 2 dans la fonction

12 Fonctions 12.5 Porte des listes
>>> print x
NameError: name 'x' is not defined
Deuximement, lorsquune variable dclare la racine du module (cest comme cela que
lon appelle un programme Python), elle est visible dans tout le module.

... print x
...
>>> x = 3
>>> mafonction()
3
>>> print x
3
Dans ce cas, la variable x est visible dans le module principal et dans toutes les fonctions du
module. Toutefois, Python ne permet pas la modification dune variable globale dans une fonc-
tion :

... x = x + 1
...
>>> x=1
>>> mafonction()
File "<stdin>", line 2, in fct
UnboundLocalError: local variable 'x' referenced before assignment
Lerreur renvoye montre que Python pense que x est une variable locale qui na pas t encore
assigne. Si on veut vraiment modifier une variable globale dans une fonction, il faut utiliser le
mot-cl global :

... global x
... x = x + 1
...
>>> x=1
>>> mafonction()
>>> x
2
Dans ce dernier cas, le mot-cl global a forc la variable x a tre globale plutt que locale au
sein de la fonction.
12.5 Porte des listes

Soyez extrmement attentifs avec les types modifiables (tels que les listes) car vous pouvez
les changer au sein dune fonction :

... liste[1] = -127
...

12.6 Rgle LGI 12 Fonctions
>>> liste = [1,2,3]

>>> mafonction()
>>> liste
[1, -127, 3]
De mme que si vous passez une liste en argument, elle est tout autant modifiable au sein de la
fonction :

... x[1] = -15
...
>>> y = [1,2,3]
>>> mafonction(y)
>>> y
[1, -15, 3]
Si vous voulez viter ce problme, utilisez des tuples, Python renverra une erreur puisque
ces derniers sont non modifiables ! Une autre solution pour viter la modification dune liste
lorsquelle est passe en tant quargument, est de la passer explicitement (comme nous lavons
fait pour laffectation) afin quelle reste intacte dans le programme principal.

... x[1] = -15
...
>>> y = [1,2,3]
>>> mafonction(y[:])
>>> y
[1, 2, 3]
>>> mafonction(list(y))
>>> y
[1, 2, 3]
Dans ces deux derniers exemples, une copie de y est cre la vole lorsquon appelle la fonc-
tion, ainsi la liste y du module principal reste intacte.
12.6 Rgle LGI

Lorsque Python rencontre une variable, il va traiter la rsolution de son nom avec des prio-
rits particulires : dabord il va regarder si la variable est locale, puis si elle nexiste pas loca-
lement, il vrifiera si elle est globale et enfin si elle nest pas globale, il testera si elle est interne
(par exemple la fonction len() est considre comme une fonction interne Python, i.e. elle
existe chaque fois que vous lancez Python). On appelle cette rgle la rgle LGI pour locale,
globale, interne. En voici un exemple :

... x = 4
... print 'Dans la fonction x vaut', x
...
>>> x = -15
>>> mafonction()
Dans la fonction x vaut 4
>>> print 'Dans le module principal x vaut',x
Dans le module principal x vaut -15

12 Fonctions 12.7 Exercices
Vous voyez que dans la fonction, x a pris la valeur qui lui tait dfinie localement en priorit
sur sa valeur dfinie dans le module principal.
Conseil : mme si Python peut reconnatre une variable ayant le mme nom que ses fonctions ou
variables internes, vitez de les utiliser car ceci rendra votre code confus !
12.7 Exercices
shell.
1. Prdisez le comportement de ce code sans le recopier dans un script ni dans linterprteur
Python :
def hello(prenom):
print "Bonjour", prenom
hello("Patrick")
print x
Python :
x = 10
def hello(prenom):
hello("Patrick")
print x
Python :
x = 10
def hello(prenom):
print x
hello("Patrick")
print x
Python :
x = 10
def hello(prenom):
x = 42
print x
hello("Patrick")
print x

12.7 Exercices 12 Fonctions
5. Crez une fonction qui prend une liste de bases et qui renvoie la squence complmen-
taire dune squence dADN sous forme de liste.
6. partir dune squence dADN ATCGATCGATCGCTGCTAGC, renvoyez le brin compl-
mentaire (noubliez pas que la squence doit tre inverse).
7. Crez une fonction distance() qui calcule une distance euclidienne en 3 dimensions
entre deux atomes. En reprenant lexercice sur le calcul de la distance entre carbones alpha
conscutifs de la protine 1BTA (chapitre sur les chanes de caractres), refaites la mme
chose en utilisant votre fonction distance().

13 Expressions rgulires et parsing
Le module re vous permet dutiliser des expressions rgulires au sein de Python. Les ex-
pressions rgulires sont aussi appeles en anglais regular expressions ou regex. Elles sont incon-
tournables en bioinformatique lorsque vous voulez rcuprer des informations dans un fichier.
Cette action de recherche de donnes dans un fichier est appele plus gnralement parsing
(qui signifie littralement analyse syntaxique en anglais). Le parsing fait partie du travail
quotidien du bioinformaticien, il est sans arrt en train de fouiller dans des fichiers pour
en extraire des informations dintrt comme par exemple rcuprer les coordonnes 3D des
atomes dune protines dans un fichier PDB ou alors extraire les gnes dun fichier genbank.
Dans ce chapitre, nous ne ferons que quelques rappels sur les expressions rgulires. Pour
un documentation plus complte, rfrez-vous la page daide des expressions rgulires sur
le site officiel de Python.
13.1 Dfinition et syntaxe
Une expression rgulire est une suite de caractres qui a pour but de dcrire un fragment
de texte. Elle est constitu de deux types de caractres :
1. Les caractres dits normaux.
2. Les mtacaractres ayant une signification particulire, par exemple ^ signifie dbut de
ligne et non pas le caractre chapeau littral.
Certains programmes Unix comme egrep, sed ou encore awk savent interprter les expres-
sions rgulires. Tous ces programmes fonctionnent gnralement selon le schma suivant :
1. Le programme lit un fichier ligne par ligne.
2. Pour chaque ligne lue, si lexpression rgulire passe en argument est prsente alors le
programme effectue une action.
Par exemple, pour le programme egrep :
[fuchs@rome cours_python]$ egrep "^DEF" herp_virus.gbk

DEFINITION Human herpesvirus 2, complete genome.
[fuchs@rome cours_python]$
Ici, egrep renvoie toutes les lignes du fichier genbank du virus de lherps (herp_virus.gbk)
qui correspondent lexpression rgulire ^DEF (i.e. DEF en dbut de ligne).
Avant de voir comment Python gre les expressions rgulires, voici quelques lments de
syntaxe des mtacaractres :

13.2 Module re et fonction search 13 Expressions rgulires et parsing
^ dbut de chane de caractres ou de ligne

Exemple : lexpression ÂTG correspond la chane de caractres ATGCGT
mais pas la chane CCATGTT.
$ fin de chane de caractres ou de ligne
Exemple : lexpression ATG$ correspond la chane de caractres TGCATG
mais pas avec la chane CCATGTT.
. nimporte quel caractre (mais un caractre quand mme)
Exemple : lexpression A.G correspond ATG, AtG, A4G, mais aussi A-G ou
A G.
[ABC] le caractre A ou B ou C (un seul caractre)
Exemple : lexpression T[ABC]G correspond TAG, TBG ou TCG, mais pas
TG.
[A-Z] nimporte quelle lettre majuscule
Exemple : lexpression C[A-Z]T correspond CAT, CBT, CCT...
[a-z] nimporte quelle lettre minuscule
[0-9] nimporte quel chiffre
[A-Za-z0-9] nimporte quel caractre alphanumrique
[ÂB] nimporte quel caractre sauf A et B
Exemple : lexpression CG[ÂB]T correspond CG9T, CGCT... mais pas
CGAT ni CGBT.
\ caractre dchappement (pour protger certains caractres)
Exemple : lexpression \+ dsigne le caractre + sans autre signification parti-
culire. Lexpression A\.G correspond A.G et non pas A suivi de nimporte
quel caractre, suivi de G.
* 0 n fois le caractre prcdent ou lexpression entre parenthses prcdente
Exemple : lexpression A(CG)*T correspond AT, ACGT, ACGCGT...
+ 1 n fois le caractre prcdent ou lexpression entre parenthses prcdente
Exemple : lexpression A(CG)+T correspond ACGT, ACGCGT... mais pas
AT.
? 0 1 fois le caractre prcdent ou lexpression entre parenthses prcdente
Exemple : lexpression A(CG)?T correspond AT ou ACGT.
{n} n fois le caractre prcdent ou lexpression entre parenthses prcdente
{n,m} n m fois le caractre prcdent ou lexpression entre parenthses prcdente
{n,} au moins n fois le caractre prcdent ou lexpression entre parenthses pr-
cdente
{,m} au plus m fois le caractre prcdent ou lexpression entre parenthses prc-
dente
(CG|TT) chanes de caractres CG ou TT
Exemple : lexpression A(CG|TT)C correspond ACGC ou ATTC.
13.2 Module re et fonction search

Dans le module re, la fonction search() permet de rechercher un motif (pattern) au sein
dune chane de caractres avec une syntaxe de la forme search(motif, chaine). Si motif
existe dans chaine, Python renvoie une instance MatchObject. Sans entrer dans les dtails
propres au langage orient objet, si on utilise cette instance dans un test, il sera considr
comme vrai. Regardez cet exemple dans lequel on va rechercher le motif tigre dans la chane
de caractres "girafe tigre singe" :
>>> import re

13 Expressions rgulires et parsing 13.2 Module re et fonction search

>>> re.search('tigre', animaux)
<_sre.SRE_Match object at 0x7fefdaefe2a0>
>>> if re.search('tigre', animaux):
... print "OK"
...
OK
Fonction match()
Il existe aussi la fonction match() dans le module re qui fonctionne sur le modle de
search(). La diffrence est quelle renvoie une instance MatchObject seulement lorsque
lexpression rgulire correspond (match) au dbut de la chane ( partir du premier caractre).

>>> re.search('tigre', animaux)
<_sre.SRE_Match object at 0x7fefdaefe718>
>>> re.match('tigre', animaux)
Nous vous recommandons plutt lusage de la fonction search(). Si vous souhaitez avoir
une correspondance avec le dbut de la chane, vous pouvez toujours utiliser laccroche de
dbut de ligne ^.
Compilation dexpressions rgulires

Il est aussi commode de pralablement compiler lexpression rgulire laide de la fonction
compile() qui renvoie un objet de type expression rgulire :
>>> regex = re.compile("^tigre")

>>> regex
<_sre.SRE_Pattern object at 0x7fefdafd0df0>
On peut alors utiliser directement cet objet avec la mthode search() :

>>> regex.search(animaux)
>>> animaux = "tigre singe"
<_sre.SRE_Match object at 0x7fefdaefe718>
>>> animaux = "singe tigre"
Groupes
Python renvoie un objet MatchObject lorsquune expression rgulire trouve une cor-
respondance dans une chane pour quon puisse rcuprer des informations sur les zones de
correspondance.
>>> regex = re.compile('([0-9]+)\.([0-9]+)')

>>> resultat = regex.search("pi vaut 3.14")
>>> resultat.group(0)
'3.14'
'3'

13.2 Module re et fonction search 13 Expressions rgulires et parsing
'14'
>>> resultat.start()
8
>>> resultat.end()
12
Dans cet exemple, on recherche un nombre compos

de plusieurs chiffres [0-9]+,
suivi dun point \. (le point a une signification comme mtacaractre, donc il faut lchap-
per avec \ pour quil ait une signification de point),
suivi dun nombre plusieurs chiffres [0-9]+.
Les parenthses dans lexpression rgulire permettent de crer des groupes qui seront r-
cuprs ultrieurement par la fonction group(). La totalit de la correspondance est donn
par group(0), le premier lment entre parenthse est donn par group(1) et le second par
group(2).
Les fonctions start() et end() donnent respectivement la position de dbut et de fin de
la zone qui correspond lexpression rgulire. Notez que la fonction search() ne renvoie
que la premire zone qui correspond lexpression rgulire, mme sil en existe plusieurs :
>>> resultat = regex.search("pi vaut 3.14 et e vaut 2.72")

'3.14'
Fonction findall()
Pour rcuprer chaque zone, vous pouvez utiliser la fonction findall() qui renvoie une
liste des lments en correspondance.
>>> regex = re.compile('[0-9]+\.[0-9]+')

>>> resultat = regex.findall("pi vaut 3.14 et e vaut 2.72")
>>> resultat
['3.14', '2.72']
>>> regex = re.compile('([0-9]+)\.([0-9]+)')
>>> resultat = regex.findall("pi vaut 3.14 et e vaut 2.72")
>>> resultat
[('3', '14'), ('2', '72')]
Fonction sub()
Enfin, la fonction sub() permet deffectuer des remplacements assez puissants. Par dfaut
la fonction sub(chaine1,chaine2) remplace toutes les occurrences trouves par lexpres-
sion rgulire dans chaine2 par chaine1. Si vous souhaitez ne remplacer que les n premires
occurrences, utilisez largument count=n :
>>> regex.sub('quelque chose',"pi vaut 3.14 et e vaut 2.72")

'pi vaut quelque chose et e vaut quelque chose'
>>> regex.sub('quelque chose',"pi vaut 3.14 et e vaut 2.72", count=1)
'pi vaut quelque chose et e vaut 2.72'
Nous esprons que vous tes convaincus de la puissance du module re et des expressions
rgulires, alors vos expressions rgulires !

13.3 Exercices : extraction des gnes dun fichier genbank
13.3 Exercices : extraction des gnes dun fichier genbank

Pour les exercices suivants, vous utiliserez le module dexpressions rgulires re et le fichier
genbank du chromosome I de la levure du boulanger Saccharomyces cerevisiae NC_001133.gbk.
1. crivez un script qui extrait lorganisme du fichier genbank NC_001133.gbk.
2. Modifiez le script prcdent pour quil affiche toutes les lignes qui indiquent lemplace-
ment du dbut et de la fin des gnes, du type :
gene 58..272
3. Faites de mme avec les gnes complmentaires :
gene complement(55979..56935)
4. Rcuprez maintenant la squence nuclique et affichez-la lcran. Vrifiez que vous
navez pas fait derreur en comparant la taille de la squence extraite avec celle indique
dans le fichier genbank.
5. Mettez cette squence dans une liste et rcuprez les deux premiers gnes (en les affi-
chant lcran). Attention, le premier gne est un gne complmentaire, noubliez pas de
prendre le complmentaire inverse de la squence extraite.
6. partir de toutes ces petites oprations que vous transformerez en fonctions, concevez un
programme genbank2fasta.py qui extrait tous les gnes dun fichier genbank fourni
en argument et les affiche lcran. Pour cela vous pourrez utiliser tout ce que vous avez
vu jusqu prsent (fonctions, listes, modules, etc.).
7. partir du script prcdent, refaites le mme programme (genbank2fasta.py) en cri-
vant chaque gne au format fasta dans un fichier.
Pour rappel, lcriture dune squence au format fasta est le suivant :
>ligne de commentaire
sequence sur une ligne de 80 caractres maxi
suite de la squence .......................
suite de la squence .......................
Vous utiliserez comme ligne de commentaire le nom de lorganisme, suivi du numero du
gne, suivi des positions de dbut et de fin du gne, comme dans cet exemple
>Saccharomyces cerevisiae 1 1807 2169
Les noms des fichiers fasta seront de la forme gene1.fasta, gene2.fasta, etc.

14 Cration de modules
14 Cration de modules
14.1 Cration
Vous pouvez crez votres propres modules trs simplement en Python. Il vous suffit dcrire
un ensemble de fonctions (et/ou de variables) dans un fichier, puis denregistrer celui-ci avec
une extension .py (comme nimporte quel script Python). titre dexemple, voici le contenu
du module message.py.
"""Module inutile qui affiche des messages :-)

"""
def Bonjour(nom):
"""Affiche bonjour !
"""
return "bonjour " + nom
def Ciao(nom):
"""Affiche ciao !
"""
return "ciao " + nom
def Hello(nom):
"""Affiche hello !
"""
return "hello " + nom + " !"
date=16092008
14.2 Utilisation
Pour appeler une fonction ou une variable de ce module, il faut que le fichier message.py
soit dans le rpertoire courant (dans lequel on travaille) ou bien dans un rpertoire indiqu
par la variable denvironnement Unix PYTHONPATH. Ensuite, il suffit dimporter le module et
toutes ses fonctions (et variables) vous sont alors accessibles.
La premire fois quun module est import, Python cre un fichier avec une extension .pyc
(ici message.pyc) qui contient le bytecode (code prcompil) du module.
Lappel du module se fait avec la commande import message. Notez que le fichier est
bien enregistr avec une extension .py et pourtant on ne la prcise pas lorsquon importe le
module. Ensuite on peut utiliser les fonctions comme avec un module classique.
>>> import message

>>> message.Hello("Joe")
'hello Joe !'
>>> message.Ciao("Bill")
'ciao Bill'
>>> message.Bonjour("Monsieur")
'bonjour Monsieur'
>>> message.date
16092008
Les commentaires (entre triple guillemets) situs en dbut de module et sous chaque fonc-
tion permettent de fournir de laide invoque ensuite par la commande help() :

14 Cration de modules 14.3 Exercices
>>> help(message)
NAME
message - Module inutile qui affiche des messages :-)
FILE
/home/cumin/poulain/message.py
FUNCTIONS
Hello(nom)
Affiche hello !
Bonjour(nom)
Affiche bonjour !
Ciao(nom)
Affiche ciao !
DATA
date = 16092008
Remarques :
Les fonctions dans un module peuvent sappeler les unes les autres.
Les fonctions dans un module peuvent appeler des fonctions situes dans un autre mo-
dule sil a t pralablement import avec la commande import.
Vous voyez que les modules sont dune simplicit enfantine crer. Si vous avez des fonc-
tions que vous serez amens utiliser souvent, nhsitez plus !
14.3 Exercices
Conseil : pour cet exercice, crivez un script dans un fichier, puis excutez-le dans un shell.
1. Reprenez lensemble des fonctions qui grent le traitement de squences nucliques et
incluez-les dans un module adn.py. Testez-les au fur et mesure.

15 Autres modules dintrt
15 Autres modules dintrt

Nous allons voir dans cette section deux modules qui peuvent se rvler trs pratiques.
Le premier (urllib2) permet de tlcharger nimporte quel fichier depuis internet. Le second
(pickle) permet denregistrer des objets python pour pouvoir les retrouver tels quels plus
tard. Ces deux modules sont prsents par dfaut dans nimporte quelle distribution Python.
15.1 Module urllib2

Les modules urllib et urllib2 permettent de rapatrier, directement avec Python, des fichiers
depuis internet. Nous naborderons ici que des exemples simples, mais libre vous dapprofon-
dir si besoin. Il existe des diffrences subtiles entre urllib et urllib2 que nous naborderons
pas ici mais qui sont consultables sur la documentation officielle de Python. Dans ce cours,
nous avons choisi de vous prsenter urllib2 car une des fonctions principales (urlopen())
est considre comme obsolte dans urllib depuis la version 2.6 de Python.
Prenons un exemple simple, supposons que vous souhaitiez rapatrier le fichier PDB de la
protine barstar. En Unix vous utiliseriez probablement la commande wget, regardez comment
faire en Python :
>>> import urllib2

>>> u = urllib2.urlopen("http://www.pdb.org/pdb/files/1BTA.pdb")
>>> pdb_lines = u.readlines()
>>> u.close()
>>> for line in pdb_lines:
... print line,
...
HEADER RIBONUCLEASE INHIBITOR 09-MAY-94 1BTA
TITLE THREE-DIMENSIONAL SOLUTION STRUCTURE AND 13C ASSIGNMENTS OF
TITLE 2 BARSTAR USING NUCLEAR MAGNETIC RESONANCE SPECTROSCOPY
COMPND MOL_ID: 1;
COMPND 2 MOLECULE: BARSTAR;
COMPND 3 CHAIN: A;
COMPND 4 ENGINEERED: YES
SOURCE MOL_ID: 1;
SOURCE 2 ORGANISM_SCIENTIFIC: BACILLUS AMYLOLIQUEFACIENS;
SOURCE 3 ORGANISM_TAXID: 1390
[...]
>>>
Comme vous le voyez, il suffit dutiliser la fonction urlopen() et de lui passer en argu-
ment une URL (i.e. adresse internet) sous forme de chane de caractres. Ds lors, les mthodes
associes aux fichiers (cf chapitre 6) sont accessibles (read(), readline(), readlines(),
etc.).
Il est galement possible denregistrer le fichier tlcharg :
>>> import urllib2

>>> u = urllib2.urlopen("http://www.pdb.org/pdb/files/1BTA.pdb")
>>> pdb_file_content = u.read()
>>> u.close()
>>> f = open("1BTA.pdb","w")
>>> f.write(pdb_file_content)
>>> f.close()

15 Autres modules dintrt 15.2 Module pickle
Dans ce dernier exemple, nous rcuprons le fichier complet sous la forme dune chane de
caractres unique (avec la fonction read()). Le fichier est ensuite enregistr dans le rpertoire
courant (duquel vous avez lanc linterprteur Python). Nous vous laissons imaginer comment
faire sur une srie de plusieurs fichiers (cf. exercices).
15.2 Module pickle

Le module pickle permet deffectuer une srialisation et dsrialisation des donnes. Il
sagit en fait dencoder (dune manire particulire) les objets que lon peut crer en Python
(variables, listes, dictionnaires, fonctions, classes, etc.) afin de les stocker dans un fichier, puis
de les rcuprer, sans devoir effectuer une tape de parsing.
15.2.1 Codage des donnes

Pour encoder des donnes avec pickle et les envoyer dans un fichier, on peut utiliser la
fonction dump(obj,file) (o file est un fichier dj ouvert) :
>>> import pickle

>>> fileout = open("mydata.dat","w")
>>> maliste = range(10)
>>> mondico = {'year': 2000, 'name': 'Far beyond driven', 'author': 'Pantera',
'style': 'Trash Metal'}
>>> pickle.dump(maliste,fileout)
>>> pickle.dump(mondico,fileout)
>>> pickle.dump(3.14,fileout)
>>> fileout.close()
Si on observe le fichier cr, on saperoit que les donnes sont codes :
>>> import os
>>> os.system("cat mydata.dat")
(lp0
I0
aI1
aI2
aI3
aI4
aI5
aI6
aI7
aI8
aI9
a.(dp0
S'style'
p1
S'Trash Metal'
p2
sS'author'
p3
S'Pantera'
p4
sS'name'
p5

15.3 Exercices 15 Autres modules dintrt
S'Far beyond driven'

p6
sS'year'
p7
I2000
s.F3.1400000000000001
.0
>>>
15.2.2 Dcodage des donnes

Pour dcoder les donnes, rien de plus simple, il suffit dutiliser la fonction load(file)
o file est un fichier ouvert en lecture :
>>> filein = open("mydata.dat")

>>> pickle.load(filein)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
{'style': 'Trash Metal', 'year': 2000, 'name': 'Far beyond driven',
'author': 'Pantera'}
3.1400000000000001
Attention ne pas utiliser la fonction load une fois de trop, sinon une erreur est gnre :
File "/usr/lib/python2.5/pickle.py", line 1370, in load
return Unpickler(file).load()
File "/usr/lib/python2.5/pickle.py", line 858, in load
dispatch[key](self)
File "/usr/lib/python2.5/pickle.py", line 880, in load_eof
raise EOFError
EOFError
>>>
Il est noter quil existe un module quivalent mais beaucoup plus rapide, le module cpi-
ckle.
15.3 Exercices
1. Concevez un script qui rapatrie de manire automatique le fichier 1MSE.pdb depuis la
Protein Data Bank ( laide du module urllib2).
2. On souhaite rcuprer les structure 3D de la partie N-terminale de la protine HSP90 en
prsence de diffrents co-cristaux, les codes PDB sont 3K97, 3K98 et 3K99. crivez un
script Python qui tlcharge de manire automatique les fichiers PDB ( laide du module
urllib2 et dune boucle) et les enregistre dans le rpertoire courant.
3. Reprenez le dictionnaire des mots de 4 lettres du gnome du chromosome I de la levure S.
cerevisiae (exercice 7 sur les dictionnaires et tuples). Encodez le dictionnaire dans un fichier
avec le module pickle. Quittez Python et regardez attentivement le fichier gnr avec
un diteur de texte. Relancez Python, et dcodez le dictionnaire.

16 Modules dintrt en bioinformatique
16 Modules dintrt en bioinformatique

Nous allons voir dans cette section quelques modules trs importants en bioinformatique.
Le premier numpy permet notamment de manipuler des vecteurs et des matrices en Python.
Le module biopython permet de travailler sur des donnes biologiques type squence (nu-
clique et protique) ou structure (fichier PDB). Le module matplotlib permet de dessiner
des graphiques depuis Python. Enfin, le module rpy permet dinterfacer nimporte quelle fonc-
tion du puissant programme R.
Ces modules ne sont pas fournis avec le distribution Python de base (contrairement tous
les autres modules vus prcdemment). Nous ne nous tendrons pas sur la manire de les
installer. Consultez pour cela la documentation sur les sites internet des modules en question.
Sachez cependant que ces modules existent dans la plupart des distributions Linux rcentes.
Dans ce chapitre, nous vous montrererons quelques exemples dutlisation de ces modules
pour vous convaincre de leur pertinence.
16.1 Module numpy

Le module numpy est incontournable en bioinformatique. Il permet deffectuer des calculs
sur des vecteurs ou des matrices, lment par lment, via un nouveau type dobjet appel
array. Ce module contient des fonctions de base pour faire de lalgbre linaire, des transfor-
mes de Fourier ou encore des tirages de nombre alatoire plus sophistiqus quavec le module
random. Vous pourrez trouver les sources de numpy cette adresse. Notez quil existe un autre
module scipy que nous naborderons pas dans ce cours. scipy est lui mme bas sur numpy,
mais il en tend considrablement les possibilits de ce dernier (e.g. statistiques, optimisation,
intgration numrique, traitement du signal, traitement dimage, algorithmes gntiques, etc.).
16.1.1 Objets de type array

Les objets de type array correspondent des tableaux une ou plusieurs dimensions et
permettent deffectuer du calcul vectoriel. La fonction array() permet la conversion dun
objet squentiel (type liste ou tuple) en un objet de type array. Voici un exemple simple de
conversion dune liste une dimension en objet array :
>>> import numpy

>>> a = [1,2,3]
>>> numpy.array(a)
array([1, 2, 3])
>>> b = numpy.array(a)
>>> type(b)
<type 'numpy.ndarray'>
>>> b
array([1, 2, 3])
Nous avons converti la liste a en array, mais cela aurait donn le mme rsultat si on
avait converti le tuple (1,2,3). Par ailleurs, vous voyez que lorsquon demande Python
le contenu dun objet array, les symboles ([]) sont utiliss pour le distinguer dune liste [] ou
dun tuple ().
Notez quun objet array ne peut contenir que des valeurs numriques. Vous ne pouvez pas,
par exemple, convertir une liste contenant des chanes de caractres en objet de type array.
La fonction arange() est quivalente range() et permet de construire un array une

dimension de manire simple.

16.1 Module numpy 16 Modules dintrt en bioinformatique
>>> numpy.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> numpy.arange(10.0)
array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])
>>> numpy.arange(10,0,-1)
array([10, 9, 8, 7, 6, 5, 4, 3, 2, 1])
>>>
Un des avantages de la fonction arange() est quelle permet de gnrer des objets array
qui contiennent des entiers ou de rels selon largument quon lui passe.
La diffrence fondamentale entre un objet array une dimension et une liste (ou un tuple) est
que celui-ci est considr comme un vecteur. Par consquent on peut effectuer des oprations
lment par lment dessus, ce qui est bien commode lorsquon analyse de grandes quantits
de donnes. Regardez ces exemples :
>>> v = numpy.arange(4)
>>> v
array([0, 1, 2, 3])
>>> v + 1
array([1, 2, 3, 4])
>>> v + 0.1
array([ 0.1, 1.1, 2.1, 3.1])
>>> v * 2
array([0, 2, 4, 6])
>>> v * v
array([0, 1, 4, 9])
Notez bien sur le dernier exemple de multiplication que larray final correspond la multi-
plication lment par lment des deux array initiaux. Avec les listes, ces oprations nauraient
t possibles quen utilisant des boucles ! Nous vous encourageons donc utiliser dornavent
les objets array lorsque vous aurez besoin de faire des oprations lment par lment.
Il est aussi possible de construire des objets array deux dimensions, il suffit de passer en
argument une liste de listes la fonction array() :
>>> numpy.array([[1,2,3],[2,3,4],[3,4,5]])
array([[1, 2, 3],
[2, 3, 4],
[3, 4, 5]])
>>>
Attention, plus complexe encore ! On peut aussi crer des tableaux trois dimensions en
passant la fonction array() une liste de listes de listes :
>>> numpy.array([[[1,2],[2,3]],[[4,5],[5,6]]])
array([[[1, 2],
[2, 3]],
[[4, 5],
[5, 6]]])
>>>

16 Modules dintrt en bioinformatique 16.1 Module numpy
La fonction array() peut crer des tableaux nimporte quel nombre de dimensions. Tou-
tefois a devient vite compliqu lorsquon dpasse trois dimensions. Retenez quun objet array
une dimension peut tre considr comme un vecteur et un array deux dimensions comme
une matrice.
Pour rcuprer un ou plusieurs lment(s) dun objet array, vous pouvez utiliser lindiage
ou les tranchage, de la mme manire que pour les listes.
>>> a = numpy.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a[5:]
array([5, 6, 7, 8, 9])
>>> a[::2]
array([0, 2, 4, 6, 8])
>>> a[1]
1
Dans le cas dun objet array deux dimensions, vous pouvez rcuprer une ligne, une co-
lonne ou bien un seul lment.
>>> a = numpy.array([[1,2],[3,4]])
>>> a
array([[1, 2],
[3, 4]])
>>> a[:,0]
array([1, 3])
>>> a[0,:]
array([1, 2])
>>> a[1,1]
4
La syntaxe a[m,:] rcupre la ligne m-1, et a[:,n] rcupre la colonne n-1. Les tranches
sont videmment aussi utilisables sur un tableau deux dimensions.
Il peut tre parfois pnible de construire une matrice (array deux dimensions) laide
dune liste de listes. Le module numpy contient quelques fonctions commodes pour construire
des matrices partir de rien. Les fonctions zeros() et ones() permettent de construire des
objets array contenant des 0 ou de 1, respectivement. Il suffit de leur passer un tuple indiquant
la dimensionnalit voulue.
>>> numpy.zeros((3,3))
array([[ 0., 0., 0.],
[ 0., 0., 0.],
[ 0., 0., 0.]])
>>> numpy.zeros((3,3),int)
array([[0, 0, 0],
[0, 0, 0],
[0, 0, 0]])
>>> numpy.ones((3,3))
array([[ 1., 1., 1.],
[ 1., 1., 1.],
[ 1., 1., 1.]])

16.1 Module numpy 16 Modules dintrt en bioinformatique
Par dfaut, les fonctions zeros() et ones() gnrent des rels, mais vous pouvez deman-
der des entiers en passant loption int en second argument.
Enfin il existe les fonctions reshape() et resize() qui permettent de remanier volont
les dimensions dun array. Il faut pour cela, leur passer en argument lobjet array remanier
ainsi quun tuple indiquant la nouvelle dimensionnalit.
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8])
>>> numpy.reshape(a,(3,3))
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
Toutefois, reshape() attend un tuple dont la dimension est compatible avec le nombre
dlments contenus dans larray de dpart, alors que resize() sen moque et remplira le
nouvel objet array gnr mme si les longueurs ne coincident pas.
>>> a.reshape((2,2))
ValueError: total size of new array must be unchanged
>>> numpy.resize(a,(2,2))
array([[0, 1],
[2, 3]])
>>> numpy.resize(a,(4,4))
array([[0, 1, 2, 3],
[4, 5, 6, 7],
[8, 0, 1, 2],
[3, 4, 5, 6]])
Dans lexemple prcdent, la fonction reshape() renvoie une erreur si les dimensions ne
concident pas. La fonction resize() duplique ou coupe la liste initiale sil le faut jusqu
temps que le nouvel array soit rempli.
Si vous ne vous souvenez plus de la dimension dun objet array, la fonction shape() per-
met den retrouver la taille.
>>> numpy.shape(a)
(3,)
Enfin, la fonction transpose() renvoie la transpose dun array. Par exemple pour une
matrice :
>>> a
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
>>> numpy.transpose(a)
array([[1, 4, 7],
[2, 5, 8],
[3, 6, 9]])

16 Modules dintrt en bioinformatique 16.1 Module numpy
16.1.2 Un peu dalgbre linaire

Aprs avoir manipul les vecteurs et les matrices, voici quelques fonctions pour faire de
lalgbre linaire.
La fonction dot() vous permet de faire une multiplication de matrices.
>>> a = numpy.resize(numpy.arange(4),(2,2))
>>> a
array([[0, 1],
[2, 3]])
>>> numpy.dot(a,a)
array([[ 2, 3],
[ 6, 11]])
>>> a * a
array([[0, 1],
[4, 9]])
Notez bien que dot(a,a) renvoie le produit matriciel entre deux matrices, alors que a*a
renvoie le produit lment par lment 1 .
Pour toutes les oprations suivantes, il faudra utiliser des fonctions dans le sous-module
numpy.linalg. La fonction inv() renvoie linverse dune matrice carre, det() son dter-
minant, eig() ses vecteurs et valeurs propres.
>>> a
array([[0, 1],
[2, 3]])
>>> numpy.linalg.inv(a)
array([[-1.5, 0.5],
[ 1. , 0. ]])
>>> numpy.linalg.det(a)
-2.0
>>> numpy.linalg.eig(a)
(array([-0.56155281, 3.56155281]), array([[-0.87192821, -0.27032301],
[ 0.48963374, -0.96276969]]))
>>> numpy.linalg.eig(a)[0]
array([-0.56155281, 3.56155281])
>>> numpy.linalg.eig(a)[1]
array([[-0.87192821, -0.27032301],
[ 0.48963374, -0.96276969]])
Notez que la fonction eig() renvoie un tuple dont le premier lment correspond aux
valeurs propres et le second lment aux vecteurs propres.
16.1.3 Un peu de transforme de Fourier

La transforme de Fourier est trs utilise pour lanalyse de signaux, notamment lorsquon
souhaite extraire des priodicits au sein dun signal bruit. Le module numpy possde la fonc-
tion fft() (dans le sous-module fft) permettant de calculer des transformes de Fourier.
Voici un petit exemple sur la fonction cosinus de laquelle on souhaite extraire la priode
laide de la fonction fft() :
1. Dans numpy, il existe galement des objets de type matrix pour lesquels les multiplications de matrices sont
diffrents, mais nous ne les aborderons pas ici.

16.2 Module biopython 16 Modules dintrt en bioinformatique
# 1) on definit la fonction y = cos(x)

import numpy
debut = -2 * numpy.pi
fin = 2 * numpy.pi
pas = 0.1
x = numpy.arange(debut,fin,pas)
y = numpy.cos(x)
# 2) on calcule la TF de la fonction cosinus

TF=numpy.fft.fft(y)
ABSTF = numpy.abs(TF)
# abcisse du spectre en radian^-1
pas_xABSTF = 1/(fin-debut)
x_ABSTF = numpy.arange(0,pas_xABSTF * len(ABSTF),pas_xABSTF)
Plusieurs commentaires sur cet exemple.

Vous constatez que numpy redfinit certaines fonctions ou constantes mathmatiques de
base, comme pi (nombre ), cos() (fonction cosinus) ou abs() (valeur absolue, ou mo-
dule dun complexe). Ceci est bien pratique car nous navons pas appeler ces fonctions
ou constantes depuis le module math, le code en est ainsi plus lisible.
Dans la partie 1), on dfinit le vecteur x reprsentant un angle allant de -2 2 radians
par pas de 0,1 et le vecteur y comme le cosinus de x.
En 2) on calcule la transforme de Fourier avec la fonction fft() qui renvoie un vec-
teur (objet array une dimension) de nombres complexes. Eh oui, le module numpy gre
aussi les nombres complexes ! On extrait ensuite le module du rsultat prcdent avec la
fonction abs().
La variable x_ABSTFL reprsente labscisse du spectre (en radian-1).
La variable ABSTF contient le spectre lui mme. Lanalyse de ce dernier nous donne un
pic 0,15 radian-1, ce qui correspond bien 2 (plutt bon signe de retrouver ce rsultat).
Le graphe de ce spectre est prsent dans la partie ddie matplotlib (section 16.3).
Notez que tout au long de cette partie, nous avons toujours utilis la syntaxe numpy.fonction()
pour bien vous montrer quelles taient les fonctions propres numpy. Bien sr dans vos futurs
scripts il sera plus commode dimporter compltement le module numpy avec linstruction
from numpy import *. Vous pourrez ensuite appeler les fonctions de numpy directement
(sans le prfixe numpy.).
Si vous souhaitez quand mme spcifier pour chaque fonction numpy son module dappar-
tenance, vous pouvez dfinir un alias pour numpy avec linstruction import numpy as np.
Le module numpy est alors connu sous le nom np. Par lappel de la fonction array() se fera
par np.array().
16.2 Module biopython

Le module biopython propose de nombreuses fonctionnalits trs utiles en bioinformatique.
Le tutoriel est particulirement bien fait, nhsitez pas le consulter.
Voici quelques exemples dutilisation.
Dfinition dune squence.
>>> import Bio
>>> from Bio.Seq import Seq
>>> from Bio.Alphabet import IUPAC
>>> ADN = Seq("ATATCGGCTATAGCATGCA", IUPAC.unambiguous_dna)
>>> ADN
Seq('ATATCGGCTATAGCATGCA', IUPACUnambiguousDNA())

16 Modules dintrt en bioinformatique 16.3 Module matplotlib
IUPAC.unambiguous_dna signifie que la squence entre est bien une squence dADN.
Obtention de la squence complmentaire et complmentaire inverse.
>>> ADN.complement()
Seq('TATAGCCGATATCGTACGT', IUPACUnambiguousDNA())
>>> ADN.reverse_complement()
Seq('TGCATGCTATAGCCGATAT', IUPACUnambiguousDNA())
Traduction en squence protique.
>>> ADN.translate()
Seq('ISAIAC', IUPACProtein())
16.3 Module matplotlib
Le module matplotlib permet de gnrer des graphes interactifs depuis Python. Il est loutil
complmentaire de numpy et scipy lorsquon veut faire de lanalyse de donnes.
Nous ne prsenterons ici quun petit exemple traitant de la reprsentation graphique de la
fonction cosinus et de la recherche de sa priode par transforme de Fourier (voir galement la
section 16.1.3).
Plutt quun long discours, regardez cet exemple que nous commenterons aprs.
# define cosine function

from pylab import *
debut = -2 * pi
fin = 2 * pi
pas = 0.1
x = arange(debut,fin,pas)
y = cos(x)
# draw the plot

plot(x,y)
xlabel('angle (rad)')
ylabel('cos(angle)')
title('Fonction: y = cos(x)')
grid()
show()
Vous devriez obtenir une image comme celle-ci :

16.3 Module matplotlib 16 Modules dintrt en bioinformatique
Vous constatez que le module matplotlib gnre un fentre graphique interactive per-
mettant lutilisateur de votre script de manipuler le graphe (enregistrer comme image, zoo-
mer, etc.).
Revenons maintenant sur le code. Tout dabord, vous voyez quon importe le module sap-
pelle pylab (et non pas matplotlib). Le module pylab importe lui-mme toutes les fonc-
tions (et variables) du module numpy (e.g. pi, cos, arange, etc.). Il est plus commode de
limporter par from pylab import * que par import pylab.
La partie qui nous intresse (aprs la ligne # draw the plot) contient les parties spci-
fiques matplotlib. Vous constatez que les commandes sont trs intuitives.
La fonction plot() va gnrer un graphique avec des lignes et prend comme valeurs en
abscisse (x) et en ordonnes (y) des vecteurs de type array une dimension.
Les fonctions xlabel() et ylabel() sont utiles pour donner un nom aux axes.
title() permet de dfinir le titre du graphique.
grid() affiche une grille en filligrane.
Jusquici, aucun graphe nest affich. Pour activer laffichage lcran du graphique, il
faut appeler la fonction show(). Celle-ci va activer une boucle dite gtk qui attendra les
manipulations de lutilisateur.
Les commandes Python ventuellement situes aprs la fonction show() seront excu-
tes seulement lorsque lutilisateur fermera la fentre graphique (petite croix en haut
droite).
Voici maintenant lexemple complet sur la fonction cosinus et sa transforme de Fourier.
from pylab import *
# define cosine function

x = arange(-2*pi,2*pi,0.1)
y = cos(x)
# calculate TF of cosine function

TF=fft(y)

16 Modules dintrt en bioinformatique 16.4 Module rpy
ABSTF = abs(TF)
pas_xABSTF = 1/(4*pi)
x_ABSTF = arange(0,pas_xABSTF * len(ABSTF),pas_xABSTF)
# draw cos plot

plot(x,y)
xlabel('angle (rad)')
ylabel('cos(angle)')
title('Fonction: y = cos(x)')
grid()
show()
# plot TF of cosine
plot(x_ABSTF[:20],ABSTF[:20])
xlabel('inverse angle (rad^-1)')
ylabel('Intensity')
title('Spectrum of cosine function')
grid()
show()
Le premier graphe doit afficher la fonction cosinus comme ci-dessus et le second doit res-
sembler cela :
On retrouve bien le pic 0,15 radian-1 correspondant 2 radians. Voil, nous esprons que
ce petit exemple vous aura convaincu de lutilit du module matplotlib. Sachez quil peut
faire bien plus, par exemple gnrer des histogrammes ou toutes sortes de graphiques utiles en
analyse de donnes.
16.4 Module rpy

R est un programme extrmement puissant permettant deffectuer des analyses statistiques.
Il contient tout un tas de fonctions permettant de gnrer divers types de graphiques. Nous

16.4 Module rpy 16 Modules dintrt en bioinformatique
ne rentrerons pas dans les dtails de R, mais nous vous montrerons quelques exemples pour
gnrer des graphiques avec R depuis Python.
Les vecteurs de R peuvent tre remplacs par des listes en Python. En interne, rpy manipule
des variables de types array car il est bas sur le module numpy vu prcdemment. Dans cet
exemple, nous allons trac les coordonnes alatoires de 50 points.
import random
import rpy
# construction d'une liste de 50 lments croissants
x = range(1, 51)
# construction d'une liste de 50 lments alatoires
y = []
for i in x:
y.append( random.random() )
# enregistrement du graphique dans un fichier png

rpy.r.png("rpy_test1.png")
# dessin des points
rpy.r.plot(x, y, xlab="position", ylab="coordonnes", col="black", pch=3)
# fin du graphique
rpy.r.dev_off()
Voici le fichier rpy_test1.png obtenu :
Les fonctions R sont accessibles par le sous-module r du module rpy. Les fonctions png() et
plot() sont utilisables comme en R. Les fonctions qui contiennent un point dans leur nom en
R (dev.off()) sont utilisables avec un caractre soulign _ la place (ici dev_off()).
Voyons maintenant un exemple plus intressant, pour lequel on calcule la distribution des
diffrentes bases dans une squence nuclique :
from rpy import r as R

seq = "ACGATCATAGCGAGCTACGTAGAA"
seq2 = list( seq )

16 Modules dintrt en bioinformatique 16.5 Exercice numpy
R.png("rpy_test2.png")
# tri des bases car unique() n'ordonne pas les donnes
# alors que table() le fait
seq3 = R.sort( seq2 )
# listes des bases prsentes
bases = R.unique( seq3 )
# effectif de chaque base
effectifs = R.table( seq3 )
# dessin du barplot et sauvegarde de la position des abscisses
coords = R.barplot( effectifs, ylab="nombre de bases")
# ajout du texte pour l'axe des abscisses
R.text(coords, -0.5, bases, xpd = True, cex = 1.5, font = 2 )
R.dev_off()
Voici le fichier rpy_test2.png obtenu :
Pour plus de concision, le module rpy.r est renom en R. Les boolens TRUE et FALSE en
R (dans la fonction text()) doivent tre remplacs par leurs quivalents en Python (True et
False ; attention la casse).
16.5 Exercice numpy

Cet exercice prsente le calcul de la distance entre deux carbones alpha conscutifs de la
barstar. Il demande quelques notions dUnix et ncessite le module numpy de Python.
1. Tlchargez le fichier 1BTA.pdb sur le site de la PDB.
2. Pour que le sparateur dcimal soit le point (au lieu de la virgule, par dfaut sur les
systmes dexploitation franais), il faut au pralable redfinir la variable LC_NUMERIC
en bash :
export LC_NUMERIC=C
Extrayez les coordonnes atomiques de tous les carbones alpha de la barstar dans le fi-
chier 1BTA_CA.txt avec la commande Unix suivante :
awk '$1=="ATOM" && $3=="CA" {printf "%.3f %.3f %.3f ", $7, $8, $9}' 1BTA.pdb > 1BTA_CA.txt
Les coordonnes sont toutes enregistres sur une seul ligne, les unes aprs les autres, dans
le fichier 1BTA_CA.txt.

16.6 Exercice rpy 16 Modules dintrt en bioinformatique
3. Ouvrez le fichier 1BTA_CA.txt avec Python et crez une liste contenant toutes les coor-
donnes sous forme de rels avec les fonctions split() et float().
4. Avec la fonction array() du module numpy, convertissez cette liste en matrice.
5. Avec la fonction reshape() de numpy, et connaissant le nombre dacides amins de la
barstar, construisez une matrice deux dimensions contenant les coordonnes des car-
bones alpha.
6. Crez une matrice qui contient les coordonnes des n-1 premiers carbones alpha et une
autre qui contient les coordonnes des n-1 derniers carbones alpha.
7. En utilisant les oprateurs mathmatiques habituels (-, **2, +) et les fonctions sqrt() et
sum() du module numpy, calculez la distance entre les atomes n et n+1.
8. Affichez les distances entre carbones alpha conscutifs et reprez la valeur surprenante.
16.6 Exercice rpy

1. Soit la squence protique WVAAGALTIWPILGALVILG. Reprsentez avec le module
rpy la distribution des diffrents acides amins.
2. Reprenez lexercice du calcul de la distance entre deux carbones alpha conscutifs de la
barstar avec numpy et reprsentez cette distance avec rpy.

17 Avoir la classe avec les objets
17 Avoir la classe avec les objets

Une classe permet de dfinir des objets qui sont des reprsentants (des instances) de cette
classe. Les objets peuvent possder des attributs (variables associes aux objets) et des m-
thodes ( fonctions associes aux objets).
Exemple de la classe Rectangle :
class Rectangle:
"ceci est la classe Rectangle"
# initialisation d'un objet
# dfinition des attributs avec des valeurs par dfaut
def __init__(self, long = 0.0, larg = 0.0, coul = "blanc"):
self.longueur = long
self.largeur = larg
self.couleur = coul
# definition de la mthode qui calcule la surface
def calculSurface(self):
print "surface = %.2f m2" %(self.longueur * self.largeur)
# definition de la mthode qui transforme un rectangle en carr
def changeCarre(self, cote):
self.longueur = cote
self.largeur = cote
Ici, longueur, largeur et couleur sont des attributs alors que calculPerimetre(),
calculSurface() et changeCarre() sont des mthodes. Tous les attributs et toutes les
mthodes se rfrent toujours self qui dsigne lobjet lui mme. Attention, les mthodes
prennent toujours au moins self comme argument.
Exemples dutilisation de la classe Rectangle :

# cration d'un objet Rectangle avec les paramtres par dfaut
rect1 = Rectangle()
print rect1.longueur, rect1.largeur, rect1.couleur
# sans surprise :
rect1.calculSurface()
# on change le rectangle en carr
rect1.changeCarre(30)
# cration d'un objet Rectangle avec des paramtres imposs
rect2 = Rectangle(2, 3, "rouge")
17.1 Exercices
shell.
1. Entranez-vous avec la classe Rectangle. Crez la mthode calculPerimetre() qui
calcule le primre dun objet rectangle.
2. Crez une nouvelle classe Atome avec les attributs x, y, z (qui contiennent les coor-
donnes atomique) et la mthode calculDistance(). Testez cette classe sur plusieurs
exemples.
3. Amliorez la classe Atome avec de nouveaux attributs (par ex. : masse, charge, etc.) et
de nouvelles mthodes (par ex. : calculCentreMasse(), calculRayonGyration()).

18 Gestion des erreurs

La gestion des erreurs permet dviter que votre programme plante en prvoyant vous
mme les sources derreurs ventuelles.
Voici un exemple dans lequel on demande lutilisateur dentrer un nombre, puis on affiche
ce nombre.
>>> nb = int(raw_input("Entrez un nombre: "))

Entrez un nombre: 23
>>> print nb
23
La fonction raw_input() permet lutilisateur de saisir une chane de caractres. Cette

chane de caractres est ensuite transforme en nombre entier avec la fonction int().
Si lutilisateur ne rentre pas un nombre, voici ce qui se passe :
>>> nb = int(raw_input("Entrez un nombre: "))

Entrez un nombre: ATCG
ValueError: invalid literal for int() with base 10: 'ATCG'
Lerreur provient de la fonction int() qui na pas pu convertir la chane de caractres

"ATCG" en nombre, ce qui est normal.
Le jeu dinstruction try / except permet de tester lexcution dune commande et din-
tervenir en cas derreur.
>>> try:
... nb = int(raw_input("Entrez un nombre: "))
... except:
... print "Vous n'avez pas entr un nombre !"
...
Vous n'avez pas entr un nombre !
Dans cette exemple, lerreur renvoye par la fonction int() (qui ne peut pas convertir
"ATCG" en nombre) est intercepte et dclenche laffichage du message davertissement.
On peut ainsi redemander sans cesse un nombre lutilisateur, jusqu ce que celui-ci en
rentre bien un.
>>> while 1:
... try:
... print "Le nombre est", nb
... break
... except:
... print "Essayez encore"
...
Essayez encore
Entrez un nombre: toto


Essayez encore
Entrez un nombre: 55
Le nombre est 55
Notez que dans cet exemple, linstruction while 1 est une boucle infinie (car la condition
1 est toujours vrifie) dont larrt est forc par la commande break lorsque lutilisateur a
effectivement bien rentr un nombre.
La gestion des erreurs est trs utile ds lors que des donnes extrieures entrent dans le
programme, que ce soit directement par lutilisateur (avec la fonction raw_input()) ou par
des fichiers.
Vous pouvez par exemple vrifier quun fichier a bien t ouvert.
>>> nom = "toto.pdb"
>>> try:
... f = open(nom, "r")
... except:
... print "Impossible d'ouvrir le fichier", nom
Si une erreur est dclenche, cest sans doute que le fichier nexiste pas lemplacement
indiqu sur le disque ou que (sous Unix), vous nayez pas les droits daccs pour le lire.
Il est galement possible de spcifier le type derreur grer. Le premier exemple que nous
avons tudi peut scrire :
>>> try:
... except ValueError:
...
Ici, on intercepte une erreur de type ValueError, ce qui correspond bien un problme de
conversion avec int(). Il existe dautres types derreurs comme RuntimeError, TypeError,
NameError, IOError, etc.
Enfin, on peut aussi tre trs prcis dans le message derreur. Observez la fonction downloadPage()
qui, avec le module urllib2, tlcharge un fichier sur internet.
import urllib2
def downloadPage(address):
error = ""
page = ""
try:
data = urllib2.urlopen(address)
page = data.read()
except IOError, e:
if hasattr(e, 'reason'):
error = "Cannot reach web server: " + str(e.reason)
if hasattr(e, 'code'):
error = "Server failed %d" %(e.code)
return page, error

La variable e est une instance (un reprsentant) de lerreur de type IOError. Certains de
ces attributs sont tests avec la fonction hasattr() pour ainsi affiner le message renvoy (ici
contenu dans la variable error).

19 Trucs et astuces
19 Trucs et astuces
19.1 Shebang et /usr/bin/env python
Lorsque vous programmez sur un sytme Unix, le shebang correspond aux caractres #!
qui se trouve au dbut de la premire ligne dun script. Le shebang est suivi du chemin complet
du programme qui interprte le script.
En Python, on trouve souvent la notation
#! /usr/bin/python
Cependant, lexcutable python ne se trouve pas toujours dans le rpertoire /usr/bin.

Pour maximiser la portabilit de votre script Python sur plusieurs systmes Unix, utilisez plutt
cette notation :
#! /usr/bin/env python
Dans le cas prsent, on appelle le programme denvironnement env (qui se situe toujours
dans le rpertoire /usr/bin) pour lui demander o se trouve lexcutable python.
19.2 Python et utf-8

Si vous utilisez des caractres accentus dans des chanes de caractres ou bien mme dans
des commentaires, cela occasionnera une erreur lors de lexcution de votre script.
Pour viter ce genre de dsagrment, ajoutez la ligne suivante la deuxime ligne (la posi-
tion est importante) de votre script :
# -*- coding: utf-8 -*-
En rsum, tous vos scripts Python devraient ainsi dbuter par les lignes :
# -*- coding: utf-8 -*-
19.3 Vitesse ditration dans les boucles

La vitesse ditration (de parcours) des lements dune liste peut tre trs diffrente selon la
structure de boucle utilise. Pour vous en convaincre, copiez les lignes suivantes dans un script
Python (par exemple boucles.py) puis excutez-le.
# -*- coding: utf-8 -*-
import time
# cration d'une liste de 5 000 000 d'lments

# ( adapter suivant la vitess de vos machines)
taille = 5000000
print "Cration d'une liste avec %d lements" %( taille )
toto = range( taille )
# la variable 'a' accde un lment de la liste
# mthode 1
start = time.time()

19.4 Liste de comprhension 19 Trucs et astuces
for i in range( len(toto) ):

a = toto[i]
print "mthode 1 (for in range) : %.1f secondes" %( time.time() - start )
# mthode 2
start = time.time()
for ele in toto:
a = ele
print "mthode 2 (for in) : %.1f secondes" %( time.time() - start )
# mthode 3
start = time.time()
for i in xrange( len(toto) ):
a = toto[i]
print "mthode 3 (for in xrange) : %.1f secondes" %( time.time() - start )
# mthode 4
start = time.time()
for idx, ele in enumerate( toto ):
a = ele
print "mthode 4 (for in enumerate): %.1f secondes" %( time.time() - start )
Vous devriez obtenir une sortie similaire celle-ci :
poulain@cumin> ./boucles.py
Cration d'une liste avec 5000000 lements
mthode 1 (for in range) : 1.8 secondes
mthode 2 (for in) : 1.0 secondes
mthode 3 (for in xrange) : 1.2 secondes
mthode 4 (for in enumerate): 1.4 secondes
La mthode la plus rapide pour parcourir une liste est donc ditrer directement sur les
lments (for element in liste). Cette instruction est privilgier le plus possible.
La mthode for i in range(len(liste)) est particulirement lente car la commande
range(len(liste)) gnre une norme liste avec tous les indices des lments (la cration
de liste est assez lente en Python). Si vous voulez absolument parcourir une liste avec les in-
dices des lements, utilisez plutt la commande for i in xrange(len(liste)) car lins-
truction xrange() ne va pas crer une liste mais incrmenter un compteur qui correspond
lindice des lments successifs de la liste.
Enfin, la commande for indice, element in enumerate(liste) est particulire-
ment efficace pour rcuprer en mme temps llment et son indice.
19.4 Liste de comprhension

Une manire originale et trs puissante de gnrer des listes est la comprhension de liste.
Pour plus de dtails, consultez ce sujet le site de Python et celui de wikipdia.
Voici quelques exemples :
Nombres pairs compris entre 0 et 99
print [i for i in range(99) if i%2 == 0]
Le mme rsultat est obtenu avec
print range(0,99,2)
ou

19 Trucs et astuces 19.5 Sauvegardez votre historique de commandes
print range(0,99)[::2]
Jeu sur la casse des mots dune phrase.
message = "C'est sympa la BioInfo"
msg_lst = message.split()
print [[m.upper(), m.lower(), len(m)] for m in msg_lst]
Formatage dune squence avec 60 caractres par ligne

# exemple d'une squence de 150 alanines
seq = "A"*150
width= 60
print "\n".join( [seq[i:i+width] for i in range(0,len(seq),width)] )
Formatage fasta dune squence (avec la ligne de commentaire)

commentaire = "mon commentaire"
# exemple d'une squence de 150 alanines.
seq = "A"*150
width= 60
print "> "+commentaire+"\n"+"\n".join( [seq[i:i+width] for i in range(0,len(seq),width)] )
Slection des lignes correspondantes aux carbones alpha dans un fichier pdb
# ouverture du fichier pdb (par exemple 1BTA.pdb)
pdb = open("1BTA.pdb", "r")
# slection des lignes correspondantes aux C alpha
CA_line = [line for line in pdb if line.split()[0] == "ATOM" and line.split()[2] == "CA"]
# fermeture du fichier
pdb.close()
# ventuellement affichage des lignes
print CA_line
19.5 Sauvegardez votre historique de commandes

Vous pouvez sauvegarder lhistorique des commandes utilises dans linterprteur Py-
thon avec le module readline.
>>> print "hello"
hello
>>> a = 22
>>> a = a + 11
>>> print a
33
>>> import readline
>>> readline.write_history_file()
Quittez Python. Lhistorique de toutes vos commandes est dans votre rpertoire person-
nel, dans le fichier .history. Relancez linterprteur Python.
>>> import readline
>>> readline.read_history_file()
Vous pouvez accder aux commandes de la session prcdente avec la flche du haut de
votre clavier.
>>> print "hello"
hello
>>> a = 22
>>> a = a + 11
>>> print a
33

Cours Python

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Cours Python

Hochgeladen von

Copyright:

Verfügbare Formate

Cours de Python

Patrick Fuchs et Pierre Poulain

version du 26 aot 2015

Universit Paris Diderot-Paris 7, Paris, France

Ce document est sous licence Creative Commons BY-SA

2 Cours de Python / Universit Paris Diderot - Paris 7 / UFR Sciences du Vivant

Table des matires

Cours de Python / Universit Paris Diderot - Paris 7 / UFR Sciences du Vivant 3

8.5 Module sys : passage darguments . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

9 Plus sur les chanes de caractres 44

10 Plus sur les listes 50

13 Expressions rgulires et parsing 64

15 Autres modules dintrt 71

4 Cours de Python / Universit Paris Diderot - Paris 7 / UFR Sciences du Vivant

16 Modules dintrt en bioinformatique 74

17 Avoir la classe avec les objets 86

18 Gestion des erreurs 87

Cours de Python / Universit Paris Diderot - Paris 7 / UFR Sciences du Vivant 5

1.2 Premier contact avec Python sous Linux

[fuchs@opera ~]$ python

print "Hello world !"

puis validez votre commande avec la touche Entre.

>>> print "Hello world !"

6 Cours de Python / Universit Paris Diderot - Paris 7 / UFR Sciences du Vivant

1.3 Premier programme Python

print 'Hello World !'

1. Soit donner le nom de votre script comme argument la commande Python :

[fuchs@opera ~]$ python test.py

print 'Hello World !'

[fuchs@opera ~]$ ./test.py

Cours de Python / Universit Paris Diderot - Paris 7 / UFR Sciences du Vivant 7

# votre premier script Python

# d'autres commandes plus utiles pourraient suivre

1.5 Sparateur dinstructions

Omettre lespace entre linstruction print et le chiffre 1 renvoie une erreur.

1.6 Notion de bloc dinstructions et dindentation

8 Cours de Python / Universit Paris Diderot - Paris 7 / UFR Sciences du Vivant

1.7 Python 2 ou Python 3 ?

[fuchs@rome cours_python]$ python

Cours de Python / Universit Paris Diderot - Paris 7 / UFR Sciences du Vivant 9

10 Cours de Python / Universit Paris Diderot - Paris 7 / UFR Sciences du Vivant

Cours de Python / Universit Paris Diderot - Paris 7 / UFR Sciences du Vivant 11

Oprations sur les chanes de caractres

>>> chaine = "Salut"

12 Cours de Python / Universit Paris Diderot - Paris 7 / UFR Sciences du Vivant

>>> chaine + " Python"

Loprateur daddition + permet de concatner (assembler) deux chanes de caractres et

Cours de Python / Universit Paris Diderot - Paris 7 / UFR Sciences du Vivant 13

>>> print nom , 'a' , x , 'ans'

>>> ani1 = 'chat'

3.1 criture formate

>>> propGC = (4500.0 + 2575)/14800

>>> print "La proportion de GC est %.2f" % propGC

14 Cours de Python / Universit Paris Diderot - Paris 7 / UFR Sciences du Vivant

Le signe % est appel une premire fois (%.2f) pour

Vous pouvez aussi formatez des entiers avec %i (i comme integer)

>>> nbG = 4500

ou mettre plusieurs nombres dans une mme chane de caractres.

>>> nbG = 4500

>>> nbG = 4500

>>> print 10 ; print 100 ; print 1000

Cours de Python / Universit Paris Diderot - Paris 7 / UFR Sciences du Vivant 15

>>> print "atom HN" ; print "atom HDE1"

>>> nbG = 4500