Une grande force de la programmation, et l'une des raisons pour lesquelles elle a été inventée, c'est de pouvoir répéter plusieurs fois la même tâche. Nous allons ajouter des « boucles » à nos
algorithmes et programmes. Nous allons étudier deux types d’instructions répétitives : i) les boucles bornées de type « for »
ii) les boucles non bornées de type « while ».
Exemple 01 Nom du fichier : Exemple_Boucle_01.py
# Écrire tous les nombres entiers de 3 à 15 Programme Python (zone de script)
# version 01 / boucle : for for i in range(3,16,1):
print(i)
Entrée et/ou Sortie Python (console)
Out : 3 4 5 6 7 8 9 10 11 12 13 14 15
Programme Python (zone de script)
# version 02 / boucle : for / variable de type : liste L=[ ]
for i in range(3,16,1):
L.append(i) print(L)
Entrée et/ou Sortie Python (console)
Out : [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
Programme Python (zone de script)
# version 03 / boucle : for / variable de type : liste / etapes L=[ ]
for i in range(3,16,1):
L.append(i) print(L)
Entrée et/ou Sortie Python (console) Out :
[3] [3, 4]
[3, 4, 5]
[3, 4, 5, 6]
[3, 4, 5, 6, 7]
[3, 4, 5, 6, 7, 8]
[3, 4, 5, 6, 7, 8, 9]
[3, 4, 5, 6, 7, 8, 9, 10]
[3, 4, 5, 6, 7, 8, 9, 10, 11]
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
Programme Python (zone de script)
# version 04 / boucle : while / variable de type : liste L=[ ]
i=3 while i<=15:
L.append(i) i=i+1
print(L)
Entrée et/ou Sortie Python (console)
Out : [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
Remarques
Dans la version 03 du programme ci-dessus on a indenté la commande print ce qui a eu pour effet d’afficher les valeurs prise par la variable liste L à chaque étape de la boucle. On peut ainsi mieux comprendre et suivre les différentes étapes de l’algorithme et ne pas avoir seulement le résultat final. Cette « astuce » est souvent utile lors de la conception d’un programme complexe.
Exemple 02 Nom du fichier : Exemple_Boucle_02.py
# Écrire tous les nombres entiers de 30 à 4 Programme Python (zone de script)
# version 01 / boucle : for / variable de type : liste L=[ ]
for i in range(30,3,-1):
L.append(i) print(L)
# version 02 / boucle : while / variable de type : liste L=[ ]
i=30
while i>=4:
L.append(i) i=i-1
print(L)
Entrée et/ou Sortie Python (console)
Out : [30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4]
Exemple 03 Nom du fichier : Exemple_Boucle_03.py
# Écrire la table de multiplication de 8 pour les entiers de 0 à 10 Programme Python (zone de script)
for k in range(0,11):
print(k,"* 8 =",k*8)
Entrée et/ou Sortie Python (console) Out :
0 * 8 = 0 1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64 9 * 8 = 72 10 * 8 = 80
Exemple 04 Nom du fichier : Exemple_Boucle_04.py
# Écrire la somme de tous les nombres entiers compris entre a et b avec 0<a<b et calculer la somme.
Programme Python (zone de script)
a=eval(input("Entrez le nombre entier a=")) b=eval(input("Entrez le nombre entier b=")) chaine=" "
somme=0 terme=0
for k in range(a,b,1):
chaine=chaine+str(k)+"+"
terme=k
somme=somme+terme chaine=chaine+str(b) somme=somme+b print(chaine,"=",somme)
Entrée et/ou Sortie Python (console)
In : Entrez le nombre entier a=1 In : Entrez le nombre entier b=10 Out : 1+2+3+4+5+6+7+8+9+10 = 55 In : Entrez le nombre entier a=4 In : Entrez le nombre entier b=13 Out : 4+5+6+7+8+9+10+11+12+13 = 85
Remarques sur les instructions répétitives a) Une boucle bornée est ainsi structurée :
En Python Résultat après exécution
for var in range (debut,fin,pas) :
<instructions>
La variable var prend successivement toutes les valeurs entières de l’entier debut à l’entier fin avec un pas entier de pas, et pour chacune d’elle, exécution des <instructions>.
La variable var est appelée compteur de la boucle.
Les paramètres debut et pas sont optionnels. Cela permet de réaliser une boucle en faisant parcourir à la variable var tous les entiers :
• de l'intervalle
[
0; fin[
si un seul paramètre est renseigné.• de l'intervalle si 2 paramètres
[
debut; fin[
sont renseignés.• dans l'intervalle
[
debut; fin[
mais en réalisant une suite arithmétique de raison pas si les 3 paramètres sont renseignés.Le "pour" va en Python se traduire par l'instruction " for ".
Les <instructions> sont indentées par rapport au for .
L'indentation (décalage du texte) peut être obtenue à l'aide de la touche (TAB) ou en utilisant des espaces.
On utilise en général la boucle " for "quand on connaît à l’avance le nombre de fois que l’on souhaite répéter une instruction.
b) Une boucle non bornée est ainsi structurée :
En Python Résultat après exécution
while <condition> :
<instructions> Tant que la <condition> est vraie (True) alors effectuer les <instructions>.
Le "tant que" va en Python se traduire par l'instruction " while ".
Lorsque Python rencontre une instruction " while ", il effectue l'ensemble des <instructions>
indentées (c'est à dire décalées) qui suivent lorsque la <condition> est vraie (True).
On utilise en général la boucle "while " quand on ne connaît pas à l’avance le nombre de fois que l’on souhaite répéter une instruction.
La boucle "while " peut s’avérer utile si on veut qu’une variable prenne successivement toutes les valeurs de debut à fin avec un pas de pas, sans que ses 3 derniers paramètres soient entiers.
Exercice 01
a) Écrire un programme en Python 3 qui affiche tous les nombres pairs entre 2254 et 2288 dans une liste.
b) Écrire un programme en Python 3 qui affiche tous les nombres impairs entre 131 et 255 dans une liste.
Remarque : Proposer deux versions, une avec la boucle while et l’autre avec for . Indication : Programme Python (zone de script)
# Version / boucle : for L=[ ]
for ……….. : L.append(……….) print(………..)
# Version / boucle : while L=[ ]
i=………..
while ……….. : L.append(……….) i=………..
print(………..) Nom du fichier : Exercice_Boucle_01.py
Exercice 02
a) Ecrire un programme en Python 3 qui affiche la somme : 20+2 21+ 2+... 2+ n et calcule cette somme. Le nombre n est un entier positif entré par l’utilisateur.
Indications : Programme Python (zone de script) n=eval(input(………))
Chaine=……….
Somme=………
Terme=………..
for ………..:
Chaine=………
Terme=……….
Somme=………..
Chaine=……….
Somme=………
print(………..)
Entrée et/ou Sortie Python (console) In : Entrez le nombre entier n=5 Out : 2^0+2^1+2^2+2^3+2^4+2^5 = 63 Nom du fichier : Exercice_Boucle_02.py
Exercice 03
Écrire un programme en Python 3 qui affiche tous les livrets de 1 à 10.
Exemple
Indications : i) Placer une boucle à l'intérieur d'une autre boucle.
ii) Programme Python (zone de script) Nom du fichier : Exercice_Boucle_03.py
Exercice 04
Décrire en français et à l’aide de dessins, sans exécuter le programme dans un éditeur, l’entrée et la sortie du programme Python 3 écrit ci-dessous.
Programme Python (zone de script)
n=eval(input("Entrez un entier positif n=")) print(n*" "+"*")
for i in range(1,n,1):
print((n-i)*" "+"*"+(2*i-1)*" "+"*") Nom du fichier : Exercice_Boucle_04.py
r
h
1.3.7 Fonctions
Nous allons définir des fonctions dans nos programmes.
Travailler avec des fonctions permet souvent de découper les problèmes et de simplifier la lisibilité et la compréhension de nos programmes.
Exemple 01 Nom du fichier : Exemple_Fonctions_01.py
# Calcul du volume d’un cylindre droit Programme Python (zone de script)
import math as mt
def volume_cylindre(h,r):
return mt.pi*r**2*h
# Programme principal
h=eval(input("Entrez la hauteur du cylindre h : ")) r=eval(input("Entrez le rayon du cylindre r : ")) print("Le volume du cylindre droit de hauteur h=",h,\
"et de rayon r=",r,"vaut :",volume_cylindre(h,r))
Entrée et/ou Sortie Python (console) In : Entrez la hauteur du cylindre h : 3 In : Entrez le rayon du cylindre r : 4
Out : Le volume du cylindre droit de hauteur h= 3 et de rayon r= 4 vaut : 150.79644737231007
Remarques
a) On a défini une fonction qui porte le nom : volume_cylindre. Cette fonction à comme « entrées » les nombres positifs h et r et comme « sortie » le nombre mt.pi*r**2*h.
b) Si on exécute au préalable une fonction dans la zone de script, on peut ensuite l’utiliser dans la console.
Entrée et/ou Sortie Python (console) In : volume_cylindre(3,4)
Out : 150.79644737231007
Exemple 02 Nom du fichier : Exemple_Fonctions_02.py
# Fonction factorielle Définition
Soit n un entier positif ou nul. On appelle n factorielle, noté n! , le produit des nombres entiers de 1 à n.
1 si n 0
n! 1 2 3 .... n si n 0
=
= ⋅ ⋅ ⋅ ⋅ >
Exemples
5! 1 2 3 4 5 120 = ⋅ ⋅ ⋅ ⋅ = 7! 1 2 3 4 5 6 7 5040= ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ = 69! 1 2 3 ... 68 69 1,71 10= ⋅ ⋅ ⋅ ⋅ ⋅ ≅ ⋅ 98 0! 1 =
70 ! ... = dépasse les capacités des calculatrices courantes ! Programme Python (zone de script)
# Version 01 (itératif) def factorielle(n):
if n==0:
return 1 produit = 1
for i in range(1,n+1):
produit=produit*i return produit
# Programme principal import math as mt
n=eval(input("Entrez un nombre entier naturel n : ")) while n!=mt.floor(n) or n<0 :
n=eval(input("Entrez un nombre entier naturel n : ")) print(n,"factorielle vaut ",factorielle(n))
Entrée et/ou Sortie Python (console) In : factorielle(5)
Out : 120
In : Entrez un nombre entier naturel n : 5 Out : 5 factorielle vaut : 120
Programme Python (zone de script)
# Version 02 (récursive) def factorielleR(n):
Entrée et/ou Sortie Python (console) In : factorielleR(5)
Out : 120
Remarque (version récursive)
# Relation entre la fonction factorielle et les permutations d’un ensemble E Définition Considérons une fonction f de A vers B. f est une bijection de A vers B si et seulement si pour tout y B∈ il existe un unique x A∈ tel que f ( x ) y= . Exemples A B E= = =
{
a,b,c}
f est une bijection de A vers B. g n’est pas une bijection de A vers B.
Définition Une permutation d’un ensemble E est une bijection de E vers E.
Exemple La fonction f de l’exemple précédent est une permutation de E=
{
a,b,c}
Remarque Toute permutation f de E admet une permutation « réciproque » de E notée f −1
Proposition Le nombre de permutations d’un ensemble E possédant n éléments est n! . Exemple E=
{
a,b,c}
n # E 3= =Le nombre de permutations de E est n! 3! 1 2 3 6= = ⋅ ⋅ =
Explication Chaque « chemin » de cet arbre représente une permutation de E.
Il y a 6 3 2 1 3!= ⋅ ⋅ = « chemin » (permutations) dans cet arbre.
Programme Python (zone de script)
import itertools as iter
L = list(iter.permutations(["a","b"]))
Entrée et/ou Sortie Python (console) Out :
[('a', 'b'), ('b', 'a')]
Nombre de permutations: 2 Out :
[('a', 'b', 'c'), ('a', 'c', 'b'), ('b', 'a', 'c'), ('b', 'c', 'a'), ('c', 'a', 'b'), ('c', 'b', 'a')]
Nombre de permutations: 6 Out :
Nombre de permutations: 24
3 possibilités
Exemple Alphabet=
{
a,b,c,d ,e,...,x,y,z}
n # Alphabet 26= =Le nombre de permutations de Alphabetest n! 26! 4 10= ≅ ⋅ 26 (nombre très grand)
Exemple 03 Nom du fichier : Exemple_Fonctions_03.py
# Arrondir un nombre positif à la demi près Programme Python (zone de script)
def ARRONDI_1_2(n):
y=int(100*n) z=y%100 if 0 <= z <= 24 : t=y//100
elif 25 <= z <= 74 : t=(y//100)+0.5 else:
t=(y//100)+1 return t
Entrée et/ou Sortie Python (console)
In : ARRONDI_1_2(3.249) Out : 3
In : ARRONDI_1_2(3.250) Out : 3.5
In : ARRONDI_1_2(3.749) Out : 3.5
In : ARRONDI_1_2(3.750) Out : 4
In : ARRONDI_1_2(4.135) Out : 4
Rappel : a % b : reste entier de la division euclidienne de a par b.
a // b : quotient entier de la division euclidienne de a par b.
Remarques sur les fonctions Nom du fichier : Remarques_fonctions.py a) La déclaration d'une fonction est ainsi structurée :
En Python Résultat après exécution
def nom_fct (paramètres) :
<instructions>
return données
On a défini une fonction nom_fct qui à des paramètres (entrées) et qui renvoie des données (sorties).
Le nom de la fonction peut comporter plusieurs lettres suivies éventuellement de chiffres.
Les <instructions> et le return sont indentées par rapport au def.
Une fonction peut dépendre de plusieurs paramètres. Il suffit de les lister en les séparant par une virgule.
b) Une fonction peut à son tour en appeler une autre. L’exemple suivant propose une fonction qui calcule le pgcd de deux entiers à l’aide de l’algorithme d’Euclide. Cette fonction est à son tour utilisée pour simplifier une fraction.
Programme Python (zone de script) Entrée et/ou Sortie Python (console)
def PGCD(a,b):
while b!=0:
a,b = b,a%b return a
def SimplFrac(num,den):
d=PGCD(num,den) return num//d , den//d
# Programme principal
num=eval(input("Entrez le numérateur :")) den=eval(input("Entrez le dénominateur :")) print(num,'/',den,"=",\
SimplFrac(num,den)[0],'/',SimplFrac(num,den)[1])
In : PGCD(12,15) Out : 3
In : SimplFrac(12,15) Out : (4, 5)
In : Entrez le numérateur:12 In : Entrez le dénominateur:15 Out : 12 / 15 = 4 / 5
Une fonction peut aussi renvoyer plusieurs données, il suffit de les séparer par une virgule au moment du return. L’exemple précédant montre comment récupérer ces valeurs.
c) Variables locales et globales Programme Python (zone de script)
a, b, c= 6, 8, 10 # a, b et c sont des variables globales def TEST(c):
a=3 # a : variable locale à la fonction TEST b=4*c # b : variable locale à la fonction TEST c=a+b # c : variable locale à la fonction TEST return a,b,c
print(TEST(c)) print(a,b,c)
Entrée et/ou Sortie Python (console) Out : (3, 40, 43)
Out : 6 8 10
Les variables utilisées à l’intérieur d’une fonction (variables locales) n’interfèrent pas avec d’autres variables du programme (variables globales) qui pourraient porter le même nom.
Exercice 01
a) Ecrire un programme en Python 3 qui calcule tous les diviseurs d’un nombre entier positif n et les affiche dans une liste.
Déclarer une fonction et notez-la en Python : diviseurs(n)
Exemple : diviseur( 60 ) devra retourner [1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60].
Indications : i) Utiliser le reste % de la division euclidienne.
ii) Programme Python (zone de script) def diviseurs(n):
L=………
for ……… : if ………
L.append(………) return ………
b) Parmi les nombres entiers suivants (appelés nombre de Mersenne), lesquels sont premiers ? 1) 217−1 2) 218−1 3) 219−1 4) 231−1 5) 280−1 Nom du fichier : Exercice_Fonctions_01.py
Exercice 02
Ecrire un programme en Python 3 qui à un nombre positif n renvoie un nombre qui correspond au nombre n arrondi au dixième.
Déclarer une fonction et notez-la en Python : ARRONDI_1_10(n) Exemples : ARRONDI_1_10( 4.546 ) devra retourner 4.5.
ARRONDI_1_10( 4.557 ) devra retourner 4.6.
Indications : i) Utiliser le quotient // et le reste % de la division euclidienne.
ii) Programme Python (zone de script) def ARRONDI_1_10(n):
Nom du fichier : Exercice_Fonctions_02.py
Exercice 03
Définition Les nombres de Fibonacci forment une suite de nombres que l'on appelle
suite de Fibonacci. Un nombre de la suite s'obtient en ajoutant les deux nombres précédents de la suite : Si on note Fn le nième nombre de Fibonacci, F Fn = n 1− + Fn 2− Les premiers nombres de la suite sont :
indice n 1 2 3 4 5 6 7 8 9 10 11 ... ...
Fn 1 1 2 3 5 8 13 21 34 55 89 ... ...
Ecrire un programme en Python 3 qui à un nombre positif n renvoie le nième nombre de Fibonacci.
Déclarer une fonction et notez-la en Python : fib(n)
Indications : i) Proposer une version non-récursive et une récursive.
ii) Programme Python (zone de script)
# Version / non recursive def fib(n) :
a,b = ………
for ……… : a,b = ………
return ………
# Version / recursive def fibR(n) :
if ……… : return ………
return ………
Nom du fichier : Exercice_Fonctions_03.py
1.3.8 Modules
Fonctions et modules
Lorsque l'on regroupe des fonctions dans un fichier on crée un ensemble de fonctions que l'on nomme en Python : module.
Création d’un module
Nous allons créer un fichier nommé arithm.py qui va contenir 3 fonctions étudiées précédemment : diviseur(n), PGCD(a,b) et SimplFrac(num,den) .
Un tel fichier est appelé un module et il va pouvoir être importé dans un autre fichier, et en particulier dans le fichier qui contient le programme principal.
Module Python dans la zone de script ( nom du fichier : arithm.py )
def diviseurs(n):
" " " Renvoie l'ensemble des diviseurs positifs du nombre entier n " " "
L=[ ]
for i in range(1,n+1,1):
if n%i==0:
L.append(i) return L
def PGCD(a,b):
" " " Calcule le plus grand diviseur commun des nombres a et b " " "
while b!=0:
a,b = b,a%b return a
def SimplFrac(num,den):
" " " Renvoie une fraction irreductible de la fraction num/den " " "
d=PGCD(num,den) return num//d , den//d
Remarque
Si on place en dessous du nom de la fonction et de ses paramètres, un texte entre des triples guillemets qui donne par exemple une description de la fonction, cet information apparaitra plus tard lorsqu’on se renseigne sur le contenu du module. Ce texte appelé docstring et est facultatif.
Importation d’un module
Il est maintenant possible d’utiliser dans un programme « principal » les fonctions qui ont été définies dans le module arithm.py .
• Pour cela, on importe le module arithm avec la commande suivante en définissant un alias ar : import arithm as ar
• Pour connaître le contenu du module importé, ici arithm on tape la commande : print(help("arithm"))
Le nom de toutes les fonctions présentes dans le module et leurs docstring apparaîtront.
• On peut ensuite utiliser à notre guise toutes les fonctions du module comme « outils » en écrivant l’alias du module suivit du nom de la fonction.
Programme Python (zone de script)
( nom du fichier : prog_principal.py ) Entrée et/ou Sortie Python (console)
# PROGRAMME PRINCIPAL import arithm as ar
print(help("arithm"))
Help on module arithm:
NAME
Pour que l’importation du module arithm.py réussisse il doit être situé dans le même répertoire que le programme « principal » progamme_principal.py .
Utilité des modules
Les modules sont donc des fichiers qui regroupent des ensembles de fonctions. En effet, il peut être commode de découper un programme important en plusieurs fichiers de taille modeste pour en faciliter la maintenance et le travail collectif. Une application Python typique peut alors être constituée d'un programme principal accompagné d’un ou plusieurs modules contenants chacun les définitions d'un certain nombre de fonctions accessoires.
Les modules prédéfinis dans Python
Voici une liste non exhaustive de modules de base prédéfinis et disponibles dans Python.
math fonctions utiles pour les opérations mathématiques (cosinus, sinus, exp, etc.) random fonctions permettant de travailler avec des valeurs aléatoires
sys fonctions systèmes
os fonctions permettant d'interagir avec le système d'exploitation time fonctions permettant de travailler avec le temps
calendar fonctions de calendrier
urllib2 fonctions permettant de récupérer des informations sur internet
Programme Python (zone de script) Entrée et/ou Sortie Python (console)
Help on built-in module math:
NAME
Help on built-in function sqrt in math:
math.sqrt = sqrt(...)
Programme Python (zone de script) Entrée et/ou Sortie Python (console)
# Module random import random as rd print(help("random"))
print(help("random.randint")) print(help("random.uniform")) L=[ ]
for k in range(10):
L.append(rd.randint(1,6)) print(L)
M=[ ]
for k in range(10):
M.append(rd.uniform(1,6)) print(M)
Out :
Help on method randint in random:
random.randint = randint(a, b) method of random.Random instance
Return random integer in range [a, b], including both end points.
Out :
Help on method uniform in random:
random.uniform = uniform(a, b) method of random.Random instance
Get a random number in the range [a, b) or [a, b] depending on rounding.
Out :
[6, 2, 1, 4, 1, 1, 1, 6, 4, 6]
Out :
[5.015342231817894, 5.049080497149493, 4.894909171221165, 1.085960530832165, 3.9163654326278015, 5.433416207571077, 3.9129757466807407, 4.598884275004628, 2.389192830497234, 2.5428879099985187]