Le python landais

Les fonctions.


Plan du chapitre :

1. Éviter de se répéter.
2. Première définition des fonctions.
3. Vraies fonctions et procédures.
4. Portée des variables : variables locales et variables globales.
5. Modifier une variable globale depuis l'intérieur d'une fonction.
6. En résumé :



1) Éviter de se répéter.

Intéressons-nous au panneau d'affichage dans un aéroport :
Airport display

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



2) 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 :
Remarques :

--> Exercices 1, 2, 3, 4.




3) 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).
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

--> Exercices 5 et 6.




4) 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()

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

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

--> QCM sur les variables locales et globales 1)





5) 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.

Examinons l'exemple suivant : 
def grandir() :
    global age
    age = age + 1
    
age = 15
grandir()
print(age)


>>> 16

--> QCM sur les variables locales et globales 2)





6) En résumé :


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)

--> Exercices 9 et 10.