Chapitre 4 - Les fonctions

Nous avons déjà vu beaucoup de fonctions : print(), type(), len(), range()...

Ce sont des fonctions pré-définies (built-in functions).

Nous avons aussi la possibilité de créer nos propres fonctions !

Intérêt des fonctions

Une fonction est une portion de code que l'on peut appeler au besoin (c'est une sorte de sous-programme).

L'utilisation des fonctions évite des redondances dans le code : on obtient ainsi des programmes plus courts et plus lisibles.

Par exemple, nous avons besoin de convertir à plusieurs reprises des degrés Celsius en degrés Fahrenheit :

print(100.0*9.0/5.0+32.0)

print(37.0*9.0/5.0+32.0)

print(233.0*9.0/5.0+32.0)

La même chose en utilisant une fonction :

def F(DegreCelsius):
    print(DegreCelsius*9.0/5.0+32.0)

F(100)

F(37)

x=233
F(x)

Avantages des fonctions

Éviter la duplication du code (factorisation du code).
Améliorer la conception : décompose un problème initial complexe en sous problèmes plus simples
Mettre en valeur les entrées et les sorties
Permettre la réutilisation ultérieure (avec l'instruction import)

L'instruction def

Syntaxe :

    def NomDeLaFonction(parametre1,parametre2,parametre3,...):
        """ Documentation
        qu'on peut écrire
        sur plusieurs lignes """    # docstring entouré de 3 guillemets (ou apostrophes)

        bloc d'instructions     # attention à l'indentation

        return resultat         # la fonction retourne le contenu de la variable resultat

Exemple n°1

def MaPremiereFonction():   # cette fonction n'a pas de paramètre
    """ Cette fonction affiche 'Bonjour' """
    print("Bonjour")
    return          # cette fonction ne retourne rien ('None')
                # l'instruction return est ici facultative

Une fois la fonction définie, nous pouvons l'appeler :

MaPremiereFonction()    # ne pas oublier les parenthèses ()

L'accès à la documentation se fait avec la fonction pré-définie help():

help(MaPremiereFonction)    # affichage de la documentation

Exemple n°2

La fonction suivante simule le comportement d'un dé à 6 faces.

Pour cela, on utilise la fonction randint() du module random.

def TirageDe():
    """ Retourne un nombre entier aléatoire entre 1 et 6 """
    import random
    valeur = random.randint(1,6)
    return valeur

print(TirageDe())

print(TirageDe())

a=TirageDe()
print(a)

Exemple n°3

# définition des fonctions
def Info():
    """ Informations """
    print("Touche q pour quitter")
    print("Touche Enter pour continuer")

def TirageDe():
    """ Retourne un nombre entier aléatoire entre 1 et 6 """
    import random
    valeur = random.randint(1,6)
    return valeur

Info()
while True:
    choix = input()
    if choix == 'q':
        break
    print("Tirage :",TirageDe())

Exemple n°4

Une fonction avec deux paramètres :

# définition de fonction
def TirageDe2(valeurMin,valeurMax):
    """ Retourne un nombre entier aléatoire entre valeurMin et valeurMax """
    import random
    return random.randint(valeurMin,valeurMax)

# début du programme
for i in range(5):
    print(TirageDe2(1,10))  # appel de la fonction avec les arguments 1 et 10

Exemple n°5

Une fonction qui affiche la parité d'un nombre entier. Il peut y avoir plusieurs instructions return dans une fonction.

L'instruction return provoque le retour immédiat de la fonction.

# définition de fonction
def Parite(nombre):
    """ Affiche la parité d'un nombre entier """
    if (nombre % 2) == 1:   # L'opérateur % donne le reste d'une division euclidienne
        print(nombre,"est impair")
        return
    if (nombre % 2) == 0:
        print(nombre,"est pair")
        return

# début du programme
Parite(13)
Parite(24)

Portée de variables : variables globales et locales

La portée d'une variable est l'endroit du programme où on peut accéder à la variable. Observons le script suivant :

a = 10  # variable globale au programme

def MaFonction():
    a = 20  # variable locale à la fonction
    print a
    return

print(a)    # nous sommmes dans l'espace global du programme

MaFonction()    # nous sommes dans l'espace local de la fonction

print(a)    # de retour dans l'espace global

La variable a de valeur 20 est créée dans la fonction : c'est une variable locale à la fonction.

Elle est détruite dès que l'on sort de la fonction.

L'instruction global rend une variable globale (Je sais, c'est fou !) :

a = 10  # variable globale

def MaFonction():
    global a    # la variable est maintenant globale
    a = 20
    print(a)
    return

print(a)

MaFonction()

print(a)

Remarque

il est préférable d'éviter l'utilisation de l'instruction global car c'est une source d'erreurs (on peut modifier le contenu d'une variable sans s'en rendre compte, surtout dans les gros programmes).

Exercices

Exercice 4.1 ☆

Écrire une fonction carre() qui retourne le carré d'un nombre :
```
    print(carre(11.11111))
    123.4567654321
```

Avec une boucle while et la fonction carre(), écrire un script qui affiche le carré des nombres entiers de 1 à 100 :

    1² = 1
    2² = 4
    3² = 9
    ...
    99² = 9801
    100² = 10000
    Fin du programme

Exercice 4.2 ☆

Ecrire une fonction qui retourne l'aire de la surface d'un disque de rayon \(R\) .

Exemple :

    print(AireDisque(2.5))
    19.6349540849

Exercice 4.3 ★

Écrire une fonction qui retourne la factorielle d'un nombre entier \(N\). la fonction factorielle s'écrit avec un point d'exclamation, on note: factorielle(n)=n! Afin de calculer la valeur renvoyée par cette fonction on a la formule:

\(N!=1 \times 2 \times ... \times (N-1) \times N\)

Exemple :
```
print(Factorielle(50))
30414093201713378043612608166064768844377641568960512000000000000
```
Comparez avec le résultat de la fonction factorial() du module math.

Exercice 4.4 ★

À l'aide de la fonction randint() du module random, écrire une fonction qui retourne un mot de passe de longueur N(chiffres, lettres minuscules ou majuscules). On donne :
```
chaine = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
```
On obtient:
```
print(Password(10))
mHVeC5rs8P
print(Password(6))
PYthoN
```
Reprendre la question 1. avec la fonction choice() du module random. Pour obtenir de l'aide sur cette fonction :
```
import random
help(random.choice)
```
Quel est le nombre de combinaisons possibles ?
Quelle durée faut-il pour casser le mot de passe avec un logiciel capable de générer 1 million de combinaisons par seconde ?

Exercice 4.5 ★

Écrire une fonction qui retourne une carte (au hasard) d'un jeu de Poker à 52 cartes.

On utilisera la fonction choice() ou randint() du module random. On donne :

ListeCarte = ['2s','2h','2d','2c','3s','3h','3d','3c','4s','4h','4d','4c','5s','5h','5d','5c', '6s','6h','6d','6c','7s','7h','7d','7c','8s','8h','8d','8c','9s','9h','9d','9c', 'Ts','Th','Td','Tc','Js','Jh','Jd','Jc','Qs','Qh','Qd','Qc','Ks','Kh','Kd','Kc','As','Ah','Ad','Ac']
print(TirageCarte())
7s
print(TirageCarte())
Kd

Exercice 4.6 ★★

Écrire une fonction qui retourne une liste de N cartes différentes d'un jeu de Poker à 52 cartes.

Noter qu'une fonction peut appeler une fonction : on peut donc réutiliser la fonction TirageCarte() de l'exercice précédent.

Exemple :

print(TirageNcarte(2))
['As', 'Ah']
print(TirageNcarte(25))
['Jc', 'Jh', 'Tc', '2d', '3h', 'Qc', '8d', '7c', 'As', 'Td', '8h', '9c', 'Ad', 'Qh', 'Kc', '6s', '5h', 'Qd', 'Kh', '9h', '5d', 'Js', 'Ks', '5c', 'Th']

Simplifier le script avec la fonction shuffle() ou sample() du module random.

Exercice 4.7 ★

Ecrire une fonction qui retourne une grille de numéros du jeu Euro Millions. On utilisera la fonction sample() du module random.

print Euromillions()
[37, 23, 9, 11, 49, 2, 11]
print Euromillions()
[16, 32, 8, 30, 40, 6, 4]

alt text