Exercice 1 : Génération de nombres premiers

Objectif : générer des nombres premiers dans un intervalle en utilisant les instructions for et
while.
Algorithme :
Un nombre premier est un nombre entier supérieur à 1 dont les seuls facteurs sont 1 et lui-même.
Les premiers nombres premiers sont 2, 3, 5, 7, 11, 13, 17, 19, 23 et 29.

Pour vérifier si un nombre donné (num) est un nombre premier, il faut d'abord le diviser par 2. Si
le résultat est un nombre entier (c'est-à-dire que num est divisible par 2 ou que le reste de num/2
est nul ou que num % 2 est 0), alors num n'est pas un nombre premier. Sinon, essayez de le
diviser par des nombres premiers 3, 5, 7, 11, ... , jusqu'à num-1 ou divisez-le par 3, 4, 5, ....
jusqu'à num-1. Si num n'est pas divisible jusqu'à num-1, alors num est un nombre premier.

a) Codage : (en utilisant l'instruction for)

# Pour afficher tous les nombres premiers dans un intervalle donné [inférieur, supérieur].

lower = int(input("Entrer la limite inférieure : "))

upper = int(input("Entrer la limite supérieure : "))
print("Les nombres premiers entre ", lower, "et", upper, "
sont :")
for num in range(lower, upper + 1):
if num > 1:
for i in range(2, num):
if (num % i) == 0:
break
else:
print(num)

Resultat:

Entrer la limite inférieure : 20

Entrer la limite supérieure : 50
Les nombres premiers entre 20 et 50
sont :
23
29
31
37
41
43
47
>>>

b) Codage : (en utilisant l'instruction while)

# Programme Python pour afficher tous les nombres premiers dans un intervalle donné [inférieur,
supérieur] en utilisant l'instruction while.
 lower = int(input("Entrer la limite inférieure : "))
upper = int(input("Entrer la limite supérieure : "))
print("Les nombres premiers entre", lower, "et", upper, "sont :")
num=lower
while(num<=upper):
if num > 1:
for i in range(2, num):
if (num % i) == 0:
break
else:
print(num)
num=num+1

Résultat :
Entrer la limite inférieure : 50
Entrer la limite supérieure : 100
Les nombres premiers entre 50 et 100 sont : 53
59
61
67
71
73
79
83
89
97
>>>

Exercice 2 : Résolution d'une équation quadratique

Objectif : trouver les racines d'une équation quadratique à partir des coefficients a, b et c.

Algorithme :

En algèbre, une équation quadratique est toute équation de la forme ax 2+ bx + c = 0, où x est

inconnu et a, b et c sont des nombres connus. Les nombres a, b et c sont les coefficients de
l'équation.

Exemples : x 2+ 5x + 6 = 0, 4x2+ 5x + 8 = 0.

Les valeurs de x qui satisfont l'équation sont appelées solutions ou racines de l'équation. Une
équation quadratique a toujours deux racines. On peut les trouver en calculant d = b 2- 4ac. La
valeur de d est zéro ou +ve ou -ve.

i) Si d = 0 alors les racines sont réelles et égales. Elles sont racine1 = -b/(2a) et racine2 = -b/(2a).

ii) Si d > 0 alors les racines sont réelles et différentes. Elles sont racine1=-b+√d/(2a) et racine2=-
b-√d/(2a).

iii) Si d < 0, alors les racines sont complexes ou imaginaires. Les racines sont de la forme p + iq
et p - iq, où p est la partie réelle de la racine et q est la partie imaginaire de la racine. La partie
 réelle de la racine est p = -b/(2a) et la partie imaginaire est q = √-d/(2a).

Codage :
# Trouver les racines de l'équation quadratique a x 2 +bx
# Importer les modules maths et maths complexes
import math,cmath
a,b,c= (input("Entrez a, b et c : ")).split()
a,b,c =[int(a),int(b),int(c)]
d = (b**2) - (4*a*c)
if d==0:
sol1 = -b/(2*a)
sol2 = -b/(2*a)
print("Les racines sont réelles et égales")
elif d>0:
sol1 = (-b-math.sqrt(d))/(2*a)
sol2 = (-b+math.sqrt(d))/(2*a)
print("Les racines sont réelles et différentes")
elif d<0:
sol1 = (-b-cmath.sqrt(d))/(2*a)
sol2 = (-b+cmath.sqrt(d))/(2*a)
print("Les racines sont imaginaires")
print('{0} and {1}'.format(sol1,sol2))

Résultat :
Entrez a, b et c : 1 4 4
Les racines sont réelles et égales.
-2,0 et -2,0
>>>
Entrez a, b et c : 1 5 6
Les racines sont réelles et différentes.
-3.0 et -2.0
>>>
Entrez a, b et c : 1 2 3
Les racines sont imaginaires
(-1-1,4142135623730951j) et (-1+1,4142135623730951j)
>>>

Exercice 3 : Opérations sur les Chaines

Objectif : effectuer les opérations de chaîne de caractères en utilisant des fonctions définies par
l'utilisateur.

Algorithme :

Une chaîne de caractères est un type de données utilisé en programmation, comme un nombre
entier et des nombres à virgule flottante, mais elle est utilisée pour représenter du texte plutôt que
des nombres. Elle est composée d'un ensemble de caractères. Un tableau de caractères est utilisé
pour stocker une chaîne de caractères.
 Exemples : "Annamalai", "2345"

Les principales opérations sur les chaînes de caractères sont : la longueur d'une chaîne
(comptage du nombre de caractères dans la chaîne), l'inversion d'une chaîne, la concaténation de
deux chaînes et la comparaison de deux chaînes. En Python, l'opérateur arithmétique '+' est
utilisé pour concaténer des chaînes de caractères et les opérateurs relationnels '<', '<=', '>', '>='
'==' sont utilisés pour comparer des chaînes de caractères. En Python, une fonction est définie à
l'aide du mot-clé def.

Codage :

# Opérations sur les chaînes de caractères : Longueur de chaîne, inversion de chaîne,

concaténation de chaîne et comparaison de chaîne def strlen(str) :

def strlen(str):
counter = 0
while str[counter:]: counter += 1
return counter

def strrev(str):
rstr=""
l=strlen(str)
while l>0:
rstr = rstr + str[l-1]
l=l-1
return rstr

def strcat(st1,st2):
return(st1+st2)

def strcmp(st1,st2):
if(st1==st2):
print(st1 + " et " + st2 + " sont identiques")
elif (st1>st2) :
print(st1 + " vient après " + st2 + " dans le Dictionnaire")
else :
print(st1 + " vient avant " + st2 + " dans le dictionnaire ")

print(" Fonctions des chaînes de caractères :\n1. Longueur de chaîne \n2. Inversion de chaîne
de caractères \n3. Concaténation de chaînes de caractères\n4. Comparaison de chaînes de
caractères")

n=int(input("Entrez votre Choix: "))

if(n==1):
str = input("Entrez une chaine: ")
print("La longueur de la chaîne est:",strlen(str))
elif (n==2):
str = input("Entrez une chaîne : ")
print("La chaîne inversée est :", strrev(str))
elif (n==3):
 str1 = input("Entrez la premiere chaîne: ")
str2 = input("Entrez la seconde chaîne: ")
print("La chaîne concaténée est ::", strcat(str1,str2))
elif (n==4):
str1 = input("Entrez la premiere chaîne: ")
str2 = input("Entrez la seconde chaîne: ")
strcmp(str1,str2)
else:
print("Choix invalide")

Resultat:

Fonctions des chaînes de caractères :

Longueur de chaîne
Inversion de chaîne de caractères
3. Concaténation de chaînes de caractères
Comparaison de chaînes de caractères

Entrez votre Choix: 1

Entrez une chaine: bonjour
La longueur de la chaîne est: 7
>>>
Entrez votre Choix: 2
Entrez une chaîne : bonjour
La chaîne inversée est : ruojnob
>>>
Entrez votre Choix: 3
Entrez la premiere chaîne: LMIAGE
Entrez la seconde chaîne: Casa
La chaîne concaténée est : LMIAGE Casa
>>>
Entrez votre Choix: 4
Entrez la premiere chaîne: bon
Entrez la seconde chaîne: bonjour
bon vient avant bonjour dans le dictionnaire
Exercice 4 : Le plus grand des N nombres
Objectif : trouver le plus grand de n nombres donnés en utilisant une liste et une fonction.
Algorithme :

Une liste est une structure de données en Python. Une liste contient une séquence ordonnée
d'éléments et elle peut être modifiée. Une liste Python est comparable à un tableau dans d'autres
langages. Les listes n'ont pas besoin d'avoir des éléments homogènes (même type de données), ce
qui en fait une structure de données très puissante en Python. Une seule liste peut contenir des
types de données tels que des entiers, des nombres flottants, des chaînes de caractères, etc,

Création de la liste : Initialement, une liste vide est créée. Les n éléments sont ajoutés à la liste
un par un en utilisant la fonction intégrée append().

Fonction : En Python, une fonction est définie à l'aide du mot-clé def. Pour trouver le plus grand
de n nombres donnés, le premier nombre est supposé être le plus grand. Le deuxième nombre est
 comparé au plus grand. Si le deuxième nombre est plus grand que le plus grand, alors le
deuxième nombre est considéré comme le plus grand nombre actuel. Ce processus est répété
pour tous les autres nombres restants de la liste afin de trouver le plus grand nombre. En Python,
la fonction intégrée max() peut également être utilisée pour trouver le plus grand des n nombres
(par exemple, largest=max(lst)).

Codage :
# Le plus grand nombre de n nombres en utilisant Liste et Fonction
def lar(lst,n) :
l=lst[0]
for i in range(1,n):
if (lst[i]>l):
l=lst[i]
return l
lst=[]
n=int(input("Entrez le nombre total d'éléments : "))
print("Entrez les éléments un par un : ")
for i in range(n) :
num=float(input())
lst.append(num)
print("Les éléments donnés sont :")
print(lst)
print("Le plus grand nombre est",lar(lst,n))

Résultat :
Entrez le nombre total d'éléments : 5
Entrez les éléments un par un : 24
78
98
12
45
Les éléments donnés sont : [24.0, 78.0, 98.0, 12.0, 45.0]
Le plus grand nombre est 98.0
>>>

Exercice 5 : Multiplication matricielle

Objectif : Multiplier deux matrices d'ordre m x n et n x p en utilisant une liste/un tableau et une
fonction.

Algorithme :

Un tableau est une structure de données et il est utilisé pour stocker le même type (type de
données) d'éléments/valeurs. En python, une liste peut contenir des éléments de différents types de
données.

Création de la liste : Initialement, une liste vide est créée. Les éléments de la matrice A (m x n
éléments) sont ajoutés à la liste un par un en utilisant la fonction intégrée append().

Création d'une matrice : Les besoins de stockage d'un tableau doivent être spécifiés. Les
éléments de la matrice B (n x p éléments) sont lus un par un et stockés dans le tableau.

Algorithme de multiplication de matrices : La matrice A a mxn éléments et la matrice B a n x

p éléments. Le résultat de A x B est une matrice C d'ordre m x p. Chaque élément de la matrice C
est initialisé à zéro et il est calculé comme indiqué ci-dessous.

for i = 0 to m-1
for j = 0 to p-1
begin
c[i][j] = 0
for k = 0 to n-1
begin
c[i][j] = c[i][j] + a[i][k] * b [k][j]
end
end

Codage :

# Multiplication de matrices : La matrice A est d'ordre (m x n) et la matrice B est

d'ordre (n x p), # Fonction pour la multiplication de matrices
def matmul(a,b,m,n,p):
c=[[0 for j in range (0,p)] for i in range (0,m)]
for i in range(m):
for j in range(p):
c[i][j]=0
for k in range(n):
c[i][j]=c[i][j]+a[i][k]*b[k][j]
return c

m=int(input("Entrez le nombre de lignes de la première matrice: "))

n=int(input("Entrez le nombre de colonnes de la première matrice: "))
p=int(input("Entrez le nombre de colonnes de la deuxième matrice: "))
# Reading matrix A using List
a=[]
print("Entrez les éléments de la première matrice (ordre des lignes) : ")
for i in range(m):
r=[]
for j in range(n):
r.append(int(input()))
a.append(r)
# Initializing two dimensional array and reading matrix B
b=[[0 for j in range (0,p)] for i in range (0,n)]
 print("Entrez les éléments de la deuxième matrice (ordre des lignes): ")
for i in range(n):
for j in range(p):
b[i][j]=int(input())
print("La matrice A est:")
print(a)
print("La matrice B est :")
print(b)
print ("Résultante est :")
print(matmul(a,b,m,n,p))

Resultat:
Entrez le nombre de lignes de la première matrice : 2
Entrez le nombre de colonnes de la première matrice : 2
Entrez le nombre de colonnes de la deuxième matrice : 2
Entrez les éléments de la première matrice (ordre des lignes) :
1
2
3
4
Entrez les éléments de la deuxième matrice (ordre des lignes) :
1
12
5
13
La matrice A est :
[[1, 2], [3, 4]]
La matrice B est :
[[1, 12], [5, 13]]
La matrice résultante est : [[11, 38], [23, 88]]
>>>

Exercice 6 : Classe et objets

Objectif : définir une classe avec un constructeur et créer des objets.

Classe et objets :

Une classe en C++/Java/Python est le bloc de construction qui mène à la programmation

orientée objet. Il s'agit d'un type de données défini par l'utilisateur qui possède des membres de
données et des fonctions membres. Les membres de données sont les variables de données et les
fonctions membres sont les fonctions utilisées pour manipuler ces variables. Une classe est
définie en python à l'aide du mot-clé class suivi du nom de la classe.

Un objet est une instance d'une classe. Lorsqu'une classe est définie, aucune mémoire n'est
allouée, mais lorsqu'elle est instanciée (c'est-à-dire lorsqu'un objet est créé), la mémoire est
allouée.

La fonction init () de la classe est exécutée automatiquement chaque fois que la classe est
utilisée pour créer un nouvel objet. Elle est appelée constructeur dans la terminologie orientée
objet. Cette fonction est utilisée pour initialiser les membres de données de la classe.

Dans la plupart des langages de programmation orientée objet (POO), les spécificateurs
d'accès sont utilisés pour limiter l'accès aux variables et aux fonctions d'une classe. La plupart
des langages POO utilisent trois types de spécificateurs d'accès : private, public et protected. En
Python, toutes les variables et les fonctions membres d'une classe sont publiques par défaut.
L'ajout d'un préfixe à la variable ou à la fonction membre les rend privées.
# Trouver la distance euclidienne entre deux pintes dans un espace à trois dimensions en utilisant des
classes et des objets.

# La classe appelée point consiste en un constructeur ( init ()) et deux fonctions

#distancefromorgin() et distance()

import math
class point():
def __init__(self,a,b,c):
self.x=a
self.y=b
self.z=c
def distancefromorigin(self):
return ((self.x ** 2) + (self.y ** 2) +(self.z ** 2)) ** 0.5

def distance(self, point2):

xdiff = self.x-point2.x
ydiff = self.y-point2.y
zdiff = self.z-point2.z
dist = math.sqrt(xdiff**2 + ydiff**2+ zdiff**2)
return dist

x1,y1,z1= (input("Entrez les coordonnées d'un premier point P1(x1,y1,z1): ")).split()

x1,y1,z1 =[int(x1),int(y1),int(z1)]
x2,y2,z2= (input("Entrez les coordonnées d'un deuxième point P2(x2,y2,z2):
")).split()
x2,y2,z2 =[int(x2),int(y2),int(z2)]
# P1 and P2 are objects of point class
p1 = point(x1,y1,z1)
p2 = point(x2,y2,z2)
 print(' Distance de l'origine à P1 :', p1.distancefromorigin())
print(' Distance de l'origine à P2 :', p2.distancefromorigin())
print(' Distance de P1 à P2:',p1.distance(p2))

Résultat :
Entrez les coordonnées d'un premier point P1(x1,y1,z1) : 1 2 3
Entrez les coordonnées d'un deuxième point P2(x2,y2,z2) : 2 3 4
Distance de l'origine à P1 : 3,7416573867739413
Distance de l'origine à P2 : 5,385164807134504
Distance de P1 à P2 : 1,7320508075688772
>>>
Exercice 7 : Classe Héritage simple et multiple

Objectif : définir une nouvelle classe à partir d'une ou plusieurs classes existantes.

Héritage :

L'héritage est un mécanisme par lequel une classe (classe dérivée) acquiert la propriété d'une autre
classe (classe de base). Avec l'héritage, nous pouvons réutiliser les variables et les méthodes de la
classe existante. La classe existante est appelée classe de base et la nouvelle classe est appelée
classe dérivée. L'héritage facilite donc la réutilisation et constitue un concept important de la
programmation orientée objet. Les types d'héritage sont : l'héritage simple, l'héritage multiple,
l'héritage multi-niveaux, l'héritage hiérarchique et l'héritage hybride.
L'héritage simple permet à une classe dérivée d'utiliser les variables et les fonctions définies dans
une classe existante. Dans l'héritage multiple, la classe dérivée hérite des caractéristiques et des
fonctions de plus d'une classe existante.
En python, la syntaxe pour définir l'héritage simple est class z(x), où x est le nom de la classe de
base et z est le nom de la classe dérivée. De même, l'héritage multiple est défini en utilisant la
syntaxe class z(x, y), où x et y sont les noms des classes de base et z est le nom de la classe
dérivée.

Codage :
class person :
def __init__ (self, n, a) :
self.name = n
self.age = a
# employee est la classe dérivée de person en utilisant l'héritage simple
class employee(person) :
def __init__ (self, n,a, d,s) :
person.__init__(self,n,a)
self.designation=d
self.salary=s
def show(self) :
print("Détails de l'employé : ")
 print(" Nom : ",self.name, "\n Age :",self.age, "\n Designation :",self.designation, "\n Salary :",self.salary)
# étudiant est une classe de base
class student :
def __init__(self, id, rno):
self.studentId = id
self.roomno=rno
# resident est une classe dérivée de person et student en utilisant l'héritage multiple
class resident(person, student) :
def __init__(self, n, a, id,rno):
person.__init__(self, n, a)
student.__init__(self, id,rno)
def show(self) :
print("Détails du résident :")
print(" Nom :", self.name, "\n Age : ",self.age, "\n Id :" ,self.studentId, "\n Room no. :",self.roomno)
# Création d'objets des classes employé et résident
e1 =employee("Arun",35, "Data analyst",50000)
r1 = resident("Jean", 30, 201900025,203)
e1.show()
r1.show()
Résultat :

Détails de l'employé :
Nom : Arun
Age : 35
Designation : Data analyst
Salary : 50000
Détails du résident :
Nom : Jean
Age : 30
Id : 201900025
Room no. : 203
>>>
Exercice 8 : Surcharge de l'opérateur

Objectif : surcharger les opérateurs binaires pour effectuer des opérations sur des objets.

Surcharge de l’opérateur :

La surcharge d'opérateurs est un concept important de la programmation orientée objet. Il s'agit

d'un type de polymorphisme dans lequel une signification définie par l'utilisateur peut être donnée
à un opérateur en plus de la signification prédéfinie pour cet opérateur.

La surcharge d'opérateur nous permet de redéfinir la façon dont l'opérateur fonctionne pour les
types définis par l'utilisateur tels que les objets. Il ne peut pas être utilisé pour les types intégrés
tels que int, float, char etc. Par exemple, l'opérateur '+' peut être surchargé pour effectuer l'addition
de deux objets de la classe distance.

Python fournit une fonction spéciale ou une fonction magique qui est automatiquement invoquée
lorsqu'elle est associée à cet opérateur particulier. Par exemple, lorsque nous utilisons l'opérateur
+ sur des objets, la méthode magique add () est automatiquement invoquée. La
signification/opération de l'opérateur + est définie pour les objets définis par l'utilisateur.

Codage :
# la distance est une classe. La distance est mesurée en termes de pieds et de pouces :

class distance:
def __init__(self, f,i):
self.feet=f
self.inches=i
# surcharge de l'opérateur binaire > pour comparer deux
def __gt__(self,d):
if(self.feet>d.feet):
return(True)
elif((self.feet==d.feet) and (self.inches>d.inches)):
return(True)
else:
return(False)
# surcharge de l'opérateur binaire + pour ajouter deux
def __add__(self, d):
i=self.inches + d.inches
f=self.feet + d.feet
if(i>=12):
i=i-12
 f=f+1
return distance(f,i)
# affichage de la distance
def show(self):
print("Pieds= ", self.feet, "Pouces= ",self.inches)
a,b= (input("Entrez les pieds et les pouces de la distance1: ")).split()
a,b =[int(a),int(b)]
c,d= (input("Entrez les pieds et les pouces de la distance2: ")).split()
c,d =[int(c),int(d)]
d1 = distance(a,b)
d2 = distance(c,d)
if(d1>d2):
print("La distance1 est supérieure à la distance2")
else:
print("La distance2 est supérieure à la distance1")
d3=d1+d2
print("La somme des deux distances est :")
d3.show()
Résultat :

Entrez les pieds et les pouces de la distance1 : 8 4 8 4

Entrez les pieds et les pouces de la distance2 : 6 9 6 9
La distance1 est supérieure à la distance2 La somme des deux distances est :
Pieds= 15 Pouces= 1
>>>

Exercice 9 : Traitement des fichiers

Objectif : : effectuer des opérations sur des fichiers telles que l'ouverture, la lecture, l'écriture et la
fermeture de fichiers de données textuelles et numériques.

Traitement des fichiers :

Un fichier est une collection de données stockées dans une unité, identifiée par un nom de fichier.
 Il peut s'agir d'un document texte, d'une image, d'un fichier audio, audio-vidéo ou d'une autre
collection de données. Les formats/extensions courants pour les documents texte sont .doc, .docx
(documents Microsoft Word), .odt (document texte ouvert LibreOffice), .pdf (format de document
portable Adobe), rtf (format de texte riche Microsoft), .tex (texte LaTeX), .txt (texte Microsoft
Notepad). Les formats de fichiers d'image sont : .jpg, .tiff, .gif, .png, bmp. Les formats audio les
plus utilisés sont : .wav et .mp3. Les formats audio-vidéo sont les
suivants : .avi, .mp4, .mkv, .mov, .flv, .wmv, etc,

Python prend en charge la manipulation des fichiers et permet aux utilisateurs de manipuler des
fichiers, c'est-à-dire de lire et d'écrire des fichiers, ainsi que de nombreuses autres options de
manipulation de fichiers, pour opérer sur des fichiers. Les fonctions Python open() et close() sont
utilisées pour ouvrir et fermer un fichier. Les fonctions read() et write() sont utilisées pour lire et
écrire du texte (ou des données numériques ou binaires) depuis/vers le fichier, respectivement. Les
modes d'ouverture de fichiers en Python sont : r (lecture), w (écriture), a (ajout), rb (lecture de
données binaires), wb (écriture de données binaires).

a) Codage : (Lire et écrire un fichier texte)

# Copie de fichier - le contenu d'un fichier texte (input.txt) est copié dans un autre fichier texte
(output.txt)

infile=open("./input.txt","r")
outfile=open("./output.txt","w")
lines = chars = 0
for line in infile:
lines += 1
chars += len(line)
outfile.write(line)

print(lines, " lignes copiées,",chars, " caractères copiés ")

infile.close()
outfile.close()
Résultat :

11 lignes copiées, 82 caractères copiés

b) Codage : (Rédaction et écriture de fichiers de données numériques)

# la somme de tous les nombres dans le fichier d'entrée (input.dat) est calculée
# et elle est écrite dans le fichier de sortie (output.dat)
infile=open("./input.dat","r")
outfile=open("./output.dat","w")

sum=0
s = infile.read()
numbers = [int(x) for x in s.split()]
print("The numbers are:")
print(numbers)

for num in numbers:

 sum=sum+num
somme=str(sum)
outfile.write("Sum is ")
outfile.write(sum)
infile.close()
outfile.close()

Résultat :

Les chiffres sont :

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Exercice 10 : Traitement des exceptions

Objectif : : comprendre et gérer les différents types d'exceptions qui surviennent au moment de
l'exécution du programme, ainsi que la méthode pour lever une exception.

Traitement des exceptions :

Les exceptions sont des anomalies d'exécution ou des conditions anormales qu'un programme
rencontre au cours de son exécution, telles que la division par zéro (ZeroDivisionError),
l'ouverture en lecture d'un fichier qui n'existe pas (IOError), une indentation incorrecte
(IndentationError), etc. La gestion des exceptions permet à un programme de traiter les
exceptions et de poursuivre son exécution normale.

Une instruction try en Python peut avoir plus d'une clause except pour gérer différentes
exceptions. L'instruction peut également comporter une instruction else et/ou finally facultative.
La syntaxe try-except est la suivante :
 try:

<body>

except <ExceptionType1>:

<handler1>

...

...

except <ExceptionTypeN>:

<handlerN>

except:

<handlerExcept>

else:

<process_else>

finally:

<process_finally>

Les excepts multiples sont similaires aux elifs en python. Lorsqu'une exception se produit, on
vérifie si elle correspond à une exception dans une clause except après la clause try, une par une
(séquentiellement). Si une correspondance est trouvée, le gestionnaire pour le cas correspondant
est exécuté et le reste des clauses except est ignoré. Notez que le <ExceptionType> de la dernière
clause except peut être omis. Si l'exception ne correspond à aucun des types d'exception avant la
dernière clause except, la clause
<handlerExcept> pour la dernière clause except est exécutée.

Une instruction try peut comporter une clause else facultative, qui est exécutée si aucune
exception n'est levée dans le corps de l'instruction try.

Une instruction try peut comporter une clause finally facultative, destinée à définir les actions
de nettoyage qui doivent être exécutées en toutes circonstances.

Codage :

try:
number1, number2 = eval(input("Entrez deux nombres séparés par une virgule : "))
result = number1 / number2
print("Le résultat est", result)
 if(number1==0):
raise RuntimeError()

except ZeroDivisionError:
print("Division par zéro")
except SyntaxError:
print("Une virgule peut manquer dans l'entrée")
except RuntimeError:
print("Peut être sans signification")
except:
print("Quelque chose d'erroné dans l'entrée")
else:
print("No Exceptions")
finally:
print("La clause finale est exécutée")

Résultat :

Entrez deux chiffres séparés par une virgule : 4,0 4,0

Division par zéro
La clause finale est exécutée
>>>
Entrez deux chiffres séparés par une virgule : 5 6 5 6
Une virgule peut manquer dans l'entrée Enfin la clause est exécutée
>>>

Entrez deux chiffres séparés par une virgule : 0,9 0,9

Le résultat est 0.0
Peut être dépourvu de sens Finalement, la clause est exécutée
>>>
Entrez deux chiffres séparés par une virgule : 6 6
Quelque chose d'erroné dans l'entrée La clause finale est exécutée
>>>
Entrez deux chiffres séparés par une virgule : 12,4 12,4
Le résultat est de 3.0 sans exception
La clause finale est exécutée

Exercice 12 : Opérations arithmétiques basées sur un menu popup avec Tkinter

Objectif : mettre en œuvre une calculatrice de prêt en utilisant Tkinter.

Tkinter :

Python offre de multiples options pour développer une interface utilisateur graphique
(GUI). Parmi toutes les méthodes d'interface graphique, Tkinter est la méthode la plus
couramment utilisée. Il s'agit d'une interface Python standard pour la boîte à outils Tk GUI livrée
avec Python. Python avec Tkinter est le moyen le plus rapide et le plus facile de créer des
applications GUI. Créer une interface graphique à l'aide de Tkinter est une tâche facile.

Une application GUI est créée en utilisant Tkinter comme suit :

1. Importez le module Tkinter en utilisant import Tkinter.

2. Créez la fenêtre principale de l'application GUI en utilisant window =Tk( ).

3. Ajoutez un ou plusieurs widgets à l'application GUI.

4. Entrez dans la boucle d'événement principale pour prendre des mesures contre
chaque événement déclenché par l'utilisateur.

Tkinter fournit divers contrôles, tels que des boutons, des étiquettes et des boîtes de texte
utilisés dans une application GUI. Ces contrôles sont communément appelés widgets. Il y a
actuellement 15 types de widgets dans Tkinter.

Calcul du prêt à l'aide de Tkinter :

Dans ce codage, une application GUI est développée pour calculer les paiements de
prêts. Le code se compose des étapes suivantes :
1. Concevez une interface utilisateur composée d'étiquettes à l'aide de Label( ), de boîtes de
saisie de texte à l'aide de Entry( ) et d'un bouton à l'aide de Button( ).
2. Traitez l'événement. Lorsque le bouton est cliqué, le programme invoque une fonction de
rappel, en utilisant getMonthlyPayment( ) pour obtenir la saisie de l'utilisateur pour le taux
d'intérêt, le nombre d'années et le montant du prêt à partir des entrées de texte. Les paiements
mensuels et totaux sont calculés à l'aide de la fonction computePayment( ) et affichés dans les
étiquettes.

Codage :
from tkinter import * # Import all definitions from tkinter
class LoanCalculator:
def __init__(self):
window = Tk() # Create a window
window.title("Loan Calculator") # Set title
Label(window, text = "Annual Interest Rate").grid(row = 1,column = 1, sticky = W)
Label(window, text = "Number of Years").grid(row = 2,column = 1, sticky = W)
Label(window, text = "Loan Amount").grid(row = 3,column = 1, sticky = W)
Label(window, text = "Monthly Payment").grid(row = 4,column = 1, sticky = W)
Label(window, text = "Total Payment").grid(row = 5,column = 1, sticky = W)
self.annualInterestRateVar = StringVar()
Entry(window, textvariable = self.annualInterestRateVar,justify = RIGHT).grid(row = 1,
column = 2)
self.numberOfYearsVar = StringVar()
Entry(window, textvariable = self.numberOfYearsVar,justify = RIGHT).grid(row = 2,
column = 2)
self.loanAmountVar = StringVar()
Entry(window, textvariable = self.loanAmountVar,justify = RIGHT).grid(row = 3, column =
2)
self.monthlyPaymentVar = StringVar()
lblMonthlyPayment = Label(window, textvariable =self.monthlyPaymentVar).grid(row = 4,
column = 2,sticky= E)
self.totalPaymentVar = StringVar()
lblTotalPayment = Label(window, textvariable =self.totalPaymentVar).grid(row = 5,column
= 2, sticky = E)
btComputePayment = Button(window, text = "Compute Payment",command
=self.computePayment).grid(row = 6, column = 2, sticky = E)
window.mainloop() # Create an event loop
def computePayment(self):
monthlyPayment =
self.getMonthlyPayment(float(self.loanAmountVar.get()),float(self.annualInterestRateVar.get()) /
1200,int(self.numberOfYearsVar.get()))
self.monthlyPaymentVar.set(format(monthlyPayment, "10.2f"))
totalPayment = float(self.monthlyPaymentVar.get()) * 12 * int(self.numberOfYearsVar.get())
self.totalPaymentVar.set(format(totalPayment, "10.2f"))
def getMonthlyPayment(self,loanAmount, monthlyInterestRate, numberOfYears):
monthlyPayment = loanAmount * monthlyInterestRate / (1- 1 / (1 + monthlyInterestRate) **
 (numberOfYears* 12))
return monthlyPayment;
LoanCalculator() # Create GUI

Résultat :

Le calculateur de prêt a été mis en œuvre en utilisant Tkinter.

Exercice 13 : Opérations arithmétiques basées sur un menu popup avec Tkinter

Objectif : créer un menu contextuel pour les opérations arithmétiques en utilisant Tkinter.

Menu popup utilisant Tkinter :

menu contextuel ressemble à un menu ordinaire, mais il n'a pas de barre de menu et il peut flotter
n'importe où sur l'écran. La création d'un menu contextuel est similaire à celle d'un menu ordinaire.
Tout d'abord, vous créez une instance de menu contextuel à l'aide de Menu( ), puis vous pouvez y
ajouter des éléments à l'aide de menu.add_command( ). Enfin, vous liez un widget avec un
événement pour faire apparaître le menu. Les commandes du menu contextuel sont utilisées pour
effectuer des actions à afficher dans un canevas créé à l'aide de canvas( ).
Le widget canvas est utilisé pour ajouter des graphiques structurés à l'application python. Il est
utilisé pour afficher du texte, des images, des graphiques et des tracés dans l'application python.
Les éléments de menu utilisent des fonctions de rappel pour demander au canevas d'effectuer des
actions.
Dans ce codage, un menu contextuel est affiché en cliquant sur le bouton droit de la souris, puis en
le liant au canevas à l'aide de canvas.bind( ). Chaque élément du menu contextuel est sélectionné
pour effectuer les opérations arithmétiques correspondantes. Les entrées sont obtenues dans deux
zones de texte et la sortie est affichée dans une zone de texte.
Codage :
from tkinter import * # Importe toutes les définitions de Tkinter

class PopupMenuDemo:

def __init__(self):

window = Tk() # Create a window

window.title("Popup Menu Demo") # Set title

# Create a popup menu

self.menu = Menu(window, tearoff = 0)

self.menu.add_command(label = "Add",command = self.add)

self.menu.add_command(label = "Subtract",command = self.subtract)

self.menu.add_command(label = "Multiply",command = self.multiply)

self.menu.add_command(label = "Divide",command = self.divide)

Label(window, text = "Number 1:").pack(side =

LEFT)

self.v1 = StringVar()

Entry(window, width = 5, textvariable = self.v1,justify = RIGHT).pack(side = LEFT)

Label(window, text = "Number 2:").pack(side =

LEFT)

self.v2 = StringVar()

Entry(window, width = 5, textvariable = self.v2,justify = RIGHT).pack(side = LEFT)

Label(window, text = "Result:").pack(side = LEFT)

self.v3 = StringVar()

Entry(window, width = 5, textvariable = self.v3,justify = RIGHT).pack(side = LEFT)

# Place canvas in window

self.canvas = Canvas(window, width = 200,height = 100, bg = "white")

self.canvas.pack()
 # Bind popup to canvas

self.canvas.bind("<Button-3>", self.popup)

window.mainloop() # Create an event loop

def add(self):

self.v3.set(eval(self.v1.get()) + eval(self.v2.get()))

def subtract(self):

self.v3.set(eval(self.v1.get()) - eval(self.v2.get()))

def multiply(self):

self.v3.set(eval(self.v1.get()) * eval(self.v2.get()))

def divide(self):

self.v3.set(eval(self.v1.get()) / eval(self.v2.get()))

def popup(self, event):

self.menu.post(event.x_root, event.y_root)

PopupMenuDemo() # Create GUI

Résultat :
 Le menu contextuel pour les opérations arithmétiques a été créé en utilisant Tkinter et les résultats sont
vérifiés.

Exercice 14 : Afficher une image et sa transformation en utilisant Tkinter et OpenCV-Python

Objectif : lire et afficher une image couleur RVB et la convertir en niveaux de gris, en négatif
et en images de bord.

Image :

Une image est définie comme une fonction bidimensionnelle, f(x, y), où x et y sont des
coordonnées spatiales, et l'amplitude de F à toute paire de coordonnées (x, y) est appelée
l'intensité de cette image à ce point. Lorsque les valeurs de x, y et l'amplitude de F sont finies, on
parle d'image numérique. En d'autres termes, une image peut être définie par un tableau
bidimensionnel spécifiquement disposé en lignes et en colonnes. L'image numérique est
composée d'un nombre fini d'éléments, dont chacun a une valeur particulière à un endroit
particulier. Ces éléments sont appelés pixels ou éléments d'image.

Les images sont représentées en lignes et en colonnes comme ci-dessous :

où chaque élément de la matrice est appelé pixel ou élément d'image.

Types d'images :

Dans ce codage, le bouton de sélection d'image est utilisé pour sélectionner une image.
La boîte de dialogue du fichier est utilisée pour sélectionner l'image d'entrée souhaitée sur le
disque dur. Après avoir sélectionné une image, quatre types d'opérations sont effectuées en
cliquant sur un bouton pour chaque opération. Le bouton RVB est utilisé pour afficher l'image
couleur RVB, le bouton gris est utilisé pour afficher l'image grise de l'image sélectionnée, le
bouton bord est utilisé pour afficher le bord de l'image sélectionnée, et le bouton négatif est
utilisé pour afficher le négatif de l'image sélectionnée.
 Image RGB :

Une image RVB est une image dans laquelle chaque pixel est spécifié par trois valeurs,
une pour les composantes rouge, bleue et verte de la couleur du pixel. Les images RVB sont
stockées sous la forme d'un tableau de données m-par-n- par-3 qui définit les composantes rouge,
verte et bleue de la couleur de chaque pixel. La couleur de chaque pixel est déterminée par la
combinaison des intensités rouge, verte et bleue stockées dans chaque plan de couleur à
l'emplacement du pixel. Les formats de fichiers graphiques stockent les images RVB sous forme
d'images de 24 bits, où les composantes rouge, verte et bleue sont de 8 bits chacune. Cela donne
un potentiel de 16 millions (2 24) de couleurs. Un pixel dont les composantes de couleur sont (0,
0, 0) est affiché en noir, et un pixel dont les composantes de couleur sont (1, 1, 1), c'est-à-dire
(255, 255, 255), est affiché en blanc.

Image en niveaux de gris :

Les niveaux de gris sont une gamme de nuances monochromatiques allant du noir au
blanc. Par conséquent, une image en niveaux de gris ne contient que des nuances de gris et
aucune couleur. La principale caractéristique des images en niveaux de gris est l'égalité des
niveaux de couleur rouge, vert et bleu. La fonction cv2.cvtColor ( ) de OpenCV-Python est
utilisée pour convertir une image couleur RVB en image en niveaux de gris.

Une image RVB est convertie en images grises à l'aide de la méthode suivante

Y = 0,299R + 0,587G + 0,114B

Image négative :
L'image négative est un type d'image qui peut être formé en soustrayant la valeur RVB de 255. La
fonction cv2.bitwise_not ( ) est utilisée pour convertir l'image couleur RGB en image négative en
couleur.
Une image couleur RVB (c'est-à-dire une image positive) est convertie en une image négative en
utilisant les méthodes suivantes
Rn = 255 – Rp
Gn = 255 - Gp
Bn = 255 – Bp
où p et n sont respectivement positifs et négatifs.
 Image de bord :

La détection des contours comprend une variété de méthodes mathématiques qui visent à
identifier les points d'une image numérique où la luminosité de l'image change brusquement ou
présente des discontinuités. Les points où la luminosité de l'image change brusquement sont
généralement organisés en un ensemble de segments de lignes courbes appelés bords. Les bords
sont souvent associés aux limites des objets dans une image. Dans ce codage, la méthode de
détection des bords de Canny est utilisée pour convertir une image RVB en image de bord en
utilisant cv2.canny ( ).

Codage :
# importer les paquets nécessaires
from tkinter import *
from PIL import Image
from PIL import ImageTk
from tkinter import filedialog
import cv2
from tkinter import filedialog
from tkinter.filedialog import askopenfilename
def start():
global image1,path
global panel
path = filedialog.askopenfilename()
image1 = cv2.imread(path)
image1 = cv2.resize(image1,(200,100))
image1 = cv2.cvtColor(image1, cv2.COLOR_BGR2RGB)
image = Image.fromarray(image1)
image = ImageTk.PhotoImage(image)
if panel is None:
panel = Label(image=image)
panel.image = image
panel.pack(side="left", padx=30, pady=60)
else:
panel.configure(image=image)
panel.image = image
def gray_image():
global panelB
gray = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
gray = Image.fromarray(gray)
gray = ImageTk.PhotoImage(gray)
if panelB is None:
panelB = Label(image=gray)
panelB.image = gray
panelB.pack(side="left", padx=30, pady=60)
else:
panelB.configure(image=gray)
 panelB.image = gray
def edge_image():
global panelB
gray = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
edge = cv2.Canny(gray, 50, 100)
edge = Image.fromarray(edge)
edge = ImageTk.PhotoImage(edge)
if panelB is None:
panelB = Label(image=edge)
panelB.image = edge
panelB.pack(side="left", padx=30, pady=60)
else:
panelB.configure(image=edge)
panelB.image = edge
def negative_image():
global panelB
image = cv2.cvtColor(image1, cv2.COLOR_BGR2RGB)
negative = cv2.bitwise_not(image)
negative = Image.fromarray(negative)
negative = ImageTk.PhotoImage(negative)
if panelB is None:
panelB = Label(image=negative)
panelB.image = negative
panelB.pack(side="left", padx=30, pady=60)
else:
panelB.configure(image=negative)
panelB.image = negative
root = Tk()
root.geometry('600x400')
fm = Frame(root, width=300, height=200)
fm.pack(side=BOTTOM, expand=NO, fill=NONE)
panelB = None
panel = None
btn = Button(root, text="Select an image", command=start,activebackground='red',fg="blue")
btn.pack(side="top")
btn2 = Button(fm, text="GRAY", command=gray_image,activebackground='red',height=2,
width=10,fg="gray")
btn2.pack(side=LEFT, padx="10", pady="20")
btn3 = Button(fm, text="EDGE", command=edge_image,activebackground='red',height=2,
width=10,fg="green")
btn3.pack(side=LEFT, padx="10", pady="20")
btn4 = Button(fm, text="NEGATIVE",
command=negative_image,activebackground='red',height=2, width=10,fg="purple")
btn4.pack(side=LEFT, padx="10", pady="20")
root.mainloop()
Résultat :
L'image couleur RVB donnée est convertie en niveaux de gris, en négatif et en images de bord en
utilisant Tkinter.

***

28