Polycopie MIP Informatique2 2024

Module Informatique 2 :
Algorithmique 2 / Python
FILIERE MIP – SEMESTRE 2
Prof. ABDELTIF EL BYED

2023-2024
Informatique2 : Algorithme2 / Python MIP-S
Table des matières

1 Présentation du module Informatique 2 ......................................................................................8
1.1 Objectifs du module ............................................................................................................8
1.2 Compétences & Connaissances à acquérir ...........................................................................8
1.3 Plan détaillé.........................................................................................................................8
2 Rappels sur la première partie : Informatique 1......................................................................... 10
2.1 Algorithme, instructions et langages informatiques ........................................................... 10
2.1.1 Définition................................................................................................................... 10
2.1.2 Exemple des langages de programmation .................................................................. 10
2.2 Le langage Python ............................................................................................................. 10
2.2.1 Création ..................................................................................................................... 10
2.2.2 Utilisation .................................................................................................................. 11
2.3 Outils de développement et d’exécution ........................................................................... 11
2.3.1 Interpréteur Python ou Shell ...................................................................................... 11
2.3.2 Environnement ANACONDA....................................................................................... 11
2.4 Éditeurs de programmes.................................................................................................... 12
2.4.1 Création et exécution d’un programme python .......................................................... 12
2.4.2 Spyder ....................................................................................................................... 12
2.4.3 Jupyter Notebook ...................................................................................................... 13
2.5 Les instructions Python ...................................................................................................... 13
2.5.1 Instructions simples ................................................................................................... 13
2.5.2 Instructions composées ............................................................................................. 14
2.6 Les données en Python ...................................................................................................... 16
2.6.1 Types de données ...................................................................................................... 16
2.6.2 Expression littérale des données ................................................................................ 16
2.7 Les variables ...................................................................................................................... 17
2.7.1 Variables et affectation de données ........................................................................... 17
2.7.2 Les constantes ........................................................................................................... 17
2.7.3 Conversion de type (Cast) .......................................................................................... 17
2.8 Les Opérateurs .................................................................................................................. 18
2.8.1 Opérateurs sur les Nombres ...................................................................................... 18
2.8.2 Opérateurs sur les chaînes de caractères ................................................................... 18
3 Fonctions Prédéfinies en Algorithme ......................................................................................... 19
3.1 Définition .......................................................................................................................... 19
3.2 Fonctions prédéfinies ........................................................................................................ 19
3.2.1 Fonctions d'entrées / sorties ...................................................................................... 19
3.2.2 Manipulation des chaînes de caractères..................................................................... 19
Pr. Abdeltif EL BYED
3.2.3 Fonctions Mathématiques ......................................................................................... 20

4 Fonctions Prédéfinies en Python & les Modules ........................................................................ 21
4.1 Fonctions de bases ............................................................................................................ 21
4.1.1 Fonctions sur les nombres ......................................................................................... 21
4.1.2 Fonctions de Conversion ............................................................................................ 21
4.1.3 La fonction type() ....................................................................................................... 22
4.2 Fonctions sur les Structures de données ............................................................................ 23
4.2.1 Listes ......................................................................................................................... 23
4.2.2 Tuples ........................................................................................................................ 24
4.2.3 Les ensembles (set).................................................................................................... 24
4.2.4 Fonctions sur les listes ............................................................................................... 25
4.2.5 Dictionnaire ............................................................................................................... 30
4.2.6 Conversion des séquences ......................................................................................... 34
4.2.7 Exercices d’application ............................................................................................... 34
4.3 Fonctions d’entrées/sorties ............................................................................................... 35
4.3.1 Fonction de sortie: PRINT ........................................................................................... 35
4.3.2 Fonction d’entrée: INPUT ........................................................................................... 37
4.4 Appel d’une fonction prédéfinie ........................................................................................ 38
4.4.1 Syntaxe de l’appel ...................................................................................................... 38
4.4.2 Valeur retournée par une fonction ............................................................................. 39
4.4.3 Les procédures........................................................................................................... 39
4.5 Modules en Python............................................................................................................ 39
4.5.1 Définition................................................................................................................... 39
4.5.2 Importation de Module .............................................................................................. 40
4.5.3 Importation des fonctions du Module ........................................................................ 40
4.5.4 Package ..................................................................................................................... 41
4.5.5 Fonctions d'aide ......................................................................................................... 41
4.5.6 Quelques modules Python courant ........................................................................... 42
4.5.7 Module: math ............................................................................................................ 42
4.5.8 Module random ......................................................................................................... 42
4.5.9 Module statistics........................................................................................................ 44
4.5.10 Module OS ................................................................................................................. 44
4.5.11 Module glob .............................................................................................................. 44
4.5.12 Module TURTLE ......................................................................................................... 44
5 Fonctions & Procédures : créer un sous-programme en Algorithme .......................................... 46
5.1 Définir une fonction........................................................................................................... 46
5.1.1 Principe ..................................................................................................................... 46
5.1.2 Buts de l’utilisation .................................................................................................... 46

5.2 Procédure et fonction ........................................................................................................ 46

5.2.1 Définition................................................................................................................... 46
5.2.2 Déclaration d’une Procédure ..................................................................................... 47
5.2.3 Déclaration d’une Fonction ........................................................................................ 47
5.2.4 Appel d’un sous algorithme........................................................................................ 48
5.3 Passages de paramètres .................................................................................................... 48
5.3.1 Passage par valeur ..................................................................................................... 48
5.3.2 Passage par adresse ................................................................................................... 48
6 Fonctions & Procédures : créer un sous-programme en Python ................................................. 50
6.1 Déclaration ................................................................................... Erreur ! Signet non défini.
6.1.1 Utilisation ............................................................................. Erreur ! Signet non défini.
6.1.2 Définition................................................................................................................... 50
6.1.3 Syntaxe ...................................................................................................................... 50
6.2 Exemples de fonctions ....................................................................................................... 51
6.2.1 Fonction sans paramètres .......................................................................................... 51
6.2.2 Fonction avec paramètres et des valeurs par défaut .................................................. 51
6.2.3 Procédure .................................................................................................................. 51
6.2.4 Fonction avec liste comme paramètre ....................................................................... 51
6.2.5 Fonction graphique avec le module Turtle ................................................................. 52
6.2.6 Fonction qui retourne plusieurs valeurs ..................................................................... 52
6.3 Appel d’une fonction ......................................................................................................... 52
6.3.1 Syntaxe ...................................................................................................................... 52
6.3.2 Arguments de fonction .............................................................................................. 52
6.3.3 Ordre des arguments ................................................................................................. 53
6.3.4 Paramètres optionnels (valeur par défaut) ................................................................. 53
6.4 Fonctions particulaires....................................................................................................... 54
6.4.1 Fonction mathématique f(x)....................................................................................... 54
6.4.2 Fonctions sur les séquences ....................................................................................... 54
6.4.3 Fonction main ............................................................................................................ 55
6.5 Portée des variables .......................................................................................................... 55
6.5.1 Variables locales ........................................................................................................ 55
6.5.2 Variables globales ...................................................................................................... 56
6.6 Passage de paramètres en python ..................................................................................... 57
6.6.1 Principe ..................................................................................................................... 57
6.6.2 Objet mutable et non mutable ................................................................................... 57
6.6.3 Règle LGI (Locale General Interne) ............................................................................. 60
6.6.4 Recommandations sur les variables et les paramètres ............................................... 60
6.7 Structure d’un programme python .................................................................................... 61

6.7.1 Structure générale ..................................................................................................... 61

6.8 Création : Module et Package ............................................................................................ 62
6.8.1 Création du Module ................................................................................................... 62
6.8.2 Création de la Package ............................................................................................... 63
6.8.3 Structuration d’un module ......................................................................................... 63
7 Récursivité ................................................................................................................................ 64
7.1 Définition .......................................................................................................................... 64
7.1.1 Appel d’une fonction dans une autre ......................................................................... 64
7.1.2 Principe de récursivité ............................................................................................... 64
7.1.3 Fonction Récursive ..................................................................................................... 65
7.1.4 Exemples de fonctions récursives............................................................................... 65
7.2 Types des récursivités ........................................................................................................ 66
7.2.1 Récursivité terminale ................................................................................................. 66
7.2.2 Récursivité directe ..................................................................................................... 66
7.3 Fonction récursive ............................................................................................................. 67
7.3.1 Définir une fonction récursive .................................................................................... 67
7.3.2 Terminaison de la fonction......................................................................................... 67
7.3.3 La bonne solution ...................................................................................................... 67
7.3.4 Résumé...................................................................................................................... 68
7.4 Quelques Exemples ........................................................................................................... 68
7.4.1 Boucle for .................................................................................................................. 68
7.4.2 Exécution de la récursivité ......................................................................................... 69
7.4.3 Quelques Constatations ............................................................................................. 69
7.5 Exercices d’application ...................................................................................................... 69
8 Gestion des fichiers .................................................................................................................. 70
8.1 Les fichiers......................................................................................................................... 70
8.1.1 Utilité des fichiers ...................................................................................................... 70
8.1.2 Utilisation .................................................................................................................. 70
8.1.3 Nom de fichier et le répertoire courant ...................................................................... 70
8.1.4 Changement du répertoire courant ............................................................................ 71
8.2 Gestion de fichier : Ouverture et lecture ............................................................................ 71
8.2.1 Ouverture du fichier: OPEN ........................................................................................ 71
8.2.2 Lecture dans un fichier : .readlines ............................................................................. 71
8.2.3 Lecture dans un fichier: read() ................................................................................... 72
8.2.4 Lecture dans un fichier: readline ................................................................................ 73
8.2.5 Fermeture du fichier: close ........................................................................................ 73
8.2.6 Autres fonctions de gestion ....................................................................................... 73
8.3 Gestion de fichier : Écriture ............................................................................................... 74

8.3.1 Écriture dans un fichier: Write ................................................................................... 74

8.3.2 Formatage de l’Écriture : .format ............................................................................... 74
8.3.3 Ouverture de plusieurs fichiers avec with................................................................... 75
8.3.4 Conversions de types ................................................................................................. 75
8.4 Gestion des exceptions ...................................................................................................... 75
8.4.1 Définition................................................................................................................... 75
8.4.2 Mécanisme de traitement des exceptions .................................................................. 76
8.4.3 try - except – else....................................................................................................... 76
8.4.4 Gestion des exceptions des fichiers ............................................................................ 77
9 Complexité algorithmique ......................................................................................................... 78
9.1 Comprendre la notion de complexité................................................................................. 78
9.1.1 Problématique ........................................................................................................... 78
9.1.2 Objectifs .................................................................................................................... 78
9.2 Types de complexités ........................................................................................................ 79
9.2.1 Complexité temporelle et spatiale ............................................................................. 79
9.2.2 Complexité en temps et en espace: exemple ............................................................. 79
9.3 Méthodes de calcul de complexité..................................................................................... 79
9.3.1 Méthode expérimentale ............................................................................................ 79
9.4 Méthode théorique ........................................................................................................... 80
9.4.1 Avantage et motivation.............................................................................................. 80
9.4.2 Etapes de calcul de la complexité ............................................................................... 80
9.4.3 Paramètre de complexité ........................................................................................... 80
9.4.4 Mesure de la complexité temporelle .......................................................................... 81
9.4.5 Règles de calcule........................................................................................................ 81
9.4.6 Les opérations élémentaires ...................................................................................... 82
9.4.7 Les opérations non élémentaires ............................................................................... 82
9.5 Calcul de la complexité théorique ...................................................................................... 82
9.5.1 Objectif ...................................................................................................................... 82
9.5.2 Principe ..................................................................................................................... 82
9.5.3 Exemple de calcul de complexité................................................................................ 82
9.5.4 Complexité au mieux et au pire.................................................................................. 83
9.6 Complexité asymptotique .................................................................................................. 84
9.6.1 Notation de Landau O ................................................................................................ 84
9.6.2 Notation O : exemples ............................................................................................... 84
9.6.3 Simplification ............................................................................................................. 85
9.6.4 Propriétés .................................................................................................................. 85
9.6.5 Classes de la complexité............................................................................................. 85
9.7 Complexité des fonctions récursives .................................................................................. 85

9.7.1 Calcule de la complexité des fonctions récursives ...................................................... 85

9.7.2 Etude de cas .............................................................................................................. 86
10 TD : les exercices ................................................................................................................... 87
10.1 TD1 : Fonctions Prédéfinies – Algorithme .......................................................................... 87
10.1.1 Opérateurs ................................................................................................................ 87
10.1.6 Fonctions sur les chaînes de caractères ...................................................................... 87
10.2 TD2 : Fonctions Prédéfinies & Modules (Python) ............................................................... 89
10.2.1 Opérations et conversions de types ........................................................................... 89
10.2.2 Structures de données : suite Fibonacci ..................................................................... 89
10.2.3 Structures de données : tuples et listes ...................................................................... 89
10.2.4 Structures de données : liste & dictionnaire ............................................................... 89
10.2.5 Fonctions sur les listes ............................................................................................... 89
10.2.6 Module math ............................................................................................................. 90
10.2.7 Formatage de string ................................................................................................... 90
10.2.8 Module Random ........................................................................................................ 90
10.2.9 Modules OS et Glob ................................................................................................... 90
10.2.10 Module Statistics.................................................................................................... 90
10.2.11 Module Turtle ........................................................................................................ 90
10.3 TD3 Fonctions et procédures : Algorithme ......................................................................... 91
10.3.1 Calcule d’une fonction mathématique ....................................................................... 91
10.3.2 Fonction Moyenne ..................................................................................................... 91
10.3.3 Nombre Premier ........................................................................................................ 91
10.3.4 Année bissextile ......................................................................................................... 91
10.3.5 Type de Triangle ........................................................................................................ 91
10.3.6 Gestion d’une liste ..................................................................................................... 91
10.3.7 Gestion de Notes ....................................................................................................... 91
10.3.8 Force de gravitation ................................................................................................... 91
10.4 TD4 Fonctions et procédures : Python ............................................................................... 93
10.4.1 Fonction Mathématique ............................................................................................ 93
10.4.2 Tableau de multiplication........................................................................................... 93
10.4.3 Chaîne de n caractères ............................................................................................... 93
10.4.4 Surface d'un cercle .................................................................................................... 93

10.4.5 Volume d'une boîte ................................................................................................... 93

10.4.6 Occurrence d’un caractère ......................................................................................... 93
10.4.7 Nombres premiers ..................................................................................................... 93
10.4.8 Séquence complémentaire ........................................................................................ 93
10.5 TD5 Fonctions Récursives : algorithme et Python ............................................................... 94
10.5.1 Calcule de Somme ..................................................................................................... 94
10.5.2 Fonction sur les listes ................................................................................................. 94
10.5.3 Nombre d’occurrence ................................................................................................ 94
10.5.4 Récursivité indirecte .................................................................................................. 94
10.5.5 Suite de Fibonacci ...................................................................................................... 94
10.5.6 Puissance d’un nombre .............................................................................................. 94
10.5.7 PGCD ......................................................................................................................... 94
10.5.8 Tours de Hanoï........................................................................................................... 95
10.6 TD6 Gestion des Fichiers avec Python ................................................................................ 96
10.6.1 Moyenne des notes ................................................................................................... 96
10.6.2 Admis ou recalé ......................................................................................................... 96
10.6.3 Menu de gestion ........................................................................................................ 96
10.6.4 Recherche dans un fichier .......................................................................................... 96
10.6.5 Tables de multiplication ............................................................................................. 97
10.6.6 Ouverture de plusieurs fichiers .................................................................................. 97
10.6.7 Base de données étudiant .......................................................................................... 97
10.6.8 Lecture simultanée .................................................................................................... 97
10.7 TD7 Complexité Algorithmique .......................................................................................... 98
10.7.1 Tri par sélection ......................................................................................................... 98
10.7.2 Tri par insertion ......................................................................................................... 98
10.7.3 Recherche dichotomique ........................................................................................... 99
10.7.4 Fonction récursive : Tri par sélection .......................................................................... 99
10.7.5 Fonction récursive : tri ............................................................................................... 99
10.7.6 Fonction récursive : partition ................................................................................... 100

1 Présentation du module Informatique 2

1.1 Objectifs du module
n Apprendre les notions avancées de l’algorithmique et de la programmation en utilisant le
langage Python: algorithmes sur les fonctions, la gestion des fichiers, les exceptions et la
complexité.
n Comprendre les fonctions et les procédures, gestion de fichier en Python
n Découvrir des outils de création, test et évaluation du langage Python
1.2 Compétences & Connaissances à acquérir

Compétences
n Utiliser les fonctions et les procédures prédéfinies en Algorithme & en Python
n Définir des fonctions et des procédures en Algorithme & en Python
n Appliquer la récursivité pour résoudre des problèmes spécifiques
n Manipuler des fichiers en Python
n Calculer la complexité d'un algorithme
n Écrire des preuves de correction et de terminaison d'un algorithme
Connaissances
n La récursivité et son application dans des algorithmes
n Les enregistrements et les fichiers en Python
n La complexité des algorithmes et ses principaux types
n Les preuves d'algorithmes et les méthodes de preuves de correction et de terminaison
1.3 Plan détaillé

1. Fonctions et procédures
n Comprendre la notion de fonction et de procédure en informatique.
n Savoir définir et utiliser des fonctions et des procédures en Python.
n Connaître les principes de la portée des variables.
2. Récursivité :
n Comprendre la notion de récursivité et savoir l'appliquer dans des algorithmes.
n Savoir utiliser la récursivité pour résoudre des problèmes spécifiques.
3. Enregistrements et fichiers.
n Comprendre la notion d'enregistrements et de fichiers en informatique.
n Savoir manipuler des fichiers en Python pour lire, écrire et modifier des données.
n Être capable de stocker et de récupérer des données structurées dans des fichiers.
4. La complexité :
n Comprendre la notion de complexité des algorithmes.
n Savoir calculer la complexité d'un algorithme.

n Connaître les principaux types de complexité et leurs caractéristiques.
5. Preuves d'algorithmes :
n Comprendre l'importance des preuves d'algorithmes.
n Savoir écrire des preuves de correction et de terminaison d'un algorithme.
n Être capable d'appliquer les méthodes de preuves d'algorithmes pour différents

types d'algorithmes.

2 Rappels sur la première partie : Informatique 1

2.1 Algorithme, instructions et langages informatiques
2.1.1 Définition
Un algorithme est une suite finie d'instructions, écrites en langage naturel, qui peuvent être
exécutées les unes à la suite des autres pour résoudre un problème.
Un algorithme peut aussi être représenté sous forme graphique, on parle d'organigramme.
Un programme informatique (appelé aussi “application”) est une traduction de l'algorithme dans un
langage de programmation.
2.1.2 Exemple des langages de programmation

Nom du langage Apparu en
Langage machine
Assembleur 1950
Basic 1964
Pascal 1970
C 1973
C++ 1983
Python 1991
Java 1994
2.2 Le langage Python

2.2.1 Création
À la fin des années 1980, le programmeur Guido
van Rossum participe au développement du
langage de programmation ABC au Centrum voor
Wiskunde en Informatica (CWI) d'Amsterdam,
aux Pays-Bas. Il travaille alors dans l'équipe
du système d'exploitation Amoeba dont
les appels systèmes sont difficilement
interfaçables avec le Bourne shell utilisé
comme interface utilisateur. Il estime alors qu'un
langage de script inspiré d'ABC pourrait être intéressant comme interpréteur de commandes pour
Amoeba9.
En 1989, Guido van Rossum écrit la première version du langage. Fan de la série télévisée Monty
Python's Flying Circus, il décide de baptiser ce projet Python. Il s'est principalement inspiré d'ABC,
par exemple pour l'indentation comme syntaxe ou les types de haut niveau mais aussi de Modula-
3 pour la gestion des exceptions, du langage C et des outils UNIX.
Durant l'année suivante, le langage commence à être adopté par l'équipe du projet Amoeba, Guido
poursuivant son développement. En février 1991, la première version publique, numérotée 0.9.0.
Il s’agit d’un langage objet, pseudo-interprété, portable, libre, ouvert, gratuit. De nombreuses
“bibliothèques” sont disponibles sur internet.

Python est utilisé dans des applications comme: moteur de recherche Google, Youtube, …
2.2.2 Utilisation
On peut créer et exécuter le langage python depuis :
· une fenêtre de terminal (ou console)

· ou bien, un environnement de développement (IDE - Interactive Development Environment)
Voici un exemple d’IDE et de distribution les plus utilisés:
· Pyzo, IPython/Jupyter, WingIDE, PyCharm, Anaconda, etc.
Il existe deux façons de travailler avec python : soit l'interpréteur ou l'éditeur.
2.3 Outils de développement et d’exécution

2.3.1 Interpréteur Python ou Shell
n Il permet de saisir des instructions qui sont immédiatement exécutées.
n Depuis une fenêtre on lance le Shell Python en saisissant python (sous Windows) ou bien
python3 (sous Linux ou MacOS X).
n Pour quitter l'interpréteur, on exécute la fonction exit()
n ou via les raccourcis clavier Ctrl-D sous Linux/MacOS X, ou Ctrl-Z sous Windows.
2.3.2 Environnement ANACONDA

La distribution ANACONDA propose plusieurs outils de développement:
· CMD.exe est un shell

· Jupyter est un interpréteur
· Spyder est un éditeur
· IP et d’autre

2.4 Éditeurs de programmes

2.4.1 Création et exécution d’un programme python
Le programme, aussi appelé script devra être enregistré dans un fichier texte d'extension .py.
On exécute le script depuis une fenêtre de terminal,
1. en se déplaçant dans le répertoire qui contient le script
2. et en saisissant le mot python suivi du nom du fichier script.
2.4.2 Spyder
On commence par le lancement de l’outil spyder soit à partir du menu de démarrage Windows ou à
partir de l’interface de la distribution Anaconda. Avec Spyder nous disposons d’une fenêtre pour
écrire le script puis on l’exécute en cliquant sur Exécution (ou F5), la fenêtre de droite contient la
sortie de notre script.
2.4.3 Jupyter Notebook

L’application Jupyter Notebook est exécutée dans un navigateur web à partir du menu démarrage de
Windows. Afin de créer un nouveau fichier python interactif (.ipynb) on :
· clique sur New àPyhton3: pour créer un nouveau fichier

· écrit puis on exécute les instructions de chaque entrée d’une manière individuelle.
2.5 Les instructions Python

2.5.1 Instructions simples
· Une instruction simple est formée d'une seule ligne
o >>> 2 + 3 ou >>> 35 / 5
· Commentaires:
o Le caractère # placé sur la ligne d'une instruction simple introduit un commentaire
d’une seule ligne.
o Pour mettre plusieurs lignes en commentaire il suffit de les encadrer par trois
guillemets (""")

"""
Commentaire sur plusieurs lignes:
Éditeur de Spyder
Ceci est un script temporaire.
"""
2.5.2 Instructions composées
Une instruction composée est formée d’un bloc d’instructions. Un bloc d’instructions est formé
n d'une instruction d'introduction terminée par le caractère deux points (:),
n suivi par un bloc d'instructions simples (ou elles-mêmes structurées) indentées par
rapport à cette instruction d'introduction. Voici sa structure :
instruction d'introduction :
instruction 1
……
instruction n
autre instruction
Remarque
Lorsqu'une instruction ouvre une expression avec une parenthèse ‘(‘ou une accolade ‘{‘ ou un
crochet ‘[‘, alors l'indentation est ignorée jusqu'à ce que le ‘)’ ou ‘}’ ou ‘]’ correspondant referme
l'expression.
2.5.2.1 Conditionnelle SI
Algorithme
si condition1 alors
instruction 1 (ou bloc d'instructions 1)
sinon si condition2 alors
sinon
fin si
Python
if condition1 :
bloc d'instructions 1
elif condition2 :
else :

Voici la traduction des mots clés du branchement Conditionnel en python :
· Si çè if
· Sinon si çè elif
· Sinon çè else
2.5.2.2 Boucle pour

Algorithme
pour n de 1 à 10 faire
u = n*n
afficher(("Le carré de ", n , "est ",u)
fin pour
Python
for n in range(1,11):
u =n*n
print ("Le carré de ", n , "est ",u)
2.5.2.3 Boucle tant que

Algorithme
afficher(« entrez un nombre strictement positif »)
Lire (n)
tant que n < 0 faire
afficher(« Erreur, le nombre n'était pas strictement positif. Recommencez»)
lire (n)
fin tant que
Python
n=int(input ("entrez un nombre strictement positif: "))
while n<0:
n=int(input ("Erreur, le nombre n'était pas strictement positif. Recommencez: "))
print ("La valeur de n est: ", n)

2.6 Les données en Python

2.6.1 Types de données
Python
L'instruction type(Var) permet de connaître le type de la variable Var.
2.6.2 Expression littérale des données

2.6.2.1 Nombres
· Nombres entiers:
n en base 10, on utilise les signes + et - : 562, 672, -95
n en binaire on préfixe le nombre par 0b: 0b10011011
n en hexadécimal on préfixe le nombre par 0x: 0xf7e5a2b
n en octal on préfixe le nombre par 0o: 0o754
n Nombres flottants (ou nombres décimaux):
n toujours exprimés en base 10, on utilise un «.» pour séparer la partie entière de la
partie décimale,
§ par exp: 45.12 , -95.3
2.6.2.2 Chaînes de caractères

n On les encadre par des simples ou doubles guillemets: ‘texte’, "texte".
n On peut y insérer des séquences d'échappement introduites par un caractère \ suivi par un
autre caractère définissant la séquence,
n \t pour une tabulation,

n \n pour un saut de ligne,
n \\ pour un \, \" pour un guillemet double, \' pour un guillemet simple
n On peut aussi exprimer des littérales chaînes de caractères sur plusieurs lignes en utilisant au
début et à la fin trois guillemets doubles ou trois guillemets simples :
" " "Une chaîne sur plusieurs lignes

avec "des" retours et
des guillemets." " "
2.7 Les variables
2.7.1 Variables et affectation de données
Algorithme
Variables a: Entier
a←1
Python
a=1
# SANS déclaration de son type. Lors de l'opération d'affectation, le langage associe à la
variable le type de la donnée qu'elle référence.
Remarque
Il ne faut pas confondre l'opérateur d'affectation = avec le symbole d'égalité mathématique.

L'affectation n'est ni une équation mathématique, ni une égalité mathématique !
Nom de Variable: Le langage Python fait la distinction entre les majuscules et les minuscules,
de même qu'entre les caractères avec et sans accent.
2.7.2 Les constantes

Une constante est une variable dont la valeur ne doit pas changer au cours de l'exécution du
programme. Par convention, on la nomme en MAJUSCULES avec _ comme séparateur.
Algorithme
Constante NB_MAX_ETUD = 110 #Nombre Maximum des étudiants

Constante PI = 3,14
Python
NB_MAX_ETUD = 110
PI = 3,14
Remarque
Contrairement à d'autres langages, Python n'empêche pas la modification d'une constante.

L'utilisation de la convention avec des majuscules indique aux développeurs qu'il ne faut pas
modifier la variable concernée.
2.7.3 Conversion de type (Cast)

La fonction de conversion (cast en anglais) consiste à convertir ou changer le type d’une donnée vers
un nouveau type. On change le type d'une donnée en l'indiquant entre parenthèses, précédée du
nom du nouveau type souhaité.

n New_Type(Var)
n Exemple: Float(3), str(5), bool(0)
Lorsque la valeur affectée à la variable ne peut pas être convertie vers le type désiré, l’opération de
Cast ne sera pas autorisée:
n Par exemple : int(‘Bonjour’)
2.8 Les Opérateurs

2.8.1 Opérateurs sur les Nombres
2.8.2 Opérateurs sur les chaînes de caractères

3 Fonctions Prédéfinies en Algorithme

3.1 Définition
Tout langage de programmation dispose d’un ensemble de fonctions prédéfinies. Elles permettent
de réaliser des manipulations sans les définir.
Par conséquent, en algorithmique on trouve des fonctions prédéfinies pour:
n La conversion de types de données,
n Le calcul mathématique,
n La manipulation de date et d’heures,
n La manipulation de chaîne de caractères
n et bien d’autres.
3.2 Fonctions prédéfinies

3.2.1 Fonctions d'entrées / sorties
La fonction Ecrire(msg): permet d'afficher à l'écran le message msg. Si on cherche à afficher un
message avec du texte statique et des valeurs dynamiques, on utilise la virgule ',' comme séparateur.
Par exemple:
n Ecrire ("Bonjour les MIP")
n Ecrire (a, "+", b, "=", c)
Dans certains documentation d'algorithme cette fonction porte le nom de: afficher(msg).
La fonction Lire(var): affecte la valeur saisie au clavier par l’utilisateur à la variable var. Il s'agit d'une
interruption de l'algorithme. Par exemple:
n lire(n) ou Lire (a,b)
3.2.2 Manipulation des chaînes de caractères

Une chaîne de caractères est une séquence de caractères, voici quelques fonctions prédéfinies en
algorithme pour la manipulation de ce type de donnée :
n Longueur(ch): retourne le nombre de caractères de ‘ch’
n Exp: Longueur("Bonjour") retourne 7
n Concat(ch1,ch2): retourne la concaténation des deux chaînes de caractères ch1 et ch2.
n Exp. Concat("Bonjour","Madame") retourne BonjourMadame
n On peut concaténer plusieurs chaines les unes après les autres:
n Exp: Concat("Bonjour"," ","Madame") retourne Bonjour Madame
n copie(ch,pos,n): retourne la copie d'une partie de la chaîne 'ch' à partir de la position 'pos' et
en limitant la recopie au nombre de caractères 'n'.
n Exp: copie("Bonjour",4,4) retourne jour
n Comp(ch1,ch2): compare les deux chaînes de caractères 'ch1' et 'ch2' par ordre
alphabétiques en utilisant le code ASCII de chaque caractère. Elle retourne:
n Une valeur positive si ch1>ch2
n Une valeur négative si ch1<ch2

n Une valeur nulle si ch1=ch2
n La fonction comp est souvent utilisée avec le branchement conditionnel
Si comp(nom1,nom2)>0 alors
Ecrire(nom1)
n recherche(ch,caractère): retourne la première position du caractère dans la chaîne 'ch'
n Exp: recherche("Bonjour","o") retourne 2
n recherche(ch,sous_ch): retourne la première position de la sous chaîne 'sous_ch' dans la

chaîne 'ch'
n Exp: recherche("Bonjour le 1 jour","jour") retourne 4
n La fonction recherche retourne 0 si le caractère ou la sous chaine n'apparaît pas dans

la chaîne de caractères
3.2.3 Fonctions Mathématiques

Les fonctions mathématiques prédéfinies permettent la réalisation des traitements mathématiques
sur des données numériques.
n Abs(n): retourne la valeur absolue du nombre n
n Exp: Abs(-10) retourne 10
n Ent(n): retourne la partie entière du nombre n
n Exp: Ent(11,153) retourne 11
n racine(n): retourne la racine carrée du nombre n
n Exp: racine(16) retourne 4
n Cos(angle): retourne la cosinus d'un angle
n Exp: Cos(0) retourne 1
n Sin(angle): retourne la sinus d'un angle
n Exp: Sin(0) retourne 0
n Tan(angle): retourne la tangente d'un angle
n Exp: Tan(0) retourne 0

4 Fonctions Prédéfinies en Python & les Modules

4.1 Fonctions de bases
Python dispose des fonctions prédéfinies appelées 'Built-in' en anglais. Ils sont très utiles et simple à
utiliser. La liste de l’ensemble de ces fonctions se trouve dans le lien suivant:
n https://docs.python.org/3/library/functions.html
4.1.1 Fonctions sur les nombres

Dans cette section on donne la définition de quelques fonctions pour réaliser des calculs
mathématiques sur des nombres.
n Abs(n): retourne la valeur absolue de n
n Round(n,ndigits): retourne un arrondie de n avec ndigits après la virgule
n Ndigits=0 par défaut
4.1.2 Fonctions de Conversion

4.1.2.1 Conversion des nombres
On peut exprimer un nombre dans des bases numériques différentes :
n bin(n): convertit un entier en binaire
n oct(n): convertit un entier en octal
n hex(n): convertit un entier en hexadécimal

4.1.2.2 Conversion des séquences

Pour la collection et le sauvegarde des données, python propose plusieurs types de collection, à
savoir : les listes, les tuples, les dictionnaires ou les ensembles. Il est utile dans certain contexte de de
convertir et de passer d’un type à un autre, voici les fonctions prédéfinies en python pour réaliser ces
conversions :
n list(seq): convertit la séquence à une liste
n tuple(seq): convertit la séquence à un tuple
n dict(seq): convertit la séquence à un dictionnaire
n set(seq): convertit la séquence à un ensemble
4.1.2.3 Conversion de types

En programmation, on est souvent amené à convertir les types, c’est-à-dire passer d’un type
numérique à une chaîne de caractères ou vice-versa.
n En Python, on utilise les fonctions
n int(), float() et str().
n Toute conversion d’une variable d’un type en un autre est appelé casting en anglais.
4.1.3 La fonction type()

On python les variables sont utilisées sans la déclaration de type, il peut être très intéressant de
connaitre le type d’une variable dans un programme.
n type(n) retourne le type de la variable n.
n Elle est utile pour connaitre le type d'une variable

n Pour Python, la valeur 2 (nombre entier)
n est différente de 2.0 (ﬂoat) et
n est aussi différente de '2‘ (chaîne de caractères).
4.2 Fonctions sur les Structures de données

4.2.1 Listes
4.2.1.1 Définition
Une liste est une structure permettant de stocker des éléments hétérogènes. La Liste est la structure
de données la plus fondamentale et la plus utilisée.
Une liste est une collection ordonnée, similaire au tableau dans d’autres langages. Les éléments de la
liste sont déclarés entre deux crochets []
n Une liste peut avoir des éléments de même type
n integer_list=[1,2,3]
n string_list=["casa","rabat","tanger","paris"]
n Une liste peut avoir des éléments de type différent
n heterogeneous_list=["string",0.1, True]
n On peut déclarer une liste de listes
n list_of_list =[integer_list, String_List,heterogeneous_list]
4.2.1.2 Initialisation
L’instruction L=[]: permet de créer une liste vide. On peut utiliser la fonction range() pour initialiser
une liste :
n [i for i in range()] ou bien

n List(range())
Initialisation de la liste par un nombre des 0 : [0 for i in range()]
4.2.2 Tuples
Les tuples permettent tout comme les listes de stocker des éléments hétérogènes. On décrit un tuple
à l’aide de parenthèses ou sans rien
n my_tuple = (1,2)
n other_tuple = 3,4
Un tuple est une liste non modifiable (on dit aussi immutable) :
n my_tuple[1]=3 #Error: 'tuple' object does not support item assignement
Il est possible d'affecter des variables à l'intérieur d'un tuple
n (a,b) = (5.5 , 8)
Les tuples sont très utile pour échanger deux variables sans avoir à utiliser une variable
supplémentaire:
n (a,b) = (b,a)
4.2.3 Les ensembles (set)

En python un ensemble (en anglais Set) est une structure de données qui permet de représenter une
collection d’éléments distincts. Les éléments de Set sont déclarés entre des accolades {}.
n s={1,2,3,1} #s={1,2,3}
Attention l'instruction set={} ne déclare pas un ensemble vide. Nous avons la fonction set() qui
permet de déclarer un ensemble vide
n S=set()
La fonction add permet d'ajouter un élément à l'ensemble
n s.add(1) # s={1}
n s.add(2) # s={1, 2}
n s.add(2) # s={1, 2}
On utilise les sets pour 2 raisons principales
1. in est une opération très rapide sur les ensembles ;

2. L’autre raison et de trouver les éléments distincts d’une collection.
4.2.4 Fonctions sur les listes

Le langage python propose plusieurs fonctions de base prédéfinies pour manipuler les listes. Voici
quelques exemples de ces fonctions.
4.2.4.1 Indexing et Slicing

Les éléments de la liste sont indexés à partir de 0. On peut accéder à un élément grâce à son indice.
Par exemple List[i]: permet de récupérer le ième élément de la liste :
List[début:fin:pas]: cette fonction de slicing permet de récupérer et retourner tous les éléments qui
se trouvent entre le début et la fin avec un pas donné.
n Début à la valeur par défaut de 0
n Fin à la valeur par défaut de la longueur de la liste
n Pas à la valeur par défaut de 1
Remarque : la fonction de slicing retourne une nouvelle liste sans modifier la liste courante.
Python indexe les éléments de la liste au sens inverse avec des indices négatifs:
n -1 représente le dernier élément
n -2 représente l’avant dernier élément
n etc.
Pas=-1: permet de récupérer les éléments de la liste au sens inverse.

Remarque : lorsque le pas est négatif le début (par défaut) de la liste et le dernier élément et la fin
(par défaut) de la liste et le premier élément.
4.2.4.2 Déballer une liste

Déballer une liste consiste à assigner à chaque élément de
la liste une variable
n x,y,z=[1,2,3] #x=1; y=2; z=3
Lors de l’assignant on peut ignorer certains éléments en

remplaçant la variable par le caractère ‘_’
n _,y,_=[1,2,3] #y=2
Erreur ValueError est déclenché si on n’a pas le même

nombre d'éléments des deux côtés
try:
x,y=[1,2,3]
except ValueError:
print ("Error")
Liste[i]=V: modifier le ième élément de la liste par la valeur V.
4.2.4.3 Fonctions de calcule

Len(liste): retourne la taille de la liste
fctMath(liste): applique la fonction mathématique sur les éléments de la liste
n max(liste): retourne la plus grande valeur de la liste
n min(liste): retourne la plus petite valeur de la liste
n sum(liste): retourne la somme des éléments de la liste
4.2.4.4 Fonctions de vérification

La fonction all(liste): retourne True si tous les éléments de la liste sont True
n =True si la liste est vide

La fonction any(liste): retourne True si au moins un éléments de la liste est True
n =False si la liste est vide
On peut appliquer les deux fonctions sur une liste des nombres avec les considérations suivantes :
n Si le nombre =0 alors il est évalué en False

n Sinon il est évalué en True
L’opérateur IN, dont la syntaxe est Elt In liste: Cherche l’existence d’un élément dans une liste, il
retourne Vrai si l’élément Elt existe dans la liste et Faux sinon.
4.2.4.5 Concaténation de deux listes

Il existe deux façons pour concaténer deux listes :
1. La fonction EXTEND, dont la syntaxe est Liste1.extend(liste2), elle permet de concaténer les
deux listes dans liste1.
2. L'opérateur + : permet de concaténer les deux listes dans une nouvelle liste sans modifier les
deux listes concaténées :
4.2.4.6 Fonctions de modification : Append, Insert et pop

La fonction APPEND, dont la syntaxe est Liste.append(élt) permet d’ajouter un élément à la fin de la
liste:

La fonction INSERT, dont la syntaxe est Liste.insert(indice, élt) permet d’ajouter un élément à la ième
position dans la liste
La fonction POP, dont la syntaxe est L.pop() permet de dépiler et retourner le dernier élément de la
liste.
4.2.4.7 Trier une liste : Sort et Sorted

Pour trier une liste on peut utiliser l’une des deux fonctions : Sort ou Sorted:
La fonction SORT est une fonction de l’objet Liste, dont la syntaxe est List.Sort(). Elle permet de trier
et modifier la liste courante.
La fonction SORTED est une fonction Python dont la syntaxe est List2=Sorted(list1). Elle permet de
trier et retourner une nouvelle liste.
Par défaut le tri est ascendant, Pour un tri descendant on utilise le paramètre REVERSE des fonctions
de tri : reverse=True. Par exemple :
n x.sort(reverse=True) #x=[9, 7, 5, 3, 2, 1]
n y=sorted(x, reverse=True)
Le paramètre KEY de ces deux fonctions de tri dont la syntaxe est key=Fct, consiste à appliquer la
fonction Fct sur les éléments de la liste avant de réaliser le tri. Par exemple :
4.2.4.8 Fonctions map et filter

La fonction map consiste à générer une collection d’éléments en appliquant une fonction donnée sur
les éléments d’une liste donnée et elle renvoie un objet map (un itérable).
Nous pouvons également passer l'objet map à la fonction de conversion list(), ou à un autre type de
séquence, pour convertir l’objet map à une nouvelle structure quelconque (liste par exemple).
La fonction filter permet de filtrer une liste en évaluant une condition (comme if), et elle renvoie un
objet filter (un itérable). On peut utiliser une fonction de conversion pour convertir l’objet filter à une
séquence, liste par exemple :
4.2.4.9 Fonction Enumerate

Si nous souhaitons exécuter une itération sur une liste et utiliser à la fois ses éléments et leur index,
on utilise un compteur, voici un exemple
La fonction ENUMERATE dont la syntaxe est Enumerate(list) produit des tuples (index, élément).
Dans le cas où nous cherchons à récupérer uniquement l’index de l’élément, il suffit d’utiliser le
caractère tiret bas ‘_’ pour ignorer la valeur de l’élément retourné par la fonction enumerate :
4.2.4.10 Déballage : fonction Zip

La fonction Zip transforme plusieurs listes en une seule, sous forme des tuples d’éléments
correspondants. Si les listes sont de longueurs différentes, zip s’arrête à la fin de la plus courte.
L’utilisation des fonctions de conversion permet de transformer l’objet retourné par zip à la structure
de donnée souhaitée.
Dans l’exemple suivant nous cherchons à retourner une liste de tuples, dont chaque tuple combine le
nom de la ville avec le nombre de sa population.

Afin de réaliser l’opération inverse, on peut aussi déballer une liste avec la même fonction ZIP en
ajoutant le caractère étoile ‘*’ avant la liste à déballer.
Voici la syntaxe: zip(*listeADeballer). Cette fonction de déballage retourne un objet zip itérable dont
les éléments représentent des tuples ou chaque tuple contient les éléments de l’une des listes
déballées.
4.2.4.11 Listes comprehensions

Le concept de la liste compréhension consiste à générer rapidement une liste à partir d'un objet
itérable. Par exemple :
n even_number =[x for x in range(5) if x%2==0] #[0, 2, 4]
n square = [x*x for x in range(5)] #[0, 1, 4, 9, 16]
n even_square = [x*x for x in even_number] #[0, 4, 16]
De la même manière on peut convertir une liste à un dictionnaire (voir la section suivante) ou un set
n square_dict = {x:x*x for x in range(5)} #{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
n square_set = {x*x for x in [-2,-1,0,1,2]} #{0, 1, 4}
Si vous n’avez pas besoin de récupérer les éléments de la liste mais juste sa taille, on utilise tiret bas
_
n zero=[0 for _ in even_number] #[0, 0, 0]
Une liste compréhension peut contenir plusieurs boucle for:
Une boucle for peut réutiliser le résultat de la précédente boucle :
4.2.5 Dictionnaire
4.2.5.1 Définition
Un dictionnaire est une structure de données fondamentale qui associe des valeurs à des clés
déclarés entre accolades {}. Par exemple:
empty_dict={}
empty_dict2=dict()
grades={"Abdo":95, "Tom":80}
Les éléments d'un dictionnaire ne sont ni ordonnés ni indexés. On peut accéder à une valeur d’une
clé en utilisant des crochets dict[clé] comme dans les listes mais en remplaçant l’index par la clé.
Abdo_grade = grades["Abdo"]
Les clés sont uniques, par conséquent, lors de la récupération d’une valeur associée à une clé, une
Erreur de type KeyError sera déclenché si cette clé n’existe pas.
try:
jim_grade=grades["Jim"]
except KeyError:
print ("Key not exsist")
L’opérateur in permet de vérifier l’existence d’une clé dans un dictionnaire:
abdo_has_grade="Abdo" in grades #True

jim_has_grade = "Jim" in grades #False
On peut ajouter ou modifier la valeur d’une clé en utilisant des crochets [key]
grades["Abdo"]=96 è Modification car la clé existe

grades["Said"]=96 è Ajout car la clé n’existe pas
On peut utiliser des tuples comme une clé dans un dictionnaire python.
4.2.5.2 Manipulation d’un dictionnaire

La fonction LEN de python dont la syntaxe est Len(dict) permet de retourner le nombre des éléments
de dictionnaire
La fonction KEYS de l’objet Dict dont la syntaxe est Dict.keys() permet de récupérer toutes les clés du
dictionnaire dans un objet itérable de type dict_keys.
La fonction VALUES de l’objet Dict dont la syntaxe est Dict.values() permet de récupérer toutes les
valeurs du dictionnaire dans un objet itérable de type dict_values.
La fonction ITEMS de l’objet Dict dont la syntaxe est Dict.items() permet de récupérer les clés et les
valeurs en même temps se forme des tuples.

L’instruction d’accès aux éléments du dictionnaire Dict[key] retourne la valeur associe à la clé ou une
erreur si la clé n’existe pas.
Afin d’éviter ce message d’erreur lors de la manipulation du dictionnaire il est conseillé d’utiliser la
fonction GET dont la syntaxe est Dict.get(key,default). Cette fonction a le même comportement que
l’instruction d’avant mais elle retourne la valeur ‘default’ si la clé n’existe pas. La valeur par défaut
du paramètre ‘default’ est ‘None’.
La fonction FROMKEYS de l’objet Dict dont la syntaxe est dict.fromkeys(seq, value) permet de créer
un nouveau dictionnaire à partir d’une séquence (liste/tuple) de clés, avec ‘value’ comme valeur
associée à l’ensemble des clés (=none par défaut).
Dans l’exemple suivant on génère un dictionnaire avec autant d’éléments que la séquence liste où la
clé de chaque élément est une valeur de la liste LKeys et la valeur associée à chaque clé est ‘value’ (le
deuxième paramètre de cette fonction).
4.2.5.3 Opérateur IN
On peut utiliser « in » pour rechercher dans les différents éléments du dictionnaire.

4.2.5.4 Suppression
La fonction DEL de python dont la syntaxe est Del dict[key] permet de supprimer une entrée (un
élément du dictionnaire) en indiquant sa clé.
La fonction POP de l’objet dict dont la syntaxe est Dict.pop(key) permet de dépiler l’élément dont la
clé=key du dictionnaire. Elle retourne la valeur de la clé key.
4.2.5.5 Copie et fusion

L’opérateur égale dict1=dict2 ne permet pas de copie un dictionnaire, mais juste un double. C’est-à-
dire que chaque modification de dict1 sera appliquée à dict2 aussi. Autrement dit, il s’agit de la
même variable avec deux étiquettes différentes dict1 et dict2.
La fonction COPY de l’objet dict dont la syntaxe est D.copy() permet de créer une copie
indépendante.

La fonction UPDATE de l’objet dict dont la syntaxe d1.update(d2) permet de fusionner les deux
dictionnaires dans d1.
4.2.6 Conversion des séquences

n list(seq): convertit la séquence à une liste
n tuple(seq): convertit la séquence à un tuple
n dict(seq): convertit la séquence à un dictionnaire
n set(seq): convertit la séquence à un ensemble
4.2.7 Exercices d’application

Exercice1 : Créer une liste ‘Lentier’ des entiers de 0 à 100, puis déduire la liste ‘Limpair’ qui contient
la liste des nombres impairs inférieurs à 100. Indice : on utilise la fonction ‘filter’ ainsi la fonction
suivante ‘is_impair’ pour vérifier si un nombre est impair :
def is_impair(n):
return n%2!=0
Solution
def is_impair(n):
return n%2!=0
Lentier=list(range(101))
Limpair=list(filter(is_impair,Lentier))
print(Limpair)
Exercice2 : Soit les deux listes suivantes :

· Lmodule: contient les noms des modules. Par exemple: [BI,IA,DS,Python]
· Letud: contient les noms des étudiants. Par exemple : ["jamal","siham","serine","mourad"]

Ecrire un script python pour générer un dictionnaire ‘dictPV’ qui contient le pv des notes des
étudiants, avec :
· Key= tuple (nom, module)
· Value= none
Solution
Lmodule=['BI','IA','DS','Python']
Letud=["jamal","siham","serine","mourad"]
#création d'une liste comprehension avec deux boucle for:
l=[(x,y)
for x in Letud
for y in Lmodule ]
d={}
#dict.fromkeys(seq, value): créer un nouveau dictionnaire à partir d’une séquence
(liste/tuple) de clés,
#vec value comme valeur (=none par défaut)
d=d.fromkeys(l)
d
4.3 Fonctions d’entrées/sorties
4.3.1 Fonction de sortie: PRINT
4.3.1.1 Syntaxe
La fonction prédéfinie print() permet d'afficher à l'écran un contenu. Il s’agit d’une procédure car elle
ne retourne pas de résultat. Pour afficher un texte et une valeur d’une variable il suffit de les séparer
par une virgule ",".
Print(‘valeur de x = ’ , x)
La fonction print() affiche l’argument qu’on lui passe entre parenthèses et un retour à ligne.
n Si on ne veut pas afficher ce retour à la ligne, on peut modifier la valeur de l'attribut end:
Print() peut également afficher le contenu d’une variable quel que soit son type.
n Par exemple: var=3; print(var)
n Pour afficher le contenu de plusieurs variables (quel que soit leur type) on les sépare par des
virgules :

Print ajoute par défaut un espace entre les variables. On peut modifier ce comportement en utilisant
l’argument sep:
Pour afficher deux chaînes de caractères sans espace:
1. on peut soit les concaténer,
2. soit utiliser l’argument sep avec une chaîne de caractères vide:
· ani1 = "chat" ; ani2 = "souris"
· print(ani1, ani2) è chat souris
· print(ani1 + ani2) è chatsouris
· print(ani1, ani2, sep="") è chatsouris
4.3.1.2 Formatage de l’écriture

La méthode format() de print permet une meilleure organisation de l’affichage des variables. Les
accolades {} précisent l’endroit où le contenu de la variable doit être inséré. La syntaxe est :
Print("…{}….{}…".format(var1,var2,….))
Il est possible d’indiquer entre les accolades {} dans quel ordre on cherche à afficher les variable
(Python commence à compter à partir de 0):
n {:.xf} formate un float (f) avec x chiffres après la virgule (renvoie un résultat arrondi) :
n {:xd} pour formater des entiers (d) sur x digits

o Si le nombre des digits de la variable est inférieur à x il ajoute des espaces à gauche

n {:xs} pour formater des chaines de caractères sur x caractères

o Si le nombre des caractères de la variable est inférieur à x il ajoute des espaces à
droite.
D’une manière générale et afin de formater les entiers ou les chaînes de caractères, on a :
n {:cAnT} pour préciser sur combien de caractères le résultat soit écrit ainsi son alignement,
avec:
n c: caractère de remplissage lors des alignements (l’espace est le caractère par

défaut).
n A: alignements, > (alignement à droite), < (alignement à gauche) ˆ (alignement

centré).
n n: nombre de caractères pour présenter le résultat.
n T: = d (pour le formatage des entiers) ou s (pour le formatage des chaines de

caractères).
Pour les valeurs réelles on a :
· {:cAn.xf} pour combiner le nombre de caractères à afficher avec le nombre de décimales:
4.3.1.3 Exercices
Exercice 1 : Écrire un script python ConversionTime, qui convertit en heures, minutes et secondes,
une durée T en secondes. Il affiche le résultat sous la forme digitale comme celle d'une montre
électronique.
n Exemple: ConversionTime (56000) affiche 04h:15min:55s
Exercice 2 : Écrire un script python IMC, pour calculer l'indice de la masse corporelle.
n Rappel : IMC est calculé en divisant le poids par la taille au carré.
4.3.2 Fonction d’entrée: INPUT

4.3.2.1 Syntaxe
La fonction Input() provoque une interruption dans le programme courant. L'utilisateur est invité à
entrer des caractères au clavier et de terminer avec un <Enter>.
L’instruction N=input(‘Msg’) permet de récupérer et d'affecter à la variable N la saisie de l'utilisateur

au clavier avec Msg: représente le message explicatif destiné à l'utilisateur.
la donnée récupérée par cette fonction est de type chaîne de caractères. Il faudra convertir cette
donnée au type souhaité.

Par exemple:
print ("Veuillez entrer un nombre positif:")

nn = input()
print '("Le carré de", nn, '"=", nn**2)
Ou bien
nn = input('Veuillez entrer un nombre positif: ')

print '("Le carré de", nn, '"=", nn**2)
4.3.2.2 Fonction split
La fonction split() de la fonction input permet de récupérer plusieurs variables d’entrée au même
temps :
n,m = input().split(‘sep’)
Split utilise le caractère ‘sep’ d’espacement comme délimiteur et le séparateur par défaut est
l’espace. Par exemple :
a,b= input("Saisir deux entiers positifs: ").split()

a= int(a)
b= int(b)
print(a," * ", b, " = ", a*b)
j,m,a = input("Saisir la date se forme: jour-mois-annee").split("-")

Print (j,"/",m,"/",a)
4.4 Appel d’une fonction prédéfinie

4.4.1 Syntaxe de l’appel
L'appel d'une fonction consiste à écrire son nom suivi par la liste des arguments entre parenthèses.
n Un Argument: peut-être une valeur ou une variable
nomDeLaFonction(argument1, argument2, argument3)
Si la fonction appartient à un module particulier (voir la section suivante), il faut importer ce module,
et préfixer le nom de la fonction par le nom du module :
import nomModule
nomModule.nomDeLaFonction(argument1, argument2, argument3)
Par exemple :

4.4.2 Valeur retournée par une fonction

Toute fonction retourne une valeur qui représente le résultat du "travail" de cette fonction. On
obtient cette valeur retournée en appelant la fonction.
La valeur retournée peut être affectée à une variable, utilisée directement dans un calcul, ou rester
inutilisée si le programme n'en a pas besoin.
var = int("123") #Couverture var en entier

print (var/2)
var = str(var) #Couverture var en string
print (var)
Si la fonction retourne plusieurs valeurs alors le résultat sera représenté par un tuple. On accède à
ces éléments du tuple soit:
1. par leur indice ou bien
2. en réalisant une affectation à de multiples variables
res = div_euclidienne(20,3)
Print ("Q= ",res[0], "R= ",res[1])
#OU BIEN
quotient,reste = div_euclidienne(20,3)
Print ("Q= ", quotient, "R= ", reste)
4.4.3 Les procédures

Les procédures sont des fonctions dont le comportement ne retourne pas une donnée. Mais même si
elles ne calculent rien, les procédures en python retournent une valeur qui est la valeur None. C'est
pourquoi on peut se permettre de les appeler, elles aussi, des « fonctions ».
n Par exemple la fonction prédéfinie : print()
4.5 Modules en Python

4.5.1 Définition
Certaines fonctionnalités de Python ne sont pas chargées par défauts, d’où la nécessité d’utiliser la
notion du module. Les modules sont des programmes Python qui contiennent des collections de
variables globales et de fonctions que l'on est amené à réutiliser souvent, on les appelle aussi
bibliothèques ou librairies. Un module est un fichier python exécutable qui peut être importé vers un
autre programme python. Voici une liste non exhaustive des propriétés caractéristiques :
n Un programme python peut donc se composer d'un ou de plusieurs modules.
n Un module python fait généralement appel à des éléments qui sont présents dans d'autres
modules python.

n Un fichier script python, d'extension .py, se nomme aussi un module.
n Il y a des modules prédéfinis par le langage python, les autres modules sont téléchargeables.
n Exemple des Modules : math, cmath, random, turtle, matplotlib, numpy …
4.5.2 Importation de Module

La syntaxe pour importer le module ‘nomModule’ est :
import nomModule
L’appel des fonctions de ce module doit être précéder par le nom du module :
nomModule.nomFonction
Dans le cas où le nom du module est long, difficile à retenir ou s’il y a une ambiguïté entre plusieurs
modules de même noms, on peut le renommer en utilisant la notion de l’alias. Voici la syntaxe :
import nomModule as aliasModule
Par exemple, le module re contient des fonctions et des constantes pour les expressions rationnelles.
On peut utiliser des alias si on a déjà un re différent ou lorsque le nom du module peu maniable
comme le pyplot:
Import re as regex
Import matplotlib.pyplot as plt (pour la visualisation des données)
4.5.3 Importation des fonctions du Module
La déclaration ci-dessus consiste à importer l’ensemble des fonctions d’un module. En revanche, si
nous souhaitons importer une sous ensemble des fonctions de ce module ‘nomModule’, on déclare :
from nomModule import fct1, fct2,…
L’appel de ces fonctions se fait d’une manière directe sans passer par le nom du module. Voir
l’exemple ci-après :
Il existe une autre déclaration qui consiste à importer toutes les fonctions du module :
from nomModule import *
MAIS c’est déconseillé, car on ne pourrait plus faire la distinction entre les fonctions et les variables
provenant de différents modules, s'ils sont nommés de façon identique. Par exemple, si on a :
from math import *

from cmath import *
è Par conséquent, nous ne pourrons plus différencier la fonction sqrt() du module math de la
fonction sqrt() du module cmath .

4.5.4 Package
Une Package est le regroupement de plusieurs modules. Pour importer un module d’une package
donnée on déclare:
From package import module Ou bien Import package.module
Par exemple le package matplotlib qui permet de générer des graphes depuis Python, possède le
module plyplot. Il y a deux façons de déclaration possible :
from matplotlib import pyplot as plt

import matplotlib.pyplot as plt
De même façon on peut importer une ou plusieurs fonction d'un module d’une package:
From package.module import functions
4.5.5 Fonctions d'aide et d’exploration

La fonction help(): affiche le contenu des chaînes de documentation DocString (voir chapitre 6). Il
s’agit d’une description détaillée de la fonction, notamment ses paramètres d’entrées et de sorties.
La fonction dir(): affiche la liste de toutes les fonctions et variables disponibles dans un module.

4.5.6 Quelques modules Python courant

Il existe une série de modules que vous serez probablement amenés à utiliser si vous programmez en
Python. En voici une liste non exhaustive de ces modules, pour la liste complète, reportez-vous à la
page des modules sur le site de Python1:
n math : fonctions et constantes mathématiques de base (sin, cos, exp, pi...).

n random : génération de nombres aléatoires.
n statistics : fournit des fonctions statistiques sur des données numériques.
n os : interaction avec le système d'exploitation.
n Glob : recherche des fichiers selon les règles utilisées dans le shell Unix.
n Turtle : permet de réaliser des dessins graphiques
n sys : interaction avec l'interpréteur Python, passage d'arguments.
n time : accès à l'heure de l'ordinateur et aux fonctions gérant le temps.
n urllib : récupération de données sur internet depuis Python.
n Tkinter : interface python avec Tk. Création d'objets graphiques.
n re : gestion des expressions régulières (parsing).
n ….
4.5.7 Module: math

Le module math fournit l'accès aux fonctions mathématiques pour la manipulation des valeurs
numériques. Par exemple :
n math.exp(x): Renvoie e à la puissance x, où e = 2.718281
n math.log(x) renvoie le logarithme naturel de x en base e.
n math.log10(x): Renvoie le logarithme de x en base 10.
n math.pow(x, y): Renvoie x élevé à la puissance y.
n math.sqrt(x): Renvoie la racine carrée de x.
Fonctions trigonométriques:
n math.cos(x), math.sin(x), math.tan(x)
n math.acos(x), math.asin(x), math.atan(x)
n math.dist(p, q): Renvoie la distance Euclidienne entre deux points p et q
Constantes, comme:
n math.pi, math.e, etc
4.5.8 Module random

Le module Random consiste à générer et manipuler les valeurs aléatoires. Il possède plusieurs
fonctions parmi eux on trouve :
1
https://docs.python.org/fr/3/py-modindex.html.
n La fonction random(): elle produit des nombres uniformément distribués entre 0 et 1. c'est la
fonction aléatoire que nous utiliserons le plus souvent. L’exemple suivant permet de créer
une liste avec trois valeurs aléatoires entre 0 et 1.
n La fonction seed(n) permet aux autres fonctions du module random de reproduire les
mêmes valeurs aléatoires à chaque exécution. On exécute seed avec une valeur de n, avant
l'appel des fonctions random.
n La fonction randrange(start,end) retourne un élément choisi aléatoirement dans

range(start,end,pas), avec 0 comme valeur par défaut de start et 1 comme valeur par défaut
de pas.
n La fonction shuffle(liste) réorganise au hasard les éléments d’une liste.
n La fonction choice(list) permet de choisir un élément au hasard dans une liste. Elle permet aussi
de choisir au hasard un échantillon d’éléments en autorisant les doublons :
n La fonction sample(l,n) permet de choisir au hasard un échantillon de n éléments sans

doublons de la liste l. Elle retourne une nouvelle liste.

4.5.9 Module statistics

Le module statistics fournit des fonctions pour le calcul des valeurs statistiques sur des données
numériques. Voici quelques fonctions du module :
n mean() Moyenne arithmétique des données.

n stdev() Écart-type d'un échantillon.
n variance() Variance d'un échantillon.
n pstdev() Écart-type de la population.
n pvariance() Variance de la population
4.5.10 Module OS
Le module os fournit une façon portable d'utiliser les fonctionnalités dépendantes du système
d'exploitation. Voici la description de quelques fonctions de ce module :
n getcwd() Renvoie une chaîne de caractères représentant le répertoire de travail actuel.

n chdir(path) Change le répertoire de travail actuel par path.
n mkdir(path, mode=0o777, *, dir_fd=None): Crée un répertoire appelé path avec comme
mode d’accès, la valeur numérique mode.
4.5.11 Module glob

Le module glob permet de rechercher tous les fichiers correspondant à un motif particulier selon les
règles utilisées par le shell Unix.
n La fonction glob(pathname|*) de ce module renvoie une liste, avec les noms des fichiers
dans le répertoire courant de travail.
4.5.12 Module TURTLE

Le module Turtle permet de réaliser des "graphiques tortue", Il s’agit des dessins géométriques
correspondant à la piste laissée par une petite « tortue » virtuelle. Nous contrôlons les déplacements
sur l'écran de l'ordinateur à l'aide des instructions simples. Voici une description de quelques
fonctions de ce module :
n reset() On efface tout et on recommence

n goto(x, y) Aller à l'endroit de coordonnées x, y
n forward(distance) Avancer d'une distance donnée
n backward(distance) Reculer avec une distance donnée
n up() Relever le crayon pour pouvoir avancer sans dessiner
n down() Abaisser le crayon pour recommencer à dessiner
n color(couleur) choisir le couleur du crayon, peut être une chaîne prédéfinie ('red', 'blue',
'green', etc.)
n left(angle) Tourner à gauche d'un angle donné (exprimé en degrés)
n right(angle) Tourner à droite d'un angle donné (exprimé en degrés)
n width(épaisseur) Choisir l'épaisseur du tracé
n write(texte) écrit une chaîne de caractères délimitée avec : " ou '
n Begin_fill(): indique que la forme choisie devra être remplie.
n End_fill(): termine le coloriage
n Circle(r): dessine un cercle avec un rayon r
Les codes suivants illustrent deux exemples avec des fonctions du module Turtle :
Exemple1 :
from turtle import *

forward(120) #trace une ligne de 120 mm
left(90) #tourne à gauche avec l’angle 90°
color('red') # change la couleur en rouge
forward(80) #trace une ligne de 80 mm
Exemple 2 :

5 Fonctions & Procédures : créer un sous-programme en Algorithme

5.1 Définir une fonction
5.1.1 Principe
Les scripts que vous avez écrits jusqu'à présent étaient à chaque fois très courte. Dans les véritables
projets, les lignes de programme vont commencer à s'accumuler...
Nous pouvons définir nos propres fonctions pour pouvoir les appeler ensuite, comme pour les
fonctions prédéfinies. La figure suivante illustre le mécanisme d’un cycle de vie d’un appel d’une
fonction dans un programme :
5.1.2 Buts de l’utilisation

L’objectif de définir et d’utiliser les fonctions est la décomposition des problèmes en sous problèmes
de taille réduite. Il s’agit d’isoler les séquences d’instructions fréquemment appelées dans un sous-
programme. Cette approche modulaire réduit le nombre d’instructions redondantes. Voici quelques
avantages de l’utilisation des sous-programmes :
n Réduction de la taille du programme
n Avoir plus de lisibilité de code qui facilite la compréhension du programme
n Réutilisation du sous-programme
n …
5.2 Procédure et fonction

5.2.1 Définition
On distingue entre deux formes de sous-programme: Procédure et Fonction
1. Procédure: est un sous-algorithme qui prend zéro ou plusieurs paramètres, puis il exécute
une suite d’instructions.
Liste des paramètres Procédure

Liste d’instructions
2. Fonction: est un sous-algorithme qui prend zéro ou plusieurs paramètres, puis il exécute une
suite d’instructions afin de générer et retourner un résultat.
Liste des paramètres Fonction Résultat
Liste d’instructions

5.2.2 Déclaration d’une Procédure

Pour déclarer une procédure il suffit de lui donner un nom et préciser ses arguments d’entrés. Voici
la syntaxe :
Procédure <nom_proc>(param1:type, param2:type,…….paramN:type)

Variables
<déclaration des variables locales>
Début
<Instructions>
Fin
Les param1…paramN: ce sont les paramètres de la procédure. Il s’agit des variables qui permettent à
la procédure de communiquer avec l’extérieur. Certaines procédures n’ont pas de paramètres.
n Procédure nom_proc()
Exemple: écrire une procédure qui affiche la somme de deux entiers.
Attention l’affichage ce n’est pas un résultat de sortie, donc il s’agit bien d’une procédure.
Procédure affiche_somme (x:entier, y:entier)

Variables S:entier
début
S ß x +y
Ecrire (S)
Fin
5.2.3 Déclaration d’une Fonction
La déclaration d’une fonction se fait de même façon que la déclaration d’une procédure, à
l’exception de préciser le type du résultat. Voici la syntaxe :
Fonction <nom_fct>(param1:type,…….paramN:type): Type de résultat

Variables
<déclaration des variables locales>
Début
<Instructions>
Fin
Le corps de la fonction doit contenir au moins une instruction de retour se forme:
Nom_fonctionßexpression ou bien retourne expression
Exemple: écrire une fonction qui retourne le Max entre deux entiers ?
Fonction fct_max (x:entier, y:entier):entier

début
si x>=y Alors
fct_maxßx \\ ou retourne x
sinon
fct_maxßy \\ ou retourne y
Finsi
Fin

5.2.4 Appel d’un sous algorithme

L’appel d’un sous algorithme (soit fonction ou procédure) se fait par le nom de la procédure ou la
fonction suivi par les valeurs de ses arguments entre parenthèses :
nom_proc(var1,….varN)
Exemple:
Affiche_somme(x,y)
ZßFct_max(x,y)
5.3 Passages de paramètres
Il existe deux types de passages de paramètres :
1. Passage par valeur

2. Passage par adresse
5.3.1 Passage par valeur

Passage par valeur: le sous-algorithme reçoit une copie de la valeur du paramètre de l’appel, par
conséquent ce paramètre ne sera jamais modifié.
Affiche_somme(a,b)
Exemple : la procédure suivante affiche_double reçoit un entier avec un passage par valeur puis elle
affiche son double :
Procédure affiche_double (x:entier)

début
x ß 2*x
Ecrire (‘dans la procédure x=‘ ,x)
Fin
//Algorithme principal
xß2
affiche_double (x)
Ecrire (‘dans l Algo Principal x=‘ ,x)
//Résultat d’exécution
dans la procédure x=4
dans l Algo Principal x=2
On remarque bien que la valeur de la variable x n’a pas été changée après l’appel de la procédure
affiche_double.
5.3.2 Passage par adresse

Passage par adresse: la procédure utilise l’adresse mémoire du paramètre de l’appel, par
conséquent ce paramètre sera modifié. Les paramètres passés par adresse sont précédés par le mot
clé Var
Affiche_somme(Var a, Var b)
Exemple : la procédure suivante affiche_double reçoit un entier avec un passage par adresse puis
elle affiche son double :
Procédure affiche_double (x:entier)

début

x ß 2*x
Ecrire (‘dans la procédure x=‘ ,x)
Fin
//Algorithme principal
xß2
affiche_double (Var x)
Ecrire (‘dans l Algo Principal x=‘ ,x)

//Résultat d’exécution
dans la procédure x=4
dans l Algo Principal x=4
Avec le passage par adresse (ou référence), on remarque que la valeur de la variable x a été modifiée
par la procédure affiche_double.

6 Fonctions & Procédures : créer un sous-programme en Python

6.1 Principe
6.1.1 Fonction et procédure en python
Une procédure est un regroupement d'instructions que l'on nomme par un nom afin de pouvoir les
exécuter de manière plus simple et/ou répétitive.
Une fonction en Python est une procédure qui calcule et qui retourne un résultat.
Voici un rappel de quelques fonctions prédéfinies :
• print() est une procédure qui permet de faire des affichages à l'écran ;
• turtle.circle() est une procédure qui permet de tracer un cercle à l'écran.
• math.sin() et math.cos() sont des fonctions qui permettent de calculer le sinus et le cosinus
d'un nombre et retournent leur résultat sous la forme d’un nombre flottant ;
• float(), int(), str(), bool() sont des fonctions qui permettent de convertir une donnée d'un
type dans un autre type, et retournent leur résultat sous la forme de la donnée dans le type
désiré;
• random.randrange() est une fonction qui permet de choisir un entier au hasard.
Remarque : En python, nous dirons indifféremment « fonction » pour parler de fonction ou de

procédure. Dana le langage Python, une procédure est une fonction qui retourne implicitement la
valeur None.
6.1.2 Définition
Une fonction a un nom, un bloc d'instructions et des paramètres. Le nom de la fonction doit être
différent aux mots réservés du langage et il ne contient aucun caractère spécial sauf le « _ ».
L’appel de la fonction est constitué du nom de la fonction suivi de parenthèses.
Les avantages de l’utilisation des fonctions dans un programme python sont:
n réaliser plusieurs fois la même opération au sein d’un programme.
n rendre le code plus lisible et plus clair en le fractionnant en blocs logiques.
6.1.3 Syntaxe
La syntaxe pour déclarer et définir une fonction est :
def nomDeMaFonction([parametre1], … , [parametreN]):

"""docstring
documentation de la fonction qui s'affichera en tapant
help(nomDeMaFonction)
"""
bloc d'instructions définissant la fonction
return valeur_retournee
Si on ne met pas de return dans le corps de la fonction, ou bien un return sans spécifier de valeur,
Python retourne automatiquement la valeur None, dans ce cas-là Il s’agit d’une procédure

6.2 Exemples de fonctions

6.2.1 Fonction sans paramètres
def Multipl5() : Multipl5()
""" Cette procédure affiche les 10 premiers termes """
de la table de multiplication de 5"" --- Résultat d’exécution ---
n=1 5 10 15 20 25 30 35 40 45 50
While n<11: """
print (n*5)
n =n+1
6.2.2 Fonction avec paramètres et des valeurs par défaut
def sommeCarres(param1 = 3, param2 = 4) :

""" Cette fonction calcule la somme des carrés de ses 2 arguments, et retourne le
résultat"""
calcul = param1 ** 2 + param2 ** 2
return calcul
x, y = 5 , 8
print(x,"^2 + ", y, "^2 = ",sommeCarres(x,y))
"""
-------- Résultat d'exécution ---
5 ^2 + 8 ^2 = 89
"""
6.2.3 Procédure
def salutation(param_prenom) :
""" cette fonction affiche une formule de bienvenue et ne retourne rien"""
print("bonjour",param_prenom)
#return None prenom = "Mohammed"
print(salutation(prenom))
"""
bonjour Mohammed
None
"""
Attention ! Ce n'est pas parce qu'une fonction affiche quelque chose à l'écran qu'elle retourne une
valeur. En outre, le mot clé return ne provoque pas l'affichage à l'écran.
6.2.4 Fonction avec paramètre liste
def produitScalaire(p_vect1, p_vect2) :

""" cette fonction calcule et retourne le produit scalaire de 2 vecteurs dont les
coordonnées sont passées en paramètre sous forme de deux listes. """
prod = 0
for k in range(len(p_vect1)): v1 = [1,2,3]
prod = prod + p_vect1[k]*p_vect2[k] v2 = [5,2,6]
return prod print("v1 * v2=",
produitScalaire(v1,v2))
"""
v1 * v2= 27
"""

6.2.5 Fonction graphique avec le module Turtle

def avance_et_traceCercle(pos,r) :
""" cette fonction avance de pos px avec la tortue, puis trace un cercle de rayon r px.
Elle retourne la position finale de la tortue.
"""
from turtle import forward, circle, position
forward(pos)
circle(r)
return position()
avance_et_traceCercle(50,100)
"""
(50.00,-0.00)
"""
6.2.6 Fonction qui retourne plusieurs valeurs

def div_euclidienne(nb1, nb2) :
""" Cette fonction retourne 2 valeurs séparées par des virgules (un tuple). Il s'agit du
quotient et du reste de la division euclidienne.
"""
quotient = nb1 // nb2 Q , R = div_euclidienne(30 , 4)
reste = nb1 % nb2 print("Quotient de 30/4 = ",Q)
return quotient, reste print("Reste de 30/4 = ",R)
"""
Quotient de 28/4 = 7
Reste de 28/4 = 2
"""
6.3 Appel d’une fonction

6.3.1 Syntaxe
L’appel d’une fonction se fait par son nom suivi de ses arguments entre parenthèses. Les valeurs des
arguments vont être affectées aux paramètres. Lorsque la fonction retourne plusieurs valeurs ceci
est toujours fait sous forme d'un tuple. Quelques constatations :
n Ne pas confondre « arguments » et « paramètres » d'une fonction. Les paramètres font

partie de la définition de la fonction. En revanche les arguments sont les valeurs fournies à la
fonction lors d'un appel, cela peut-être une valeur littérale, une variable, ou toute expression
fabriquant une valeur.
n Les paramètres d'une fonction n'ont pas de signification hors de la portée locale, c’est à dire
le corps de cette fonction. Par conséquent, Il est impossible d'accéder à ces paramètres (par
leur nom) en dehors du bloc de la fonction.
n par convention, on nomme souvent les paramètres avec un préfixe: p_
6.3.2 Arguments de fonction

Il est strictement obligatoire de préciser les arguments de la fonction lors de son appel. Ainsi il est
nécessaire de respecter le même ordre lors de l’appel que dans la définition de la fonction. Il est
possible de passer un ou plusieurs argument(s) de manière facultative et de leur attribuer une valeur
par défaut (exemple2).

def fct(x=0,y=0) :
return x,y
Fct() # (0,0)
Fct(10) #(10,0)
Fct(0,10) #(0,10)
Remarque: les arguments sont pris dans l’ordre dans lesquels on les passe lors de l’appel.
MAIS ! Comment faire si on souhaitait préciser l’argument y et garder la valeur de x par défaut?
Pour réaliser un tel objectif il suffit de préciser le nom de l’argument lors de l’appel:
Fct(y=10) #retourne (0,10)
6.3.3 Ordre des arguments

Les arguments passés lors de l'appel doivent figurer dans le même ordre que celui des paramètres
dans la définition de la fonction.
Une dérogation à cette règle : lorsqu'on appelle une fonction, on peut adopter un ordre quelconque
pour les arguments lorsqu'on précise les noms des paramètres associés pour chaque argument.
Par exemple: resultat(p_unite2 = 9, p_unite1 = 15, p_unite3=11)
On peut rentrer les arguments dans un ordre arbitraire en précisant le nom de l’argument lors de
l’appel:
Fct(y=20,x=10)
n Arguments par mot-clé = Les arguments avec une valeur par défaut
n Arguments positionnels = Les arguments sans valeur par défaut
Recommandation: Préciser le nom des arguments par mot-clé lors de l’appel d’une fonction. Par
exemple : print("Message ", end="")
6.3.4 Paramètres optionnels (valeur par défaut)

Certains paramètres peuvent être définis avec une valeur par défaut. Il devient alors facultatif
d'indiquer leur valeur au moment de l'appel. La valeur par défaut étant utilisée à la place de
l'argument manquant.
Exemple 1 : la fonction print a un argument optionnel end dont la valeur par défaut est "\n", c'est à
dire un caractère invisible de retour à la ligne.
Exemple 2 : soit la fonction avance_et_traceCercle() suivante dont on donne des valeurs par défaut
aux paramètres p_avant et p_rayon :
def avance_et_traceCercle(p_avant = 50, p_rayon = 100) :

from turtle import forward, circle, position
forward(p_avant)
circle(p_rayon)
return position()

>>> avance_et_traceCercle()
(50.00,-0.00)
>>> avance_et_traceCercle(10,400)
(60.00,0.00)
>>> avance_et_traceCercle(-40)
(20.00,0.00)
>>> avance_et_traceCercle(p_rayon = 70)
(70.00,0.00)
Question : simuler le résultat de ces instructions si on ajoute la fonction reset() dans le code de la
fonction ‘avance_et_traceCercle’:
6.4 Fonctions particulaires

6.4.1 Fonction mathématique f(x)
Pour définir une fonction mathématique f(x) on utilise le mot clé lambda, avec la syntaxe:
Fct = lambda args:

définition de la function
Voici quelques exemples :
Ou encore une fonction avec deux variables :
6.4.2 Fonctions sur les séquences

Une séquence peut être : liste, tuple, dictionnaire.
6.4.2.1 Fonction map

La fonction map consiste à appliquer une fonction sur les éléments d’une séquence (liste, tuple,
dictionnaire…) et elle renvoie un objet map (un itérateur).
Voici la syntaxe :
Map(fonction, séquence)
Exemple: La fonction map reçoit une liste et une fonction qui calcule le double d’un nombre et elle
retourne un objet map qui comporte les doubles des éléments de la liste reçu en argument.

6.4.2.2 Fonction filter

La fonction filter permet de filtrer les éléments d’une séquence en évaluant une condition (comme
if), Elle retourne un objet filter, qu’on peut le convertir à une nouvelle structure
n Syntaxe:
filter(fonction, séquence)
Exemple: mettre les éléments pairs d’une liste dans une nouvelle liste.
6.4.3 Fonction main

Dans un programme python ou dans un module, les instructions qui ne font pas partie des blocs de
définitions des différentes fonctions sont appelées le programme principal.
Généralement on regroupe les instructions du programme principal à la fin du module, après toutes
les définitions des fonctions.
Les instructions du programme principal peuvent être regroupées dans une fonction spécifique, la
fonction main. Voici sa déclaration.
if __name__ == "__main__":
Cette déclaration conditionnelle consiste à définir deux façons d’exécution du programme python :
1. Si le programme est exécuté en tant que script, le résultat du test if sera True et le bloc
d’instructions sera exécuté.
2. Si le programme est importé en tant que module, le résultat du test if sera False et le bloc
d’instructions ne sera pas exécuté.
6.5 Portée des variables

6.5.1 Variables locales
Chaque nom de variable est connu dans un "espace de nom" et inconnu hors de cet espace. Cette
espace de nom est appelée "portée locale" de la variable.
Une variable est dite locale lorsqu’elle est créée dans une fonction. Par exemple la constante pi est
connue dans le module math, et inconnue en dehors. Si on souhaite l'utiliser, il faut importer son
module.
from math import pi

print("la valeur de pi est", pi)
Exemple : la variable y est inconnue à l’extérieure de la fonction ‘fct’

6.5.2 Variables globales

Une variable Globale est une variable déclarée dans le programme principal, elle est visible dans
celui-ci ainsi que dans toutes les fonctions. Voici la portée des variables Locale et Globales:
n Les variables déclarées dans une fonction sont inconnues hors de la portée locale de cette
fonction.
n Les paramètres des fonctions sont inconnus hors de la portée locale de cette fonction
n Les variables déclarées dans un module sont inconnues hors de la portée locale de ce
module.
n Une variable est dite globale lorsqu’elle est créée dans le programme principal.
n Variable Globale: est une variable qui est connue dans tout un module.
La variable x est connu dans le programme principal ainsi dans la fonction fct().
Attention! Python ne permet pas la modification d’une variable globale dans une fonction:
La valeur de x n’a pas été changé après l’appel de la fonction fct(). Il s’agit d’un passage de paramètre
par valeur.
Voici le deuxième exemple :
L’erreur renvoyée montre que Python pense que x est une variable locale qui n’a pas été encore
assignée. Comment faire un passage de paramètre par adresse afin de changer sa valeur par une
fonction ?
Si on veut Vraiment modifier une variable globale dans une fonction, il faut utiliser le mot-clé global:
La valeur de x à passer de 8 à 16 après l’appel de la fonction fct().
6.6 Passage de paramètres en python

6.6.1 Principe
En algorithme, on parle de
n Passage par valeur: la fonction appelée ne modifie pas la valeur du paramètre
n Passage par adresse ou référence: la fonction appelée modifie la valeur du paramètre
En revanche le seul type de passage de paramètre en python est le passage par référence:
Cet exemple montre que la variable et le paramètre on la même adresse mémoire
MAIS!!.... dans ce cas-là comment python gère la mutabilité des variables !?
6.6.2 Objet mutable et non mutable

Contrairement le passage par référence définie en algorithme, ce type de passage n’assure pas la
modification (ou la non modification) du paramètre. La modification du paramètre dépend de son
type. Nous avons des types Mutables et d’autres non mutables
En python, il existe deux types d’objets:
n Les mutables comme les listes, dictionnaires …
n Les non mutables comme les strings, int, float, tuples,…
Les mutables sont ceux qu’on peut modifier par la fonction appelée et les non mutables sont ceux
qu’on ne peut pas modifier par la fonction appelée.
6.6.2.1 Objet non mutable

Dans l’exemple ci-après on remarque bien que la valeur de la variable entière x n’a pas été échangée
par la fonction ‘fct’ :

6.6.2.2 Modification d’un objet non mutable

Si vous voulez modifier la valeur d’une variable de type non mutable par une fonction, que faire!
Par exemple si on cherche à définir une fonction qui consiste à permuter la valeur de deux variables.
On peut écrire le code suivant :
def permuter(x,y):
t=x
x=y
y=t
x=3
y=5
permuter(x,y)
print("x:",x,"y=",y)
En remarque dans cet exemple que la valeur de x et y n’a pas été changé par la fonction.
Modification d’un objet non mutable : Pour modifier la valeur d’un objet mutable il suffit que la
fonction renvoie une valeur puis on récupère cette valeur renvoyée dans une variable portant le
même nom.
def permuter(x,y):
return (y,x)
x=3
y=5
x,y=permuter(x,y)
print("x:",x,"y=",y)
6.6.2.3 Objet mutable: liste

Les types modifiables, tels que les listes, on peut les changées directement au sein d’une fonction.

Dans cet exemple la liste est traitée comme une variable globale, on remarque que le deuxième
élément de la liste a été bien modifié par la fonction.
De même si vous passez une liste en argument, elle est modifiable au sein de la fonction:
Attention ! Les Tuples ne sont pas modifiables
6.6.2.4 Eviter la modification d’un objet mutable

Si vous voulez éviter la modification de la liste, lorsqu’elle est passée en argument à une fonction.
Nous avons à notre disposition deux solutions possible :
1. Utiliser des tuples: Python renverra une erreur car ces derniers sont non modifiables. Ou
bien
2. Passer explicitement afin qu’elle reste intacte dans le programme principal, passage par
valeur.
n Une copie de y est créée à la volée lorsqu’on appelle la fonction, ainsi la liste y du module
principal reste intacte.
n Idem pour z
Si le paramètre est un tuple on aura un message d’erreur :

6.6.3 Règle LGI (Locale General Interne)

La règle LGI (Locale General Interne) consiste que lorsque Python rencontre une variable,
1. Il vérifiera si la variable est Locale,
2. Sinon il vérifiera si elle est Globale
3. Et enfin il testera si elle est Interne. C’est à dire un mot clé de Python, par exemple :
len.
6.6.4 Recommandations sur les variables et les paramètres

Conseil 1 : Même si Python peut reconnaître une variable ayant le même nom que ses propres
fonctions ou variables internes, évitez de les utiliser car ceci rendra votre code confus!
Inconvénients des variables Globales:
n vos fonctions ne seront pas réutilisables dans un autre contexte
n Très difficile de relire ou mettre à jour votre code par la suite.
Conseil 2 : Évitez les variables globales
n Plutôt que d’utiliser des variables globales, passez vos variables explicitement aux fonctions
comme des argument(s).
Conseil 3 : Modification d’une liste dans une fonction
n Il est conseillé d’indiquer clairement la liste dans votre code

n C’est-à-dire que la fonction renvoie la liste modifiée puis on récupère cette liste
renvoyée dans une variable portant le même nom.

n Exemple 1 :
n Exemple 2 :
Les deux exemples génèrent le même résultat, MAIS
n Exemple1: La liste liste_notes passée à la fonction est écrasée par la liste renvoyée
n Exemple2: n’est pas forcément évident de comprendre que la liste est modifiée dans la
fonction.
6.7 Structure d’un programme python

6.7.1 Structure générale
Etape Tâche Exemple
1 On écrit d'abord un entête de #!/usr/bin/python3
module, constitué d'une chaîne # -*- coding: UTF-8 -*3.
de documentation et de méta- """
informations (date, auteur…). (DocString) Ce module détermine les résultats
semestriels des étudiants.
"""
# fichier: resultats_semestre.py
# auteur : prof
# date : septembre 2024
2 On rassemble tous les imports ### imports ###

en début du module. import random
import turtle
3 on indique toutes les ### constantes et variables globales ###

déclarations (initialisations) de NOTE_MIN_UE = 8
constantes et de variables MIN_MOYENNE = 10
globales COEF_UE1 = 10
COEF_UE2 = 9
COEF_UE3 = 11
4 On définit toutes les fonctions ### définitions ###

du module, les unes à la suite def resultat(p_unite1, p_unite2, p_unite3) :

des autres. """détermine et retourne le résultat du semestre"""

somme = COEF_UE1 + COEF_UE2 + COEF_UE3
moy=(p_unite1*COEF_UE1+p_unite2*COEF_UE2+
p_unite3* COEF_UE3) /somme
return moy
def graphique(p_reussi):
if p_reussi :
turtle.color('black', 'green')
turtle.begin_fill()
turtle.circle(100)
else :
turtle.color('black', 'red')
turtle.begin_fill()
turtle.circle(100)
turtle.end_fill()
return None
5 On écrit le programme principal ### programme principal ###

du module. if __name__ == "__main__" :
prenom = input("quel étudiant ? ")
print("voici les résultats de", prenom, ":")
note1 = random.randrange(21)
…
print("Les notes des UE 1 2 et 3 sont", note1, note2,
note3)
moyenne_generale = resultat(note1, note2, note3)
print("La moyenne générale est de",
moyenne_generale)
valide = note1>=NOTE_MIN_UE and
note2>=NOTE_MIN_UE and
note3>=NOTE_MIN_UE and
moyenne_generale>=MIN_MOYENNE
graphique (valide)
6 on copier-coller les résultats """ --- RESULTAT d’EXECUTION

d'exécution entre triple- quel étudiant ? Georges
guillemets. voici les résultats de Georges :
- les notes des UE 1 2 et 3 sont 0 13 13
- la moyenne générale est de 8.666666666666666
"""
6.8 Création : Module et Package

6.8.1 Création du Module
Lorsque votre programme grandit, vous pouvez séparer votre code dans plusieurs fichiers. Un
module vous permet de placer des définitions dans un fichier et de les utiliser dans un script ou une
session interactive.
n Un module est un fichier contenant des définitions et des instructions avec l’extension .py
n Import nomModule: permet d’importer le module
Voici les étapes de création d'un module,

1. écrire un fichier MyModule.py qui contient la ou les fonctions, exemple MyFonction
2. Dans un nouvel éditeur python importer le module MyModule
3. Utiliser la fonction MyFonction du module MyModule
6.8.2 Création de la Package

Package est le regroupement de plusieurs modules. Pour Importer un module d’une package on
utilise la syntaxe suivante :
From package import module

From package.module import functions
Afin de créer notre propre package il suffit de respecter les étapes de création suivantes :
1. Créer un dossier portant le nom de votre package.
2. Dans ce dossier, ajouter le fichier suivant: __init__.py , cela indique à python qu'il s'agit
d'une package. Ce fichier peut être vide, seule sa présence est importante.
3. Ensuite ajouter le ou les modules dans ce répertoire.
6.8.3 Structuration d’un module

Le fichier de votre module doit comporter entre autre les trois parties suivantes :
1. En-tête : Contient le nom

du fichier, le nom des
auteurs, la date ainsi
qu'une documentation sur
ce que fait le script.
2. Programme : Contient les
instructions de l'algorithme
traduites en langage
python.
3. Exécution : Après avoir
enregistré le module en
.py, on exécute le
programme puis on
récupère les résultats de
l'exécution (d’une
simulation) entre des
triple-guillemets, comme
dans l'exemple ci-dessous.

7 Récursivité
7.1 Définition
7.1.1 Appel d’une fonction dans une autre
Nous avons vu des fonctions qui étaient appelées depuis le programme principal. Mais il est possible
d’appeler une fonction depuis une autre fonction (des fonctions imbriquées). La figure suivante
illustre le processus de l’appel inter-fonctions à travers un exemple.
Dans cette exemple nous avons une un programme principal qui appel la fonction calc_vals avec
deux arguments : début et fin. Cette fonction doit retourner une liste en appliquant une fonction
polynomiale sur l’ensemble des entiers entre le début et la fin.
Pour avoir une bonne organisation du code, la fonction calc_vals va déléguer le comportement du
calcul polynomial à une deuxième fonction qui s’appelle polynome. Cette dernière reçoit un entier x
et elle retourne f(x) avec f(x)=x2-2x+1
Fonction polynôme
x=val
entre -5 et 5 F(x)=x2-2x+1
Fonction calc_vals
début=-5 Retourne la
Fin=5 liste
Programme Principale
7.1.2 Principe de récursivité

Tout objet est dit récursif s’il se définit à partir de lui-même, par exemple en mathématique:
définition des entiers

n 0 est un entier
n Si n est un entier, alors n+1 est un entier
Une structure est récursive si un de ses attributs en est une autre instance, par exemple une liste
récursive
n Le premier élément
n Et le reste de la liste (qui est aussi une liste)
Une fonction est dite récursive si elle comporte, dans son corps, au moins un appel à elle-même
7.1.3 Fonction Récursive

Fonction Récursive est une fonction qui s'appelle à elle-même. Elle est typiquement utilisée
lorsqu'une expression dans la fonction nécessite un résultat qui peut être produit par un appel à la
fonction elle-même avec un nouvel argument.
Par exemple, le calcule de n factoriel (n!) consiste à calculer le n-1 factoriel ((n-1) !) puis le multiplier
fois n. ensuite de faire la même chose pour calculer le( n-1) ! et ainsi de suite jusqu’à 1.
def factorielle(p_nombre):
if nombre > 1:
return p_nombre*factorielle(p_nombre - 1)
else :
return 1
Fonction Récursive: simulation de la fonction factorielle avec n =4 :
4*6=24
3*2=6
2*1=2
Factorielle(4) Factorielle(3) Factorielle(2) Factorielle(1)

6 2 1
Résultat final= 24
Remarque : La fonction reste figée dans le même état, jusqu’à ce que la fonction appelée lui renvoie
une valeur.
7.1.4 Exemples de fonctions récursives

Calcul de la somme des entiers de 1 à n
n On calcule la somme jusqu’à n-1
n Puis on ajoute n
Donc d’une manière itérative pour calculer la somme(n), on calcule la somme de (n-1) c’est-à-dire on
appel somme(n-1). Lorsqu’on arrive à n=1 on arrête l’appel récursif.

Idem avec le produit (fonction factorielle).
7.2 Types des récursivités

7.2.1 Récursivité terminale
Pour une fonction récursive, on parlera de deux types de récursivité :
1. La récursivité terminale si aucune instruction n’est exécutée après l’appel de la fonction à elle-
même
def f(n):
if n==0:
print("Hello")
else:
f(n-1)
f(3)
2. La récursivité non terminale dans cas contraire :
def f(n):
if n>0:
f(n-1)
print("Hello")
f(5)
7.2.2 Récursivité directe

Lorsque f s’appelle elle-même, on parle de récursivité directe. Par exemple de la fonction factorielle.
L’autre cas, et lorsque f appelle g qui appelle f, il s’agit aussi d’un appel récursif, on parle de la
récursivité indirecte

Remarque : Ce type de récursivité est souvent plus dur à suivre et à déboguer.
7.3 Fonction récursive

7.3.1 Définir une fonction récursive
Il suffit que la fonction s’appeler elle-même. Cette définition de la récursivité est la même entre
l’algorithme et le langage Python.
Par la suite un exemple d’une fonction récursive en algorithme et sa traduction en python :
n Algorithme
Fonction f(n:entier):entier
Debut
fßf(n-1)
Fin
n Python
Def f(n):
Return f(n-1)
MAIS! On s’arrête quand!? La fonction f telle qu’elle est écrite ne s’arrête jamais :
n Appel : f(2)
n Appel : f(1)
n Appel : f(0)
n Appel : f(-1)
n Appel : f(-2)
n Etc...
7.3.2 Terminaison de la fonction

Pour définir une fonction récursive la première étape consiste à déterminer la condition terminale,
cette condition est obligatoire au début de toute fonction récursive. Quand la condition est vérifiée,
on arrête le processus de l’appel récursif.
Dans l’exemple suivant une fois n atteint la valeur de 0 on arrête l’appel récursif.
def f(n):
if n==0:
print("Fin d'appel")
else:
f(n-1)
La condition terminale ne sert à rien si elle ne devient jamais vrai. Par exemple avec la fonction
précédente :
n f(-2) provoque une pile d’appels infinie
n Probablement d’autres tests à faire (si n<0, envoyer une exception par exemple).
7.3.3 La bonne solution

n Si n est négatif ou nul : c’est le cas d’arrêt.
n Si n est positif : on appelle f avec la valeur n-1

n Chaine d’appels avec des valeurs entières strictement décroissantes de 1 en 1
n On arrive forcément à 0
n On affiche «Fin d'appel»
n On remonte la pile des appels (sans rien faire, ici la récursivité est terminale)
def f(n):
if n<=0:
print("Fin d'appel")
else:
f(n-1)
7.3.4 Résumé
Une fonction récursive doit comporter :
1. Un cas d’arrêt dans lequel aucun autre appel n’est effectué
2. Un cas général dans lequel un ou plusieurs autres appels sont effectués
La chaîne d’appel doit conduire au critère d’arrêt. Optionnellement, des cas impossibles ou incorrects
à traiter par des exceptions.
7.4 Quelques Exemples

7.4.1 Boucle for
Toute boucle for peut se transformer en une fonction récursive.
Principe : Pour réaliser des traitements itératifs allant de 1 à n
1. On les fait de 2 à n (même traitement avec une donnée différente)
2. Puis on les fait pour l’indice 1 (cas particulier)
Exemple
n Boucle for
def som(n):
s=0
for i in range(1,n+1):
s=s+i
return s
n Récursivité
def som(n):
if n==1:
return 1
else:
return n+som(n-1)

7.4.2 Exécution de la récursivité
7.4.3 Quelques Constatations

La plupart des traitements sur les tableaux peuvent se mettre sous forme récursive. Par exemple :
n Tris (sélection, insertion)
n Recherche séquentielle (attention: pas dichotomique)
n Inversion
n Etc..
L’écriture sous forme récursive est toujours plus simple que l’écriture sous forme itérative.
7.5 Exercices d’application

Exercice 1
1. Ecrire une fonction récursive qui calcule le PGCD de deux entiers positifs.
2. Tester la fonction
Exercice 2
1. Ecrire la fonction récursive qui calcule somme(n)=1+2+…..+n.
2. Tester la fonction

8 Gestion des fichiers

8.1 Les fichiers
8.1.1 Utilité des fichiers
Jusqu'à présent, les programmes que nous avons réalisés ne traitaient qu'un très petit nombre de
données. Les données se trouvent dans le corps du programme lui-même.
Cette façon de procéder devient cependant tout à fait inadéquate lorsqu’on souhaite traiter une
quantité d'information plus importante. Imaginons, nous voulons écrire un petit programme qui
fasse apparaître à l'écran des questions à choix multiples, avec traitement automatique des
réponses :
n Comment allons-nous mémoriser les questions?
L'idée la plus simple consiste à placer chacune de ces questions dans une variable:
a = "Quelle est la capitale du Maroc?"
b = "Combien font 26 x 43 ?"
Etc.
La manipulation de ces données par les instructions (comme if) sera très compliqué notamment
lorsqu’on a un grand nombre de questions. Une première réflexion consiste à utiliser une liste, par
exemple : Liste=["Quelle est la capitale du Maroc?", "Combien font 26 x 43 ?",…]
Mais même avec les listes il reste plusieurs problèmes gênants, à savoir :
1. La lisibilité du programme ;
2. L'ajout de nouvelles questions, ou la modification de certaines ;
3. L'échange de données avec d'autres programmes.
D’où l’utilité de séparer les données, et les programmes qui les traitent, dans des fichiers différents.
Remarque : Lorsque les quantités de données deviennent très importantes, il est nécessaire de
structurer les relations entre ces données (Base de données).
8.1.2 Utilisation
Pour utiliser un fichier, on doit
1. Le trouver à l'aide de son nom, puis l'ouvrir.
2. Tant qu'il est ouvert, vous pouvez :
n y lire des informations diverses, et vous pouvez aussi
n y écrire des annotations, mais généralement vous ne faites pas les deux à la fois.
3. Le refermer, à la fin
8.1.3 Nom de fichier et le répertoire courant

Le nom de fichier contient le titre ainsi le chemin complet du répertoire où se trouve ce dernier. Par
défaut Python cherche le fichier dans le répertoire courant de travail.
Cependant comment faire si nous souhaiterons forcer Python à changer le répertoire courant par un
autre? Il y’a deux solutions:
1. On indique le chemin d'accès complet dans le nom de fichier, ou bien

2. On change le répertoire courant en utilisant module os.
8.1.4 Changement du répertoire courant

La fonction chdir() du module os, provoque le changement de répertoire courant (voir le chapitre 4 :
Fonctions Prédéfinies en Python).
from os import chdir

chdir("Chemin du répertoire")
Pour le chemin on utilise un antislash « / » au lieu un slash« \ », par exemple:
chdir("C:/SMI/Algorithme/TP")
Dans certain cas, il est utile de connaitre le chemin du répertoire courant. Pour cela on utilise la
fonction getcwd() du module os qui retourne le chemin complet de ce répertoire.
8.2 Gestion de fichier : Ouverture et lecture

8.2.1 Ouverture du fichier: OPEN
La fonction OPEN de python dans la syntaxe est : Open (file,mode) permet d’ouvrir le fichier ‘file’ et
elle retourne un objet-fichier, avec :
n file: est le nom du fichier à ouvrir, à partir du répertoire courant
n mode : définissez le mode dans lequel vous souhaitez ouvrir le fichier. Le tableau suivant
résume l’ensemble des modes d’accès au fichier :
Mode Signification
r Read : Valeur par défaut. Ouvre un fichier en lecture seule, erreur si le fichier n’existe pas
a Append : Ouvre un fichier à ajouter, les données sont ajoutées à la fin du fichier, crée le
fichier s’il n’existe pas
W Write : Ouvre un fichier vide pour l’écriture, les données sont ajoutées au début du
fichier, crée le fichier s’il n’existe pas
x Create : Crée le fichier spécifié, renvoie une erreur si le fichier existe
t Ouvrir le fichier en mode texte.

b Ouvrir le fichier en mode binaire.
+ Ouvrir un fichier pour mise à jour (lecture et écriture)
8.2.2 Lecture dans un fichier : .readlines

La fonction .readlines() de l’objet File renvoie une liste contenant toutes les lignes du fichier, chaque
élément de la liste représente une ligne du fichier:

Chaque élément de la liste est une chaîne de caractères qui se termine par le caractère \n (retour à la
ligne), Qui permet de passer d’une ligne à la ligne suivante.
L’objet file est un objet itérable donc on peut boucler sur ses éléments, où chaque élément est une
ligne du fichier avec un retour chariot. Sur l’exemple suivant on utilise end=‘’ pour éviter un double
saut.
8.2.3 Lecture dans un fichier: read()

La méthode .read() de l’objet File lit tout le contenu d’un fichier et renvoie une chaîne de caractères
unique. Contrairement à readlines(), cette méthode concatène les lignes du fichier dans une seule
chaine de caractères en gardant \n comme séparateur :
Pour la fonction print on n’a pas besoin de changer la valeur par défaut de son attribut end.

8.2.4 Lecture dans un fichier: readline

La méthode .readline() (sans s) lit une ligne d’un fichier et la renvoie sous forme de chaîne de
caractères. À chaque nouvel appel de .readline(), la ligne suivante est renvoyée. Souvent cette
fonction et associée à la boucle while afin qu’on puisse lire le fichier ligne par ligne. Noter que la
dernière ligne est une ligne vide sans ‘\n’.
8.2.5 Fermeture du fichier: close

Après l’ouverture et le traitement d’un fichier on doit impérativement le fermé. La méthode .close()
de l’objet File, permet de fermer le fichier et elle ne renvoie rien mais elle modifie l’état de l’objet.
Par conséquent si on essaie de lire à nouveau les lignes du fichier, Python renvoie une erreur.
8.2.6 Autres fonctions de gestion

8.2.6.1 Ouvrir et Fermer: WITH
L’utilisation de mot clé with garantit la bonne fermeture du fichier. with introduit un bloc
d’indentation dont nous effectuons toutes les opérations sur le fichier. Une fois sorti du bloc
d’indentation, Python fermera automatiquement le fichier. Voici la syntaxe de with :
with open(file, mode) as nomFile:

Traitement de fichier
8.2.6.2 Lecture: Itérations directe

L’objet File retourné par open est itérable sur les lignes de fichier. Par conséquent, on peut boucler
directement sur le fichier avec une boucle FOR :

Conseil : Privilégiez cette méthode par la suite.
8.2.6.3 Lecture de fichier avec seek

Il existe d’autre méthode de lecture de fichier, notamment la fonction, Seek(). Elle permet de se
rendre à un endroit précis dans le fichier.
8.3 Gestion de fichier : Écriture

8.3.1 Écriture dans un fichier: Write
Le mode w de open permet d’ouvre un fichier vide pour l’écriture.
1. Créer le fichier s’il n’existe pas
2. Vider et ajouter au début si le fichier existe
La fonction WRITE de l’objet File, dont la syntaxe est file.write(‘contenu’) permet d’ajouter le
‘contenu’ à la fin du fichier ouvert et elle retourne le nombre d’octets ajoutés au fichier (équivalent
au nombre de caractères). Par exemple :
On remarque que les éléments de la liste ont été sauvegardés dans le fichier comme une seule ligne.
Si nous souhaitons mettre chaque élément de la liste dans une ligne séparée on doit ajouter le
séparateur "\n".
8.3.2 Formatage de l’Écriture : .format

La fonction Write permet de concaténer les contenus les unes après les autres. On peut utiliser la
fonction .format de write pour formater le contenu du fichier. La syntaxe de la fonction format est
semblable à celle de la fonction de print.

On remarque que le nombre d’octets ajoutés est augmenté de 1.
8.3.3 Ouverture de plusieurs fichiers avec with

With permet d’ouvrir et fermer plusieurs fichiers en même temps avec des modes différentes, voici
la syntaxe :
with open(file, mode) as file1, open(file, mode) as file2, …:
Dans l’exemple précédent, on a copié le contenu du fichier filiereFile en filiereFileCopie et en

ajoutant un ‘-’ avant chaque ligne. Voici le fichier généré :
8.3.4 Conversions de types

Les différentes méthodes de lecture et d’écriture permet de manipuler le type chaine de caractères.
Si vous souhaitez utiliser autre types de données vous devez passer par les fonctions de conversions
de types: int(), float(), str() …
8.4 Gestion des exceptions

8.4.1 Définition
Les exceptions sont les opérations qu'effectue un interpréteur ou un compilateur lorsqu'une erreur
est détectée au cours de l'exécution d'un programme.
En règle générale, l'exécution du programme est alors interrompue, et un message d'erreur plus ou
moins explicite est affiché.

Le message d'erreur comporte deux parties séparées par un double point
Type d'erreur : une information spécifique de cette erreur
8.4.2 Mécanisme de traitement des exceptions

Il est possible de prévoir à l'avance certaines de ces erreurs, afin d’inclure à cet endroit des
instructions particulières, qui seront activées seulement si ces erreurs se produisent.
Dans Python, il est possible d'associer un mécanisme de surveillance à tout un ensemble

d'instructions, et de simplifier le traitement des erreurs qui peuvent se produire dans n'importe
laquelle de ces instructions. Il permet aussi de personnaliser le message d’erreur.
Un mécanisme de ce type s'appelle en général mécanisme de traitement des exceptions.
8.4.3 try - except – else

Les instructions try - except – else , permettent d'intercepter une erreur et d'exécuter une portion
de script spécifique de cette erreur.
Try:
blocInstructions1
Except:
blocInstructions2
Else:
blocInstructions3
Si une erreur survient pendant l'exécution de blocInstructions1, Python annule ce bloc d’instructions
et exécute les instructions du blocInstructions2.
Si aucune erreur ne s'est produite dans blocInstructions1, Python exécute blocInstructions3 de else
(si elle est présente). Exemple 1 : avec les opérations
Exemple 2 : avec les fichiers

Exemple 3 : avec les fichiers et le bloc de ‘Else’ :
8.4.4 Gestion des exceptions des fichiers

Nous pouvons définir une fonction qui vérifier l’existence d’un fichier. La fermeture du fichier on
l’ajoute dans le bloc d’instructions de ‘else’.
Remarque : Il est possible de faire suivre l'instruction try de plusieurs blocs except, chacun d'entre
eux traitant un type d'erreur spécifique.

9 Complexité algorithmique
9.1 Comprendre la notion de complexité
9.1.1 Problématique
Supposons qu’on cherche à définir une fonction qui renvoie 1 si un nombre ‘n’ appartient à une liste
L et 0 si non. Nous disposons de plusieurs solutions pour répondre à cet exercice, voici une liste des
solutions possibles :
n Avec l’opérateur in
Def recherche(n,L):
if n in L:
return 1
return 0
n Avec la boucle for
Def recherche(n,L):
for i in range (len(L)):
if L[i]==n:
return 1
return 0
n Avec la boucle while
Def recherche(n,L):
i=0
while i<len(L):
if L[i]==n:
return 1
i=i+1
return 0
n Avec une fonction récursive
Def recherche(n,L):
if L==[] :
return 0
if L[0]==n:
return 1
return chercher(n, L[1:])
Par conséquent, on se retrouve devant deux problématiques :
1. Le code le plus court est-il meilleur ?
2. Comment peut-on désigner le meilleur code parmi les solutions proposées ?
9.1.2 Objectifs
La section précédente nous a montré que la solution algorithmique n’est pas unique pour un
problème donné!. Alors comment connaitre et choisir la meilleure solution lorsqu'on a le choix?
Nous avons besoin d’une métrique d’évaluation pour comparer les différents algorithmes d’un
problème donné. Il s’agit de la complexité algorithmique.
Le calcule de complexité a pour objectif d’une part de prévoir le temps d‘exécution d'un algorithme,
et d’autre part de comparer deux algorithmes réalisant le même traitement. Par exemple :
1. si on lance le calcul de la factorielle de 26, combien de temps faudra-t-il attendre le résultat?

2. quel algorithme de tri vaut-il mieux utiliser pour retrier un tableau?
9.2 Types de complexités

9.2.1 Complexité temporelle et spatiale
La complexité d'un algorithme peut être évalue en temps et en espace, on parle aussi de la
Complexité temporelle et spatiale, avec :
n Complexité temporelle ou complexité en temps est l’évaluation du temps d'exécution de

l'algorithme.
n Complexité spatiale ou complexité en espace est l’évaluation de l'espace mémoire occupé

par l'exécution de l'algorithme.
Recommandation sur l'espace-temps informatique : pour gagner du temps de calcul, on doit utiliser
davantage d'espace mémoire. Aujourd’hui on s’intéresse essentiellement à la complexité en temps.
Ce qui n‘était pas forcément le cas quand les mémoires coutaient cher.
9.2.2 Complexité en temps et en espace: exemple

Prenons l’exemple d’échange de deux valeurs entières. Il existe entre autre deux solutions possibles:
1. la première méthode utilise une variable supplémentaire et réalise 3 affectations:
z <- x
x <- y
y <- z
2. La deuxième méthode n'utilise que les deux variables qu’on veut échanger, mais réalise 3
affectations et 3 opérations
x <- y-x
y <- y-x
x <- y+x
9.3 Méthodes de calcul de complexité
L'évaluation de la complexité peut se faire à plusieurs niveaux. Au niveau de l'exécution du
programme expérimentalement et au niveau purement algorithmique, par l'analyse et le calcul.
9.3.1 Méthode expérimentale

9.3.1.1 Définition et calcul
Il s’agit de la solution la plus intuitive pour choisir la meilleure solution. Elle consiste à mesurer le
temps d'exécution exacte pour chaque algorithme. Pour ce faire, python (par exemple) offre le
module time qui permet de calculer le temps d'exécution.
Le module time possède la fonction perf_counter(), elle retourne un réel qui représente l’horloge du
système en seconde. Par conséquent il suffit de calculer la différence du temps avant et après
l’exécution du programme:
from time import perf_counter

t0 = perf_counter()
#Triatements
t1 = perf_counter()
print(t1-t0)
9.3.1.2 Limites
Le calcul de la complexité avec la méthode expérimentale représente certains inconvénients, à
savoir:

1. Implémentation de l’algorithme : il faut identifier l’ensemble des solutions possibles.
2. Résultats dépends de l’environnement : Processeur, la taille de la mémoire, système

d’exploitation, etc.
3. Lancer plusieurs exécutions, qui peuvent prendre beaucoup de temps.
9.4 Méthode théorique

9.4.1 Avantage et motivation
Contrairement la méthode expérimentale, la méthode théorique consiste à pallier aux limites de
cette dernière. Voici les avantages de cette méthode :
1. Comparer les algorithmes théoriquement
2. Pas besoin d’implémentation
9.4.2 Etapes de calcul de la complexité

Voici le processus de calcule de complexité avec la méthode théorique :
1. Identifier le paramètre de complexité de l’algorithme
2. Calculer la complexité en fonction du paramètre de la complexité
3. Calculer la complexité asymptotique
9.4.3 Paramètre de complexité

Le paramètre de la complexité est la donnée du traitement qui va faire varier le temps d‘exécution
de l'algorithme. Par exemple : calcul de la factorielle, le paramètre de complexité est la valeur de n,
parce que le temps d’exécution dépend du nombre d’itération de la boucle pour.
resultat <- 1;
pour (i allant de 2 à n pas 1) faire
resultat <- resultat*i;
Finpour
Voici un deuxième exemple: multiplier les éléments d'un tableau d'entiers par un entier. Voici
l’algorithme proposé :
fonction multiplie(entier tab[], entier x)

entier i;
début
pour (i allant de 0 à tab.longueur-1 pas de 1) faire
tab[i] <– tab[i] * x;
finpour
Fin
n Paramètre de complexité est la valeur de la longueur du tableau.
Exemple 3 : table de multiplication d’un entier:
fonction TabMultiplie(entier n)
début
pour (i allant de 1 à 10 pas de 1) faire
print(i * n)
Fin
n Pas de paramètre de complexité
Pour un même algorithme, différents choix de paramètre de complexité peuvent être possible. C’est-
à-dire plusieurs complexités peuvent être calculées, selon les besoins.
9.4.4 Mesure de la complexité temporelle

La mesure de la complexité temporelle nécessite un modèle.
n On précise les opérations élémentaires qui, par hypothèse, se déroulent en temps borné par
une constante,
n On suppose que la complexité temporelle d’un algorithme est proportionnelle au nombre

d’opérations élémentaires.
Les opérations suivantes sont considérées comme élémentaires :
n Les opérations arithmétiques (+,-,*,/,//,%),
n La comparaison de données : relation d’égalité (==), d’ordre (,...),
n Le transfert de données : lecture (input, open, readline,...) et écriture dans un emplacement

mémoire (print, close, writeline,...),
n Les instructions de contrôle (if,elif,else, while,for),
n l’affectation en général.
9.4.5 Règles de calcule

Pour déterminer le coût d’un algorithme, on se fonde en général sur le modèle de complexité suivant
:
1. Une affectation, une comparaison ou une évaluation d’une opération arithmétique ayant en
général un faible temps d’exécution, celui-ci sera considéré comme l’unité de mesure du
coût d’un algorithme.
2. Le coût des instructions p et q en séquence est la somme des coûts de l’instruction p et de

l’instruction q.
3. Le coût d’un test if b: p else: q est inférieur ou égal au maximum des coûts des instructions p
et q, plus le temps d’évaluation de l’expression b.
4. Le coût d’une boucle for : est égal au nombre d’éléments de l’itérable multiplié par le coût de
l’instruction p si ce dernier ne dépend pas de la valeur de i. Quand le coût du corps de la
boucle dépend de la valeur de i, le coût total de la boucle est la somme des coûts du corps de
la boucle pour chaque valeur de i.
5. Le cas des boucles while est plus complexe à traiter puisque le nombre de répétitions n’est
en général pas connu a priori. On peut majorer le nombre de répétitions de la boucle de la
même façon qu’on démontre sa terminaison et ainsi majorer le coût de l’exécution de la
boucle.
Remarques : En effet, la mesure de la complexité dépend partiellement du langage de

programmation. Par exemple,
· Les entiers python sont de type long (i.e. 8 octets à partir de la version 3.0) : les opérations
arithmétiques ne sont donc pas toujours élémentaires. On supposera cependant leur temps
d’exécution est borné.
· La comparaison entre deux chaînes de caractères n’est pas élémentaire, seule la

comparaison entre deux caractères sera supposée élémentaire.
· La recopie d’un tableau d’entier n’est pas élémentaire, seule la copie d’un élément d’un
tableau sera supposée élémentaire.

9.4.6 Les opérations élémentaires

Certaines opérations (liées à des structures de données) se déroulent en temps constant et on peut
les considérer comme des opérations élémentaires :
· l’ajout dans un tableau t de type list, càd. t.append(item) ou t[i] = item
· l’ajout dans un dictionnaire d via d[i]=item
· l’accès à un élément via son index dans un itérable, càd. t[i], d[i], s[i], .
· l’accès à la longueur d’un itérable, càd. len(t), len(d), len(s),...
· la suppression d’un élément dans un dictionnaire càd. del dict[key]
· la récupération des clés d’un dictionnaire càd. dict.keys()
· le test d’existence d’un élément dans un dictionnaire ou un ensemble
9.4.7 Les opérations non élémentaires

Parmi les opérations non élémentaires (en python), on peut citer :
· la recherche d’un élément dans un tableau de type list,
· la suppression d’un élément dans un tableau de type list,
· les tests d’égalité entre deux listes (t1 == t2),
· le slicing d’une liste (t[a:b]).
9.5 Calcul de la complexité théorique

9.5.1 Objectif
L’objectif est d’évaluer le temps de calcul indépendamment de toute implémentation et de tout
contexte d’exécution. Par exemple : la factorielle, le paramètre de complexité est la valeur de n.
En effet, Il faut associer des temps d'exécution constants à chaque type d'instruction :
n affectation d'entier : ae
n comparaison d'entier : ce
n opération élémentaire sur des entiers : oe
On peut négliger le cout des déclarations, des affectations et du retour.
9.5.2 Principe
Pour calculer le temps d’exécution d’un programme il suffit de faire la somme du temps d’exécution
de toutes les instructions élémentaires. Au total, le temps d'exécution sera de la forme : a*n+b avec
n comme paramètre de complexité et a et b des constantes.
Il n’est pas possible de fixer des valeurs numériques aux constantes, qui dépendent du langage
d’implémentation et du contexte d’exécution. On se contente donc de déterminer la forme générale
de la complexité.
9.5.3 Exemple de calcul de complexité

Par exemple, l’algorithme suivant permet de réaliser une recherche séquentielle dans un tableau de
n chaines de caractères :
fonction recherche(chaine tab[], chaine x): booléen

Variables i : entier
b: booléen

début
b <- FAUX
i <- 0
tantque (i < tab.longueur ET non b) faire
si (tab[i] = x) alors
b <- VRAI
finsi
i <- i+1
fintantque
retourne b
fin
Le paramètre de complexité est la taille du tableau d'entrée, n. et le nombre de tours de la boucle
tant que varie selon que x est dans le tableau ou pas, et selon l'endroit ou x est présent. Voici une
étude des différents cas possibles :
n Si x est dans la première case du tableau : 1 tour de boucle avec la condition tab[i]=x vraie
n Si x est dans la deuxième case du tableau : 1 tour de boucle avec la condition tab[i]=x fausse
et 1 tour de boucle avec la condition tab[i]=x vraie
n ...
n Si x est dans la dernière case du tableau : tab.longueur-1 tours de boucle avec la condition
tab[i]=x fausse et 1 tour de boucle avec la condition tab[i]=x vraie
n Si x n'est pas dans le tableau : tab.longueur tours de boucle avec la condition tab[i]=x fausse
9.5.4 Complexité au mieux et au pire

Pour une valeur donnée du paramètre de complexité, le temps d'exécution varie selon les données
d'entrée, on peut distinguer :
1. La complexité au pire : temps d'exécution maximum, dans le cas le plus défavorable.
2. La complexité au mieux : temps d'exécution minimum, dans le cas le plus favorable (en
pratique, cette complexité n'est pas très utile).
3. La complexité moyenne : temps d'exécution dans un cas médian, ou moyenne des temps
d’exécution.
Le plus souvent, on utilise la complexité au pire, car on veut borner le temps d’exécution.
Exemple d’une fonction qui cherche l’occurrence d’une chaine de caractères dans un tableau des
chaînes:
fonction recherche(chaine tab[], chaine x): booléen

Variables i : entier
b: booléen
début
b <- FAUX
i <- 0
tantque (i < tab.longueur ET non b) faire
si (tab[i] = x) alors
b <- VRAI
finsi
i <- i+1

fintantque
retourne b
fin
n Complexité au pire (x n'est pas dans le tableau) :
• 2*ae+n*(3*ce+1*oe+2*ae)+1*ret = 6n+3
n Complexité au mieux (x est dans la première case du tableau) :
• 2*ae+3*ce+2*ae+2*oe = 9
n Complexité en moyenne : considérons qu'on a 50% de chance que x soit dans le tableau, et sa
position est au milieu. Soit il n’y a pas
• [ 6n+3+(2*ae+n/2*(3*ce+1*oe+2*ae)+1*ret)] /2 = 4n+3
9.6 Complexité asymptotique

Les complexités algorithmiques théoriques sont toujours des approximations :
1. Première approximation : on ne calcule que la forme générale de la complexité
2. Deuxième approximation : on ne considère souvent que la complexité au pire
3. Troisième approximation : on ne regarde que le comportement asymptotique de la

complexité car le temps de calcul ne pose pas de problème lorsqu’on traite des données peu
volumineuses.
9.6.1 Notation de Landau O

Soit C(n) une fonction qui désigne le temps de calcul d'un algorithme A. On dit que C(n) est en grand
O de f(n) et on note C(n) = O(f(n)) si et seulement si :
Ǝ(n0; x) telle que C(n) <= x*f (n) pour tous n >= n0
x*f(n)
C(n)
C = O(f) signifie que C est dominée asymptotiquement par f ou que f domine asymptotiquement C.
9.6.2 Notation O : exemples

Exemple 1 : Si C(n) = 3n + 6 alors C(n) = O(n)
Démonstration : En effet, pour n >= 2, on a 3n + 6 <= 9n ; la quantité 3n + 6 est donc bornée, à partir
d'un certain rang, par le produit de n et d'une constante.
· 3 *2 + 6 <= 9 *2
· 3 *3 + 6 <= 9 *3
· 3 *4 + 6 <= 9 *4
· 3 *5 + 6 <= 9 *5
Exemple 2: Si C(n) = n2+ 3n alors T(n) = O(n2)

Démonstration : En effet, pour n >= 3, on a n2+ 3n <= 2n2 ; la quantité n2 + 3n est donc bornée, à
partir d'un certain rang, par le produit de n2 et d'une constante.
9.6.3 Simplification
On calcule le temps d'exécution comme avant, mais on effectue les simplifications suivantes :
1. On oublie les constantes multiplicatives (elles valent 1) ;
2. On annule les constantes additives ;
3. On ne retient que les termes dominants ;
Exemple: Soit un algorithme effectuant C(n) = 4n3-5n2+ 2n +3 opérations
n On remplace les constantes multiplicatives par 1 : 1n3-1n2+ 1n + 3
n On annule les constantes additives : n3-n2+ n + 0
n On garde le terme de plus haut degré : n3
Donc : C(n) = O(n3):
9.6.4 Propriétés
Pour le calcule de la complixité avec la notation O on utilse les propriètés suivantes:
1. Le produit de la complixité d’une fonction et une constante est la compexité de cette

fonction: c *O(f (n)) = O(f (n))
2. La somme de la complexité des deux fonctions est la complexité de la somme de ces deux
fonctions : O(f (n)) + O(g(n)) = O(f (n) + g(n))
3. La produit de la complexité des deux fonctions est la complexité du produit de ces deux
fonctions : O(f (n)) * O(g(n)) = O(f (n) * g(n))
9.6.5 Classes de la complexité

La valeur de la complexité O d’une fonction permet de catégoriser cette fonction dans l’une des
classes de complexité suivantes :
9.7 Complexité des fonctions récursives

9.7.1 Calcule de la complexité des fonctions récursives
Comment calculer la complexité des fonctions récursives ?
Soit la fonction factorielle suivante:

Def factoriel(n) :
if n==0 or n==1 :
return 1
return n*factoriel(n-1)
Le paramètre de complexité est n
C(0)=2 # deux comparaisons (L2)
C(1)=2 #idem
C(n)=2 +1+ C(n-1) #1 pour l’opération de la miltiplication
= 3 + C(n-1)=∑ 3+2+2=3(n-1)+4=3n+1=O(n)
Il s’agit d’une complexité linéaire: O(n)
9.7.2 Etude de cas

Cas 1: Si la complexité d’une fonction récursive est c(n)=c(n-1)+b
n Alors c(n)=c(0)+b*n= O(n) une complexité linéaire
n Exemple: factorielle
Cas 2:Si la complexité d’une fonction récursive est c(n)=a*c(n-1)+b / a#1
n Alors c(n)=an*(c(0)-b/(1-a))+b/(1-a) = O(an) une complexité exponentielle
n Exemple: répétition du traitement sur le résultat de l’appel récursive
Cas 3:Si la complexité c(n)=c(n-1)+a*n+b
n Alors c(n)=c(0)+a*n*(n+1)/2 +n*b = O(n2) une complexité quadratique
n Exemple: tri à bulle
Cas 4: Si c(n)=c(n/2)+b
n Alors c(n)=c(1)+b*log2(n)= O(log(n)) une complexité logarithmique
n Exemple: recherche dichotomique récursive
Cas 5: Si c(n)=c(n/2)+a*n+b
n Alors c(n)= O(n) une complexité linéaire
n Exemple: traitement linéaire avant l’appel récursif dichotomique
Cas 6: Si c(n)=2*c(n/2)+a*n+b
n Alors c(n)= O(n*log(n)) une complexité quasi-linéaire
n Exemple: traitement linéaire avant double appel récursif dichotomique, tri fusion

10 TD : les exercices
10.1 TD1 : Fonctions Prédéfinies – Algorithme
10.1.1 Opérateurs
Écrivez un algorithme qui convertisse en mètres par seconde puis en km par heure une vitesse
fournie par l'utilisateur en miles/heure. (Rappel : 1 mile = 1609 mètres)

Écrivez un algorithme qui calcule le périmètre et l'aire d'un triangle quelconque dont l'utilisateur
fournit les 3 côtés.
Rappel : l'aire d'un triangle quelconque se calcule à l'aide de la formule :
· d désigne la longueur du demi-périmètre,

· et a, b, c celles des trois côtés.

Écrivez un algorithme qui calcule la période d'un pendule simple de longueur donnée. La formule qui
permet de calculer la période d'un pendule simple est :
· l représentant la longueur du pendule et

· g la valeur de l'accélération de la pesanteur au lieu d'expérience

Parmi ces affectations (considérées indépendamment les unes des autres), les quelles provoqueront
des erreurs, et pourquoi?
Variables A, B, C : Réel
D,E : Caractères
Début
A ß Sin(B)
A ß Sin(A + B*C)
B ß Sin(A) – Sin(D)
D ß Sin(A / B)
C ß Cos(Sin(A)
FIN
Ecrire un algorithme qui reçoit un nombre, il affiche ensuite : soit la racine carrée de ce nombre, soit
un message indiquant que la racine carrée de ce nombre ne peut être calculée.
10.1.6 Fonctions sur les chaînes de caractères

Ecrire un algorithme qui reçoit un entier ‘n’ et un caractère "ca", puis il affiche une chaîne de n
caractères « ca ».
Par exemple : si n=4 et ca="k" on affiche "kkkk"


Ecrivez un algorithme qui demande une phrase à l'utilisateur et qui affiche à l'écran le nombre de
mots de cette phrase. On suppose que les mots ne sont séparés que par des espaces.

Ecrivez un algorithme qui demande une phrase à l'utilisateur et qui affiche à l'écran le nombre du
caractère "e" contenue dans cette phrase. Proposez deux solutions:
1. Solution 1 : traite la chaîne comme un tableau de caractères.

2. Solution 2: utilise une fonction prédéfinie sur les chaînes de caractères.

10.2 TD2 : Fonctions Prédéfinies & Modules (Python)

10.2.1 Opérations et conversions de types
Prédire le résultat de chacune des instructions suivantes:
1. (1+2)**3
2. "Da" * 4
3. "Da" + 3
4. ("Pa"+"La") * 2
5. ("Da"*4) / 2
6. 5/2
7. 5 // 2
8. 5%2
9. str(4) * int("3")
10. int("3") + float("3.2")
11. str(3) * float("3.2")
12. str(3/4) * 2
10.2.2 Structures de données : suite Fibonacci

Écrire un script python qui crée et affiche une liste des éléments de la suite de Fibonacci inférieure à
n, avec n un entier initialisé dans le script. Par exemple si n=10 le script affiche la liste suivante :
[0,1,1,2,3,5,8].
10.2.3 Structures de données : tuples et listes

Définir un script python qu’à partir d’une liste de tuples d'entiers ‘lst’ et un entier ‘val’ il génère une
nouvelle liste de tuples ‘lst2’ avec le dernier élément de chaque tuple est remplacé par ‘val’. Par
exemple :
· si lst = [(10, 20), (30, 40, 50, 60), (70, 80, 90)] et val=100
· alors Lst2=[(10, 100), (30, 40, 50, 100), (70, 80, 100)].
10.2.4 Structures de données : liste & dictionnaire

L’objectif de l’exercice et de convertir deux listes quelconques en un dictionnaire. Proposer deux
solutions:
1. Solution 1: En utilisant les fonctions zip et dict.

2. Solution 2: En utilisant la compréhension des dictionnaires.
10.2.5 Fonctions sur les listes
1. Écrire un code python qui demande à l’utilisateur d’entrer le nombre des étudiants n puis de
saisir (en boucle) le nom et la note de chaque étudiant. On affecte les notes à la liste Notes et
les noms à la liste noms.
2. Convertir les deux listes (noms et notes) en un dictionnaire. (utilisez la fonction zip)
Exemple d’exécution :

10.2.6 Module math

Écrivez un script python qui calcule la période d'un pendule simple de longueur donnée.
La formule qui permet de calculer la période d'un pendule simple est :
· l représentant la longueur du pendule et

· g la valeur de l'accélération de la pesanteur au lieu d'expérience
10.2.7 Formatage de string

1. Écrire un programme python qui, étant donnée deux bornes entières a et b, additionne les
nombres multiples communs à 3 et à 5 compris entre ces deux bornes.
· Par exemple a = 0, b = 32 → le résultat devrait être alors 0 + 15 + 30 = 45.
2. Modifier légèrement ce programme pour qu'il additionne les nombres multiples de 3 ou de 5
compris entre les bornes a et b.
· Avec les bornes 0 et 32, le résultat devrait donc être : 0 +3 + 5 + 6 + 9 + 10 + 12 + 15 + 18
+ 20 + 21 + 24 + 25 + 27 + 30 = 225.
10.2.8 Module Random

Écrire un petit jeu dont l’utilisateur doit trouver un nombre aléatoire caché (entre 0 et 100). Le
programme demande à l’utilisateur de saisir une valeur entre 0 et 100 et affiche:
· Si la valeur saisie > au nombrealéatoire : saisie une valeur inférieure

· Si la valeur saisie < au nombrealéatoire : saisie une valeur supérieure
· Si la valeur saisie = au nombrealéatoire : Félicitation vous avez trouvé la valeur après n
tentatives (arrêt de programme)
10.2.9 Modules OS et Glob

1. Écrire un programme python qui affiche une liste avec l’ensemble des fichiers d’extension
.ipynb du répertoire courant.
2. Afficher le chemin complet du répertoire courant.
3. Afficher la liste de l’ensemble des fichiers d’extension .ipynb dans un répertoire donné par
l’utilisateur.
· On suppose que l’utilisateur saisie un chemin complet et correcte d’un répertoire.
10.2.10 Module Statistics

A partir de l’exercice 2 (gestions des notes des étudiants) afficher :
· La meilleure note et le nom d’étudiant
· La plus mauvaise note et le nom de l’étudiant
· La note moyenne
· La variance des notes
· L’écart type des notes
10.2.11 Module Turtle

A l’aide du module Turtle dessinez la forme de la figure ci-dessous.
La forme est de couleur rouge avec un border vert de largeur de
5mm.

10.3 TD3 Fonctions et procédures : Algorithme

10.3.1 Calcule d’une fonction mathématique
1. Ecrire la fonction mathématique f(x) qui calcule f(x)=3x3+4x+8
2. Ecrire un algorithme principal qui fait l’appel à cette fonction et affiche son résultat pour x=1, x=2
et x=27
10.3.2 Fonction Moyenne

1. Ecrire la fonction fct_avg qui calcule la moyenne de trois entiers.
2. Ecrire un algorithme principal qui teste cette fonction avec les valeurs x=5, y=15, z=8.
10.3.3 Nombre Premier

1. Ecrire une fonction qui teste si un nombre est premier ou non
2. Tester votre fonction par un algorithme principal qui demande à l’utilisateur de saisir un entier
puis il affiche si le nombre est premier ou non.
10.3.4 Année bissextile

Ecrire une fonction qui détermine si une année introduite par l'utilisateur est bissextile ou non.
Rappel : Une année A est bissextile si A est divisible par 4 et elle ne l'est cependant pas si A est un
multiple de 100, à moins que A ne soit multiple de 400.
10.3.5 Type de Triangle

Ecrire un algorithme qui demande à l'utilisateur d'entrer trois longueurs a, b, c. et à l'aide de ces trois
longueurs, déterminer s'il est possible de construire un triangle. Déterminer ensuite si ce triangle est
rectangle, isocèle, équilatéral ou quelconque.
· Il faut définir et utiliser plusieurs sous-fonctions.

· Attention : un triangle rectangle peut être isocèle.
10.3.6 Gestion d’une liste

Ecrivez une fonction qui reçoit un tableau des noms et elle affiche chacun de ces noms avec le
nombre de caractères correspondant.
Testez la fonction avec la liste suivante : ['Jean-Michel', 'Marc', 'Vanessa', Maximilien', 'Alexandre-
Benoît', 'Louise'].
10.3.7 Gestion de Notes

1. Écrire la fonction saisieNotes, qui demande à l'utilisateur d'entrer des notes d'élèves. La saisie se
terminera seulement si l'utilisateur entre une valeur négative. Avec les notes ainsi entrées,
construire progressivement un tableau ‘notes’ qui sera retourné par la fonction.
· Une note est une valeur entre 0 et 20.
2. Ecrire les fonctions countNotes, maxNotes, minNotes, avgNote qui retournent respectivement
le nombre de notes entrées, la note la plus élevée, la note la plus basse, la moyenne de toutes les
notes. L’ensemble de ces fonctions reçoivent le tableau ‘notes’ comme un paramètre d’entré.
10.3.8 Force de gravitation

Ecrivez une fonction qui affiche la valeur de la force de gravitation s'exerçant entre deux masses de
10000 kg, pour des distances qui augmentent suivant une progression géométrique de raison 2, à
partir de 5 cm (0,05 mètre) jusqu’à 10m.La force de gravitation est régie par la formule

F=6,67 10−11*m*m'/d2
Exemple d'affichage :
d=0.05 m : la force vaut 2.6680 N
Indice : commencer par définir la fonction forceGravite(n,m,d) qui calcule la force de gravitation
s'exerçant entre deux masses n et m, pour une distance d.

10.4 TD4 Fonctions et procédures : Python

10.4.1 Fonction Mathématique
1. Ecrire la fonction mathématique f(x) qui calcule f(x)=3x3+4x+8
2. Ecrire un programme principal qui calcule f(x) tel que x est une valeur donnée par l’utilisateur.
10.4.2 Tableau de multiplication

1. Ecrire une procédure qui affiche le tableau de multiplication d’un entier (entre 1 et 9).
2. Tester votre proposition par un programme principal qui affiche le tableau de multiplication d’un
entier entre 1 et 9 saisi par l’utilisateur.
10.4.3 Chaîne de n caractères

Définissez une fonction ligneCar(n, ca) qui renvoie une chaîne de n caractères « ca ».
10.4.4 Surface d'un cercle

Définissez une fonction surfCercle(R). Cette fonction doit renvoyer la surface d'un cercle (l'aire d’un
disque) dont on lui a fourni le rayon R en argument. Formatez le résultat pour afficher uniquement
deux chiffres après la virgule.
Par exemple, surfCercle(2.5) doit donner le résultat 19.63.
10.4.5 Volume d'une boîte

Définissez une fonction volBoite(x,y,z) qui renvoie le volume d'une boîte dont on fournit les trois
dimensions en arguments. Formatez le résultat pour afficher uniquement trois chiffres après la
virgule.
Par exemple, l'exécution de l'instruction : volBoite(5.2, 7.7, 3.3) retourne 132.132
10.4.6 Occurrence d’un caractère

Définissez une fonction compteCar (ca,ch) qui renvoie le nombre de fois que l'on rencontre le
caractère ca dans la chaîne de caractères ch.
Par exemple, l'exécution de l'instruction : compteCar('e','Cette phrase est un exemple') doit donner
le résultat : 7
10.4.7 Nombres premiers

Créez une fonction isPremier() qui prend comme argument un nombre entier positif n (>2) et qui
renvoie le booléen True si n est premier et False si n n’est pas premier.
Déterminez tous les nombres premiers de 2 à 100. Voici l’affichage du programme :
10.4.8 Séquence complémentaire

Créez une fonction seq_comp() qui prend comme argument une liste de bases et qui renvoie la
séquence complémentaire d’une séquence d’ADN sous forme de liste.
Dans le programme principal, à partir d’une séquence ADN seq, saisie par l’utilisateur affichez seq et
sa séquence complémentaire. Exemple de seq : ["A", "T", "C", "G", "A", "T", "C", "G","A", "T", "C"]
Rappel : la séquence complémentaire s’obtient en remplaçant A par T, T par A, C par G et G par C.

10.5 TD5 Fonctions Récursives : algorithme et Python

Remarque : Pour l’ensemble des exercices de cette section, donnez l’algorithme ainsi sa traduction
en langage Python.
10.5.1 Calcule de Somme

Ecrire une fonction récursive qui calcule la somme des inverses des carrés des n premiers entiers
naturels non nuls. ∑
10.5.2 Fonction sur les listes

Soit le code python suivant :
def fct_list(L1,L2=[]):
if L1 == []:
return L2
else:
s = L1.pop(0)
if s not in L2:
L2.append(s)
return fct_list(L1,L2)
Que renverra la fonction fct_list définie ci-dessus lorsqu’on l’appelle comme suit ?
fct_list ([34,2,3,11,11,2,34,7,1,7,7,11,3,11]).
10.5.3 Nombre d’occurrence

Ecrire une fonction récursive qui reçoit deux arguments c et s avec : c est un caractère et s est une
chaine de caractères. La fonction retourne le nombre d’occurrences de c dans s.
Exemple fct_occ("a", "abracadabra les MIP") retourne 5.
10.5.4 Récursivité indirecte

Voici la déclaration en Python de deux fonctions:
def fct1(n):
if n == 0:
return True
else:
return not fct2(n)
def fct2(n):
if n == 0:
return False
else:
return not fct1(n)
Que calculent les fonctions fct1 et fct2? Que pensez-vous de leur définition.
10.5.5 Suite de Fibonacci

Proposer une fonction récursive pour calculer le terme d’indice n de la suite de Fibonacci. Les
premiers termes sont 1, 1, 2, 3, 5, 8, 13, 21... Le terme suivant est calculé en ajoutant les deux
derniers termes.
Dessiner le graphe des appels successifs de fib(4).
10.5.6 Puissance d’un nombre

Proposer une fonction récursive qui calcule la puissance d’un nombre. Puissance(3, 2) ---> 9.
10.5.7 PGCD
Ecrire une fonction récursive qui calcule le PGCD de deux entiers. Puis tester la fonction avec deux
valeurs saisies par l’utilisateur.

10.5.8 Tours de Hanoï

Transférer n disques de l’axe A à l'axe C, en utilisant l’axe B, de sorte que jamais un disque ne repose
sur un disque de plus petit diamètre.

10.6 TD6 Gestion des Fichiers avec Python

10.6.1 Moyenne des notes
L’objectif de cette exercice et de créer et gérer le fichier notes.txt qui contient les notes obtenues par
des étudiants pour le cours de Python. Chaque ligne du fichier ne contient qu’une seule note.
1. Créez la fonction ‘init’ qui crée et initialise ce fichier avec les notes saisies par l’utilisateur. La
fonction demande à l’utilisateur de saisir les notes une à une en terminant la saisie par la
valeur -1. La note saisie doit être entre 0 et 20.
2. Créez la fonction ‘transform’ qui lit chaque ligne de ce fichier, extrait les notes sous forme de
float et les stocke dans une liste.
3. Créez la fonction ‘moyenNotes’ qui calcule et affiche la moyenne des notes avec deux
décimales.
10.6.2 Admis ou recalé

À partir du fichier notes.txt de l’exercice précèdent générer le fichier notes2.txt avec une note par
ligne suivie de la mention « recalé » si la note est inférieure à 10 et « admis » si la note est supérieure
ou égale à 10.
n Toutes les notes seront écrites avec deux chiffres après la virgule.
10.6.3 Menu de gestion

Écrivez un script qui permette de créer un fichier texte. Votre programme demandera d'abord à
l'utilisateur d'entrer le nom du fichier. Ensuite il lui proposera le choix, soit d'enregistrer de nouvelles
lignes de texte, soit d'afficher le contenu du fichier.
· L'utilisateur devra pouvoir entrer ses lignes de texte successives en utilisant simplement la
touche <Enter> pour les séparer les unes des autres.
· Pour terminer les entrées, il lui suffira d'entrer une ligne vide (c'est-à-dire utiliser la touche
<Enter> seule).
· L'affichage du contenu devra montrer les lignes du fichier séparées les unes des autres de la
manière la plus naturelle (les codes de fin de ligne ne doivent pas apparaître).
10.6.4 Recherche dans un fichier

Ecrivez un script python qui demande à l'utilisateur d'entrer le nom d’un fichier existant pour
rechercher la phrase la plus longue.
· Ecrivez une fonction qui teste l’existence du fichier

· Écrivez une fonction qui recherche et affiche la phrase la plus longue

10.6.5 Tables de multiplication

Écrivez un script qui génère automatiquement un fichier texte contenant les tables
de multiplication de 2 à 9. On sépare deux tables de multiplication successive par
une ligne vide. Voici le résultat attendu :
10.6.6 Ouverture de plusieurs fichiers

1. Écrivez un script qui recopie un fichier texte en triplant tous les espaces entre les mots.
2. Écrivez un script qui compare les contenus de deux fichiers et signale la première différence
rencontrée.
10.6.7 Base de données étudiant

1. Écrivez un script qui permette au professeur de saisir des informations sur ses étudiants:
· Le professeur commence par donner un nom au fichier généré
· Puis il indique le nombre des étudiants à ajoutés
· Pour chaque étudiant il doit saisir le nom, prénom, adresse, code postal et n° de
téléphone.
· Chaque étudiant sera ajouter comme une ligne dans le fichier, dont ces information
sont séparées par un ‘|’
2. Ajoutez une fonction pour afficher le contenu du fichier
3. Écrivez un script qui modifie le fichier précédent pour ajouter la date de naissance et le sexe
de chaque étudiant.
· Il faut afficher le nom complet de l’étudiant puis demander à l'utilisateur d'entrer ces
données complémentaires).
10.6.8 Lecture simultanée

1. A partir de deux fichiers préexistants A et B, construisez un fichier C qui contienne
· alternativement un élément de A, un élément de B, un élément de A, ... et ainsi de

suite
· jusqu'à atteindre la fin de l'un des deux fichiers originaux. Complétez ensuite C avec
les éléments restant de l'autre fichier.
· Un élément = une ligne

10.7 TD7 Complexité Algorithmique

10.7.1 Tri par sélection
Le code ci-après représente l’implémentation de l’algorithme de tri par sélection avec le langage
python.
Rappel : Le tri par sélection (ou tri par extraction) est un algorithme de tri par comparaison. Il
consiste à :
· rechercher le plus petit élément du tableau, et l'échanger avec l'élément d'indice 0 ;

· rechercher le second plus petit élément du tableau, et l'échanger avec l'élément d'indice 1 ;
· continuer de cette façon jusqu'à ce que le tableau soit entièrement trié.
Def tri_selection(T,n) :
for i in range(n-1) :
posmin=i
for j in range(i+1,n) :
if T[j]<T[posmin] :
posmin=j
T[i],T[posmin]=T[posmin],T[i]
return T
1. Calculer la complexité de la fonction. Et déduire sa classe ?
10.7.2 Tri par insertion

Le code ci-après représente l’implémentation de l’algorithme de tri par sélection avec le langage
python.
Rappel : Le tri par insertion considère chaque élément du tableau et l'insère à la bonne place parmi
les éléments déjà triés. Ainsi, au moment où on considère un élément, les éléments qui le précèdent
sont déjà triés, tandis que les éléments qui le suivent ne sont pas encore triés.
Pour trouver la place où insérer un élément parmi les précédents, il faut le comparer à ces derniers,
et les décaler afin de libérer une place où effectuer l'insertion. Le décalage occupe la place laissée
libre par l'élément considéré. En pratique, ces deux actions s'effectuent en une passe, qui consiste à
faire « remonter » l'élément au fur et à mesure jusqu'à rencontrer un élément plus petit.
Voici une simulation avec le tableau d’entiers [6,5,3,1,8,7,2,4]
Def tri_insertion(T):
for i in range(1,len(T)):
k=i
while k>0 and T[k]<T[k-1]:
T[k], T[k-1] = T[k-1], T[k]
k = k –1
Calculer la complexité de la fonction. Et déduire sa classe ?
10.7.3 Recherche dichotomique

Soit la fonction de recherche dichotomique, elle consiste à trouver l’indice d’une occurrence de x
dans une liste triée T.
Def RechDichotomique(T,x) :
inf=0
sup=len(T)-1
while inf<=sup :
m=(inf+sup)//2
if T[m]==x :
return m
if T[m]<x :
inf=m+1
else:
sup=m-1
return -1
1. Calculer la complexité de la fonction. Et déduire sa classe ?
10.7.4 Fonction récursive : Tri par sélection

Soit l’algorithme de la fonction récursive suivante :
Function fct(n:entire): Entier

Début
Si n <=0 alors
Retourne 1
Sinon
Retourne 1+fct(n div 5)
Finsi
Fin
1. Donner une simulation de l’algorithme avec n=1, 4, 26, 55, 100, 1000
2. Quel est le rôle de cette fonction ?
3. Calculer la complexité de la fonction récursive. Et déduire sa classe de complexité?
10.7.5 Fonction récursive : tri

Soit le code python des deux fonctions suivantes.
def fusionner(A, B):

R = []
while A!=[] and B!=[]:
if A[0] < B[0] :
R.append(A.pop(0))
else :
R.append(B.pop(0))
return R + A + B
def tri(L):
n = len(L)
if n==0 or n==1:
return L
m=(n-1)//2
return fusionner(tri(L[:m+1]), tri(L[m+1:]))
1. Donner une simulation de la fonction tri avec l=[56,3,12,0,1,200,55,7]

2. Quel est le rôle de ces deux fonctions ?
3. Calculer la complexité de la fonction tri. Et déduire sa classe de complexité?
10.7.6 Fonction récursive : partition

Soit le code python des deux fonctions suivantes :
Def partition(L, debut, fin):

pivot = L[debut]
ipivot= debut
for i in range(debut+1, fin+1):
if L[i]<=pivot :
a = L.pop(i)
L.insert(debut,a)
ipivot= ipivot+ 1
return ipivot
def quick(L, debut, fin):

if debut<fin :
ipivot= partition(L, debut, fin)
quick(L,debut,ipivot-1)
quick(L,ipivot+1, fin)
1. Donner une simulation de la fonction tri avec l=[56,3,12,0,1,200,55,7]

2. Quel est le rôle de ces deux fonctions ?
3. Calculer la complexité au mieux et au pire de la fonction quick. Et déduire sa classe de
complexité dans les deux cas?

11 Bibliographie
• BALKANSKI, Cécile et MAYNARD, Hélène, Algorithmique et C++, Supports de TD et de TP, IUT
d'Orsay, département Informatique
• CHESNEAU Myriam, Cours d'informatique - Initiation au langage C, IUT d'Annecy,
Département Mesures Physiques, 2010-2011
• CHUN, W. J., Au Cœur de Python, CampuPress, 2007.
• DABANCOURT, Christophe, Apprendre à programmer, Algorithmes et conception objet,
Eyrolles, 2008, 2e édition.
• LUTZ, Mark & BAILLY, Yves, Python précis et concis, O’Reilly, 2e édition, 2005.
• MARTELLI, Alex, Python par l'exemple, O’Reilly, 2006.
• SWINNEN, Gérard, Apprendre à programmer avec Python 3, Eyrolles, 2010
Webographie
• Complexité algorithmique, Florent Bouchez Tichadou, 9 septembre 2021

• Cours Complexité d’un algorithme, ,2022
• Algorithmique, Florent Hivert, université paris sud, 2023
• Cours Algorithmique avec le langage Python, Sabine MARDUEL, université paris sud, IUT
d’Orsay, 2022.
• CORDEAU, Bob & POINTAL, Laurent, Introduction à Python 3:
htps://perso.limsi.fr/pointal/python:courspython3
• Une introduction à Python 3 (document pdf)
• Exercices corrigé Python 3 (document pdf)
• SWINNEN, Gérard, Apprendre à programmer avec Python 3:
htp://inforef.be/swi/python.htm. Téléchargeable (document pdf), et existe sous forme
imprimée (Eyrolles)
• POINTAL, Laurent, Cours 2012-2013 (présentations, fiches récapitulatives, scripts) :
htps://perso.limsi.fr/pointal/python:cours_prog (documents pdf, texte sources)
• NAROUN , Kamel, Débuter avec Python au Lycée : htp://python.lycee.free.fr
• POINTAL, Laurent, Mémento Python 3 : htps://perso.limsi.fr/pointal/python:memento
(document pdf)
• LE GOF, Vincent, Apprenez à programmer en Python, Le Livre du Zéro, 2011 :
htp://www.siteduzero.com/informatique/tutoriels/apprenez-a-programmer-en-python
• Manuel de référence python (en anglais) : htp://www.python.org/ (partie documentation)
• Sites web interactifs permettant d’apprendre à programmer
• CodinGame: htps://www.codingame.com/start
• Codecademy: htps://www.codecademy.com/fr/learn/python
• Wikibook python : htp://fr.wikibooks.org/wiki/Programmation_Python

Polycopie MIP Informatique2 2024

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Polycopie MIP Informatique2 2024

Transféré par

Droits d'auteur :

Formats disponibles

Module Informatique 2 :

Prof. ABDELTIF EL BYED

Table des matières

3.2.3 Fonctions Mathématiques ......................................................................................... 20

Pr. Abdeltif EL BYED

5.2 Procédure et fonction ........................................................................................................ 46

Pr. Abdeltif EL BYED

6.7.1 Structure générale ..................................................................................................... 61

Pr. Abdeltif EL BYED

8.3.1 Écriture dans un fichier: Write ................................................................................... 74

Pr. Abdeltif EL BYED

9.7.1 Calcule de la complexité des fonctions récursives ...................................................... 85

Pr. Abdeltif EL BYED

10.4.5 Volume d'une boîte ................................................................................................... 93

Pr. Abdeltif EL BYED

1 Présentation du module Informatique 2

n Comprendre les fonctions et les procédures, gestion de fichier en Python

n Découvrir des outils de création, test et évaluation du langage Python

1.2 Compétences & Connaissances à acquérir

n Utiliser les fonctions et les procédures prédéfinies en Algorithme & en Python

n Définir des fonctions et des procédures en Algorithme & en Python

n Appliquer la récursivité pour résoudre des problèmes spécifiques

n Manipuler des fichiers en Python

n Calculer la complexité d'un algorithme

n Écrire des preuves de correction et de terminaison d'un algorithme

n La récursivité et son application dans des algorithmes

n Les enregistrements et les fichiers en Python

n La complexité des algorithmes et ses principaux types

n Les preuves d'algorithmes et les méthodes de preuves de correction et de terminaison

1.3 Plan détaillé

n Comprendre la notion de fonction et de procédure en informatique.

n Savoir définir et utiliser des fonctions et des procédures en Python.

n Connaître les principes de la portée des variables.

n Comprendre la notion de récursivité et savoir l'appliquer dans des algorithmes.

n Savoir utiliser la récursivité pour résoudre des problèmes spécifiques.

n Comprendre la notion d'enregistrements et de fichiers en informatique.

n Comprendre la notion de complexité des algorithmes.

n Savoir calculer la complexité d'un algorithme.

n Connaître les principaux types de complexité et leurs caractéristiques.

n Comprendre l'importance des preuves d'algorithmes.

n Savoir écrire des preuves de correction et de terminaison d'un algorithme.

n Être capable d'appliquer les méthodes de preuves d'algorithmes pour différents

Pr. Abdeltif EL BYED

2 Rappels sur la première partie : Informatique 1

2.1.2 Exemple des langages de programmation

2.2 Le langage Python

Pr. Abdeltif EL BYED

· une fenêtre de terminal (ou console)

Voici un exemple d’IDE et de distribution les plus utilisés:

· Pyzo, IPython/Jupyter, WingIDE, PyCharm, Anaconda, etc.

Il existe deux façons de travailler avec python : soit l'interpréteur ou l'éditeur.

2.3 Outils de développement et d’exécution

n Pour quitter l'interpréteur, on exécute la fonction exit()

2.3.2 Environnement ANACONDA

· CMD.exe est un shell

Pr. Abdeltif EL BYED

2.4 Éditeurs de programmes

On exécute le script depuis une fenêtre de terminal,

1. en se déplaçant dans le répertoire qui contient le script

2. et en saisissant le mot python suivi du nom du fichier script.

2.4.3 Jupyter Notebook

· clique sur New àPyhton3: pour créer un nouveau fichier

2.5 Les instructions Python

Pr. Abdeltif EL BYED