Cours de Python les boucles et comparaisons

Cours de Python

Variables

Une variable est une zone de la mémoire dans laquelle une valeur est stockée. Aux yeux du programmeur, cette variable est définie par un nom, alors que pour l’ordinateur, il s’agit en fait d’une adresse (i.e. une zone particulière de la mémoire).
En Python, la déclaration d’une variable et son initialisation (c.-à-d. la première valeur que l’on va stocker dedans) se fait en même temps. Pour vous en convaincre, regardez puis testez les instructions suivantes après avoir lancé l’interpréteur :
x = 2
Dans cet exemple, nous avons déclaré, puis initialisé la variable x avec la valeur 2. L’inter-préteur nous a ensuite permis de regarder le contenu de la variable juste en tapant son nom. Retenez ceci car c’est une spécificité de l’interpréteur Python, très pratique pour chasser les erreurs (debug) dans un programme. Par contre, la ligne d’un script Python qui contient seule-ment le nom d’une variable (sans aucune autre fonction) n’affichera pas la valeur de la variable à l’écran.

Types

Le type d’une variable correspond à la nature de celle-ci. Les trois types principaux dont nous aurons besoin sont les entiers, les réels et les chaînes de caractères. Bien sûr, 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 effrayés, vous pouvez vous en rendre compte ici).
Dans l’exemple précédent, nous avons stocké un nombre entier (int) dans la variable x, mais il est tout a fait possible de stocker des nombres réels (float) ou des chaînes de caractères (string) :
y = 3.14
y
3.1400000000000001
a = « bonjour »
a
‘bonjour’
b = ‘salut’
b
‘salut’
c =  »’girafe »’
c
‘girafe’
Vous remarquez que Python reconnaît certains types de variable automatiquement (en-tier, réel). Par contre, pour une chaîne de caractères, il faut l’entourer de guillemets (simples, doubles voire triples) afin d’indiquer à Python le début et la fin de la chaîne.
Vous vous posez sans doute une question concernant l’exemple du réel. Si vous avez entré le
chiffre 3.14, pourquoi Python l’imprime-t-il finalement avec des zéros derrière (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 détails techniques, la manière de coder un réel dans l’ordinateur est rarement exacte. Python ne nous le cache pas et le montre lorsqu’il affiche ce nombre.

Nommage

Le nom des variable en Python peut-être constitué de lettres minuscules (a à z), de lettres majuscules (A à Z), de nombres (0 à 9) ou du caractère souligné (_).
Néanmoins, un nom de variable ne doit pas débuter ni par un chiffre, ni par _ et ne peut pas contenir de caractère accentué. Il faut absolument éviter d’utiliser un mot « réservé » 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 différentes. Enfin, n’utilisez jamais d’espace dans un nom de variable puisque celui-ci est le sépérateur d’instructions.

Opérations

Les quatre opérations de base se font de manière simple sur les types numériques (nombres entiers et réels) :
x = 45
x + 2
47
y = 2.5
x + y
47.5
(x * 10) / y
180.0
Remarquez toutefois que si vous mélangez les types entiers et réels, le résultat est renvoyé comme un réel (car ce type est plus général).
L’opérateur puissance utilise le symbole ** et pour obtenir le reste d’une division entière, on utilise le symbole modulo % :
2**3
8
3 % 4
3
8 % 4
0
Opérations sur les chaînes de caractères
Pour les chaînes de caractères, deux opérations sont possibles, l’addition et la multiplica-tion :
chaine = « Salut »
chaine
‘Salut’
chaine +  » Python » ‘Salut Python’
chaine * 3 ‘SalutSalutSalut’
L’opérateur d’addition + permet de concaténer (assembler) deux chaînes de caractères et l’opérateur de multiplication * permet de dupliquer plusieurs fois une chaîne.
Opérations illicites
Attention à ne pas faire d’opération 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
Notez que Python vous donne le maximum d’indices dans son message d’erreur. Dans l’exemple précédent, il vous indique que vous ne pouvez pas mélanger des objets de type str (string, donc des chaînes de caractères) avec des objets de type int (donc des entiers), ce qui est assez logique.
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 différente de 2.0 (nombre réel), de même que 2 (nombre entier) est différent de ‘2’ (chaîne de caractères).

Écriture

Nous avons déjà vu au chapitre précédent la fonction print qui permet d’afficher une chaîne de caractères. 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 remplaçant 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 séparateur , avec la commande print. En regardant de plus près, vous vous aperçe-vrez que Python a automatiquement ajouté un espace à chaque fois que l’on utilisait le sépara-teur ,. Par conséquent, si vous voulez mettre un seul espace entre chaque bloc, vous pouvez retirer ceux de vos chaînes de caractères :
print nom , ‘a’ , x , ‘ans’ John a 32 ans
Pour imprimer deux chaînes de caractères l’une à côté de l’autre sans espace, vous devrez les concaténer :
ani1 = ‘chat’
ani2 = ‘souris’
print ani1, ani2 chat souris
print ani1 + ani2 chatsouris

Écriture formatée

Imaginez que vous vouliez calculer puis afficher la proportion de GC d’un génome. Notez que la proportion de GC s’obtient comme la somme des bases Guanine (G) et Cytosine (C) divisée par le nombre total de bases. Sachant que l’on a 4500 bases G, 2575 bases C pour un total de 14800 bases, vous pourriez faire comme suit (notez bien l’utilisation des parenthèses pour gérer les priorités des opérateurs) :
propGC = (4500.0 + 2575)/14800
print « La proportion de GC est », propGC La proportion de GC est 0.478040540541
Remarquez que si vous aviez fait le calcul avec (4500 + 2575)/14800, vous auriez ob-tenu 0 car tous les nombres sont des entiers et le résultat aurait été, lui aussi, un entier. L’intro-duction de 4500.0 qui est un réel résoud le problème, puisque le calcul se fait alors sur des réels.
Néanmoins, le résultat obtenu présente trop de décimales (onze dans le cas présent). Pour pouvoir écrire le résultat plus lisiblement, vous pouvez utiliser l’opérateur de formatage %. Dans votre cas, vous voulez formater un réel pour l’afficher avec deux puis trois décimales :
print « La proportion de GC est %.2f » % propGC Le proportion de GC est 0.48
print « La proportion de GC est %.3f » % propGC La proportion de GC est 0.478
Le signe % est appelé une première fois (%.2f) pour désigner l’endroit où sera placée la variable dans la chaîne de caractères ; préciser le type de la variable à formater, ici f pour float donc pour un réel ; préciser le formatage voulu, ici .2 soit deux chiffres après la virgule.
Le signe % est rappelé une seconde fois (% propGC) pour indiquer les variables à formater.
Notez que les réels ainsi formatés sont arrondis et non tronqués.
Vous pouvez aussi formatez des entiers avec %i (i comme integer)
nbG = 4500
print « Le génome de cet exemple contient %i guanines » % nbG Le génome de cet exemple contient 4500 guanines
ou mettre plusieurs nombres dans une même chaîne de caractères.
nbG = 4500
nbC = 2575
print « Ce génome contient %i G et %i C, soit une prop de GC de %.2f » \
… % (nbG,nbC,propGC)
Ce génome contient 4500 G et 2575 C, soit une prop de GC de 0.48
Remarque :
Dans l’exemple précédent, 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 formatée, il suffit de le doubler. Toutefois, si l’écriture formatée n’est pas utilisée dans la même chaîne de caractères où vous voulez utilisez le symbole pourcent, cette opération n’est pas nécessaire. Par exemple :
nbG = 4500
nbC = 2575
percGC = propGC * 100
print « Ce génome contient %i G et %i C, soit un %%GC de %.2f » \
… % (nbG,nbC,percGC) , »% »
Ce génome 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 préciser sur combien de caractères vous voulez qu’un résultat soit écrit. Dans la portion de code suivant, le caractère ; sert de séparateur entre les instructions sur une même ligne :
print 10 ; print 100 ; print 1000
10
100
1000
print « %4i » % 10 ; print « %4i » % 100 ; print « %4i » % 1000
10
100
1000
>>>
Ceci est également possible sur les chaînes de caractères (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 formatée. Cela permet d’écrire en colonnes parfaitement alignées. Nous verrons que ceci est très pratique si l’on veut écrire les coordonnées des atomes d’une molécule au format PDB.

Exercices

Conseil : utilisez l’interpréteur Python pour les exercices 2 à 5.
Ouvrez l’interpréteur Python et tapez 1+1. Que se passe-t-il ? Écrivez la même chose dans un script test.py. Exécutez ce script en tapant python test.py dans un shell. Que se passe-t-il ? Pourquoi ?
Calculez le pourcentage de GC avec le code percGC = ((4500 + 2575)/14800)*100 puis affichez le résultat. Que se passe-t-il ? Comment expliquez-vous ce résultat ? Corrigez l’instruction précédente pour calculer correctement le pourcentage de GC. Affichez cette valeur avec deux décimales de précision.
Générez une chaîne de caractères représentant un oligonucléotide polyA (AAAA…) de 20 bases de longueurs, sans taper littéralement toutes les bases.
Suivant le modèle du dessus, générez en une ligne de code un polyA de 20 bases suivi d’un polyGC régulier (GCGCGC…) de 40 bases.
En utilisant l’écriture formatée, affichez en une seule ligne les variables a, b et c dont les valeurs sont respectivement « salut », 102 et 10.318.

Listes

Définition

Une liste est une structure de données qui contient une série de valeurs. Python autorise la construction de liste contenant des valeurs de type différent (par exemple entier et chaîne de caractères), ce qui leur confère une grande flexibilité. Une liste est déclarée par une série de valeurs (ne pas oublier les guillemets, simples ou doubles, s’il s’agit de chaînes de caractères) séparées 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.

Utilisation

Un des gros avantages d’une liste est que vous pouvez appeler ses éléments par leur posi-tion. Ce numéro est appelé indice (ou index) de la liste.
liste : [‘girafe’, ‘tigre’, ‘singe’, ‘souris’]
indice : 0 1 2 3
Soyez très attentifs au fait que les indices d’une liste de n éléments 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 conséquent, si on appelle l’élément 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 bugs inattendus !

Opération sur les listes

Tout comme les chaînes de caractères, les listes supportent l’opérateur + de concaténation, ainsi que l’opérateur * pour la duplication :
ani2 = [‘singe’,’souris’]
ani1 + ani2
[‘girafe’, ‘tigre’, ‘singe’, ‘souris’]
>>> ani1 * 3
[‘girafe’, ‘tigre’, ‘girafe’, ‘tigre’, ‘girafe’, ‘tigre’]

1 Introduction 
1.1 Avant de commencer
1.2 Premier contact avec Python sous Linux
1.3 Premier programme Python
1.4 Commentaires
1.5 Séparateur d’instructions
1.6 Notion de bloc d’instructions et d’indentation
2 Variables 
2.1 Types
2.2 Nommage
2.3 Opérations
3 Écriture 
3.1 Écriture formatée
3.2 Exercices
4 Listes 
4.1 Définition
4.2 Utilisation
4.3 Opération sur les listes
4.4 Indiçage négatif et tranches
4.5 Fonctions range et len
4.6 Listes de listes
4.7 Exercices
5 Boucles et comparaisons
5.1 Boucles for
5.2 Comparaisons
5.3 Boucles while
5.4 Exercices
6 Tests 
6.1 Définition
6.2 Tests à plusieurs cas
6.3 Tests multiples
6.4 Instructions break et continue
6.5 Exercices
7 Fichiers 
7.1 Lecture dans un fichier
7.2 Écriture dans un fichier
7.3 Exercices
8 Modules 
8.1 Définition
8.2 Importation de modules
8.3 Obtenir de l’aide sur les modules importés
8.4 Modules courants
8.5 Module sys : passage d’arguments
8.6 Module os
8.7 Exercices
9 Plus sur les chaînes de caractères 
9.1 Préambule
9.2 Chaînes de caractères et listes
9.3 Caractères spéciaux
9.4 Méthodes associées aux chaînes de caractères
9.5 Conversion de types
9.6 Conversion d’une liste de chaînes de caractères en une chaîne de caractères
9.7 Exercices
10 Plus sur les listes 
10.1 Propriétés des listes
10.2 Test d’appartenance
10.3 Copie de listes
10.4 Exercices
11 Dictionnaires et tuples
11.1 Dictionnaires
11.2 Tuples
11.3 Exercices
12 Fonctions
12.1 Principe
12.2 Définition
12.3 Passage d’arguments
12.4 Portée des variables
12.5 Portée des listes
12.6 Règle LGI
12.7 Exercices
13 Expressions régulières et parsing
13.1 Définition et syntaxe
13.2 Module re et fonction search
13.3 Exercices : extraction des gènes d’un fichier genbank
14 Création de modules 
14.1 Création
14.2 Utilisation
14.3 Exercices
15 Autres modules d’intérêt 
15.1 Module urllib2
15.2 Module pickle
15.2.1 Codage des données
15.2.2 Décodage des données
15.3 Exercices
16 Modules d’intérêt en bioinformatique 
16.1 Module numpy
16.1.1 Objets de type array
16.1.2 Un peu d’algèbre linéaire
16.1.3 Un peu de transformée de Fourier
16.2 Module biopython
16.3 Module matplotlib
16.4 Module rpy
16.5 Exercice numpy
16.6 Exercice rpy
17 Avoir la classe avec les objets
17.1 Exercices
18 Gestion des erreurs 
19 Trucs et astuces 
19.1 Shebang et /usr/bin/env python
19.2 Python et utf-8
19.3 Vitesse d’itération dans les boucles
19.4 Liste de compréhension
19.5 Sauvegardez votre historique de commandes