Chapitre 2 Bases Langage Python

Chapitre 2 : Bases du langage Python
Responsable : Dr Ousmane KHOUMA

Licence 1/Université Amadou Mahtar MBOW
1 Introduction
L’exécution de la plupart des programmes est liée à des conditions. Ces conditions permettent
d’exécuter une ou plusieurs instructions dans un cas, d’autres instructions dans un autre cas.
Par conséquent, Python dispose des instructions de contrôle (conditions) de flux classiques que
l’on trouve dans d’autres langages de programmation, mais toujours avec ses propres tournures.
Pour les boucles, elles vont nous permettre de répéter une certaine opération autant de fois que
nécessaire.
En programmation, la résolution de problèmes complexes demande l’utilisation d’un nombre im-
portant d’instructions. Dans ce cas, on est toujours amené à utiliser plusieurs fois des groupes
d’instructions dans un but très précis. De ce fait, les fonctions permettent de regrouper plusieurs
instructions dans un bloc qui sera appelé grâce à un nom. Quant aux modules, ils permettent de
regrouper plusieurs fonctions selon le même principe.
2 Les structures conditionelles

Les structures conditionelles peuvent être ramenées à la vraie vie. Vous faites certaines choses ou
vous ne le faites pas lorsqu’une condition spécifique est remplie ou non, par exemple, vous allez vous
promener s’il fait beau ou rester à la maison s’il fait humide et froid.
Pour prendre de telles décisions, Python propose une instruction spéciale. En raison de sa nature
et de son application, on l’appelle une instruction conditionnelle (ou structure conditionelle).
Il en existe plusieurs variantes. Nous allons commencer par le plus simple, en augmentant lente-
ment la difficulté.
2.1 L’instruction conditionelle if

Les conditions sont un concept essentiel en programmation. Elles vont vous permettre de faire
une action précise si, par exemple, une variable est positive, une autre action si cette variable est
négative, ou une troisième action si la variable est nulle.
La syntaxe est la suivante :
if (condition):
« Séquence d'actions »
1
Licence 1 Université Amadou Mahtar MBOW
L’utilisation de l’instruction if se compose des éléments suivants, strictement nécessaires et dans

cet ordre uniquement :
• Le mot - clé if ;
• un ou plusieurs espaces blancs ;
• une expression (condition) dont la valeur sera interprétée comme vraie (lorsque sa valeur
est non nulle) et fausse (lorsqu’elle est égale à zéro);
• un deux-points (:) suivi d’une nouvelle ligne ;
• une instruction (séquence d’actions) en retrait ou un ensemble d’instructions (au moins une
instruction est absolument nécessaire).
Remarque : Python identifie les instructions formant un bloc grâce à l’indentation.
On entend par indentation un certain décalage vers la droite, obtenu par un (ou plusieurs) espaces
ou tabulations.
L’indentation peut être réalisée de deux manières : en insérant un nombre particulier d’espaces
(la recommandation est d’utiliser quatre(4) espaces d’indentation), ou en utilisant le caractère de
tabulation.
Les indentations sont essentielles pour Python. Il ne s’agit pas, comme dans d’autres langages,
d’un confort de lecture mais bien d’un moyen pour l’interpréteur de savoir où se trouvent le
début et la fin d’un bloc.
Exemple 1 : On veut afficher la valeur d’une variable si elle est positive.
[1]: a = int(input("Entrez un nombre positif : "))

if a > 0 :
print(a,"est supérieur à 0")
Entrez un nombre positif : 20

20 est supérieur à 0
Le bloc d’instruction de l’exemple précédent est constitué d’une seule ligne. Néanmoins, plusieur
lignes pourraient être utilisées.
Exemple 2 :
[2]: a = int(input("Entrez un nombre positif : "))

b = int(input("Entrez un nombre positif : "))
if a > 0 :
# on ajoute 20 à la variable b
b +=20
# On affiche les variables
print("a =",a,"et b =",b)

a = 15 et b = 50
Dr Ousmane KHOUMA 2 Année Académique 2019 - 2020

NB : Pour rendre les programmes beaucoup plus explicites, il est conseillé d’insérer des commen-
taires. Les commentaires sont des messages qui sont ignorés par l’interpréteur et qui permettent
de donner des indications sur le code. En Python, un commentaire débute par un dièse (« # ») et
se termine par un saut de ligne. Tout ce qui est compris entre ce # et ce saut de ligne est ignoré.
2.2 L’instruction conditionelle if - else

L’intruction if peut être pour tester plusieurs conditions.
Exemple 3 : Écrire un programme Python qui demande le prénom, le nom et l’âge d’une personne
puis affiche « mineur » si la personne est âgée de moins de 18 ans et « majeur » dans le cas contraire.
[3]: prenom = input("Veuillez entrer votre prénom : ")

nom = input("Veuillez entrer votre nom : ")
age = int(input("Veuillez entrer votre âge : "))
print("vous êtes", prenom, nom)
if age < 18 :
print("Vous êtes mineur")
if age >= 18 :
print("Vous êtes majeur")
Veuillez entrer votre prénom : Modou

Veuillez entrer votre nom : NDIAYE
Veuillez entrer votre âge : 14
vous êtes Modou NDIAYE
Vous ête mineur
La condition if est donc bien pratique mais insuffisante.
Le mot-clé else, qui signifie « sinon » en anglais, permet de définir une première forme de complé-
ment à notre instruction if.
On parle alors de structure conditionelle composée. Si le test n’a pas marché (il est faux), on va
dire à l’ordinateur d’exécuter d’autres instructions.
if (condition):
« séquence d’actions 1 »
else:
« séquence d’actions 2 »
On reprend l’exemple 3 en utilisant la structure condition if-else.
Exemple 4 :
[4]: prenom = input("Veuillez entrer votre prénom : ")

nom = input("Veuillez entrer votre nom : ")
age = int(input("Veuillez entrer votre âge : "))
print("vous êtes", prenom, nom)
if age < 18 :
print("Vous êtes mineur")

else:
print("Vous êtes majeur")
Veuillez entrer votre prénom : Fatou

Veuillez entrer votre nom : DIOP
Veuillez entrer votre âge : 20
vous êtes Fatou DIOP
Vous êtes majeur
2.3 L’instruction conditionelle elif

Le mot-clé elif est une contraction de « else if », que l’on peut traduire très littéralement par «
sinon si ». Il permet de faire un autre test si le premier test n’a pas marché.
Prenons par exemple l’eau qui peut être dans trois états différents :
• Glace, si la température est inférieure ou égale à 0 °C (température <= 0) ;
• Liquide, si la température est supérieure à 0 °C et inférieure à 100 °C (0 < température < 100)
(Nous avons ici un sinon si) ;
• Vapeur, si la température est supérieure ou égale à 100 °C (température > = 100) (C’est un
sinon).
Ces conditions traduites en Python, cela donne :
[5]: temp = float(input("Entrez la température de l'eau : "))

if temp <= 0: # température inférieure ou égale à 0
print("C’est de la glace.")
elif temp < 100: # température comprise entre 0 et 100
print("C’est du liquide.")
else:
print("C'est de la vapeur.")
Entrez la température de l'eau : -35

C’est de la glace.
De même que le else, le elif est sur le même niveau d’indentation que le if initial. Il se termine
aussi par deux points (:). Cependant, entre le elif et les deux points (:) se trouve une nouvelle
condition.
Sachez qu’il est heureusement possible d’imbriquer des conditions et, dans ce cas, l’indentation
permet de comprendre clairement le schéma d’exécution du programme.
2.4 Les opérateurs de comparaison

Les opérateurs de comparaison (ou les opérateurs dits relationnels) sont utilisés dans des « condi-
tions » pour comparer les valeurs.
Le tableau suivant présente les opérateurs de comparaison.

Opérateur Description
== Égal à
!= Différent de
> Strictement supérieur à
< Strictement inférieur à
>= Supérieur ou égal à
<= Inférieur ou égal à
NB : L’égalité de deux valeurs est comparée avec l’opérateur « == » et non « = ». Ce dernier est en
effet l’opérateur d’affectation et ne doit pas être utilisé dans une condition.
3 Les opérateurs logiques

Avez-vous remarqué que les conditions que nous avons utilisées jusqu’à présent étaient très sim-
ples, pour ne pas dire assez primitives ? Les conditions que nous utilisons dans la vie réelle sont
beaucoup plus complexes. Regardons cette phrase :
« Si nous avons du temps libre, et qu’il fait beau, nous irons nous promener. »
Nous avons utilisé la conjonction et (and), ce qui signifie que faire une promenade dépend de la
réalisation simultanée de ces deux conditions. Dans le langage de la logique, une telle connexion
de conditions s’appelle une conjonction (operateur logique and).
Et maintenant un autre exemple :
« Si vous êtes dans le centre commercial ou si je suis dans le centre commercial, l’un de nous achètera un
cadeau pour maman. »
L’apparence du mot ou (or) signifie que l’achat dépend d’au moins une de ces conditions. En
logique, un tel composé est appelé une disjonction (operateur logique or).
De plus, il existe un autre opérateur qui peut être appliqué pour créer des conditions. C’est un
opérateur unaire effectuant une négation logique (operateur logique not). Son fonctionnement
est simple : il transforme la vérité en mensonge et le mensonge en vérité.
Cependant, il existe quatre opérateurs qui vous permettent de manipuler des bits de données
uniques. Ils sont appelés opérateurs au niveau du bit.
Il existe aussi un opérateur supplémentaire, il s’agit de l’opérateur xor (ou exclusif).
Voici tous les opérateurs :
• and ( & ) : conjonction ;
• or ( | ) : disjonction ;
• not ( ~ : caractère tilde) : négation ;
• xor ( ˆ ) : ou exclusif.
Prenons un exemple qui va nous permettre de vérifier si un varaible quelconque, de type entier,
appartient à un intervalle ou pas.

• Avec les méthode if - else d’abord.

[6]: # On fait un test pour savoir si une variable b est comprise
# dans l'intervalle [3 15].
b = int(input("Entrez un entier : "))
if b >= 3:
if b <= 15:
print(b, "est dans l'intervalle [3 15].")
else:
print(b,"n'est pas dans l'intervalle [3 15].")
else:
Entrez un entier : 2
2 n'est pas dans l'intervalle [3 15].
Cela marche mais c’est assez lourd, d’autant que, pour être sûr qu’un message soit affiché à chaque
fois, il faut fermer chacune des deux conditions (if) à l’aide d’un else.
Cependant, les opérateurs logiques peuvent nous rendre un fier service. Pour cet exemple,
l’opérateur and peut être utilisé afin de réduire les conditions imbriquées. Nous avons alors :

if b >= 3 and b <= 15:
else:
Dans le même registre, on peut utiliser l’opérateur logique or pour faire le même test.

if b < 3 or b > 15:
else:
Exercice d’application :
Écrire un programme qui détermine si une année, saisie par un utilisateur, est bissextile ou non.
Une année bissextile est une année de 366 jours (au lieu de 365) dont le mois de février comporte

29 jours (au lieu de 28), qui revient tous les 4 ans. Depuis l’ajustement du calendrier grégorien,
l’année n’est bissextile que dans l’un des deux cas suivants :
• Si l’année est divisible par 4 et non divisible par 100 ;
• Si l’année est divisible par 400.
Le code Python est le suivant :
[9]: # Programme testant si une année, saisie par l'utilisateur, est bissextile ou non
annee = int(input("Entrez une année : ")) # On attend que l'utilisateur saisisse

# l'année qu'il désire tester
if annee % 400 == 0 or (annee % 4 == 0 and annee % 100 != 0):
print("L'année",annee, "est bissextile.")
else:
print("L'année",annee, "n'est pas bissextile.")
Entrez une année : 2020

L'année 2020 est bissextile.
NB : Les mot-clés if et elif doivent être suivis d’un test (appelé prédicat ou condition).
4 Les boucles while et for

Les boucles constituent un moyen de répéter un certain nombre de fois des instructions d’un
programme informatique.
4.1 La boucle while

La boucle while (Tant que en français) permet de répéter un bloc d’instructions tant qu’une con-
dition est vraie.
En Python, une boucle while peut être représentée comme suit :
while condition:
instruction
Remarque : toutes les règles concernant l’indentation sont également applicables ici. Nous avons
alors :
while condition:
instruction_1
instruction_2
instruction_3
:
.
instruction_n
Attention!

Vous pouvez tomber sur une boucle infinie, s’il n’y a pas d’instructions qui peuvent rendre la
condition fausse (False). De ce fait, une boucle infinie, également appelée boucle sans fin, est une
séquence d’instructions dans un programme qui se répète indéfiniment (boucle sans fin).
Voici un exemple de boucle qui ne parvient pas à terminer son exécution :
while True:
print("Je suis coincé dans une boucle")
Si vous voulez obtenir la meilleure expérience d’apprentissage en voyant comment se comporte
une boucle infinie, lancez IDLE (ou éditeur Python). Tapez ces deux lignes de code en respectant
l’indentation.
Ce que vous verrez est la séquence interminable de « Je suis coincé dans une boucle ». Pour quitter
le programme, appuyez simplement sur Ctrl+C.
Écrire un programme qui demande à l’utilisateur de saisir une valeur entière positive. Le pro-
gramme affiche tous les nombres pairs compris entre 1 et la valeur saisie.
[10]: a = int(input("Entrez une valeur entière positive : "))

while a <= 0: # on fait ici un contrôle de saisie
a = int(input("Entrez une valeur entière positive : "))
i=2
while i <= a: # Cette partie permet d'afficher les nombres pairs
# compris entre 1 et la valeur saisie.
print(i,"est pair")
i +=2 # Pour chaque exécution, le programme ajoute 2 à la valeur de i (i=i+1)
Entrez une valeur entière positive : 0

Entrez une valeur entière positive : -10
Entrez une valeur entière positive : 7
2 est pair
4 est pair
6 est pair
Regardons un autre exemple utilisant la boucle while. Suivez les commentaires pour découvrir
l’idée et la solution.
[11]: # Un programme qui lit une séquence de nombres
# et compte combien de nombres sont pairs et combien sont impairs.
# Le programme se termine lorsque zéro est entré.
cpt_impair = 0 # cpt_impair est le compteur des nombres impairs
cpt_pair = 0 # cpt_pair est le compteur des nombres pairs
# Lecture du premier nombre
nombre = int(input("Entrez un nombre ou tapez 0 pour arrêter : "))
# 0 met fin à l'exécution
while nombre != 0:
# On vérifie si le nombre est impair

if nombre % 2 == 1:
# On augmente le compteur cpt_impair
cpt_impair += 1
else:
# On augmente le compteur cpt_pair
cpt_pair += 1
# Lecture du nombre suivant
nombre = int(input("Entrez un nombre ou tapez 0 pour arrêter : "))
# Affichage des résultats
print("Les nombres impairs comptent :", cpt_impair)
print("Les nombres pairs comptent : ", cpt_pair)
Entrez un nombre ou tapez 0 pour arrêter : 7

Les nombres impairs comptent : 2
Les nombres pairs comptent : 4
NB : En Python, il faut utiliser la boucle « while » pour les cas où on vous demande de contrôler
une saisie.
4.2 La boucle for

Un autre type de boucle disponible en Python vient du constat, qu’il est parfois plus important de
compter les « tours » de la boucle que de vérifier les conditions. Il s’agit de la boucle for.
En fait, la boucle for est conçue pour effectuer des tâches plus compliquées. Elle peut « parcourir
» de grandes collections de données élément par élément.
Il existe plusieurs syntaxes de la boucle for.
1. Première syntaxe
for i in range(n):
« Traitement »
• Le mot clé in introduit un élément de syntaxe décrivant la plage de valeurs possibles affec-
tées à la variable de contrôle (la variable i) ;
• La fonction range() (c’est une fonction très spéciale) est chargée de générer toutes les valeurs
souhaitées de la variable de contrôle ;
• Dans ce cas, la fonction range() commence son travail à partir de 0 (valeur initiale par défaut)
et le termine une étape (un nombre entier) avant la valeur de son argument (c’est-à-dire à n
- 1) ;
Regardons le code Python suivant :

[12]: for i in range(3):

print("La valeur de i est actuellement :",i)
La valeur de i est actuellement : 0

2. Deuxième syntaxe
L’appel de la fonction range() peut être équipé de deux arguments, et non d’un seul :
for i in range(k,n):
« Traitement »
• Dans ce cas, le premier argument détermine la valeur initiale (la valeur k) de la variable de
contrôle ;
• Le dernier argument indique la valeur à laquelle la variable de contrôle ne sera pas affectée
(La valeur limite est n - 1).
[13]: for i in range(2,6):
print("La valeur de i est actuellement :",i)

NB : La fonction range() n’accepte que des entiers comme arguments et génère des séquences
d’entiers.
Écrire un programme qui demande un nombre de départ, et qui ensuite affiche la table de multi-
plication de ce nombre.
[14]: n = int(input("Entrez un nombre positif : "))

print("La table de multiplication de",n,"est : ")
for i in range(1,11):
print(n, " x ", i, " = ", n*i)

La table de multiplication de 5 est :
5 x 1 = 5
5 x 2 = 10
5 x 3 = 15
5 x 4 = 20
5 x 5 = 25
5 x 6 = 30
5 x 7 = 35
5 x 8 = 40

5 x 9 = 45
5 x 10 = 50
3. Troisième syntaxe
for element in sequence:
« Traitement »
Cette syntaxe est très utilisée quand on veut parcourir une chaine de caractères et d’y faire des
traitements.
On souhaite par exemple rechercher et afficher toutes les voyelles d’une chaine de caractères.
[15]: chaine = "Merci mon ami"

for lettre in chaine: # On parcourt la chaine élément par élément
if lettre in "AEIOUYaeiouy": # lettre est une voyelle
print(lettre)
else: # lettre est une consonne... ou plus exactement, lettre n'est pas une␣
,→voyelle
print("*")
*
e
*
*
i
*
*
o
*
*
a
*
i
4.3 Les mots - clés break et continue

Python fournit deux instructions spéciales, qui sont :
• L’instruction (mot - clé) Break, qui veut dire, « quitte la boucle immédiatement et met fin
sans condition à l’opération de la boucle ; le programme commence à exécuter l’instruction
la plus proche après le corps de la boucle » ;
[16]: print("L'instruction break :")

for i in range(1, 8):
if i == 4:
break
print("À l'intérieur de la boucle.", i)
print("En dehors de la boucle.")

L'instruction break :
À l'intérieur de la boucle. 1
En dehors de la boucle.
• L’instruction (mot - clé) continue permet de continuer une boucle, en repartant directement
à la ligne du while ou for. Elle se comporte comme si le programme avait soudainement
atteint le bout du corps ; le tour suivant est démarré et l’expression de condition est testée
immédiatement.
[17]: i = 1
while i < 20: # Tant que i est inférieure à 20
if i % 3 == 0:
i += 4 # On ajoute 4 à i
print("On incrémente i de 4. i est maintenant égale à", i)
continue # On retourne au while sans exécuter les autres lignes
print("La variable i =", i)
i += 1 # Dans le cas classique on ajoute juste 1 à i
La variable i = 1
La variable i = 2
On incrémente i de 4. i est maintenant égale à 7
La variable i = 7
La variable i = 8
La variable i = 13
La variable i = 14
La variable i = 19
5 La programmation modulaire
Vous avez rencontré des fonctions à plusieurs reprises jusqu’à présent. Vous n’avez appelé les
fonctions qu’en les utilisant comme des outils pour vous faciliter la vie et simplifier les tâches
fastidieuses. D’ailleurs, vous avez déjà vu des fonctions : print(), input(), int() et float() en font
partie par exemple.
Vous allez maintenant apprendre à écrire vos propres fonctions et à les utiliser. Nous allons écrire
plusieurs fonctions ensemble, de la plus simple à la plus complexe, ce qui nécessitera votre con-
centration et votre attention. C’est le premier pas que vous ferez vers la modularité.
5.1 Création de fonctions

Il existe plusieurs méthodes de création de fonctions.
5.1.1 Création de fonctions sans paramètres (arguments)

On crée une fonction selon la sintaxe suivante :

def Nom_de_la_fonction():
« corps de la fonction »
Pour la ligne de la définition de la fonction, nous avons :
• Il commence toujours par le mot-clé def, qui est l’abréviation de « define » (définir, en
anglais) ;
• Le nom de la fonction, qui se nomme exactement comme une variable. N’utilisez pas un
nom de variable déjà instanciée pour nommer une fonction ;
• Après le nom de la fonction, il y a une place pour une paire de parenthèses (elles ne contien-
nent rien ici, mais cela changera bientôt) ;
• Les deux points, encore et toujours, qui clôturent la ligne.
La ligne juste après def commence le corps de la fonction. Un couple (au moins un) d’instructions
nécessairement imbriquées, qui seront exécutées à chaque fois que la fonction est appelée. On
note que la fonction se termine là où se termine l’imbrication, il faut donc faire attention.
Déterminons par exemple une fonction qui permet d’afficher la table de multiplication d’un entier
demandé en entrée. On peut même utiliser la boucle while à la place de for.
[18]: def table_multiplication():

n = int(input("Entrez un nombre positif : "))
i = 1
while i <= 10: # Tant que i est strictement inférieure ou égale à 10,
print(n, " x ", i, " = ", n*i)
i +=1 # On incrémente i de 1 à chaque tour de boucle.
Quand vous exécutez ce code à l’écran, il ne se passe rien. Vous devez faire appel à la fonction
pour avoir un résultat.
[19]: table_multiplication()

3 x 1 = 3
3 x 2 = 6
3 x 3 = 9
3 x 4 = 12
3 x 5 = 15
3 x 6 = 18
3 x 7 = 21
3 x 8 = 24
3 x 9 = 27
3 x 10 = 30
L’avantage est que l’on peut appeler facilement la fonction et réafficher toute la table sans avoir
besoin de tout réécrire !

NB : Si vous utilisez un éditeur ou bien vous travaillez avec des fichiers, l’appel de la fonction se
fait dans le fichier après le corps de la fonction. Le code suivant nous le montre.
[20]: def table_multiplication():

n = int(input("Entrez un nombre positif : "))
i = 1
while i <= 10: # Tant que i est strictement inférieure ou égale à 10,
print(n, " x ", i, " = ", n*i)
# Fin du corps de la fonction
table_multiplication() # appel de la fonction avec les deux parenthèses.

4 x 1 = 4
4 x 2 = 8
4 x 3 = 12
4 x 4 = 16
4 x 5 = 20
4 x 6 = 24
4 x 7 = 28
4 x 8 = 32
4 x 9 = 36
4 x 10 = 40
5.1.2 Création de fonctions avec paramètres (arguments)

Un paramètre est en fait une variable, mais il y a deux facteurs importants qui rendent les
paramètres différents et spéciaux :
• Les paramètres n’existent qu’à l’intérieur des fonctions dans lesquelles ils ont été définis, et
le seul endroit où le paramètre peut être défini est un espace entre une paire de parenthèses
dans l’instruction def ;
• L’attribution d’une valeur au paramètre se fait au moment de l’appel de la fonction, en spé-
cifiant l’argument correspondant.
def Nom_de_la_fonction(parametre1, parametre2, ... , parametreN):
Bon à savoir :
• Les paramètres vivent à l’intérieur des fonctions (c’est leur environnement naturel) ;
• Les arguments existent en dehors des fonctions et sont porteurs de valeurs passées aux
paramètres correspondants.
Déterminons par exemple une fonction qui réçoit une valeur positive n et calcule son factoriel.

Formule :
n ! = n x (n – 1) x (n – 2) x ... x 2 x 1
= 1 x 2 x ... x (n – 2) x (n – 1) x n
0 !=1 !=1
[21]: def factoriel(n):
fact = 1
for i in range(1,n+1):
fact *=i # On effectue le produit entre i et fact
# à chaque tour de boucle.
print("La factorielle de", n, "est :", fact)
# Fin de la fonction
a = int(input("Entrez un entier positif : ")) # On demande à l'utilisateur
# de donner un entier.
# On fait appel à la fonction
factoriel(a) # a est la valeur saisie (argument),
# qui remplace la valeur n dans la définition de la fonction.
Entrez un entier positif : 4

La factorielle de 4 est : 24
Une fonction peut avoir autant de paramètres que vous le souhaitez, mais plus vous en avez, plus il est
difficile de mémoriser leurs rôles et objectifs.
Reprenons l’exemple de la table de multiplication. On peut aussi envisager de passer en paramètre
le nombre de valeurs à afficher dans la table. Le code python est le suivant :
[22]: def table_multiplication(n,max):

print("La table de multiplication de",n,"avec",max, "valeurs est : ")
i = 1
while i <= max: # Tant que i est strictement inférieure ou égale à 10,
print(n, " x ", i, " = ", n*i)
a = int(input("Entrez un nombre positif : ")) # On demande à l'utilisateur
# de donner un entier.
max = int(input("Entrez le nombre de valeurs à afficher : ")) # On demande
# à l'utilisateur de donner la valeur maximale.
table_multiplication(a,max) # appel de la fonction avec les deux arguments.

Entrez le nombre de valeurs à afficher : 3
La table de multiplication de 4 avec 3 valeurs est :
4 x 1 = 4
4 x 2 = 8
4 x 3 = 12
Un autre exemple de fonction qui reçoit trois entiers et effectue leur somme.

[23]: def somme(a, b, c):

print(a, "+", b, "+", c, "=", a + b + c)
print("Somme de trois entiers :\n")
x = int(input("Entrez le premier entier : ")) # premier entier
# (il va remplacer a)
y = int(input("Entrez le deuxième entier : ")) # deuxième entier
# (il va remplacer b)
z = int(input("Entrez le deuxième entier : ")) # troisième entier
# (il va remplacer c)
somme(x,y,z) # Appel de la fonction
Somme de trois entiers :
Entrez le premier entier : 1

Entrez le deuxième entier : 2
1 + 2 + 4 = 7
5.1.3 L’instruction return

Une fonction peut retourner un résultat de type simple à l’aide du mot-clé return. La syntaxe est
la suivante :
def Nom_de_la_fonction():
return expression
L’utilisation de return a deux conséquences :

• Il provoque l’arrêt immédiat de l’exécution de la fonction (rien de nouveau par rapport à la
première variante)
• De plus, la fonction évaluera la valeur de l’expression et la retournera (d’où le nom une fois
de plus) comme résultat de la fonction.
NB : La fonction peut aussi avoir des paramètres. Et il peut exister ou non le corps de la fonction.
Reprenons l’exemple précédent qui consiste à effectuer la somme de trois entiers.
[24]: def somme(a, b, c):

return a + b + c
print("Somme de trois entiers :\n")
x = int(input("Entrez le premier entier : ")) # premier entier
y = int(input("Entrez le deuxième entier : ")) # deuxième entier
z = int(input("Entrez le deuxième entier : ")) # troisième entier
print(x, "+", y, "+", z, "=", somme(x,y,z)) # Appel de la fonction

Somme de trois entiers :
Entrez le premier entier : 1

1 + 4 + 5 = 10
5.2 Les fonctions et les portées

La portée d’un nom (par exemple, un nom de variable) est la partie d’un code où le nom est
correctement reconnaissable.
Par exemple, la portée du paramètre d’une fonction est la fonction elle-même. Le paramètre est
inaccessible en dehors de la fonction.
Regardons l’exemple suivant :
[25]: def Testportee():

x = 2020
Testportee()
print(x)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-25-70aa9e92a6ae> in <module>
3
4 Testportee()
----> 5 print(x)
NameError: name 'x' is not defined
On constate que le programme a échoué lors de son exécution et un message d’erreur est généré.
Cela veut dire que la variable « x » dans le print() est en dehors de la fonction et elle n’est pas
définie.
Regardons le deux cas où la variable sera définie après le corps de la fonction et avant son appel.
[26]: def annee_academique():

print("L'année académique est :", an)
an = 2020
annee_academique() # Appel de la fonction
print("C'est effectivement",an,". Merci.")

L'année académique est : 2020

C'est effectivement 2020 . Merci.
NB : Une variable existant en dehors d’une fonction a une portée à l’intérieur des corps des
fonctions.
En plus, une variable existant en dehors d’une fonction a une portée à l’intérieur des corps des
fonctions, à l’exclusion de ceux d’entre eux qui définissent une variable du même nom.
Il existe une méthode Python spéciale qui peut étendre la portée d’une variable d’une manière à
inclure les corps des fonctions.
Un tel effet est causé par un mot-clé nommé global :
global nom_variable
ou bien
global nom_variable1, nom_variable2, ... , nom_variableN
[27]: def annee_academique():
global an
an = 2020 # Cette valeur est globale.
# Il impose sa force sur toutes les variables de même nom
print("L'année académique est :", an)
an = 2019 # Cette valeur ne sera pas considérée à cause de la variable globale.

annee_academique() # Appel de la fonction
print("C'est effectivement",an,". Merci.") # C'est la valeur de la variable
# globale qui sera considérée ici
L'année académique est : 2020

C'est effectivement 2020 . Merci.
Le résultat obtenu devrait être une preuve suffisante pour montrer que le mot-clé global fait ce
qu’il promet.
5.3 La récursivité
La récursivité est généralement utilisée en mathématiques et dont l’application est possible en
informatique. Elle consiste à remplacer une boucle par un appel à la fonction elle-même.
Ces deux cas semblent être les meilleurs pour illustrer la récusivité : la factorielle et le nombres
de Fibonacci. Surtout ce dernier.
• La factorielle
La factorielle a également un deuxième côté récursif. Regardez :
n! = 1 × 2 × 3 × ... × n-1 × n
Il est évident que :
1 × 2 × 3 × ... × n-1 = (n-1)!
Donc, finalement, le résultat est :

n! = (n-1)! × n
[28]: def factoriel(n):

if n < 0:
return None # La fonction ne renvoie aucune valeur
elif n < 2:
return 1
else:
return n * factoriel(n - 1)
a = int(input("Entrez un nombre positif :"))

print("La factorielle de",a,"est : ", factoriel(a))
Entrez un nombre positif :5

La factorielle de 5 est : 120
• Les nombres de Fibonacci
La suite de Fibbonacci est définie comme suit :
U0 = U1 = 1
Un = Un−1 + Un−2
[29]: def fibo(n):

if n < 0:
return None
elif n < 2:
return 1
else:
return fibo(n - 1) + fibo(n - 2)
a = int(input("Entrez un nombre positif :"))

print("Le terme",a,"de la suite de Fibonacci est :", fibo(a))
Entrez un nombre positif :10

Le terme 10 de la suite de Fibonacci est : 89
N’oubliez pas ceci : si une fonction ne renvoie pas une certaine valeur à l’aide d’une clause de l’expression
return, on suppose qu’elle renvoie implicitement None.
5.4 Les modules

Un module représente un bout de code que l’on a enfermé dans un fichier. Ce dernier peut con-
tenir ainsi des fonctions et des variables ayant toutes un rapport entre elles.
Il y a une possibilité d’utiliser des fonctions et variables emprisonnées dans le fichier en important
le module.

Cependant, Python possède un grand nombre de modules dont leur utilisation ne demande pas
d’installer des bibliothèques supplémentaires.
On peut citer par exemple le module math qui contient, comme son nom l’indique, des fonctions
mathématiques.
Il existe plusieurs techniques d’importation des fonctions mathématiques dans le module math.
5.4.1 Les méthodes import

Au début, les fonctionnalités du module math ne sont pas incluses lors que vous ouvrez
l’interpréteur Python.
Si votre programme a besoin des fonctions mathématiques comme cosinus, racine carrée, etc, vous
serez obligé à importer le module math à l’aide de la syntaxe suivante :
import math
Prenons l’exemple de le fonction sqrt() et la constante pi du module math qui renvoie la racine
carrée d’un nombre.
[30]: import math
Le module math est déjà importé grâce à la ligne précédente. Maintenant, il reste qu’à utiliser les
fonctions ou constante de ce module.
Pour appeler une fonction ou une constante ou une variable du module, il faut taper le nom du
module suivi d’un point « . » puis du nom de la fonction.
[31]: math.pi
[31]: 3.141592653589793
[32]: math.sqrt(9)
[32]: 3.0
Remarque : Il est impossible de lister toutes les fonctionnalités d’un module comme math. Pour
avoir des détails concenant un module, il est recommandé d’utiliser la fonction help() (aide, en
anglais).
[33]: help("math")
Saisissez la commande help(“math”) dans votre interpréteur Python et vous obtenez la liste de
toutes les fonctions et variables dans le module math.
5.4.2 Espace de noms spécifiques

Un espace de noms est une notion permettant de lever une ambiguïté sur des termes qui pour-
raient être homonymes. Il s’agit de regrouper certaines fonctions et variables sous un préfixe
spécifique.

Prenons le cas de l’exemple du module math dont son espace de noms est du même nom. Dans
l’espace de noms math, on touve la constante (variable) pi, la fonction sqrt, etc.
On peut créer un espace de noms dans lequel Python héberge le module principale.
Prenons par exemple le module math qui sera hébergé par l’espace de noms « mathematiques ».
Nous obtenons le code suivant :
[34]: import math as mathematiques
mathematiques.sqrt(64)
[34]: 8.0
5.4.3 Autres méthodes d’importation

1. La méthode from . . . import . . .
Cette méthode d’importation ne fonctionne pas de la même façon que la précéente (méthode
import). Elle n’importe que la fonction dont vous avez besoin dans votre programme au lieu
d’importer tout le module.
[35]: from math import sqrt

sqrt(25) # Pas besoin de mettre math.sqrt(25)
[35]: 5.0
2. La méthode from . . . import *

Cette méthode est un peu similaire à la précédent (La méthode from . . . import . . . ). Il s’agit
d’appeler toutes les variables et fonctions d’un module.
[36]: from math import*

sqrt(16) # Pas besoin de mettre math.sqrt(25)
[36]: 4.0
6 Traitement des exceptions

Vous avez au moins rencontré des erreurs pendant l’exécution de vos programmes. De ce fait, il
existe deux types d’erreurs : les erreurs de syntaxe et les exceptions.
6.1 Les erreurs de syntaxe

Les erreurs de syntaxe, qui sont des erreurs d’analyse du code, sont peut-être celles que vous
rencontrez le plus souvent lorsque vous êtes encore en phase d’apprentissage de Python.
[37]: while False print('Bonjour tout le monde')
File "<ipython-input-37-b9c37f82f0f6>", line 1

while False print('Bonjour tout le monde')

ˆ
SyntaxError: invalid syntax
L’analyseur indique la ligne incriminée et affiche une petite « flèche » pointant vers le premier
endroit de la ligne où l’erreur a été détectée. L’erreur est causée (ou, au moins, a été détectée
comme telle) par le symbole placé avant la flèche. Dans cet exemple la flèche est sur la fonction
print() car il manque deux points (‘:’) juste avant. Le nom du fichier et le numéro de ligne sont
affichés pour vous permettre de localiser facilement l’erreur lorsque le code provient d’un script.
6.2 Les exceptions

Même si une instruction ou une expression est syntaxiquement correcte, elle peut générer une er-
reur lors de son exécution. Les erreurs détectées durant l’exécution sont appelées des exceptions et
ne sont pas toujours fatales : nous apprendrons bientôt comment les traiter dans vos programmes.
La plupart des exceptions toutefois ne sont pas prises en charge par les programmes (Python lève
des exceptions). Sans le savoir, vous avez donc déjà vu des exceptions levées par Python :
[38]: # Exemple classique : test d'une division par zéro

variable = 5/0
---------------------------------------------------------------------------
ZeroDivisionError Traceback (most recent call last)
<ipython-input-38-d135fc405675> in <module>
1 # Exemple classique : test d'une division par zéro
----> 2 variable = 5/0
ZeroDivisionError: division by zero
[39]: 2 + x*10
---------------------------------------------------------------------------
<ipython-input-39-a3868e39253b> in <module>
----> 1 2 + x*10
NameError: name 'x' is not defined

Pour ces deux exemple, nous avons deux informations importantes :

ZeroDivisionError ou NameError : le type de l’exception ;
division by zero ou name ‘x’ is not defined : le message qu’envoie Python pour vous aider à
comprendre l’erreur qui vient de se produire.
6.3 Gestion des exceptions

6.3.1 Première forme d’exception
Il est possible d’écrire des programmes qui prennent en charge certaines exceptions. La syntaxe
est la suivante :
try:
# Cette partie contient le Bloc à essayer
except:
# Bloc qui sera exécuté en cas d'erreur
Prenons un exemple, qui demande une saisie à l’utilisateur jusqu’à ce qu’un entier valide ait été
entré, mais permet à l’utilisateur d’interrompre le programme (en utilisant Control+C ou un autre
raccourci que le système accepte).
[40]: while True:

try:
x = int(input("Entrez un nombre positif : "))
break
except:
print("Oups! Ce n'était pas un numéro valide. Merci de réessayer...")
Entrez un nombre positif : a

Oups! Ce n'était pas un numéro valide. Merci de réessayer...
Cette méthode essaye une instruction et intercepte n’importe quelle exception liée à cette instruc-
tion. Ce qui peut présenter des limites lorsque le nombre d’erreurs augmente. Mais le minimum
qu’on peut faire pour gérer les exceptions.
6.3.2 Deuxième forme d’exception

Cette méthode complète la précédente en y apportant beaucoup plus de précision. En plus,
plusieurs erreurs peuvent se produire et que la première forme intercepte toutes ces erreurs sans
les distinguer, ce qui peut être problématique dans certains cas.
Prenons l’exemple de la division de deux nombres.
resultat = numerateur / denominateur
Les erreurs qu’on pourrait rencontrer sont :
• ValueError : une erreur de conversion est détectée ;
• NameError : l’une des variables numerateur ou denominateur n’a pas été définie ;

• TypeError : l’une des variables numerateur ou denominateur ne peut diviser ou être divisée
(les chaînes de caractères ne peuvent être divisées, ni diviser d’autres types, par exemple) ;
• ZeroDivisionError : Si denominateur vaut 0, cette exception sera levée.
La liste d’exceptions qui peuvent être levées à l’exécution de ce code n’est pas exhaustive.
[41]: while True:

try:
x = int(input("Entrez un nombre positif : "))
break
except ValueError: # Interception d'une erreur de conversion
print("Oups! Ce n'était pas un numéro valide. Merci de réessayer...")
Entrez un nombre positif : $

Oups! Ce n'était pas un numéro valide. Merci de réessayer...
• Erreur liée à la définition des variables.
[42]: try:
resultat = numerateur / denominateur
except NameError:
print("La variable numerateur ou denominateur n'a pas été définie.")
except TypeError:
print("La variable numerateur ou ", end="")
print("denominateur possède un type incompatible avec la division.")
except ZeroDivisionError:
print("La variable denominateur est égale à 0.")
La variable numerateur ou denominateur n'a pas été définie.

• Erreur liée au type
[43]: try:
resultat = 2 / "b"
except NameError:
except TypeError:
La variable numerateur ou denominateur possède un type incompatible avec la

division.
• Erreur liée à la division par 0
[44]: try:
resultat = 2 / 0

except NameError:
except TypeError:
La variable denominateur est égale à 0.
6.3.3 Les mots-clés

• Le mot-clé else
Si aucune erreur ne survient dans le bloc try, le mot-clé else va permettre d’exécuter une action.
On reprend l’exemple précédent.
[45]: try:
resultat = 10/4
except NameError:
except TypeError:
else:
print("Le résultat obtenu est", resultat)
Le résultat obtenu est 2.5

• Le mot-clé finally
Le mot-clé (clause) finally est toujours exécutée avant de quitter l’instruction try, qu’une exception
ait été déclenchée ou non. Quand une exception a été déclenchée dans la clause try et n’a pas été
prise en charge par une clause except (ou si elle a été déclenchée dans une clause except ou else), elle
est re-déclenchée après l’exécution de la clause finally. La clause finally est également exécutée
« à la sortie » quand n’importe quelle autre clause de l’instruction try est abandonnée par une
instruction break, continue ou return.
try:
# Test d'instruction(s)
except type_de_l_exception:
# Traitement en cas d'erreur
finally:
# Instruction(s) exécutée(s) qu'il y ait eu des erreurs ou non
Exécutons l’exemple suivant :

[46]: def division(x, y):

try:
result = x / y
else:
print("Le résultat est", result)
finally:
print("La clause finally est bien exécutée.")
[47]: division(30,4) # Appel de la fonction division
Le résultat est 7.5

La clause finally est bien exécutée.
[48]: division(30,"4") # Appel de la fonction division
La clause finally est bien exécutée.
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-48-58fa0f2a0cf3> in <module>
----> 1 division(30,"4") # Appel de la fonction division
<ipython-input-46-d5ad6f1e5291> in division(x, y)
1 def division(x, y):
2 try:
----> 3 result = x / y
4 except ZeroDivisionError:
5 print("La variable denominateur est égale à 0.")
TypeError: unsupported operand type(s) for /: 'int' and 'str'
Comme vous pouvez le voir, la clause finally est exécutée dans tous les cas. L’exception de type
TypeError déclenchée en divisant un entier par une chaîne de caractères n’est pas prise en charge
par la clause except et est donc re-déclenchée après que la clause finally ait été exécutée.
6.4 Les assertions

Avant de continuer l’exécution des lignes de code, il est nécessaire de vérifier qu’une condition est
respectée. Pour ce faire, on fait appel aux assertions. En général, on les utilise dans des blocs try
. . . except.


assert test
Si le test renvoie True, l’exécution se poursuit normalement. Sinon, une exception AssertionError
est levée.
Reprenons l’exemple d’une année bissextile. Pour s’assurer que l’utilisateur ne saisie pas une
année inférieure ou égale à 0, on peut recours à l’utilisation de l’assertion.
def bissextile(annee):
try:
annee = int(annee) # Conversion de l'année
assert annee > 0
if annee % 400 == 0 or (annee % 4 == 0 and annee % 100 != 0):
print("L'année",annee, "est bissextile.")
else:
print("L'année",annee, "n'est pas bissextile.")
except ValueError:
print("Vous n'avez pas saisi un nombre.")
except AssertionError:
print("L'année saisie est inférieure ou égale à 0.")
[50]: bissextile(2024) # Année saisie est valide
L'année 2024 est bissextile.
[51]: bissextile("x") # Exception pour une erreur de valeur
Vous n'avez pas saisi un nombre.
[52]: bissextile(-2020) # Exception pour une condition ne respectant pas l'assertion
L'année saisie est inférieure ou égale à 0.
6.5 Déclencher des exceptions

Pour déclencher (lever) une exeption, on utilise le mot-clé raise. La syntaxe est la suivante :
raise TypeDeLException("message à afficher")
[53]: raise NameError("La variable n'est pas définie")
---------------------------------------------------------------------------
<ipython-input-53-eaa616e4f679> in <module>
----> 1 raise NameError("La variable n'est pas définie")

NameError: La variable n'est pas définie
Le seul argument à raise indique l’exception à déclencher.

Reprenons encore l’exemple de l’année bissextile.
try:
if annee<=0:
raise ValueError("l'année saisie est négative ou nulle")
except ValueError:
print("La valeur saisie est invalide (l'année est peut-être négative).")
[55]: bissextile(-2000)
La valeur saisie est invalide (l'année est peut-être négative).

Si vous avez besoin de savoir si une exception a été levée mais que vous n’avez pas l’intention de
la gérer, une forme plus simple de l’instruction raise permet de propager l’exception :
try:
if annee<=0:
raise ValueError("l'année saisie est négative ou nulle")
except ValueError:
print("La valeur saisie est invalide (l'année est peut-être négative).")
raise # On n'a pas l'intention de gérer l'exception
[57]: bissextile(-2020)
La valeur saisie est invalide (l'année est peut-être négative).
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-57-d015fb96faea> in <module>
----> 1 bissextile(-2020)
<ipython-input-56-e16dfc648eb3> in bissextile(annee)
4 annee = int(annee) # Conversion de l'année

5 if annee<=0:
----> 6 raise ValueError("l'année saisie est négative ou nulle")
7 except ValueError:
8 print("La valeur saisie est invalide (l'année est peut-être␣
,→négative).")
ValueError: l'année saisie est négative ou nulle
NB : Il n’est pas demandé de connaître toutes les exceptions que Python utilise. Par contre, vous
devez être en mesure, grâce à l’interpréteur, de déterminer les types d’exceptions que peuvent
lever Python devant une situation donnée.
Fin*****du*****chapitre

Chapitre 2 Bases Langage Python

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre 2 Bases Langage Python

Transféré par

Droits d'auteur :

Formats disponibles

Chapitre 2 : Bases du langage Python

Responsable : Dr Ousmane KHOUMA

2 Les structures conditionelles

2.1 L’instruction conditionelle if

L’utilisation de l’instruction if se compose des éléments suivants, strictement nécessaires et dans

[1]: a = int(input("Entrez un nombre positif : "))

Entrez un nombre positif : 20

[2]: a = int(input("Entrez un nombre positif : "))

Entrez un nombre positif : 15

Dr Ousmane KHOUMA 2 Année Académique 2019 - 2020

2.2 L’instruction conditionelle if - else

[3]: prenom = input("Veuillez entrer votre prénom : ")

Veuillez entrer votre prénom : Modou

[4]: prenom = input("Veuillez entrer votre prénom : ")

Dr Ousmane KHOUMA 3 Année Académique 2019 - 2020

Veuillez entrer votre prénom : Fatou

2.3 L’instruction conditionelle elif

[5]: temp = float(input("Entrez la température de l'eau : "))

Entrez la température de l'eau : -35

2.4 Les opérateurs de comparaison

Dr Ousmane KHOUMA 4 Année Académique 2019 - 2020

3 Les opérateurs logiques

Dr Ousmane KHOUMA 5 Année Académique 2019 - 2020

• Avec les méthode if - else d’abord.

[7]: # On fait un test pour savoir si une variable b est comprise

[8]: # On fait un test pour savoir si une variable b est comprise

Dr Ousmane KHOUMA 6 Année Académique 2019 - 2020

annee = int(input("Entrez une année : ")) # On attend que l'utilisateur saisisse

Entrez une année : 2020

4 Les boucles while et for

4.1 La boucle while

Dr Ousmane KHOUMA 7 Année Académique 2019 - 2020

[10]: a = int(input("Entrez une valeur entière positive : "))

Entrez une valeur entière positive : 0

Dr Ousmane KHOUMA 8 Année Académique 2019 - 2020

Entrez un nombre ou tapez 0 pour arrêter : 7

4.2 La boucle for

Dr Ousmane KHOUMA 9 Année Académique 2019 - 2020

[12]: for i in range(3):

La valeur de i est actuellement : 0

La valeur de i est actuellement : 2

[14]: n = int(input("Entrez un nombre positif : "))

Entrez un nombre positif : 5

Dr Ousmane KHOUMA 10 Année Académique 2019 - 2020

[15]: chaine = "Merci mon ami"

4.3 Les mots - clés break et continue

[16]: print("L'instruction break :")

Dr Ousmane KHOUMA 11 Année Académique 2019 - 2020

5.1 Création de fonctions

5.1.1 Création de fonctions sans paramètres (arguments)

Dr Ousmane KHOUMA 12 Année Académique 2019 - 2020

[18]: def table_multiplication():

Entrez un nombre positif : 3

Dr Ousmane KHOUMA 13 Année Académique 2019 - 2020

[20]: def table_multiplication():

Entrez un nombre positif : 4

5.1.2 Création de fonctions avec paramètres (arguments)

Dr Ousmane KHOUMA 14 Année Académique 2019 - 2020

Entrez un entier positif : 4

[22]: def table_multiplication(n,max):

Entrez un nombre positif : 4

Dr Ousmane KHOUMA 15 Année Académique 2019 - 2020

[23]: def somme(a, b, c):

Somme de trois entiers :