Chap3 programmation modulaire en python

[PROGRAMMATION MODULAIRE EN PYTHON] ESPRIMS’
Mariem ZAOUALI | Chapitre 3 : Programmation modulaire en Python 1
Chapitre 3 : Programmation modulaire en Python
• Savoir écrire un programme modulaire
• Connaître l’effet de différentes variables (locales, globales), les fonctions
lambda etc
• Gérer les erreurs
Python offre un ensemble de fonctions prédéfinies. Au moment du démarrage de
l’interpréteur, ces fonctions se chargent comme la fonction abs() ou la fonction
len(). On distingue aussi d’autres fonctions qui se chargent au moment de
l’importation de modules (c’est le cas de sqrt du module math ou de polar du
module cmath). Dans ce chapitre, nous s’initions à la notion de fonctions en python.
1. Les fonctions en Python
a. Déclaration et appel de la fonction
Pourquoi développer une fonction ? Imaginons le cas suivant, où nous voudrions
calculer le factorielle 10 !
Dans le même programme, on veut aussi calculer 100 !
Dans l’exemple précédent, nous avons recopié le code, ce qui rend cette
procédure lourde et source de propagation d’erreurs. Donc la solution est de
factoriser le code -> Notion de fonction !
Une fonction est un bloc d’instructions qui possède un nom et qui reçoit un certain
nombre de paramètres et renvoie un résultat. En utilisant les fonctions, on évite la
répétition, on sépare les données des résultats, on rend le code réutilisable à travers

l’importation des fichiers de fonctions et on décompose les tâches complexes en
des tâches simples plus abordables
Pour déclarer la fonction, en Python, il suffit d’utiliser le mot-clé def :
• Le mot clé def sert à déclarer la fonction
• Il est suivi du nom de la fonction ainsi que de parenthèses contenant les
paramètres formels de cette dernière. Dans le cas où on a plusieurs
paramètres dans une fonction, on utilise les virgules pour les séparer. En cas
où il n’y a pas de paramètres, on laisse les parenthèses vides (on ouvre et on
ferme les parenthèses). On ne précise jamais le type des paramètres. Une
même fonction peut recevoir des paramètres de natures différentes entre
deux jeux d’appels grâce à la notion de typage dynamique= le type d’une
variable dépend de son contenu. La représentation de la fonction en
algorithme est la suivante :
• La chaîne de documentation est optionnelle mais fortement recommandée
• Le bloc d’instruction est obligatoire. L’instruction pass permet d’avoir un bloc
d’instruction vide (si on n’a pas encore désigné que fait notre fonction)
b. Le NoneType et les fonctions avec retour
On peut développer une fonction en Python qui retourne un résultat récupérable
par la fonction appelante. Le mot cle return permet d’arrêter l’exécution d’une
fonction et de renvoyer un résultat. Tous les types qu’on a vus en Python, peuvent
être utilisés comme retour. Quand la fonction ne contient pas le mot clé return,
Python retourne un objet vide ayant comme type NoneType. C’est un type réservé
pour exprimer le vide.
Prenons l’exemple suivant où la fonction ne retourne pas de résultat et testons le
type de retour obtenu :

Testons le cas où la fonction retourne un résultat :
Le mot clé return peut figurer dans plusieurs endroits au sein d’une fonction.
Exemple :
En Python, on peut retourner plus qu’un résultat. Ici, on recourt au tuple pour stocker
les valeurs retournées.
Au moment de l’appel, il faut prendre en considération la nature du résultat. Ainsi,
soit on utilise un objet qui stocke le tuple puis pour accéder aux résultats, on utilise les
indices respectifs, soit on effectue un appel basé sur le nombre de variables
retournées. Exemple :
c. Mode de passage des paramètres
Que se passe-t-il en mémoire au cours de l’appel d’une fonction ?
Au moment de l’appel de la fonction :

• des variables correspondant aux arguments sont créés en mémoire,
• les valeurs des arguments sont copiées dans les variables,
• à la fin de l’appel de la fonction, les variables sont détruites.
• à la fin de l’appel de la fonction, les arguments n’ont pas été modifiés.
• On appelle ce mode de passage : passage d’argument par valeur. Seule la
valeur de l’argument est transmise à la fonction, pas l’argument lui-même
Testons ce code !
Constatation ? C’est un passage différent que celui de valeur!
L’appel de fonction permet de substituer les paramètres formels par des paramètres
effectifs. Les modes de passages dépendent du type des données passés en
paramètres :
• Les types non mutables (int, float, str, complex, bool, tuple…) sont passés par
valeur
• Les types mutables (listes, ensembles, dictionnaires..) imitent le mode de
passage par variable (S ou ES en algorithmique)
Pour bien assimiler la notion de mode de passage, on se base sur l’évolution de la
valeur des identifiants. Testons les codes suivants et notez le résultat obtenu :
Manipulation 1 :
Le résultat :

Manipulation 2 :
Le résultat :
Revenons à notre exemple de factorielle. Fact et c sont deux variables locales. Une
variable locale est une variable déclarée dans le corps d’une fonction. Elle ne peut
pas être modifiée que dans le corps de la fonction dans laquelle elle a été déclarée.
Les variables locales sont créées au moment de l’appel de la fonction,
utilisées/modifiées pendant l’exécution de la fonction et détruite à la fin de l’appel.
Alors maintenant, c’est quoi une variable globale ? Dans le programme suivant, N a
été déclarée à l’extérieur de toute fonction, directement dans le programme
principal : c’est une variable globale.
Une variable globale peut-être lue et modifiée depuis n’importe quel endroit du
programme. Que se passe-t-il si une variable locale et une variable globale ont le
même nom ? Pour répondre à cette question, testez ce code :

La variable ________________________ est prioritaire !
d. Les fonctions Lambda
En Python, une fonction lambda est une fonction anonyme à laquelle on n’a pas
donné de nom et qu’on appliqué quand on veut. La syntaxe est : lambda
paramètres :expression.
Prenons un exemple. Ecrivons un script renvoyant la norme d’un vecteur du plan de
coordonnés (x,y).
Traduisons cette fonction en fonction lambda et ça devient : lambda
x,y :math .sqrt(x**2+y**2).
On peut affecter cette fonction lambda à une variable : f= lambda
x,y :math .sqrt(x**2+y**2). Ainsi, f peut être appelé même en tant que argument à
passer dans une autre fonction !
Prenons un exemple. Considérons f=lambda x :x**2+x+1. On peut appeler f dans une
fonction.

e. Paramètres avec valeurs par défaut-Paramètres positionnels
Une fonction peut être déclarée avec des paramètres ayant des valeurs de départ.
Si l’utilisateur omet l’un des paramètres au moment de l’appel, la valeur par défaut
sera prise en considération tel est le cas de la fonction construire_point qui affiche le
point (0,0) si l’utilisateur ne communique aucun paramètre.
En plus de donner des valeurs de départ aux paramètres, Python autorise d’appeler
la fonction sans trop respecter l’ordre des arguments au moment de la déclaration. Il
suffit d’utiliser le nom du paramètre au moment de l’appel et de préciser la valeur
qu’il prend :
f. Nombre de paramètres variable
Python permet de définir une fonction avec un nombre arbitraire de paramètres. Ce
paramètre est précédé par ‘*’ et est appelé généralement args ou params. Avec
ce genre de paramètres, on ne sait pas vraiment le nombre de paramètres au
moment de l’appel. L’appel de fonction est basé sur un tuple de valeurs :

g. La gestion des exceptions
Quand une erreur se produit dans un script, elle provoque l’arrêt du programme et
affiche un message d’erreur. Pour éviter cette interruption brutale, on peut appliquer
un traitement spécifique. Plus généralement, on peut traiter une situation
exceptionnelle dont on ne sait pas forcément où et quand elle va survenir à
l’intérieur d’un bloc donné. On emploie le terme exception pour désigner une erreur
et rattrape une exception levée en précisant le traitement à faire lorsqu’elle est
levée.
Pour traiter une erreur, Python propose, comme dans d’autres langages, l’emploi de
la clause « try…except » sous la forme suivante :
Cette forme est la plus simple. Le bloc 1 contient le code qui peut lever l’exception,
tandis que le bloc 2 contient le code à exécuter lorsqu’on a une exception levée
dans le bloc 1. Si tout va bien dans le bloc 1, le bloc 2 ne sera pas exécuté. Une
forme plus élaborée est donnée comme suit :
On peut spécifier un traitement particulier à plusieurs exceptions. C’est pour cela
qu’on utilise except NomException1. L’instruction except peut être complétée par
une clause else. Elle sera exécutée si aucune des exceptions dans except n’est
exécutée.
Python possède beaucoup d’exceptions prédéfinies, en voici quelques-unes :

Type de l’exception Explication
IndexError Accès à un élément non existant d’une
liste
NameError Utilisation d’un objet non existant
SyntaxError Erreur de syntaxe dans une instruction
TypeError Erreur de type
ValueError Erreur de valeur
ZeroDivisionError Division par 0
Exemple :
Re-tapez le code suivant :
Exécutez-le en entrant la valeur «p » :
Ajoutez-le bloc d’exception convenable dans le code de la fonction saisie() :

h. Les fonctions imbriquées
Il est possible de déclarer une fonction g à l’intérieur d’une fonction f. Seule la
fonction f est capable d’appeler g. Cette dernière a un comportement local au sein
de f. Pour déterminer les noms des objets considérés comme locaux à une fonction
et leurs équivalent globaux, python offre deux commandes : locals et globals()
Suite à l’appel de min1, on obtient la liste des objets locaux et globaux pour
chacune des fonctions min1 et min2. La fonction min2 figure comme un objet local à
la fonction min3.
i. Les variables globales
Pour forcer une fonction à considérer une variable comme globale, on utilise le mot
clé global suivi du nom de la variable en question. La fonction inc1 utilise la variable
x sans la déclarer ni comme paramètre ni comme variable globale. L’interpréteur ne
reconnait pas x et déclenche une exception :

La deuxième version, inc2(), la variable x est déclarée globale d’une manière
explicite. La variable est initialisée à l’extérieur de la fonction et son contenu est
modifiable par les fonctions qui la déclarent comme le mot clé « global ».
2. Les modules personnels
Python permet de créer des modules personnels qui regroupent un ensemble de
fonctions et de variables ( Il nous donne la possibilité de développer une classe,
notion que nous introduisons cette année et vous la verrez en deuxième année) à
l’intérieur d’un même fichier .py et de les utiliser en cas de besoin. Le fichier possède
un nom défini par le programmeur. Avant de penser à développer un module,
vérifier que Python n’offre pas déjà une alternative !
• L’instruction import nom_module permet de charger la totalité du module en
mémoire. Les fonctions et les variables du module sont accessibles de la
façon suivante : nom_module.nom_element_du_module
• Pour choisir l’élément à charger d’un module et gagner en mémoire, la
syntaxe suivante est sollicitée : from nom_module import
fonction1,fonction2,var1… Dans ces cas, les éléments importés sont
accessible sans le préfixe nom_module
• Le contenu d’un module est affiché par la commande dir(nom_module)
• L’aide est fournie par la commande help(nom_module)
• Pour choisir les instructions qui seront exécutées comme programme principal
dans un script on utilise une variable spéciale __name__. Cette variable est
crée par Python partout et renseigne comme son nom l’indique sur le nom de
tout objet utilisé (script, fonction, variable). Le Shell est une fonction python qui
porte le nom ‘__main__’. Ainsi, pour forcer des fonctions à s’exécuter comme
programme principal, on teste si la variable __name__contient la valeur
‘__main__’. (Voir l’exemple traité au TD)
3. Application
Application 1 : Palindrome
def palindrome(s):
n=len(s)-1
for i in range(n+1):

if s[i]!=s[n-i]:
return False
return True
mot="kayak"
print(palindrome(mot))
Application 2 : Nombre de armstrong
Un nombre est dit de Armstrong s’il est égal à la somme des cubes de ses chiffres
(par exemple, 371 = 33 + 73 + 13 ). Générez la liste des nombres de Armstrong
inférieurs à 1000
Application 3 : Evaluation d’un polynôme
Ecrire une fonction qui permet de prendre en paramètres deux arguments P et x tel
que P représente un polynôme et x la valeur à passer à ce polynôme.
Exemple : P=[-1,0,1]#x²-1
def polynome(P,x):
P_x=P[0]
for i in range(1,len(P)):
P_x=P_x+P[i]*x**i
return P_x
P=[-1,0,1]#x^2-1
x=1
print(polynome(P,x))
(module personnel, fonction imbriquée, forcer les variables pour devenir une var
globale)
4. Du modulaire à l’orienté objet
1. Notion de la programmation orientée objet
La programmation orientée objet consiste à représenter les éléments du monde réel
par des entités informatiques appelés "objets" en adoptant un haut niveau
d'abstraction. Comparons les approches de programmation à savoir procédurale et
orientée objet :

Approche procédurale :
"Que doit faire mon programme ? "
Approche orientée-objet :
"De quoi doit être composé mon programme ?"
Exemple : Si vous êtes appelés à coder un traitement afin de gérer une bibliothèque,
vous serez appelé à comprendre son écosystème tout d’abord pour en déduire le
traitement à faire par votre application.
En adoptant l’approche procédurale, nous pouvons développer de maintes
méthodes, comme « chercher livre », « demander le prêt d’un livre ». L’inconvénient
de cette approche est que nous ne pouvons pas spécifier qui fait quoi ?
Une solution : La programmation orientée objet !
La future application de gestion de la bibliothèque sera composée d’un ensemble
d’objets similaires qui peuvent être informatiquement décrits par :
• une même abstraction : une classe
o même structure de données et méthodes de traitement
o valeurs différentes pour chaque objet

Mariem ZAOUALI | 14
2. La classe et son contenu
On appelle classe la structure d'un objet, c'est-à-dire la déclaration de l'ensemble
des entités qui composeront un objet. Un objet est donc « issu » d'une classe, c'est le
produit qui sort d'un moule.
En réalité, on dit qu'un objet est une instanciation d'une classe : objet = instance
Une classe est composée de deux parties :
• Les attributs (parfois appelés données membres) : il s'agit des données
représentant l'état de l'objet
• Les méthodes (parfois appelées fonctions membres): il s'agit des
opérations applicables aux objets
Notre classe Voiture est une sorte d'usine à créer des voitures. La méthode __init__() (en
appuyant deux fois sur le underscore de la touche 8) est appelée lors de la création
d'un objet de type Voiture.
self.nom est une manière de stocker une information dans la classe. On parle d'attribut
d’instance. Dans notre cas, on stock le nom dans l'attribut nom.
Créons maintenant notre voiture:
Les méthodes sont des fonctions définies dans une classe. Créons une nouvelle
méthode dans notre classe voiture:
Utilisons cette méthode:

Chap3 programmation modulaire en python

Contenu connexe

Tendances

Similaire à Chap3 programmation modulaire en python

Plus de Mariem ZAOUALI

Chap3 programmation modulaire en python