Filière : GPE - Niveau : C2A1 – Année académique : 2023/2024

ALGORITHMIQUE ET PROGRAMMATION EN PYTHON

Wansouwé Wanbitching, PhD

Chef de Département de la FCQ
 Informations générales
 Intitulé : Algorithmique et Programmation en Python
 Cours magistral : 15 heures
 Travaux dirigés / pratiques : 15 heures

 Éléments constitutifs de l'Unité d'Enseignement

 Cours magistral : soyez attentifs!
 Travaux Dirigés : Exercices
 Travaux Pratiques : le plus intensif possible
 Projet

2
 Bibliographie

 Cormen T.H., Leiserson C., Rivest R., Stein C. (2002). Introductions to

Algorithms, 2e édition.
 Swinnen, G. (2012). Apprendre à programmer avec Python 3, 3e Edition,
Eyrolles
 Ramalho, L. (2019). Programmer en Python, O’reilley
 Le Goff, V. (2019). Apprenez à programmer en Python, 3e edition, Eyrolles

3
 OBJECTIFS

o Maitriser les fondamentaux de Python

o Présenter les concepts de la programmation orientée en Python
o Présenter les différentes bibliothèques les plus utilisées en Python
o Apprendre à utiliser les notebooks de Jupyter

4
Plan
Partie A : Algorithmique

▷ Chap 1: Introduction à l’algorithmique

▷ Chap 2: Structures algorithmiques

▷ Chap 3: Récursivité

▷ Partie B : Programmation

▷ Chap 1: Introduction à Python

▷ Chap 2: Modules de data science

▷ Chap 3: Programmation orientée objet en Python

▷ Chap 4: Gestion des fichiers et exceptions

5
5
Plan

Partie B : Programmation

▷ Chap 1: Introduction à Python

▷ Chap 2: Modules de data science

▷ Chap 3: Programmation orientée objet en Python

▷ Chap 4: Gestion des fichiers et exceptions

6
6
 Chapitre 1: Introduction à Python
▷ I. Généralités sur la Programmation
▷ I.1. Compilation
▷ I.2. Interprétation
▷ I.3. Semi-compilation
▷ II. Eléments fondamentaux du langage Python
▷ II.1. Introduction
▷ II.2. Les variables
▷ II. 3. Les Opérateurs
▷ II.4. Les structures de données
▷ III. Fonctions en Python
▷ III.1. Définitions et création
▷ III.2. Passage de paramètres
▷ III. 3. Fonctions lambda
▷ 7
7
 Généralités sur la programmation
•Un programme est la traduction d’un algorithme dans un
langage compréhensible par l’ordinateur
•On utilise des systèmes de traduction automatiques,
capables de convertir en nombres binaires des suites de
caractères formant des mots-clés.
•Le système de traduction proprement dit s’appellera
interpréteur ou bien compilateur, suivant la méthode de
traduction utilisée.

8
8
Du code source à son exécution

9
9
 Compilation
•La compilation consiste à traduire la totalité du code source
en une fois.
• Le compilateur lit toutes les lignes du programme source et
produit une nouvelle suite de codes appelée programme
objet (ou code objet).
•Celui-ci peut désormais être exécuté indépendamment du
compilateur et être conservé tel quel dans un fichier (fichier
exécutable).
•Exemples : Ada, C, C++ et Fortran, Pascal.
10
10
 Interprétation
•L’interprétation consiste à traduire chaque ligne du
programme source en quelques instructions du langage
machine, qui sont ensuite directement exécutées au fur et à
mesure.

•L’interpréteur doit être utilisé chaque fois que l’on veut faire
fonctionner le programme.

Exemples : Lisp et Prolog.

11
11
 Semi-compilation
• Semi – Compilation = Compilation + Interprétation

• Compilation du code source pour produire un code

intermédiaire, similaire à un langage machine (mais pour une
machine virtuelle), que l’on appelle bytecode,

• Interprétation du bytecode pour l’exécution finale.

• Le bytecode est très facile à interpréter en langage machine.
• Exemples : Python, Java
12
12
GENERALITES SUR LA PROGRAMMATION

Généralités sur Python

13
13
 Généralités sur Python
• Créé par Guido van Rossum en 1991
• Langage : objet, de nouvelle génération, pseudo -interprété, portable, libre, ouvert, gratuit.
• Nombreuses “ bibliothèques ” disponibles sur internet.

• “I chose Python as a working title for the project, being in a slightly irreverent mood (and a
big fan of Monty Python's Flying’Circus)”

14
14
 Généralités sur Python
• Proche de l'algorithmique donc approprié pour :
 l'enseignement
 les applications dans le monde réel
o Moteur de recherche Google, Youtube,
o Laboratoires de recherche (CNRS, INRIA, Univ
o Agences spatiales (NASA…),
o Jeux vidéo, cinéma,
o Finance,
o etc.
• Utilisé dans de nombreuses entreprises
o Collecte et analyse de données donc pour la Data Science 15
15
 GENERALITES SUR LA PROGRAMMATION
Python 2 (2000) et Python 3 (2008)
Dans la lignée de Perl :
• Langage « script » : interprété, compilé à la volée en bytecode (fichiers .ypc)
• Faiblement typé (typage à l’exécution)
• Types de base, listes, dictionnaires
• Programmation fonctionnelle (faible)
• Programmation orientée objet (faiblement typée)

Forces et faiblesses :
• Forces: flexibilité, simplicité et rapidité de développement
• Faiblesses : lent et gourmand en mémoire, peu robuste

16
16
 Les Variables
Les variables Python sont automatiquement créées au moment où on leur assigne
une valeur
Règles usuelles pour le nom de variable :
• commencer par une lettre ou par un underscore ;
• ne contenir que des caractères alphanumériques courants;
• ne pas être un mot réservé de Python,

NB : Python est sensible à la casse

Opérateur d’affection : « = »

Exemple : monage = 30 monAge = 30

sont deux variables distinctes!
17
17
 Les Types de données
1. Les types numériques :
int - type des entiers : a = 1, b = 45, monage = 20
float - type des réels : pi = 3.14, a = 1.0
complex - type des nombres complexes : z = 1+2j

2. Le type chaine de caractères :

str (string) : nom = ‘Latifa’, prenom = ‘Maï’

3. Le type booléen
bool – le type des valeurs booléennes
Exemples : trouve = True, aUnChien = False
18
18
 GENERALITES SUR LA PROGRAMMATION
Les opérateurs arithmétiques

19
19
 GENERALITES SUR LA PROGRAMMATION
Les opérateurs de chaînes de caractères

•Python dispose de deux opérateurs de chaine

concaténation : +
‘123’ + ‘45’ # ‘12345’

répétition : *
‘abc’ * 2 # ‘abcabc’
20
20
 GENERALITES SUR LA PROGRAMMATION
Les opérateurs d’affection simple et composés

21
21
Les structures de données

22
22
 Les listes
• Une liste est une collection ordonnée et modifiable d’éléments éventuellement hétérogènes.

• Elle est construite à l’aide d’éléments séparés par des virgules, et entourés de crochets.

Exemples

1. couleurs = [’trèfle’, ’carreau’, ’coeur’, ’pique’]

2. couleurs[1] = 14 # modifie la deuxième valeur
3. list1 = [’a’, ’b’], list2 = [4, 2.718]

list3 = [list1, list2] # crée une liste de listes

print(list3) # [[’a’, ’b’], [4, 2.718]]

23
23
 Manipulation des listes
• nombres = [17, 38, 10, 25, 72]
• [Link]() # trie la liste
• print(nombres) # [10, 17, 25, 38, 72]
• [Link](12) # ajoute la valeur 12 à la fin
• [Link]() # inverse la liste
• [Link](38) # retire la valeur 38 de la liste
• print(nombres) # [12, 72, 25, 17, 10]
• print([Link](17)) # livre l’indice d’un nombre
• nombres[0] = 11
• nombres[1:3] = [14, 17, 2]
• print([Link]()) # livre l’élément de tête 10
• print(nombres) # [11, 14, 17, 2, 17]
• print([Link](17)) # nombre d’occurrences
• [Link]([1, 2, 3]) # étend la liste
24
24
 Manipulations des listes
• mots = [’jambon’, ’sel’, ’miel’, ’confiture’, ’beurre’]
• mots[2:4] = [] # effacement par affectation d’une liste vide
• print(mots) # [’jambon’, ’sel’, ’beurre’]
• mots[1:3] = [’salade’]
• print(mots) # [’jambon’, ’salade’]
• mots[1:] = [’mayonnaise’, ’poulet’, ’tomate’]
• print(mots) # [’jambon’, ’mayonnaise’, ’poulet’, ’tomate’]
• mots[2:2] = [’miel’] # insertion en 3è position
• print(mots) #[’jambon’, ’mayonnaise’, ’miel’, ’poulet’, ’tomate’]
25
25
 Les Tuples
• Un tuple est une collection ordonnée et non modifiable d’éléments éventuellement
hétérogènes.

• Ses éléments sont séparés par des virgules, et entourés de parenthèses.

Exemples
mon_tuple = (’a’, 2, [1, 3])
mon_tuple[1] #2
t = 123, 456, ‘hello’

Types séquentiels de données : chaines de caractères, listes et tuples

Données organisées sous forme de séquence de caractères ou de valeurs.

26
26
 Les Dictionnaires
• Un dictionnaire est une collection de couples cle : valeur entourée d’accolades.
• Les dictionnaires constituent un type composite mais ils n’appartiennent pas aux séquences.
• Un dictionnaire vide :
d1 = {} ou d1 = dict()
• Ajout des élements un à un
d1['nom'] = 'Fati‘ d1['taille'] = 176
print(d1) # {”nom”: ‘Fati’, ”taille”: 176}
• Définition en extension
d2 = {'a' : 1, 'b' : 2, 'c' : None }
• Utilisation de paramètres nommés
d3 = dict(nom=3, taille=176)
• Utilisation d’une liste de couples clés/valeurs
d4 = dict([(”nom”, 3), (”taille”, 176)])
• Définition en compréhension
d5 = {x: x**2 for x in (2, 4, 6)}
27
27
 Les Dictionnaires
• Un dictionnaire est une collection de couples cle : valeur entourée
d’accolades.

• Les dictionnaires sont modifiables, mais les couples enregistrés n’occupent pas
un ordre immuable;

• Une clé pourra être de tout type excepté les listes et les dictionnaires.

• Les valeurs pourront être de n’importe quel type: valeurs numériques,

séquences, dictionnaires, mais aussi des fonctions, des classes ou des
instances.
28
28
 Les ensembles
• Un ensemble est une collection itérable non ordonnée d’éléments hachables distincts.
• Création : paire d’accolades { } avec les différents éléments de l’ensemble entre ces accolades, séparés par des virgules ou à
l’aide du mot clé set.
Exemples
• X, Y = set(’abcd’), set(’sbds’)
• print(”X =”, X) # X = {’a’, ’c’, ’b’, ’d’}
• print(”Y =”, Y) # Y = {’s’, ’b’, ’d’} : un seul élément ’s’
• print(’c’ in X) # True
• print(’a’ in Y) # False
• print(X - Y) # {’a’, ’c’}
• print(Y - X) # {’s’}
• print(X | Y) # {’a’, ’c’, ’b’, ’d’, ’s’} (Union )
• print(X & Y) # {’b’, ’d’} (Intersection)

29
29
 Les ensembles
• Un ensemble est une collection itérable non ordonnée d’éléments hachables distincts.

Remarques
• Les ensembles ou sets forment un autre type de données composites Python.

• Un ensemble est une collection d’éléments non ordonnée, sans index et qui ne peut pas
posséder l’élément dupliqué.

• Une des utilisations les plus courantes des ensembles est de les utiliser pour supprimer
des valeurs doublons à partir d’un autre type de données.
30
30
 Les ensembles
• Un ensemble est une collection itérable non ordonnée d’éléments hachables distincts.

Remarques
• Les ensembles ou sets forment un autre type de données composites Python.

• Un ensemble est une collection d’éléments non ordonnée, sans index et qui ne peut pas
posséder l’élément dupliqué.

• Une des utilisations les plus courantes des ensembles est de les utiliser pour supprimer
des valeurs doublons à partir d’un autre type de données.
31
31
Structures de contrôle et itérations

32
32
 Instruction conditionnelle « if …elif… else »
Syntaxe :
if « condition 1 » :
sequence
elif « condition 2 » :
sequence
else :
sequence
Exemple
a = float(input("le nombre a : "))
if a > 0 :
print(‘ Le nombre est positif’)
elif a < 0 :
print(‘Le nombre est négatif’)
else :
print(‘le nombre est nul’)
33
33
 Itérations
Clause « while … »
Syntaxe
while « condition » :
sequence

Exemple
i=0
while i < 5:
print("i = {}".format(i))
i=i+1
print("Fin de la boucle avec i = {}".format(i))
34
34
 Itérations
Boucle « for … »
Syntaxe
for item in items :
sequence
1. Exemple 1 de boucle for :
for x in [0, 1, 2 ,3]:
print("x = {}".format(x))

2. Exemple 2 de boucle for avec range :

for x in range(4):
print("x = {}".format(x))

3. Exemple 3 de boucle for :

for word in ["calcul","scientifique","en","python"]:
print(word)
35
35
 Exercices

1. Créer une liste en compréhension L1 des entiers naturels pairs inférieurs ou égaux à 50.
2. Créer une liste en compréhension L2 des racines carrées des éléments de L1

36
36
 Fonctions et Modules
Fonction : ensemble d’instructions créées pour effectuer une tâche précise, regroupées
ensemble et exécutables à l’aide d’un appel.

Deux grands types de fonctions

1. Les fonctions prédéfinies
Exemples : print(), type(), input(), len(), etc.

2. Les fonctions définies par l’utilisateur

La syntaxe de définition est :
def nom_function (parametres_eventuels)
37
37
 Fonctions et Modules
def nom_function (parametres_eventuels):
sequence
return resultat
Exemple :
def square(number):
return number**2
Le mot clé return termine l’execution d’une fonction.
Une fonction peut ne pas avoir de return: c’est le cas des procédures. Dans ce cas, l'indentation permet
d'identifier la fin de la fonction
def example_b():
print('example_a is running')
print('returning value "a"')

38
38
 Passage de paramètres
Paramètres par défaut
Ils permettent aux utilisateurs d’appeler cette fonction en omettant de
passer les arguments relatifs aux paramètres possédant des valeurs par
défaut.

def difference(a=10, b) :
return a-b
Appel : difference(5) --------- # 5
mais difference(20,6)------- # 14

39
39
 Passage de paramètres non définis
Le paramètre *args :
permet d’indiquer lors de la définition d’une fonction qu’elle peut accepter un nombre variable
d’arguments
Exemple
def somme(*args):
s=0
for n in args :
s+= n
print(‘la somme est:’, s)
Appel : somme(2,5) --- ----# 7
somme(4, 7, 8) ----- # 19

40
40
 Passage de paramètres on définis

Le paramètre **kwargs :
permet d’indiquer lors de la définition d’une fonction qu’elle peut accepter un
nombre variable d’arguments mais comme dictionnaire.
Exemple
def pres (**kwargs):
for i, j in [Link]() :
print(i, j)

Appel : pres(prenom = ‘Pierre ’, age = 27, sexe = ‘Masculin’)

41
41
 Retour de plusieurs valeurs
Il est possible de retourner plusieurs valeurs à l’issue de l’exécution d’une fonction en
Python.
Pour cela, on utilise return en séparant les valeurs retournées par une virgule (Tuples).
Exemple
def ordre(a,b):
if a < b :
return a, b
else:
return b, a
Appel : ordre(20,50) -------- # (20,50)
ordre(15,3) ----------# (3,15)
42
42
 Fonctions récursives
Les fonctions récursives s’appellent elles-mêmes.

Exemple
def factoriel(n):
if n < = 1 :
return 1
else:
return n* factoriel(n-1)

Appel : factoriel(0) -------- # 1

factoriel(3) --------- # 6
43
43
 Variables globales et variables locales
• En Python, une variable peut avoir une portée locale ou une portée globale.
• Les variables définies dans une fonction sont locales : elles ne sont utilisées qu’à l’intérieur de la
fonction
def portee_locale() :
x = 10
print(x)
Appel: portee_locale() --------------# 10
Mais print(x) ---------------------# Erreur
Les variables définies en dehors de toute fonction sont:
o appelées des variables globales
o utilisables à travers l’ensemble du script
o accessibles en lecture à l’intérieur des fonctions et nécessitent le mot clé global pour modifications.

44
44
 Quelques fonctions utiles
input() : permet de dialoguer et d’échanger des données avec l’utilisateur.
On va pouvoir passer un message en argument de cette fonction.
Exemple :
prenom = input(‘Rentrez votre prénom : ’)
dir() : 1- Sans argument, renvoie la liste des variables et des fonctions (ou plus exactement des
objets et des méthodes) disponibles dans l’espace de portée courant.
2- Avec argument, renvoie la liste des méthodes disponibles pour ce type de donnée.

len() : donne la longueur de l’objet passé en paramètre.

type() : livre le type de l’objet passé en paramètre.

45
45
 Les fonctions de conversion
Elles permettent de modifier le type de certaines variables, c’est-à-dire de les “convertir”.
Ces fonctions portent le nom du type de donnée souhaité : str(); int(), float(), complex(), bool(); tuple(), list(), dict(), set().
Exemples :
list(‘Paul’)-----------# [‘P’, ‘a’, ‘u’, ‘l’]
float(’20’) -----------# 20.0
bool(‘False’) -------# True
bool(False) -------# False
Les fonctions mathématiques
Les plus courantes sont : range(), round(), sum(), min(), max()
range() : génère une suite de nombres paramètres
range(n) = 0,1,2,...n-1 range(n,m) = n, n+1,..., m-1
range(n,m,p) : n, n+p, n+2p, ... (avec une valeur maximale = m)
round() : arrondit à l’entier le plus proche avec un degré de précision (un nombre de décimales) éventuellement spécifié en
deuxième argument.

46
46
 Les fonctions lambda
Fonction lambda = fonction anonyme
Elles sont définies à l’aide du mot clé lambda (donc sans le mot clé def)
Elles sont utilisées lorsqu’il n’est pas nécessaire de nommer une fonction.
Syntaxe : lambda arguments: expression
NB: Les fonctions lambda ne peuvent contenir qu’une seule expression.
Exemples :
1. def sum_classic (a, b) : sum_lambda = lambda a, b : a+b
return a+b
2. some_numbers_list= [1, 2, 3, 87, 40, 49, 303, 34, 32, 98]
filtered_list = list(filter(lambda x: x > 10, some_numbers_list))
def my_custum_filter(x):
return x >10
some_numbers_list= [1,2,3,87,40,49,303,34,32,98]
filtered_list = list(filter(my_custum_filter, some_numbers_list))
47
47
 Exercices : Les dictionnaires
Créer les dictionnaires ci-dessus
1- d_2 = { 5 : "int",
"5" : "string",
3.5 : "float",
False : "Boolean"}
print(d_2)

2 - d_3 = { [1,2,3] : "liste"}

3 - d_4 = { {"cle":"valeur"} : "dictionnaire"}

4- d_5 = { "une_cle" : 1,
"une_autre_cle" : 2,
"une_cle" : 3,
"une_derniere" : 4}
print(d_5)

48
47