partie-2-cours-python

July 8, 2021

Université Alioune Diop de Bambey

Cours de Programmation avancée : Python + POO
Enseignant : Dr. Mamadou Salif DIALLO
Email : [Link]@[Link]
Partie II : Conditions, Boucles et Exceptions
1. Conditions
2. Boucles
3. Compréhension de listes, d’ensembles, et de dictionnaires
4. Excéptions

0.1 1. Opérateurs

0.1.1 Comparaison

< (inférieur) ; <= (inférieur ou égal) ; > (supérieur) ; >= (supérieur ou égal) ; == (égalité) ; !=
(différent), is (est) et not is (n’est pas).

0.1.2 Logique

in (appartient) ; not (negation) ; not in (n’appartient pas) ; and (et) ; or (ou)

True and True # True
True and False # False
False and False # False
True or False # True
not False # True
not(True or False) # False
not(True or True) # False
not True or True # True
[ ]: 2 < 5

[ ]: 4 == 8-4

[ ]: 0 == 0.0

1
[ ]: 6 != 6.0001

[ ]: (2 < 5) and 9 in (6, 8.1, 9)

[ ]: x = 10

9 <= x < 10.5

1 2. La condition if ...., elif ...., else .....

1.1 Cas 1

if condition:
<Instructions>

1.2 Cas 2

if condition:
<Instructions>
else:
<Instructions>

if condition 1:
<Instructions>
elif condition 2:
<Instructions>
elif condition 3:
<Instructions>
# .
# .
elif condition n:
<Instructions>

1.3 Cas Général

if condition 1:
<Instructions>
elif condition 2:

2
 <Instructions>
elif condition 3:
<Instructions>
# .
# .
else:
<Instructions>

Il peut y avoir un nombre quelconque de parties elif et la partie else est facultative, seul la partie
if est obligatoire. Le mot clé elif est un raccourci pour else if.
[27]: email = input("Saisire une adresse email GMAIL valide")
if (not [Link]("@[Link]")) or ([Link]("@") > 1):
print("Adresse GMAIL non valide")
elif len(email) < 13:
print("Adresse email trop courte")
elif len(email) > 30:
print("Adresse email trop longue")
else:
print("Adresse email semble être normale")

Saisire une adresse email GMAIL valideserignediopmassfayedeme2548_1@[Link]

Adresse email trop longue

2 Exo 1

Ecrire un code en python qui permet de distinguer un entier pair et un entier impair
[2]: # Votre code ici
n = int(input("Donner un entier n"))
if n % 2 == 0:
print("Pair")
else:
print("Impair")

Donner un entier n9
Impair
Remarque : La fonction eval
[6]: n = eval(input("Saisir qqchse"))
print(type(n))

3
 Saisir qqchse"lui"
<class 'str'>

[4]: a = 8
eval("a")

[4]: 8

3 Exercice

Ecrire un code en python qui permet de distinguer un entier pair et un entier impair
On s’assurera que l’utilisteur a bien saisi un entier
[8]: n = 7
if type(n)== int:
pass

Remarque : tester le type d’une variable : la fonction isinstance

[9]: n = 8.7
isinstance(n, int)

[9]: False

[10]: isinstance(n, (int, float))

[10]: True

4 Exo2

1. Demander à l’utilisteur son age

2. • Si 0 ≤ age ≤ 18, afficher Mineur
• Si 18 < age ≤ 60, afficher Adulte
• Si $ age > 60$, afficher Vieux
• Sinon, afficher “Erreur”
[ ]: # Votre code ici

5 Exo 3 : Calcul de mediane d’une serie statistique

Ecrire un programme qui permet de calculer la médiane d’une série statistique donnée sous
forme d’une liste ou tuple.

4
 On rappele que la médiane Me d’une série statistique de taille N est le nombre qui sépare la série
ordonnée en deux groupes de même effectif.
N +1
• Si N est impair, elle correspond à la -ième valeur de la série ordonnée.
2
N N
• Si N est pair, elle correspond à la moyenne de la -ième de la + 1-ième valeur de la série
2 2
ordonnée.
Remarque : On s’assurera que l’utilisateur a bien saisie une liste ou tuple avant de calculer la
médiane..
[ ]: # Votre code ici

[15]: L = [1,55,3, 8]

[12]: L[int(4/2)]

[12]: 3

[13]: val = [1,2,3]

if (type(val) != list) or (type(val) != tuple):
print("OOO")

OOO

[14]: list((4, 3, 1))

[14]: [4, 3, 1]

Remarque : Opérateur := (nouveau python >=3.8)

[28]: v = [1,2,3,4]
if (n:=len(v)) == 4:
print(3*n)

12

[29]: v = [1,2,3,4]
n=len(v)
if n == 4:
print(3*n)

12

5.1 La fonction range

• range(m) → 0, 1, 2, ..., m − 1

5
[19]: range(10) # 0, 1, 2, ..., 8, 9

[19]: range(0, 10)

[18]: list(range(10))

[18]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

• range(m, n) → m, m + 1, m + 2, ..., n − 1

[20]: list(range(0, 10)) # = list(range(10))

[20]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

• range(m, n, k) → m, m + k, m + 2k, m + 3k, ..., n − 1

[21]: list(range(4, 20, 2))

[21]: [4, 6, 8, 10, 12, 14, 16, 18]

[22]: type(range(4, 10, 1))

[22]: range

6 3. La boucle for

L’instruction for que propose Python est un peu différente de celle que l’on peut trouver en C. Au
lieu de donner à l’utilisateur la possibilité de définir le pas d’itération et la condition de fin (comme
en C), l’instruction for en Python itère sur les éléments d’une séquence (qui peut être
de type list, str, tuple, range, etc), dans l’ordre dans lequel ils apparaissent dans la
séquence. Par exemple :
[23]: for i in range(0, 10):
print(i)

0
1
2
3
4
5
6
7
8
9

6
[25]: fruits = ["Pomme", "Orange", "Mangue", "Bannane", "Pastec", "Citron"]

[26]: for fr in fruits:

print(fr)

Pomme
Orange
Mangue
Bannane
Pastec
Citron

[27]: chaine = "Equipe ESE"

for caracter in chaine:
print(caracter, 5*caracter)
# noter que 5*caracter = caracter + caracter + caracter + caracter + caracter

E EEEEE
q qqqqq
u uuuuu
i iiiii
p ppppp
e eeeee

E EEEEE
S SSSSS
E EEEEE

[ ]: liste = eval(input("Donner une liste d'entiers : "))

liste_carre = []
for elt in liste:
liste_carre.append(elt ** 2)

print(liste_carre)

7 Exercice 4

1. Demander à l’utilisateur une liste de valeur.

2. Déterminer et afficher la moyenne
[ ]: # Votre code ici

7
 8 Les instructions break, continue et les clauses else au sein des
boucles

• L’instruction break, comme en C, interrompt la boucle for ou while la plus profonde.

• L’instruction continue, également empruntée au C, fait passer la boucle à son itération suiv-
ante :
• Les boucles peuvent également disposer d’une instruction else ; celle-ci est exécutée
lorsqu’une boucle se termine alors que tous ses éléments ont été traités (dans le cas d’un
for) ou que la condition devient fausse (dans le cas d’un while), mais pas lorsque la boucle
est interrompue par une instruction break.

8.1 Exemple

Supposons qu’on cherche le premier entier n positif entre 0 et 20 tel que −9n2 + n3 − 8n > 100
[1]: # Utilisation de break
for n in range(21):
if -9*n**2 + n**3 - 8*n > 100:
print(f"n = {n}")
break

n = 11
Supposons qu’on cherche qu’on cherche à déterminer s’il existe un n avec 0 ≤ n ≤ 100 tel que
n3 + 2n − 1 = 20.
[ ]: # Utilisation de else donc une boucle for
for n in range(101):
if n **3 +2*n -1 == 20:
print(f"n = {n}")
break
else:
print("Aucune valeur trouvée")

Exercice :
1. Demander à l’utilisateur un entier naturel N>1.
2. Dire si N est un nombre premier ou non
On rappelle qu’on nombre N > 1 est premier s’il n’admet que deux diviseurs 1 et lui-même.
[5]: # Votre code ici
n = int(input("Donner un entier"))
if n > 1:
for i in range(2, n):
if n % i == 0:
print("Non premier")

8
 break
else:
print("Premier")

Donner un entier74
Non premier

9 L’instruction pass

L’instruction pass ne fait rien. Elle peut être utilisée lorsqu’une instruction est nécessaire pour
fournir une syntaxe correcte, mais qu’aucune action ne doit être effectuée
[7]: for i in range(n):
pass

[10]: N = (13**3)/5
if N > 400:
print("YES")
else:
pass

YES

10 4. Listes, tuples et dictionnaires en compréhension

Une compréhension de liste consiste à placer entre crochets une expression suivie par une clause
for puis par zéro ou plus clauses for ou if. Le résultat est une nouvelle liste résultat de l’évaluation
de l’expression dans le contexte des clauses for et if qui la suivent i.e
[expresion boucle 1 ... boucle k condition 1 .... condition n]

{f (x)|x ∈ Ensemble et x verifie une condition}

[11]: L = []
for x in range(10):
[Link](x**2)
print(L)

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

9
 10.0.1 Ce code est équivalent au code suivant

[12]: [x**2 for x in range(10)]

[12]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

[ ]:

Bonjour

10.0.2 L’ensemble des couples (i,j) avec 0 ≤ i, j ≤ 9 et 2i < j

[13]: [(i,j) for i in range(10) for j in range(10) if 2*i < j]

[13]: [(0, 1),

(0, 2),
(0, 3),
(0, 4),
(0, 5),
(0, 6),
(0, 7),
(0, 8),
(0, 9),
(1, 3),
(1, 4),
(1, 5),
(1, 6),
(1, 7),
(1, 8),
(1, 9),
(2, 5),
(2, 6),
(2, 7),
(2, 8),
(2, 9),
(3, 7),
(3, 8),
(3, 9),
(4, 9)]

[14]: "@".join([str(i) for i in range(1, 51)])

[14]: '1@2@3@4@5@6@7@8@9@10@11@12@13@14@15@16@17@18@19@20@21@22@23@24@25@26@27@28@29@3
0@31@32@33@34@35@36@37@38@39@40@41@42@43@44@45@46@47@48@49@50'

Exercice : Déterminer la liste de l’ensemble des carrés des entiers naturels plus petit que 10

10
[ ]: # Votre code ici

10.0.3 Exercice :

Déterminer l’ensemble des carrés des entiers naturels i plus petit que 10 et congrus à 1 modulo 3.
[ ]: # Votre code ici

10.0.4 Avec les dictionnaires ?

[24]: dico = {i: i**2 for i in range(10)}

print(dico)

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

[30]: dico2 = {i: i**2 for i in range(10) if i%3 == 1}

print(dico2)

{1: 1, 4: 16, 7: 49}

[31]: dico1 = {i: i**2 for i in range(10)}

dico1

[31]: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

[32]: [Link]()

[32]: dict_items([(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49),
(8, 64), (9, 81)])

Exercice: 1. Lire un dictionnaire appelé dico3 de la forme

{key1:value1, key2: value2, …, keyn: value} 2. Afficher le dictionnaire inverse :
{value1:key1, ..., valuen: keyn}
[33]: L = [(1,3), (4,5), (9, 4)]

for (i, j) in L:
print(f"i={i} et j={j}")

i=1 et j=3
i=4 et j=5
i=9 et j=4

[ ]: dico3 = eval(input("Donner un dictionnaire"))

{value: key for key, value in [Link]()}

11
 11 5-Excéptions

11.0.1 Quelques exceptions

• StopIteration
• ZeroDivisionError
• AssertionError
• ImportError
• ModuleNotFoundError
• IndexError
• KeyError
• NameError
• UnboundLocalError
• SyntaxError
• IndentationError
• TabError
• TypeError
• ValueError
• ….
[15]: # ept n'est pas défini
lpn + 1

␣
,→ ---------------------------------------------------------------------------

NameError Traceback (most recent call last)

<ipython-input-15-1816ddd0c06d> in <module>
1 # ept n'est pas défini
----> 2 lpn + 1

NameError: name 'lpn' is not defined

[16]: dic = {}

[17]: # "ept" n'est pas une clé de `dic`

dic["lpn"]

␣
,→ ---------------------------------------------------------------------------

KeyError Traceback (most recent call last)

12
 <ipython-input-17-3ebe947042a7> in <module>
1 # "ept" n'est pas une clé de `dic`
----> 2 dic["lpn"]

KeyError: 'lpn'

11.0.2 Gestion des excéptions :

11.1 Méthode 1:

try:
<instructions>
except <type-d'exception>:
<instructions>

[18]: 3/0

␣
,→---------------------------------------------------------------------------

ZeroDivisionError Traceback (most recent call last)

<ipython-input-18-f6cc6d14333b> in <module>
----> 1 3/0

ZeroDivisionError: division by zero

[23]: a = int(input("Donner un entier a : "))

b = int(input("Donner un autre entier b : "))

try:
b = a/b
print(f"a/b = {a/b}")
except ZeroDivisionError:
print("On ne peut pas diviser par Zero")

Donner un entier a : 10
Donner un autre entier b : 2
a/b = 2.0
Remarque : affectation d’une exception à une variable

13
[20]: a = int(input("Donner un entier a : "))
b = int(input("Donner un autre entier b : "))

try:
b = a/b
print(f"a/b = {a/b}")
except Exception as e:
print("La nature de l'exception")
print(e)
print(f"Type de l'exception {type(e)}")
if type(e) == ZeroDivisionError:
print("Attenion : Division par Zero")

Donner un entier a : 8
Donner un autre entier b : 5
a/b = 5.0

11.2 Méthode 2: Plus générale

try:
<instructions>
except <type-1-d'exception>:
<instructions>
except <type-2-d'exception>:
<instructions>
.
.
.
except <type-n-d'exception>:
<instructions>

Remarque: Comment gerer le fait que l’utilsateur pourrait ne pas saisir une valeur qu’on ne
pourrait pas convertir en un entier.
[ ]: try:
a = int(input("Donner un entier a : "))
b = int(input("Donner un autre entier b : "))
b = a/b
print(f"a/b = {a/b}")
except ZeroDivisionError:
print("On ne peut pas diviser par Zero")

Remarque : Une même clause except peut citer plusieurs exceptions sous la forme d’un tuple.
[ ]: try:
a = int(input("Donner un entier a : "))

14
 b = int(input("Donner un autre entier b : "))
b = a/b
print(f"a/b = {a/b}")
except (ZeroDivisionError, ValueError):
print("OOOH")

11.3 Méthode 2: Plus générale

try:
<instructions>
except <type-1-d'exception>:
<instructions>
except <type-2-d'exception>:
<instructions>
.
.
.
except <type-n-d'exception>:
<instructions>
else:
<instructions>
finally:
<instructions>

[ ]: try :
8/"8"
except ZeroDivisionError:
print("A")
finally:
print("DIC1")

[ ]: try :
8/0
except:
pass

11.4 Lever une exception

Syntaxe :

raise Exception("Message")

[ ]: email = input("Donner votre email ")

if "@" not in email:

15
 raise ValueError("Il faut saisir un email valide.")
print(f"Votre email est {email = }") # valide python >= 3.8

16