La syntaxe Python pour la définition d’un sous programme est :
def nomDeLaFonction(liste de paramètres):
blocdinstructions
La définition (= le code) des fonctions doit précéder leur utilisation.
Les sous programmes peuvent être catégorisés en deux sous types : les procédures et les fonctions. Vous pouvez choisir n’importe quel nom pour le sous programme que vous créez.( A l’exception des mots réservés du langage, même règle que pour les noms de variable )
Comme les instructions if et while, l’instruction def est une instruction composée. La ligne contenant cette instruction se termine obligatoirement par un double point, lequel introduit un bloc d’instructions qui est indenté.
Un sous programme s’utilise pratiquement comme une instruction quelconque. Dans le corps d’un programme, un appel de sous programme est constitué de son nom suivi de parenthèses.
Si c’est nécessaire, on place dans ces parenthèses le ou les arguments que l’on souhaite transmettre au sous programme. Il faudra en principe fournir un argument pour chacun des paramètres spécifiés, encore qu’il soit possible de définir pour ces paramètres des valeurs par défaut.
La liste de paramètres spécifie quelles informations il faudra fournir en guise d’arguments lorsque l’on voudra utiliser ce sous programme (les parenthèses peuvent parfaitement rester vides si le sous programme ne nécessite pas d’arguments).
Définition d’un sous programme appelée table7() qui calcule et affiche les 10 premiers termes de la table multiplication par 7:
def table7():
n = 1
while n <10:
print(n * 7, end =' ')
n = n +1
Pour utiliser cette procédure, il suffit de l’appeler par son nom :
table7()
Une procécdure peut faire appelle à elle-même, ou à une 2ème procédure qui elle-même fait appel à une 3ème procédure, etc…
On peut ainsi réaliser des scripts évolués à partir d’une combinaison de fonctions simples.
def table7triple():
print('La table par 7 en triple exemplaire :')
table7()
table7()
table7()
Une procédure peut être paramétrée. Dans la définition d’un tel sous programme, il faut prévoir une variable particulière pour recevoir l’argument transmis. Cette variable particulière s’appelle un paramètre.
On lui choisit un nom en respectant les mêmes règles de syntaxe que d’habitude (pas de lettres accentuées, etc.), et on place ce nom entre les parenthèses qui accompagnent la définition de la procédure.
Exemple pour afficher la table de multiplication pour une valeur passée en paramètre (base)
def table(base):
n = 1
while (n < 11) :
print( n * base, end = ' ' )
n = n + 1
Pour définir une procédure avec plusieurs paramètres, il suffit d’inclure ceux-ci entre les parenthèses qui suivent le nom de la procédure, en les séparant à l’aide de virgules.
Lors de l’appel de la procédure, les arguments utilisés doivent être fournis dans le même ordre que celui des paramètres correspondants (en les séparant eux aussi à l’aide de virgules). Le 1er argument sera affecté au 1er paramètre, le 2nd argument sera affecté au 2nd paramètre, et ainsi de suite.
Exemple:
def tableMulti(base, debut, fin) :
print('Fragment de la table de multiplication par', base, ':')
n = debut
while n <= fin :
print(n, 'x', base, '=', n * base)
n = n +1
Utilisation :
tableMulti(8, 13, 17)
Une fonction, au sens strict, doit en effet renvoyer une valeur comme résultat lorsqu’elle se termine. Alors qu’une procédure va afficher le résultat.
Une « vraie » fonction peut s’utiliser à la droite du signe égale dans des expressions telles que y = sin(a). (Pas une procédure.) On comprend aisément que dans cette expression, la fonction sin() renvoie une valeur (le sinus de l’argument a) qui est directement affectée à la variable y.
L’instruction return définit la valeur renvoyée par la fonction.
def cube(w):
return w*w*w
En l’occurrence, il s’agit ici du résultat de l’expression w*w*w.
Comme les procédures, les fonctions peuvent avoir de 0 à n paramètres.
Le typage des variables sous Python est un typage dynamique, ce qui signifie que le type d’une variable est défini au moment où on lui affecte une valeur.
Ce mécanisme fonctionne aussi pour les paramètres d’une fonction. Le type d’un paramètre devient automatiquement le même que celui de l’argument qui a été transmis à la fonction.
Exemple :
def afficher3fois(arg) :
print(arg, arg, arg)
afficher3fois(5) #affiche 5 5 5
afficher3fois('zut') #affiche zut zut zut
afficher3fois(6**2) #affiche 36 36 36
Il est possible de définir un argument par défaut pour chacun des paramètres. On obtient ainsi une fonction qui peut être appelée avec une partie seulement des arguments attendus.
Exemple :
def politesse(nom, vedette ='Mr’) :
print(" Bjr,", vedette, nom, ".")
politesse('Dupont') #affiche Bjr, Mr Dupont .
politesse('Dui', 'Melle') #affiche Bjr, Melle Dui .
Lorsque l’on appelle la fonction politesse en ne lui fournissant que le premier argument, le second reçoit tout de même une valeur par défaut. Si l’on fournit les deux arguments, la valeur par défaut pour le deuxième est tout simplement ignorée.
On peut définir une valeur par défaut pour tous les paramètres, ou une partie d’entre eux seulement.
def question(annonce, essais =4, please ='Oui ou non, s.v.p.!'):
while essais >0:
reponse = input(annonce)
if reponse in ('o', 'oui','O','Oui','OUI'):
return 1
if reponse in ('n','non','N','Non','NON'):
return 0
print(please)
essais = essais-1
La fonction précédente peut être appelée de différentes façons :
rep = question('Voulez-vous vraiment terminer ? ')
ou bien :
rep = question('Faut-il effacer ce fichier ? ', 3)
ou même encore :
rep = question('Avez-vous compris ? ', 2, 'Répondez par oui ou par non !')
Si les paramètres annoncés dans la définition de la fonction ont reçu chacun une valeur par défaut, sous la forme déjà décrite ci-dessus, on peut faire appel à la fonction en fournissant les arguments correspondants dans n’importe quel ordre, à la condition de désigner nommément les paramètres correspondants.
def oiseau(voltage=100, etat='allumé', action='danser la java’):
print('Ce perroquet ne pourra pas', action)
print('si vous le branchez sur', voltage, 'volts !’)
print("L'auteur de ceci est complètement", etat)
oiseau(etat='givré',voltage=250,action='vous approuver')
oiseau()
Lorsque nous définissons des variables à l’intérieur du corps d’un sous programme, ces variables ne sont accessibles qu’à la fonction elle-même. On dit que ces variables sont des variables locales à la fonction.
Les variables définies à l’extérieur d’une fonction (ou d'une procédure) sont des variables globales. Leur contenu est « visible » de l’intérieur d’une fonction, mais la fonction ne peut pas le modifier.
def mask() :
p = 20
print(p, q)
p, q = 15, 38
mask() # affichera 20 38
print(q,p) # affichera 15 38
Exactement le même nom de variable p a été utilisé à deux reprises, pour définir deux variables différentes : l’une est globale et l’autre est locale.
Ces deux variables sont bel et bien des variables distinctes, indépendantes, obéissant à une règle de priorité qui veut qu’à l’intérieur d’une fonction, ce sont les variables définies localement qui ont la priorité.
Il se peut que vous ayez à définir une procédure qui soit capable de modifier une variable globale.
Pour atteindre ce résultat, il vous suffira d’utiliser l’instruction global. Cette instruction permet d’indiquer – à l’intérieur de la définition d’un sous programme– quelles sont les variables à traiter globalement.
def monter() :
global a
a = a+1
print(a)
a = 15
monter() #affiche 16
monter() #affiche 17
On peut réunir un ensemble de fonctions et/ou procédures ayant un lien entre elle au sein d’un même espace de nom : c’est un module.
C’est en fait un fichier en *.py
Dans un autre script, on peut alors faire appel à un module externe en utilisant l’instruction import.