Les fonctions

Les fonctions

Voici des instructions qui permettent d'afficher le carré d'un nombre

>>>a=3
>>>b=a**2
>>>b
9

Si, nous avons également besoin du carré de 5 et 7... on pourrait copier-coller les instructions précédentes et afficher le résultat. Mais il y a mieux à faire : regrouper ces instructions dans un bloc sous la forme d'une fonction, a devenant un paramètre de la fonction.

En Python une fonction est définie par l'instruction composée def suivie du nom de la fonction et se termine obligatoirement par deux points : puis le bloc d'instructions qu'il ne faut pas oublier d'indenter.

Une fonction est utilisée comme une instruction quelconque. Dans le corps d'un programme, un appel de fonction est constitué du nom de la fonction suivi de parenthèses

La notion de fonction en informatique relève du même concept qu'une fonction mathématique, c'est-à-dire qu'on définit une fonction puis on l'applique à différentes valeurs.

# -*- coding: utf-8 -*-
def carree(a) :
	""" 
	Fonction permettant de renvoyer le carré du nombre a qui est en paramètre
	"""
	return a**2 # renvoye l'image de a par la fonction carree

Pour écrire le programme ci-dessus dans la zone de Saisie de programme de EduPython, on clique sur Fichier, Nouveau puis Nouveau Module Python comme l'indique la figure ci-dessous :

Fonction

ou bien, on clique sur Nouveau Fichier, l'icônePython 3.4, puis Créer comme l'indique la figure ci-dessous :

Fonction

Une fois la fonction est définie dans la zone de Saisie de programme de EduPython, on ne doit pas oublier de l'enregistrer dans le dossier qui convient en lui donnant un nom :

Fonction

Après l'enregistrement, pour utiliser cette fonction, on l'appelle par l'instruction carree(3) en utilisant la console pour afficher le carré de 3 mais il ne faut pas oublier d'exécuter le programme en utilisant l'icône "flèche verte" avant d'utiliser la console, sinon la fonction carree ne sera pas reconnue comme l'indique la figure ci-dessous :

Fonction

Lorsqu'on définit la fonction carree(), a est appelé paramètre de la fonction. Quant on appelle la fonction avec une valeur explicite pour a, comme dans carree(3), on dira plutôt que 3 est un argument de la fonction.

En appelant la fonction carree() d'argument 3, on obtient 9 :

>>> carree(3)
9
>>>

Quelques remarques.

  • La fonction est auto-documentée par un texte entre """ et """ (c'est ce que l'on appelle le docstring de la fonction).

    Le docstring d'une fonction permet de donner des informations sur la fonction, le lien entre les entrées et la sortie (en d'autres termes, le rôle de la fonction).

    Quant on saisit dans la console, après l'exécution de la fonction, l'instruction help(nom de la fonction), python affiche le docstring de la fonction ce qui nous permet d'avoir des informations sur la fonction en cas d'oubli.

    >>> help(carree)
    Help on function carree in module __main__:
    
    carree(x)
        Fonction permettant de renvoyer le carré
        du nombre x qui est en paramètre
    
    >>>
  • La fonction se termine avec une instruction return. Ce qui suit le return est l'image des entrées par la fonction. Dès que la fonction rencontre un return, elle renvoie ce qui suit le return et stoppe son exécution.

Un autre exemple

Voici un exemple de fonctions dont les paramètres sont les coordonnées des extrémités d'un segment et les images sont les coordonnées du milieu de ce segment

# -*- coding: utf-8 -*-
def milieu(x1,y1,x2,y2) :
	""" 
	Fonction permettant de renvoyer les coordonnées du milieu d'un segment d'extrémités 
	A(x1; y1) et B(x2 ; y2) qui sont en paramètres
	"""
	return (x1+x2)/2,(y1+y2)/2

Remarque

  • Les entrées sont de type flottant.
  • Les sorties sont de type flottant.
  • La fonction se termine avec l'instruction return qui renvoye simultanément deux valeurs

En appelant la fonction milieu() avec les arguments 1,4,3 et 5, on obtient :

>>> print(milieu(1,4,3,5))
(2.0, 4.5)
>>>

Fonction Lambda

Python nous permet de définir des mini-fonctions d’une ligne. Ces fonctions dites lambda peuvent être employées partout où une fonction est nécessaire.

Exemple

>>>def f(x) :
...     return x**2
... 
>>> f(3)
9
>>> 

Voici une fonction lambda qui fait la même chose que la fonction ordinaire précédente. On remarque que la syntaxe est condensée, il n’y a pas de parenthèses autour de la liste d’arguments et le mot-clé return est manquant (il est implicite, la fonction complète ne pouvant être qu’une seule expression)

cette fonction n'a pas de nom, mais on peut l'affecter à une variable pour l'appeler à travers cette variable.

>>>g = lambda x : x**2
>>> g(3)
9 
>>> 

Activité

Question 1

  1. Ecrire une fonction en Python, de paramètre deux réels \(a \text{ et } b \), qui les compare et renvoie le plus grand des deux
  2. Exécuter cette fonction plusieurs fois

Une proposition de réponse :

# -*- coding: utf-8 -*-
def plusGrand(a,b):
    """Cette fonction compare ses deux arguments et renvoie le plus grand des deux"""
    if a >= b:
        return a
    else :
        return b
>>>plusGrand(-3,5)
5
>>> plusGrand(-3,-5)
-3
>>>

Question 2

  1. Ecrire une fonction en Python, de paramètre trois réels \(a, b \text{ et } c \), qui les compare et renvoie le plus grand des trois
  2. Exécuter cette fonction plusieurs fois

Une proposition de réponse :

# -*- coding: utf-8 -*-
def plusGrand(a,b,c):
    """Cette fonction compare ses trois arguments et renvoie le plus grand des trois"""
    if a >= b and a >=c:
        return a
    elif b >=c :
        return b
    else :
        return c
>>>plusGrand(-3,5,2)
5
>>> plusGrand(-3,-5,-8)
-3
>>>

Question 3

    • Ecrire une fonction en Python, de paramètre trois réels \(a, b \text{ et } c \), qui les trie et les renvoie rangés par ordre croissant
    • Exécuter cette fonction plusieurs fois
    • Ecrire une fonction en Python, de paramètre trois réels \(a, b \text{ et } c \), qui les trie et les renvoie rangés par ordre décroissant
    • Exécuter cette fonction plusieurs fois

Une solution de l'exercice "Trier trois nombres par ordre croissant".

  1. # -*- coding: utf-8 -*-
    def trier(a,b,c):
        """Cette fonction trie ses paramètres et les renvoie rangés 
    	par ordre croissant
         """
        if a>b : a,b = b,a
        if b>c : b,c = c,b
        if a>b : a,b = b,a
        return (a,b,c)
    >>> trier(4,-3,-7)
    (-7, -3, 4)
    >>>

Une solution de l'exercice "Trier trois nombres par ordre décroissant".

# -*- coding: utf-8 -*-
def trier(a,b,c):
    """Cette fonction trie ses paramètres et les renvoie rangés
	par ordre décroissant
     """
    if b>a : a,b = b,a
    if c>b : b,c = c,b
    if b>a : a,b = b,a
    return (a,b,c)
>>> trier(-7,-3,4)
(4, -3, -7)
>>>

Question 4

  1. Ecrire une fonction en Python, de paramètre un entier naturel n non nul, qui renvoie la somme des n premiers entiers naturels non nuls
  2. Exécuter cette fonction plusieurs fois

Une proposition de réponse :

# -*- coding: utf-8 -*-
def SommeEntiers(n):
    """Cette fonction, de paramètre un entier naturels non nul n, 
	renvoie la somme des n premiers entiers naturels non nuls"""
    s = 0
    for i in range(1,n+1):
        s = s + i
    return s
>>> SommeEntiers(3)
6
>>> SommeEntiers(4)
10
>>> SommeEntiers(100)
5050
>>>

ou bien

Une autre proposition de réponse :

# -*- coding: utf-8 -*-
def SommeEntiers(n):
    """Cette fonction, de paramètre un entier naturels non nul n, 
	renvoie la somme des n premiers entiers naturels non nuls"""
	assert(n>0 and type(n)==int)
    s = 0
    k = 1
    while k <= n :
        s = s + k
        k = k + 1
    return s

Question 5

  1. Ecrire une fonction en Python, de paramètre un entier naturel n non nul, qui renvoie la liste des carrés des n premiers entiers naturels
  2. Exécuter cette fonction plusieurs fois

Une proposition de réponse :

def listeCarres(n):
	assert(n>0 and type(n)==int)
    """Cette fonction, de paramètre un entier naturels non nul n, renvoie 
	la liste des carrés des n premiers entiers naturels"""
    liste = []
    for i in range(n):
        liste.append(i**2)
    return liste
>>> listeCarres(10)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> listeCarres(15)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196]
>>>

ou bien

Une autre proposition de réponse :

def listeCarres(n):
    assert(n>0 and type(n)==int)
    """Cette fonction, de paramètre un entier naturels non nul n, renvoie
	la liste des carrés des n premiers entiers naturels"""
    liste = []
    i=0
    while i<n:
        liste.append(i**2)
        i=i+1
    return liste
>>> listeCarres(10)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> listeCarres(15)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196]
>>>