Projet ELIFE
Algorithmique et
programmation procédurale
avec Python
Plan de la formation
• Semaine 1 : (2h cours + 1h TD) • Semaine 4 : (2h cours + 1h TD)
• Environnement de travail. • Les algorithmes d’insertion et de recherche
2/2.
• Les Entrées-Sorties.
• L’estimation de la complexité d’un algorithme.
• Le modèle mémoire et les types de données.
• Les instructions conditionnelles. • Semaine 5 : (1h cours + 2h TD + 3h Projet)
• Les instructions itératives 1/2. • Les structures de données avancées 1/3
• Semaine 2 : (2h cours + 1h TD) • Semaine 6 : (1h cours + 2h TD + 3h Projet)
• Les instructions itératives 2/2. • Les structures de données avancées 2/3
• Les fonctions et les procédures. • Semaine 7 : (1h cours + 2h TD + 3h Projet)
• Semaine 3 : (2h cours + 1h TD) • Les structures de données avancées 3/3
• Les fichiers.
• Les algorithmes d’insertion et de recherche
2
1/2.
Programmation procédurale
Définition:
• Un sous-programme est un bloc d’instructions réalisant une certaine
tâche. Il possède un nom et est exécuté lorsqu’on l’appelle.
• Un script bien structuré contiendra un programme dit principal,
et plusieurs sous-programmes dédiés à des fonctionnalités
spécifiques.
• Quand le programme principal fait appel à un sous-programme,
il suspend son propre déroulement, exécute le sous-programme en
question, et reprend ensuite son fonctionnement
3
Programmation procédurale
Définition:
• Il existe deux types de sous-programmes : les procédures et les
fonctions.
• une procédure c’est un sous-programme qui exécute une tâche et qui
affiche éventuellement des résultats à l’écran.
• une fonction c’est un sous-programme qui exécute une tâche, qui
affiche éventuellement des résultats à l’écran et qui retourne un
résultat.
4
Programmation procédurale
Paramètres de la procèdure.
Exemples 1 :
def fonctionSomme(x,y):
return x+y Fonction retournant un résultat avec la commande return.
def procedureSomme(x,y):
s=x+y Procédure affichant un résultat.
print("%f+%f=%f"%(x,y,s))
a,b=5,6
Appel de la fonction et récupération du résultat dans une
somme=fonctionSomme(a,b) variable.
print("%f+%f=%f"%(a,b,somme))
procedureSomme(a,b) Appel de la procédure. 5
Programmation procédurale
Exemple 2:
i=0
while True:
if i%2==0:
print(i) Ce bloc affiche i si elle est paire
i=i+1
if i == 10 :
break
print("fin")
6
Programmation procédurale
Exemple 2:
def afficheSiPaire(val): Une procédure c’est un sous programme qui exécute une
tache pouvant recevoir éventuellement des paramètres
if val%2==0: mais ne retourne aucune valeur
print(val)
i=0
while True:
afficheSiPaire(i)
i=i+1
if i == 10 :
break
print("fin") 7
Programmation procédurale
Problème 1 :
• Nous voulons réaliser le programme [Link] qui affiche le menu suivant :
********************************
* 1) Addition *
* 2) Soustraction *
* 3) Multiplication *
* 4) Division *
* 5) Quitter *
********************************
choix ? 1
a?5
b?6
5.000000 + 6.000000 = 11.000000 8
Programmation procédurale
Solution 1 (sans sous programmes): b=float(input(" b ? "))
while True: if(choix==1):
print (""" print ("%f + %f = %f"%(a,b,a+b))
1) Addition elif(choix==2):
2) Soustraction print ("%f - %f = %f"%(a,b,a-b))
3) Multiplication elif(choix==3):
4) Division print ("%f * %f = %f"%(a,b,a*b))
5) Quitter elif(choix==4):
""") if(b!=0):
choix=int(input("choix ? ")) print ("%f / %f = %f"%(a,b,a/b))
if choix==5 : else:
break print ("Erreur : division par zero !!!")
else: else :
if choix<6 and choix >0 : print ("mauvais choix !!!")
a=float(input(" a ? ")) print ("au revoir") 9
Programmation procédurale
Solution 1 (avec sous programmes):
def afficheMenu(): def afficheSomme(x,y):
while True: print ("%f + %f = %f"%(x,y,x+y))
print (""" def afficheSoustraction(x,y):
1) Addition print ("%f - %f = %f"%(x,y,x-y))
2) Soustraction def afficheMultiplication(x,y):
3) Multiplication print ("%f * %f = %f"%(x,y,x*y))
4) Division def afficheDivision(x,y):
5) Quitter """) if(y!=0):
val=int(input("choix ? ")) print ("%f / %f = %f"%(x,y,x/y))
if val not in [1,2,3,4,5] : else:
print ("mauvais choix !!!") print ("Erreur : division par zero !!!")
else :
10
return val
Programmation procédurale
Solution 1 (avec sous programmes): #Programme principal
def executerChoix(val,a,b): while True:
if(choix==1): choix=afficheMenu()
afficheSomme(a,b) if choix==5 :
elif(choix==2): break
afficheSoustraction(a,b) a=float(input(" a ? "))
elif(choix==3): b=float(input(" b ? "))
afficheMultiplication(a,b) executerChoix(choix,a,b)
elif(choix==4): print("au revoir")
afficheDivision(a,b)
11
Programmation procédurale
Mode de passage des paramètres:
def incremente(x):
x=x+1
a=1
incremente(a)
Affiche la valeur 1 pourquoi ?
print(a)
12
Programmation procédurale
Mode de passage des paramètres:
def ajouterElement(L,e):
[Link](e)
A=[1,2]
print(A)
ajouterElement(A,3)
print(A) Affiche la valeur [1,2,3] pourquoi ?
13
Programmation procédurale
Mode de passage des paramètres:
def creerListeVide(L):
L=[]
A=[1,2]
print(A)
creerListeVide(A)
print(A)
Affiche la valeur [1,2] pourquoi ?
14
Programmation procédurale
Mode de passage des paramètres:
Question
Les paramètres sont passés par valeur ou par référence ?
15
Programmation procédurale
Mode de passage des paramètres:
Question
Les paramètres sont passés par valeur ou par référence ?
Réponse
Les paramètres sont passés par référence
16
Programmation procédurale
Mode de passage des paramètres:
Explications en utilisant la fonction id(x) qui renvoie la référence d’une valeur en
mémoire
17
Programmation procédurale
Mode de passage des paramètres:
def incremente(x):
print("id(x)",id(x))
x=x+1
print("id(x)",id(x))
a=1
Affiche la valeur 1 pourquoi ?
print("id(a)",id(a))
incremente(a)
print("id(a)",id(a))
print(a)
18
Programmation procédurale
Mode de passage des paramètres:
def ajouterElement(L,e):
print("id(L)",id(L))
[Link](e)
print("id(L)",id(L))
A=[1,2]
print("id(A)",id(A))
print(A) Affiche la valeur [1,2,3] pourquoi ?
ajouterElement(A,3)
print("id(A)",id(A))
print(A) 19
Programmation procédurale
Mode de passage des paramètres:
def creerListeVide(L):
print("id(L)",id(L))
L=[]
print("id(L)",id(L))
A=[1,2]
print(A)
print("id(A)",id(A)) Affiche la valeur [1,2] pourquoi ?
creerListeVide(A)
print("id(A)",id(A))
print(A) 20
Programmation procédurale
La portée des variable:
• Variables locales, variables globales
21
Programmation procédurale
La portée des variable:
def affiche(): x=5
print(x) def affiche():
x=5 print(x)
affiche()
affiche()
X est une variable crée dans le contexte global
X est une variable crée dans le contexte global
22
Programmation procédurale
La portée des variable:
Les variables globales sont toujours accessibles en mode lecture dans tous le
programme à condition qu’elle ne soit pas masquées par une variable locale portant
le même nom.
23
Programmation procédurale
La portée des variable:
def affiche(): Affiche 10
x=10
print(x) Affiche 5 pourquoi ?
x=5
affiche()
print(x)
24
Programmation procédurale
La portée des variable:
def affiche():
x=10 Création d’une variable locale x qui cachera la variable
print(x) globale portant le même nom. La variable locale sera
détruite à la sortie de la fonction
x=5
affiche()
print(x)
Affichera la variable globale x
25
Programmation procédurale
La portée des variable:
def affiche():
global x
Déclare la variable globale x dans le contexte de la
x=10 fonction et ainsi la rendre accessible en écriture.
print(x)
x=5
affiche()
print(x)
26
Programmation procédurale
La portée des variable:
• Variables locales, variables globales, variables internes
• La commande global permet de rendre accessible une variable globale dans le
contexte locale d'une fonction.
• Si on tente d'utiliser une variable globale en écriture sans la déclarer avec la
commande global ceci engendrera la création d'une nouvelle variable locale
portant le même nom.
• En conclusion lors de l’accès en lecture on cherche la variable localement si on ne
la trouve pas on la cherche globalement. Alors que lors de l’accès en écriture on
cherche la variable localement et si on ne la trouve pas on va la créer. C’est pour
cette raison qu’il faut utiliser la commande global pour écrire dans des variables
globale.
27
