Contrôle d'exécution
====================

Execution conditionnelle
------------------------

Un bloc d'instructions conditionnel est défini avec l'instruction :py:obj:`if` suivie d'une expression de type :py:obj:`bool` et de ``:``. Le bloc doit être indenté. Voici un exemple :

.. code-block:: python
    :linenos:
    
    x = 1.0
    if x > 0:
        print("x est strictement positif")
    
    
``x`` est une variable contenant un flottant. L'expression ``x > 0`` donne un objet de type :py:obj:`bool`. Si sa valeur est :py:obj:`True`, le bloc indenté est exécuté.

Il faut noter que le bloc indenté défini après l'instruction :py:obj:`if` travaille dans le même espace de noms que le code qui contient cette instruction. Ainsi, une variable définie dans ce bloc :

.. code-block:: python
    :linenos:
    
    x = 1.0
    if x > 0:
        print("x est strictement positif")
        signe = 'positif'
        
est visible en dehors du bloc, c'est-à-dire après l'instruction :py:obj:`if`. Bien sûr, dans l'exemple précédent, le nom ``signe`` n'est pas défini si la condition est fausse. Pour remédier à cet inconvénient, on peut utiliser la clause :py:obj:`else`, qui permet de définir le bloc exécuté si la condition est fausse :

.. code-block:: python
    :linenos:
    
    x = 1.0
    if x > 0:
        signe = 'positif'
    else :
        signe = 'négatif ou nul'
    print('x est ' + signe)
    
L'expression située à droite de :py:obj:`if` est le plus souvent de type :py:obj:`bool`, mais il peut aussi s'agir d'un nombre (entier ou flottant), qui est automatiquement converti en :py:obj:`True` si ce nombre est strictement positif.
    
Dans le cas où la condition est fausse, on peut parfois avoir besoin de faire un autre test. Le mot clé :py:obj:`elif` (qui signifie *else if*) permet de le faire :

.. code-block:: python
    :linenos:
    
    x = 0.0
    if x > 0:
        signe = 'positif'
    elif x < 0:
        signe = 'negatif'
    else:
        signe = 'nul'
    print('x est ' + signe)
    
On remarque que la condition *a priori* la moins probable est placée en dernier, ce que l'on essaye de faire en général pour des raisons d'efficacité. 

Boucle conditionnelle
---------------------

L'instruction :py:obj:`while` permet d'exécuter en boucle un bloc d'intructions, tant que la condition donnée est vraie. Par exemple :

.. code-block:: python
    :linenos:
    
    demande = True
    while demande:
        x = float(input("Entrez un nombre positif : "))
        demande = not(x > 0)
            
Ce bloc d'intructions demande à l'utilisateur d'entrer un nombre et répète la demande tant que le nombre saisi n'est pas positif. Ce type de boucle est à utiliser lorsque le nombre d'itérations ne peut être déterminé *a priori*.

Il faut noter l'existence de l'instruction :py:obj:`break`, qui permet de sortir de la boucle à partir de n'importe quel point du bloc, par exemple :

.. code-block:: python
    :linenos:
    
    while True:
        x = float(input("Entrez un nombre positif : "))
        if x > 0:
            break

Cette solution est cependant moins claire, car la condition n'apparaît plus dans l'instruction :py:obj:`while`.   

Tout comme pour le bloc conditionnel, les variables définies dans la boucle continuent d'exister après la boucle, et l'exemple précédent permet de comprendre pourquoi cela est souhaitable.

Boucle for
----------

L'instruction :py:obj:`for` permet de construire une boucle en itérant sur les éléments d'une liste :

.. code-block:: python
    :linenos:
    
    L = [0,3,8,11]
    for n in L:
        print(n)

On peut en faire autant avec un n-uplet ou avec une chaîne de caractères. Si on souhaite disposer aussi des indices des éléments, voici comment procéder :

.. code-block:: python
    :linenos:
    
    L = [0,3,8,11]
    for i,n in enumerate(L):
        print(i,n)

L'objet :py:obj:`range` permet d'itérer sur un nombre entier en progression arithmétique. 
    
.. code-block:: python
    
    range(start,stop,step)
    
Le paramètre ``start`` indique la première valeur, ``stop`` indique la valeur qu'il ne faut pas dépasser et ``step`` est l'incrément (la raison de la suite). L'incrément peut être omis et dans ce cas la valeur 1 est utilisée. L'argument ``start`` peut être omis, auquel cas la valeur 0 est utilisée. Voici un exemple :

.. code-block:: python
    :linenos:
    
    for i in range(10):
        print(i)
        
Il faut remarquer que la variable ``i`` continue d'exister après le bloc de la boucle :

.. code-block:: python
    :linenos:
    
    for i in range(10):
        print(i)
    print(i) # dernière valeur (9)
    
Il est donc possible de poursuivre l'itération :

.. code-block:: python
    :linenos:
    
    for i in range(10):
        print(i)
    for i in range(i+1,20):
        print(i)
        
        
Dans certains cas, il faut passer à l'itération suivante lorsqu'une certaine condition est remplie. L'instruction :py:obj:`continue` permet de le faire :

.. code-block:: python
    :linenos:

    for i in range(0,20,1):
        if (i > 10):
            continue
        print(i) # seuls les nombres <= 10 sont affichés
        
        
Tout comme pour le bloc conditionnel et la boucle while, les variables définies dans la boucle continuent d'exister après la boucle. Autrement dit, le contenu de la boucle travaille dans le même espace de noms que le code qui contient la boucle.