Généralités sur les fonctions et les modules s o u s Python
5. PROCÉDURES
1. Meilleure organisation du programme (regrouper les
tâches par blocs : lisibilité maintenance)
Pourquoi 2. Eviter la redondance (pas de copier/coller maintenance,
ET créer des meilleure réutilisation du code)
fonctions ? 3. Possibilité de partager les fonctions (via des modules)
FON CTI ON S 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.
40 41
Définition des fonctions Appels des fonctions
• Fonction Bloc d’instructions Passer les paramètres selon
Pas sage de
• Prend (éventuellement) des paramètres en entrée (non typés)
Fonction paramètres print(petit(10, 12)) les positions attendues
•Renvoie une valeur en sortie (ou plusieurs valeurs, ou pas de par position La fonction renvoie 10
valeurs du tout : procédure)
• def pour dire que l’on définit une fonction
• Le nom de la fonction est « petit » Pas s age par print(petit(a=10,b=12)) Aucune confusion possible 10
def petit (a, b): nom. Le mode de
if (a < b): • Les paramètres ne sont pas typés
p assage que je
Un exemple d=a • Noter le rôle du: préconise, d’autant
else: • Attention à l’indentation plus que les Aucune confusion possible 10
paramètres ne
print(petit(b=12, a=10))
d=0 • return renvoie la valeur sont p as typés.
return d
• return provoque immédiatement la sortie
de la fonction Sans instructions spécifiques, le
En revanche… print(petit(12, 10)) passage par position prévaut
Procédure = Fonction sans return
La fonction renvoie 0
42 43
1
Un exemple de programme Valeur par défaut
Définition de la fonction • 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
Programme principal
Appel de la fonction dans le programme
def ecart(a,b,epsilon = 0.1):
principal (on peut faire l’appel d’une d = [Link](a – b)
fonction dans une autre fonction) if (d < epsilon):
Exem ple
d=0
return d
ecart(a=12.2, b=11.9, epsilon = 1) #renvoie 0
2exécutions du ecart(a=12.2, b=11.9) #renvoie 0.3
programme
La valeur utilisée est epsilon = 0.1 dans ce cas
44 45
6
Passage de paramètres Fonction renvoyant plusieurs valeurs ) 1 )
Les paramètres sont toujours passés
#écriture de la fonction
par référence (référence à l’objet), mais
def modifier_non_mutable(a,b):
ils sont modifiables selon qu’ils sont
Renvoyer return peut envoyer plusieurs valeurs simultanément.
a = 2 * a
mutables (dictionnaire*, liste*, etc.) ou plusieurs valeurs La récupération passe par une affectation multiple.
b = 3 * b
print(a,b) non mutables (types simples, tuples*, avec return
etc..)
#appel
x = 10 20 45 *à voir plus tard #écriture de la fonction
y = 15 def extreme(a,b):
modifier_non_mutable(x,y) if (a < b): Remarque : Que se passe-t-il si nous ne
print(x,y) 10 15 return a,b mettons qu’une variable dans la partie
else: gauche de l’affectation?
#écriture de la fonction return b,a
def modifier_mutable(a,b):
#ou autre appel
[Link](8) C’est ce qui est pointé #appel
v = extreme(x,y) v = (10, 15)
b[0] = 6 par la référence qui x = 10
[10, 8] [6] print(v)
print(a,b) y = 15
est modifiable, pas la #quel type pour v ?
vmin,vmax = extreme(x,y)
#appel pour les listes référence elle-même. print(type(v))
print(vmin,vmax)
lx = [10] Ex. b = [6] ne sera pas
Ly = [15] répercuté à l’extérieur <class ‘tuple’>
modifier_mutable(lx,ly)
[10, 8] [6] de la fonction. v est un « tuple », une collection
print(lx,ly) vmin =10 et vmax=15
de valeurs, à voir plus tard.
46 47
2
Fonction renvoyant plusieurs valeurs ) 2 ) Visibilité (portée) des variables
Nous pouvons aussi passer par une structure intermédiaire telle que 1. Les variables définies localement dans les fonctions sont
Utilisation des la liste ou le dictionnaire d’objets. Les objets peuvent être de type Variables uniquement visibles dans ces fonctions.
listes et des différent, au final l’outil est très souple. (nous verrons plus en détail locales et [Link] variables définies (dans la mémoire globale) en dehors
dictionnaires les listes et les dictionnaires plus loin) globales de la fonction ne sont pas accessibles dans la fonction
#écriture de la fonction #écriture de la fonction 3. Elles ne le sont uniquement que si on utilise un mot clé
def extreme_liste(a,b): def extreme_dico(a,b): spécifique
if (a < b): if (a < b:)
return [a,b] return {'mini' : a,'maxi' : b} #fonction #fonction #fonction
else: else: def modif_1(v): def modif_2(v:) def modif_3(v):
return [b,a] return {'mini' : b,'maxi' : a} global x
x = v x = x + v
x = x + v
#appel #appel
x = 10 x = 10 #appel #appel
y = 15 y = 15
#appel
x = 10 x = 10 x = 10
res = extreme_liste(x,y) res = extreme_dico(x,y)
print(res[0]) print(res['mini'])
modif_1(99) modif_2(99) modif_3(99)
print(x) 10 print(x) print(x) 109
Les deux fonctions renvoient deux objets différents
x est une variable locale, x n’est pas assignée ici, On va utiliser la variable
Notez l’accès à la valeur minimale selon le type de l’objet pas de répercussion l’instruction provoque globale x. L’instruction
une ERREUR suivante équivaut à
48 49 x = 10 + 99
Imbrication des fonctions
Fonctions Il est possible de définir une fonction dans une autre
6. Les Modules
locales et
globales fonction. Dans ce cas, elle est locale à la fonction, elle
n’est 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 51
50
3
Principe des Modules - Les modules standards de Python Exemple d’utilisation de modules standards
•Un module est un fichier « .py » contenant un ensemble de
-*- #coding: utf-*-
Si plusieurs modules à importer, on les
variables, fonctions et classes que l’on peut importer et utiliser
met à la suite en les séparant par « , »
dans le programme principal (ou dans d’autres modules).
M odules #importer les modules
• Le mot clé import permet d’importer un module #math et random
•C’est un pas supplémentaire vers la modularité : un module import math, random
maximise la réutilisation et facilite le partage du code #génerer un nom réel
#compris entre 0 et 1
[Link](None) Préfixer la fonction
value = [Link])(
• Des modules standards prêts à l’emploi sont livrés avec la à utiliser par le
Modules distribution Python. Ex. random, math, os, hashlib, etc. #calculer le carré de nom du module
standards • Ils sont visibles dans le répertoire « Lib » de Python #son logarithme
logv = [Link](value)
abslog = [Link](logv,2.0)
Voir la liste #affichage
[Link] print(abslog)
complète sur
52 53
Autres utilisations possibles Création d’un module personnalisé
#définition d'alias
Il suffit de créer un fichier nom_module.py,
import math as m, random as r
et d’y implémenter les fonctions à partager.
#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? dir() et help() permettent d’obtenir des
#utilisation directe
seed(None) informations sur le module (liste du contenu)
value = random)( N.B.: Avec « * », nous les importons
logv = log(value) toutes (ex. from math import *). Là non
abslog = pow(logv,2.0) 54
plus pas besoin de préfixe par la suite.
54 55
R . R. – U ni ver sit é L yon 2
4
Importation d’un module personnalisé Documentation
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. Documentez vos modules, vous
import os faciliterez le travail des
[Link]() # affiche le répertoire de travail actuel
programmeurs qui les utilisent.
[Link](chemin) # permet de le modifier
Ex. [Link]("c:/temp/exo") #noter l’écriture du chemin
56 57
20