Le python landais

Accueil

Plan du cours
Introduction
1. Installation
2. Variables
3. Types
4. If
5. While
6. For ... in
7. Fonctions
8. Interfaces graphiques
9. Listes
10. Interfaces graphiques 2
11. Traitement de l'image

Les exercices

Les QCM

Reeborg

Mini projets

Codage

L'ordinateur

Liens et ressources

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

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.

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

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é :

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 auront la structure suivante :

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)

--> Exercices 9 et 10.

--> chapitre 8

Contact
CC BY-NC-SA 4.0