Cours de Python

Par Patrick Fuchs

- Pierre Poulain

Date de publication : 17 avril 2012

Dernire mise jour : 27 fvrier 2013

Bienvenue au cours de Python !

Ce cours a t conu l'origine pour les tudiants dbutants en programmation Python des
filires biologie et biochimie de l' Universit Paris Diderot - Paris 7 ; et plus spcialement
pour les tudiants du master Biologie Informatique.
Ce cours est bas sur les versions 2.x de Python et ne prend pas en compte, pour l'instant,
les nouvelles versions 3.x. Nanmoins, nous essaierons de le mettre rapidement jour de
manire traiter la compatibilit entre les deux gnrations. Si vous relevez des erreurs
la lecture de ce document, merci de nous les signaler.
Version du 17 avril 2012.

Cours de Python par Patrick Fuchs - Pierre Poulain

I - Introduction..............................................................................................................................................................5
I-A - Avant de commencer..................................................................................................................................... 5
I-B - Premier contact avec Python sous Linux...................................................................................................... 5
I-C - Premier programme Python...........................................................................................................................6
I-D - Commentaires................................................................................................................................................ 6
I-E - Sparateur d'instructions................................................................................................................................7
I-F - Notion de bloc d'instructions et d'indentation................................................................................................ 7
II - Variables.................................................................................................................................................................7
II-A - Types............................................................................................................................................................. 8
II-B - Nommage...................................................................................................................................................... 8
II-C - Oprations.....................................................................................................................................................9
II-C-1 - Oprations sur les chanes de caractres........................................................................................... 9
II-C-2 - Oprations illicites................................................................................................................................ 9
II-C-3 - Fonction type()................................................................................................................................... 10
III - criture................................................................................................................................................................ 10
III-A - criture formate........................................................................................................................................10
III-B - Exercices.................................................................................................................................................... 12
IV - Listes...................................................................................................................................................................12
IV-A - Dfinition.................................................................................................................................................... 12
IV-B - Utilisation....................................................................................................................................................13
IV-C - Opration sur les listes............................................................................................................................. 13
IV-D - Indiage ngatif et tranches...................................................................................................................... 13
IV-E - Fonctions range et len...............................................................................................................................14
IV-F - Listes de listes........................................................................................................................................... 15
IV-G - Exercices................................................................................................................................................... 15
V - Boucles et comparaisons.................................................................................................................................... 16
V-A - Boucles for..................................................................................................................................................16
V-B - Comparaisons............................................................................................................................................. 17
V-C - 5.3 Boucles while....................................................................................................................................... 18
V-D - 5.4 Exercices.............................................................................................................................................. 19
VI - Tests....................................................................................................................................................................20
VI-A - Dfinition.................................................................................................................................................... 20
VI-B - Tests plusieurs cas.................................................................................................................................21
VI-C - Tests multiples........................................................................................................................................... 22
VI-D - Instructions break et continue................................................................................................................... 23
VI-E - Exercices....................................................................................................................................................23
VII - Fichiers...............................................................................................................................................................24
VII-A - Lecture dans un fichier.............................................................................................................................24
VII-A-1 - Mthode read().................................................................................................................................25
VII-A-2 - Mthode readline()........................................................................................................................... 25
VII-A-3 - Mthodes seek() et tell().................................................................................................................. 26
VII-A-4 - Itrations directement sur le fichier..................................................................................................26
VII-B - criture dans un fichier............................................................................................................................ 26
VII-C - Exercices.................................................................................................................................................. 27
VIII - Modules.............................................................................................................................................................27
VIII-A - Dfinition.................................................................................................................................................. 27
VIII-B - Importation de modules........................................................................................................................... 28
VIII-C - Obtenir de l'aide sur les modules imports.............................................................................................29
VIII-D - Modules courants.................................................................................................................................... 29
VIII-E - Module sys : passage d'arguments......................................................................................................... 30
VIII-F - Module os................................................................................................................................................ 31
VIII-G - Exercices................................................................................................................................................. 31
IX - Plus sur les chanes de caractres....................................................................................................................32
IX-A - 9.1 Prambule........................................................................................................................................... 32
IX-B - Chanes de caractres et listes.................................................................................................................32
IX-C - Caractres spciaux.................................................................................................................................. 33
IX-D - Mthodes associes aux chanes de caractres...................................................................................... 33
IX-E - Conversion de types..................................................................................................................................34
-2Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

IX-F - Conversion d'une liste de chanes de caractres en une chane de caractres....................................... 35

IX-G - Exercices................................................................................................................................................... 36
X - Plus sur les listes................................................................................................................................................ 37
X-A - Proprits des listes................................................................................................................................... 37
X-B - Test d'appartenance....................................................................................................................................39
X-C - Copie de listes............................................................................................................................................39
X-D - Exercices.................................................................................................................................................... 40
XI - Dictionnaires et tuples........................................................................................................................................ 40
XI-A - Dictionnaires.............................................................................................................................................. 40
XI-A-1 - Mthodes keys() et values()............................................................................................................. 41
XI-A-2 - Liste de dictionnaires........................................................................................................................ 41
XI-A-3 - Existence d'une cl........................................................................................................................... 41
XI-B - 11.2 Tuples................................................................................................................................................ 42
XI-C - Exercices................................................................................................................................................... 42
XII - Fonctions............................................................................................................................................................43
XII-A - Principe..................................................................................................................................................... 43
XII-B - Dfinition................................................................................................................................................... 44
XII-C - Passage d'arguments............................................................................................................................... 44
XII-D - Porte des variables.................................................................................................................................45
XII-E - Porte des listes....................................................................................................................................... 46
XII-F - Rgle LGI..................................................................................................................................................47
XII-G - Exercices.................................................................................................................................................. 48
XIII - Expressions rgulires et parsing.................................................................................................................... 48
XIII-A - Dfinition et syntaxe................................................................................................................................ 49
XIII-B - Module re et fonction search...................................................................................................................51
XIII-B-1 - Fonction match()............................................................................................................................. 51
XIII-B-2 - Compilation d'expressions rgulires..............................................................................................52
XIII-B-3 - Groupes...........................................................................................................................................52
XIII-B-4 - Fonction findall()..............................................................................................................................53
XIII-B-5 - Fonction sub()................................................................................................................................. 53
XIII-C - Exercices : extraction des gnes d'un fichier genbank........................................................................... 53
XIV - Cration de modules........................................................................................................................................ 54
XIV-A - Cration................................................................................................................................................... 54
XIV-B - Utilisation................................................................................................................................................. 54
XIV-C - 14.3 Exercices.........................................................................................................................................55
XV - Autres modules d'intrt................................................................................................................................... 55
XV-A - Module urllib2........................................................................................................................................... 55
XV-B - Module pickle........................................................................................................................................... 56
XV-B-1 - Codage des donnes...................................................................................................................... 56
XV-B-2 - Dcodage des donnes...................................................................................................................57
XV-C - 15.3 Exercices..........................................................................................................................................58
XVI - Modules d'intrt en bioinformatique............................................................................................................... 58
XVI-A - Module numpy.........................................................................................................................................58
XVI-A-1 - Objets de type array.......................................................................................................................58
XVI-A-2 - Un peu d'algbre linaire............................................................................................................... 61
XVI-A-3 - Un peu de transforme de Fourier.................................................................................................62
XVI-B - Module biopython.................................................................................................................................... 63
XVI-C - Module matplotlib.................................................................................................................................... 63
XVI-D - Module rpy.............................................................................................................................................. 65
XVI-E - Exercice numpy.......................................................................................................................................67
XVI-F - Exercice rpy.............................................................................................................................................67
XVII - Avoir la classe avec les objets....................................................................................................................... 68
XVII-A - Exercices................................................................................................................................................ 68
XVIII - Gestion des erreurs........................................................................................................................................68
XIX - Trucs et astuces...............................................................................................................................................70
XIX-A - Shebang et /usr/bin/env Python.............................................................................................................. 70
XIX-A-1 - Python et utf-8................................................................................................................................ 71
XIX-B - Vitesse d'itration dans les boucles........................................................................................................71
-3Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

XIX-C - Liste de comprhension..........................................................................................................................72

XIX-D - Sauvegardez votre historique de commandes....................................................................................... 73
XX - Remerciements..................................................................................................................................................73

-4Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

I - Introduction
I-A - Avant de commencer
Avant de commencer ce cours, voici quelques indications gnrales qui pourront vous servir pour la suite.

Familiarisez-vous avec le site [Link]. Il contient normment d'informations et de liens sur Python
et vous permet en outre de le tlcharger pour diffrentes plateformes (Linux, Mac, Windows). La page
d'index des modules est particulirement utile.
Pour aller plus loin avec Python, Grard Swinnen a crit un trs bon livre intitul Apprendre 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 transposable aux
systmes d'exploitation Windows et Mac.
L'apprentissage d'un langage informatique comme Python va ncessiter d'crire des lignes de code l'aide
d'un diteur de texte. Si vous tes dbutants, nous vous conseillons vivement d'utiliser gedit ou nedit, qui sont
les plus proches des diteurs que l'on peut trouver sous Windows (Notepad). Des diteurs comme emacs et
vi sont trs puissants, mais ncessitent un apprentissage particulier.

I-B - Premier contact avec Python sous Linux

Python est un langage interprt, c'est--dire que chaque ligne de code est lue puis interprte afin d'tre excute
par l'ordinateur. Pour vous en rendre compte, lancez la commande :
Python

Celle-ci va dmarrer l'interprteur 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 l'invite de commande de votre shell sous Linux.
Le triple chevron >>> est l'invite de Python (prompt en anglais), ce qui signifie que Python attend une commande.
Tapez par exemple l'instruction
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 l'invite de l'interprteur Python (>>>). En rsum, voici ce qui a d apparatre sur votre cran :
>>> print "Hello world !"
Hello world !
>>>

Vous pouvez refaire un nouvel essai en vous servant cette fois de l'interprteur comme d'une machine calculer.
>>> 1 + 1
2
>>>

-5Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

ce stade, vous pouvez entrer une autre commande ou bien quitter l'interprteur l'aide des touches Ctrl-D.
Finalement l'interprteur Python est un systme interactif dans lequel vous pouvez entrer des commandes, que
Python excutera sous vos yeux (au moment o vous validerez la commande en tapant sur Entre).
Il existe de nombreux autres langages interprts tels que Perl ou R. Le gros avantage est que l'on peut directement
tester une commande l'aide de l'interprteur, ce qui est trs utile pour dboguer (c'est--dire corriger les ventuelles
erreurs d'un programme). Gardez bien en mmoire cette proprit de Python qui pourra parfois vous faire gagner
un temps prcieux !

I-C - Premier programme Python

Bien sr, l'interprteur prsente vite des limites ds lors que l'on veut excuter une suite d'instructions plus complexes.
Comme tout langage informatique, on peut enregistrer ces instructions dans un fichier, que l'on appelle communment
un script Python.
Pour reprendre l'exemple 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 [Link], puis quittez l'diteur de texte. L'extension 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 :

Soit rendre votre fichier excutable. Pour cela deux oprations sont ncessaires :

prcisez au shell la localisation de l'interprteur Python en indiquant dans la premire ligne du script :

[fuchs@opera ~]$ Python [Link]

Hello World !
[fuchs@opera ~]$

#!/usr/bin/env Python

3
4

#!/usr/bin/env Python
print Hello World !

rendez votre script Python excutable en tapant :

chmod +x [Link]
[fuchs@opera ~]$ ./[Link]
Hello World !
[fuchs@opera ~]$

I-D - 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 humain.
#!/usr/bin/env Python
# votre premier script Python
print Hello World !
# dautres commandes plus utiles pourraient suivre

-6Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

I-E - Sparateur d'instructions

Python utilise l'espace comme sparateur d'instructions. 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 l'espace entre l'instruction print et le chiffre 1 renvoie une erreur.

I-F - Notion de bloc d'instructions et d'indentation

Pour terminer ce chapitre d'introduction, nous allons aborder ds maintenant les notions de bloc d'instructions et
d'indentation.
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 trois instructions diffrentes, les unes la suite des autres.
Regardez l'exemple suivant en pseudocode :
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 d'autres instructions (il
s'agit d'une boucle, on verra le nom de la commande exacte plus tard). Dans le pseudocode ci-dessus, il y a trois
instructions rpter, nommes sous-instruction1 sous-instruction3.
Notez bien les dtails de la syntaxe. La premire ligne indique que l'on veut rpter une ou plusieurs instructions,
elle se termine par : . Ce symbole : indique Python qu'il doit attendre un bloc d'instructions, c'est--dire un
certain nombre de sous-instructions rpter. Python reconnat un bloc d'instructions, car il est indent. L'indentation
est le dcalage d'un ou plusieurs espaces ou tabulations des instructions sous-instruction1 sous-instruction3,
par rapport instruction_qui_indique__Python_de_rpter_10_fois_ce_qui_suit:.
Pratiquement, l'indentation en Python doit tre homogne (soit des espaces, soit des tabulations, mais pas un
mlange des deux). Une indentation avec quatre espaces est le style d'indentation le plus traditionnel et celui qui
permet une bonne lisibilit du code.
Enfin, la ligne instruction_suivante sera excute une fois que le bloc d'instructions 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.

II - 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 l'ordinateur, il s'agit en fait d'une adresse (i.e. une zone particulire
de la mmoire).

-7Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

En Python, la dclaration d'une variable et son initialisation (c.--d. la premire valeur que l'on va stocker dedans)
se fait en mme temps. Pour vous en convaincre, regardez puis testez les instructions suivantes aprs avoir lanc
l'interprteur :
>>> x = 2
>>> x
2

Dans cet exemple, nous avons dclar, puis initialis la variable x avec la valeur 2. L'interprteur nous a ensuite
permis de regarder le contenu de la variable juste en tapant son nom. Retenez ceci, car c'est une spcificit de
l'interprteur Python , trs pratique pour chasser les erreurs ( debug ) dans un programme. Par contre, la ligne
d'un script Python qui contient seulement le nom d'une variable (sans aucune autre fonction) n'affichera pas la valeur
de la variable l'cran.

II-A - Types
Le type d'une 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), c'est d'ailleurs un des gros avantages de Python (si vous n'tes pas effrays, vous pouvez
vous en rendre compte ici ).
Dans l'exemple prcdent, nous avons stock un nombre entier ( int ) dans la variable x , mais il est tout 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 (entier, rel). Par contre, pour
une chane de caractres, il faut l'entourer de guillemets (simples, doubles voire triples) afin d'indiquer Python le
dbut et la fin de la chane.
Vous vous posez sans doute une question concernant l'exemple du rel. Si vous avez entr le nombre 3.14 ,
pourquoi Python l'imprime-t-il finalement avec des zros derrire ( 3.1400000000000001 ) ? Un autre exemple :
>>> 1.9
1.8999999999999999
>>>

Cette fois-ci, Python crit 1.9 sous la forme 1.8 suivi de plusieurs 9 ! Cela s'explique par le fait que, sans
rentrer dans les dtails techniques, la manire de coder un rel dans l'ordinateur est rarement exacte. Python ne
nous le cache pas et le montre lorsqu'il affiche ce nombre.

II-B - Nommage
Le nom des variables en Python peut-tre constitu de lettres minuscules (a z), de lettres majuscules (A Z), de
chiffres (0 9) ou du caractre soulign (_).

-8Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

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 d'utiliser 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, n'utilisez
jamais d'espace dans un nom de variable puisque celui-ci est le sparateur d'instructions.

II-C - 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).
L'oprateur puissance utilise le symbole
modulo % :

**

et pour obtenir le reste d'une division entire, on utilise le symbole

>>> 2**3
8
>>> 3 % 4
3
>>> 8 % 4
0

II-C-1 - Oprations sur les chanes de caractres

Pour les chanes de caractres, deux oprations sont possibles, l'addition et la multiplication :
>>> chaine = "Salut"
>>> chaine
Salut
>>> chaine + " Python"
Salut Python
>>> chaine * 3
SalutSalutSalut

L'oprateur d'addition
+
permet de concatner (assembler) deux chanes de caractres et l'oprateur de
multiplication * permet de dupliquer plusieurs fois une chane.

II-C-2 - Oprations illicites

Attention ne pas faire d'opration illicite, car vous obtiendriez un message d'erreur :
>>> toto + 2
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: cannot concatenate str and int objects

-9Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

Notez que Python vous donne le maximum d'indices dans son message d'erreur. Dans l'exemple 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.

II-C-3 - Fonction type()

Si vous ne vous souvenez plus du type d'une 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).

III - criture
Nous avons dj vu au chapitre prcdent la fonction print qui permet d'afficher une chane de caractres. Elle
permet en plus d'afficher le contenu d'une 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 apercevrez que Python a automatiquement ajout un
espace chaque fois que l'on utilisait le sparateur , . 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 l'une ct de l'autre sans espace, vous devrez les concatner :
>>> ani1 = chat
>>> ani2 = souris
>>> print ani1, ani2
chat souris
>>> print ani1 + ani2
chatsouris

III-A - criture formate

Imaginez que vous vouliez calculer puis afficher la proportion de GC d'un gnome. Notez que la proportion de GC
s'obtient comme la somme des bases Guanine (G) et Cytosine (C) divise par le nombre total de bases. Sachant
que l'on a 4500 bases G, 2575 bases C pour un total de 14 800 bases, vous pourriez faire comme suit (notez bien
l'utilisation des parenthses pour grer les priorits des oprateurs) :
>>> propGC = (4500.0 + 2575)/14800
>>> print "La proportion de GC est", propGC
- 10 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

La proportion de GC est 0.478040540541

Remarquez que si vous aviez fait le calcul avec (4500 + 2575)/14800 , vous auriez obtenu 0, car tous les nombres
sont des entiers et le rsultat aurait t, lui aussi, un entier. L'introduction de 4500.0 qui est un rel rsout 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 l'oprateur de formatage % . Dans votre cas, vous voulez formater un rel
pour l'afficher avec deux puis trois dcimales :
>>> print "La
Le proportion
>>> print "La
La proportion

proportion de GC est %.2f" % propGC

de GC est 0.48
proportion de GC est %.3f" % propGC
de GC est 0.478

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

1
2
3

Dsigner l'endroit o sera place la variable dans la chane de caractres ;

Prciser le type de la variable formater, ici f pour float donc pour un rel ;
Prciser le formatage voulu, ici .2 soit deux chiffres aprs le symbole dcimal.

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 formater 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 l'exemple prcdent, nous avons utilis le symbole % pour formater des variables. Si vous avez
besoin d'crire le symbole pourcentage % sans qu'il soit confondu avec celui servant pour l'criture
formate, il suffit de le doubler. Toutefois, si l'criture formate n'est pas utilise dans la mme chane de
caractres o vous voulez utiliser le symbole pour cent, cette opration n'est 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 %

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 qu'un 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

- 11 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

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 ) :
>>> 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 l'norme avantage de l'criture formate. Cela permet d'crire en colonnes parfaitement
alignes. Nous verrons que ceci est trs pratique si l'on veut crire les coordonnes des atomes d'une molcule au
format PDB.

III-B - Exercices
Conseil : utilisez l'interprteur Python pour les exercices 2 5.
1
2
3
4
5

Ouvrez l'interprteur Python et tapez 1+1 . Que se passe-t-il ? crivez la mme chose dans un script
[Link] . Excutez ce script en tapant Python [Link] dans un shell . Que se passe-t-il ? Pourquoi ?
Calculez le pourcentage de GC avec le code
percGC = ((4500 + 2575)/14800)*100

Gnrez une chane de caractres reprsentant un oligonuclotide polyA (AAAA) de 20 bases de

longueurs, sans taper littralement toutes les bases.
Suivant le modle du dessus, gnrez en une ligne de code un polyA de 20 bases suivi d'un polyGC rgulier
(GCGCGC) de 40 bases.
En utilisant l'criture formate, affichez en une seule ligne les variables a, b et c dont les valeurs sont
respectivement "salut" , 102 et 10.318.

IV - Listes
IV-A - Dfinition
Une liste est une structure de donnes qui contient une srie de valeurs. Python autorise la construction de liste
contenant des valeurs de types diffrents (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, s'il
s'agit 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 l'on affiche une liste, Python la restitue telle qu'elle a t saisie.

- 12 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

IV-B - Utilisation
Un des gros avantages d'une liste est que vous pouvez appeler ses lments par leur position. 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 d'une liste de n lments commence 0 et se termine n-1. Voyez
l'exemple suivant :
>>> animaux = [girafe,tigre,singe,souris]
>>> animaux[0]
girafe
>>> animaux[1]
tigre
>>> animaux[3]
souris

Par consquent, si on appelle l'lment d'indice 4 de notre liste, Python renverra un message d'erreur :
>>> animaux[4]
Traceback (innermost last):
File "<stdin>", line 1, in ?
IndexError: list index out of range

N'oubliez pas ceci ou vous risqueriez d'obtenir des bogues inattendus !

IV-C - Opration sur les listes

Tout comme les chanes de caractres, les listes supportent l'oprateur + de concatnation, ainsi que l'oprateur
* pour la duplication :
>>> ani1 =
>>> ani2 =
>>> ani1 +
[girafe,
>>> ani1 *
[girafe,

[girafe,tigre]
[singe,souris]
ani2
tigre, singe, souris]
3
tigre, girafe, tigre, girafe, tigre]

IV-D - 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 ngatif : -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 d'une liste l'aide de l'indice -1 sans pour autant connatre la longueur de la liste.
>>> animaux = [girafe,tigre,singe,souris]
- 13 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

>>> 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 l'lment m inclus l'lment n
+1 exclu). On dit alors qu'on 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:]
[girafe, tigre, singe, souris]
>>> animaux[:]
[girafe, tigre, singe, souris]
>>> animaux[1:]
[tigre, singe, souris]
>>> animaux[1:-1]
[tigre, singe]

Remarquez que lorsqu'aucun indice n'est indiqu gauche ou droite du symbole : , Python prend par dfaut
tous les lments depuis le dbut ou tous les lments jusqu' la fin respectivement.
Dans les versions rcentes de Python, on peut aussi prciser le pas en ajoutant un : supplmentaire et en indiquant
le pas par un entier.
>>> animaux = [girafe, tigre, singe, souris]
>>> 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 l'accs au contenu d'une liste avec des crochets fonctionne sur le modle liste[dbut:fin:pas].

IV-E - Fonctions range et len

L'instruction range() vous permet de crer des
rapide. Voyez plutt :

listes d'entiers

(et d'entiers uniquement) de manire simple et

>>> 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]

- 14 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

L'instruction range() fonctionne sur le modle range([dbut,] fin[, pas]). Les arguments entre crochets sont optionnels.
L'instruction len() vous permet de connatre la longueur d'une liste, ce qui parfois est bien pratique lorsqu'on lit un
fichier par exemple, et que l'on ne connat pas a priori la longueur des lignes. Voici un exemple d'utilisation :
>>> animaux = [girafe, tigre, singe, souris]
>>> len(animaux)
4
>>> len(range(10))
10

IV-F - Listes de listes

Pour finir, sachez qu'il est tout fait possible de construire des listes de listes. Cette fonctionnalit peut tre parfois
trs pratique. Par exemple :
>>> 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 d'animal et le nombre d'animaux pour chaque catgorie.
Pour accder un lment de la sous-liste, on utilise une double indication.
>>> zoo[1]
[tigre, 2]
>>> zoo[1][0]
tigre
>>> zoo[1][1]
2

On verra un peu plus loin qu'il existe en Python les dictionnaires qui sont trs pratiques pour faire ce genre de choses.
On verra aussi qu'il existe un module nomm numpy permettant de grer des listes ou tableaux de nombres (vecteurs
et matrices), ainsi que de faire des oprations dessus.

IV-G - Exercices
Conseil : utilisez l'interprteur Python.
1

2
3
4

5
6

Constituez une liste semaine contenant les sept jours de la semaine. partir de cette liste, comment
rcuprez-vous seulement les cinq premiers jours de la semaine d'une part, et ceux du week-end d'autre part
( utilisez pour cela l'indication ) ? Cherchez un autre moyen pour arriver au mme rsultat ( en utilisant une
autre indication ).
Trouvez deux manires pour accder au dernier jour de la semaine.
Inversez les jours de la semaine en une commande.
Crez quatre 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 l'interprteur :

saisons[2]

saisons[1][0]

saisons[1:2]

saisons[:][1]
Comment expliquez-vous ce dernier rsultat ?
Affichez la table des 9 en une seule commande avec l'instruction range().
Avec Python, rpondez la question suivante en une seule commande. Combien y a-t-il de nombres pairs
dans l'intervalle [2 , 10000] inclus ?

- 15 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

V - Boucles et comparaisons
V-A - Boucles for
Imaginez que vous ayez une liste de quatre lments dont vous voulez afficher les lments les uns aprs les autres.
Dans l'tat 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 qu'elle en contienne 100 voire
1000 ! Pour remdier cela, il faut utiliser les boucles. Regardez l'exemple suivant :
>>> animaux = [girafe,tigre,singe,souris]
>>> for i in animaux:

print i

girafe
tigre
singe
souris

En fait, la variable i va prendre successivement les diffrentes valeurs de la liste animaux chacune de ses
itrations. D'ores et dj, remarquez avec attention l' indentation . Vous voyez que l'instruction print i est dcale par
rapport l'instruction for i in animaux:. Outre une meilleure lisibilit, ceci est formellement requis en Python. Toutes
les instructions que l'on veut rpter constituent le corps de la boucle (ou un bloc d'instructions) et doivent tre
indentes d'un(e) ou plusieurs espace(s) ou tabulation(s). Dans le cas contraire, Python vous renvoie un message
d'erreur :
>>> for i in animaux:
print i
File "<stdin>", line 2
print i
^
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 d'utiliser une tranche d'une liste :
>>> animaux = [girafe,tigre,singe,souris]
>>> for i in animaux[1:3]:

print i

tigre
singe

On a vu que les boucles for pouvaient utiliser une liste contenant des chanes de caractres, mais elles peuvent
tout aussi bien utiliser des listes numriques. En utilisant l'instruction range on peut facilement accder une liste
d'entiers.

- 16 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

>>> for i in range(4):

print i

0
1
2
3

Par consquent, vous pouvez utiliser les boucles comme une itration sur les indices des lments d'une liste.
>>> animaux = [girafe, tigre, singe, souris]
>>> for i in range(4):

print animaux[i]

girafe
tigre
singe
souris

Cependant, la mthode utiliser pour parcourir avec une boucle for les lments d'une liste est celle qui ralise
les itrations directement sur les l ments .
>>> animaux = [girafe,tigre,singe,souris]
>>> for i in animaux:

print i

girafe
tigre
singe
souris

Si vous avez besoin de parcourir votre liste par ses indices, prfrez la fonction xrange() qui s'utilise de la mme
manire que range(), mais qui ne construit pas de liste et qui est donc beaucoup plus rapide. La fonction r ange()
ne sera donc employe que pour crer des listes d'entiers.
>>> animaux = [girafe,tigre,singe,souris]
>>> for i in xrange(4):

print animaux[i]

girafe
tigre
singe
souris

Enfin, si vous avez besoin de l'indice d'un lment d'une liste et de l'lment lui-mme, la fonction enumerate()
est pratique.
>>> animaux = [girafe,tigre,singe,souris]
>>> for i, ani in enumerate(animaux):

print i, ani

0 girafe
1 tigre
2 singe
3 souris

V-B - 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 d'effectuer toute une srie de comparaisons
entre le contenu de diffrentes variables, telles que :
syntaxe Python

signification

- 17 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

==
!=
>
>=
<
<=

gal
diffrent
suprieur
suprieur
infrieur
infrieur

de

ou gal

ou gal

Observez l'exemple suivant sur des nombres entiers.

>>> x
>>> x
True
>>> x
False
>>> x
True

= 5
== 5
> 10
< 10

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 l' oprateur d'affectation = qui donne une valeur une variable et l'
oprateur de comparaison == qui compare les valeurs de deux variables.
Vous pouvez galement effectuer des comparaisons sur des chanes de caractres.
>>> animal
>>> animal
False
>>> animal
True
>>> animal
True

= "tigre"
== "tig"
!= "tig"
== tigre

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 l'ordre alphabtique est pris en compte, par exemple :
>>> "a" < "b"
True

"a" est infrieur "b, car il est situ avant dans l'ordre alphabtique. En fait, c'est l'ordre 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 d'un 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 qu'un caractre est diffrent entre l'une et l'autre 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.

V-C - 5.3 Boucles while

Une autre alternative l'instruction for couramment utilise en informatique est la boucle while. Le principe est simple.
Une srie d'instructions est excute tant qu'une condition est vraie. Par exemple :
>>> i = 1
>>> while i <= 4:

print i

- 18 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

1
2
3
4

i = i + 1

Remarquez qu'il est encore une fois ncessaire d'indenter le bloc d'instructions. Une boucle while ncessite trois
lments pour fonctionner correctement :
1
2
3

L'initialisation de la variable de test avant la boucle ;

Le test de la variable associ l'instruction while ;
L'incrmentation de la variable de test dans le corps de la boucle.

Faites bien attention aux tests et l'incrmentation que vous utilisez, car une erreur mne souvent des boucles
infinies qui ne s'arrtent pas. Vous pouvez nanmoins toujours stopper l'excution d'un script Python l'aide de la
combinaison de touches Ctrl-C.

V-D - 5.4 Exercices

Conseil : pour ces exercices, crivez des scripts dans des fichiers, puis excutez-les dans un shell.

Soit la liste ['vache','souris','levure','bacterie']. Affichez l'ensemble des lments de cette liste (un lment par
ligne) de trois manires diffrentes (deux avec for et une avec while).

Constituez une liste semaine contenant les sept jours de la semaine. crivez une srie d'instructions affichant
les jours de la semaine (en utiliser une boucle for), ainsi qu'une autre srie d'instructions affichant les jours du
week-end (en utilisant une boucle while).
Avec une boucle, affichez les nombres de 1 10 sur une seule ligne.
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.
Voici les notes d'un tudiant [14, 9, 6, 8, 12]. Calculez la moyenne de ces notes. Utilisez l'criture formate
pour afficher la valeur de la moyenne avec deux dcimales.
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 itrations :

0
2
6

Python

Triangle. crivez un script qui dessine un triangle comme celui-ci :

*
**
***
****
*****
******
*******
********
*********
**********

Triangle invers. crivez un script qui dessine un triangle comme celui-ci :

**********
*********
********

- 19 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

*******
******
*****
****
***
**
*

Triangle gauche. crivez un script qui dessine un triangle comme celui-ci :

*
**
***
****
*****
******
*******
********
*********
**********

Triangle isocle. crivez un script qui dessine un triangle comme celui-ci :

*
***
*****
*******
*********
***********
*************
***************
*****************
*******************

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. Initialement, cette suite a t utilise pour
dcrire la croissance d'une population de lapins, mais elle 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 l'affiche.

VI - Tests
VI-A - Dfinition
Les tests sont un lment essentiel tout langage informatique si on veut lui donner un peu de complexit, car
ils permettent l'ordinateur de prendre des dcisions si telle ou telle condition est vraie ou fausse. Pour cela, Python
utilise l'instruction if ainsi qu'une 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 = "tigre"
>>> if x == "tigre":

print "Le test est vrai !"

- 20 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

Plusieurs remarques concernant ces deux exemples :

dans le premier exemple, le test tant vrai, l'instruction print "Le test est vrai !" est excute. Dans le second
exemple, le test est faux et rien n'est affich ;

les blocs d'instruction dans les tests doivent forcment tre indents comme les boucles for et while.
L'indentation indique la porte des instructions excuter si le test est vrai ;
l'instruction if se termine comme les instructions for et while par le caractre : .

VI-B - 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
d'utiliser deux instructions if, on peut se servir de if et de else :
>>> x = 2
>>> if x ==

print
else:

print

Le test est
>>> x = 3
>>> if x ==

print
else:

print

Le test est

2:
"Le test est vrai !"
"Le test est faux !"
vrai !
2:
"Le test est vrai !"
"Le test est faux !"
faux !

On peut utiliser une srie de tests dans la mme instruction if, notamment pour tester plusieurs valeurs d'une mme
variable. Par exemple, on se propose de tirer au sort une base d'ADN puis d'afficher le nom de cette dernire. Dans
le code suivant, nous utilisons l'instruction [Link](liste) qui renvoie un lment choisi au hasard dans une
liste. L'instruction import random sera vue plus tard, admettez pour le moment qu'elle est ncessaire.
>>> import random
>>> base = [Link](["a", "t", "c", "g"])
>>> if base == "a":

print "choix dune adnine"

elif base == "t":

print "choix dune thymine"

elif base == "c":

print "choix dune cytosine"

elif base == "g":

print "choix dune guanine"

choix dune 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 l'indentation dans ces deux derniers exemples ! Vous devez tre trs
rigoureux ce niveau-l. Pour vous en convaincre, excutez ces deux scripts dans l'interprteur Python :
Script 1 :
nombres = [4, 5, 6]
for i in nombres:
if i == 5:
print "Le test est vrai"
print "car la variable i vaut", i

- 21 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

Script 2 :
nombres = [4, 5, 6]
for i in nombres:
if i == 5:
print "Le test est vrai"
print "car la variable i vaut", i

Comment expliquez-vous ce rsultat ?

VI-C - 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
Vrai
Faux
Faux

OU
OU
OU
OU

Vrai
Faux
Vrai
Faux

Vrai
Vrai
Vrai
Faux

Vrai
Vrai
Faux
Faux

ET
ET
ET
ET

Vrai
Faux
Vrai
Faux

Vrai
Faux
Faux
Faux

En Python, on utilise le mot rserv and pour l'oprateur ET et le mot rserv or pour l'oprateur OU . Respectez
bien la casse, and et or s'crivent en minuscule. En voici un exemple d'utilisation :
>>> x = 2
>>> y = 2
>>> if x == 2 and y == 2:

print "le test est vrai"

le test est vrai

Notez que le mme rsultat 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 l'effet de ces oprateurs l'aide de True et False (attention respecter la casse).
>>> True or False
True

Enfin, on peut utiliser l'oprateur logique de ngation not qui inverse le rsultat d'une condition :
>>> not True
False
>>> not False
True
>>> not (True and True)
False

- 22 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

VI-D - Instructions break et continue

Ces deux instructions permettent de modifier le comportement d'une boucle (for ou while) avec un test.
L'instruction break stoppe la boucle.
>>> for i in range(5):

if i > 2:

break

print i

0
1
2

L'instruction continue saute l'itration suivante.

>>> for i in range(5):

if i == 2:

continue

print i

0
1
3
4

VI-E - Exercices
Conseil : pour ces exercices, crivez des scripts dans des fichiers, puis excutez-les dans un shell.

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 s'il s'agit du lundi au jeudi

Chouette c'est vendredi s'il s'agit du vendredi

Repos ce week-end s'il s'agit du week-end (Les messages ne sont que des suggestions, vous pouvez
laisser aller votre imagination.)

La liste ci-dessous reprsente une squence d'ADN :

["A","C","G","T","T","A","G","C","T","A","A","C","G"]

La fonction min() de Python, renvoie l'lment le plus petit d'une liste. Sans utiliser cette fonction, crivez un
script qui dtermine le plus petit lment de la liste [8, 4, 6, 1, 5].
La liste ci-dessous reprsente une squence d'acides amins
["A","R","A","W","W","A","W","A","R","W","W","R","A","G","A","R"]

Voici les notes d'un 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 mention obtenue sachant que la mention est passable si la moyenne est entre 10
inclus et 12 exclu, assez bien entre 12 inclus et 14 exclu et bien au-del de 14.
Faites une boucle qui parcourt les nombres de 0 20 et qui affiche les nombres pairs infrieurs ou gaux
10 d'une part, et les nombres impairs strictement suprieurs 10 d'autre part. Pour cet exercice, vous
pourrez utiliser l'oprateur modulo % qui retourne le reste de la division entire entre deux nombres.
Exercice +++. Conjecture de Syracuse.

Exercice +++. Attribution simple de structure secondaire.

- 23 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

[[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]]

\
\
\
\
\
\

Exercice +++. Dtermination des nombres premiers infrieurs 100.

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 l'oprateur modulo %) depuis 1 jusqu'
lui-mme. Si c'est 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 n'est 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, c'est--dire qu'ils 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 n'importe quel nombre premier est nul. Le cas chant, ce nombre n'est
pas premier.

VII - Fichiers
VII-A - 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 d'outils 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 [Link], par exemple :
girafe
tigre
singe
souris

Ensuite, testez cet exemple :

>>> filin = open([Link], r)
>>> filin
<open file [Link], mode r at 0x7f8ea16efc00>
>>> [Link]()
[girafe\n, tigre\n, singe\n, souris\n]
>>> [Link]()
>>> filin
<closed file [Link], mode r at 0x7f8ea16efc00>

La premire commande ouvre le fichier [Link] en lecture seule (ceci est indiqu avec la lettre r). Remarquez
que le fichier n'est pas encore lu, mais simplement ouvert ( un peu comme lorsqu'on ouvre un livre, mais
qu'on ne l'a pas encore lu ). Lorsqu'on affiche la valeur de la variable filin, vous voyez que Python la
considre comme un objet de type fichier
<open file [Link], mode r at 0x7f8ea16efc00>

- 24 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

propos de mthode, on applique la mthode readlines() sur l'objet filin dans l'instruction suivante
(remarquez la syntaxe du type [Link]). Ceci nous retourne une liste contenant toutes les lignes du
fichier ( dans notre analogie avec un livre, ceci correspondrait lire les lignes du livre ).
Enfin, on applique la mthode close( ) sur l'objet filin, ce qui vous vous en doutez, va fermer le fichier ( ceci
correspondrait bien sr fermer le livre ). On pourra remarquer que l'tat de l'objet a chang
<closed file [Link], mode r at 0x7f8ea16efc00>

Vous n'avez bien sr pas retenir ces concepts d'objets pour pouvoir programmer avec Python, nous avons juste
ouvert cette parenthse pour attirer votre attention sur la syntaxe.
Remarque : n'utilisez 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 d'un fichier avec Python.
>>> filin = open([Link], r)
>>> lignes = [Link]()
>>> lignes
[girafe\n, tigre\n, singe\n, souris\n]
>>> for i in lignes:

print i

girafe
tigre
singe
souris
>>> [Link]()

Vous voyez qu'en 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 d'entre elles (ceci est cod par un caractre spcial que l'on symbolise par \n). Vous
pourrez parfois rencontrer galement la notation octale \012 ;
remarquez aussi que lorsque l'on affiche les diffrentes lignes du fichier l'aide de la boucle for et de
l'instruction print, Python saute chaque fois une ligne.

VII-A-1 - Mthode read()

Il existe d'autres mthodes que readlines() pour lire (et manipuler) un fichier. Par exemple, la mthode read() lit tout
le contenu d'un fichier et renvoie une chane de caractres unique.
>>> filin = open([Link], r)
>>> [Link]()
girafe\ntigre\nsinge\nsouris\n
>>> [Link]()

VII-A-2 - Mthode readline()

La mthode readline() (sans s) lit une ligne d'un fichier et la renvoie sous forme d'une 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.
>>> filin = open([Link], r)
>>> ligne = [Link]()
>>> while ligne != "":

print ligne

- 25 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

ligne = [Link]()

girafe
tigre
singe
souris
>>> [Link]()

VII-A-3 - Mthodes seek() et tell()

Les mthodes seek() et tell() permettent respectivement de se dplacer au nime caractre (plus exactement au
nime octet) d'un fichier et d'afficher o en est la lecture du fichier, c'est--dire quel caractre (ou octet) est en
train d'tre lu.
>>> filin = open([Link], r)
>>> [Link]()
girafe\n
>>> [Link]()
7
>>> [Link](0)
>>> [Link]()
0
>>> [Link]()
girafe\n
>>> [Link]()

On remarque qu' l'ouverture d'un fichier, le tout premier caractre est considr comme le caractre 0 (tout comme
le premier lment d'une liste). La mthode seek() permet facilement de remonter au dbut du fichier lorsque l'on
est arriv la fin ou lorsqu'on en a lu une partie.

VII-A-4 - 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.
>>> filin = open([Link], r)
>>> for li in filin:

print li

girafe
tigre
singe
souris
>>> [Link]()

La boucle for va demander Python d'aller lire le fichier ligne par ligne. Privilgiez cette mthode par la suite.

VII-B - criture dans un fichier

crire dans un fichier est aussi simple que de le lire. Voyez l'exemple suivant :
>>> animaux2 = [poisson, abeille, chat]
>>> filout = open([Link], w)
>>> for i in animaux2:

[Link](i)
- 26 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

>>> [Link]()

Le contenu du fichier [Link] 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 l'aide d'une boucle. chaque itration, nous avons crit chaque lment de
la liste dans le fichier. Remarquez nouveau la mthode write() qui s'applique sur l'objet filout ;
enfin, on a ferm le fichier avec la mthode close().

Vous voyez qu'il est extrmement simple en Python de lire ou d'crire dans un fichier.
Remarque : si votre programme produit uniquement du texte, vous pouvez l'crire sur la sortie standard (avec
l'instruction print). L'avantage est que dans ce cas l'utilisateur peut bnficier de toutes les potentialits d'Unix
(redirection, tri, parsing ). S'il veut crire le rsultat du programme dans un fichier, il pourra toujours le faire en
redirigeant la sortie.

VII-C - Exercices
Conseil : pour les exercices 1 et 2, utilisez l'interprteur Python. Pour les exercices suivants, crivez des scripts dans
des fichiers, puis excutez-les dans unshell.
1
2
3

Dans l'exemple '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.
En reprenant le dernier exemple sur l'criture dans un fichier, vous pouvez constater que les noms d'animaux
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.
Dans cet exercice, nous allons utiliser une sortie partielle de DSSP (Define Secondary Structure of Proteins),
qui est un logiciel d'extraction des structures secondaires. Ce fichier contient cinq colonnes correspondant
respectivement au numro de rsidu, l'acide amin, sa structure secondaire et ses angles phi/psi.
Tlchargez le fichier first_helix_1tfe.txt sur le site du cours et sauvegardez-le dans votre rpertoire de
travail (jetez-y un il en passant).
Chargez les lignes de ce fichier en les plaant dans une liste puis fermez le fichier.
crivez chaque ligne.

VIII - Modules
VIII-A - Dfinition
Les modules sont des programmes Python qui contiennent des fonctions que l'on 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 n'existe 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 sur le site de
Python. Surfez un peu sur ce site, la quantit de modules est impressionnante.

- 27 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

VIII-B - Importation de modules

Jusqu' maintenant, nous avons rencontr une fois cette notion de module lorsque nous avons voulu tirer un nombre
alatoire.
>>> import random
>>> [Link](0,10)
4

Regardons de plus prs cet exemple :

l'instruction import permet d'accder toutes les fonctions du module random ;

ensuite, nous utilisons la fonction (ou mthode) randint(a,b) du module random. Attention cette fonction
renvoie un nombre entier alatoirement entre a inclus et b inclus (contrairement range() par exemple).
Remarquez la notation objet [Link]() o la fonction randint() peut tre considre comme une
mthode de l'objet random.

Il existe un autre moyen d'importer une ou des fonctions d'un module :

>>> from random import randint
>>> randint(0,10)
7

l'aide du mot-cl from, vous pouvez importer une fonction spcifique d'un 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 d'un 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

Comme vous l'avez devin, l'instruction from random import * importe toutes les fonctions du module random. On
peut ainsi utiliser toutes ses fonctions directement, par exemple shuffle(), qui permute une liste alatoirement.
Dans la pratique, plutt que de charger toutes les fonctions d'un module en une seule fois (from random import
*), nous vous conseillons de charger le module (import random) puis d'appeler explicitement les fonctions voulues
([Link](0,2)).
Enfin, si vous voulez vider de la mmoire un module dj charg, vous pouvez utiliser l'instruction del :
>>> import random
>>> [Link](0,10)
2
>>> del random
>>> [Link](0,10)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name random is not defined

- 28 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

Vous pouvez constater qu'un rappel d'une fonction du module random aprs l'avoir vid de la mmoire retourne un
message d'erreur.
Enfin, il est galement possible de dfinir un alias (un nom plus court) pour un module :
>>> import random as rand
>>> [Link](1, 10)
6

Dans cet exemple, les fonctions du module random sont accessibles via l'alias rand.

VIII-C - Obtenir de l'aide sur les modules imports

Pour obtenir de l'aide sur un module rien de plus simple, il suffit d'invoquer la commande help() :
>>> import random
>>> help(random)

On peut se promener dans l'aide avec les flches ou les touches page-up et page-down (comme dans les commandes
Unix man, more ou less). Il est aussi possible d'invoquer de l'aide sur une fonction particulire d'un module de la
manire suivante help([Link]).
La commande help() est en fait une commande plus gnrale permettant d'avoir de l'aide sur n'importe 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 sequences items
|
| Methods defined here:
|
| __add__()
|
x.__add__(y) <==> x+y
|

Enfin, si on veut connatre en seul coup d'il 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, SystemRandom,
TWOPI, WichmannHill, _BuiltinMethodType, _MethodType, __all__, __builtins__,
__doc__, __file__, __name__, _acos, _ceil, _cos, _e, _exp, _hexlify,
_inst, _log, _pi, _random, _sin, _sqrt, _test, _test_generator,
_urandom, _warn, betavariate, choice, expovariate, gammavariate, gauss,
getrandbits, getstate, jumpahead, lognormvariate, normalvariate,
paretovariate, randint, random, randrange, sample, seed, setstate,
shuffle, uniform, vonmisesvariate, weibullvariate]
>>>

VIII-D - Modules courants

Il existe une srie de modules que vous serez probablement amens utiliser si vous programmez en Python. En
voici une liste non exhaustive. Pour la liste complte, reportez-vous la page des modules sur le site de Python :
- 29 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

math : fonctions et constantes mathmatiques de base (sin, cos, exp, pi) ;

sys : passage d'arguments, gestion de l'entre/sortie standard ;
os : dialogue avec le systme d'exploitation (e.g. permet de sortir de Python, lancer une commande en
shell , puis de revenir Python) ;
random : gnration de nombres alatoires ;
time : permet d'accder l'heure de l'ordinateur et aux fonctions grant le temps ;
calendar : fonctions de calendrier ;
profile : permet d'valuer le temps d'excution 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 d'installer Tk) ;
re : gestion des expressions rgulires ;
pickle : criture et lecture de structures Python (comme les dictionnaires par exemple).

Nous vous conseillons vivement d'aller surfer sur les pages de ces modules pour dcouvrir toutes leurs potentialits.
Vous verrez plus tard comment crer votre propre module lorsque vous tes amens rutiliser souvent vos propres
fonctions.
Enfin, notez qu'il 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)

VIII-E - Module sys : passage d'arguments

Le module sys contient (comme son nom l'indique) des fonctions et des variables spcifiques au systme, ou plus
exactement l'interprteur lui-mme. Par exemple, il permet de grer l'entre ( stdin ) et la sortie standard ( stdout
). Ce module est particulirement intressant pour rcuprer les arguments passs un script Python lorsque celuici est appel en ligne de commande. Dans cet exemple, oublions l'interprteur et crivons le script suivant que l'on
enregistrera sous le nom [Link] (n'oubliez pas de le rendre excutable) :
#!/usr/bin/env Python
import sys
print [Link]

Ensuite lancez [Link] suivi de plusieurs arguments. Par exemple :

poulain@cumin> Python [Link] salut girafe 42
[[Link], salut, girafe, 42]

Dans l'exemple prcdent, poulain@cumin> reprsente l'invite du shell , [Link] est le nom du script Python, salut,
girafe et 42 sont les arguments passs au script.
La variable [Link] est une liste qui reprsente tous les arguments de la ligne de commande, y compris le nom
du script lui-mme qu'on peut retrouver dans [Link][0]. On peut donc accder chacun de ces arguments avec
[Link][1], [Link][2]
On peut aussi utiliser la fonction [Link]() pour quitter un script Python. On peut donner comme argument un objet
(en gnral une chane de caractres) qui sera renvoy au moment o Python quittera le script. Par exemple, si
vous attendez au moins un argument en ligne de commande, vous pouvez renvoyer un message pour indiquer
l'utilisateur ce que le script attend comme argument :
#!/usr/bin/env Python
import sys
if len([Link]) != 2:

- 30 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

[Link]("ERREUR : il faut exactement un argument.")

#
# suite du script
#

Puis on l'excute sans argument :

poulain@cumin> Python [Link]
ERREUR : il faut exactement un argument.

Notez qu'ici on vrifie que le script possde deux arguments, car le nom du script lui-mme est le premier argument
et [Link] constitue le second.

VIII-F - Module os
Le module os gre l'interface avec le systme d'exploitation.
Une fonction pratique de ce module permet de grer la prsence d'un fichier sur le disque.
>>> import sys
>>> import os
>>> if [Link]("[Link]"):

print "le fichier est prsent"

else:

[Link]("le fichier est absent")

le fichier est absent

Dans cet exemple, si le fichier n'est pas prsent sur le disque, on quitte le programme avec la fonction exit() du
module sys.
La fonction system() permet d'appeler n'importe quelle commande externe.
>>> import os
>>> [Link]("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
-rw-r--r-- 1 poulain dsimb 4706057 2010-07-21 14:31
-rw-r--r-- 1 poulain dsimb 233585 2010-07-21 14:30
-rw-r--r-- 1 poulain dsimb 463559 2010-07-21 14:33
0

.
..
[Link]
NC_000913.fna
NC_001133.fna
NC_001133.gbk

La commande externe ls -al est introduite comme une chane de caractres la fonction system().

VIII-G - Exercices
Conseil : pour les trois premiers exercices, utilisez l'interprteur Python. Pour les exercices suivants, crivez des
scripts dans des fichiers, puis excutez-les dans un shell.

Affichez sur la mme ligne les nombres de 10 20 (inclus) ainsi que leur racine carre avec 3 dcimales
(module math). Exemple :
10
11
12
13

3.162
3.317
3.464
3.606

- 31 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

Calculez le cosinus de pi/2 (module math).

Affichez la liste des fichiers du rpertoire courant avec le module os. N'utilisez pas la fonction [Link](),
mais la fonction [Link]() (lisez la documentation pour comprendre comment l'utiliser).
crivez les nombres de 1 10 avec 1 seconde d'intervalle (module time).
Gnrez une squence alatoire de 20 chiffres, ceux-ci tant des entiers tirs entre 1 et 4 (module random).
Gnrez une squence alatoire de 20 bases de deux manires diffrentes (module random).
Dterminez votre jour (lundi, mardi) de naissance (module calendar).
Exercice +++. valuation du nombre par la mthode Monte Carlo .
Soit un cercle de rayon 1 (en rouge) inscrit dans un carr de ct 2 (en bleu).

Conseil : pour les premiers exercices, utilisez l'interprteur Python.

IX - Plus sur les chanes de caractres

IX-A - 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 caractres . Notez qu'il existe un module string,
mais qui est maintenant considr comme obsolte depuis la version 2.5 de Python.

IX-B - 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 = "girafe tigre"
>>> 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 d'erreur :
>>> animaux = "girafe tigre"
>>> animaux[4]
f
>>> animaux[4] = "F"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: str object does not support item assignment

Par consquent, si vous voulez modifier une chane, vous tes obligs d'en construire une nouvelle. Pour cela,
n'oubliez 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.

- 32 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

IX-C - Caractres spciaux

Il existe certains caractres spciaux comme le \n que nous avons dj vu (pour le retour la ligne). Le \t vous permet
d'crire une tabulation. Si vous voulez crire un guillemet simple ou double (et que celui-ci ne soit pas confondu avec
les guillemets de dclaration de la chane de caractres), vous pouvez utiliser \' ou \" ou utiliser respectivement des
guillemets doubles ou simple pour dclarer votre chane de caractres.
>>> print "Un retour a la ligne\n puis une tabulation\t, puis un guillemet\""
Un retour a la ligne
puis une tabulation
, puis un guillemet"
>>> print J\imprime un guillemet simple
Jimprime un guillemet simple
>>> print "Un brin dADN"
Un brin dADN
>>> print Python est un "super" langage
Python est un "super" langage

Lorsqu'on souhaite crire un texte sur plusieurs lignes, il est trs commode d'utiliser 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

IX-D - Mthodes associes aux chanes de caractres

Voici quelques mthodes spcifiques aux objets de type string :
>>> x = "girafe"
>>> [Link]()
GIRAFE
>>> x
girafe
>>> [Link]()
tigre

Les fonctions lower() et upper() passent un texte en minuscules et en majuscules respectivement. On remarque que
l'utilisation de ces fonctions n'altre 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 :

>>> [Link]()
Girafe

Il existe une mthode associe aux chanes de caractres qui est particulirement pratique, la fonction split() :
>>> animaux = "girafe tigre singe"
>>> [Link]()
[girafe, tigre, singe]

- 33 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

>>> for i in [Link]():

print i

girafe
tigre
singe

La fonction split() dcoupe la ligne en champs, en utilisant comme sparateur les espaces ou les tabulations. Il est
possible de modifier le sparateur de champs, par exemple :
>>> animaux = "girafe:tigre:singe"
>>> [Link](":")
[girafe, tigre, singe]

La fonction find() recherche une chane de caractres passe en argument.

>>>
>>>
1
>>>
3
>>>
-1

animal = "girafe"
[Link](i)
[Link](afe)
[Link](tig)

Si l'lment recherch est trouv, alors l'indice du dbut de l'lment dans la chane de caractres est renvoy. Si
l'lment n'est pas trouv, alors la valeur -1 est renvoye.
Si l'lment recherch est trouv plusieurs fois, seul l'indice de la premire occurrence est retourn :
>>> animaux = "girafe tigre"
>>> [Link]("i")
1

On trouve aussi la fonction replace(), qui serait l'quivalent de la fonction de substitution de la commande Unix sed :
>>> animaux = "girafe tigre"
>>> [Link]("tigre", "singe")
girafe singe
>>> [Link]("i", "o")
gorafe togre

Enfin, la fonction count() compte le nombre d'occurrences d'une chane de caractres passe en argument :
>>>
>>>
2
>>>
0
>>>
1

animaux = "girafe tigre"

[Link]("i")
[Link]("z")
[Link]("tigre")

IX-E - Conversion de types

Dans tout langage de programmation, on est souvent amen convertir les types, c'est--dire passer d'un 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

- 34 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

>>> int(i)
456
>>> float(i)
456.0
>>> i = 3.1416
>>> float(i)
3.1415999999999999

Ces conversions sont essentielles lorsqu'on 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.

IX-F - Conversion d'une liste de chanes de caractres en une chane de caractres

La conversion d'une liste de chanes de caractres en une chane de caractres est un peu particulire puisqu'elle
fait appel 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 n'importe quelle chane de caractres (ici, nous avons utilis un tiret, un espace et rien).
Attention, la fonction join() ne s'applique qu' une liste de chanes de caractres.
>>> maliste = ["A", 5, "G"]
>>> " ".join(maliste)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: sequence item 1: expected string, int found

Nous esprons qu'aprs ce petit tour d'horizon vous serez convaincu de la richesse des mthodes associes aux
chanes de caractres. Pour avoir une liste exhaustive de l'ensemble des mthodes associes une variable
particulire, vous pouvez utiliser la commande dir().
>>> dir(animaux)
[__add__, __class__, __contains__, __delattr__, __doc__, __eq__, __ge__,
__getattribute__, __getitem__, __getnewargs__, __getslice__, __gt__,
__hash__, __init__, __le__, __len__, __lt__, __mod__, __mul__, __ne__,
__new__, __reduce__, __reduce_ex__, __repr__, __rmod__, __rmul__,
__setattr__, __str__, capitalize, center, count, decode, encode,
endswith, expandtabs, find, index, isalnum, isalpha, isdigit, islower,
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 l'instant vous pouvez ignorer les mthodes qui commencent et qui se terminent par deux tirets bas (underscores)
__ .
Vous pouvez ensuite accder l'aide et la documentation d'une fonction particulire avec help() :

- 35 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

>>> help([Link])
Help on built-in function split:
split()
[Link]([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)

IX-G - Exercices
Conseil : pour ces exercices, crivez des scripts dans des fichiers, puis excutez-les dans un shell .

Soit la liste ['girafe', 'tigre', 'singe', 'souris']. Avec une boucle, affichez chaque lment ainsi que sa taille
(nombre de caractres).
Soit la squence nuclique ATATACGGATCGGCTGTTGCCTGCGTAGTAGCGT. Calculez la frquence de
chaque base dans cette squence.
Soit la squence protique ALA GLY GLU ARG TRP TYR SER GLY ALA TR P . Transformez cette
squence en une chane de caractres en utilisant le code une lettre pour les acides amins.
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.
Palindrome.
Un palindrome est un mot ou une phrase dont l'ordre 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 dbarrasser 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 .
Mot composable.
Un mot est composable partir d'une squence de lettres si la squence contient toutes les lettres du mot.
Comme au Scrabble, chaque lettre de la squence ne peut tre utilise qu'une seule fois. Par exemple, coucou
est composable partir de uocuoceokzefhu.
crivez un script qui permet de savoir si un mot est composable partir d'une 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 caractres.
Alphabet et pangramme.
Les codes ASCII des lettres minuscules de l'alphabet vont de 97 (lettre a) 122 (lettre z). La fonction chr()
prend en argument un code ASCII sous forme d'un 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 l'alphabet.
Un pangramme est une phrase comportant au moins une fois chaque lettre de l'alphabet. 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 pangramme ou non. Pensez
vous dbarrasser 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 .

- 36 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

Tlchargez le fichier pdb 1BTA dans votre rpertoire. Faites un script qui rcupre seulement les
carbones alpha et qui les affiche l'cran.
En vous basant sur le script prcdent, affichez l'cran les carbones alpha des deux premiers rsidus.
Toujours avec le mme script, calculez la distance inter atomique entre ces deux atomes.
En vous basant sur le script prcdent, calculez les distances entre carbones alpha conscutifs. Affichez ces
distances sous la forme

umero_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 l'ordre de 3,8 angstrms. Observez avec attention les valeurs que vous avez obtenues.
Expliquez l'anomalie dtecte.

X - Plus sur les listes

X-A - 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 d'en remanier la taille (e.g. ajouter, insrer ou supprimer
un ou plusieurs lments, etc.). Les listes possdent cet effet des mthodes qui leur sont propres. Observez les
exemples suivants :
append()
pour ajouter un lment la fin d'une liste.
>>>
>>>
>>>
[1,

x = [1,2,3]
[Link](5)
x
2, 3, 5]

qui est quivalent

>>>
>>>
>>>
[1,

x = [1,2,3]
x = x + [5]
x
2, 3, 5]

insert()
pour insrer un objet dans une liste avec un indice dtermin.
>>> [Link](2,-15)
>>> x
[1, 2, -15, 3, 5]

del
pour supprimer un lment d'une liste un indice dtermin.
>>> del x[1]
>>> x
[1, -15, 3, 5]

remove()

- 37 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

pour supprimer un lment d'une liste partir de sa valeur

>>> [Link](5)
>>> x
[1, -15, 3]

sort()
pour trier une liste
>>> [Link]()
>>> x
[-15, 1, 3]

reverse()
pour inverser une liste
>>> [Link]()
>>> x
[3, 1, -15]

count()
pour compter le nombre d'lments (pass en argument) dans une liste.
>>>
>>>
3
>>>
1
>>>
0

l=[1, 2, 4, 3, 1, 1]
[Link](1)
[Link](4)
[Link](23)

Remarque 1 : attention, une liste remanie n'est pas renvoye ! Pensez-y dans vos utilisations futures des listes.
Remarque 2 : attention, certaines fonctions ci-dessus dcalent les indices d'une liste (par exemple insert(), del, etc.).
La mthode append() est particulirement pratique, car elle permet de construire une liste au fur et mesure des
itrations d'une boucle. Pour cela, il est commode de dfinir pralablement 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 i in seq:

seq_list.append(i)

>>> 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 n'importe 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]

- 38 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

Cette mthode est certes plus simple, mais il arrive parfois que l'on doive utiliser les boucles tout de mme, comme
lorsqu'on lit un fichier.

X-B - Test d'appartenance

L'inscription in permet de tester si un lment fait partie d'une liste.
liste
>>> 3
True
>>> 4
False
>>> 3
False
>>> 4
True

= [1, 3, 5, 7, 9]
in liste
in liste
not in liste
not in liste

La variation avec not permet, a contrario , de vrifier qu'un lment n'est pas dans une liste.

X-C - Copie de listes

Il est trs important de savoir que l'affectation d'une liste ( partir d'une liste prexistante) cre en ralit une rfrence
et non une copie :
>>>
>>>
>>>
[1,
>>>
>>>
[1,

x = [1,2,3]
y = x
y
2, 3]
x[1] = -15
y
-15, 3]

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 n'en ayez fait la demande explicitement. Regardez cet
exemple :
>>>
>>>
>>>
>>>
[1,

x = [1,2,3]
y = x[:]
x[1] = -15
y
2, 3]

Dans l'exemple prcdent, x[:] a cr une copie la vole de la liste x. Vous pouvez utiliser aussi la fonction list()
qui renvoie explicitement une liste :
>>>
>>>
>>>
>>>
[1,

x = [1,2,3]
y = list(x)
x[1] = -15
y
2, 3]

Attention, les deux techniques prcdentes ne fonctionnent que pour les listes une dimension, autrement dit les
listes qui ne contiennent pas elles-mmes d'autres listes.
>>> x = [[1,2],[3,4]]
>>> x
[[1, 2], [3, 4]]
>>> y = x[:]
>>> y[1][1] = 55

- 39 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

>>> 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 = [Link](x)
>>> y[1][1] = 99
>>> y
[[1, 2], [3, 99]]
>>> x
[[1, 2], [3, 4]]

X-D - Exercices
Conseil : pour ces exercices, crivez des scripts dans des fichiers, puis excutez-les dans un shell.
1
2
3
4
5
6

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).
Gnrez alatoirement une squence nuclique de 20 bases en utilisant une liste et la mthode append().
Transformez la squence nuclique TCTGTTAACCATCCACTTCG en sa squence complmentaire inverse.
N'oubliez pas que la squence complmentaire doit tre inverse, pensez aux mthodes des listes !
Soit la liste de nombres [5, 1, 1, 2, 5, 6, 3, 4, 4, 4, 2]. Enlevez les doublons de cette liste, triez-la et affichez-la.
Gnrez alatoirement une squence nuclique de 50 bases contenant 10 % de A, 50 % de G, 30 % de T et
10 % de C.
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 prcdente. partir de l'ordre 1 (ligne 2, 11), gnrez
l'ordre suivant (121). Vous pouvez utiliser une liste pralablement gnre avec range(). Gnralisez l'aide d'une
boucle. crivez dans un fichier [Link] les lignes du triangle de Pascal de l'ordre 1 jusqu' l'ordre 10.

XI - Dictionnaires et tuples
XI-A - 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 collections non ordonnes d'objets, c.--d. qu'il n'y
a pas de notion d'ordre (i.e. pas d'indice). On accde aux valeurs d'un dictionnaire par des cls. Ceci semble un
peu confus ? Regardez l'exemple suivant :
- 40 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

>>> 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 d'lments
que vous voulez dans une liste). Pour rcuprer la valeur d'une cl donne, il suffit d'utiliser une syntaxe du style
dictionnaire['cle'].

XI-A-1 - Mthodes keys() et values()

Les mthodes keys() et values() renvoient, comme vous vous en doutez, les cls et les valeurs d'un dictionnaire
(sous forme de liste) :
>>> [Link]()
[nom, poids, taille]
>>> [Link]()
[girafe, 1100, 5.0]

On peut aussi initialiser toutes les cls d'un dictionnaire en une seule opration :
>>> ani2 = {nom:singe, poids:70, taille:1.75}

XI-A-2 - 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, taille: 1.75}]
>>>
>>> for ani in animaux:

print ani[nom]

girafe
singe

XI-A-3 - Existence d'une cl

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 cl poids existe pour ani2

- 41 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

Vous voyez que les dictionnaires permettent de grer des structures complexes de manire plus explicite que les
listes.

XI-B - 11.2 Tuples

Les tuples correspondent aux listes la diffrence qu'ils 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):
File "<stdin>", line 1, in ?
TypeError: object doesnt support item assignment

L'affectation et l'indiage fonctionnent comme avec les listes, mais si l'on essaie de modifier un des lments du
tuple, Python renvoie un message d'erreur. 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 d'un 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 d'en crer
de nouveaux sans les parenthses, ds lors que ceci ne pose pas d'ambigut avec une autre expression :
>>>
>>>
(1,
>>>
>>>
(1,

x = (1,2,3)
x
2, 3)
x = 1,2,3
x
2, 3)

Toutefois, nous vous conseillons d'utiliser systmatiquement les parenthses afin d'viter les confusions.
Enfin, on peut utiliser la fonction tuple(sequence) qui fonctionne exactement comme la fonction list, c'est--dire qu'elle
prend en argument un objet squentiel et renvoie le tuple correspondant :
>>> 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 collections d'autres objets.
On peut donc construire des listes qui contiennent des dictionnaires, des tuples ou d'autres listes, mais aussi des
dictionnaires contenant des tuples, des listes, etc.

XI-C - Exercices
Conseil : pour ces exercices, crivez des scripts dans des fichiers, puis excutez-les dans un shell.

- 42 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

En utilisant un dictionnaire et la fonction has_key(), dterminez le nombre d'occurrences de chaque acide

amin dans la squence AGWPSGGASAGLAILWGASAIMPGALW. Le dictionnaire ne doit contenir que les
acides amins prsents dans la squence.
Soit la squence nuclotidique suivante :

ACCTAGCCATGTAGAATCGCCTAGGCTTTAGCTAGCTCTAGCTAGCTG

En utilisant un dictionnaire, faites un programme qui rpertorie tous les mots de deux lettres qui existent dans la
squence (AA, AC, AG, AT, etc.) ainsi que leur nombre d'occurrences puis qui les affiche l'cran.

Faites de mme avec des mots de trois et quatre lettres.

En vous basant sur les scripts prcdents, extrayez les mots de deux lettres et leur occurrence 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.
Crez un script [Link] qui prend en arguments un fichier genbank suivi d'un entier compris entre 1
et 4. Ce script doit extraire du fichier genbank tous les mots (ainsi que leur nombre d'occurrences) du nombre
de lettres passes en option.
Appliquez ce script sur le gnome d' Escherichia coli : NC_000913.fna (au format fasta). Cette mthode
vous parat-elle efficace sur un gnome assez gros comme celui d' E. Coli ? Comment pourrait-on en
amliorer la rapidit ?
partir du fichier PDB 1BTA , construisez un dictionnaire qui contient quatre cls se rfrant au premier
carbone alpha : le numro du rsidu, puis les coordonnes x, y et z.
Sur le mme modle que ci-dessus, crez une liste de dictionnaires pour chacun des carbones alpha de la
protine.
l'aide de cette liste, calculez les coordonnes x, y et z du barycentre de ces carbones alpha.

XII - Fonctions
XII-A - Principe
En programmation, les fonctions sont trs utiles pour raliser plusieurs fois la mme opration au sein d'un
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 [Link](angle) du module math renvoie le cosinus
de la variable angle exprime en radians. Vous connaissez aussi des fonctions internes Python comme range() ou
len(). Pour l'instant, une fonction est vos yeux une sorte de bote noire :

laquelle vous passez une (ou zro ou plusieurs) valeur(s) entre parenthses. Ces valeurs sont appeles
arguments ;
qui effectue une action. Par exemple [Link]() 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 n'intresse pas directement l'utilisateur. Par
exemple, il est inutile de savoir comment la fonction [Link]() calcule un cosinus, on a juste besoin de
savoir qu'il faut lui passer en argument un angle en radians et qu'elle renvoie le cosinus de cet angle. Ce qui
se passe au sein de la fonction ne regarde que le programmeur (c'est--dire vous dans ce chapitre) ;

- 43 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

Chaque fonction effectue en gnral une tche unique et prcise. Si cela se complique, il est plus judicieux
d'crire plusieurs fonctions (qui peuvent ventuellement s'appeler les unes les autres). Cette modularit
amliore la qualit gnrale et la lisibilit du code. Vous verrez qu'en Python, les fonctions prsentent une
grande flexibilit.

XII-B - 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
d'instructions est donc attendu. De mme que pour les boucles et les tests, l' indentation de ce bloc d'instructions
(i.e. le corps de la fonction) est obligatoire .
Dans l'exemple prcdent, nous avons pass un argument la fonction carre() qui nous a retourn une valeur que
nous avons affiche l'cran. Que veut dire valeur retourne ? Eh bien, cela signifie que cette dernire est stockable
dans une variable :
>>> res = carre(2)
>>> print res
4

Ici, le rsultat renvoy par la fonction est stocke dans la variable res. Notez qu'une fonction 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 d'imprimer la chane de caractres "hello" l'cran. Elle ne prend aucun
argument et ne renvoie aucun rsultat. Par consquent, cela n'a 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

XII-C - Passage d'arguments

Le nombre d'arguments que l'on peut passer une fonction est variable. Nous avons vu ci-dessus des fonctions
auxquelles on passait 0 ou 1 argument. Dans les chapitres prcdents, vous avez vu des fonctions internes Python
qui prenaient au moins deux arguments, pour rappel souvenez-vous de range(1,10) ou encore range(1,10,2). Le
nombre d'arguments est donc laiss libre l'initiative du programmeur qui est en train de dvelopper une nouvelle
fonction.
Une particularit des fonctions en Python est que vous n'tes 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

- 44 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

connu comme tant un langage au typage dynamique, c'est--dire qu'il reconnat pour vous le type des variables au
moment de l'excution, par exemple :
>>> def fois(x,y):

return x*y

>>> fois(2,3)
6
>>> fois(3.1415,5.23)
16.430045000000003
>>> fois(to,2)
toto

L'oprateur * reconnat plusieurs types (entiers, rels, chanes de caractres), notre fonction est donc capable
d'effectuer 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

>>> carre_cube(2)
(4, 8)

Vous voyez qu'en ralit Python renvoie un objet squentiel qui peut par consquent contenir 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):.

XII-D - Porte des variables

Il est trs important lorsque l'on manipule des fonctions de connatre la porte des variables. Premirement, on peut
crer des variables au sein d'une fonction qui ne seront pas visibles l'extrieur 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

- 45 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

>>> print x
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name x is not defined

Lorsque Python excute le code de la fonction, il connat le contenu de la variable x. Par contre, de retour dans le
module principal (dans notre cas, il s'agit de l'interprteur Python), il ne la connat plus d'o le message d'erreur. De
mme, une variable passe en argument est considre comme locale lorsqu'on arrive dans la fonction :
>>> def mafonction(x):

print x vaut,x,dans la fonction

>>> mafonction(2)
x vaut 2 dans la fonction
>>> print x
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name x is not defined

Deuximement, lorsqu'une variable dclare la racine du module (c'est comme cela que l'on appelle un programme
Python), elle est visible dans tout le module.
>>>

>>>
>>>
3
>>>
3

def mafonction():
print x
x = 3
mafonction()
print x

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 d'une variable globale dans une fonction :
>>> def mafonction():

x = x + 1

>>> x=1
>>> mafonction()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in fct
UnboundLocalError: local variable x referenced before assignment

L'erreur renvoye montre que Python pense que x est une variable locale qui n'a pas t encore assigne. Si on veut
vraiment modifier une variable globale dans une fonction, il faut utiliser le mot-cl global :
>>>

>>>
>>>
>>>
2

def mafonction():
global x
x = x + 1
x=1
mafonction()
x

Dans ce dernier cas, le mot-cl global a forc la variable x a tre globale plutt que locale au sein de la fonction.

XII-E - Porte des listes

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

- 46 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

>>>

>>>
>>>
>>>
[1,

def mafonction():
liste[1] = -127
liste = [1,2,3]
mafonction()
liste
-127, 3]

De mme que si vous passez une liste en argument, elle est tout autant modifiable au sein de la fonction :
>>>

>>>
>>>
>>>
[1,

def mafonction(x):
x[1] = -15
y = [1,2,3]
mafonction(y)
y
-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 d'une liste lorsqu'elle est passe en tant qu'argument est
de la passer explicitement (comme nous l'avons fait pour l'affectation) afin qu'elle reste intacte dans le programme
principal.
>>>

>>>
>>>
>>>
[1,
>>>
>>>
[1,

def mafonction(x):
x[1] = -15
y = [1,2,3]
mafonction(y[:])
y
2, 3]
mafonction(list(y))
y
2, 3]

Dans ces deux derniers exemples, une copie de y est cre la vole lorsqu'on appelle la fonction, ainsi la liste
y du module principal reste intacte.

XII-F - Rgle LGI

Lorsque Python rencontre une variable, il va traiter la rsolution de son nom avec des priorits particulires : d'abord
il va regarder si la variable est locale , puis si elle n'existe pas localement, il vrifiera si elle est globale et enfin
si elle n'est 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 :
>>> def mafonction():

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

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 !

- 47 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

XII-G - Exercices
Conseil : pour ces exercices, crivez des scripts dans des fichiers, puis excutez-les dans un shell.

Prdisez le comportement de ce code sans le recopier dans un script ni dans l'interprteur Python :
def hello(prenom):
print "Bonjour", prenom
hello("Patrick")
print x

Prdisez le comportement de ce code sans le recopier dans un script ni dans l'interprteur Python :
x = 10
def hello(prenom):
print "Bonjour", prenom
hello("Patrick")
print x

Prdisez le comportement de ce code sans le recopier dans un script ni dans l'interprteur Python :
x = 10
def hello(prenom):
print "Bonjour", prenom
print x
hello("Patrick")
print x

Prdisez le comportement de ce code sans le recopier dans un script ni dans l'interprteur Python :
x = 10
def hello(prenom):
x = 42
print "Bonjour", prenom
print x
hello("Patrick")
print x

Crez une fonction qui prend une liste de base et qui renvoie la squence complmentaire d'une squence
d'ADN sous forme de liste.
partir d'une squence d'ADN ATCGATCGATCGCTGCTAGC, renvoyez le brin complmentaire (n'oubliez
pas que la squence doit tre inverse).
Crez une fonction distance() qui calcule une distance euclidienne en trois dimensions entre deux atomes.
En reprenant l'exercice 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().

XIII - Expressions rgulires et parsing

Le module re vous permet d'utiliser des expressions rgulires au sein de Python. Les expressions rgulires sont
aussi appeles en anglais regular expressions ou regex. Elles sont incontournables en bioinformatique lorsque vous
voulez rcuprer des informations dans un fichier.

- 48 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

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 d'intrt par exemple rcuprer les coordonnes
3D des atomes d'une protine dans un fichier PDB ou alors extraire les gnes d'un fichier genbank.
Dans ce chapitre, nous ne ferons que quelques rappels sur les expressions rgulires. Pour une documentation plus
complte, rfrez-vous la page d'aide des expressions rgulires sur le site officiel de Python.

XIII-A - Dfinition et syntaxe

Une expression rgulire est une suite de caractres qui a pour but de dcrire un fragment de texte. Elle est constitue
de deux types de caractres :
1
2

Les caractres dits normaux ;

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 expressions rgulires. Tous ces
programmes fonctionnent gnralement selon le schma suivant :
1
2

Le programme lit un fichier ligne par ligne ;

Pour chaque ligne lue, si l'expression 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 l'herps (herp_virus.gbk) qui correspondent
l'expression 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 :

- 49 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

[ABC]

[A-Z]

[a-z]
[0-9]
[A-Za-z0-9]
[^AB]

dbut de chane de caractres ou de ligne

Exemple : l'expression ^ATG correspond
la chane de caractres ATGCGT, mais pas
la chane CCATGTT.
fin de chane de caractres ou de ligne
Exemple : l'expression ATG$ correspond
la chane de caractres TGCATG, mais pas
avec la chane CCATGTT.
n'importe quel caractre (mais un caractre
quand mme)
Exemple : l'expression A.G correspond
ATG, AtG, A4G, mais aussi A-G ou A G.
le caractre A ou B ou C (un seul caractre)
Exemple : l'expression T[ABC]G correspond
TAG, TBG ou TCG, mais pas TG.
n'importe quelle lettre majuscule
Exemple : l'expression C[A-Z]T correspond
CAT, CBT, CCT
n'importe quelle lettre minuscule
n'importe quel chiffre
n'importe quel caractre alphanumrique
n'importe quel caractre sauf A et B
Exemple : l'expression CG[^AB]T
correspond CG9T, CGCT mais pas
CGAT ni CGBT.
caractre d'chappement (pour protger
certains caractres)
Exemple : l'expression \+ dsigne le
caractre + sans autre signification
particulire. L'expression A\.G correspond

- 50 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

A.G et non pas A suivi de n'importe quel

caractre, suivi de G.
0 n fois le caractre prcdent ou
l'expression entre parenthses prcdente
Exemple : l'expression A(CG)*T correspond
AT, ACGT, ACGCGT

1 n fois le caractre prcdent ou

l'expression entre parenthses prcdente
Exemple : l'expression A(CG)+T correspond
ACGT, ACGCGT mais pas AT.
0 1 fois le caractre prcdent ou
l'expression entre parenthses prcdente
Exemple : l'expression A(CG)?T correspond
At ou ACGT.
n fois le caractre prcdent ou l'expression
entre parenthses prcdente
n m fois le caractre prcdent ou
l'expression entre parenthses prcdente
au moins n fois le caractre prcdent ou
l'expression entre parenthses prcdente
au plus m fois le caractre prcdent ou
l'expression entre parenthses prcdente
chanes de caractres CG ou TT
Exemple : l'expression A(CG|TT)C
correspond ACGC ou ATTC.

{n}
{n,m}
{n,}
{,m}
(CG|TT)

XIII-B - Module re et fonction search

Dans le module re, la fonction search() permet de rechercher un motif (pattern) au sein d'une 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
>>> animaux = "girafe tigre singe"
>>> [Link](tigre, animaux)
<_sre.SRE_Match object at 0x7fefdaefe2a0>
>>> if [Link](tigre, animaux):

print "OK"

OK

XIII-B-1 - Fonction match()

Il existe aussi la fonction match() dans le module re qui fonctionne sur le modle de search(). La diffrence est qu'elle
renvoie une instance MatchObject seulement lorsque l'expression rgulire correspond ( match ) au dbut de la
chane ( partir du premier caractre).
>>> animaux = "girafe tigre singe"
>>> [Link](tigre, animaux)
<_sre.SRE_Match object at 0x7fefdaefe718>
>>> [Link](tigre, animaux)

- 51 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

Nous vous recommandons plutt l'usage de la fonction search(). Si vous souhaitez avoir une correspondance avec
le dbut de la chane, vous pouvez toujours utiliser l'accroche de dbut de ligne ^.

XIII-B-2 - Compilation d'expressions rgulires

Il est aussi commode de pralablement compiler l'expression rgulire l'aide de la fonction compile() qui renvoie
un objet de type expression rgulire :
>>> regex = [Link]("^tigre")
>>> regex
<_sre.SRE_Pattern object at 0x7fefdafd0df0>

On peut alors utiliser directement cet objet avec la mthode search() :

>>> animaux = "girafe tigre singe"
>>> [Link](animaux)
>>> animaux = "tigre singe"
>>> [Link](animaux)
<_sre.SRE_Match object at 0x7fefdaefe718>
>>> animaux = "singe tigre"
>>> [Link](animaux)

XIII-B-3 - Groupes
Python renvoie un objet MatchObject lorsqu'une expression rgulire trouve une correspondance dans une chane
pour qu'on puisse rcuprer des informations sur les zones de correspondance.
>>> regex = [Link](([0-9]+)\.([0-9]+))
>>> resultat = [Link]("pi vaut 3.14")
>>> [Link](0)
3.14
>>> [Link](1)
3
>>> [Link](2)
14
>>> [Link]()
8
>>> [Link]()
12

Dans cet exemple, on recherche un nombre compos :

de plusieurs chiffres [0-9]+ ;

suivi d'un point \. (le point a une signification comme mtacaractre, donc il faut l'chapper avec \ pour qu'il ait
une signification de point) :
suivi d'un nombre plusieurs chiffres [0-9]+.

Les parenthses dans l'expression rgulire permettent de crer des groupes qui seront rcuprs ultrieurement par
la fonction group(). La totalit de la correspondance est donne par group(0), le premier lment entre parenthses
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
l'expression rgulire. Notez que la fonction search() ne renvoie que la premire zone qui correspond l'expression
rgulire, mme s'il en existe plusieurs :
>>> resultat = [Link]("pi vaut 3.14 et e vaut 2.72")
>>> [Link](0)
3.14

- 52 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

XIII-B-4 - Fonction findall()

Pour rcuprer chaque zone, vous pouvez utiliser la fonction findall() qui renvoie une liste des lments en
correspondance.
>>> regex = [Link]([0-9]+\.[0-9]+)
>>> resultat = [Link]("pi vaut 3.14 et e vaut 2.72")
>>> resultat
[3.14, 2.72]
>>> regex = [Link](([0-9]+)\.([0-9]+))
>>> resultat = [Link]("pi vaut 3.14 et e vaut 2.72")
>>> resultat
[(3, 14), (2, 72)]

XIII-B-5 - Fonction sub()

Enfin, la fonction sub() permet d'effectuer des remplacements assez puissants. Par dfaut la fonction sub(chaine1,
chaine2) remplace toutes les occurrences trouves par l'expression rgulire dans chaine2 par chaine1 . Si vous
souhaitez ne remplacer que les n premires occurrences, utilisez l'argument count=n :
>>>
pi
>>>
pi

[Link](quelque
vaut quelque chose
[Link](quelque
vaut quelque chose

chose,"pi vaut 3.14 et e vaut 2.72")

et e vaut quelque chose
chose,"pi vaut 3.14 et e vaut 2.72", count=1)
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 !

XIII-C - Exercices : extraction des gnes d'un fichier genbank

Pour les exercices suivants, vous utiliserez le module d'expressions rgulires re et le fichier genbank du chromosome
I de la levure du boulanger Saccharomyces cerevisiae NC_001133.gbk .

crivez un script qui extrait l'organisme du fichier genbank NC_001133.gbk .

Modifiez le script prcdent pour qu'il affiche toutes les lignes qui indiquent l'emplacement du dbut et de la
fin des gnes, du type :
gene

Faites de mme avec les gnes complmentaires :

gene

58..272

complement(55979..56935)

Rcuprez maintenant la squence nuclique et affichez-la l'cran. Vrifiez que vous n'avez pas fait
d'erreur en comparant la taille de la squence extraite avec celle indique dans le fichier genbank.
Mettez cette squence dans une liste et rcuprez les deux premiers gnes (en les affichant l'cran).
Attention, le premier gne est un gne complmentaire, n'oubliez pas de prendre le complmentaire inverse
de la squence extraite.
partir de toutes ces petites oprations que vous transformerez en fonctions, concevez un programme
[Link] qui extrait tous les gnes d'un fichier genbank fourni en argument et les affiche l'cran.
Pour cela vous pourrez utiliser tout ce que vous avez vu jusqu' prsent (fonctions, listes, modules, etc.).
partir du script prcdent, refaites le mme programme ([Link]) en crivant chaque gne au
format fasta dans un fichier.

Pour rappel, l'criture d'une squence au format fasta est le suivant :

- 53 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

>ligne de commentaire
squence sur une ligne de 80 caractres maxi
suite de la squence ..
suite de la squence ..

Vous utiliserez comme ligne de commentaire le nom de l'organisme, suivi du numro 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 [Link], [Link], etc.

XIV - Cration de modules

XIV-A - Cration
Vous pouvez crer vos propres modules trs simplement en Python. Il vous suffit d'crire un ensemble de fonctions
(et/ou de variables) dans un fichier, puis d'enregistrer celui-ci avec une extension .py (comme n'importe quel script
Python). titre d'exemple, voici le contenu du module [Link].
"""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

XIV-B - Utilisation
Pour appeler une fonction ou une variable de ce module, il faut que le fichier [Link] soit dans le rpertoire
courant (dans lequel on travaille) ou bien dans un rpertoire indiqu par la variable d'environnement Unix
PYTHONPATH. Ensuite, il suffit d'importer le module et toutes ses fonctions (et variables) vous sont alors accessibles.
La premire fois qu'un module est import, Python cre un fichier avec une extension .pyc (ici [Link]) qui
contient le bytecode (code prcompil) du module.
L'appel 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 lorsqu'on importe le module. Ensuite on peut utiliser les fonctions
comme avec un module classique.
>>> import message
>>> [Link]("Joe")
hello Joe !
>>> [Link]("Bill")
ciao Bill
>>> [Link]("Monsieur")
bonjour Monsieur
- 54 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

>>> [Link]
16092008

Les commentaires (entre triples guillemets) situs en dbut de module et sous chaque fonction permettent de fournir
de l'aide invoque ensuite par la commande help() :
>>> help(message)
NAME
message - Module inutile qui affiche des messages :-)
FILE

/home/cumin/poulain/[Link]

FUNCTIONS
Hello(nom)
Affiche hello !
Bonjour(nom)
Affiche bonjour !
Ciao(nom)
Affiche ciao !
DATA

date = 16092008

Remarques :

les fonctions dans un module peuvent s'appeler les unes les autres ;
les fonctions dans un module peuvent appeler des fonctions situes dans un autre module s'il a t
pralablement import avec la commande import.

Vous voyez que les modules sont d'une simplicit enfantine crer. Si vous avez des fonctions que vous serez
amens utiliser souvent, n'hsitez plus !

XIV-C - 14.3 Exercices

Conseil : pour cet exercice, crivez un script dans un fichier, puis excutez-le dans un shell.
Reprenez l'ensemble des fonctions qui grent le traitement de squences nucliques et incluez-les dans un module
[Link]. Testez-les au fur et mesure.

XV - Autres modules d'intrt

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

XV-A - Module urllib2

Les modules urllib et urllib2 permettent de rapatrier, directement avec Python, des fichiers depuis internet. Nous
n'aborderons ici que des exemples simples, mais libre vous d'approfondir si besoin. Il existe des diffrences subtiles
entre urllib et urllib2 que nous n'aborderons 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.

- 55 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

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 = [Link]("[Link]
>>> pdb_lines = [Link]()
>>> [Link]()
>>> for i in pdb_lines:

print i,

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 d'utiliser la fonction urlopen() et de lui passer en argument 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 d'enregistrer le fichier tlcharg :
>>>
>>>
>>>
>>>
>>>
>>>
>>>

import urllib2
u = [Link]("[Link]
pdb_file_content = [Link]()
[Link]()
f = open("[Link]","w")
[Link](pdb_file_content)
[Link]()

Dans ce dernier exemple, nous rcuprons le fichier complet sous la forme d'une chane de caractres unique (avec
la fonction read()). Le fichier est ensuite enregistr dans le rpertoire courant (duquel vous avez lanc l'interprteur
Python). Nous vous laissons imaginer comment faire sur une srie de plusieurs fichiers (cf. exercices).

XV-B - Module pickle

Le module pickle permet d'effectuer une srialisation et dsrialisation des donnes. Il s'agit en fait d'encoder (d'une
manire particulire) les objets que l'on 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 .

XV-B-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("[Link]","w")
>>> maliste = range(10)
>>> mondico = {year: 2000, name: Far beyond driven, author: Pantera,
style: Trash Metal}
>>> [Link](maliste,fileout)
>>> [Link](mondico,fileout)
>>> [Link](3.14,fileout)
>>> [Link]()

- 56 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

Si on observe le fichier cr, on s'aperoit que les donnes sont codes :

>>> import os
>>> [Link]("cat [Link]")
(lp0
I0
aI1
aI2
aI3
aI4
aI5
aI6
aI7
aI8
aI9
a.(dp0
Sstyle
p1
STrash Metal
p2
sSauthor
p3
SPantera
p4
sSname
p5
SFar beyond driven
p6
sSyear
p7
I2000
s.F3.1400000000000001
.0
>>>

XV-B-2 - Dcodage des donnes

Pour dcoder les donnes, rien de plus simple, il suffit d'utiliser la fonction load(file) o file est un fichier ouvert en
lecture :
>>> filein = open("[Link]")
>>> [Link](filein)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> [Link](filein)
{style: Trash Metal, year: 2000, name: Far beyond driven,
author: Pantera}
>>> [Link](filein)
3.1400000000000001

Attention ne pas utiliser la fonction load une fois de trop, sinon une erreur est gnre :
>>> [Link](filein)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/usr/lib/python2.5/[Link]", line 1370, in load
return Unpickler(file).load()
File "/usr/lib/python2.5/[Link]", line 858, in load
dispatch[key](self)
File "/usr/lib/python2.5/[Link]", line 880, in load_eof
raise EOFError
EOFError
>>>

Il est noter qu'il existe un module quivalent, mais beaucoup plus rapide, le module cpickle .

- 57 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

XV-C - 15.3 Exercices

1
2

Concevez un script qui rapatrie de manire automatique le fichier [Link] depuis la Protein Data Bank
( l'aide du module urllib2).
On souhaite rcuprer les structures 3D de la partie N-terminale de la protine HSP90 en prsence de
diffrents cocristaux, les codes PDB sont 3K97, 3K98 et 3K99. crivez un script Python qui tlcharge de
manire automatique les fichiers PDB ( l'aide du module urllib2 et d'une boucle) et les enregistre dans le
rpertoire courant.
Reprenez le dictionnaire des mots de quatre 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.

XVI - Modules d'intrt 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 (nuclique et protique) ou structure (fichier PDB). Le module matplotlib permet
de dessiner des graphiques depuis Python. Enfin, le module rpy permet d'interfacer n'importe quelle fonction du
puissant programme R.
Ces modules ne sont pas fournis avec la 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 montrerons quelques exemples d'utilisation de ces modules pour vous convaincre de
leur pertinence.

XVI-A - Module numpy

Le module numpy est incontournable en bioinformatique. Il permet d'effectuer des calculs sur des vecteurs ou des
matrices, lment par lment, via un nouveau type d'objet appel array. Ce module contient des fonctions de
base pour faire de l'algbre linaire, des transformes de Fourier ou encore des tirages de nombres alatoires plus
sophistiqus qu'avec le module random. Vous pourrez trouver les sources de numpy cette adresse. Notez qu'il
existe un autre module scipy que nous n'aborderons 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 d'image, algorithmes gntiques, etc.).

XVI-A-1 - Objets de type array

Les objets de type array correspondent des tableaux une ou plusieurs dimensions et permettent d'effectuer du
calcul vectoriel. La fonction array() permet la conversion d'un objet squentiel (type liste ou tuple) en un objet de type
array. Voici un exemple simple de conversion d'une liste une dimension en objet array :
>>> import numpy
>>> a = [1,2,3]
>>> [Link](a)
array([1, 2, 3])
>>> b = [Link](a)
>>> type(a)
<type [Link]>
>>> b
array([1, 2, 3])

- 58 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

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 lorsqu'on demande Python le contenu d'un objet array, les symboles ([]) sont utiliss
pour le distinguer d'une liste [] ou d'un tuple ().
Notez qu'un 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.
>>> [Link](10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> [Link](10.0)
array([ 0., 1., 2., 3., 4., 5., 6., 7., 8.,
>>> [Link](10,0,-1)
array([10, 9, 8, 7, 6, 5, 4, 3, 2, 1])
>>>

9.])

Un des avantages de la fonction arange() est qu'elle permet de gnrer des objets array qui contiennent des entiers
ou de rels selon l'argument qu'on 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 lorsqu'on analyse de grandes quantits de donnes. Regardez ces exemples :
>>> v = [Link](4)
>>> v
array([0, 1, 2, 3])
>>> v + 1
array([1, 2, 3, 4])
>>> v + 0.1
array([ 0.1, 1.1, 2.1,
>>> v * 2
array([0, 2, 4, 6])
>>> v * v
array([0, 1, 4, 9])

3.1])

Notez bien sur le dernier exemple de multiplication que l'array final correspond la multiplication lment par lment
des deux array initiaux. Avec les listes, ces oprations n'auraient t possibles qu'en utilisant des boucles ! Nous
vous encourageons donc utiliser dornavant 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() :
>>> [Link]([[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 :
>>> [Link]([[[1,2],[2,3]],[[4,5],[5,6]]])
array([[[1, 2],
[2, 3]],

>>>

[[4, 5],
[5, 6]]])

- 59 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

La fonction array() peut crer des tableaux n'importe quel nombre de dimensions. Toutefois a devient vite
compliqu lorsqu'on dpasse trois dimensions. Retenez qu'un 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) d'un objet array, vous pouvez utiliser l'indiage ou les tranchages, de la
mme manire que pour les listes.
>>> a = [Link](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 d'un objet array deux dimensions, vous pouvez rcuprer une ligne, une colonne ou bien un seul
lment.
>>> a = [Link]([[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) l'aide d'une 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.
>>> [Link]((3,3))
array([[ 0., 0., 0.],
[ 0., 0., 0.],
[ 0., 0., 0.]])
>>> [Link]((3,3),int)
array([[0, 0, 0],
[0, 0, 0],
[0, 0, 0]])
>>> [Link]((3,3))
array([[ 1., 1., 1.],
[ 1., 1., 1.],
[ 1., 1., 1.]])

Par dfaut, les fonctions zeros() et ones() gnrent des rels, mais vous pouvez demander des entiers en passant
l'option int en second argument.
Enfin il existe les fonctions reshape() et resize() qui permettent de remanier volont les dimensions d'un array. Il faut
pour cela, leur passer en argument l'objet array remanier ainsi qu'un tuple indiquant la nouvelle dimensionnalit.
>>> a = [Link](9)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8])
>>> [Link](a,(3,3))
array([[0, 1, 2],
- 60 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

[3, 4, 5],
[6, 7, 8]])

Toutefois, reshape() attend un tuple dont la dimension est compatible avec le nombre d'lments contenus dans
l'array de dpart, alors que resize() s'en moque et remplira le nouvel objet array gnr mme si les longueurs ne
concident pas.
>>> a = [Link](9)
>>> [Link]((2,2))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: total size of new array must be unchanged
>>> [Link](a,(2,2))
array([[0, 1],
[2, 3]])
>>> [Link](a,(4,4))
array([[0, 1, 2, 3],
[4, 5, 6, 7],
[8, 0, 1, 2],
[3, 4, 5, 6]])

Dans l'exemple prcdent, la fonction reshape() renvoie une erreur si les dimensions ne concident pas. La fonction
resize() duplique ou coupe la liste initiale s'il le faut jusqu' tant que le nouvel array soit rempli.
Si vous ne vous souvenez plus de la dimension d'un objet array, la fonction shape() permet d'en retrouver la taille.
>>> a = [Link](3)
>>> [Link](a)
(3,)

Enfin, la fonction transpose() renvoie la transpose d'un array. Par exemple pour une matrice :
>>> a
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
>>> [Link](a)
array([[1, 4, 7],
[2, 5, 8],
[3, 6, 9]])

XVI-A-2 - Un peu d'algbre linaire

Aprs avoir manipul les vecteurs et les matrices, voici quelques fonctions pour faire de l'algbre linaire.
La fonction dot() vous permet de faire une multiplication de matrices.
>>> a = [Link]([Link](4),(2,2))
>>> a
array([[0, 1],
[2, 3]])
>>> [Link](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.

- 61 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

Pour toutes les oprations suivantes, il faudra utiliser des fonctions dans le sous-module [Link]. La fonction
inv() renvoie l'inverse d'une matrice carre, det() son dterminant, eig() ses vecteurs et valeurs propres.
>>> a
array([[0, 1],
[2, 3]])
>>> [Link](a)
array([[-1.5, 0.5],
[ 1. , 0. ]])
>>> [Link](a)
-2.0
>>> [Link](a)
(array([-0.56155281, 3.56155281]), array([[-0.87192821, -0.27032301],
[ 0.48963374, -0.96276969]]))
>>> [Link](a)[0]
array([-0.56155281, 3.56155281])
>>> [Link](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.

XVI-A-3 - Un peu de transforme de Fourier

La transforme de Fourier est trs utilise pour l'analyse de signaux, notamment lorsqu'on souhaite extraire des
priodicits au sein d'un signal bruit. Le module numpy possde la fonction 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 l'aide de la fonction fft() :
# 1) on dfinit la fonction y = cos(x)
import numpy
debut = -2 * [Link]
fin = 2 * [Link]
pas = 0.1
x = [Link](debut,fin,pas)
y = [Link](x)
# 2) on calcule la TF de la fonction cosinus
TF=[Link](y)
ABSTF = [Link](TF)
# abscisse du spectre en radians^-1
pas_xABSTF = 1/(fin-debut)
x_ABSTF = 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 pi), cos() (fonction cosinus) ou abs() (valeur absolue, ou module d'un complexe). Ceci est bien
pratique, car nous n'avons 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*pi 2*pi 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 vecteur (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 l'abscisse du spectre (en radians-1).
La variable ABSTF contient le spectre lui-mme. L'analyse de ce dernier nous donne un pic 0,15 radian-1,
ce qui correspond bien 2*pi (plutt bon signe de retrouver ce rsultat). Le graphe de ce spectre est
prsent dans la partie ddie matplotlib (section 16.3).

- 62 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

Notez que tout au long de cette partie, nous avons toujours utilis la syntaxe [Link]() pour bien vous montrer
quelles taient les fonctions propres numpy. Bien sr dans vos futurs scripts il sera plus commode d'importer
compltement le module numpy avec l'instruction 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 d'appartenance, vous pouvez
dfinir un alias pour numpy avec l'instruction import numpy as np. Le module numpy est alors connu sous le nom
np. L'appel de la fonction array() se fera par [Link]().

XVI-B - Module biopython

Le module biopython propose de nombreuses fonctionnalits trs utiles en bioinformatique. Le tutoriel est
particulirement bien fait, n'hsitez pas le consulter.
Voici quelques exemples d'utilisation.
Dfinition d'une squence.
>>> import Bio
>>> from [Link] import Seq
>>> from [Link] import IUPAC
>>> ADN = Seq("ATATCGGCTATAGCATGCA", IUPAC.unambiguous_dna)
>>> ADN
Seq(ATATCGGCTATAGCATGCA, IUPACUnambiguousDNA())

IUPAC.unambiguous_dna signifie que la squence entre est bien une squence d'ADN.
Obtention de la squence complmentaire et complmentaire inverse.
>>> [Link]()
Seq(TATAGCCGATATCGTACGT, IUPACUnambiguousDNA())
>>> ADN.reverse_complement()
Seq(TGCATGCTATAGCCGATAT, IUPACUnambiguousDNA())

Traduction en squence protique.

>>> [Link]()
Seq(ISAIAC, IUPACProtein())

XVI-C - Module matplotlib

Le module matplotlib permet de gnrer des graphes interactifs depuis Python. Il est l'outil complmentaire de
numpy et scipy lorsqu'on veut faire de l'analyse de donnes.
Nous ne prsenterons ici qu'un 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 qu'un 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
- 63 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

plot(x,y)
xlabel(angle (rad))
ylabel(cos(angle))
title(Fonction: y = cos(x))
grid()
show()

Vous devriez obtenir une image comme celle-ci :

Vous constatez que le module matplotlib gnre une fentre graphique interactive permettant l'utilisateur de votre
script de manipuler le graphe (enregistrer comme image, zoomer, etc.).
Revenons maintenant sur le code. Tout d'abord, vous voyez qu'on importe le module qui s'appelle pylab (et non
pas matplotlib). Le module pylab importe lui-mme toutes les fonctions (et variables) du module numpy (e.g. pi, cos,
arange, etc.). Il est plus commode de l'importer par from pylab import * que par import pylab.
La partie qui nous intresse (aprs la ligne # draw the plot) contient les parties spcifiques 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 filigrane.
Jusqu'ici, aucun graphe n'est affich. Pour activer l'affichage l'cran du graphique, il faut appeler la fonction
show(). Celle-ci va activer une boucle dite gtkqui attendra les manipulations de l'utilisateur.
Les commandes Python ventuellement situes aprs la fonction show() seront excutes seulement lorsque
l'utilisateur fermera la fentre graphique (petite croix en haut droite).

Voici maintenant l'exemple 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)
ABSTF = abs(TF)
pas_xABSTF = 1/(4*pi)
x_ABSTF = arange(0,pas_xABSTF * len(ABSTF),pas_xABSTF)
# draw cos plot
plot(x,y)
- 64 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

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 ressembler cela :

On retrouve bien le pic 0,15 radian-1 correspondant 2*pi radians.

Voil, nous esprons que ce petit exemple vous aura convaincu de l'utilit du module matplotlib. Sachez qu'il peut
faire bien plus, par exemple gnrer des histogrammes ou toutes sortes de graphiques utiles en analyse de donnes.

XVI-D - Module rpy

R est un programme extrmement puissant permettant d'effectuer des analyses statistiques. Il contient tout un tas
de fonctions permettant de gnrer divers types de graphiques. Nous 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 type
array, car il est bas sur le module numpy vu prcdemment. Dans cet exemple, nous allons tracer les coordonnes
alatoires de 50 points.
import random
import rpy
# construction dune liste de 50 lments croissants
x = range(1, 51)
# construction dune liste de 50 lments alatoires
y = []
for i in x:
[Link]( [Link]() )
# enregistrement du graphique dans un fichier png
[Link]("rpy_test1.png")
# dessin des points
[Link](x, y, xlab="position", ylab="coordonnes", col="black", pch=3)
# fin du graphique
rpy.r.dev_off()

- 65 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

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 ([Link]()) 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 )
[Link]("rpy_test2.png")
# tri des bases, car unique() nordonne pas les donnes
# alors que table() le fait
seq3 = [Link]( seq2 )
# listes des bases prsentes
bases = [Link]( seq3 )
# effectif de chaque base
effectifs = [Link]( seq3 )
# dessin du barplot et sauvegarde de la position des abscisses
coords = [Link]( effectifs, ylab="nombre de bases")
# ajout du texte pour laxe des abscisses
[Link](coords, -0.5, bases, xpd = True, cex = 1.5, font = 2 )
R.dev_off()

Voici le fichier rpy_test2.png obtenu :

- 66 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

Pour plus de concision, le module rpy.r est renomm 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).

XVI-E - Exercice numpy

Cet exercice prsente le calcul de la distance entre deux carbones alpha conscutifs de la barstar. Il demande
quelques notions d'Unix et ncessite le module numpy de Python.

Tlchargez le fichier [Link] sur le site de la PDB.

Pour que le sparateur dcimal soit le point (au lieu de la virgule, par dfaut sur les systmes d'exploitation
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 fichier 1BTA_CA.txt avec la
commande Unix suivante :
awk $1=="ATOM" && $3=="CA" {printf "%.3f %.3f %.3f ", $7, $8, $9} [Link] > 1BTA_CA.txt

Les coordonnes sont toutes enregistres sur une seule ligne, les unes aprs les autres, dans le fichier 1BTA_CA.txt.

Ouvrez le fichier 1BTA_CA.txt avec Python et crez une liste contenant toutes les coordonnes sous forme
de rels avec les fonctions split() et float().
Avec la fonction array() du module numpy, convertissez cette liste en matrice.
Avec la fonction reshape() de numpy, et connaissant le nombre d'acides amins de la barstar, construisez
une matrice deux dimensions contenant les coordonnes des carbones alpha.
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.
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.
Affichez les distances entre carbones alpha conscutifs et reprez la valeur surprenante.

XVI-F - Exercice rpy

1

Soit la squence protique WVAAGALTIWPILGALVILG. Reprsentez avec le module rpy la distribution des
diffrents acides amins.

- 67 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

Reprenez l'exercice du calcul de la distance entre deux carbones alpha conscutifs de la barstar avec numpy
et reprsentez cette distance avec rpy.

XVII - 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 mthodes (~ fonctions associes aux objets).
Exemple de la classe Rectangle :
class Rectangle:
"ceci est la classe Rectangle"
# initialisation dun objet
# dfinition des attributs avec des valeurs par dfaut
def __init__(self, long = 0.0, larg = 0.0, coul = "blanc"):
[Link] = long
[Link] = larg
[Link] = coul
# dfinition de la mthode qui calcule la surface
def calculSurface(self):
print "surface = %.2f m2" %([Link] * [Link])
# dfinition de la mthode qui transforme un rectangle en carr
def changeCarre(self, cote):
[Link] = cote
[Link] = 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 l'objet lui-mme.
Attention, les mthodes prennent toujours au moins self comme argument.
Exemples d'utilisation de la classe Rectangle :
# cration dun objet Rectangle avec les paramtres par dfaut
rect1 = Rectangle()
print [Link], [Link], [Link]
# sans surprise :
[Link]()
# on change le rectangle en carr
[Link](30)
[Link]()
# cration dun objet Rectangle avec des paramtres imposs
rect2 = Rectangle(2, 3, "rouge")
[Link]()

XVII-A - Exercices
Conseil : pour ces exercices, crivez des scripts dans des fichiers, puis excutez-les dans un shell.
1
2
3

Entranez-vous avec la classe Rectangle. Crez la mthode calculPerimetre() qui calcule le primtre d'un
objet rectangle.
Crez une nouvelle classe Atome avec les attributs x, y, z (qui contiennent les coordonnes atomiques) et la
mthode calculDistance(). Testez cette classe sur plusieurs exemples.
Amliorez la classe Atome avec de nouveaux attributs (par ex. : masse , charge, etc.) et de nouvelles
mthodes (par ex. : calculCentreMasse(), c alculRayonGyration()).

XVIII - Gestion des erreurs

La gestion des erreurs permet d'viter que votre programme plante en prvoyant vous-mme les sources d'erreurs
ventuelles.
- 68 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

Voici un exemple dans lequel on demande l'utilisateur d'entrer 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 l'utilisateur de saisir une chane de caractres. Cette chane de caractres est
ensuite transforme en nombre entier avec la fonction int().
Si l'utilisateur ne rentre pas un nombre, voici ce qui se passe :
>>> nb = int(raw_input("Entrez un nombre: "))
Entrez un nombre: ATCG
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: ATCG

L'erreur provient de la fonction int() qui n'a pas pu convertir la chane de caractres "ATCG" en nombre, ce qui est
normal.
Le jeu d'instructions try/except permet de tester l'excution d'une commande et d'intervenir en cas d'erreur.
>>> try:

nb = int(raw_input("Entrez un nombre: "))

except:

print "Vous navez pas entr un nombre !"

Entrez un nombre: ATCG

Vous navez pas entr un nombre !

Dans cet exemple, l'erreur renvoye par la fonction int() (qui ne peut pas convertir "ATCG" en nombre) est intercepte
et dclenche l'affichage du message d'avertissement.
On peut ainsi redemander sans cesse un nombre l'utilisateur, jusqu' ce que celui-ci en rentre bien un.
>>> while 1:

try:

nb = int(raw_input("Entrez un nombre: "))

print "Le nombre est", nb

break

except:

print "Vous navez pas entr un nombre !"

print "Essayez encore"

Entrez un nombre: ATCG

Vous navez pas entr un nombre !
Essayez encore
Entrez un nombre: toto
Vous navez pas entr un nombre !
Essayez encore
Entrez un nombre: 55
Le nombre est 55

Notez que dans cet exemple, l'instruction while 1 est une boucle infinie (car la condition 1 est toujours vrifie) dont
l'arrt est forc par la commande break lorsque l'utilisateur 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 l'utilisateur (avec la fonction raw_input()) ou par des fichiers.
Vous pouvez par exemple vrifier qu'un fichier a bien t ouvert.

- 69 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

>>> nom = "[Link]"

>>> try:

f = open(nom, "r")
except:

print "Impossible douvrir le fichier", nom

Si une erreur est dclenche, c'est sans doute que le fichier n'existe pas l'emplacement indiqu sur le disque ou
que (sous Unix), vous n'ayez pas les droits d'accs pour le lire.
Il est galement possible de spcifier le type d'erreur grer. Le premier exemple que nous avons tudi peut s'crire :
>>> try:

nb = int(raw_input("Entrez un nombre: "))

except ValueError:

print "Vous navez pas entr un nombre !"

Entrez un nombre: ATCG

Vous navez pas entr un nombre !

Ici, on intercepte une erreur de type ValueError, ce qui correspond bien un problme de conversion avec int(). Il
existe d'autres types d'erreurs comme RuntimeError, TypeError, NameError, IOError, etc.
Enfin, on peut aussi tre trs prcis dans le message d'erreur. Observez la fonction downloadPage() qui, avec le
module urllib2, tlcharge un fichier sur internet.
import urllib2
def downloadPage(address):
error = ""
page = ""
try:
data = [Link](address)
page = [Link]()
except IOError, e:
if hasattr(e, reason):
error = "Cannot reach web server: " + str([Link])
if hasattr(e, code):
error = "Server failed %d" %([Link])
return page, error

La variable e est une instance (un reprsentant) de l'erreur 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).

XIX - Trucs et astuces

XIX-A - Shebang et /usr/bin/env Python
Lorsque vous programmez sur un systme Unix, le shebang correspond aux caractres #! qui se trouve au dbut
de la premire ligne d'un 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, l'excutable 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

- 70 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

Dans le cas prsent, on appelle le programme d'environnement env (qui se situe toujours dans le rpertoire /usr/bin)
pour lui demander o se trouve l'excutable Python.

XIX-A-1 - 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 l'excution de votre script.
Pour viter ce genre de dsagrment, ajoutez la ligne suivante la deuxime ligne ( la position est importante
) de votre script :
# -*- coding: utf-8 -*-

En rsum, tous vos scripts Python devraient ainsi commencer par les lignes :
#! /usr/bin/env Python
# -*- coding: utf-8 -*-

XIX-B - Vitesse d'itration dans les boucles

La vitesse d'itration (de parcours) des lments d'une 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 [Link]) puis
excutez-le.
#! /usr/bin/env Python
# -*- coding: utf-8 -*import time
# cration dune liste de 5 000 000 dlments
# ( adapter suivant la vitesse de vos machines)
taille = 5000000
print "Cration dune liste avec %d lements" %( taille )
toto = range( taille )
# la variable a accde un lment de la liste
# mthode 1
start = [Link]()
for i in range( len(toto) ):
a = toto[i]
print "mthode 1 (for in range) : %.1f secondes" %( [Link]() - start )
# mthode 2
start = [Link]()
for ele in toto:
a = ele
print "mthode 2 (for in) : %.1f secondes" %( [Link]() - start )
# mthode 3
start = [Link]()
for i in xrange( len(toto) ):
a = toto[i]
print "mthode 3 (for in xrange) : %.1f secondes" %( [Link]() - start )
# mthode 4
start = [Link]()
for idx, ele in enumerate( toto ):
a = ele
print "mthode 4 (for in enumerate): %.1f secondes" %( [Link]() - start )

Vous devriez obtenir une sortie similaire celle-ci :

- 71 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

poulain@cumin>
Cration dune
mthode 1 (for
mthode 2 (for
mthode 3 (for
mthode 4 (for

./[Link]
liste avec 5000000 lments
in range) : 1.8 secondes
in) : 1.0 secondes
in xrange) : 1.2 secondes
in enumerate): 1.4 secondes

La mthode la plus rapide pour parcourir une liste est donc d'itrer 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 indices des lments, utilisez plutt la commande for i in xrange(len(liste)), car l'instruction
xrange() ne va pas crer une liste, mais incrmenter un compteur qui correspond l'indice des lments successifs
de la liste.
Enfin, la commande for indice, element in enumerate(liste) est particulirement efficace pour rcuprer en mme
temps l'lment et son indice.

XIX-C - 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 :
print range(0,99)[::2]

Jeu sur la casse des mots d'une phrase :

message = "Cest sympa la BioInfo"
msg_lst = [Link]()
print [[[Link](), [Link](), len(m)] for m in msg_lst]

Formatage d'une squence avec 60 caractres par ligne :

# exemple dune 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 d'une squence (avec la ligne de commentaire)

commentaire = "mon commentaire"
# exemple dune 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)] )
- 72 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]

Cours de Python par Patrick Fuchs - Pierre Poulain

Slection des lignes correspondantes aux carbones alpha dans un fichier pdb :
# ouverture du fichier pdb (par exemple [Link])
pdb = open("[Link]", "r")
# slection des lignes correspondant aux C alpha
CA_line = [line for line in pdb if [Link]()[0] == "ATOM" and [Link]()[2] == "CA"]
# fermeture du fichier
[Link]()
# ventuellement affichage des lignes
print CA_line

XIX-D - Sauvegardez votre historique de commandes

Vous pouvez sauvegarder l'historique des commandes utilises dans l'interprteur Python avec le module readline.
>>> print "hello"
hello
>>> a = 22
>>> a = a + 11
>>> print a
33
>>> import readline
>>> readline.write_history_file()

Quittez Python. L'historique de toutes vos commandes est dans votre rpertoire personnel, dans le fichier .history.
Relancez l'interprteur 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

XX - Remerciements
Un grand merci Sander du CMBI de Nijmegen pour la premire version de ce cours.
Merci galement tous les contributeurs, occasionnels 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. 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 d'viter la tentation de les regarder trop vite, mais vous pouvez nous crire et nous vous les enverrons.
Ce document est sous licence Creative Commons BY-SA
Patrick Fuchs et Pierre Poulain, UFR des Sciences du Vivant, Universit Paris Diderot - Paris 7, version du
17-04-2012.

- 73 Le contenu de cet article a t rdig par Patrick Fuchs et Pierre Poulain et est disponible sous la licence Creative Commons "Paternit Pas d'Utilisation Commerciale". Par contre, les logos
[Link], en-tte, pied de page, css et look & feel de l'article sont eux sous copyright 2013 [Link]

[Link]