1
Découpage des programmes
PROCÉDURES ET FONCTIONS
2
Généralités sur les fonctions et les modules sous Python
1. Meilleure organisation du programme (regrouper les
tâches par blocs : lisibilité → maintenance)
Pourquoi 2. Eviter la redondance (pas de copier/coller → maintenance,
créer des meilleure réutilisation du code)
fonctions ? 3. Possibilité de partager les fonctions (via des modules)
4. Le programme principal doit être le plus simple possible
1. Module = fichier " .py "
2. On peut regrouper dans un module les fonctions traitant
des problèmes de même nature ou manipulant le même
Qu’est-ce type d’objet
qu’un module 3. Pour charger les fonctions d’un module dans un autre
sous Python ? module / programme principal, on utilise la commande
import nom_du_module
4. Les fonctions importées sont chargées en mémoire. Si
collision de noms, les plus récentes écrasent les anciennes.
3
Définition des fonctions
•Fonction ➔ Bloc d’instructions
•Prend (éventuellement) des paramètres en entrée (non typés)
Fonction
•Renvoie une valeur en sortie (ou plusieurs valeurs, ou pas de
valeurs du tout : procédure)
• def pour dire que l’on définit une fonction
• Le nom de la fonction est « petit »
def petit (a, b):
if (a < b): • Les paramètres ne sont pas typés
Un exemple d=a • Noter le rôle du :
else: • Attention à l’indentation
d=0 • return renvoie la valeur
return d
• return provoque immédiatement la sortie
de la fonction
Procédure = Fonction sans return
4
Appels des fonctions
Passage de Passer les paramètres selon
paramètres print(petit(10, 12)) les positions attendues
par position La fonction renvoie 10
Passage par print(petit(a=10,b=12)) Aucune confusion possible → 10
nom. Le mode de
passage que je
préconise, d’autant
plus que les Aucune confusion possible → 10
paramètres ne
print(petit(b=12, a=10))
sont pas typés.
Sans instructions spécifiques, le
En revanche… print(petit(12, 10)) passage par position prévaut
La fonction renvoie → 0
5
Un exemple de programme
Définition de la fonction
Programme principal
Appel de la fonction dans le programme
principal (on peut faire l’appel d’une
fonction dans une autre fonction)
2 exécutions du
programme
6
Portée des variables, imbrications des fonctions, …
PLUS LOIN AVEC LES FONCTIONS
7
Valeur par défaut
•Affecter des valeurs aux paramètres dès la définition de la fonction
•Si l’utilisateur omet le paramètre lors de l’appel, cette valeur est utilisée
Paramètres
•Si l’utilisateur spécifie une valeur, c’est bien cette dernière qui est utilisée
par défaut
•Les paramètres avec valeur par défaut doivent être regroupées en
dernière position dans la liste des paramètres
def ecart(a,b,epsilon = 0.1):
d = [Link](a - b)
Exemple if (d < epsilon):
d=0
return d
ecart(a=12.2, b=11.9, epsilon = 1) #renvoie 0
ecart(a=12.2, b=11.9) #renvoie 0.3
La valeur utilisée est epsilon = 0.1 dans ce cas
8
Passage de paramètres
Les paramètres sont toujours passés par
#écriture de la fonction référence (référence à l’objet), mais ils sont
def modifier_non_mutable(a,b):
a = 2 * a modifiables selon qu’ils sont mutables
b = 3 * b (dictionnaire*, liste*, etc.) ou non mutables
print(a,b)
(types simples, tuples*, etc.).
#appel
x = 10 20 45 * à voir plus tard
y = 15
modifier_non_mutable(x,y)
print(x,y) 10 15
#écriture de la fonction
def modifier_mutable(a,b):
[Link](8)
b[0] = 6 C’est ce qui est pointé
print(a,b) [10, 8] [6]
par la référence qui
est modifiable, pas la
#appel pour les listes
lx = [10] référence elle-même.
ly = [15] Ex. b = [6] ne sera pas
modifier_mutable(lx,ly) répercuté à l’extérieur
print(lx,ly) [10, 8] [6]
de la fonction.
9
Fonction renvoyant plusieurs valeurs (1)
Renvoyer return peut envoyer plusieurs valeurs simultanément.
plusieurs valeurs La récupération passe par une affectation multiple.
avec return
#écriture de la fonction
def extreme(a,b):
if (a < b): Remarque : Que se passe-t-il si nous ne
return a,b mettons qu’une variable dans la partie
else: gauche de l’affectation ?
return b,a
#ou autre appel
#appel
v = extreme(x,y) v = (10, 15)
x = 10
print(v)
y = 15
#quel type pour v ?
vmin,vmax = extreme(x,y)
print(type(v))
print(vmin,vmax)
<class ‘tuple’>
v est un « tuple », une collection
vmin =10 et vmax=15
de valeurs, à voir plus tard.
10
Fonction renvoyant plusieurs valeurs (2)
Nous pouvons aussi passer par une structure intermédiaire telle que
Utilisation des la liste ou le dictionnaire d’objets. Les objets peuvent être de type
listes et des différent, au final l’outil est très souple. (nous verrons plus en détail
dictionnaires les listes et les dictionnaires plus loin)
#écriture de la fonction #écriture de la fonction
def extreme_liste(a,b): def extreme_dico(a,b):
if (a < b): if (a < b):
return [a,b] return {'mini' : a,'maxi' : b}
else: else:
return [b,a] return {'mini' : b,'maxi' : a}
#appel #appel
x = 10 x = 10
y = 15 y = 15
res = extreme_liste(x,y) res = extreme_dico(x,y)
print(res[0]) print(res['mini'])
Les deux fonctions renvoient deux objets différents
Notez l’accès à la valeur minimale selon le type de l’objet
11
Visibilité (portée) des variables
1. Les variables définies localement dans les fonctions sont
Variables uniquement visibles dans ces fonctions.
locales et [Link] variables définies (dans la mémoire globale) en dehors de la
globales fonction ne sont pas accessibles dans la fonction
[Link] ne le sont uniquement que si on utilise un mot clé spécifique
#fonction #fonction #fonction
def modif_1(v): def modif_2(v): def modif_3(v):
x = v x = x + v global x
x = x + v
#appel #appel
#appel
x = 10 x = 10 x = 10
modif_1(99) modif_2(99) modif_3(99)
print(x)➔ 10 print(x) print(x)➔ 109
x est une variable locale, x n’est pas assignée ici, On va utiliser la variable
pas de répercussion l’instruction provoque globale x. L’instruction
une ERREUR suivante équivaut à
x = 10 + 99
12
Imbrication des fonctions
Fonctions Il est possible de définir une fonction dans une autre
locales et fonction. Dans ce cas, elle est locale à la fonction, elle n’est
globales pas visible à l’extérieur.
#écriture de la fonction
def externe(a):
La fonction interne() est
#fonction imbriquée
def interne(b): imbriquée dans externe,
return 2.0* b elle n’est pas exploitable
dans le prog. principal ou
#on est dans externe ici
return 3.0 * interne(a) dans les autres fonctions.
#appel
x = 10
print(externe(x)) ➔ renvoie 60
print(interne(x)) ➔ provoque une erreur
13
Création et utilisation des modules
LES MODULES
14
Principe des Modules - Les modules standards de Python
•Un module est un fichier « .py » contenant un ensemble de
variables, fonctions et classes que l’on peut importer et utiliser
dans le programme principal (ou dans d’autres modules).
Modules
•Le mot clé import permet d’importer un module
•C’est un pas supplémentaire vers la modularité : un module
maximise la réutilisation et facilite le partage du code
• Des modules standards prêts à l’emploi sont livrés avec la
Modules distribution Python. Ex. random, math, os, hashlib, etc.
standards • Ils sont visibles dans le répertoire « Lib » de Python
Voir la liste
[Link]
complète sur
15
Exemple d’utilisation de modules standards
# -*- coding: utf -*-
Si plusieurs modules à importer, on les
met à la suite en les séparant par « , »
#importer les modules
#math et random
import math, random
#génerer un nom réel
#compris entre 0 et 1
[Link](None) Préfixer la fonction
value = [Link]()
à utiliser par le
#calculer le carré de nom du module
#son logarithme
logv = [Link](value)
abslog = [Link](logv,2.0)
#affichage
print(abslog)
16
Autres utilisations possibles
#définition d'alias
import math as m, random as r
#utilisation de l'alias L’alias permet d’utiliser des noms
[Link](None) plus courts dans le programme.
value = [Link]()
logv = [Link](value)
abslog = [Link](logv,2.0)
Cette écriture permet de désigner
#importer le contenu
#des modules nommément les fonctions à importer.
from math import log, pow Elle nous épargne le préfixe lors de
from random import seed, random l’appel des fonctions. Mais est-ce
vraiment une bonne idée ?
#utilisation directe
seed(None)
value = random() N.B.: Avec « * », nous les importons
logv = log(value) toutes (ex. from math import *). Là non
abslog = pow(logv,2.0)
plus pas besoin de préfixe par la suite.
17
Création d’un module personnalisé
dir() et help() permettent d’obtenir des
informations sur le module (liste du contenu)
18
Importation d’un module personnalisé
Python cherche automatiquement le module dans le
« search path » c.-à-d.
•le dossier courant
•les dossiers listés dans la variable d’environnement
PYTHONPATH (configurable sous Windows)
•les dossiers automatiquement spécifiés à
l’installation. On peut obtenir la liste avec la
commande [Link] (il faut importer le module sys au
préalable).
Pour connaître et modifier le répertoire courant, utiliser les
fonctions du module os c.-à-d.
import os
[Link]() # affiche le répertoire de travail actuel
[Link](chemin) # permet de le modifier
Ex. [Link]("c:/temp/exo") #noter l’écriture du chemin
19
Documentation
Documentez vos modules, vous
faciliterez le travail des
programmeurs qui les utilisent.