Chap2 Fonctions

Introdution
Fonctions : Définition& Appel

Procédures : Définition& Appel
La portée des variables (variables locales, variables globales)
Les modules
Chapitre 2
Les fonctions
2eme Année API

Texte
Texte
Texte
saadi mo@yahoo.fr
9 octobre 2022
ENSA, Khouribga 2023-2023 1/ 29

Introdution
Les modules
Plan
1 Introdution
2 Fonctions : Définition& Appel
3 Procédures : Définition& Appel
4 La portée des variables (variables locales, variables globales)
5 Les modules

Introdution
Les modules
Le concept de la programmation modulaire

La programmation modulaire consiste à décomposer un problème donné en un
ensemble fini des sous problèmes. Ensuite, pour chaque sous-problème i, on cherche
de trouver la solution si . Enfin on regroupe l’ensemble des sous solultions pour aboutir
à la résolution du problème de départ.
Chaque solution d’un sous problème est appellée un module. Un module est une
entité qui contient les données et les instructions. Cette entité est appellée aussi un
sous programme.

Introdution
Les modules
Qu’est-ce qu’un sous programme ?
Un sous programme est une partie du programme principal,

qui porte un nom donné et qui peut être appelé selon les
besoins pour exécuter une tâche donnée.
En programmation, on distingue deux types de sous
programme :
1 Les fonctions
2 Les procédures
⇒Objectif
Il existe déjà des fonctions prédéfinies comme : len, sqrt, pow,
abs, randint,etc.
Notre objectif consiste à developper nos propres fonctions.

Introdution
Les modules
Qu’est qu’une fonction ?

⇒Qu’est qu’une fonction ?
Une fonction en langage Python :
fait une tâche
a un identificateur
reçoit des paramètres en cas de besoin
retourne un résultat si nécessaire
⇒Syntaxe
def NomFonction(parametre1, parametre2, parametre3, ...) :
Text# attention à l’indentation
TextInstruction 1
TextInstruction 2
Text......
TextInstruction n
Textreturn resultat

Introdution
Les modules
instruction return
La valeur de l’expression suivant return est la valeur de la

fonction
Le programme s’arrête après l’exécution du 1er return
rencontré
Ne pas confondre return et print
• print affiche un texte à l’écran mais n’a pas de valeur,
• return décide de la valeur de la fonction mais n’affiche rien sur
l’écran
Remarque
Dans le cas d’une procédure, on peut utiliser : return ;

Introdution
Les modules
Appel
Pour appeler une fonction, il suffit d’utiliser son nom dans
l’instruction print ou dans une expression arithmétique.
Pour appeler une procédure, il suffit d’utiliser son nom dans la
fonction principale main().

Introdution
Les modules
Exemples
Exemple1 : f (x) = x 2 + 1
• Le modèle mathématique :
f : R → R
x 7→ x 2 + 1
⇒Code python ⇒Résultat d’exécution (écran)
##Définition de la fonction f()## Texte
def f(x) : Texte
Textey=x*x+1 Texte
Textereturn y Texte
##Programme principal## Texte
a=10 Texte
##Appel## Texte
print(f(a)) Texte
b=f(0)+f(2) Texte
print(b) Texte
print(f(6) Texte

Introdution
Les modules
Exemples
Exemple2 : fact(n) = n!
fact : N → N
n 7→ n!
##Définition de la fonction fact()## Texte
def fact(n) : Texte
TexteF=1 Texte
Textefor i in range(1,n+1) : Texte
TexteTextF=F*i Texte
Textereturn F Texte
a=5 Texte
##Appel## Texte
print(fact(a)) Texte
print(fact(0)) Texte

Introdution
Les modules
Exemples
√
Exemple3 : g (x) = x +2
√
g (x) = x +2
from math import sqrt Texte
##Définition de la fonction g()## Texte
def g(x) : Texte
Textey=sqrt(x)+2 Texte
Textereturn y Texte
a=25 Texte
##Appel## Texte
b=g(a)+10 Texte
c=g(36)*2 Texte
print(b) Texte
print(c)

Introdution
Les modules
Exemples
Exemple 4 : calcul de h(x)
√
x +2
h(x) =
x2 +1
Texte Texte
Texte Texte
Texte Texte
Texte Texte
Texte Texte
Texte Texte
Texte Texte
Texte Texte
Texte Texte
Texte Texte

Introdution
Les modules
Qu’est qu’une procédure ?

Une procédure est un sous programme qui ne retourne pas une
valeur. Généralement, une procédure est utilisée soit pour lire des
objets ou soit pour les afficher.
def NomProcedure(param1, param2, param3, ...) :
Text# attention à l’indentation
TextInstruction 1
TextInstruction 2
Text......
TextInstruction n
L’appel d’une procédure

En python, L’appel d’une procédure se fait dans le programme
principal ou dans une autre procédure par une instruction
indiquant le nom de la procédure.
Introdution
Les modules
Exemples
Exemple1 :
##sous programme##
def Afficher(msg) :
Texte print(msg)
##programme principal##
ch1=“salut”
ch2=“sami”
##Appel ##
Afficher(ch1)
Afficher(ch2)
⇒Résultat d’exécution (écran)
Texte
Texte
Introdution
Les modules
Exemples
Exemple 2 :
##sous programme##
def T() :
Texte print(“Bonjour”)
##Appel ##
T()

Texte
Texte

Introdution
Les modules
Exemples
Exemple 3 :
##sous programme##
def Ali() :
Texte print(“ali”)
def Bonjour() :
Texte print(“Bonjour”)
Texte Ali()
##Appel ##
Bonjour()
Texte
Texte
Introdution
Les modules
Portée d’une variable locale
Définition
Une variable déclarée dans le corps d’une fonction est une variable
locale à cette fonction.
⇒Exemple
def tableMulti(base, debut, fin) :
Texte print(’Affichage de la table de multiplication par’, base, ’ :’)
Texte n = debut
Texte while n <= fin :
TexteTexte print(n, ’x’, base, ’=’, n * base)
TexteTexte n=n+1
Dans cet exemple les variables base, debut, fin et n représentent
des variables locales.

Introdution
Les modules

Une variable locale ne peut-être lue et modifiée que dans le corps
de la fonction dans laquelle elle a été déclarée.
⇒Exemple
>>> print(base)
Traceback (most recent call last) :
File ”< stdin >”, line 1, in < module >
NameError : name ’base’ is not defined
D’après cet exemple, si nous essayons d’afficher le contenu de la
variable base juste après avoir effectué l’exécution du code, nous
obtenons un message d’erreur.

Introdution
Les modules
Portée d’une variable globale

Définition
Les variables définies à l’extérieur d’une fonction sont des variables
globales.
⇒Exemple
##Déclaration d’une varibale globale
N=100
def ma fonction(a) :
Texte return N+a
##Programme principal
resultat=ma fonction(10)
print(resultat)
N a été déclarée à l’extérieur de toute fonction, directement dans
le programme principal : c’est une variable globale.
Introdution
Les modules

Le contenu d’une variable globale est visible de l’intérieur d’une
fonction, mais la fonction ne peut pas le modifier.
⇒Exemple
a=10
#####Sous programme #####
def incrementer() :
Texte a=a+1
Texte return a
#####Programme principal#####
resultat=incrementer(a)
print(resultat)
File ”C :\Users\saadi\Desktop\tp1.py”, line 7, in < module >
result=incrementer()
File ”C :\Users\saadi\Desktop\tp1.py”, line 4, in incrementer
UnboundLocalError : local variable ’a’ referenced before assignment

Introdution
Les modules
Variable locale vs variable globale

Variable locale vs variable globale
Dans une fonction, si deux variables ont même nom, c’est la variable
locale qui est prioritaire.
⇒Exemple
def mask() :
Texte p = 20
Texte print(p,q)
#programme principal
p, q = 15, 38 #affectation parallèle
>>> mask() #exécution
20 38
>>> print(p, q)
15 38
Introdution
Les modules
L’instruction global
L’instruction global
Cette instruction permet d’indiquer – à l’intérieur de la définition
d’une fonction – quelles sont les variables à traiter globalement.
⇒Exemple
>>> def monter() :
Texte global a
Texte a = a+1
Texte print(a)
>>> a = 15
>>> monter()
16

Introdution
Les modules
L’instruction from et import

En Python, il existe de nombreux modules additionnels dont le
plus connu est le module math, ce dernier définit une vingtaine de
constantes et fonctions mathématiques usuelles. On peut importer
ce module en utilisant deux manières : l’instruction from ou
l’instruction import :
L’instruction from
Cette instruction consiste à charger toutes les fonctions d’un module
dans la mémoire.
⇒Exemple
>>>from math import sin, pi
>>> sin(pi/2)
1.0
Il est possible également d’importer toutes les fonctions d’un module. Pour ce faire on
utilise l’astérisque (*) qui signifie ≪ tout ≫.
>>> from math import *
>>> sqrt(tan(log(pi)))
1.484345173593278

Introdution
Les modules
L’instruction from et import
L’instruction import
Cette instruction consiste à utiliser un module directement sans le
charger dans la mémoire.
⇒Exemple
>>> import math
>>> math.sin(math.pi/2)
1.0
⇒Remarque
il faut utiliser le nom du module comme préfixe, sinon on obtient une erreur.
>>> import math
>>> sqrt(2)
File ” < stdin > ”, line 1, in < module >
NameError : name ’sqrt’ is not defined

Introdution
Les modules
Comment créer un nouveau module
Un module est un fichier dont l’extension est .py et qui

contient un ensemble des procédures ou des fonctions.
Pour créer un nouveau module, on applique les étapes
suivantes :
1 tout d’abord on crée le code d’une fonction nommée fact qui
permet de calculer la factorielle d’un nombre n.
2 Ensuite on met le code de cette fonction dans un fichier appelé
progfact.py (ce fichier est un module).
3 Enfin on peut utiliser ce nouveau module afin de calculer le
nombre de combinaisons :

Introdution
Les modules

⇒Exemple (solution 1)
####le fichier progfact.py####
def fact(n) :
Texte f=1
Texte for i in range(1,n+1) :
TexteTexte f=f*i
Texte return f
####le fichier combinaison.py ####
from progfact import fact
def comb(n,p) :
Texte y=fact(n)/(fact(p)*fact(n-p))
Texte return y
>>> comb(3,1)
3
Introdution
Les modules

⇒Exemple (solution 2)
####le fichier progfact.py####
def fact(n) :
Texte f=1
Texte for i in range(1,n+1) :
TexteTexte f=f*i
Texte return f
####le fichier combinaison.py ####
import progfact
def comb(n,p) :
Texte y=progfact.fact(n)/(progfact.fact(p)*progfact.fact(n-p))
Texte return y
>>> comb(3,1)
3
Introdution
Les modules
Documentation d’une fonction

Lorsqu’on écrit une fonction, il convient de la documenter pour
expliquer comment l’utiliser et éventuellement comment elle a été
implémentée. C’est la doc string de la fonction à placer en tête :
entre le symbole ”””......”””.
Exemple
def TexteTexte max 2 entiers(a,b)
Text”””
Textappel : max 2 entiers(a,b)
Textcette fonction retourne la valeur maximale de deux entiers
Texta,b : sont deux entiers
Textvaleur de retour : a ou b
Text”””
Textif a>b :
TextTextreturn a
Textelse :
TextTextreturn b

Introdution
Les modules
Documentation d’une fonction
L’accès à la documentation d’une fonction se fait via l’appel de la

fonction help(fonction).
Exemple
>>>help(max 2 entiers)
Donne :
Help on function max 2 entiers in module main :
max 2 entiers(a,b)
appel : max 2 entiers(a,b)
cette fonction retourne la valeur maximale de deux entiers
a,b : sont deux entiers
valeur de retour : a ou b
⇒Les fonctions prédéfinies sont souvent bien documentées.

Introdution
Les modules
Compléments sur les modules en PYTHON

Module (os : gestion des répertoires).
import os TextTextLes fonctions seront préfixées par os.
os.getcwd()TextTextQuel est le répertoire de travail ?
os.chdir(’chemin’)TextTextChangement du répertoire de travail
os.listdir()TextTextListe des fichiers dans le répertoire de travail
Module (numpy : gestion des tableaux).

import numpy as npTextTextLes fonctions seront préfixées par np.
np.array(liste)TextTextCréation d’un tableau à partir d’une liste
np.linspace(min,max],nbPoints)TextTextCréation d’un tableau 1D
np.arange(min,max[,pas)TextTextCréation d’un tableau 1D
tableau.reshape(nbElts sur axe 0,...)TextTextPermet de reformer un tableau
tableau.shape TextTextNombre d’éléments sur chaque axe
Module (copy : gestion des ≪ copies ≫ ).

from copy import deepcopyTextTextimportation de la fonction deepcopy
deepcopy(var) TextTextCréation d’une copie ≪ indépendante ≫

Chap2 Fonctions

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chap2 Fonctions

Transféré par

Droits d'auteur :

Formats disponibles

Introdution

Fonctions : Définition& Appel

2eme Année API

ENSA, Khouribga 2023-2023 1/ 29

2 Fonctions : Définition& Appel

3 Procédures : Définition& Appel

4 La portée des variables (variables locales, variables globales)

ENSA, Khouribga 2023-2023 2/ 29

Le concept de la programmation modulaire

ENSA, Khouribga 2023-2023 3/ 29

Qu’est-ce qu’un sous programme ?

Un sous programme est une partie du programme principal,

ENSA, Khouribga 2023-2023 4/ 29

Qu’est qu’une fonction ?

ENSA, Khouribga 2023-2023 5/ 29

La valeur de l’expression suivant return est la valeur de la

ENSA, Khouribga 2023-2023 6/ 29

ENSA, Khouribga 2023-2023 7/ 29

ENSA, Khouribga 2023-2023 8/ 29

ENSA, Khouribga 2023-2023 9/ 29

ENSA, Khouribga 2023-2023 10/ 29

ENSA, Khouribga 2023-2023 11/ 29

Qu’est qu’une procédure ?

L’appel d’une procédure

⇒Résultat d’exécution (écran)

ENSA, Khouribga 2023-2023 14/ 29

Portée d’une variable locale

ENSA, Khouribga 2023-2023 16/ 29

Portée d’une variable locale

Portée d’une variable locale

ENSA, Khouribga 2023-2023 17/ 29

Portée d’une variable globale

Portée d’une variable globale

ENSA, Khouribga 2023-2023 19/ 29

Variable locale vs variable globale

ENSA, Khouribga 2023-2023 21/ 29

L’instruction from et import

ENSA, Khouribga 2023-2023 22/ 29

L’instruction from et import

ENSA, Khouribga 2023-2023 23/ 29

Comment créer un nouveau module

Un module est un fichier dont l’extension est .py et qui

ENSA, Khouribga 2023-2023 24/ 29

Comment créer un nouveau module

Comment créer un nouveau module

Documentation d’une fonction

ENSA, Khouribga 2023-2023 27/ 29

Documentation d’une fonction

L’accès à la documentation d’une fonction se fait via l’appel de la

ENSA, Khouribga 2023-2023 28/ 29

Compléments sur les modules en PYTHON

Module (numpy : gestion des tableaux).

Module (copy : gestion des ≪ copies ≫ ).

ENSA, Khouribga 2023-2023 29/ 29

Vous aimerez peut-être aussi