0

Les fonctions

Apprendre à programmer en python

python

Nous avons déjà vu beaucoup de fonctions : print(), type(), len(), input(), 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)
212.0
>>> print(37.0*9.0/5.0 + 32.0)
98.6
>>> print(233.0*9.0/5.0 + 32.0)
451.4

La même chose en utilisant une fonction :

>>> def fahrenheit(degre_celsius):
        """ Conversion degré Celsius en degré Fahrenheit """
        print(degre_celsius*9.0/5.0 + 32.0)
>>> fahrenheit(100)
212.0
>>> fahrenheit(37)
98.6
>>> temperature = 233
>>> fahrenheit(temperature)
451.4

Rien ne vous oblige à définir des fonctions dans vos scripts, mais cela est tellement pratique qu’il serait improductif de s’en passer !

L’instruction def

Syntaxe

def nom_de_la_fonction(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 ()
Bonjour

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

>>> help(mapremierefonction)    # affichage de la documentation
Help on function mapremierefonction in module __main__:

mapremierefonction()
    Cette fonction affiche 'Bonjour'

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 tirage_de():
    """ Retourne un nombre entier aléatoire entre 1 et 6 """
    import random
    valeur = random.randint(1, 6)
    return valeur
>>> print(tirage_de())
3
>>> print(tirage_de())
6
>>> resultat = tirage_de()
>>> print(resultat)
1

Exemple n°3

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

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

# début du programme
info()
while True:
    choix = input()
    if choix == 'q':
        break
    print("Tirage :", tirage_de())
>>>
Touche q pour quitter
Touche Enter pour continuer

Tirage : 5

Tirage : 6
q
>>>

Exemple n°4

Une fonction avec deux paramètres :

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

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

Exemple n°5

Une fonction qui retourne une liste :

def tirage_multiple_de(nombretirage):		# définition de fonction
    """ Retourne une liste de nombres entiers aléatoires entre 1 et 6 """
    import random
resultat = [random.randint(1, 6) for i in range(nombretirage)]	# compréhension de listes (Cf. annexe)
    return resultat

# début du programme
print(tirage_multiple_de(10))
>>>
[4, 1, 3, 3, 2, 1, 6, 6, 2, 5]




>>> help(tirage_multiple_de)
Help on function tirage_multiple_de in module __main__:

tirage_multiple_de(nombretirage)
    Retourne une liste de nombres entiers aléatoires entre 1 et 6

Exemple n°6

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.

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

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
10
>>> mafonction()    # nous sommes dans l'espace local de la fonction
20
>>> print(a)        # de retour dans l'espace global
10

Nous avons deux variables différentes qui portent le même nom a

Une 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.

Entraînement 1 :
1) Écrire une fonction carre() qui retourne le carré d’un nombre :

>>> print(carre(4))
16
2) Écrire une fonction qui retourne l’aire de la surface d’un disque de rayon R. Exemple :

>>> print(airedisque(2.5))
19.6349540849

3) Ajouter un paramètre qui précise l’unité de mesure :

>>> print(airedisque2(4.2, 'cm'))
55.4176944093 cm²

Entraînement 2 :

1) Écrire une fonction qui retourne la valeur de la fonction mathématique f(x)= 6x + 10 :

>>> print(f(0), f(1))
10 16

2) Écrire une fonction qui retourne la valeur de la fonction mathématique f(x)= 2x2 + 9x + 13 :