AMU :: Polytech Biotech 3A :: JGB53D :: 2014/2015 :: Jacques van Helden, Denis Puthier, Nicolas Terrapon

Contenu

Dans le premier TD nous avons vu ensemble un certain nombre d'objets permettant à python de stocker des informations sous la forme de variables simples (objets de type int, float, str ou bool) ou de tableaux (listes, tuples et dictionnaires).

Lorsque l'on développe un programme on a généralement besoin de tester si une condition est vraie (e.g. l'utilisateur a-t-il soumis un fichier qui existe ou une réponse valide,..). Les informations étant stockées dans des variables le programme doit alors pouvoir interroger les variables et tester leur contenu. Les stuctures conditionnelles (e.g.if ... else) offre la possibilité de réaliser de tels tests.

Par ailleurs, lorsque de l'information réside dans un tableau, il sera souvent nécessaire de parcourir le tableau pour, par exemple, afficher son contenu, tester le contenu de chacune de ses positions, effectuer un calcul à partir de chacune des valeurs. De manière plus générale, lorsque l'on souhaitera répéter une instruction, on utilisera alors, des boucles (for, while,...).

Structures conditionnelles.

Présentation

Une structure conditionnelle permet de tester si une condition est vraie ou fausse. Ces structures conditionnelles évaluent de manière générale un test ou une expression booléenne (e.g. a > 4, b < 4, 5 ≤ b ≤ 10, ...). Dans la structure if...else classique, on exécutera un certain nombre d'instructions si la condition est vraie, et un autre jeu d'intructions si celle-ci s'avère fausse.

Ci-dessous sont présentées un certain nombre de syntaxes possibles pour ces structures de contrôle.

Attention! En python, l'indentation est significative. En particulier, le domaine d'application d'une structure conditionnelle est défini par les lignes qui sont en retrait par rapport à l'instruction initiale.

Une structure if simple: 
if test:                        # 'test' est une expression booléenne (e.g a > 3).
    instruction(s)              # une/des instruction(s) réalisée(s) si la condition est vraie ( e.g print() ).

la structure if...else:

if test:                        # 'test' est une expression booléenne (e.g a > 3).
    instruction(s)              # une/des instruction(s) réalisée(s) si la condition est vraie ( e.g print() ).
else:                           # sinon (si 'test' est faux).
    instruction(s)              # une/des instruction(s) réalisée(s) si la condition est fausse.

la structure if...elif...else:

if test:                        # 'test' est une expression booléenne (e.g a == 1).
    instruction(s)              # une/des instruction(s) réalisée(s) si la condition 'test' est vraie ( e.g print() ).
elif test2:                     # teste une autre expression, 'test2' (e.g a == 2),  si 'test' est faux.
    instruction(s)              # une/des instruction(s) réalisée(s) si la condition 'test2' est vraie. 
elif test3:                     # teste une autre expression, 'test3' (e.g a == 3),  si 'test' et test2 sont faux.
    instruction(s)              # une/des instruction(s) réalisée(s) si la condition 'test3' est vraie. 
else:                           # Sinon, si 'test', 'test2' et 'test3' sont faux alors...               
    instruction(s)              # une/des instruction(s) réalisée(s) si aucune condition n'est vérifiée.

Structures if...else imbriquées

Les instructions réalisées dans le corps d'un if, elif ou else peuvent elles-même comporter des structures conditionnelles:

if test:                        # 'test' est une expression booléenne
    instruction(s)              # une/des instruction(s) réalisée(s) si la condition 'test' est vraie
    if test2:                   # 'test' est une expression booléenne.
        instruction(s)          # une/des instruction(s) réalisée(s) si la condition 'test2' est vraie.
else:
    instruction(s)              # une/des instruction(s) réalisée(s) si la condition 'test' est fausse.

Opérateurs de comparaison

Afin de pouvoir effectuer des tests renvoyant une valeur vraie ou fausse on dispose d'un certain nombre d'opérateurs de comparaison. Les plus fréquemment utilisés sont présentés ci-dessous.

Operateur Description
a == b Opérateur d'égalité. Renvoie true si a et b contiennent des valeurs égales.
a != b Renvoie true si a et b contiennent des valeurs différentes.
a > b Renvoie true si la valeur de a est supérieure à la valeur de b.
a < b Renvoie true si la valeur de a est inférieure à la valeur de b.
a >= b Renvoie true si la valeur de a est supérieure ou égale à la valeur de b.
a <= b Renvoie true si la valeur de a est inférieure ou égale à la valeur de b.
c < a < b Renvoie true si la valeur de a est supérieure ou égale à c et inférieure ou égale à b.
c <= a <= b Renvoie true si la valeur de a est strictement supérieure à c et inférieure à b.

Opérateurs logiques

On a fréquemment besoin de combiner plusieurs test (condition 1 est vraie et condition b est vraie). Pour combiner les opérations de comparaison on utilisera des opérateurs logiques.

Operator Description Example
and L'opérateur logique ET. Renvoie True si les deux conditions sont vraies (sinon False). a < b and c > d
or L'opérateur logique OR. Renvoie True si l'une des deux conditions est vraie (sinon False). a < b or c > d
not L'opérateur de négation logique, NON. Renvoie True si son argument est faux et False si il est vrai. not(a < b)

Boucles.

Présentation

Comme indiqué en introduction, il est souvent nécessaire de réaliser des itérations (boucles). Les deux types de boucles que l'on rencontre le plus fréquemment sont les boucles for et les boucles while, toutes deux implémentées dans le langage Python (qui propose aussi la structure with que nous ne développerons pas ici).

Boucles for

La boucle for peut être utilisée pour répéter une instruction un certain nombre de fois. Elle permet de parcourir des listes, des chaînes de caractères (dont nous avons vu qu'elles ressemblaient dans une certaine mesure aux listes), les clefs d'un dictionnaire, les lignes d'un fichier, etc. En Python, la boucle for se présente typiquement de la manière suivante:

# La variable v prend successivement la valeur des différents éléments de la liste for v in liste: # Pour chaque élément v de la liste instruction(v) # On effectue une opération avec v # La variable v prend successivement la valeur des différents éléments de la liste # La variable p contient la position for p,v in enumerate(liste): # Pour chaque élément v de la liste on énumère sa position (p) et sa valeur (v) instruction(v) # On effectue une opération avec v instruction(p) # On effectue une opération avec p

Ci-dessous, on propose quelques exemples permettant d'illustrer l'utilisation de boucles for:

Copiez-collez les instructions suivantes ligne par ligne dans IPython. Analysez les résultats et répondez aux questions.

In []: 
###################################################
### Effectuer une opération n fois              ###
###################################################
n = 10
for i in range(n):
    print("je le fais")
In []: 
###################################################
### Fonction range()                            ###
###################################################
# help(range)
In [1]: 
###################################################
### Parcourir des listes                        ###
###################################################
chroms = ["Chr1", "Chr2", "Chr3", "Chr4", "Chr5", "Chr6", "Chr7"]

for c in chroms:
    print(c)

Chr1
Chr2
Chr3
Chr4
Chr5
Chr6
Chr7
In [2]: 
for p,c in enumerate(chroms):
    print(p, c)

0 Chr1
1 Chr2
2 Chr3
3 Chr4
4 Chr5
5 Chr6
6 Chr7
In [5]: 
###################################################
### Parcourir des châines de caractères         ###
###################################################
dna = 'ATGCTCGC'

# On passe les en revue les nucléotides contenus dans la séquence
for  nuc in dna:
    print("La séquence contient "+ nuc)

La séquence contient A
La séquence contient T
La séquence contient G
La séquence contient C
La séquence contient T
La séquence contient C
La séquence contient G
La séquence contient C
In [13]: 
# On passe les en revue les nucléotides contenus dans la séquence
for  pos, nuc in enumerate(dna):
    print("La séquence contient un " + nuc + " en position " + str(pos))

La séquence contient un A en position 0
La séquence contient un T en position 1
La séquence contient un G en position 2
La séquence contient un C en position 3
La séquence contient un T en position 4
La séquence contient un C en position 5
La séquence contient un G en position 6
La séquence contient un C en position 7
In [18]: 
###################################################
### Parcourir un Dictionnaire                   ###
###################################################
# Un tableau associatif dont les clefs sont des noms d'utilisateurs
# Et les valeurs des mots de passe
 
login2passwd = {"Alain":"abc123", "John":"qwerty", "Alice":"1234567"} 

# Afficher les clefs
for key in login2passwd: # ou login2passwd.keys()
    print(key)

Alice
Alain
John
In [16]: 
# Afficher les valeurs
for value in login2passwd.values():
    print(value)

1234567
abc123
qwerty
In []: 
# Afficher les clefs et valeurs 
# Il faut utiliser la méthode item()
for key, value in login2passwd.items():
    print("Value is " + value + " for key " + key)

Boucles while

La boucle while permet d'effectuer un jeu d'instruction tant qu'une condition est vrai.

while condition: # Tant que la condition est vraie (e.g. a > 10) alors le jeu d'instructions est exécuté statement(s) # Une ou plusieurs instruction(s) à exécuter

Ci-dessous, on propose quelques exemples permettant d'illustrer l'utilisation de boucles while. Copiez collez les instructions suivantes une ligne après l'autre dans IPython. Analysez les résulats.

In []: 
#########################################
###     Un exemple de boucle while    ###
#########################################

password=None # La variable password est initialisé à None (vide)

# On effectue une boucle while

while password != "^^@@??":                       ## Tant que le mot de passe n'est pas  "^^@@??"
    password = input("Enter a password please:")  ## On demande un nouveau mot de passe à l'utilisateur
print("Welcome")                                     ## On imprime Welcome quand password != "^^@@??
In []: 
## Un exemple de boucle infini:

while True:
    print("C'est vrai et ça le restera longtemps")

Breaks and continue

Comme dans beacoup d'autres langages, le mot clef break, permet de 'casser' une boucle, de l'arrêter avant qu'elle n'arrive à sa fin.

Le mot clef continue permet de passer directement à la prochaine itération, sans effectuer la suite des instructions de cette itération.

In []: 
###########################
###  Break et continue  ###
###########################
## Exemple 1
# La sortie est:
# 0 1 2 3 4

for i in range(10):
    if i==5:
        break
    print(i)

## Exemple 2
# La sortie est 
# 1 2 8 9 10

i = 0
while i < 10:
    i += 1
    if  2 < i < 8:
        continue
    print(i)
In []: