Éviter de se répéter.

Intéressons-nous au panneau d’affichage dans un aéroport.
L’employé chargé des affichages pourrait envisager le programme suivant :

print("Embarquement pour Bordeaux à 10h35")
print("Embarquement pour Toulouse à 10h43")
print("Embarquement pour Marseille à 10h57")
print("Embarquement pour Lille à 11h03")
print("Embarquement pour Strasbourg à 11h10")
print("Embarquement pour Lyon à 11h17")

Celui-ci produirait le résultat suivant :

Embarquement pour Bordeaux à 10h35
Embarquement pour Toulouse à 10h43
Embarquement pour Marseille à 10h57
Embarquement pour Lille à 11h03
Embarquement pour Strasbourg à 11h10
Embarquement pour Lyon à 11h17

Il semble cependant inutile de re-taper à longueur de journée les mêmes mots « Embarquement pour», « à ».
Une solution plus économique consiste à écrire une séquence d’instructions unique destinée à être ré-utilisée aussi souvent que nécessaire.

Exemple

C’est le premier objectif de la notion de fonction. Examinons le programme suivant :

def vol(destination, heure) :
    print("Embarquement pour ", destination, " à ", heure)


vol("Bordeaux", "10h35")
vol("Toulouse", "10h43")
vol("Marseille", "10h57")
vol("Lille", "11h03")
vol("Strasbourg", "11h10")
vol("Lyon", "11h17")

Ce programme fournit exactement le même résultat que le précédent. Nous avons créé une fonction vol qui est utilisée plusieurs fois de suite, pour peu qu’on lui fournisse, lors de son appel, les paramètres dont elle a besoin pour fonctionner.

Première définition des fonctions.

En python, la syntaxe pour définir une fonction est la suivante :

def NomDeLaFonction(variable) :
     ...
     bloc d'instructions
     ...   

Fonctionnement :

• en Python, l’écriture d’une fonction commence toujours par le mot def.
• vous pouvez choisir le nom que vous voulez pour la fonction.
• les variables sont déclarées entre parenthèses, séparées par des virgules, juste après le nom de la fonction.
• comme les instructions if, for ou while, l’instruction def est une instruction composée : la ligne démarrant l’instruction def est terminée par deux points « : », lesquels introduisent un bloc d’instructions qui doit être indenté.
• La fonction s’utilise ensuite dans le reste du programme par un simple appel :Nom_De_La_Fonction(Valeurs_des_Variables)

Remarques :

• Des fonctions, nous en utilisons depuis le premier chapitre : l’instruction « print(« Bonjour ») » n’est autre que l’appel de la fonction print, avec en argument la valeur de variable « « Bonjour » ».
• En effet, Python comprend un très grand nombre de fonctions prédéfinies : des fonctions déjà définies par les développeurs de Python.
• A celles-ci, nous allons maintenant en ajouter d’autres, que nous coderons nous-mêmes en fonction de nos besoins.

Exercice 21

Écrire une fonction « carré », qui affichera le carré du nombre fourni en argument dans la fonction. Vous devez répondre avec une phrase du type « Le carré de 5 est 25 ».

def carre(nombre):
    print ("le carré de "+str(nombre)+" est "+str(nombre**2))

carre(5)
carre(25)

Exercice 22

Afin de créer un jeu d’apprentissage des tables de multiplication pour les jeunes enfants, nous aurions besoin de pouvoir afficher une table de multiplication pour la rappeler au joueur, à chaque fois qu’il aura fait une erreur.
Écrire une fonction « table » qui prendra en argument, le numéro de la table souhaitée, et affichera la table correspondante.
Testez votre fonction en fin de programme en l’appelant avec différents nombres.

def table(nombre):
    for i in range(1, 11):
        print(str(nombre)+" * "+str(i)+" = "+str(nombre*i))

table(5)
print("")# Pour rajouter une ligne vide entre les 2 tables
table(9)

Vraies fonctions et procédures.

Les fonctions écrites jusqu’à présent se contentent de réaliser des actions (afficher un message, par exemple). C’est ce l’on appelle des procédures.
Une vraie fonction doit, en plus, lorsqu’elle se termine, renvoyer une valeur :
comme une fonction en mathématiques qui renvoie au final l’image d’un nombre : lorsque l’on appelle f avec la valeur 3, elle renvoie le nombre f(3).

Ainsi si je reprends l’exemple de l’exercice 21 :

def carre(nombre) :
    resultat = nombre**2
    return resultat

	
a = carre(12)
print("Le carré de 12 est : ")
print(a)

L’instruction return, qui vient toujours en dernière ligne de la fonction, définit ce que doit renvoyer la fonction.
La valeur (ou l’objet) renvoyée pourra, par exemple, être stockée dans une variable et ré-exploitée par le programme.

Syntaxe d’une fonction renvoyant un résultat:

def NomDeLaFonction(variable1, variable 2, ...) :
    bloc d'instructions
    ...
    return Resultat_Renvoyé_Par_La_Fonction

Portée des variables : variables locales et variables globales.

Examinons le programme suivant :

def table(base) :
    print("Nous allons afficher la table des ", base, " :")
    for compteur in range(11):
        print(compteur*base)
        
table(9)

Lorsque nous définissons une variable à l’intérieur du corps d’une fonction, cette variable n’est accessible qu’à la fonction elle-même. On dit que cette variable est une variable locale à la fonction.

C’est le cas ci-dessus de la variable base. Chaque fois que la fonction table est appelée, Python réserve pour elle, dans la mémoire de l’ordinateur un espace de noms. Le contenu de la variable base est contenu dans cet espace qui est innacessible depuis l’extérieur de la fonction. Ainsi par exemple, si nous essayons d’afficher le contenu de la variable base juste après avoir effectué l’exercice ci-dessus, nous obtenons un message d’erreur :

>>> print(base)
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'base' is not defined
>>> 

L’ordinateur nous signale clairement que la variable base lui est inconnue, alors qu’elle était correctement affichée par la fonction table juste avant. L’espace de noms qui contient la variable base est strictement réservé au fonctionnement interne de table, et il est automatiquement détruit dès que la fonction a terminé son travail.

Les variables définies à l’extérieur des fonctions sont des variables globales.
Leurs contenus sont visibles de l’intérieur d’une fonction, mais la fonction ne peut pas les modifier :

– contenu visible de l’intérieur de la fonction :

def test() :
    print(globale)
    
globale = 5
test()

Le programme ci-dessus affiche>>> 5 lorsqu’on l’exécute.

– la fonction ne peut pas modifier une variable globale :

def test() :
    globale = 15
    print("depuis l'intérieur de la fonction, globale = ")
    print(globale)
    
globale = 5
test()
print("depuis l'extérieur de la fonction, globale = ")
print(globale)

Ce qui donne lors de l’exécution :

depuis l'intérieur de la fonction, globale = 
15
depuis l'extérieur de la fonction, globale = 
5

Nous constatons que la variable « globale » n’a pu être modifiée à l’intérieur de la fonction, puisque son affichage final en dehors de la fonction donne toujours 5.

Pire encore, nous remarquons que le nom de variable « globale », est ici utilisé pour définir deux variables différentes : l’une globale, l’autre locale.
Ces deux variables sont bel et bien des variables distinctes, indépendantes, obéissant à une règle de priorité :
à l’intérieur d’une fonction (où elles pourraient entrer en compétition), ce sont les variables définies localement qui ont la priorité.
Ainsi lors de l’utilisation d’une variable dans une fonction, Python commence par rechercher s’il existe une telle variable dans l’espace des variables locales à la fonction. Ce n’est que si elle n’en trouve pas qu’elle ira chercher si cette variable existe au niveau global.

Modifier une variable globale depuis l’intérieur d’une fonction.

Nous avons déjà précisé que c’était à priori impossible.
Ceci étant, il arrivera bien souvent qu’une fonction ait besoin de modifier une variable globale. Pour cela, il suffit d’utiliser l’instruction global, qui permet d’indiquer à l’intérieur d’une fonction, qu’une variable devra être traitée de façon globale à l’intérrieur de la fonction. La variable pourra alors être modifiée à l’intérieur de la fonction comme dans l’exemple ci-dessous:

def grandir() :
    global age
    age = age + 1
    
age = 15
grandir()
print(age)

En résumé :

• Les fonctions répondent à 2 besoins :
  • 1) éviter de répéter plusieurs fois une même partie de code.
  • 2) décomposer un problème complexe en plusieurs sous-problèmes plus simples, qui seront chacun traités par des fonctions différentes.
• Dans un programme, il y a 2 types de variables :
  • 1) variable locale :
    • définie à l’intérieur d’une fonction,
    • inacessible depuis l’extérieur de la fonction,
    • détruite après l’exécution de la fonction.
    • 2) variable globale :
      • définie à l’extérieur des fonctions,
      • contenu visible depuis l’intérieur des fonctions,
      • non modifiable depuis l’intérieur d’une fonction.
• Lorsqu’une variable locale et une variable globale porte le même nom, à l’intérieur d’une fonction, c’est la variable locale qui est prioritaire.
• Une variable globale peut devenir modifiable à l’intérieur d’une fonction en indiquant dans la fonction : global NomDeLaVariable
• Désormais nos programmes pourront avoir une structure plus recherché:
  • 1) Importation des librairies et fonctions prédéfinies nécessaires au programme,
  • 2) Définition de nos fonctions personnelles,
  • 3) Main, ou encore en français : corps principal du programme.

Exemple :

## 1) Importation des librairies et fonctions prédéfinies nécessaires au programme  ##

from random import randint

#################### 2) Définition de nos fonctions personnelles  #########

def lancer() :
    """ fonction simulant un lancer de dé """
    return randint(1,6)
    
###################################### 3) Main  ################################
####              aussi  appelé: «corps principal du programme»                ####

n = int(input("Combien de fois voulez-vous lancer le dé ?"))  
       
for i in range(1,n+1) :
    essai = lancer()    
    print("Lancer ", i , " : ")
    print(essai)