Langage de Programmation Evolué - BI

L3 BI-EBUS

Chapitre 3: Les fonctions et le modules en Python

Haïfa Nakouri

hayfa.nakouri@esen.tn

ESEN Manouba

2021/2022
 Objectifs du chapitre

 Ecrire et créer des fonctions, des modules ainsi que

des paquetages pour résoudre des problèmes
complexes

 Définir et appeler une fonction (en passant

correctement les arguments correspondants)

 Être capable d’appliquer et d’utiliser des fonctions et

des modules intégrés en Python

Haïfa Nakouri LPE-BI ESEN 2021/2022 2

 1- Les fonctions

Haïfa Nakouri LPE-BI ESEN 2021/2022 3

 Les fonctions en Python

Les fonctions en Python sont :

 Prédéfinies
 prédéfinies sous Python et toujours accessibles.
 Définies par l’utilisateur
 définies par le programmeur et personnalisables.

Haïfa Nakouri LPE-BI ESEN 2021/2022 4

 Les fonctions définies par l’utilisateur
 Les blocs de fonction commencent par le mot-clé def suivi du nom de la
fonction et des parenthèses ().

 Tous les paramètres ou arguments d’entrée doivent être placés entre ces
parenthèses (les paramètres sont à l’intérieur des fonctions, tandis que les
arguments sont utilisés dans les appels de fonction, c’est-à-dire les valeurs
transmises à la fonction au moment de l’exécution).

 Le bloc de code dans chaque fonction commence par un deux-points (:) et il

est en retrait (indentation).

 L’instruction return [expression] quitte une fonction et renvoie éventuellement

une expression à l’appelant. Une instruction return sans arguments est
identique à « return None ».

def nomfonction (paramèters):

function_suite
return [expression]

Haïfa Nakouri LPE-BI ESEN 2021/2022 5

 Créer une fonction

 Exemples

def my_function():
print("Hello from a function")

def sum(a,b):
return (a+b)

def small(a,b):
if (a<b):
d=a
else:
d=0
return d

Haïfa Nakouri LPE-BI ESEN 2021/2022 6

 Créer une fonction

 Exemples

def Min(a,b):
if (a<b):
return a
else:
return b

def Min(a,b):
if (a<b):
return a
elif (a>b):
return b
else:
s=‘there are equal’
return s

Haïfa Nakouri LPE-BI ESEN 2021/2022 7

 Appeler une fonction

 Pour appeler une fonction, on utilise le nom de la fonction suivi

d’une parenthèse et d’arguments.
 Arguments d’une fonction : on peut appeler une fonction à l’aide
des types d’arguments formels suivants :

 Arguments requis (Required arguments)

 Arguments par mot-clé (Keyword arguments)
 Arguments par défaut (Default arguments)
 Arguments variables (Variable-length arguments)

Haïfa Nakouri LPE-BI ESEN 2021/2022 8

 Appeler une fonction

 Arguments requis : arguments transmis à une fonction dans l’ordre

donné. Ici, le nombre d’arguments dans l’appel de fonction doit
correspondre exactement à la définition de la fonction.
x=2
y=4
print(sum(x,y))
Output :
6
print(small(2,4))
Output :
2
x=2
y=4
print(small(x,y))
# ou bien print(small(a=x,b=y))
Haïfa Nakouri LPE-BI ESEN 2021/2022 9
 Appeler une fonction

 Arguments avec mots-clés : on utilise des arguments avec des mots-clés

dans un appel de fonction, l’appelant identifie les arguments par le nom du
paramètre formel. Cela vous permet d’ignorer des arguments ou de les
placer dans un ordre aléatoire, car l’interpréteur Python est capable
d’utiliser les mots-clés fournis pour faire correspondre les valeurs avec les
paramètres.
def small(a,b):
if (a<b):
d=a
else:
d=0
return d
print(small(b=2,a=4))

Output :
0

Haïfa Nakouri LPE-BI ESEN 2021/2022 10

 Appeler une fonction

Exercice :
Que retourne ce programme ?
def Info(name,age):
print ("Name: ",name)
print ("Age ",age)
return
#Appel de la fonction Info
Info( age=20, name= "Jim" )
Info(‘Marry’,30)
Info(50,40)

Haïfa Nakouri LPE-BI ESEN 2021/2022 11

 Appeler une fonction
 Arguments par défaut : un argument qui suppose une valeur par défaut si
aucune valeur n’est fournie dans l’appel de fonction pour cet argument. L’exemple
suivant donne une idée sur les arguments par défaut, il imprime l’âge par défaut
s’il n’est pas passé.
 Tous les arguments sans valeurs par défaut doivent être placés avant les
arguments avec des valeurs par défaut dans la définition de fonction.

def Info(name,age=35):
print ("Name: ",name)
print ("Age ",age)
#Appels de la fonction Info
Info( age=20, name="Jim" )
Info(‘Mack’)
Output :
Name: Jim
Age 20
Name: Mack
Age 35
Haïfa Nakouri LPE-BI ESEN 2021/2022 12
 Appeler une fonction
Exercice :
Que retournent les programmes suivants ?
def Greet(name,msg=‘Greetings!’):
print (name +’, ’+msg)
return
#Appel de Greet
Greet("Jack","Good morning!")
Greet("Yvonne","Good afternoon!")
Greet("Jim","Good evening!")
Greet("Mary")

def Greet(msg=‘Greetings!’,name):
print (msg +’, ’+name)
return
#Appel de Greet
Greet("Good morning! ", "Jack")
Greet("Good afternoon! ", "Yvonne")
Greet("Good evening! ", "Jim")
Haïfa Nakouri
Greet("Mary") LPE-BI ESEN 2021/2022 13
 Appeler une fonction

Arguments de taille variable :

 Outre les arguments nommés, les fonctions peuvent accepter deux
collections spéciales d’arguments. En Python, nous pouvons passer un
nombre variable d’arguments à une fonction à l’aide de symboles spéciaux.
Il existe deux symboles spéciaux :
 *args (Non Keyword Arguments)
 **kwargs (Keyword Arguments)
 Le premier est un tuple nommé. Cet argument spécial est identifié en le
préfixant d’un seul astérisque (*).
 Le second est un dictionnaire de longueur variable contenant tous les
arguments de mot-clé transmis à la fonction qui n’ont pas été explicitement
définis dans le cadre des arguments de fonction. Cet argument est identifié
en le préfixant de deux astérisques (**).

Haïfa Nakouri LPE-BI ESEN 2021/2022 14

 Appeler une fonction
 Arguments de taille variable

def anyFunc(name, age,*cap_letters, gender='M'):

print ("name ", name)
print ("age ", age)
print ("gender ", gender)
for s in cap_letters:
print ("capital letter: ", s)
anyFunc('Mack',24,('A','B'))

Output :
Name: Mack
Age 24
gender: M
capital letter: ('A', 'B')

Haïfa Nakouri LPE-BI ESEN 2021/2022 15

 Appeler une fonction
 Arguments de taille variable
def any_function(**K):
print(“Data type of argument:", type(K))
print (‘K:',K)
any_function(type=‘Senior‘,Age=22)
Output :
Data type of argument: <class 'dict'>
K: {'type': ‘Senior ‘,'Age': 22}
 *args et **kwargs sont des mots-clés spéciaux qui permettent à la fonction
de prendre un argument de longueur variable.
 *args passe un nombre variable d’arguments sans mot-clé qui seront
affectés à un tuple
 **kwargs transmet un nombre variable d’arguments avec mots-clés qui
seront affectés à un dictionnaire
 *args et **kwargs rendent la fonction plus flexible.

Haïfa Nakouri LPE-BI ESEN 2021/2022 16

 Appeler une fonction
Exercice:
Que retournent les programmes suivants ?
def adder(*num):
sum = 0
for n in num:
sum = sum + n
print("Sum:",sum)
adder(3,5)
adder(4,5,6,7)

def countryISO_code(**code):
print ("ISO codes")
print(code)
return
#Appel de countryISO_code
countryISO_code(tn=“Tunisia”,de="German",en="English",fr="French")

Haïfa Nakouri LPE-BI ESEN 2021/2022 17

 Variables globales – Variables locales

Les règles de base pour le mot-clé global en Python sont les suivantes :
 Lorsque nous créons une variable à l’intérieur d’une fonction, elle est
locale par défaut.
 Lorsque nous définissons une variable en dehors d’une fonction, elle
est globale par défaut. Vous n’avez pas besoin d’utiliser le mot-clé
global.
 Nous utilisons un mot-clé global pour lire et écrire une variable globale
à l’intérieur d’une fonction.
 L’utilisation d’un mot-clé global en dehors d’une fonction n’a aucun effet.

Haïfa Nakouri LPE-BI ESEN 2021/2022 18

 Variables globales – Variables locales

def small(a,b):
if(a<b):
d=a
else:

d=0
return d
#Appel
print(small(9,8))
def modify(a): def modify(a): def modify(a): print(d)
x=a x=x+a global x
#Appel #Appel x=x+a
x=10 x=10 Output :
#Appel
modify(99) modify(99) NameError: name ‘d' is not
x=10
print(x) print(x) defined
modify(99)
Output : print(x)
10 Output :
Output :
UnboundLocalError
X est une variable locale,
109 Message d’erreur : les
Aucun effet Message d’erreur : X est variables locales des fonctions
X est une variable locale ne peuvent pas être accédées
reférencée avant l’affectation
X=10+99 de l’extérieur quand l’appel de
function est terminé.

Haïfa Nakouri LPE-BI ESEN 2021/2022 19

 Variables globales – Variables locales

Exercice:
Que retournent les programmes suivants ?

x=10 x=10 global x

def my_function(): def my_function(): x=10
x=5 global x def my_function():
print(x) x=5 x=5
return print(x) print(x)
#Appel de la fct #Appel de la fct #Appel de la fct
my_function() my_function() my_function()
print (x) print (x) print (x)

Haïfa Nakouri LPE-BI ESEN 2021/2022 20

 Fonctions imbriquées

 Python adopte le concept d’une fonction imbriquée ou d’une fonction interne, qui
est simplement une fonction définie à l’intérieur d’une autre fonction
 Il est important de mentionner que la fonction externe doit être appelée pour que
la fonction interne s’exécute. Si la fonction externe n’est pas appelée, la
fonction interne ne s’exécutera jamais.
def outer(): def outer():
x=5 x=5
def inner(): def inner():
x=10 x=10
print(‘inner’,x) print(‘inner’,x)
return return
inner() inner()
print(‘outer’,x) print(‘outer’,x)
#Appel de la function externe #Appel de la function interne
outer() inner()
Output : Output :
inner 10
outer 5 # Le code ne retourne rien
après exécution

Haïfa Nakouri LPE-BI ESEN 2021/2022 21

 Fonctions imbriquées
 msg est déclaré dans la fonction outside et a comme valeur « Outside! ».
 Ensuite, dans la fonction inside, la valeur « Inside! » lui est attribuée.
 Lorsque nous exécutons à l’extérieur, msg a la valeur « Inside! » dans la
fonction inside, mais conserve l’ancienne valeur dans la fonction outside.
 Python n’a pas affecté à la variable msg existante, mais a créé une nouvelle
variable appelée msg dans l’étendue locale de inside.

def outside():
msg = "Outside!"
def inside():
msg = "Inside!"
print(msg)
inside()
Output :
print(msg)
Inside!
outside()
Outside!

Haïfa Nakouri LPE-BI ESEN 2021/2022 22

 Fonctions imbriquées
En ajoutant un mot-clé nonlocal en haut de l’intérieur, Python sait que lorsqu’il
voit une affectation à msg, il doit affecter à la variable à partir de l’étendue
externe au lieu de déclarer une nouvelle variable.
L’utilisation de nonlocal est très similaire à celle de global, sauf qu’elle est
utilisée pour les variables dans les étendues de la fonction externe et que cette
dernière est utilisée pour la variable dans la portée globale.

def outside():
msg = "Outside!"
def inside():
nonlocal msg
msg = "Inside!"
print(msg) Output :
inside() Inside!
print(msg) Inside!
outside()

Haïfa Nakouri LPE-BI ESEN 2021/2022 23

 Fonctions imbriquées
Exercice:
Que retournent les codes suivants ?
def function1():
def function1(): x=2
x=2 def function2(a):
def function2(a): nonlocal x
x=6 x=6
print (a+x) print (a+x)
function2(3) print (x)
print (x) function2(3)
# Appel de function1 #Appel de function1
function1() function2()

def function1():
x=2 def outer(num1):
def function2(a): def inner_increment(num1):
nonlocal x return (num1+1)
x=6 num2= inner_increment(num1)
print (a+x)
function2(3) print (num1, num2)
print (x) # Appel de outer
# Appel de function1 outer(10)
function1()
Haïfa Nakouri LPE-BI ESEN 2021/2022 24
 Fonctions récursives
 Python permet la récursivité des fonctions.
 La récursivité est un concept mathématique et de programmation courant.
 Cela signifie qu’une fonction s’appelle elle-même. Cela signifie qu’on peut
parcourir les données en boucle pour atteindre un résultat.

Règles pour la fonction récursive :

- Doit avoir un cas de base.
def factorial_recursive(n): - Doit changer d’état et se diriger vers le
if n==1: scénario de base.
return 1 - Doit s’appeler elle-même, récursivement.
else:
return n*factorial_recursive(n-1)
# Appel de factorial_recursive
a=3
print(factorial_recursive(a)) Output :
print(factorial_recursive(5)) 6
120

Haïfa Nakouri LPE-BI ESEN 2021/2022 25

 Fonctions récursives
Exercice:
Que retourne le code suivant ?
def factorial(n):
print("factorielle de n = " + str(n))
if n == 1:
return 1
else:
res = n * factorial(n-1)
print(“Rés intermédiaire pour ", n, " * factorial(" ,n-1, "): ",res)
return res
print(factorial(5))
Factorielle de n = 5
Factorielle de n = 4
Factorielle de n = 3
Factorielle de n = 2
Factorielle de n = 1
Rés intermédiaire pour 2 * factorial( 1 ): 2
Rés intermédiaire pour 3 * factorial( 2 ): 6
Rés intermédiaire pour 4 * factorial( 3 ): 24
Rés intermédiaire pour 5 * factorial( 4 ): 120
120
Haïfa Nakouri LPE-BI ESEN 2021/2022 26
 Passage par valeur / par référence

 Quelle stratégie est utilisée en Python : passage par valeur et/ou

passage par adresse (par référence)?

La bonne réponse est : ni l’un ni l’autre.

 Python utilise un mécanisme, connu sous le nom d’appel par objet, parfois
aussi appelé référence d’appel par objet (c’est la façon la plus précise de le
décrire).

 En Python, tout est un objet : ce que nous appelons communément des

variables en Python sont plus correctement appelés noms. De même,
l’affectation est en réalité la liaison d’un nom à un objet.

 En Python, les variables ne sont pas transmises par référence ou par

valeur, elles sont transmises en fonction du type de l’objet :
 Si l’objet est mutable, les modifications apportées à l’objet persisteront
 Si l’objet est immuable, les modifications apportées à la variable ne persistent
pas.
Haïfa Nakouri LPE-BI ESEN 2021/2022 27
 Passage par valeur / par référence

 Objets immuable (non modifiable)

 Tuples
 Booléens
 Nombres
 Chaînes
 Objets mutables (modifiable)
 Dictionnaires
 Listes
 Sets
 Objets définis par l’utilisateur

Haïfa Nakouri LPE-BI ESEN 2021/2022 28

 Passage par valeur / par référence

Exemple:
def change_Them(a,b):
a.append(5)
b[0]=6
print(a,b)
def change_It(a): return
a=10 #Appel de change_Them
print(a) T1=[10]
return T2=[15]
#Appel de change_It print(type(T1))
b=5 print(type(T2)) Output :
print(type(b)) change_Them(T1,T2) <class 'list'>
change_It(b) print(T1,T2) <class 'list'>
print(b) [10,5] [6]
Output : [10,5] [6]
<class ‘int'>
10
5
Haïfa Nakouri LPE-BI ESEN 2021/2022 29
 Passage par valeur / par référence

Exercice:
Que retournent les programmes suivants ? def AddMoney(m):
m+=1
def location(a): print(m)
a.pop(“year”) return
a[‘address’]=“Downtown” #Appel de AddMoney
print(a) Money=1000
def squares(list): return AddMoney(Money)
#Appel de location print(Money)
list.append(5**2) student = {
print(list) “name":“Med", def AddMoney(m):
return “Major":“IT", m+=1
#Appel de squares "year":2019, print(m)
L=[1,4,5] “address”: “Rades” return m
squares(L) } #Appel de AddMoney
print(L) location(student) Money=1000
print(student) Money=AddMoney(Money)
print(Money)

Haïfa Nakouri LPE-BI ESEN 2021/2022 30

 La fonction lambda
 En Python, la fonction anonyme est une fonction définie sans nom.
 Les fonctions anonymes sont définies à l’aide du mot-clé lambda.
 La fonction Lambda n’inclut pas d’instruction « return », elle contient
toujours une expression qui est renvoyée
 Les fonctions anonymes sont également appelées fonctions lambda.
 Une fonction lambda peut prendre n’importe quel nombre d’arguments,
mais ne peut avoir qu’une seule expression.
Arguments lambda : expression

x =lambda a, b, c: a + b + c
Output :
print(x(5, 6, 2))
13

x=lambda a:a** 2
print(x(5)) Output :
25

La function lambda peut être utilisée en conjonction avec des fonctions

prédéfinies telles que filter(), map() et reduce().

Haïfa Nakouri LPE-BI ESEN 2021/2022 31

 La fonction lambda avec filter()

 La fonction filter() offre un moyen élégant de filtrer tous les

éléments d’une séquence et de renvoyer une nouvelle liste
qui contient des éléments pour lesquels la fonction est
évaluée à True.
 La function filter() prend deux arguments :
 Une function - teste si les éléments d’un fichier itérable
renvoient true ou false
 Un itérable - doit être filtré, peut être des listes, des
ensembles, des tuples ou des conteneurs de n’importe
quel itérateur

Haïfa Nakouri LPE-BI ESEN 2021/2022 32

 La fonction lambda avec filter()

 Exemple: Trouver les nombres divisibles par 13 à partir d’une

liste à l’aide de la fonction anonyme.

my_list = [12, 65, 54, 39, 102, 339, 221]

result = list(filter(lambda x: (x % 13 == 0),
my_list))
print("Numbers divisible by 13 are",result)

Output :
Numbers divisible by 13 are [65, 39, 221]

Haïfa Nakouri LPE-BI ESEN 2021/2022 33

 La fonction lambda avec map()
 La function map() prend deux arguments une liste et une fonction et
applique une expression donnée à chaque élément d’une liste et
renvoie une nouvelle liste du résultat.
 Example: utiliser la fonction map() pour doubler tous les éléments
d’une liste :

my_list = [1, 5, 4, 6, 8, 11, 3, 12]

new_list = list(map(lambda x: x * 2 , my_list))
print(new_list)
Output :
[2, 10, 8, 12, 16, 22, 6, 24]

 Passer plusieurs itérateurs à la function map() en utilisant Lambda

num1 = [4, 5, 6]
num2 = [5, 6, 7]
result = map(lambda n1, n2: n1+n2, num1, num2)
print(list(result)) Output :
Haïfa Nakouri LPE-BI [9,ESEN
11, 13]
2021/2022 34
 La fonction lambda avec map()

Exercice :
Que retourne le code suivant ?

def calculateSquare(n):
return n*n
numbers = (1, 2, 3, 4)
result = map(calculateSquare, numbers)
print(result)
# converting map object to set
numbersSquare = set(result)
print(numbersSquare)

Haïfa Nakouri LPE-BI ESEN 2021/2022 35

 La fonction lambda avec reduce()

 La fonction reduce() prend deux arguments une liste et une

fonction et effectue une opération répétitive sur les paires de
la liste et renvoie une nouvelle liste des résultats. Ceci fait
partie du module intégré functools.
 Exemple :

from functools import reduce

My_list = [5, 8, 10, 20, 50, 100]
sum = reduce((lambda x, y: x + y), My_list)
print (sum)

Output :
193

Haïfa Nakouri LPE-BI ESEN 2021/2022 36

 2- Les modules

Haïfa Nakouri LPE-BI ESEN 2021/2022 37

 Qu’est ce qu’un module ?

 Les modules sont des fichiers contenant des définitions

et des instructions Python
 Exemple : module_name.py
 Les modules vous permettent de diviser des parties de
votre programme en différents fichiers pour une
maintenance plus facile et de meilleures performances.
 Un module est un fichier contenant une ou plusieurs
définitions de fonction qui peuvent être partagées avec
d’autres programmeurs ou projets.
 Il peut définir des fonctions, des classes et des variables,
et peut également inclure du code exécutable.
 Tout fichier Python peut être référencé en tant que
module

LPE-BI 38
 Les modules en Python
Les modules en Python sont :
Modules prédéfinis:
 Contient des ressources pour certaines fonctionnalités
spécifiques au système telles que la gestion du système
d’exploitation, les E/S disque, etc.
 La bibliothèque standard contient également de nombreux
scripts Python (avec l’extension .py) contenant des utilitaires
utiles.
 Pour afficher la liste de tous les modules disponibles, utilisez
la commande suivante :
help(‘modules’)
Modules définis par l’utilisateur:
 Définis et personnalisables par le programmeur.
LPE-BI 39
 Modules prédéfinis

 Python propose plusieurs modules prédéfinis et qui sont

fréquemment utilisés :
sys Information about Python itself (path, etc.)
platform used to access the underlying platform’s data, such as,
hardware, operating system, interpreter version information.
os Operating system functions
os.path Portable pathname tools
shutil Utilities for copying files and directory trees
cmp Utilities for comparing files and directories
glob Finds files matching wildcard pattern
re Regular expression string matching
time Time and date handling
datetime Fast implementation of date and time handling
doctest, unittest Modules that facilitate unit test
math, cmath Math functions (real and complex) faster for scalars
random Random generators (likewise)
gzip read and write gzipped files
struct Functions to pack and unpack binary data structures
StringIO, cStringIO String-like objects that can be read and written
as files (e.g., in-memory files)
types Names for all the standard Python type
… LPE-BI 40
 Modules prédéfinis
• Exemple : Importer et utiliser le module “platform”

import platform
x = platform.system()
print(x) Output :
Windows

• Utiliser les fonctions dir() : fonction intégrée pour répertorier

tous les noms de fonction (ou noms de variables) dans un
module.
• Exemple : Lister tous les noms définis appartenant au module
de plateforme
import platform
x = dir(platform)
print(x)

LPE-BI 41
 Modules prédéfinis
• Example: Importer et utiliser le module os
import os
print(os.getcwd())
#Retourne le dossier courant
Output :
C:\Users\HP\PycharmProjects\MDTutorial
import os
#crée un répertoire
os.mkdir(‘OldDir’)
import time
#La fonction sleep() du module time suspends
l’éxecution pendant quelques secondes
time.sleep(3)
#Renommer un fichier ou un répertoire
os.rename(‘OldDir’,’NewDir’)
#Supprimer un répertoire
os.rmdir(‘NewDir’)
#retle contenu d’un répertoire
print(os.listdir())

LPE-BI 42
 Modules prédéfinis

• Example: Importer et utiliser les modules time et datetime

import time
importdatetime
print("Current date and time: " , datetime.datetime.now())
print("Current year: ", datetime.date.today().strftime("%Y"))
print("Month of year: ", datetime.date.today().strftime("%B"))
print("Week number of the year: ",
datetime.date.today().strftime("%W"))
print("Weekday of the week: ",
datetime.date.today().strftime("%w"))
print("Day of year: ", datetime.date.today().strftime("%j"))
print("Day of the month : ",
datetime.date.today().strftime("%d"))
print("Day of week: ", datetime.date.today().strftime("%A"))

Current date and time: 2021-11-10 21:54:27.089264

• Résultat affiché Current year: 2021
Month of year: November
Week number of the year: 45
Weekday of the week: 3
Day of year: 314
Day of the month : 10
LPE-BI
Day of week: Wednesday 43
 Modules prédéfinis

• Example: Importer et utiliser le module math

import math
content=dir(math)
print(content)

• Résultat affiché

['__doc__', '__name__', '__package__', 'acos', 'acosh',

'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil',
'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc',
'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod',
'frexp', 'fsum', 'gamma', 'hypot', 'isinf', 'isnan',
'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'modf', 'pi',
'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh',
'trunc']

LPE-BI 44
 Modules définis par l’utilisateur

 Un module peut être importé par un autre programme pour utiliser

ses fonctionnalités.

 Les définitions d’un module peuvent être importées dans d’autres

modules ou dans le module principal en utilisant « import
module_name ».

 Écrire un module, c’est comme écrire n’importe quel autre fichier

Python.

 Le nom du module est disponible en tant que valeur de variable

globale

LPE-BI 45
 Créer et utiliser un module

Pour créer un module, enregistrez simplement le code souhaité dans un

fichier avec l’extension de fichier .py :
Exemple : Fonction d’écriture pour ajouter / soustraire deux nombres dans
un fichier calculation.py def add(x,y):
return (x+y)
def sub(x,y):
return (x-y)

 Nous pouvons maintenant utiliser le module crée, en utilisant l’instruction

import.
 Pour accéder aux fonctions d’un module, on écrit :
« nom_module.nom_function() »
 Créer un autre script python dans le même répertoire avec le nom
module_test.py et y écrire le code suivant :
import calculation #Importer le module calculation
#Appeler la fonction définie dans le module calculation
print(calculation.add(1,2)) Output :
LPE-BI 3
46
 Créer et utiliser un module

• Exemple: Lister tous les noms définis appartenant au module de calcul

à l’aide des fonctions dir() et help().

import calculation
x = dir(calculation)
print(x)

Output :
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__',
'__name__', '__package__', '__spec__', 'add', 'sub']

LPE-BI 47
Exercice

 Développer un module Python appelé

Perfect_Prime.py définissant trois fonctions :
sumDiv, isPerfect et isPrime :
 La fonction sumDiv renvoie la somme des diviseurs
propres de son argument ;
 La fonction isPerfect renvoie True si le nombre est
égal à la somme de ses diviseurs positifs propres
sinon False.
 La fonction isPrime renvoie True si le nombre est
divisible par 1 et lui-même sinon False.

Haïfa Nakouri LPE-BI ESEN 2021/2022 48

Exercice
# fichier :PerfectPrime.py
 Module .py def sumDiv(n):
s = 0
for i in range(1,(int(n/2)+1)):
if(n%i==0):
s += i
return s

def isPerfect(n):
return sumDiv(n)==n

def isPrime(n):
return sumDiv(n) == 1

 Utiliser les fonctions du module dans mon programme

import PerfectPrime
print(PerfectPrime.isPrime(15))
Haïfa Nakouri LPE-BI ESEN 2021/2022 49
 Créer et utiliser un module
Il existe d’autres façons d’importer des modules:
 L’instruction from…import permet d’importer des fonctions/variables
spécifiques à partir d’un module au lieu de tout importer.
 Dans l’exemple précédent, lorsque nous avons importé le calcul dans
module_test.py, les fonctions add () et sub() ont été importées. Mais
que se passerait-il si nous n’avions besoin que de la fonction add () ?
#Importer la fonction add du module calculation
from calculation import add
#Appeler la fonction add définie dans le module calculation
print(add(1,2))

 Nous pouvons maintenant accéder à la fonction directement sans

utiliser le nom du module.
 Nous pouvons également importer plusieurs attributs, en les séparant
par une virgule dans l’instruction import.
from calculation import add,sub
print(add(1,2))
print(sub(3,2))
LPE-BI 50
 Créer et utiliser un module
 Instruction from ... import * : importe toutes les
fonctions/attributs d’un module.
from calculation import *
print(add(1,2))
print(sub(3,2))

 Renommer un module importé :

 On peut renommer un module, ceci peut être utile pour lui
donner un nom plus significatif ou lorsque le nom du
module est trop grand pour être utilisé à plusieurs reprises.
 On peut créer un alias lorsqu’on importe un module, en
utilisant le mot-clé as :
import calculation as cal
print(cal.add(1,2))
LPE-BI 51
 Les variables dans un module

• Le module peut contenir des fonctions, mais aussi des variables

de tous types (tableaux, dictionnaires, objets etc.)
def add(x,y):
return (x+y)
def sub(x,y):
return (x-y)
student = {
"name": “Med",
" level": “L3",
"age": 19,
"country": “Tunis"}

• Importation calcul module nommé calculation et accès au

dictionnaire student :
import calculation
a = calculation.student["age"]
print(a)
Output :
19
LPE-BI 52
 Chemin d’accès d’un module
• Les modules peuvent être utilisés dans différents programmes/ projets et
leur emplacement physique dans le répertoire peut être différent.
• Pour utiliser le code dans un module, Python doit être capable de localiser
le module et de le charger en mémoire. Les informations d’emplacement
sont stockées sous forme de chemins d’accès dans Python. Chaque fois
que vous demandez à Python d’importer un module, Python examine tous
les fichiers de sa liste de chemins d’accès pour le trouver.
• Les informations de chemin proviennent de trois sources :
• Variables d’environnement : Les variables d’environnement Python,
telles que PYTHONPATH, indiquant à Python où trouver des modules
sur le disque.
• Répertoire actuel : vous pouvez modifier le répertoire Python actuel
afin qu’il puisse localiser tous les modules utilisés par votre application.
• Répertoires par défaut : Python peut toujours trouver ses propres
bibliothèques dans l’ensemble des répertoires par défaut qui sont
inclus dans le cadre de ses propres informations sur les chemins.

LPE-BI 53
 Localisation d’un module

• Lorsque vous importez un module nommé calcul, l’interpréteur

recherche d’abord un module intégré portant ce nom. S’il n’est
pas trouvé, recherche le module dans les séquences suivantes :
• L’interpréteur recherche un fichier nommé name.py dans le
répertoire courant donné par la variable sys.path
• Si le module est introuvable, il recherche dans la liste des
répertoires spécifiés par PYTHONPATH
• Si tout le reste échoue, Python vérifie le chemin par défaut
(sous UNIX - .:/ usr/local/lib/python, et dans Windows
c:\python20\lib)

• Le script en cours d’exécution ne doit pas avoir le même nom

qu’un module standard ou une erreur se produira lors de
l’importation du module

LPE-BI 54
 Les packages en Python
 De même, comme un répertoire peut contenir des sous-
répertoires et des fichiers, un package Python peut avoir des
sous-paquets et des modules.

 Physiquement, un package est un dossier contenant un ou

plusieurs fichiers de module

 Un répertoire doit contenir un fichier nommé __init__.py pour

que Python le considère comme un package. Ce fichier peut
être laissé vide, mais généralement le code d’initialisation de
ce package est placé dans ce fichier.

LPE-BI 55
 Les packages en Python

 Example: Supposons que nous développions un jeu, une

organisation possible des paquets et des modules pourrait
être comme indiqué dans la figure suivante :

LPE-BI 56
 Importer un module d’un package
 On peut importer des modules depuis des packages en utilisant
l’opérateur ‘.’.
Examples:
 Si on souhaite importer le module start de l’exemple précédent :
import Game.Level.start

 Si ce module contient une fonction nommée select_difficulty_level(),

on lui fait reference en utilisant le nom complet.
Game.Level.start.select_difficulty_level(2)

 On peut importer le module sans le préfix du package et simplement

appeler la fonction :
from Game.Level import start
start.select_difficulty_level(2)

 Il est également possible d’importer uniquement la fonction requise à

partir d’un module dans un paquet, ensuite on peut appeler directement
cette fonction :
from Game.Level.start import select_difficulty_level
select_difficulty_level(2)
LPE-BI
 Packages et modules
La principale différence entre un module et un package est
qu’un package est une collection de modules ET qu’il a un
fichier __init__.py. # add.py
myMath/ def add(x, y):
__init__.py """"""
adv/ return x + y # sqrt.py
__init__.py
import math
sqrt.py
add.py
def squareroot(n):
subtract.py
""""""
multiply.py
return math.sqrt(n)
divide.py

# outer __init__.py import mymath

from add import add
from divide import division print mymath.add(4,5)
from multiply import multiply print mymath.division(4, 2)
from subtract import subtract print mymath.multiply(10, 5)
from adv.sqrt import squarerootLPE-BI print mymath.squareroot(48))