Conditions sur les paramètres

Précondition

Une précondition est une condition à respecter par les paramètres pour que le calcul effectué par la fonction ait un sens.

Par exemple, pour une fonction racine carrée racineCarree(x), le paramètre x est un flottant et l'on imposera la précondition $x \geqslant 0$.

def racineCarree(x):
    """
    x -- flottant
    précondition: x >= 0

    renvoie le flottant racine carrée de x
    """

Précondition dans le code

On peut également renforcer une précondition dans le code à l'aide d'un assert.

La syntaxe:

assert condition à respecter, "Message d'alerte à l'utilisateur en cas de non respect de la précondition"

Exemple:

def racineCarree(x):
    """
    x -- flottant
    précondition:  x >= 0

    renvoie le flottant racine carrée de x
    """
    assert x >= 0, "Le paramètre x doit être positif ou nul."
    return x**0.5

A vous

Tester la fonction racineCarree proposée avec une valeur de x négative. Puis tester avec des valeurs positives.

Exercice

Écrire une fonction prenant en paramètres quatre entiers a, b, c, d et renvoyant en sortie True si la fraction $\frac{a}{b}$ est égale à la fraction $\frac{c}{d}$ et renvoie False sinon.

Quelle précondition semble-t-il raisonnable d'imposer? Utiliser un assert pour le traduire dans le code.

Attention

Le code if a/b == c/d serait une bien mauvaise idée. Rappelez vous: on ne peut pas comparer des flottants!

Pour bien se convaincre que cela engendrera des erreurs, un exemple:

>>> a = 10**20+1
>>> b = 10**20
>>> c = 10**20
>>> d = 10**20

Avec ces nombres, il est clair que l'on a $\frac{c}{d} = 1$ puisque c et d sont égaux mais que $\frac{a}{b} \neq 1$ puisque a et b ne sont pas égaux.

Pourtant:

>>> a/b == c/d
True

de sorte que le test a/b == c/d ne donnera pas une conclusion correcte.

Un code

def fractionsEgales(a, b, c, d):
    """
    a -- entier naturel
    b -- entier naturel 
    précondtion: b non nul
    c -- entier naturel
    d -- entier naturel  
    précondition: d non nul
    """
    assert b != 0, "Attention, le dénominateur b ne peut être nul."
    assert d != 0, "Attention, le dénominateur d ne peut être nul."
    return a*d == b*c