# 4. D’autres outils de contrôle de flux

Besides the `while` statement just introduced, Python uses the usual flow control statements known from other languages, with some twists.

## 4.1. L’instruction `if`

L’instruction `if` est sans doute la plus connue. Par exemple :

    >>> x = int(raw_input("Please enter an integer: "))
    Please enter an integer: 42
    >>> if x < 0:
    ...     x = 0
    ...     print 'Negative changed to zero'
    ... elif x == 0:
    ...     print 'Zero'
    ... elif x == 1:
    ...     print 'Single'
    ... else:
    ...     print 'More'
    ...
    More

Il peut y avoir un nombre quelconque de parties `elif` et la partie `else` est facultative. Le mot clé `elif` est un raccourci pour else if, mais permet de gagner un niveau d’indentation. Une séquence `if` … `elif` … `elif` … est par ailleurs équivalente aux instructions `switch` ou `case` disponibles dans d’autres langages.

## 4.2. L’instruction `for`

L’instruction `for` que propose Python est un peu différente de celle que l’on peut trouver en C ou en Pascal. Au lieu de toujours itérer sur une suite arithmétique de nombres (comme en Pascal), ou de donner à l’utilisateur la possibilité de définir le pas d’itération et la condition de fin (comme en C), l’instruction `for` en Python itère sur les éléments d’une séquence (qui peut être une liste, une chaîne de caractères…), dans l’ordre dans lequel ils apparaissent dans la séquence. Par exemple :

    >>> # Measure some strings:
    ... words = ['cat', 'window', 'defenestrate']
    >>> for w in words:
    ...     print w, len(w)
    ...
    cat 3
    window 6
    defenestrate 12

Si vous devez modifier la séquence sur laquelle s’effectue l’itération à l’intérieur de la boucle (par exemple pour dupliquer ou supprimer un élément), il est plus que recommandé de commencer par en faire une copie, celle-ci n’étant pas implicite. La notation « par tranches » rend cette opération particulièrement simple :

    >>> for w in words[:]:  # Loop over a slice copy of the entire list.
    ...     if len(w) > 6:
    ...         words.insert(0, w)
    ...
    >>> words
    ['defenestrate', 'cat', 'window', 'defenestrate']

## 4.3. La fonction `range()`

Si vous devez itérer sur une suite de nombres, la fonction intégrée `range()` est faite pour cela. Elle génère une liste contenant une simple progression arithmétique :

    >>> range(10)
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Le dernier élément fourni en paramètre ne fait jamais partie de la liste générée ; `range(10)` génère une liste de 10 valeurs, dont les valeurs vont de 0 à 9. Il est possible de spécifier une valeur de début et/ou une valeur d’incrément différente(s) (y compris négative pour cette dernière, que l’on appelle également parfois le “pas”)

    >>> range(5, 10)
    [5, 6, 7, 8, 9]
    >>> range(0, 10, 3)
    [0, 3, 6, 9]
    >>> range(-10, -100, -30)
    [-10, -40, -70]

Pour itérer sur les indices d’une séquence, on peut combiner les fonctions `range()` et `len()` :

    >>> a = ['Mary', 'had', 'a', 'little', 'lamb']
    >>> for i in range(len(a)):
    ...     print i, a[i]
    ...
    0 Mary
    1 had
    2 a
    3 little
    4 lamb

Cependant, dans la plupart des cas, il est plus pratique d’utiliser la fonction `enumerate()`. Voyez pour cela Techniques de boucles.

## 4.4. Les instructions `break`, `continue` et les clauses `else` au sein des boucles

The `break` statement, like in C, breaks out of the innermost enclosing `for` or `while` loop.

Les boucles peuvent également disposer d’une instruction `else` ; celle-ci est exécutée lorsqu’une boucle se termine alors que tous ses éléments ont été traités (dans le cas d’un `for`) ou que la condition devient fausse (dans le cas d’un `while`), mais pas lorsque la boucle est interrompue par une instruction `break`. L’exemple suivant, qui effectue une recherche de nombres premiers, en est une démonstration :

    >>> for n in range(2, 10):
    ...     for x in range(2, n):
    ...         if n % x == 0:
    ...             print n, 'equals', x, '*', n/x
    ...             break
    ...     else:
    ...         # loop fell through without finding a factor
    ...         print n, 'is a prime number'
    ...
    2 is a prime number
    3 is a prime number
    4 equals 2 * 2
    5 is a prime number
    6 equals 2 * 3
    7 is a prime number
    8 equals 2 * 4
    9 equals 3 * 3

(Oui, ce code est correct. Regardez attentivement : l’instruction `else` est rattachée à la boucle `for`, et non à l’instruction `if`.)

Lorsqu’elle utilisée dans une boucle, la clause `else` est donc plus proche de celle associée à une instruction `try` que de celle associée à une instruction `if` : la clause `else` d’une instruction `try` s’exécute lorsqu’aucune exception n’est déclenchée, et celle d’une boucle lorsque aucun `break` n’intervient. Plus plus d’informations sur l’instruction `try` et le traitement des exceptions, consultez Gestion des exceptions.

L’instruction `continue`, également empruntée au C, fait passer la boucle à son itération suivante :

    >>> for num in range(2, 10):
    ...     if num % 2 == 0:
    ...         print "Found an even number", num
    ...         continue
    ...     print "Found a number", num
    Found an even number 2
    Found a number 3
    Found an even number 4
    Found a number 5
    Found an even number 6
    Found a number 7
    Found an even number 8
    Found a number 9

## 4.5. L’instruction `pass`

L’instruction `pass` ne fait rien. Elle peut être utilisée lorsqu’une instruction est nécessaire pour fournir une syntaxe correcte, mais qu’aucune action ne doit être effectuée. Par exemple :

    >>> while True:
    ...     pass  # Busy-wait for keyboard interrupt (Ctrl+C)
    ...

On utilise couramment cette instruction pour créer des classes minimales :

    >>> class MyEmptyClass:
    ...     pass
    ...

Un autre cas d’utilisation du `pass` est de réserver un espace en phase de développement pour une fonction ou un traitement conditionnel, vous permettant ainsi de construire votre code à un niveau plus abstrait. L’instruction `pass` est alors ignorée silencieusement :

    >>> def initlog(*args):
    ...     pass   # Remember to implement this!
    ...

## 4.6. Définir des fonctions

On peut créer une fonction qui écrit la suite de Fibonacci jusqu’à une limite imposée :

    >>> def fib(n):    # write Fibonacci series up to n
    ...     """Print a Fibonacci series up to n."""
    ...     a, b = 0, 1
    ...     while a < n:
    ...         print a,
    ...         a, b = b, a+b
    ...
    >>> # Now call the function we just defined:
    ... fib(2000)
    0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

Le mot-clé `def` introduit une définition de fonction. Il doit être suivi du nom de la fonction et d’une liste, entre parenthèses, de ses paramètres. L’instruction qui constitue le corps de la fonction débute à la ligne suivante et doit être indentée.

La première instruction d’une fonction peut, de façon facultative, être une chaîne de caractères littérale ; cette chaîne de caractères sera alors la chaîne de documentation de la fonction, appelée docstring (consultez la section Chaînes de documentation pour en savoir plus). Il existe des outils qui utilisent ces chaînes de documentation pour générer automatiquement une documentation en ligne ou imprimée, ou pour permettre à l’utilisateur de naviguer de façon interactive dans le code ; prenez-en l’habitude, c’est une bonne pratique que de documenter le code que vous écrivez !

L’exécution d’une fonction introduit une nouvelle table de symboles utilisée par les variables locales de la fonction. Plus précisément, toutes les affectations de variables effectuées au sein d’une fonction stockent la valeur dans la table de symboles locale ; en revanche, les références de variables sont recherchées dans la table de symboles locale, puis dans la table de symboles locale des fonctions englobantes, puis dans la table de symboles globale et finalement dans la table de noms des primitives. Par conséquent, bien qu’elles puissent être référencées, il est impossible d’affecter une valeur à une variable globale (sauf en utilisant une instruction `global`).

Les paramètres effectifs (arguments) d’une fonction sont introduits dans la table de symboles locale de la fonction appelée au moment où elle est appelée ; par conséquent, les passages de paramètres se font par valeur, la valeur étant toujours une référence à un objet et non la valeur de l’objet lui-même. 1 Lorsqu’une fonction appelle une autre fonction, une nouvelle table de symboles locale est créée pour cet appel.

Une définition de fonction introduit le nom de la fonction dans la table de symboles courante. La valeur du nom de la fonction est un type qui est reconnu par l’interpréteur comme une fonction utilisateur. Cette valeur peut être affectée à un autre nom qui pourra alors être utilisé également comme une fonction. Ceci fournit un mécanisme de renommage général :

    >>> fib
    <function fib at 10042ed0>
    >>> f = fib
    >>> f(100)
    0 1 1 2 3 5 8 13 21 34 55 89

Si vous venez d’autres langages, vous pouvez penser que `fib` n’est pas une fonction mais une procédure, puisqu’elle ne renvoie pas de résultat. En fait, même les fonctions sans instruction `return` renvoient une valeur, quoique ennuyeuse. Cette valeur est appelée `None` (c’est le nom d’une primitive). Écrire la valeur `None` est normalement supprimé par l’interpréteur lorsqu’il s’agit de la seule value écrite. Vous pouvez le voir si vous y tenez vraiment en utilisant `print`

    >>> fib(0)
    >>> print fib(0)
    None

Il est facile d’écrire une fonction qui renvoie une liste de la série de Fibonacci au lieu de l’afficher :

    >>> def fib2(n):  # return Fibonacci series up to n
    ...     """Return a list containing the Fibonacci series up to n."""
    ...     result = []
    ...     a, b = 0, 1
    ...     while a < n:
    ...         result.append(a)    # see below
    ...         a, b = b, a+b
    ...     return result
    ...
    >>> f100 = fib2(100)    # call it
    >>> f100                # write the result
    [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Cet exemple, comme d’habitude, illustre de nouvelles fonctionnalités de Python :

- L’instruction `return` provoque la sortie de la fonction en renvoyant une valeur. `return` sans expression en paramètre renvoie `None`. Arriver à la fin d’une fonction renvoie également `None`.

- L’instruction `result.append(a)` appelle une méthode de l’objet `result` qui est une liste. Une méthode est une fonction qui « appartient » à un objet et qui est nommée `obj.methodname`, où `obj` est un objet (il peut également s’agir d’une expression) et `methodname` est le nom d’une méthode que le type de l’objet définit. Différents types définissent différentes méthodes. Des méthodes de différents types peuvent porter le même nom sans qu’il n’y ait d’ambigüité (vous pouvez définir vos propres types d’objets et leurs méthodes en utilisant des classes, voir Classes). La méthode `append()` donnée dans cet exemple est définie pour les listes ; elles ajoute un nouvel élément à la fin de la liste. Dans cet exemple, elle est l’équivalent de `result = result + [a]`, mais elle est plus efficace.

## 4.7. D’avantage sur la définition des fonctions

Il est également possible de définir des fonctions avec un nombre variable d’arguments. Trois syntaxes peuvent être utilisées, éventuellement combinées.

### 4.7.1. Valeur par défaut des arguments

La forme la plus utile consiste à indiquer une valeur par défaut pour certains arguments. Ceci crée une fonction qui pourra être appelée avec moins d’arguments que ceux présents dans sa définition. Par exemple :

    def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
        while True:
            ok = raw_input(prompt)
            if ok in ('y', 'ye', 'yes'):
                return True
            if ok in ('n', 'no', 'nop', 'nope'):
                return False
            retries = retries - 1
            if retries < 0:
                raise IOError('refusenik user')
            print complaint

Cette fonction peut être appelée de plusieurs façons :

- en ne fournissant que les arguments obligatoires : `ask_ok('Do you really want to quit?')`

- en fournissant une partie des arguments facultatifs : `ask_ok('OK to overwrite the file?', 2)`

- en fournissant tous les arguments : `ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')`

Cet exemple présente également le mot-clé `in`. Celui-ci permet de tester si une séquence contient une certaine valeur.

Les valeurs par défaut sont évaluées lors de la définition de la fonction dans la portée de définition, de telle sorte que :

    i = 5

    def f(arg=i):
        print arg

    i = 6
    f()

Affiche `5`.

Avertissement important : la valeur par défaut n’est évaluée qu’une seule fois. Ceci fait une différence lorsque cette valeur par défaut est un objet muable tel qu’une liste, un dictionnaire ou des instances de la plupart des classes. Par exemple, la fonction suivante accumule les arguments qui lui sont passés au fil des appels successifs :

    def f(a, L=[]):
        L.append(a)
        return L

    print f(1)
    print f(2)
    print f(3)

Ceci affiche :

    [1]
    [1, 2]
    [1, 2, 3]

Si vous ne voulez pas que cette valeur par défaut soit partagée entre des appels successifs, vous pouvez écrire la fonction de cette façon :

    def f(a, L=None):
        if L is None:
            L = []
        L.append(a)
        return L

### 4.7.2. Les arguments nommés

Les fonctions peuvent également être appelées en utilisant des arguments nommés sous la forme `kwarg=value`. Par exemple, la fonction suivante :

    def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
        print "-- This parrot wouldn't", action,
        print "if you put", voltage, "volts through it."
        print "-- Lovely plumage, the", type
        print "-- It's", state, "!"

accepte un argument obligatoire (`voltage`) et trois arguments facultatifs (`state`, `action` et `type`). Cette fonction peut être appelée de n’importe laquelle des façons suivantes :

    parrot(1000)                                          # 1 positional argument
    parrot(voltage=1000)                                  # 1 keyword argument
    parrot(voltage=1000000, action='VOOOOOM')             # 2 keyword arguments
    parrot(action='VOOOOOM', voltage=1000000)             # 2 keyword arguments
    parrot('a million', 'bereft of life', 'jump')         # 3 positional arguments
    parrot('a thousand', state='pushing up the daisies')  # 1 positional, 1 keyword

mais tous les appels qui suivent sont incorrects :

    parrot()                     # required argument missing
    parrot(voltage=5.0, 'dead')  # non-keyword argument after a keyword argument
    parrot(110, voltage=220)     # duplicate value for the same argument
    parrot(actor='John Cleese')  # unknown keyword argument

Dans un appel de fonction, les arguments nommés doivent suivre les arguments positionnés. Tous les arguments nommés doivent correspondre à l’un des arguments acceptés par la fonction (par exemple, `actor` n’est pas un argument accepté par la fonction `parrot`), mais leur ordre n’est pas important. Ceci inclut également les arguments facultatifs (`parrot(voltage=1000)` est également correct). Aucun argument ne peut recevoir une valeur plus d’une fois, comme l’illustre cet exemple incorrect du fait de cette restriction :

    >>> def function(a):
    ...     pass
    ...
    >>> function(0, a=0)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: function() got multiple values for keyword argument 'a'

Quand un dernier paramètre formel est présent sous la forme `**name`, il reçoit un dictionnaire (voir Les types de correspondances — dict) contenant tous les arguments nommés à l’exception de ceux correspondant à un paramètre formel. Ceci peut être combiné à un paramètre formel sous la forme `*name` (décrit dans la section suivante) qui lui reçoit un tuple contenant les arguments positionnés au-delà de la liste des paramètres formels (`*name` doit être présent avant `**name`). Par exemple, si vous définissez une fonction comme ceci :

    def cheeseshop(kind, *arguments, **keywords):
        print "-- Do you have any", kind, "?"
        print "-- I'm sorry, we're all out of", kind
        for arg in arguments:
            print arg
        print "-" * 40
        keys = sorted(keywords.keys())
        for kw in keys:
            print kw, ":", keywords[kw]

Elle pourrait être appelée comme ceci :

    cheeseshop("Limburger", "It's very runny, sir.",
               "It's really very, VERY runny, sir.",
               shopkeeper='Michael Palin',
               client="John Cleese",
               sketch="Cheese Shop Sketch")

et, bien sûr, elle affiche :

    -- Do you have any Limburger ?
    -- I'm sorry, we're all out of Limburger
    It's very runny, sir.
    It's really very, VERY runny, sir.
    ----------------------------------------
    client : John Cleese
    shopkeeper : Michael Palin
    sketch : Cheese Shop Sketch

Notez que la liste des arguments nommés est créée en classant les clés du dictionnaire extraites par la méthode `keys()` avant de les afficher. Si cela n’est pas fait, l’ordre dans lequel les arguments sont affichés n’est pas défini.

### 4.7.3. Listes d’arguments arbitraires

Pour terminer, l’option la moins fréquente consiste à indiquer qu’une fonction peut être appelée avec un nombre arbitraire d’arguments. Ces arguments sont intégrés dans un tuple (voir Tuples et séquences). Avant le nombre variable d’arguments, zéro arguments normaux ou plus peuvent apparaître :

    def write_multiple_items(file, separator, *args):
        file.write(separator.join(args))

### 4.7.4. Séparation des listes d’arguments

La situation inverse intervient lorsque les arguments sont déjà dans une liste ou un tuple mais doivent être séparés pour un appel de fonction nécessitant des arguments positionnés séparés. Par exemple, la primitive `range()` attend des arguments start et stop distincts. S’ils ne sont pas disponibles séparément, écrivez l’appel de fonction en utilisant l’opérateur `*` pour séparer les arguments présents dans une liste ou un tuple :

    >>> range(3, 6)             # normal call with separate arguments
    [3, 4, 5]
    >>> args = [3, 6]
    >>> range(*args)            # call with arguments unpacked from a list
    [3, 4, 5]

De la même façon, les dictionnaires peuvent fournir des arguments nommés en utilisant l’opérateur `**` :

    >>> def parrot(voltage, state='a stiff', action='voom'):
    ...     print "-- This parrot wouldn't", action,
    ...     print "if you put", voltage, "volts through it.",
    ...     print "E's", state, "!"
    ...
    >>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
    >>> parrot(**d)
    -- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

### 4.7.5. Fonctions anonymes

Avec le mot-clé `lambda`, vous pouvez créer de petites fonctions anonymes. En voici une qui renvoie la somme de ses deux arguments : `lambda a, b: a+b`. Les fonctions lambda peuvent être utilisées partout où un objet fonction est attendu. Elles sont syntaxiquement restreintes à une seule expression. Sémantiquement, elles ne sont que du sucre syntaxique pour une définition de fonction normale. Comme les fonctions imbriquées, les fonctions lambda peuvent référencer des variables de la portée englobante :

    >>> def make_incrementor(n):
    ...     return lambda x: x + n
    ...
    >>> f = make_incrementor(42)
    >>> f(0)
    42
    >>> f(1)
    43

L’exemple précédent utilise une fonction anonyme pour renvoyer une fonction. Une autre utilisation classique est de donner une fonction minimaliste directement en tant que paramètre :

    >>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
    >>> pairs.sort(key=lambda pair: pair[1])
    >>> pairs
    [(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

### 4.7.6. Chaînes de documentation

Il existe des conventions émergeantes concernant le contenu et le format des chaînes de documentation.

La première ligne devrait toujours être courte et résumer de manière concise l’utilité de l’objet. Afin d’être bref, nul besoin de rappeler le nom de l’objet ou son type, qui sont accessibles par d’autres moyens (sauf si le nom est un verbe qui décrit une opération). Cette ligne devrait commencer avec une majuscule et se terminer par un point.

S’il y a d’autres lignes dans la chaîne de documentation, la deuxième ligne devrait être vide, pour la séparer visuellement du reste de la description. Les autres lignes peuvent alors constituer un ou plusieurs paragraphes décrivant le mode d’utilisation de l’objet, ses effets de bord, etc.

L’analyseur de code Python ne supprime pas l’indentation des chaînes de caractères littérales multi-lignes, donc les outils qui utilisent la documentation doivent si besoin faire cette opération eux-mêmes. La convention suivante s’applique : la première ligne non vide après la première détermine la profondeur d’indentation de l’ensemble de la chaîne de documentation (on ne peut pas utiliser la première ligne qui est généralement accolée aux guillemets d’ouverture de la chaîne de caractères et dont l’indentation n’est donc pas visible). Les espaces « correspondant » à cette profondeur d’indentation sont alors supprimés du début de chacune des lignes de la chaîne. Aucune ligne ne devrait présenter un niveau d’indentation inférieur mais si cela arrive, toutes les espaces situés en début de ligne doivent être supprimées. L’équivalent des espaces doit être testé après expansion des tabulations (normalement remplacés par 4 espaces).

Voici un exemple de chaîne de documentation multi-lignes :

    >>> def my_function():
    ...     """Do nothing, but document it.
    ...
    ...     No, really, it doesn't do anything.
    ...     """
    ...     pass
    ...
    >>> print my_function.__doc__
    Do nothing, but document it.

        No, really, it doesn't do anything.

## 4.8. Aparté : le style de codage

Maintenant que vous êtes prêt à écrire des programmes plus longs et plus complexes, il est temps de parler du style de codage. La plupart des langages peuvent être écrits (ou plutôt formatés) selon différents styles ; certains sont plus lisibles que d’autres. Rendre la lecture de votre code plus facile aux autres est toujours une bonne idée et adopter un bon style de codage peut énormément vous y aider.

En Python, la plupart des projets adhèrent au style défini dans la PEP 8 ; elle met en avant un style de codage très lisible et agréable à l’œil. Chaque développeur Python se doit donc de la lire et de s’en inspirer autant que possible ; voici ses principaux points notables :

- Utilisez des indentations de 4 espaces et pas de tabulation.

  4 espaces constituent un bon compromis entre une indentation courte (qui permet une profondeur d’imbrication plus importante) et une longue (qui rend le code plus facile à lire). Les tabulations introduisent de la confusion et doivent être proscrites autant que possible.

- Faites en sorte que les lignes ne dépassent pas 79 caractères, au besoin en insérant des retours à la ligne.

  Vous facilitez ainsi la lecture pour les utilisateurs qui n’ont qu’un petit écran et, pour les autres, cela leur permet de visualiser plusieurs fichiers côte à côte.

- Utilisez des lignes vides pour séparer les fonctions et les classes, ou pour scinder de gros blocs de code à l’intérieur de fonctions.

- Lorsque c’est possible, placez les commentaires sur leur propres lignes.

- Utilisez les chaînes de documentation.

- Utilisez des espaces autour des opérateurs et après les virgules, mais pas juste à l’intérieur des parenthèses : `a = f(1, 2) + g(3, 4)`.

- Nommez toujours vos classes et fonctions de la même manière ; la convention est d’utiliser une notation `CamelCase` pour les classes, et `minuscules_avec_trait_bas` pour les fonctions et méthodes. Utilisez toujours `self` comme nom du premier argument des méthodes (voyez Une première approche des classes pour en savoir plus sur les classes et les méthodes).

- N’utilisez pas d’encodages exotiques dès lors que votre code est sensé être utilisé dans des environnements internationaux. L’ASCII est encore ce qui marche le mieux dans la plupart des cas.

Notes

1

  En fait, appels par référence d’objets serait sans doute une description plus juste dans la mesure où, si un objet muable est passé en argument, l’appelant verra toutes les modifications qui lui auront été apportées par l’appelé (insertion d’éléments dans une liste…).