Structures de contrôle

Dans le dernier exercice du chapitre précédent, on a recopié 11 fois la même ligne, pour tester 11 valeurs différentes de distance pour une station donnée. C'est problématique par plusieurs aspects :

• C'est difficile et long à lire
• Si on veut tester plus de valeurs de distance, on doit recopier encore et toujours plus de lignes
• Si on veut tester une autre station, on doit changer toutes les lignes.

La syntaxe de Python permet d'exprimer des structures de contrôle. Ce sont des constructions pour altérer l'ordre dans laquelle les instructions d'un programme sont executées. Par exemple :

• Répéter une ou plusieurs instructions un certain nombre de fois.
• Répéter une ou plusieurs instructions tant qu'une condition est vérifiée.
• Executer une ou plusieurs instructions si une condition est vérifiée.

Boucle for

Pour répéter une instruction un certain nombre de fois, on peut utiliser une boucle for. Sa syntaxe est la suivante :

SyntaxeExemple

for v in range(debut, fin):
    instructions

La variable v prends successivement chaque valeur entre debut (inclus) et fin (exclus). Les instructions instructions sont exécutées pour chaque valeur de v.

for i in range(1, 5):
    print("i vaut : ")
    print(i)

Affiche :

i vaut : 
1
i vaut : 
2
i vaut : 
3
i vaut : 
4

Exercice

EnoncéAideSolution

Réécrivez le code de l'exercice du chapitre précédent en utilisant une boucle for, testant cette fois-ci les valeurs distance de 1 à 150. Ajoutez éventuellement un affichage de la distance pour plus de lisibilité...

Utilisez une boucle for. Attention à ne pas vous tromper dans les bornes début et fin !

def irradiance(r):
        return (5535.8/r)**2

def station_compatible(ir_min, ir_max, distance):
    """ir_min, ir_max les irradiances minimales et maximales que peut supporter la stations, en watts par mètre carré.
    distance la distance au soleil, en millions de kilomètres

    >>> station_compatible(9800, 12000, 125)
    False

    >>> station_compatible(2000, 3000, 120)
    True

    >>> station_compatible(1000, 2000, 120)
    False
    """
    return ir_min <= irradiance(distance) <= ir_max

#Le programme en question commence ici
for distance in range(1, 151):
    print(distance)
    print(station_compatible(2000, 3000, distance))

Instruction conditionnelle if

On peut choisir d'executer des instructions uniquement si une condition est vraie en utilisant l'instruction conditionnelle if. Voici sa syntaxe :

=== "Syntaxe

```python
if condition:
    instructions
```

Si la valeur booléenne `condition` vaut `True`, alors les instructions `instructions` sont executées. Sinon, elles sont ignorées.

Example

a = 2
if a == 2:
    print("a vaut 2")
if a != 2:
    print("a ne vaut pas 2")

affiche

a vaut 2

Exercice

EnoncéAideSolution

Ecrivez une fonction distance_min, qui prends en paramètre des valeurs mini et maxi d'irradiance, et retourne la distance minimale entre 1 et 150 millions de kms avec laquelle la station est compatible.

def distance_min(irr_min, irr_max):
    """ir_min, ir_max les irradiances minimales et maximales que peut supporter la stations, en watts par mètre carré.
    retourne la distance minimale au soleil à laquelle la station fonctionne en millions de kilomètres

    >>> distance_min(2000, 3000)
    102
    """

Remarque : utiliser une instruction return dans une boucle for interromp la boucle.

Utilisez une boucle for. Testez chaque distance entre 1 et 150 avec station_compatible, qui retourne un booléen. Retournez la première distance compatible.

def irradiance(r):
        return (5535.8/r)**2

def station_compatible(ir_min, ir_max, distance):
    """ir_min, ir_max les irradiances minimales et maximales que peut supporter la stations, en watts par mètre carré.
    distance la distance au soleil, en millions de kilomètres

    >>> station_compatible(9800, 12000, 125)
    False

    >>> station_compatible(2000, 3000, 120)
    True

    >>> station_compatible(1000, 2000, 120)
    False
    """
    return ir_min <= irradiance(distance) <= ir_max

def distance_min(irr_min, irr_max):
    """ir_min, ir_max les irradiances minimales et maximales que peut supporter la stations, en watts par mètre carré.
    retourne la distance minimale au soleil à laquelle la station fonctionne en millions de kilomètres

    >>> distance_min(2000, 3000)
    102
    """
    for distance in range(1, 151):
        if station_compatible(irr_min, irr_max, distance):
            return distance

Boucle while

En fait, notre fonction à un problème : rien ne nous garantis que la distance mini de notre station est inférieure à 150 millions de kilomètres.

On ne veut donc pas vérifier chaque distance entre 1 et 150 millions de kilomètre, mais plutôt tester chaque distance à partir de 1 jusqu'à en trouver une compatible.

Pour ça, on va utiliser une boucle while, qui permet de répéter des instructions tant qu'une condition est vraie, avec la syntaxe suivante :

SyntaxeExemple

while condition:
    instructions

Tant que la valeur booléenne condition est True, les instructions instructions sont répétées

i = 1
while i < 5:
    print("i vaut")
    print(i)
    i = i + 1 #on augmente la valeur de i

affiche :

i vaut
1
i vaut
2
i vaut
3
i vaut
4

Exercice

EnoncéAideSolution

Ecrivez une fonction distance_min, qui prends en paramètre des valeurs mini et maxi d'irradiance, et retourne la distance minimale en millions de kms avec laquelle la station est compatible.

def distance_min(irr_min, irr_max):
    """ir_min, ir_max les irradiances minimales et maximales que peut supporter la stations, en watts par mètre carré.
    retourne la distance minimale au soleil à laquelle la station fonctionne en millions de kilomètres

    >>> distance_min(2000, 3000)
    102

    >>> distance_min(200, 300)
    320
    """

Remarque : utiliser une instruction return dans une boucle while interromp la boucle. Mais vous n'en aurez pas besoin ici.

Remarque : not permet d'inverser un booléen : not True vaut False. not False vaut True.

Utilisez une boucle while. Testez chaque distance à partir de 1 avec station_compatible, qui retourne un booléen. Retournez la première distance compatible.

def irradiance(r):
        return (5535.8/r)**2

def station_compatible(ir_min, ir_max, distance):
    """ir_min, ir_max les irradiances minimales et maximales que peut supporter la stations, en watts par mètre carré.
    distance la distance au soleil, en millions de kilomètres

    >>> station_compatible(9800, 12000, 125)
    False

    >>> station_compatible(2000, 3000, 120)
    True

    >>> station_compatible(1000, 2000, 120)
    False
    """
    return ir_min <= irradiance(distance) <= ir_max

def distance_min(irr_min, irr_max):
    """ir_min, ir_max les irradiances minimales et maximales que peut supporter la stations, en watts par mètre carré.
    retourne la distance minimale au soleil à laquelle la station fonctionne en millions de kilomètres

    >>> distance_min(2000, 3000)
    102

    >>> distance_min(200, 300)
    320
    """
    distance = 1
    while not station_compatible(irr_min, irr_max, distance):
        distance = distance + 1
    return distance

Exercice

EnoncéAideSolution

Ecrivez une fonction distance_max, qui prends en paramètre des valeurs mini et maxi d'irradiance, et retourne la plus grande distance à laquelle la station est compatible.

def distance_max(irr_min, irr_max):
    """ir_min, ir_max les irradiances minimales et maximales que peut supporter la stations, en watts par mètre carré.
    retourne la distance maximale au soleil à laquelle la station fonctionne en millions de kilomètres

    >>> distance_max(2000, 3000)
    102

    >>> distance_max(200, 300)
    320
    """

Utilisez une boucle while. Testez chaque distance à partir de la distance min, obstenue avec distance_min avec station_compatible, qui retourne un booléen. Retournez la première distance non compatible, moins un.

def irradiance(r):
        return (5535.8/r)**2

def station_compatible(ir_min, ir_max, distance):
    """ir_min, ir_max les irradiances minimales et maximales que peut supporter la stations, en watts par mètre carré.
    distance la distance au soleil, en millions de kilomètres

    >>> station_compatible(9800, 12000, 125)
    False

    >>> station_compatible(2000, 3000, 120)
    True

    >>> station_compatible(1000, 2000, 120)
    False
    """
    return ir_min <= irradiance(distance) <= ir_max


def distance_min(irr_min, irr_max):
    """ir_min, ir_max les irradiances minimales et maximales que peut supporter la stations, en watts par mètre carré.
    retourne la distance minimale au soleil à laquelle la station fonctionne en millions de kilomètres

    >>> distance_min(2000, 3000)
    102

    >>> distance_min(200, 300)
    320
    """
    distance = 1
    while not station_compatible(irr_min, irr_max, distance):
        distance = distance + 1
    return distance

def distance_max(irr_min, irr_max):
    """ir_min, ir_max les irradiances minimales et maximales que peut supporter la stations, en watts par mètre carré.
    retourne la distance maximale au soleil à laquelle la station fonctionne en millions de kilomètres

    >>> distance_max(2000, 3000)
    123

    >>> distance_max(200, 300)
    391
    """
    distance = distance_min(irr_min, irr_max)
    while station_compatible(irr_min, irr_max, distance):
        distance = distance + 1
    return distance - 1