Pr Amadou Dahirou GUEYE

[email protected]
Année académique: 2024-2025
1
Plan global du cours
Chapitre 0 : Notion d’algorithme et programme
Chapitre 1 : Introduction à Python et aux bases de la programmation
Chapitre 2 : Structures de données en python (Dictionnaires, tuples,
ensembles)
Chapitre 3 : Les fonctions
Chapitre 4: La récursivité
Chapitre 5 : Les fichiers

2
Plan global détaillé du cours
Chapitre 0 : Notion d’algorithme et programme
 Définir un algorithme
 Connaître l’utilité d’un algorithme dans la résolution d’un problème
informatique
 Elaborer un algorithme
 Définir la notion de pseudo-langage
 Ecrire un algorithme
 Définir un programme
 Citer les langages de programmations
 Citer les différentes étapes d’un processus de programmation
3
Plan global détaillé du cours
Chapitre 1 : Introduction à Python et aux bases de la
programmation
• Présentation de Python.
• Types de données et objets.
• Structures de contrôle (conditions et boucles).

Chapitre 2 : Structures de données

• Listes, tuples, ensembles, et dictionnaires.
• Opérations sur les structures de données.

4
 Plan global détaillé du cours
Chapitre 3 : Les fonctions et la modularité
• Définition et appel de fonctions.
• Paramètres, arguments, et valeurs de retour.
• Organisation d’un programme avec des fonctions.
Chapitre 4: Les Fichiers
Lecture et écriture dans des fichiers (texte, CSV, JSON).
Chapitre 5 : Algorithmique fondamentale et récursivité
• Résolution de problèmes avec des algorithmes simples.
• Introduction au pseudo-code.
• Notions de récursivité et comparaisons avec l’itération.

5
Plan global détaillé du cours
Chapitre 6 : Applications pratiques et projets
• Développement d’applications simples (calculatrice, gestion de données).
• Introduction à l’analyse de complexité algorithmique.
• Réalisation et présentation d’un mini-projet.

6
 Chapitre 0:
Notion d’algorithme et programme

7
Objectifs du Chapitre 0
 Définir un algorithme
 Connaître l’utilité d’un algorithme dans la résolution
d’un problème informatique
 Elaborer un algorithme
 Définir la notion de pseudo-langage
 Ecrire un algorithme
 Définir un programme
 Citer les langages de programmations
 Citer les différentes étapes d’un processus de
programmation

8
Définition: Algorithme
Exemple 1: Nous allons faire de la bouillie

9
Définition: Algorithme
Exemple 1: Nous allons faire de la bouillie
1ière étape: Faire bouillir l’eau dans une casserole
2ième étape: Verser le riz dans la casserole
3ième étape: Attendre 20 minutes pour la cuisson du riz
4ième étape: Retirer la casserole et servir

10
Définition
A travers cet exemple, on peut définir l’algorithme
de la manière suivante:
C’est une séquence d’instructions qui s’exécute de
façon logique parce que la personne (la machine)
qui exécute l’ensemble des instructions est
capable de comprendre et d’exécuter chacune
d’elle.

11
Définition
Exemple 2: Créer un document Word
1ière étape: Allumer l’ordinateur
2ième étape: Attendre le chargement du système
d’exploitation
3ième étape: S’authentifier
4ième étape: Exécuter Word
5ième étape: Enregistrer le document Word en lui
donnant un nom

12
Définition
Exemple 3 : Résolution d’une équation à second degré

13
 Notions d’algorithme et de programme
Supposons que l’on veuille automatiser la résolution de l’équation du second degré à
solutions réelles ax2 + bx + c = 0 (a  0)

❑ Rendre automatique la résolution d’un problème revient à confier à cette tâche à un ordinateur.

Sachez, à priori, qu’un ordinateur ne sait rien faire à part ce qu’on lui a appris à faire.

❑ Donc, si nous décidons de lui confier la résolution de cette équation, nous sommes tenus de lui

apprendre à le faire.

❑ En d’autres termes, il nous faut lui donner l’ensemble des instructions qu’il doit exécuter pour

résoudre ce problème.

❑ C'est cet ensemble d’instructions que nous appellerons programme. Et ce programme doit être écrit

dans un langage compréhensible par l’ordinateur, par exemple le langage Pascal ou le langage python.

14
❑ Mais, avant l’écriture d’un tel programme, nous devons d’abord élaborer une liste ordonnée
des opérations qui, appliquées aux données du problème dans l’ordre prescrit, doivent aboutir à sa
résolution.
❑ Cette suite d’opérations s’appelle algorithme et c’est la théorie des algorithmes que l’on nomme
algorithmique.

Définition :
❑ Un algorithme est une suite d’actions ordonnées en séquence qui portent sur des objets. Ces objets
doivent être définis de manière très précise.
❑ Un programme c’est le codage d’un algorithme dans un langage de programmation, et qui peut
être traité par une machine donnée.

La construction d’un programme se fait par étape :

Problème → Enoncé → Algorithme → Programme → Résultats attendus

15
Propriétés d’un algorithme
 Un algorithme doit être précis
 Il doit indiquer l’ordre des étapes qui le constitue
 Il doit indiquer à quel moment il faut exécuter l’étape
suivante
 Un algorithme doit être fini dans le temps: si chaque
étape doit être fini alors l’ensemble constitué par ses
étapes doit être fini dans le temps

16
Importance de l’algorithme
Un algorithme doit être exprimé dans un langage de
programmation pour être compris et exécuter par
un ordinateur.

17
Programme
Un programme est le codage d’un algorithme donné.
L’écriture d’un programme n’est qu’une étape d’un
processus de programmation.

18
Etapes
Pb réel Analyse

Algorithme
Erreurs
sémantiques Codage (langage de
programmation)

Programme
Erreurs
syntaxiques Exécution

Résultats

19
Les différentes étapes
 Analyse: consiste à définir les différentes étapes de
résolution du problème. Elle permet de définir le
programme en termes de données et d’action à
exécuter sur ces données.
 Le codage: consiste à traduire l’algorithme dans un
langage de programmation donnée comme Pascal,
langage C, PHP, python, java, etc.

20
Les différentes étapes
 L’exécution: nous permet de déceler les différentes
erreurs qui peuvent être de deux (2) types:
 Les erreurs syntaxiques: elles sont faciles à déceler
car elles sont signalisées par le compilateur
 Les erreurs sémantiques, dans ce cas le programme
est obligé de reprendre l’analyse du problème qui
entraine la reprise de l’écriture de l’algorithme,
l’écriture du programme et de la recompilation de ce
dernier.

Le résultat escompté est obtenu qu’après avoir corrigé

l’ensemble des erreurs syntaxiques et sémantiques.
21
Pseudo-langage
Les langages de programmation sont compréhensibles
que par la machine. Ils ne sont pas directement liés
aux langages utilisés par une communauté, c’est dans
ce contexte que les chercheurs ont essayé de
concevoir un langage qui se détache de plus possible
de la machine mais qui se rapproche du langage
officiel utilisé par une communauté d’utilisateur: c’est
le pseudo-langage.

22
Pseudo-langage
L’avantage de sa création et de sa compréhension par
un grand public qui partage le même domaine, c’est-
à-dire la programmation: un algorithme n’a
d’intérêt que s’il est compris par un grand nombre
d’utilisateurs.

23
Elaboration d’un algorithme
On distingue 4 étapes d’une élaboration d’un
algorithme
a) Analyse du problème
b) Expression du raisonnement
c) Expression en pseudo-langage
d) Test et vérification de l’adéquation de la solution

24
Elaboration d’un algorithme
Analyse du problème
Elle consiste à bien comprendre l’énoncé du problème

25
Elaboration d’un algorithme
Expression du raisonnement
Il s’agit de traduire votre compréhension de l’énoncé du
problème en différentes étapes élémentaires,
précises, ordonnées et finies dans le temps.

26
Elaboration d’un algorithme
Expression en pseudo-langage
Elle consiste à traduire les étapes décrites dans
l’expression du raisonnement en pseudo-langage

27
Elaboration d’un algorithme
Test et vérification de l’adéquation de la solution
Elle consiste à faire le tour de toutes les instructions
contenues dans l’algorithme afin de vérifier leur
ordonnancement, leur cohérence et enfin
l’obtention du résultat final.

28
Exemple
Décrire les différentes étapes qui permettent de faire la
somme de deux entiers

1ière étape: Saisir la valeur du premier entier;

Saisir la valeur du deuxième
2ième étape: Additionner les deux valeurs
3ième étape: Afficher la somme (le résultat)

29
Notion d’objet
Le traitement d’un objet concerne la valeur de cet objet.
Si cette valeur ne peut pas être modifiée, nous parlons de constante, sinon nous parlons de
variable.
Un objet est parfaitement défini si nous connaissons ses trois caractéristiques, à savoir :
- Son identificateur : il est représenté par une suite quelconque de caractères alphanumériques
(numériques et alphabétiques sans espace) commençant obligatoirement par une lettre ou un tiret.
De préférence, le nom est choisi en rapport avec le contenu de l’objet.

Exemple : DELTA, Premiere_Racine .

- Sa valeur: constante ou variable
- Son type : nous ne pouvons pas appliquer de traitement à la valeur d’un objet si nous ne
connaissons pas son type.

30
❑ Un type est défini par un ensemble de constantes et l’ensemble des opérations que nous
pouvons leur appliquer.

❑ Il y a trois grands types d’objet :

• Booléen
Constantes : vrai, faux
Opérations : et logique, ou logique, non logique

• Numérique : entier ou réel

Constantes : ensemble des entiers relatifs ou ensemble des réels
Opérations : toutes les opérations arithmétiques et trigonométriques, notamment l’addition, la soustraction,
la multiplication, la division, la puissance, la division entière, la partie entière d’un réel.
• Caractère : c’est soit une lettre de l’alphabet latin, soit un code opération (‘+’, ‘-‘, ‘*’, ‘/’,
‘%’, …) ou un code de ponctuation (‘,’, ‘.’, ‘ :’, ‘ !’, …) ou un code spécial (‘&’, ‘$’, ‘#’, ..).
Un caractère est lié à un code numérique (par exemple, code ASCII) qui le représente en machine et qui
permet d’établir une relation d’ordre entre les caractères.

31
Résumé sur les types
En algorithme, un objet peut prendre l’un des types
simples suivants:
 Entier (ensemble des entiers naturels)
 Réel
 Caractère (tous les caractères du clavier)
 Chaine de caractères (ensemble de caractères)
 Booléen (c’est un objet qui peut prendre 2 valeurs
vraie ou fausse)

32
Opérations sur les types simples
 Entiers: opérations arithmétiques (+, -, /, *), div
(division entière), mod (modulo reste de la
division entière)
Exemple: 9 div 2 = 4; 9 mod 2 = 1

33
Opérations de comparaison ()
 Réel: opération arithmétique de comparaison
 Caractères et chaines de caractères
 Booléen: opérations logiques (ET, OU, NON)

34
Instructions élémentaires
Affectation
L’opération d’affectation consiste à effectuer une valeur à un objet (une variable). Elle
s’écrit sous la forme :
<variable>  <valeur> ( en algo)
<variable> := <valeur> ( en Pascal) ou <variable> = <valeur> ( en python)
La valeur affectée peut être :
- une variable de même type
- une constante du type de l’identificateur
- une expression dont l’évaluation produit un résultat du type de l’identificateur.
Exemples :
U 5 (algo)
a := 3 ; (pascal)
b := a ;
Delta := b*b – 4*a*c ;
>>> age = 36 (python)
35
Instructions d’entrée et de sortie
Nous disposons d’une instruction de saisie qui permet de récupérer une
valeur sur un périphérique d’entrée (le clavier), et d’une instruction
d’affichage qui permet l’édition d’une valeur sur un périphérique de sortie
(l’écran).
La forme générale de telles instructions est la suivante :
lire (<identificateur>) pour la saisie
ecrire (<valeur>) pour l’affichage

L’identificateur est un objet déclaré. La valeur située derrière d’affichage

peut être soit : un identificateur, une constante, une expression.

36
Instructions d’entrée et de sortie
Exemple d’instruction d’affichage:
Ecrire (‘Bienvenue dans le cours d’algo et programmation’)
Ecrire (10)
Ecrire (a)
Ecrire (‘delta vaut: ’ , delta)
Exemple d’instruction de lecture:
Lire(a)
Lire (x, y, z)
Combinaison des deux:
Ecrire (‘Entrez votre prénom’)
Lire (prenom)
Ecrire (‘Entrez votre nom’)
Lire (nom)

37
Structure d’un algorithme
Voici la structure générale d’un algorithme

Entête
Déclaration
Corps de l’algorithme

38
Structure d’un algorithme
Entête
Elle commence par le mot réservé algorithme suivi par
le nom de l’algorithme.
NB: Le nom de l’algorithme est un identificateur
Exemple:
Algorithme nomAlgo;

39
Structure d’un algorithme
Déclaration
L’ensemble des objets manipulés par l’algorithme
doivent être déclarés avant son utilisation. L’objet
peut être :
 Une variable
Variable nomVar1: type var 1
nomVar2: type Var 2
 Une constante
Constante nomConstante=valeurConstante

40
Structure d’un algorithme
Corps de l’algorithme
Il est délimité par les mots réservés Début et Fin. La
syntaxe est la suivante
Debut
Instruction 1;
Intruction 2;
…
…
Instruction n:
Fin.

41
Instruction
 Une instruction est une phrase de l’algorithme.
 C’est l’ensemble des étapes traduites au niveau de
l’expression du raisonnement écrites en pseudo-code
 Une instruction peut être une instruction d’affichage,
de saisie, d’affection.

42
Exercice d’application
Exemple 1:
Ecrire un algorithme qui lit trois nombres entiers, calcule et affiche leur somme, leur
produit et leur moyenne.

Algorithme calcul ;
Variables nbre1, nbre2, nbre3, S, P : entier ;
M : réel ;
Debut
ecrire (‘donnez trois nombres entiers :’)
lire (nbre1, nbre2, nbre3)
S := nbre1 + nbre2 + nbre3
P := nbre1 * nbre2 * nbre3
M := S / 3
ecrire (‘Somme:’, S, ‘Produit:’, P, ‘Moyenne’, M)
Fin
1
Essayez avant de regarder la solution !

Le langage utilisé pour écrire cet algorithme s’appelle pseudo-code (ou langage 43
Exercice d’application
Exemple 2:
1. écrire un algorithme qui calcule et écrit le carré de
547.
2. écrire un algorithme qui calcule et écrit le carré d’un
entier x lu au clavier.

44
Exercice d’application
Exemple 3 :
Ecrire un algorithme qui, à partir d’un prix unitaire et
d’un nombre d’articles fournis en données, calcule le
prix hors taxes et le prix TTC correspondant. Le taux
de TVA sera supposé égal à 18,6% et l’affichage devra
se présenter ainsi :

Prix unitaire: 45.65 Nombre d’articles: 17

Prix hors taxe :776.05 Tva: 144.35 prix TTC : 920.40

45
 Chapitre 1:
Introduction à Python et aux bases de la
programmation

46
 Chapitre 1:
Introduction à Python et aux bases de la
programmation
Partie 1: Présentation python
47
Présentation & Historique
Python, langage très moderne à la popularité grandissante

Historique:
Python est développé depuis 1989 par Guido van Rossum et de nombreux
contributeurs bénévoles.
1991 : Création de la première version publique de Python par Guido van
Rossum au CWI Centrum Wiskunde & Informatica d’ Amsterdam
1996 : sortie de la librairie NumPy
2001 : création de la Python Software Foundation (PSF) qui prend en
charge le développement du langage
2008 : sortie de Python 2.6 et 3.0
Python est resté peu connu pendant de longues années
Croissance lente mais constante
Depuis 2015, python est le langage le plus enseigné aux USA

48
Python 2.x et Python 3.x
Différentes versions: Python 1.5.2, puis d'autres sous Python 1.6, Python 2.0,
Python 2.1, Python 2.2, Python 2.3, 2.7 et enfin on parle aujourd’hui de Python 3.x
Deux versions de Python cohabitent encore :
▪ La version 2.7, stable et assez largement utilisé
▪ La version 3.x, dont le développement se poursuit

Ces deux versions sont très proches mais incompatibles

Nous étudierons la version 3.x
▪ Actuellement (janvier 2025) on est à la version 3.13 qui est stable et la
toute dernière est 3.13.1
Les deux versions sont téléchargeables sur https://www.python.org/downloads/

49
Comment utiliser python?
 Python présente la particularité́ de pouvoir être utilisé de plusieurs manières différentes :
▪ En mode interactif
o c’est à dire de manière à dialoguer avec lui directement depuis le clavier

o Les trois caractères « supérieur à » constituent le signal d’invite, ou prompt

principal, lequel vous indique que Python est prêt à exécuter une
commande.
▪ Sous forme de programmes (scripts) et les sauvegarder sur disque.
o (fichier complet avec l’extension .py) en utilisant par exemple un éditeur de
fichier
▪ IDE (PyCharm, Visual studio code, jupyter notebook TextWrangler,
SublimeText, etc.)
50
Installation de base de python
Windows
▪ Se rendre à la page https://www.python.org/download où vous
trouverez un programme d’installation qui contient tout ce dont
vous aurez besoin pour suivre le cours.
▪ Pour vérifier que vous êtes prêts, il vous faut lancer IDLE
(quelque part dans le menu Démarrer) et vérifier le numéro de
version.

MacOs
▪ Vous pouvez télécharger la version exécutable de python sur
Mac OS à l'adresse suivante :
https://www.python.org/downloads/mac-osx/

Fedora
sudo yum install python3-tools
51
Installation de base de python
Debian/Ubuntu
▪ Ici encore, Python-2.7 est sans doute déjà̀ disponible. Procédez
comme ci-dessus, voici un exemple recueilli dans un terminal
sur une machine installée en Ubuntu-14.04/trusty :
$ python3

Python 3.6.2 (default, Jul 20 2017, 12:30:02)

[GCC 6.3.1 20161221 (Red Hat 6.3.1-1)] on linux

Type "help", "copyright", "credits" or "license" for more information.

>>> exit()

▪ Pour installer python

$ sudo apt-get install python3

▪ Pour installer idle $ sudo apt-get install idle3

52
Jupyter
jupyterlab : facile d’utilisation pour écrire et exécuter des codes partiellement. Permet
d’espacer les codes et c’est plus rapide. JupyterLab est en constante évolution mais apparaît
aujourd'hui comme une solution de développement complètement open source parfaitement
adaptée au data scientist et à ses besoins.
Pour installer jupyterlab:
pip install jupyterlab # ou notebook
Pour démarrer l’éditeur jupyterlab, on lance la commande jupyter-lab
o On crée d’abord un dossier TPPYTHON avec la commande mkdir TPPYTHON
o Puis on se positionne dans le dossier et on lance la commande:
jupyter-lab pour démarrer l’éditeur

NB: Si vous avez Anaconda, il est déjà là ! Par contre, je vous conseille de le mettre à jour,
pour cela, il vous suffit de rentrer dans le prompt de l'Anaconda le code suivant :
53
 conda install -c conda-forge jupyterlab
Partie 2: Types de données et
objets

54
Les commentaires
Les commentaires ne sont pas exécutés par Python, ils sont destinés aux humains et non
à l'ordinateur
Ils facilitent la lecture et la compréhension du programme par d'autres personnes (ou par
soi-même quelques années plus tard !)
Commentaires simples (mono lignes)
▪ Les commentaires commencent par un dièse #
▪ Ils se prolongent jusqu'à la fin de la ligne
# Ceci est mon premier commentaire !
Commentaires longs
▪ Il n'y a pas de commentaire long (type /* */) à proprement parler en Python
Commenter chaque ligne
Utiliser une chaîne de caractères longue :

 """Ceci est une chaîne longue non utilisée,

qui fait office de commentaire multi-ligne !
"""
55
Afficher à l'écran
La fonction print() permet d'écrire à l'écran (dans le
terminal)
>>> print(5 + 2)
7
>>> print("Bonjour")
Bonjour
>>> print("Bonjour", "Master SI/SR")
Bonjour Master SI/SR

 Rq: double quote " et code simple ' sont les mêmes
En ligne de commande, le print() peut être omis
>>> 5 + 2
7

56
Print avec format
La méthode format() a été ajoutée dans Python(2.6). La méthode de formatage des chaînes
de caractères nécessite plus d'efforts manuels. Les utilisateurs utilisent {} pour marquer
l'endroit où une variable sera substituée et peuvent fournir des directives de formatage
détaillées, mais l'utilisateur doit également fournir les informations à formater.
Les valeurs sont soit explicitement fournies, soit référencées par l'ordre dans lequel elles
apparaissent dans la procédure format(). Les chaînes f permettent d'utiliser des accolades et
le préfixe f pour intégrer des expressions à l'intérieur de chaînes littérales. Les expressions
des chaînes f sont évaluées et leurs valeurs appropriées leur sont substituées.
>>> print('{} a considérablement changé {}!'.format(‘UAM', ‘Diamniadio'))
UAM a considérablement changé Diamniadio!
>>> print('{0} a considérablement changé {1}!'.format(‘UAM', ‘Diamniadio'))
UAM a considérablement changé Diamniadio!
>>> print('{1} a considérablement changé {0}!'.format(‘UAM', ‘Diamniadio’))
Diamniadio a considérablement changé UAM!
>>> print(f"Jaime {‘Diamniadio'} par \"{‘UAM'}!\"")
Jaime Diamniadio par "UAM!"
>>>

57
Aide
Plusieurs commandes permettent d'obtenir de l'aide en
Python
▪ Aide sur une classe ou une méthode :
help(list)
help(list.append)
▪ Lister les méthodes d'un objet :
dir(objet)

Aide en ligne
▪ https://docs.python.org/3/
▪ Aussi disponible en téléchargement ou en paquet Linux
58
Les types de données
Votre programme !
Tableaux :
Modules Python Module numpy
(utilisation rare)
Classes et objets

Type de données de collection :

Séquences : Tableaux associatifs (hash) :
liste (list) dictionnaire (dict)
tuple (tuple) dictionnaire ordonné
ensemble (set) (OrderedDict)
ensemble fixe (frozenset)

Type de données de base :

Nombres : Textes : Fonction
booléen (bool) chaîne de
entier (int) caractères (str) Fichier
flottant (float) chaîne binaire (bytes) (file) 59
Nombres entiers
 >>> print(1)
1
>>> print(1 + 2)
3
>>> print((3 + 4) * (5 + 8))
91
Pas de limite aux nombres entiers en Python !
 >>> print(123456789123456789123456789)
123456789123456789123456789

60
Nombres à virgule
 >>> print(1.3)
1.3
>>> print(1.3e6)
1300000.0
La précision du flottant Python correspond en fait à un
double.

61
Booléens
Deux valeurs possibles : vrai ou faux
True
False

62
Variables
Une variable est un nom auquel on associe une valeur
La valeur est souvent connu seulement à l'exécution du programme
(par exemple c'est le résultat d'un calcul)

Sous Python, les noms de variables doivent en outre obéir à quelques règles
simples :
Un nom de variable est une séquence de lettres (a→z,A→Z) et de
chiffres(0→9), qui doit toujours commencer par une lettre.
Seules les lettres ordinaires sont autorisées. Les lettres accentuées,
les cédilles, les espaces, les caractères spéciaux tels que $, #, @, etc.
sont interdits, à l’exception du caractère _ (souligné).
Attention majuscules et minuscules sont différenciées !
Il est important de trouver des noms parlants

63
Variables
En plus de ces règles, il faut encore ajouter que vous ne pouvez pas utiliser
comme nom de variables les 33 « mots réservés » ci-dessous

64
Affectations simples de variables
On crée une variable en lui donnant une valeur, avec =
>>> age = 36

On obtient la valeur d'une variable

 En donnant son nom
>>> age
36
Ou bien avec print
>>> print(age)
36

La valeur de la variable peut être modifiée avec =

>>> age = 37
>>> age = age + 1 # Anniversaire
37

del permet de supprimer une variable. del age

65
Affectations multiples
Sous Python, on peut assigner une valeur à plusieurs variables simultanément

On peut aussi effectuer des affectations parallèles à l’aide d’un seul opérateur :


66
Types de données
Python peut manipuler différents types de données :
des nombres entiers (integer en anglais, abrégé en int),
des nombres à virgule (souvent appelé flottants ou float en anglais),
des chaînes de caractères (string en anglais, abrégé en str)
et des booléens (valeur vraie ou fausse, bool) :

➢ age = 38 # Entier
➢ poids = 76.5 # Flottant
➢ nom = "Dahirou Gueye" # Chaîne de caractères
➢ enseignant = TRUE # Booléen
➢ etudiant = FALSE # Booléen
➢ telephone = "00221 77 501 25 35" # Chaîne de caractères!

67
Opérations sur les nombres
Opérations basique :
Addition : +
Soustraction : -
Multiplication : *
Division : /
Division entière : //
Modulo (reste de la division) : %
Puissance : **

D'autres opérations sont définies dans le module math

68
Priorité des opérations
Sous Python, les règles de priorité́ sont les mêmes que celles qui vous ont été́
enseignées au cours de mathématique. Vous pouvez les mémoriser à l’aide de
l’acronyme PEMDAS :
o P pour parenthèses
Ainsi 2*(3-1) = 4 , et (1+1)**(5-2) = 8.
o E pour exposants
Ainsi 2**1+1 = 3 (et non 4), et 3*1**10 = 3 (et non 59049 !).
o M et D pour multiplication et division, qui ont la même priorité́
Si deux opérateurs ont la même priorité, l’évaluation est effectuée de
gauche à droite. Ainsi dans l'expression 59*100/60, la multiplication est
effectuée en premier, et la machine doit donc ensuite effectuer 5900/60,
ce qui donne 98.
o A et S l’addition A et la soustraction S
Ainsi 2*3-1 = 5 (plutôt que 4), et 2/3-1 = -1 (Rappelez-vous que par
défaut Python effectue une division entière).
69
Chaînes de caractères
Les chaînes de caractère s'écrivent entre guillemets (simples ou doubles)
> Structure="Département d’Informatique TIC"
> chaine_vide= " "

Les chaînes de caractère sont en Unicode

▪ Cela permet de gérer toutes les langues du monde et des symboles

Pas de type caractère en Python

▪ On utilise une chaîne d'un seul caractère

Caractères spéciaux
▪ Retour à la ligne : "\n"
▪ Tabulation : "\t"
▪ Antislash : "\\"

70
Chaînes de caractères
Chaînes avec des guillemets à l'intérieur
▪ « Antislasher » les guillemets à l'intérieur de la chaîne : "Il se
nomme \"Dahirou\"."
▪ Tripler les guillemets extérieurs : """Il se nomme "Dahirou"."""
▪ Alterner guillemets doubles et simples : 'Il se nomme "Dahirou".'

71
Chaînes de caractères
Opérations sur les  Exemples avec s = "Bonjour"
chaînes
len(s) => 7
Obtenir la longueur d'une
chaîne (= le nombre de
caractères)
Obtenir un caractère de la s[0] => "B" s[-1] => "r"
chaîne

Obtenir une partie de la

chaîne s[0:3] => "Bon"

Concaténer deux chaînes "Hi " + s

Rechercher si une chaîne s.find("jour") => 3 # Trouvé en position 3

est incluse dans une autre
(-1 si pas trouvé)
72
Chaînes de caractères
Opérations sur les
chaînes 

Passer une chaîne en s.lower()

minuscule
s.upper()
ou en majuscule

Remplacer un morceau s.replace("Bonjour", "Good morning")

d'une chaîne

Demander à l'utilisateur de
saisir une chaîne saisie = input("Entrez un nom : ")
73
Chaînes de caractères
Formatage de chaînes de caractère : inclure des variables dans une chaîne : %
>>> nom = "Gueye "
>>> prenom = "Dahirou"
>>> "Salut %s !" % prenom
Salut Dahirou !
>>> "Bonjour %s %s !" % (prenom, nom)

>>> "Taux de réussite : %s %" % 100

Taux de réussite : 100 %

Attention aux faux nombres !

telephone1 = "00221 33 823 37 38"
telephone2 = 00221338233738

▪ Quel est le type de donnée des deux variables ci-dessus ?

▪ Pourquoi a-t-on choisi ce type de donnée pour le premier cas?
74
Conversions
Il est souvent nécessaire de convertir un type de
données vers un autre
▪ Les fonctions int(), float(), bool() et str() permettent de convertir
une valeur vers un entier, un flottant et une chaîne de caractère
▪ int("8") => 8
str(8) => "8"

▪ input() retourne toujours une chaîne de caractères ; il faut

penser à la transformer en entier ou en flottant si l'on demande
la saisie d'un nombre !
age = int(input("Entrez votre âge : "))
poids = float(input("Entrez votre poids : "))

75
Exercices
Testez les lignes d'instructions suivantes. Décrivez ce
qui se passe :
 >>> r , pi = 12, 3.14159
 >>> s = pi * r**2
 >>> print s
 >>> print type(r), type(pi), type(s)
 >>>
Quelle est, à votre avis, l'utilité de la fonction type() ?
(Note : les fonctions seront décrites en détail, plus loin
dans ce cours).
76
Partie 3: Les structures de
contrôle

77
Les structures de contrôle en algorithme

78
 Ecrivons l’algorithme permettant de calculer les valeurs de la fonction f(x) = |x| pour un réel x
donné.
Pour calculer f(x), on doit tester le signe de x et effectuer l’une des deux actions suivantes :
f(x) =x (si x >=0) et f(x) = -x (si x<0)
1 L’alternative

La structure de contrôle permettant de programmer ceci est l’alternative, dont la forme générale est :

si condition (booléenne) alors

action 1
Sinon
action 2

Cela nous donne pour notre exemple :

si (x>=0) alors
f(x) =x
sinon
f(x)=-x

Remarque : Dans le cas où la 2eme action est vide, on peut omettre le SINON.

Exercice d’application:
Une société paie ses employés chaque semaine. Le salaire étant calculé sur la base d’un taux
horaire, écrire un programme qui calcule et affiche le salaire sachant qu’il y a une majoration
79
de 20% si le nombre d’heures est supérieur à 35.
2 La répétition
Elle permet d’effectuer plusieurs fois consécutives la même opération. Sa forme la plus
simple est :
répéter
action

Mais un programme simulant une telle opération ne s’arrêterait, en principe jamais.

Donc il nous faut pouvoir contrôler une répétition. On dispose pour cela de deux moyens :

- ajouter à cette structure une condition permettant de décider s’il faut poursuivre ou
arrêter l’exécution de l’action répétée,
- prescrire le nombre de fois qu’il s’agira d’exécuter l’action.

2.1 La boucle avec compteur

La forme générale est
pour <compteur> := <valeur initiale> à <valeur finale> faire
action (à répéter)
Un pas (généralement égal à 1) permet de faire passer automatiquement le compteur
d’une valeur initiale à une valeur finale, et à chaque étape (ou itération ou tour de boucle),
on exécute l’action spécifiée.

80
 Ce pas, appelé aussi incrément, peut être négatif ; cela sous entend que la valeur initiale est
supérieure à celle finale.
Il est à remarquer que cette structure de contrôle s’apparente beaucoup avec la formule
mathématique .

Exemple :
Voici un algorithme qui affiche les entiers compris entre 1 et 100.
variable i : entier
debut
pour i :=1 à 100 faire
ecrire(i)
fin

81
Remarques :
1. Dans une boucle tant que, la condition contrôlant la répétition est testée avant chaque itération i.e.
l’exécution du corps de la boucle.
2. Lorsque le corps de la boucle contient plus d’une instruction (comme dans l’exemple ci-dessus), il faut
l’encadrer par les termes debut et fin.

Exercice d’application
Ecrire un algorithme permettant la saisie de la réponse à la question : « Aimez vous l’algorithmique
(o/n) ? ». Le programme doit afficher un message en cas de mauvaise réponse, et renouveler la question
jusqu’à ce que la réponse soit correcte.

82
2.3 La boucle REPETER
Elle s’écrit
Repeter
<instruction(s)>
jusqu’à <condition>;

83
 Elle est presque identique à la boucle tant que à la différence près que la condition de sortie est
testée après exécution des instructions.
Dans une boucle repeter, on est sûr que le corps de la boucle sera exécuté au moins une fois. Donc,
on choisira cette structure de contrôle si l’on veut que le corps de la boucle soit exécuté au moins une
fois. Ici, même si le corps de la boucle contient plus d’une instruction, il n’est pas nécessaire de
l’encadrer par debut et fin.
Par exemple, si l’on devait rédiger l’algorithme de l’exercice précédent en utilisant l’instruction repeter
:
Variable rep : caractère ;

debut

repeter

ecrire(‘Aimez vous l’’algorithmique (o/n) ? ‘) ;

lire(rep) ;

jusqu’à (rep=’o’) ou (rep=’n’);

fin.

84
 Exercice d’application
Ecrire un algorithme qui permet de saisir une valeur entière positive et de calculer sa racine
carrée.

Remarque:
On utilise généralement les instructions tant que ou repeter lorsque l’on ne connaît pas, à l’avance,
le nombre d’itérations

85
.
3 La structure de choix

Considérons le programme qui permet d’afficher littéralement un chiffre saisi au clavier.

On pourrait l’écrire en utilisant l’alternative,
on imbriquerait alors des Si :
Lire (X)
Si X = 1 alors ecrire (‘un’) Sinon
Si X = 2 alors ecrire (‘deux’) sinon
Si X = 3 alors ecrire (‘trois’) sinon
Si X = 4 alors ecrire (‘quatre’) sinon
Si X = 5 alors ecrire (‘cinq’) sinon
Si X = 6 alors ecrire (‘six’) sinon
Si X = 7 alors ecrire (‘sept’)

86
 sinon
Si X = 8 alors ecrire (‘huit’) sinon
Si X = 9 alors ecrire (‘neuf’) sinon
Si X= 0 alors ecrire (‘zero’)

La structure de choix dont la forme générale est la suivante est plus adaptée à ce problème.
Suivant <expression> faire

Valeur 1 : action 1

Valeur 2 : action 2
…
Valeur n : action n
Sinon : action par defaut
Fin
Son effet est de réaliser l’action correspondant à une condition i qui est satisfaite ; si aucune des
conditions n’ est satisfaite, c’est la condition par défaut qui est réalisée.

87
Les structures de contrôle en python

88
La structure conditionnelle

89
Sélection conditionnelle
if condition :
commande exécutée si la condition est vraie
commande exécutée si la condition est vraie…
suite du programme (exécuté que la condition soit vraie ou fausse)

▪ Attention à l'indentation (= les espaces blancs en début de ligne)

▪ La condition est une comparaison utilisant un booléen ou un
opérateur :

Inférieur à : < Supérieur ou égal à : >=

Supérieur à : > Égal à : ==

Inférieur ou égal à : <= Différent de : !=

90
Sélection conditionnelle
Le résultat doit être ceci:

Tapez encore une fois sur <Enter>. Le programme s’exécute, et vous obtenez :

91
Instructions successives
Il est possible d'ajouter plusieurs conditions successives,
et un bloc par défaut (else = sinon)
if condition1:
commande exécutée si condition1 est vraie
commande exécutée si condition1 est vraie…
elif condition2:
commande exécutée si condition1 est fausse et condition2 est vraie...
else:
commande exécutée si condition1 et condition2 sont fausses…
suite du programme (exécutée que les conditions soient vraies ou
fausses)

92
Instructions successives
Exemple1 de condition :

 Exemple2 de condition :
age = int(input("veuillez saisir votre âge : "))

if age == 0 :
print("Vous êtes un nouveau-né.")
elif age < 18 :
print("Vous êtes un enfant.")
elif age >= 65 :
print("Vous êtes une personne âgée.")
else :
print("Vous êtes un adulte.")

print("L'année prochaine vous aurez ", age + 1, " ans.") 93

Instructions imbriquées
Il est possible d’imbriquer les unes dans les autres
plusieurs instructions composées, de manière à réaliser
des structures de décision complexes
Exemple 1:

94
Instructions imbriquées
Exemple 2 :
 age = int(input("veuillez saisir votre âge : "))
poids = float(input("veuillez saisir votre poids : "))

if age == 0 :
print("Vous êtes un nouveau-né.")

if poids > 10.0 :

print("Je pense qu'il y a une erreur sur le poids !")

Les opérateurs logiques not, and et or permettent de

combiner plusieurs conditions entre elles.
Respectivement NON, ET et OU logique
if (age < 18) or (age > 65) :
print("Vous ne travaillez probablement pas.")
95
Les tableaux en Algorithme

96
 Les tableaux

1 Notion de tableau

Soit un entier n positif.

Supposons qu’on veuille saisir n valeurs réelles afin de calculer leur moyenne, ou de trouver
leur minimum, ou de les afficher par ordre croissant.
Pour des valeurs petites de n, on peut déclarer n variables réelles pour résoudre le problème.
Mais si n est assez grand, on se rend compte que cela devient impropre, fastidieux, voire impossible.
Il faudrait, dans ce cas, utiliser une variable permettant de représenter les n valeurs. Le type de
données de cette variable serait le type tableau.

Définition :
Un tableau est une collection séquentielle d’éléments de même type, où chaque élément peut être
identifié par sa position dans la collection. Cette position est appelée indice et doit être de type
scalaire.

97
 Déclaration :
Pour déclarer un tableau, il faut donner :
- son nom (identificateur de la variable)
- Ses bornes: la borne inférieure correspondante à l’indice minimal et la borne supérieure
correspondante à l’indice maximal.
- le type des éléments le composant.

Syntaxe:
type nom=tableau [<indice minimum> .. <indice maximum> ] de
<type des composants>
ou
variable nom : tableau [<indice minimum> .. <indice maximum> ]
de <type des composants>

Exemple:
Variable t : tableau [1 .. 10 ] de réels

98
 Schématiquement, on va représenter la variable t comme suit :

1 2 3 4 5 6 7 8 9 10
8.4 3.5 12 20 10 13.34 50 100 30.1 60.9

Dans la mémoire centrale, les éléments d’un tableau sont stockés de façon linéaire, dans des
zones contiguës.
Le tableau ci-dessus est de dimension 1, nous verrons un peu plus loin que l’on peut
représenter des tableaux à 2 dimensions, voire même plus.

99
L’élément n° I sera représenté par l’expression t[I].
Dans notre exemple, t[I] peut être traité comme une variable réelle. On dit que le tableau t est de
taille 10.

2 Création d’un tableau

La création d’un tableau consiste au remplissage des cases le composant. Cela peut se faire par
saisie, ou par affectation.
Par exemple, pour remplir le tableau t précédent, on peut faire :
t[1] := 8.4 ; t[2] := 3.5 ; … t[10] := 60.9 ;
Si on devait saisir les valeurs, il faudrait écrire :
Pour i := 1 à 10 faire
lire(t[i] );

3 Affichage d’un tableau

Afficher un tableau revient à afficher les différents éléments qui le composent. Pour cela, on le
parcourt (généralement à l’aide d’une boucle avec compteur) et on affiche les éléments un à un.

100
Exercice d’application
Ecrire un a l g o r i t h m e qui permet de créer un tableau d’entiers t1 de taille 20 par saisie, et
un tableau t2 de même taille en mettant dans t2[i]
le double de t1[i], i  {1, .., 20 }.
Type tab = tableau [1..20] d’entierr ;
variable t1, t2 : tab ;
i : entier ;
Debut
{ saisie de t1 }
Pour i :=1 à 20 faire
Debut
ecrire(‘donner t1[‘,i,’]:’)
lire(t1[i])
fin
{ création de t2 }
Pour i :=1 à 20 faire
t2[i] := 2*t1[i];
{ affichage de t2 }
Pour i :=1 à 20 faire
ecrire(‘t2[‘,i,’]=’, t2[i]);
FIN.

101
4 Traitement d’un tableau

Après avoir créé un tableau, on peut y effectuer plusieurs opérations comme le calcul de la
somme ou de la moyenne des éléments, la recherche du plus petit ou du grand élément du tableau, le test
d’appartenance d’un objet au tableau, …
Pour la suite, on considère un tableau
d’entiers t déclaré comme suit :
Variable t : tableau[1 .. n] d’entier ;
1. Somme des éléments d’un tableau

On effectue la somme des éléments du tableau t, le rpésultat est dans la variable S :

S0;
Pour i 1 to n faire S  S + t[i];
ecrire(‘la somme des éléments de t est:’, S);

2. Minimum d’un tableau

On cherche le plus petit élément du tableau t, le résultat est dans la variable min :
min <-- t[1] ;
Pour i :=2 à 10 faire
Si t[i] < min alors min := t[i];
ecrire(‘Le minimum des elements de t est:’, min) ; 102
4.3 Test d’appartenance

On cherche si l’entier x apartient à t, le résultat est mis dans la variable booléenne appartient :
appartient  false
for i1 to n faire
Si (t[i]=x) then
appartient := true;
Si (appartient) alors
ecrire(‘x appartient à t’)
sinon ecrire (‘x n’’appartient pas à t’);
On remarque que l’on peut arrêter les itérations (la recherche) si l’on rencontre l’élément x
dans t. Pour cela, il faut utiliser une boucle Tant Que ou Repeat:

i := 1;
Tant que (i<=n) et (t[i]<>x) faire
i:=i+1;
Si (i>n) alors
ecrire(‘x n’’appartient pas à t’)
sinon
ecrire(‘x appartient à t’);

103
 6 Les tableaux à deux dimensions
Pour traiter les notes obtenues par un étudiant à 10 épreuves on peut utiliser un tableau de 10 réels.

Pour traiter les notes obtenues par 5 étudiants, on pourrait utiliser 5 tableaux de 10 réels chacun. Mais
puisqu’on va effectuer très probablement les mêmes traitements sur ces tableaux, il est préférable de les
regrouper dans une seule variable qui sera un tableau de 5 lignes et 10 colonnes. Chaque élément de ce
tableau multidimensionnel sera identifié par deux indices : la position indiquant la ligne et la position
indiquant la colonne.

Déclaration :
variable t : tableau[1..5, 1..10] de reels ;

Pour accéder à l’élément se trouvant sur la ligne i et la colonne j, on utilise le terme t[i,j].

Exercice d’application
Ecrire un programme qui permet de créer (par saisie) et d’afficher un tableau t à deux dimensions
d’entiers de taille 3x5.

Type TAB_3_5 = tableau[1..3, 1..5] d’entier ;

variable t : TAB_3_5 ; i,j : entier ;
Debut
(* saisie de t *)
104
 Pour i :=1 to 3 faire
Pour j :=1 to 5 faire
debut
ecrire(‘donner t[‘,i,’,’,j,’]:’);
lire(t[i]);
fin;
(* affichage de t *)
Pour i :=1 to 3 faire
Début
Pour j :=1 to 5 faire
ecrire(t[i,j],’ ‘);
ecrire;
fin;
FIN.

105
Exemple de définition de types ensembles:

TYPE

EnsCar = set of char ;

Chiffre = set of 0 .. 9; (* 0 .. 9 est appelé sous-intervalle *)

JOUR = (dim, lun, mar, mer, jeu, ven, sam) ; (* JOUR est un type énuméré *)

Jours = set of JOUR ;

106
 Exercices proposés
Exercice 1:
Ecrire un programme qui permet de saisir des nombres entiers dans un tableau à deux dimensions
TAB (10, 20) et de calculer les totaux par ligne et par colonne dans des tableaux TOTLIG(10) et
TOTCOL(20).
Exercice 2 :
Un palindrome est un mot ou une phrase qui se peut se lire de la même façon de gauche à droite et de
droite à gauche. Par exemple:
"ANNA" et "ESOPE RESTE ICI ET SE REPOSE".
Proposer un programme qui permet de dire si un mot ou une phrase est un palindrome.
Exercice 3 :
On considère un tableau t (n,m) à deux dimensions.
Ecrire un programme qui calcule la somme et le produit des éléments de t.
Ecrire un programme qui affiche le plus petit élément de t et sa position.
Exercice 4 :
Ecrire un programme qui met à zéro les éléments d'un tableau à deux dimensions tels que l'indice de
ligne est égal à l'indice de colonne.

107
Exercice 5 :

Ecrire un programme qui permet de chercher une valeur x dans un tableau à deux dimensions

t (m,n). Le programme doit aussi afficher les indices ligne et colonne si x a été trouvé.

108
Listes et Boucles
(en python)

109
Listes
Une liste est vue comme une collection d’éléments séparés
par des virgules, l’ensemble étant enfermé dans des crochets

il est possible de changer les éléments individuels d’une

liste :

▪ Fonction len()
 >>> print(len(jour))
 7 110
Listes
Fonction del

Fonction append()

111
Accès aux éléments
Soit les listes
 >>> nombres = [15, 48, 20, 35]
>>> animaux = ["éléphant", "girafe", "rhinocéros", "gazelle"]
 >>> liste3 = [2000, "Bambey", 3.14, ["Ablaye", "Daouda", 1980]]
>>> >>> >>> >>> >>> >>> >>>
print(nombres[2 print(nombres[1: print(nombres[2: print(nombres[2: print(nombres[:2 print(nombres[- print(nombres[-
]) 3]) 3]) ]) ]) 1]) 2])

20 [48, 20] [20] [20, 35] [15, 48] 35 20

Notation
o la notation liste[i:j] désigne les éléments i à j-1 de la liste
o la notation [i:] désigne les éléments i et suivants
o la notation [:i] désigne les éléments 0 à i-1
112
Les listes sont modifiables
Modification par affectation directe
o Exemple1:
 >>> nombres[0] = 12
 >>> nombres
 [12, 48, 20, 35]
o Exemple2:
 >>> liste3[3][1] = "Dahirou"
>>> liste3
 [2000, "Bambey", 3.14, ["Ablaye", "Dahirou", 1980]]

113
Les listes sont modifiables
Les listes peuvent être  Exemples
modifiées animaux = ["éléphant", "girafe",
"rhinocéros", "gazelle"]

animaux.append("lion")
o Ajouter un élément à la fin

animaux.insert(0, "hippopotame")
o Ajouter un élément à une
position donnée

animaux.remove("gazelle")
o Enlever un élément

del animaux[-2]
o Enlever unQue contient
élément à unealors la liste animaux ?
position donnée
114
Les listes sont modifiables
 Exemples
o Ajouter tous les éléments animaux.extend(["lion",
d'une autre liste "buffle"])

o Trier une liste (ordre

numérique / alphabétique) animaux.sort()

o Concaténer deux listes

animaux + ["lion", "buffle"]
o Inverser l'ordre d'une liste
animaux.reverse()
o Cloner une liste
Lcopie=list(animaux)
115
Listes (Exemples (1))
Supprimer une entrée avec son index avec la fonction del
>>> liste = ["a", "b", "c"]
>>> del liste[1]
>>> liste
['a', 'c']
❑ Supprimer une entrée avec sa valeur avec la méthode remov
>>> liste = ["a", "b", "c"]
>>> liste.remove("a")
>>> liste
['b', 'c']
116
Listes (Exemples (2))
❑ Inverser les valeurs d'une liste avec la méthode reverse
>>> liste = ["a", "b", "c"]
>>> liste.reverse()
>>> liste
['c', 'b', 'a']
❑ Compter le nombre d'items d'une liste
>>> liste = [1,2,3,5,10]
>>> len(liste)
5

117
Listes (Exemples (3))
❑ Compter le nombre d'occurrences d'une valeur
>>> liste = ["a","a","a","b","c","c"]
>>> liste.count("a")
3
>>> liste.count("c")
2
❑ Trouver l'index d'une valeur
>>> liste = ["a","a","a","b","c","c"]
>>> liste.index("b")
3
118
Listes (Exemples (4))
❑ Trouver un item dans une liste avec le mot clé in
>>> liste = [1,2,3,5,10]
>>> 3 in liste
True
>>> 11 in liste
False
❑ La fonction range
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

119
Listes (Exemples (5))
❑ Agrandir une liste
>>> x = [1, 2, 3, 4]
>>> y = [4, 5, 1, 0]
>>> x.extend(y)
>>> print x
[1, 2, 3, 4, 4, 5, 1, 0]
❑ Additionner deux listes
>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> x + y
[1, 2, 3, 4, 5, 6]

120
Listes (Exemples (6))
❑ Multiplier une liste:
>>> x = [1, 2]
>>> x*5
[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
❑ Initialiser une liste:
 >>> [0] * 5
 [0, 0, 0, 0, 0]

121
Listes (Exemples (7))
❑ Obtenir le plus grand é
́ lément d’une liste, ou le plus petit :
 >>> max([2, 1, 4, 3])
 4
 >>> min([2, 1, 4, 3])
 1
❑ Faire la somme d’une liste:
 >>> sum([2, 1, 4, 3])
 10

122
Listes et chaînes de caractères
Couper une chaîne de caractères en une liste de
chaînes : split
split sans argument : couper sur les espaces, sauts de ligne,
tabulations
>>> "Une phrase avec des mots".split()
["Une", "phrase", "avec", "des", "mots"]
Split avec argument : couper sur un séparateur donné
>>> "Plan-Jaxaay".split("-")
["Plan", "Jaxaay"]

Assembler une liste de chaînes en une seule chaîne :

join
>>> "/".join(["répertoire", "sous_répertoire", "fichier"])
123
Boucles
Une boucle permet d'exécuter plusieurs fois les mêmes
commandes
▪ La boucle parcourt une séquence

for variable in sequence :

commande répétée plusieurs fois
commande répétée plusieurs fois
suite du programme (exécuté une seule fois)

124
Boucles

▪ La séquence peut être :

une variable
Chaîne de caractères
Liste, ensemble, tuple
...
une liste d'indice générée avec la fonction range()
range(5) => [0, 1, 2, 3, 4]

125
Boucles

▪ Exemple de séquence de type chaine de caractères:

o L’instruction for permet donc d’ écrire des boucles, dans

lesquelles l’itération traite successivement tous les
éléments d’une séquence donnée.
o L’argument end =" " signifie que vous souhaitez remplacer
le saut à la ligne par un simple espace. Si vous supprimez
cet argument, les nombres seront affichés les uns en-
dessous des autres (sur la verticale). 126
Boucles
Exemple de séquence de type Liste

animaux = ["éléphant", "biche", "rhinocéros", "brochet"]

environnements = ["savane", "forêt", "savane", "rivière"]
Afficher un animal par ligne
for animal in animaux : print(animal)
print("C'est fini !")
Afficher un animal par ligne avec son numéro
for i in range(len(animaux)) :
print("Numéro " + str(i) + " : " + animaux[i])
print("C'est fini !")
Afficher un animal par ligne avec son environnement
for i in range(len(animaux)) :
print(animaux[i] + " dans la " + environnements[i])
127
Boucles (boucler sur plusieurs listes avec zip)

Exemples
animaux = ["éléphant", "biche", "rhinocéros", "brochet"]
environnements = ["savane", "forêt", "savane", "rivière"]

 for animal, envir in zip(animaux, environnements):

 print(animal + " vit dans " + envir)
Ce qui donne :
 ́éléphant vit dans savane
 biche vit dans forêt
 Rhinocéros vit dans savane
 brochet vit dans rivière

128
Boucles (boucler sur plusieurs listes avec des
boucles imbriquées)

Exemples
animaux = ["éléphant", "biche", "rhinocéros", "brochet"]
environnements = ["savane", "forêt", "rivière"]

 for animal in animaux:

 for envir in environnements:
 print (animal+ " dans " + envir )
Ce qui donne :
 éléphant dans savane ́
rhinocéros dans savane
 éléphant dans forêt ́ rhinocéros dans forêt
 éléphant dans rivière rhinocéros dans rivière
 biche dans savane brochet dans savane
biche dans forêt brochet dans forêt
biche dans rivière brochet dans rivière

129
Boucles
break permet d'interrompre la boucle
continue permet de passer immédiatement à l'élément
suivant
La boucle for peut aussi avoir un bloc else :
for variable in liste :
if condition d'exclusion :
continue
commande répétée plusieurs fois
if condition :
commande exécutée si condition satisfaite
break
else :
commande exécutée si condition jamais satisfaite 130
Boucles
continue : permet de passer immédiatement à l'élément
suivant
for variable in liste :
if condition d'exclusion : continue
commande répétée plusieurs fois
for i in range(10):
if i == 2:
continue
print(i)

131
Boucles
break et else :
break permet d'interrompre la boucle
for i in range(10):
if i == 2:
break

print(i)
le bloc else est exécuté si la boucle est allée jusqu'au bout (sans rencontrer
break)
for variable in liste :
commande répétée plusieurs fois
if condition :
commande exécutée si condition satisfaite
break
else :
commande exécutée si condition jamais satisfaite
132
Boucles
La boucle while dure tant qu'une condition est satisfaite :
while condition :
commande répétée plusieurs fois
suite du programme (la boucle est finie)

Elle peut aussi avoir un break et un else

Exemple: la liste des carrés et des cubes des nombres de 1 à 12

Afficher les dix premiers termes d’une suite appelée « Suite

de Fibonacci »
133
Exercices
Exo1 : Afficher les dix premiers termes d’une suite
appelée « Suite de Fibonacci ». Il s’agit d’une suite de
nombres dont chaque terme est égal à la somme des deux
termes qui le précédent

Résultat

134
Exercices
Exo 2: Ecrivez un programme qui affiche les 20 premiers
termes de la table de multiplication par 7.
Exo 3: Ecrivez un programme qui affiche la suite de
symboles suivante
 *
 **
 ***
 ****
 *****
 ******
 ******* 135
Exercice : le dot-plot
 Exo 4:
Le dot-plot est une technique très simple pour analyser
visuellement deux séquences d'ADN
Principe :
Mettre une séquence à l'horizontal et l'autre en vertical, sur une
matrice
Mettre un X dans les cases où les bases sont les mêmes dans
les deux séquences

Faire un programme Python pour générer un

dot-plot
Les séquences d'ADN sont des chaînes de
caractères
On générera le dot-plot ligne par ligne
et on écrira chaque ligne avec print() 136
Exercice : Nombres paires d’une
liste
Exo 5 : Garder seulement les nombres pairs d’une liste :
 nombres = [1, 4, 7, 8, 12, 15]
 nombres_pairs = [ ] …????
Exo 6: Soient les listes suivantes :
 t1 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
 t2 = ['Janvier', ’Février', 'Mars', 'Avril', 'Mai', 'Juin', 'Juillet',
'Août', 'Septembre', 'Octobre', 'Novembre', 'Décembre']
 Ecrivez un petit programme qui crée une nouvelle liste
t3. Celle-ci devra contenir tous les éléments des deux
listes en les alternant, de telle manière que chaque nom
de mois soit suivi du nombre de jours correspondant :
['Janvier',31, 'Février',28, 'Mars',31, etc...]. 137
Listes procédurales (comprehension list)
Permet de créer une liste sans donner les éléments un à un mais en donnant une
boucle pour la remplir
>>> [len(mot) for mot in "Un texte avec des mots".split()]
[2, 5, 4, 3, 4]
sum() retourne la somme d'une liste
>>> sum(len(mot) for mot in "Un texte avec des mots".split())
18

Plusieurs boucles peuvent être combinées

print(" " + seq1)
print("\n".join(base2 + "".join([" ", "X"][base1 == base2] for base1 in

seq1) for base2 in seq2 ))

=> Plusieurs approches différentes pour faire la même chose

Mais en général, une approche est plus simple et claire ! 138
 Chapitre 2:
Structures de données en python

139
Dictionnaires
Les types de données composites que nous avons abordés
jusqu’à présent (chaines, listes) étaient tous des séquences,
c’est à dire des suites ordonnées d’éléments.
Dans une séquence, il est facile d’accéder à un élément
quelconque à l’aide d’un index (un nombre entier), mais à la
condition express de connaître son emplacement.
Les dictionnaires que nous découvrons ici constituent un
autre type composite.
Ils ressemblent aux listes dans une certaine mesure (ils sont
modifiables comme elles), mais ne sont pas des séquences.
En revanche, nous pourrons accéder à n’importe lequel
d’entre eux à l’aide d’un index spécifique que l’on appellera
une clé́, laquelle pourra être alphabétique, numérique, ou
même d’un type composite sous certaines conditions.
140
Dictionnaires
Un tableau associatif qui fait correspondre des valeurs à des
clefs : dict
dict = { clef1 : valeur1, clef2 : valeur2, … }
>>> définitions = {"os" : "système d'exploitation", "python" : "langage de
programmation", "dictionnaire" : "association clef-valeur"}
>>> fiche = {"nom":"Gueye","prenom":"Dahirou"}

>>> materiel = {}
>>> materiel['computer'] = 'ordinateur'
>>> materiel['mouse'] ='souris’
>>> materiel['keyboard'] ='clavier'
>>> print(materiel)
{'computer': 'ordinateur', 'keyboard': 'clavier', 'mouse': 'souris'}
141
Opérations sur les dictionnaires
La recherche est optimisée dans les dictionnaires (table de
hachage)
Principales opérations :
▪ Nombre de clés ou de valeur : len(definitions) -> 3

▪ Obtenir la valeur associée à une clé: definitions["python"] -> langage de

programmation
▪ Ajouter un couple de clé: valeur: definitions["flottant"] = "nombre décimal"

▪ supprimer une clé et la valeur associée: del definitions["os"]

▪ Test d’appartenance

>>> if "os" in definitions:

... print("Intègre un système")
... else:
... print("Pas de système. Sorry") ...
Pas de systèmes. Sorry
142
Opérations sur les dictionnaires
Récupérer une valeur dans un dictionnaire: get
>>> data = {"os": "systeme", "age": 30}

>>> data.get("os")

'système’

>>> data.get("nom")

None

Méthode keys()
 >>> print(data.keys())
Vérifier la présence d'une clé : haskey
 >>> data.has_key("os")
True

Méthode values()
 >>> print(data.values())
Méthode update permet de fusionner deux dictionnnaires
 >>> a.update(b)

143
Dictionnaires et boucles
Une boucle sur un dictionnaire parcourt les clefs :
for clef in définitions:
print(clef, " : ", définitions[clef])

Récupérer les clefs

for clef in définitions.keys(): print (clef)

Récupérer les valeurs

for valeur in définitions.values() :
print(valeur)

Récupérer les couples (clés:valuers)

for clef, valeur in définitions.items() :
print(clef, " : ", valeur)

Dictionnaire procédural :
quadruple = { i : 4 * i for i in range(10) }
144
Construction d’un histogramme à l’aide d’un
dictionnaire

Supposons par exemple que nous voulions établir

l’histogramme qui représente la fréquence d’utilisation de
chacune des lettres de l’alphabet dans un texte donné.
Méthode:
o Pour chacun de ces caractères, nous interrogeons le
dictionnaire à l’aide de la méthode get(), en utilisant le caractère
en guise de clé́ , afin d’y lire la fréquence déjà̀ mémorisée pour
ce caractère.

o Si cette valeur n’existe pas encore, la méthode get() doit

renvoyer une valeur nulle. Dans tous les cas, nous
incrémentons la valeur trouvée, et nous la mémorisons dans le
dictionnaire, à l’emplacement qui correspond à la clé́

145
Result
 >>> texte="Master SI-SR du département TIC de SATIC-
UADB: Cours de python décembre 2021"
 >>> lettres={}
 >>> for c in texte:
 ... lettres[c]=lettres.get(c,0)+1
 ...
 >>> print(lettres)
 {'M': 1, 'a': 2, 's': 2, 't': 4, 'e': 7, 'r': 4, ' ': 11, 'S': 3, 'I': 3,
'-': 2, 'R': 1, 'd': 5, 'u': 2, 'é': 2, 'p': 2, 'm': 2, 'n': 2, 'T':
2, 'C': 3, 'A': 2, 'U': 1, 'D': 1, 'B': 1, ':': 1, 'o': 2, 'y': 1, 'h':
1, 'c': 1, 'b': 1, '2': 2, '0': 1, '1': 1}
 >>>
▪ On peut utiliser la méthode sort() pour trier notre
histogramme 146
Remarques sur les clés

Les clés ne sont pas nécessairement des nombres ou chaines de

caractères
En fait nous pouvons utiliser en guise de clés n’importe quel type de
données non modifiables : des entiers, des réels, des chaînes de
caractères, et même des tuples.
Considérons par exemple que nous voulions répertorier les arbres
remarquables situés dans un grand terrain rectangulaire
Nous pouvons pour cela utiliser un dictionnaire, dont les clés seront
des tuples indiquant les coordonnées x,y de chaque arbre :
>>> arb = {}
>>> arb[(1,2)] = 'Peuplier'
>>> arb[(3,4)] = 'Platane'
>>> arb[6,5] = 'Palmier'
>>> arb[5,1] = 'Cycas'
>>> arb[7,3] = 'Sapin'
 >>> print(arb[1,2])
 Peuplier 147
Les dictionnaires ne sont pas des séquences

Les clés ne sont pas nécessairement des nombres ou chaines

de caractères

les éléments d’un dictionnaire ne sont pas disposés dans un

ordre particulier. Des opérations comme la concaténation et
l’extraction (d’un groupe d’éléments contigus) ne peuvent donc
tout simplement pas s’appliquer ici.
>>> print(arb[1:3])

***** Erreur : TypeError

Vous avez vu également qu’il suffit d’affecter un nouvel

indice (une nouvelle clé) pour ajouter une entrée au
dictionnaire. Cela ne marcherait pas avec les listes: 148
Les dictionnaires ne sont pas des séquences

>>> invent ={"oranges":274, "poires":137,

"bananes":312}
>>> invent['cerises'] = 987
>>> print(invent)

{'oranges': 274, 'poires': 137, 'bananes': 312, 'cerises': 987}

>>> liste =['jambon', 'salade', 'confiture', 'chocolat']
>>> liste[4] ='salami'
***** IndexError: list assignment index out of range
*****

149
Contrôle du flux d’exécution à l’aide d’un dico

Il arrive fréquemment que l’on ait à diriger l’exécution d’un

programme dans différentes directions, en fonction de la
valeur prise par une variable.
Vous pouvez bien évidemment traiter ce problème à l’aide
d’une série d’instructions if - elif - else , mais cela peut
devenir assez lourd et inélégant
 materiau = input("Choisissez le matériau : ")
 if materiau == 'fer': fonctionA()
 elif materiau == 'bois': fonctionC()
 elif materiau == 'cuivre': fonctionB()
 elif materiau == 'pierre': fonctionD()
 elif ... etc ... 150
Contrôle du flux d’exécution à l’aide d’un dico
materiau = input("Choisissez le matériau : ")
dico = {'fer':fonctionA,
'bois':fonctionC,
'cuivre':fonctionB,
'pierre':fonctionD
}
 Les deux se résument:
dico[materiau]
 On peut améliorer la technique avec get()

dico.get(materiau, fonctAutre)()

151
Tuples
Du point de vue de la syntaxe, un tuple est une
collection d’éléments séparés par des virgules :
Très proches des listes. La différence est qu’ils ne sont
pas modifiables
Les tuples s'écrivent entre ou sans parenthèses
>>> triplet = (1, 2, 3)
>>> couple = (1, 2)
>>> tup = 'a', 'b', 'c', 'd', 'e'
>>> print(tup)
('a', 'b', 'c', 'd', 'e')

152
Tuples
Si un seul élément, il faut mettre une virgule après
>>> tuple_a_un_element = (1,)

Les parenthèses ne sont pas obligatoires

 >>> mon_tuple = 1, 2, 3
Afficher une valeur d’un tuple
>>> mon_tuple[0]
1

153
Tuples
Les tuples ne sont pas modifiables
=> ils peuvent servir de clef dans les dictionnaires
C'est leur principale utilisation

 Changement de valeur
>>> mon_tuple[1] = "ok"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

154
Tuples
Le tuple permet une affectation multiple
>>> v1, v2 = 11, 22
>>> v1
11
>>> v2
22

Il permet également de renvoyer plusieurs valeurs lors

d'un appel d'une fonction:
 >>> def renvoyer_nom():
 ... return "Dahirou", "Gueye"
 ...
 >>> renvoyer_nom()
 ('Dahirou', 'Gueye')

155
Opérations sur les tuples
NB: Les opérations que l’on peut effectuer sur des tuples
sont syntaxiquement similaires à celles que l’on effectue
sur les listes, si ce n’est que les tuples ne sont pas
modifiables :
 >>> print(tup[2:4])
('c', 'd')
 >>> tup[1:3] = ('x', 'y')
 ==> ***** erreur ! *****

>>> tup = ('bambey') + tup[1:]
>>> print(tup)
('bambey', 'b', 'c', 'd', 'e') 156
Opérations sur les tuples
Les opérateurs de concaténation et de multiplication
fonctionnent aussi. Mais puisque les tuples ne sont pas
modifiables, vous ne pouvez pas utiliser avec eux, ni
l’intruction del ni la méthode remove() :
 >>> tu1, tu2 = ("a","b"), ("c","d","e")
>>> tu3 = tu1*4 + tu2
>>> tu3
('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b', 'c', 'd', 'e')
 >>> for e in tu3:
 ... print(e, end=":")
 ...
 a:b:a:b:a:b:a:b:c:d:e: 157
Opérations sur les tuples
 >>> del tu3[2]
 Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
 TypeError: 'tuple' object doesn't support item
deletion

158
Ensembles
Ensembles (set) au sens mathématique, proches des
listes
Les ensembles ne sont pas ordonnés
Les doublons sont automatiquement enlevés des ensembles

Contrairement aux séquences comme les listes et les

tuples dans lesquels chaque élément est indexé
Les ensembles s'écrivent entre accolades
>>> {1, 1, 2, 3}
{1, 2, 3}
>>> {1, 1, 2, 3} == {2, 3, 1}
True
>>> my_set = {1.0, "Hello", (1, 2, 3)}
159
Ensembles
Les opérations ensemblistes sont disponibles, ex :
Exemple 1:
>>> {1, 2, 3}.intersection({2, 3, 4})
{2, 3}
Exemple2:
>>> s1 = set([4, 6, 9])
>>> s2 = set([1, 6, 8])
>>> s1.intersection(s2)
set([6])

Convertir une liste en ensemble : set([1, 2, 3])

160
Ensembles
Union: Somme des éléments de deux ensembles
>>> s1 = set([4, 6, 9])
>>> s2 = set([1, 6, 8])
>>> s1.union(s2)
set([1, 4, 6, 8, 9])

>>> s1 | s2
set([1, 4, 6, 8, 9])

161
Ensembles
Un "frozenset" (ensemble figé) se comporte comme un
ensemble,
Sauf qu'il est immutable, c'est-à-dire qu'une fois créé, on ne
peut pas le mettre à jour
Il dispose donc des mêmes fonctions que le type "set", mais
sans "add", "update", "pop", "remove", "discard" et "clear".
This datatype supports methods like copy(), difference(),
intersection(), isdisjoint(), symmetric_difference() and union()
De plus, ils sont hachables, ce qui leur permet de faire partie
d'ensembles.
Ensemble immutable : frozenset([1, 2, 3]) (clef de dictionnaire)

162
Ensembles
>>> fs = frozenset([2, 3, 4])
>>> s1 = set([fs, 4, 5, 6])
>>> s1
{frozenset({2, 3, 4}), 4, 5, 6}
>>> fs.intersection(s1)
frozenset([4])
Ou
frozenset({4})
>>> fs.add(6)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'
>>>

163
Programmation orientée objet
en Python

Chapitre 3:
Les Fonctions

164
Fonctions
Une fonction (ou function) est une suite d'instructions
que l'on peut appeler avec un nom.
Les fonctions sont créées avec l'instruction def :
def nom_fonction(nom_paramètre1, nom_paramètre2,…) :
corps de la fonction
return valeur de retour
Exemple1:

 >>> def indique_mon_age():

 ... return 25
Exemple2:
def table_de_multiplication(nombre):
for i in range(1, 11):
print(i, "x", nombre, "=", i * nombre)


165
Fonctions
Les fonctions sont appelées avec des parenthèses
nom_fonction(valeur_paramètre1, valeur_paramètre2,…)

 >>> indique_mon_age()
 25
>>> table_de_multiplication(7)
(1, 'x', 7, '=', 7)
(2, 'x', 7, '=', 14)
(3, 'x', 7, '=', 21)
(4, 'x', 7, '=', 28)
(5, 'x', 7, '=', 35)
(6, 'x', 7, '=', 42)
(7, 'x', 7, '=', 49)
(8, 'x', 7, '=', 56)
(9, 'x', 7, '=', 63)
(10, 'x', 6, '=', 70)

166
Fonctions
Exemple 3:

def affiche_carre(n):
print(" le carre de" , n "vaut", n*n)
Qui s’utiliserait comme ceci:
affiche_carre(12)
Le carre de 12 vaut 144
Mais en fait il serait plus intéressant de retourner quelque chose
Def carre(n):
return n*n
If carre(8) <= 100:
print (" petit appartement ")
167
Fonctions
Possibilité de retourner plusieurs valeurs (à l'aide d'un
tuple) :
>>> def extrémités(liste) :
… return liste[0], liste[-1]
>>> i, j = extrémités(range(10))
>>> i
0
>>> j
9

Des variables locales peuvent être définies à l'intérieur

de la fonction
def calcul_compliqué(x, y):
résultat_intermédiaire = x + y
résultat_final = résultat_intermédiaire + 1
return résultat_final 168
Fonctions
Les paramètres peuvent avoir une valeur par défaut
On parle de paramètres optionnels, par exemple :
def table_de_multiplication(nombre, début = 1, fin = 10):
for i in range(début, fin):
print(i, "x", nombre, "=", i * nombre)
Si la valeur par défaut doit être calculée à partir d'autres valeurs :
def créer_utilisateur(nom, login = None) :
login = login or nom login vaut par défaut la valeur de nom

Les paramètres d'une fonction peuvent être nommés lors de

l'appel, ce qui permet de les passer dans le désordre :
résultat = nom_fonction (paramètre2 = valeur_paramètre 2, paramètre1 =
valeur_paramètre 1)
Exemple: table_de_multiplication(nombre, fin = 20)
169
Fonctions
L’opérateur splat
 L'opérateur splat : * est très souvent utilisé en python.
 def ma_function(*var)
 def ma_function(**var)

 ma_function(*var)
 ma_function(**var)

170
Fonctions
Une liste en paramètre
 Exemple 1: On peut récupérer les valeurs renseignées via une liste:
 >>> def additionne_moi(*param):
 ... return param[0] + param[1] + param[2]
 ...
 >>> additionne_moi(10, 20, 30)
 60
 L'utilisation de l'étoile permet de passer par une liste:
 >>> data = [1, 2, 3]
 >>> additionne_moi(*data)
 6

171
Fonctions
Utilisez un dictionnaire pour les paramètres
 Vous pouvez utiliser un dictionnaire en paramètres. Pour cela, vous
devez ajouter une double étoile: **

 >>> def ma_fiche(**parametres):

 ... return parametres["prenom"]
 ...
 >>> ma_fiche(prenom="Dahirou")
 'Dahirou'

172
Fonctions
Utilisation de splat dictionnaire au niveau des appels de fonctions
 Prenons l'exemple de cette fonction:
 >>> def test(firstname="", lastname=""):
 ... return "{} {}" .format(firstname, lastname)
 Créons notre dictionnaire:
 >>> data = {'firstname':'Dahirou', 'lastname':'Gueye'}
 Et envoyons notre variable avec une étoile *
 >>> test(*data)
 'lastname firstname’
 Puis avec deux étoiles **
 >>> test(**data)
 ’Dahirou Gueye'

173
Fonctions
 Exemple 2 paramètres liste et dictionnaire :
Une fonction peut avoir un nombre de paramètre variable,
nommé ou non
>>> def fonction_à_paramètres_variables(*args, **kargs): kargs = keyword
arguments
… print(args, kargs)
>>> fonction_à_paramètres_variables(1, 2, 3, param = 4)
(1, 2, 3) { "param" : 4 }

Cette syntaxe peut aussi s'utiliser lors de l'appel d'une

fonction
args = [5, 1, 10]
table_de_multiplication(*args)
kargs = { "nombre" : 5, "début" : 1, "fin" : 10 }
table_de_multiplication(**kargs)
sont équivalents à :
table_de_multiplication(5, 1, 10) 174
Fonctions
Portée des variables (variable globale et variable locale)
 Une variable déclarée à la racine d'un module est visible
dans tout ce module. On parle alors de variable globale.
 >>> x = "hello"
 >>> def test():
 ... print x
 ...
 >>> test() hello

175
Fonctions
 Et une variable déclarée dans une fonction ne sera visible
que dans cette fonction. On parle alors de variable locale.
 >>> x = False
 >>> def test():
 ... x = "hello"
 ... >>> test()
 >>> x
 False

176
Fonctions
En Python, les fonctions sont des objets
>>> def nombre_suivant(x) : return x + 1
>>> variable_fonction = nombre_suivant
>>> print(variable_fonction(5))
6

177
Fonctions prédéfinies
Il existe des fonctions internes à python:
 abs(x) Retourne une valeur absolue
 >>> abs(-1)
 1
 all(iterable) Retourne True si tous les éléments d'un élément itérable sont True
 >>> liste = [True,True,True,1]
 >>> all(liste)
 True
 any(iterable) Retourne True si au moins un élément d'un élément itérable est True
 >>> liste = [True, False, True]
 >>> any(liste)
 True

178
Fonctions prédéfinies
 bin(x) Convertit un integer en chaine de caractères
binaires.
 >>> bin(101)
 '0b1100101’
callable(object) Determine si un objet est callable.
 >>> callable("A")
 False
 >>> callable(int)
 True
 str.capitalize() La méthode capitalize permet de mettre
une chaine de caractères au format Xxxxx
 >>> "oLIviER".capitalize() 'Olivier’ 179
Fonctions prédéfinies
 choice([]) Retourne une valeur d'une liste aléatoirement.
 >>> import random
 >>> random.choice([1,2,3,4,5])
3
 >>> random.choice([1,2,3,4,5])
2
str.count(string) La méthode count compte le nombre
d'occurences de la recherche demandée.
>>> "ifoad".count("o")
1
180
Fonctions prédéfinies
str.endswith(str) La méthode endswith teste si une chaine de caractères se termine
par la chaine demandée
>>> a = "olivier"
>>> a.endswith("r")
True
>>> a.endswith("er")
True
>>> a.endswith("é")
False
str.find(string) La méthode find trouve la première occurence de la recherche
demandée.
>>> "sagna".find("a")
1

181
Fonctions prédéfinies
help(element) Cette fonction vous retourne des informations sur l'utilisation de
l'élément qui vous intéresse.
Hex Convertit un nombre en valeur hexadécimale.
>>> hex(16)
'0x10’
str.islower() Retoune True si tous les caractères sont en minuscule.
>>> "olivier".islower() True
>>> "Olivier".islower() False
str.isspace() Retoune True si il n'y a que des espaces et au moins un caractère.
>>> " ".isspace() True
>>> "jean louis".isspace() False
>>> " ".isspace() True

182
Fonctions prédéfinies
str.istitle() Retourne True si la chaine a un format titre.
>>> "Titre".istitle() True
>>> "TitrE".istitle() False
>>> "Titre de mon site".istitle() False
>>> "Titre De Mon Site".istitle() True
str.isupper() Retourne True si tous les caractères sont en majuscule et qu'il y a au
moins un caractère.
>>> "OLIVIER".isupper()
True
>>> "Olivier".isupper()
False
>>> "OlivieR".isupper()
False

183
Fonctions prédéfinies
len(s) Retourne le nombre d'items d'un objet.
>>> len([1,2,3])
3
>>> len("olivier")
7
 str.lower() La méthode lower permet de mettre en minuscule une chaine de caractères.
 >>> "IFOAD".lower()
 'ifoad’
 randint() Retourne un int aléatoire.
 >>> import random
 >>> random.randint(1,11)
 5

184
Fonctions prédéfinies
random() Retourne une valeur aléatoire.
>>> import random
>>> random.random()
0.9563522652738929
str.replace(string, string) La méthode replace remplace un segment d'une chaine de
caractères par une autre:
>>> "Tic".replace("ic","IC")
'TIC’
reverse() La méthode reverse inverse l'ordre d'une liste.
>>> x = [1,4,7]
>>> x.reverse()
>>> x
[7, 4, 1]

185
Fonctions prédéfinies
shuffle([]) Mélange aléatoirement une liste.
>>> import random
>>> x = [1,2,3,4,5]
>>> random.shuffle(x)
>>> x
[2, 5, 4, 1, 3]
list.sort() La méthode sort permet de trier une liste.
>>> l = [5,1,4,2,10]
>>> l.sort()
>>> l
[1, 2, 4, 5, 10]

186
Fonctions prédéfinies
sorted(iterable) Tri un élément itérable.
>>> sorted([3,2,12,1])
[1, 2, 3, 12]
str.split(séparateur) La méthode split transforme une chaine de caractères en liste.
>>> "olivier:sagna".split(":")
['olivier', ’sagna']
sum(iterable [,start]) Additionne les valeurs d'un élément itérable.
>>> sum([1,2,3])
6

187
 Chapitre 3:
La Récursivité

188
Introduction
La récursivité est une technique de
programmation où une fonction s'appelle elle-
même pour résoudre un problème en le divisant
en sous-problèmes plus petits. Une fonction
récursive peut être vue comme une solution
naturelle pour des problèmes qui ont une
structure répétitive.

189
Principe de base
Une fonction récursive doit toujours avoir :
 Un cas de base (condition d'arrêt) :
C'est une condition qui permet d'arrêter
l'exécution de la récursion. Sans cela, la
fonction s’appellerait indéfiniment, entraînant
une erreur de dépassement de la pile (stack
overflow).

190
Principe de base
 Un appel récursif :
La fonction s'appelle elle-même en réduisant
progressivement la taille du problème pour se
rapprocher du cas de base.

191
Illustration
Un exemple simple de récursivité est le calcul
de la factorielle d'un nombre. La définition
mathématique de la factorielle est :
𝒏! = 𝒏 ∗ 𝒏 − 𝟏 ∗ 𝒏 − 𝟐 ∗ ⋯ ∗ 𝟏
Avec la relation de récurrence :
𝒏! = 𝒏 ∗ 𝒏 − 𝟏 !
et la condition de base :
𝟎! = 𝟏

192
Exemples en Algorithmique
(Pseudo-code)
Nous allons maintenant écrire des algorithmes
récursifs en pseudo-code.
Factorielle d'un Nombre
Fonction Factorielle(n)
Si n = 0 Alors
Retourner 1 // Cas de base
Sinon
Retourner n * Factorielle(n – 1) // Appel récursif
Fin Fonction

193
Exemples en Algorithmique
(Pseudo-code)
Explication :
 Si n = 0, on retourne 1 (cas de base).
 Sinon, on calcule n × Factorielle(n - 1).

194
Exemples en Algorithmique
(Pseudo-code)
Factorielle(5) → 5 × Factorielle(4)
→ 5 × (4 × Factorielle(3))
→ 5 × 4 × (3 × Factorielle(2))
→ 5 × 4 × 3 × (2 × Factorielle(1))
→ 5 × 4 × 3 × 2 × (1 × Factorielle(0))
→5×4×3×2×1
→ 120

195
Implémentation en python
Nous allons maintenant coder ces exemples
en Python.
Exemple 1: Factorielle d'un Nombre
def factorielle(n):
if n == 0: # Cas de base
return 1
return n * factorielle(n - 1) # Appel récursif

print(factorielle(5)) # Affiche 120

196
Exemple 2: Somme des n premiers
entiers
Somme des chiffres d’un nombre
Écrire une fonction récursive qui prend un
nombre entier positif et retourne la somme de
ses chiffres.
def somme(n):
if n == 0:
return 0

return n + somme(n-1)

197
Exemple 3: Multiplication par addition
successive
Multiplication avec addition successive

def multiplication(a, b):

if a == 0 or b == 0:
return 0

return a + multiplication(a, b-1)

198
Exemple 3: Somme de deux entiers a et b
Astuce solution 1: a + b= a+(b-1) +1
Som (a, b: entier): entier
Début
Si b=0 alors
retourner (a)
Sinon
retourner (som(a, b-1)+1)
FIN
Implémenter en python
199
Exemple 3: Somme de deux entiers a et b
Astuce solution 2: a + b= (a-1)+b+1
Ecrire l’algo récursif approprié
Coder-le en python

200
Exemple 4: Produit de deux entiers a et b
Astuce solution 1: a × b= a ×(b-1)+a
Prod (a, b: entier): entier
Début
Si a=0 ou b=0 alors
retourner (0)
Sinon
retourner (Prod(a, b-1)+a
FIN
Implémenter en python
201
Exemple 4: Produit de deux entiers a et b
Astuce solution 2: a × b= (a-1)×b+b

Réécrire l’algo récursif associé

Coder-le en python

202
Exercices
Exercice 1 : Calcul de la puissance
Écrire une fonction récursive qui calcule a^b avec la relation
suivante : 𝑎𝑏 = 𝑎 ∗ 𝑎𝑏−1
Cas de base : 𝑎0 = 1
Exercice 2 : Le reste de la division de a par b
Technique: On prend a et soustrait autant b; la dernière
valeur qui reste correspond au résultat
Exercice 3 : Plus grand commun diviseur entre a et b (a
et b deux entiers positifs)
Sachant que le pgcd ne peut pas dépasser le minimum entre
a et b, c’est-à-dire une valeur comprise entre 1 et le
minimum de a et b.
Astuce: Recherche successif du premier diviseur
commun i entre a et b
On va utiliser un indice qui commence à partir de min (a, b)
Cas de base: (Cas d’arrêt)
Si (i divise a et b) : PGCD(a, b, i) = i
Cas général:
203
Sinon: PGCD (a, b, i)=(a, b, i-1)
Chapitre 4:
Les Fichiers

204
Fichiers
▪ il est temps que nous apprenions à séparer les données,
et les programmes qui les traitent, dans des fichiers
différents.
▪ Pour que cela devienne possible, nous devrons doter nos
programmes de divers mécanismes permettant de créer
des fichiers, d'y envoyer des données et de les récupérer
par après.
▪ Une manière de garder des données de manière
pérenne est de les stocker dans des fichiers.

205
Fichiers
 Editer un fichier
o Pour éditer un fichier en python on utilise la fonction
open .
o Cette fonction prend en premier paramètre le chemin
du fichier (relatif ou absolu) et en second paramètre le
type d'ouverture
Chemin relatif / chemin absolu
o Un chemin relatif est un chemin qui prend en compte
l'emplacement de lecture.
o Un chemin absolu est un chemin complet qui peut être
lu quelque soit l'emplacement de lecture.
206
Fichiers
Les fichiers sont ouverts avec la fonction open():
fichier = open("chemin/nom_du_fichier", mode)
fichier = open("/tmp/test.txt") # lecture (r) mode
texte (valeur par défaut)
fichier = open("/tmp/test.txt", "w") # écrire (w) mode
texte
fichier = open("/tmp/test.bin", "rb") # lecture (r) mode
binaire (b)
fichier = open("/tmp/test.bin", "wb") # écrire (w) mode
binaire (b)
Ouvrir un fichier en écriture crée le fichier s'il n'existe pas,
et l'écrase sinon
Python gère la conversion des sauts de ligne (Unix / Windows / Mac)
207
Types d’ouverture
r, pour une ouverture en lecture (READ).
w, pour une ouverture en écriture (WRITE), à chaque
ouverture, le contenu du fichier est écrasé. Si le fichier
n'existe pas python le crée.
a, pour une ouverture en mode ajout à la fin du fichier
(APPEND). Si le fichier n'existe pas python le crée.
b, pour une ouverture en mode binaire.
t, pour une ouverture en mode texte.
x, crée un nouveau fichier et l'ouvre pour écriture

208
Autres fonctions:

La méthode write() réalise l’écriture proprement dite.

Les données à écrire doivent être fournies en argument.
Ces données sont enregistrées dans le fichier les unes à la
suite des autres (c'est la raison pour laquelle on parle de
fichier à accès séquentiel). Chaque nouvel appel de
write() continue l’écriture à la suite de ce qui est déjà̀
enregistré.
La méthode close() referme le fichier. Celui-ci est
désormais disponible pour tout usage.

209
Ecriture séquentielle dans un fichier

L'exemple ci-dessous vous montre comment ouvrir un fichier « en

écriture », y enregistrer deux chaines de caractères, puis le refermer.
Notez bien que si le fichier n'existe pas encore, il sera créé
automatiquement. Par contre, si le nom utilisé concerne un fichier
préexistant qui contient déjà̀ des données, les caractères que vous y
enregistrerez viendront s'ajouter à la suite de ceux qui s'y trouvent déjà̀.
 >>> obFichier = open('Monfichier','a')
 >>> obFichier.write('Bonjour, SRT 2022-2023 !')
 >>> obFichier.write("Quel beau temps, aujourd'hui !")
 >>> obFichier.close()

210
Lecture séquentielle d’un fichier

 >>> fi = open('Monfichier', 'r')

>>> t = fi.read()
>>> print t
Bonjour, SRT 2021-2022 !Quel beau temps, aujourd'hui !
 >>> fi.close()
La méthode read() lit les données présentes dans le fichier et les
transfère dans une variable de type « chaine » (string) . Si on utilise
cette méthode sans argument, la totalité́ du fichier est transférée.
Le fichier que nous voulons lire s'appelle « Monfichier ».
L'instruction d'ouverture de fichier devra donc nécessairement faire
référence à ce nom-là. Si le fichier n'existe pas, nous obtenons un
message d'erreur. Exemple :
>>> ofi = open('Monficier','r')
IOError: [Errno 2] No such file or directory: 'Monficier'

211
Lecture séquentielle d’un fichier

La méthode read() peut également être utilisée avec un argument. Celui-ci

indiquera combien de caractères doivent être lus, à partir de la position déjà̀
atteinte dans le fichier :
 >>> fi = open('Monfichier', 'r’)
 >>> t = ofi.read(7)
>>> print t
Bonjour

212
Mot clé With
Le mot clé with
o Il existe une autre syntaxe plus courte qui permet de
s’émanciper du problème de fermeture du fichier: le mot
clé with

with open("test.txt", "r") as fichier:

print fichier.read()

213
Instruction break pour sortir d’une boucle
La fonction ci-dessous copie l'intégralité d'un fichier, quelle
que soit sa taille, en transférant des portions de 50 caractères à
la fois :
def copieFichier(source, destination):
"copie intégrale d'un fichier"
fs = open(source, 'r')
fd = open(destination, 'w')
while 1:
txt = fs.read(50)
if txt =="":
break
fd.write(txt)
fs.close()
fd.close()
return
214
Fichier texte
Un fichier texte est un fichier qui contient des caractères
imprimables et des espaces organisés en lignes successives, ces
lignes étant séparées les unes des autres par un caractère spécial non
imprimable appelé́ « marqueur de fin de ligne »
Les instructions suivantes créent un fichier texte de
quatre lignes :
 >>> f = open("Fichiertexte", "w")
>>> f.write("Ceci est la ligne un\nVoici la ligne deux\n")
 >>> f.write("Voici la ligne trois\nVoici la ligne quatre\n")
 >>> f.close()

215
Fichier texte
La méthode readline(), par exemple, ne lit qu'une seule ligne à la fois (en incluant le
caractère de fin de ligne) :
 >>> f = open('Fichiertexte','r’)
 >>> t = f.readline()
>>> print t
Ceci est la ligne un
 >>> print f.readline()
 Voici la ligne deux
La méthode readlines() transfère toutes les lignes restantes dans une liste de chaînes :
 >>> t = f.readlines()
>>> print t
['Voici la ligne trois\012', 'Voici la ligne quatre\012’]
 >>> f.close()

216
Fichier texte: Exemple
Créer une fonction destinée à effectuer un certain traitement sur un fichier texte.
En l'occurrence, il s'agit ici de recopier un fichier texte en omettant toutes les
lignes qui commencent par un caractère '#’
def filtre(source,destination):
"recopier un fichier en éliminant les lignes de remarques"
fs = open(source, 'r’)
fd = open(destination, 'w’)
while 1:
txt = fs.readline()
if txt ==’’:
break
if txt[0] != '#’:
fd.write(txt)
fs.close()
fd.close()
return
Exemple d’appel:
filtre('test.txt', 'test_f.txt')
217
Enregistrement et restitution de variables
diverses
L'argument de la méthode write() doit être une chaîne de caractères.
Nous pouvons réaliser cela à l'aide de la fonction intégrée str() :
 >>> x = 52
>>> f.write(str(x))
NB: Si nous enregistrons les valeurs numériques en les transformant d'abord en chaînes
de caractères, nous risquons de ne plus pouvoir les retransformer correctement en valeurs
numériques lorsque nous allons relire le fichier. Exemple :
 >>> a = 5
>>> b = 2.83
>>> c = 67
>>> f = open('Monfichier', 'w’)
 >>> f.write(str(a))
>>> f.write(str(b))
>>> f.write(str(c))
>>> f.close()
>>> f = open('Monfichier', 'r’)
 >>> print f.read()
52.8367
>>> f.close()

218
Enregistrement et restitution de variables
diverses
L'une des meilleures consiste à importer un module Python spécialisé́ : le module pickle
(sert effectivement à enregistrer des données en conservant leur type).
 >>> import pickle
>>> f = open('Monfichier', ‘wb’)
 >>> pickle.dump(a, f)
>>> pickle.dump(b, f)
>>> pickle.dump(c, f)
>>> f.close()
>>> f = open('Monfichier', ‘rb’)
 >>> t = pickle.load(f)
>>> print (t, type(t))
5 <type 'int'>
>>> t = pickle.load(f)
>>> print (t, type(t))
2.83 <type 'float'>
>>> t = pickle.load(f)
>>> print (t, type(t))
67 <type 'int'>
>>> f.close()

219
Enregistrement et restitution de variables
diverses: Explication

Pour cet exemple, on considère que les variables a, b et c contiennent les mêmes valeurs
que dans l'exemple précédent.
La fonction dump() du module pickle attend deux arguments : le premier est la variable à
enregistrer, le second est l'objet fichier dans lequel on travaille.
La fonction pickle.load() effectue le travail inverse, c'est-à-dire la restitution de chaque
variable avec son type.

220
Fichiers: Exercices
Enoncé 1:
 Vous devez lire et écrire des données dans un fichier texte. Si le
fichier n’existe pas, il doit être créé. Si le fichier a un contenu, le
contenu doit être supprimé. Quel code devriez vous utiliser?
A. open ("local_data", "r")
B. open ("local_data", "r+")
C. open ("local_data", "w+")
D. open ("local_data", "w")

221
Fichiers: Exercices
Enoncé 2:
 Créer une fonction qui lit un fichier de données et imprime chaque
ligne du fichier
Enoncé 3:
 Ecrire un programme python qui permet de regrouper dans une
liste les mots communs à deux fichiers textes: fichier1 et fichier2

222
FIN

223