Support Formation Samsung - Python - Session 1 - 2022.pptx

Happy CodersAcademy
Formation Python
1

PYTHON & Algorithme
1. Introduction à la programmation orientée objet
2. Introduction à Python
3. Installation Python et Anaconda
4. Algorithmes ‘pseudo code and flow charts’
5. Découverte Python (Premiers pas)
6. Instructions
7. Structures de données
8. Algorithme de tri
9. Développement des algorithme de la recherche séquentielle et binaire
10. Exercices et Challenges
2

Python & Algorithme - 1ère session
J1 J2 J3 J4 J5
Formation Code
* Introduction sur Python.
* Installation des environnements de
développement (Anaconda et
l'environnement virtuel, Python) et se
familiariser avec les différents outils.
* Algorithme.
* Découverte Python (notion de
bases).
* Exercices et challenges de base.
From unit 1 to unit 9
Formation Créativité
* Exercices et Challenge avancés
Formation Code
* Manipulations et opérations sur les
différents types de données.
* Manipulations et opérations sur des
fonctions simples et complexes.
* Introduction sur la programmation
orientée objet.
* Exercices et Challenges de base.
Formation Pédagogie
* Manipulations et opérations sur les
class.
* Exercices et Challenge avancés.
Formation Code/Pédagogie
* Manipulations et opérations sur la
structure de données la file 'Queue'.
* Manipulations et opérations sur la
structure de données la plie 'Stack'.
* Développement des algorithme de la
recherche séquentielle et binaire.
* Manipulations et opérations la
structure de données table de hachage.
* Développement d'un mini-projet (I).
Formation Code
* Algorithme de tri :
1. Sélection;
2. Bulles
3. Insertion
4. Fusion
5. Rapide
* Exercices et Challenge.
Atelier projet 'Partie I'
* Projets encadré :
1. Méthodologie de travail
'Méthode Scrum de la méthode Agile"
2. Langage UML et conception du
projet (2 ou 3 diagrammes
fondamentaux)
3. Choix des projets
4. Elaboration et présentation du cahier
des charges.
Atelier projet 'Partie II'
* Projets encadré :
5. Développement du projet
6. Test, vérification et Validation
7. Présentation des projets.
Quiz Global et feedbacks
3

1. Introduction à la programmation orientée objet :
La programmation orientée objet est l'un des outils les plus importants dans le
développement logiciel. C'est une façon de programmer qui permet une meilleure
organisation de son code.
Le code développé à l'aide de la programmation orientée objet est bien
plus flexible et donc facilement exportable.
4

2. Introduction à Python :
Python est un langage puissant, à la fois facile à apprendre et riche en possibilités.
Dès l'instant où vous l'installez sur votre ordinateur, vous disposez de nombreuses
fonctionnalités intégrées au langage que nous allons découvrir tout au long de ce cours.
Python est un langage de programmation interprété, c'est-à-dire que les instructions que
vous lui envoyez sont « transcrites » en langage machine au fur et à mesure de leur lecture.
D'autres langages (comme le C / C++) sont appelés « langages compilés » car, avant de pouvoir
les exécuter, un logiciel spécialisé se charge de transformer le code du programme en langage
machine. On appelle cette étape la « compilation ». À chaque modification du code, il faut
rappeler une étape de compilation.
5

3. Installation Python et Anaconda :
Vous pouvez télécharger gratuitement le logiciel Python depuis le site officiel ci-dessous :
https://www.python.org/downloads/
L’installation de Python peut-être un vrai challenge. Déjà il faut se décider entre les versions 2.X et
3.X du langage (Slide suivant). Et par la suite, choisir les librairies nécessaires (ainsi que les versions
compatibles). Sans oublier les subtilités liées aux différents OS (Windows, Linux, Mac…) qui peuvent
rendre l’installation encore plus douloureuse.
3.1 – Installation simple de Python:
6

Versions de langage Python
Python continue à évoluer, mais cette évolution ne vise qu’à améliorer ou perfectionner le produit.
Il est donc très rare qu’il faille modifier les programmes afin de les adapter à une nouvelle version qui
serait devenue incompatible avec les précédentes
‣ Décembre 2000 ~ the present Python 2.7
‣ Syntax : Exemple fonction print : print "bonjour“
‣ Décembre 2008 ~ the present Python 3.8
‣ Syntax : Exemple fonction print : print ("bonjour“)
‣ Plus de bibliothèques.
Python 2.0
Python 3.0
7

L’installation d’un environnement Python complet peut-
être complexe. Pour commmencer, il faut télécharger
Python et l’installer. Par la suite, télécharger un à un les
packages dont on a besoin. Parfois, le nombre de ces
librairies peut-être grand.
Par ailleurs, il faut s’assurer de la compatibilité entre les
versions des différentes packages qu’on a à télécharger
3.2 – Installation avancée avec Anaconda :
8

Anaconda est une distribution Python. A son installation, Anaconda installera Python ainsi
qu’une multitude de packages (voir liste de packages anaconda).
Finalement, Anaconda propose un outil de gestion de packages appelé Conda. Ce dernier
permettra de mettre à jour et installer facilement les librairies dont on aura besoin pour nos
développements.
3.2 – Anaconda :
9

Téléchargement Anaconda :
3.2 – Anaconda :
Note : Les instructions qui suivent ont été testées sur Windows 10. Le même processus
d’installation pourra s’appliquer pour les autres OS.
Pour télécharger Anaconda, rendez vous à la https://www.anaconda.com/products/distribution
Ou vous pouvez télécharger en cliquant sur le lien ci-dessous :
https://repo.anaconda.com/archive/Anaconda3-2022.05-Windows-x86_64.exe
10

3.2 – Anaconda :
A l’issue de l’installation, vous
aurez Anaconda Navigator. Ce dernier est une
interface graphique permettant de
lancer Jupyter (pour écrire du python au
format notebook), ou encore Spyder (IDE pour
éditer du code python).
Tout au long de la formation, nous
utiliserons Jupyter.
11

4. Algorithmes ‘pseudo code and flow charts’ :
Pour créer un notebook, cliquez sur le bouton à
droite New puis sélectionnez Python 3. Vous noterez au
passage qu'il est également possible de créer un fichier
texte, un répertoire ou bien encore de lancer un shell via
un Terminal.
On retrouve également les triples chevrons >>> qui
indiquent que Python est prêt à recevoir votre première
instruction.
Le notebook fraîchement créé ne contient qu'une
cellule vide.
12

5. Premiers pas : Pour commencer il faut ouvrir Jupyter
Pour créer un notebook, cliquez sur le bouton à
droite New puis sélectionnez Python 3. Vous noterez au
passage qu'il est également possible de créer un fichier
texte, un répertoire ou bien encore de lancer un shell via
un Terminal.
On retrouve également les triples chevrons >>> qui
indiquent que Python est prêt à recevoir votre première
instruction.
Le notebook fraîchement créé ne contient qu'une
cellule vide.
13

Premier pas et notions importantes
‣ Calculer avec Jupyter/Python :
Vous pouvez entrer des instructions Python dans la première cellule. Par exemple :
Pour exécuter le contenu de cette cellule, vous avez plusieurs possibilités :
 Cliquer sur le menu Cell, puis Run Cells.
 Cliquer sur le bouton Run (sous la barre de menu).
 Presser simultanément les touches Ctrl + Entrée.
14

Dans tous les cas, vous devriez obtenir quelque chose qui ressemble à l'image
ci-dessous.
La notation In [1] à gauche de la cellule indique qu'il s'agit de la première cellule
exécutée;
15

Pour créer une nouvelle cellule, vous avez, ici encore, plusieurs possibilités :
 Cliquer sur l’icône + sous la barre de menu.
 Cliquer sur le menu Insert, puis Insert Cell Below.
 Une nouvelle cellule vide devrait apparaître.
16

‣ Convention de nommage :
- Commencer par une lettre ou un underscore.
- Elle doit ne pas contenir de caractères spéciaux.
- Elle ne doit pas contenir d'espaces.
- On peut utiliser des underscores (_).
- Il est encouragé d’utiliser des noms qui puissent directement commenter votre code.
- Il faut absolument éviter d’utiliser un mot « réservé » par Python (cf. liste ci-dessous)
False Class finally is return
None continue for lambda try
True def from nonlocal while
and del global not with
as elif if or yield
assert else import pass
break except in raise
17

‣ Type des Variables :
- Entier numérique (int).
- Nombre flottant (float).
- Chaîne de caractères (str).
- Booléen (bool).
- Listes.
- Dictionnaires.
- Tuples.
Le type d’une variable correspond à la nature de celle-ci :
type(_)
Saisir la commande
18

‣Prédire le résultat : opérations
Essayez de prédire le résultat de chacune des instructions suivantes, puis vérifiez-le
dans l’interpréteur Python :
>> (1+2)**3
>> "Da" * 4
>> "Da" + 3
>> ("Pa"+"La") * 2
‣Prédire le résultat : Conversion de type (cast)
Essayez de prédire le résultat de chacune des instructions suivantes, puis vérifiez-le dans
l’interpréteur Python :
>> ("Da"*4) / 2
>> 5 / 2
>> 5 // 2
>> 5 % 2
>> str(4) * int("3")
>> int("3") + float("3.2")
>> str(3) * float("3.2")
>> str(3/4) * 2
19

‣ Sélection ou exécution conditionnelle
La plus simple de ces instructions conditionnelles est l’instruction if. Pour expérimenter
son fonctionnement, veuillez entrer dans votre éditeur Python les deux lignes suivantes :
>>> a = 0
>>> if a > 0 :
... print("a est positif")
elif a < 0 :
... print("a est négatif")
else:
... print("a est nul")
20

‣ Opérateurs de comparaison
La condition évaluée après l’instruction if peut contenir les opérateurs de
comparaison suivants :
x == y # x est égal à y
x != y # x est différent de y
x > y # x est plus grand que y
x < y # x est plus petit que y
x >= y # x est plus grand que, ou égal à y
x <= y # x est plus petit que, ou égal à
>>> a = 7
>>> if (a % 2 == 0):
... print("a est pair")
... print("parce que le reste de sa division par 2 est nul")
... else:
... print("a est impair")
21

Il est parfaitement possible d’imbriquer plusieurs instructions composées, de manière
à réaliser des structures de décision complexes. Exemple :
‣ Instructions imbriquées
if embranchement == "vertébrés": # 1
if classe == "mammifères": # 2
if ordre == "carnivores": # 3
if famille == "félins": # 4
print("c’est peut-être un chat") # 5
print("c’est en tous cas un mammifère") # 6
elif classe == "oiseaux": # 7
print("c’est peut-être un canari") # 8
print("la classification des animaux est complexe") # 9
22

‣ Répétitions en boucle – l’instruction while
Nous allons commencer par l’une des plus fondamentales : la boucle
construite à partir de l’instruction while. Veuillez donc entrer les commandes ci-
dessous :
>>> a = 0 # Il faut que la conditionne soit toujours vérifiée
>>> while (a < 7) : # (n’oubliez pas le double point !)
............. a = a + 1 # (n’oubliez pas l’indentation !)
............. print(a)
>>> n = 3
>>> while n < 5:
... print("hello !")
23

‣ Les listes (première approche)
Sous Python, on peut définir une liste comme une collection d’éléments séparés par des
virgules, l’ensemble étant enfermé dans des crochets. Exemple :
>>> jour = ['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi']
>>> print(jour)
['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi']
Dans cet exemple, la valeur de la variable jour est une liste.
>>> jour = ['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi']
>>> print(jour[2])
mercredi
>>> print(jour[4])
20.357
24

>>> print(jour) ['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi']
>>> jour[3] = jour[3] +47
>>> print(jour) ['lundi', 'mardi', 'mercredi', 1847, 20.357, 'jeudi', 'vendredi‘]
Il est possible de changer les éléments individuels d’une liste :
On peut donc remplacer certains éléments d’une liste par d’autres, comme ci-
dessous :
>>> jour[3] = 'Juillet'
>>> print(jour) ['lundi', 'mardi', 'mercredi', 'Juillet', 20.357, 'jeudi', 'vendredi']
La fonction intégrée len(), que nous avons déjà rencontrée à propos des chaînes,
s’applique aussi aux listes. Elle renvoie le nombre d’éléments présents dans la liste :
>>> print(len(jour))
7
25

Une autre fonction intégrée permet de supprimer d’une liste un élément quelconque (à
partir de son index). Il s’agit de la fonction del() 23 :
>>> del(jour[4])
>>> print(jour) ['lundi', 'mardi', 'mercredi', 'juillet', 'jeudi', 'vendredi']
Il est également tout à fait possible d’ajouter un élément à une liste :
>>> jour.append('samedi')
>>> print(jour)
>>> ['lundi', 'mardi', 'mercredi', 'juillet', 'jeudi', 'vendredi', 'samedi']
26

‣ Affichage : la fonction print()
On manipule les valeurs et les variables qui les référencent en les
combinant avec des opérateurs pour former des expressions. Exemple :
Fonctions prédéfinies
>>> print("Bonjour", "à", "tous", sep ="*")
Bonjour*à*tous
>>> print("Bonjour", "à", "tous", sep ="")
Bonjouràtous
>>> n =0
>>> while n<6:
... print("zut", end ="")
... n = n+1 ...
zutzutzutzutzut
27

‣ Interaction avec l’utilisateur : la fonction input()
La plupart des scripts élaborés nécessitent une intervention de l’utilisateur (entrée d’un
paramètre, clic de souris sur un bouton, etc.).
>>> prenom = input("Entrez votre prénom : ")
>>> print("Bonjour,", prenom)
>>> print("Veuillez entrer un nombre positif quelconque : ", end=" ")
>>> ch = input()
>>> nn = int(ch)
>>> print("Le carré de", nn, "vaut", nn**2)
Fonctions prédéfinies
28

Fonctions simple sans paramètre
Affichage:
>>> table7()
7 14 21 28 35 42 49 56 63 70
>>> def table7triple():
... print('La table par 7 en triple exemplaire :')
... table7()
... table7()
... table7()
Affichage:
>>> table7triple()
La table par 7 en triple exemplaire :
7 14 21 28 35 42 49 56 63 70
7 14 21 28 35 42 49 56 63 70
7 14 21 28 35 42 49 56 63 70
La syntaxe Python pour la définition d’une fonction
est la suivante :
def nomDeLaFonction (liste de paramètres):
...
bloc d'instructions
...
Exemple:
>>> def table7():
... n = 1
... while n <11 :
... print(n * 7, end =' ‘)
... n = n +1
...
Rq: Une première fonction peut donc appeler une deuxième fonction, qui elle-même en appelle une troisieme, etc.
6. Instructions :
29

Fonctions avec paramètre :
>>> def table(base):
... n = 1
... while n <11 :
... print(n * base, end =' ')
... n = n +1
Utilisation d’une variable comme argument:
>>> a = 1
>>> while a <20:
... table(a)
... a = a +1
...
Remarque importante:
Dans l’exemple ci-dessus, l’argument que nous passons à la fonction table() est le contenu de la variable a.
A l’intérieur de la fonction, cet argument est affecté au paramètre base, qui est une toute autre variable.
Notez donc bien des maintenant que le nom d’une variable que nous passons comme argument n’a rien à voir avec le
nom du paramètre correspondant dans la fonction.
>>> table(13)
30

>>> def tableMulti(base, debut, fin):
... print('Fragment de la table de multiplication par', base, ':')
... n = debut
... while n <= fin :
... print(n, 'x', base, '=', n * base)
... n = n +1
>>> tableMulti(8, 13, 17) => Qu’est ce que ca va donner !!!!
Exemple:
>>> t, d, f = 11, 5, 10
>>> while t<21:
... tableMulti(t,d,f)
... t, d, f = t +1, d +3, f +5
...
Fonctions avec paramètre :
31

Variables locales:
>>> print(base)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'base' is not defined
La machine nous signale clairement que le symbole base lui est inconnu, alors
qu’il était correctement imprimé par la fonction tableMulti() elle-même. L’espace
de noms qui contient le symbole base est strictement réservé au
fonctionnement interne de tableMulti(), et il est automatiquement détruit dès
que la fonction a terminé son travail.
Variables globales:
Les variables définies à l’extérieur
d’une fonction sont des variables
globales. Leur contenu est ≪ visible≫
de l’intérieur d’une fonction, mais la
fonction ne peut pas le modifier.
>>> def monter() :
... global a
... a = a+1
... print(a)
>>> a = 15
>>> monter()
16
>>> monter()
17
Exemple :
>>> def mask():
... p = 20
... print(p, q)
>>> p, q = 15, 38
>>> mask()
20 38
>>> print(p, q)
15 38
32

Vraies fonctions et procédures:
>>> def cube(w):
... return w*w*w L’instruction « return » définit ce que doit être la valeur renvoyée par la fonction.
En l’occurrence, il s’agit du cube de l’argument qui a été transmis lors de l’appel
de la fonction.
Exemple
>>> b = cube(9)
>>> print(b)
729
>>> def table(base):
... resultat = [] # résultat est d’abord une liste vide
... n = 1
... while n < 11:
... b = n * base
... resultat.append(b) # ajout d’un terme à la liste
... n = n +1
... return resultat
Test
>>> ta9 = table(9)
>>> print(ta9)
[9, 18, 27, 36, 45, 54, 63, 72, 81, 90]
>>> print(ta9[0])
9
>>> print(ta9[3])
36
>>> print(ta9[2:5])
[27, 36, 45]
33

Typage des paramètres:
le typage des variables sous Python est un typage dynamique, ce qui signifie que le
type d’une variable est défini au moment où on lui affecte une valeur. Ce mécanisme
fonctionne aussi pour les paramètres d’une fonction. Le type d’un paramètre devient
automatiquement le même que celui de l’argument qui a été transmis à la fonction.
>>> def afficher3fois(arg):
... print(arg, arg, arg) ...
>>> afficher3fois(5)
5 5 5
>>> afficher3fois('zut')
zut zut zut
>>> afficher3fois([5, 7])
[5, 7] [5, 7] [5, 7]
>>> afficher3fois(6**2)
36 36 36
34

Valeur par défaut pour les paramètres :
Dans la définition d’une fonction, il est possible (et souvent souhaitable) de définir un
argument par défaut pour chacun des paramètres.
>>> def politesse(nom, vedette ='Monsieur'):
... print("Veuillez agréer ,", vedette, nom, ", mes salutations cordiales.") ...
>>> politesse('Dupont')
Veuillez agréer , Monsieur Dupont , mes salutations cordiales.
>>> politesse('Durand', 'Mademoiselle')
Veuillez agréer , Mademoiselle Durand , mes salutations cordiales
35

Valeur par défaut pour les paramètres :
Dans la définition d’une fonction, il est possible (et souvent souhaitable) de définir un argument
par défaut pour chacun des paramètres.
>>> def question(annonce, essais =4, please =’Oui ou non, s.v.p.!’):
while essais >0: ...
reponse = input(annonce) ...
if reponse in ('o', 'oui','O','Oui','OUI'): ...
return 1 ...
if reponse in ('n','non','N','Non','NON'): ...
return 0 ...
print(please) ...
essais = essais-1
... >>>
rep = question('Voulez-vous vraiment terminer ? ')
ou bien :
rep = question('Faut-il effacer ce fichier ? ', 3)
ou même encore :
rep = question('Avez-vous compris ? ', 2, 'Répondez par oui ou par non !')
36

• Objets :
>>> def affiche_point(p):
... print("coord. horizontale =", p.x, "coord. verticale =", p.y)
Les fonctions peuvent utiliser des objets comme paramètres, et elles peuvent également
fournir un objet comme valeur de retour.
>>> affiche_point(p9)
coord. horizontale = 3.0 coord. verticale = 4.0
Classes, objets, attributs :
37

• Objets (Similitude et unicité) :
>>> p1 = Point()
>>> p1.x = 3
>>> p1.y = 4
>>> p2 = Point()
>>> p2.x = 3
>>> p2.y = 4
>>> print(p1 == p2)
False
>>> print(p1)
<__main__.Point instance at 00C2CBEC>
>>> print(p2)
<__main__.Point instance at 00C50F9C
• Objets comme valeurs de retour d’une fonction
>>> def trouveCentre(box):
... p = Point()
38

• Attributs :
>>> class Point(object): ... "Définition d'un point géométrique"
L’objet que nous venons de créer est juste une coquille vide. Nous allons à présent lui
ajouter des composants, par simple assignation, en utilisant le système de qualification des noms
par points
>>> p9.x = 3.0
>>> p9.y = 4.0
>>> print(p9.x) 3.0
>>> print(p9.x**2 + p9.y**2)
25.0
39

Méthode
• Définition :
>>> class Time(object):
... "définition d'objets temporels"
>>> instant = Time()
>>> instant.heure = 11
>>> instant.minute = 34
>>> instant.seconde = 25
>>> affiche_heure(instant) 11:34:25
>>> def affiche_heure(t): ... print(str(t.heure) +":" +str(t.minute) +":" +str(t.seconde))
>>> def affiche_heure(t): ... print("{}:{}:{}".format(t.heure, t.minute, t.seconde))
40

7. Structures de données:
‣ Une structure de donnée : c'est une organisation des données permettant de simplifié ou d'organisé
leur traitement. Autrement dit, elle relie entre elles, les données.
Définition :
Structure de donnée
Structure linéaire Structure non-linéaire
• Les listes
• Les piles
• Les files
• Les arbres
• Les graphes
41

Les piles et les files, c’est quoi ?
‣ Ce sont deux variantes de listes chaînées.
‣ Les piles et files ne sont pas de nouveaux types de données mais plutôt une manière de gérer un
ensemble de données.
‣ Elles permettent de contrôler la manière dont sont ajoutés les nouveaux éléments.
‣ Seulement, cette fois ci, on n'insère plus de nouveaux éléments au milieu de la liste mais seulement au
début ou à la fin.
‣ Elles sont très souvent utiles et servent, entre autre, à mémoriser des évènements en attente de
traitement.
42

7.1 La pile :
Les piles de données - en anglais ‘Stack’ :
‣ La pile est une structure de données, qui permet de stocker les données dans l'ordre LIFO (Last In First
Out) - en français (Dernier Entré Premier Sorti). Autrement dit, la récupération des données sera faite
dans l'ordre inverse de leur insertion.
‣ Une pile est un ensemble de valeurs ne permettant des insertions ou des suppressions qu’a une seule
extrémité, appelée sommet de la pile.
Type abstrait de données (représentation logique qui définit le comportement) :
Sommet
43

Pile P
Pile vide
(Empty stack)
7.1 La pile :
44

Pile P
‣ Empiler un objet sur une pile P consiste à insérer cet objet au sommet de P.
1
Empiler (push)
7.1 La pile :
45

Pile P
1
Empiler (push)
23
7.1 La pile :
46

Pile P
‣ Empiler un objet sur une pile P consiste à insérer cet objet au sommet de P
‣ On ajoute d’autre éléments à l’aide de l’opération – empiler (push).
1
Empiler (Push)
23
15
7.1 La pile :
47

Pile P
‣ Empiler un objet sur une pile P consiste à insérer cet objet au sommet de P
1
Empiler (Push)
23
15
3
7.1 La pile :
48

‣ Seul le sommet de la pile est accessible, on peut le consulter à l’aide d’une
opération – sommet (peek en anglais).
Pile P
1
Sommet (peek)
23
15
3
7.1 La pile :
49

Pile P
‣ Pour avoir accès au nombre 1 il va falloir dépiler les éléments de la pile un par
un.
1
Dépiler (pop)
23
15
3
7.1 La pile :
50

Pile P
un.
1
Dépiler (pop)
23
15
7.1 La pile :
51

Pile P
un.
1
Dépiler (pop)
23
7.1 La pile :
52

Pile P
un.
1
Dépiler (pop)
7.1 La pile :
53

‣ Les éléments de la pile sont reliés entre eux à la manière d'une liste chaînée. Ils
possèdent un pointeur vers l'élément suivant et ne sont donc pas forcément
placés côte à côte en mémoire.
‣ Le dernier élément (tout en bas de la pile) doit pointer vers NULL pour indiquer
qu'on a… touché le fond.
1
23
15
3
Pile P
NULL
7.1 La pile :
54

À quoi sert une pile ?
‣ En informatique une pile sert
essentiellement à stocker des
données qui ne peuvent pas être
traitées immédiatement, car le
programme a une tâche plus urgente
ou préalable à accomplir auparavant.
‣ En particulier les appels et retours de
fonctions sont gérés grâce à une pile
appelée pile d'exécution.
7.1 La pile :
Les processeurs dans les
ordinateur gèrent un système
de piles.
Une pile est utilisée pour
mémorisé une page visitée
dans le navigateur web.
Traitement de texte ou traitement
d’image (ctrl+z)
55

Les manipulations six principales :
‣ La manipulation d’une pile revient à l’appel de fonctions et procédures dites de bases définies une
seule fois et utilisées autant de fois qu’il est nécessaire.
✔ Initialisation : permet d’initialiser une pile à vide lors de sa création ;
✔ Pile vide : pour vérifier si une pile est vide ou non et savoir alors s’il reste des valeurs à traiter ou
non ;
✔ Pile pleine : pour vérifier s’il est possible de rajouter ou non un nouveau élément (utilisée dans le
seul cas des piles statiques) ;
7.1 La pile :
56

Les manipulations six principales :
‣ La manipulation d’une pile revient à l’appel de fonctions et procédures dites de bases définies une
‣ Empiler : permet d’ajouter une nouvelle valeur (envoyé en paramètre par l’appelant) à la pile (au
dessus du sommet et dans le cas d’une pile non pleine) ;
‣ Dépiler : permet de supprimer une valeur (se trouvant au sommet de la pile) et de la renvoyer en
paramètre. Cette opération n’est possible que si la pile n’est pas vide.
‣ Sommet : permet de consulter le sommet ( le dernier élément) de la pile.
7.1 La pile :
57

Exercice : Création d’un système de pile
Nous avons étudié le principe de fonctionnement des piles, essayons d'en construire une.
Nous aurons besoin en tout et pour tout des fonctions suivantes :
• empilage d'un élément ;
• dépilage d'un élément;
• Affichage de l’élément le plus haut de la pile.
• Fonction d’affichage pour vérifier si le programme se comporte correctement.
7.1 La pile :
58

Solution - Création d’un système de pile
7.1 La pile :
class Stack:
def __init__(self):
self.elements = []
def push(self, data):
self.elements.append(data)
return data
def pop(self):
return self.elements.pop()
def peek(self):
return self.elements[-1]
def is_empty(self):
return len(self.elements) == 0
if __name__ == '__main__':
stack = Stack()
## checking is_empty method -> true
print(stack.is_empty())
## pushing the elements
stack.push(1)
stack.push(2)
stack.push(3)
stack.push(4)
stack.push(5)
## again checking is_empty method -> false
## printing the topmost element of the stack -> 5
print(stack.peek())
## popping the topmost element -> 5
stack.pop()
## checking the topmost element using peek method -> 4
print(stack.peek())
## popping all the elements
stack.pop()
stack.pop()
stack.pop()
stack.pop()
## checking the is_empty method for the last time -> true
59

7.2 La file :
Les files de données - en anglais queue :
‣ En informatique une file sert essentiellement à stocker des données qui doivent être traitées selon leur
ordre d’arrivée.
‣ Quand on vous dit file, pensez directement à une file d’attente où chacun à son tour qu’il doit
respecter.
‣ Ce qui fait que les objets quittent la pile dans l'ordre de leur ordre d'arrivée. Pour cette raison, une
file est aussi appelée structure FIFO (First In, First Out) ou (premier arrivé, premier sorti)
60

File F
File vide
(Empty queue)
7.2 La file :
61

File F
Enfiler
(enqueue)
‣ Enfiler un objet sur une file F consiste à insérer cet objet à la fin de la file F.
1
7.2 La file :
62

File F
Enfiler
(enqueue)
8 1
7.2 La file :
63

File F
Enfiler
(enqueue)
12 8 1
7.2 La file :
64

File F
Enfiler
(enqueue)
5 12 8 1
7.2 La file :
65

File F
début
(front)
opération – début (front en anglais).
5 12 8 1
7.2 La file :
66

File F
Défiler
(dequeue)
‣ Défiler un objet de F consiste à supprimer de F l'objet placé en début de file
5 12 8 1
7.2 La file :
67

File F
Défiler
(dequeue)
5 12 8
7.2 La file :
68

File F
Défiler
(dequeue)
5 12
7.2 La file :
69

File F
Défiler
(dequeue)
5
7.2 La file :
70

File F
File vide
(Empty queue)
7.2 La file :
71

À quoi sert une file ?
‣ En informatique une file sert essentiellement à stocker des données qui doivent être traitées selon
leur ordre d’arrivée.
Evaluation des expression
mathématiques.
Systèmes d’exploitation.
7.2 La file :
72

‣ La manipulation d’une file revient à l’appel de fonctions et procédures dites de bases définies une
✔ Initialisation : permet d’initialiser une file à vide lors de sa création ;
✔ file vide : pour vérifier si une file est vide ou non et savoir s’il reste des valeurs à traiter ou non ;
✔ file pleine : pour vérifier s’il est possible de rajouter ou non un nouveau élément (utilisée dans le
seul cas des piles statiques) ;
Les six manipulations principales (1/2):
7.2 La file :
73

Les six manipulations principales (2/2):
‣ La manipulation d’une file revient à l’appel de fonctions et procédures dites de bases définies une
‣ Enfiler : permet d’ajouter une nouvelle valeur (envoyé en paramètre par l’appelant) à la file;
‣ Défiler : permet de supprimer une valeur (se trouvant au début de la file) et de la renvoyer en
paramètre. Cette opération n’est possible que si la file n’est pas vide.
‣ front : permet de consulter le début ( le premier élément) de la file.
7.2 La file :
74

Exercice : Création d’un système de file
Nous avons étudié le principe de fonctionnement des files, essayons d'en construire une. Le
système de file va ressembler à peu de choses près aux piles. Il y a seulement quelques petites
subtilités étant donné que les éléments sortent de la file dans un autre sens, mais rien
d'insurmontable si vous avez compris les piles.
Nous aurons besoin en tout et pour tout des fonctions suivantes :
• Enfilage d'un élément ;
• Défilage d'un élément;
• Fonction d’affichage pour vérifier si le programme se comporte correctement.
7.2 La file :
75

7.2 La file :
Solution - Création d’un système de file
class Queue:
def __init__(self):
self.elements = []
def enqueue(self, data):
self.elements.append(data)
return data
def dequeue(self):
return self.elements.pop(0)
def rear(self):
return self.elements[-1]
def front(self):
return self.elements[0]
def is_empty(self):
return len(self.elements) == 0
if __name__ == '__main__':
queue = Queue()
## checking is_empty method -> True
print(queue.is_empty())
## adding the elements
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
queue.enqueue(4)
queue.enqueue(5)
## again checking is_empty method -> False
## printing the front and rear elements using front and rear methods respectively -> 1, 5
print(queue.front(), end=' ')
print(queue.rear())
## removing the element -> 1
queue.dequeue()
## checking the front and rear elements using front and rear methods respectively -> 2 5
print(queue.front(), end=' ')
print(queue.rear())
## removing all the elements
queue.dequeue()
queue.dequeue()
queue.dequeue()
queue.dequeue()
## checking the is_empty method for the last time -> True
76

Problème : 'Problème de Josephus'
Josephus Flavius était un célèbre historien du premier siècle. Durant une guerre il fut pris au piège dans une cave avec son
groupe de 40 soldats, entouré par les troupes ennemies. La légende raconte que le groupe encerclé préféra se suicider plutôt
que d'être capturé. Ainsi Josephus et ses soldats formèrent un cercle et décidèrent de se tuer mutuellement et successivement,
de manière à ce qu'une personne tue la troisième personne sur sa gauche, que la personne à droite du mort tue à son tour la
troisième personne sur sa gauche, ainsi de suite jusqu'à ce qu'il ne reste qu'un seul survivant. Restant seul, ce dernier est censé
se suicider lui-même. Josephus, qui ne souhaitait pas mourir, trouva rapidement la place sûre, c'est-à-dire la place de la
dernière personne debout, sans que quiconque ne reste pour le tuer. Ainsi il resta en vie et put par la suite raconter cette
légende. Trouver cette place sûre est maintenant appelé le problème de Josephus.
7.2 La file :
77

7.2 La file :
class Maillon:
def __init__(self, valeur, precedent=None, suivant=None):
self.valeur = valeur
self.precedent = precedent
self.suivant = suivant
class File:
def __init__(self):
self.longueur = 0
self.debut = None
self.fin = None
def enfiler(self, valeur):
if self.longueur == 0:
self.debut = self.fin = Maillon(valeur)
else:
self.fin = Maillon(valeur, self.fin)
self.fin.precedent.suivant = self.fin
self.longueur += 1
def defiler(self):
if self.longueur > 0:
valeur = self.debut.valeur
if self.longueur > 1:
self.debut = self.debut.suivant
self.debut.precedent = None
else:
self.debut = self.fin = None
self.longueur -= 1
return valeur
def estVide(self):
return self.longueur == 0
def __str__(self):
ch = "nEtat de la file:n"
maillon = self.debut
while maillon != None:
ch += str(maillon.valeur) + " "
maillon = maillon.suivant
return ch 78

8. Algorithme de tri :
Le tri est l'une des fonctionnalités les plus utilisées en programmation.
Et il faudrait beaucoup de temps pour terminer le tri si nous n'utilisons pas le bon algorithme.
Dans cette partie, nous allons discuter de différents algorithmes de tri.
Nous vous guiderons à travers les différents algorithmes de tri à chaque étape de la mise en œuvre.
Vous pouvez facilement le convertir dans n'importe quelle langue une fois que vous obtenez
l'algorithme : c'est la question de la syntaxe du langage.
79

‣ Un algorithme de tri est, en informatique ou en mathématiques, un algorithme qui permet
d'organiser une collection d'objets selon une relation d'ordre déterminée.
‣ C'est une suite d'opérations afin de ranger selon un certain ordre les données.
Définition :
Exemple :
80

Problématique :
Lorsque l'on veut traiter un grand
nombre de données, ces opérations
de tri deviennent trop longues et
difficiles.
Les informaticiens ont cherché à
élaborer des algorithmes de tri plus
efficaces et plus rapides possibles.
Solution
81

Historique :
L'un des premier tris automatisés par une machine a été le dépouillement des recensements aux état unis.
En 1880, le dépouillement
du recensement effectué à
la main à pris 9 ans.
En 1890, le dépouillement
du recensement a pris
uniquement 3 ans.
82

‣ Tri par sélection
‣ Tri par insertion
‣ Tri à bulles
• Trois algorithmes basique à savoir :
Dans cette partie nous allons parlé de 5 algorithmes de tri qui font partie des algorithmes de tri :
• Deux algorithmes rapides et plus évolués
‣ Tri par fusion
‣ Tri rapide
83

8.1 Algorithme de tri ‘Bulles’ :
Le principe du tri à bulle (Bubble Sort en Anglais) est de reproduire le déplacement d’une bulle d’air dans
un liquide : elle remonte progressivement à la surface.
On appelle cycle la séquence d’actions suivante :
1. On part du premier élément du tableau.
2. On compare les éléments consécutifs deux à deux :
• Si le premier est supérieur au deuxième : ils sont échangés ;
• Sinon : on ne fait rien.
3. On passe aux deux éléments consécutifs suivants, jusqu’à arriver à la fin du tableau.
On répète ce cycle jusqu’à ce que plus aucun échange ne soit effectué.
84

Algorithmes de tri – Simulation :
Tri à bulle
6 5 1 3 2 7 4
85

Tri à bulle
6 5 1 3 2 7 4
86

Tri à bulle
6 5 1 3 2 7 4
87

Tri à bulle
5 6 1 3 2 7 4
88

Tri à bulle
5 6 1 3 2 7 4
89

Tri à bulle
5 6 1 3 2 7 4
90

Tri à bulle
5 1 6 3 2 7 4
91

Tri à bulle
5 1 6 3 2 7 4
92

Tri à bulle
5 1 3 6 2 7 4
93

Tri à bulle
5 1 3 6 2 7 4
94

Tri à bulle
5 1 3 2 6 7 4
95

Tri à bulle
5 1 3 2 6 7 4
96

Tri à bulle
5 1 3 2 6 7 4
97

Tri à bulle
5 1 3 2 6 7 4
98

Tri à bulle
5 1 3 2 6 4 7
99

Tri à bulle
5 1 3 2 6 4 7
100

Tri à bulle
5 1 3 2 6 4 7
101

Tri à bulle
1 5 3 2 6 4 7
102

Tri à bulle
1 5 3 2 6 4 7
103

Tri à bulle
1 3 5 2 6 4 7
104

Tri à bulle
1 3 5 2 6 4 7
105

Tri à bulle
1 3 5 2 6 4 7
106

Tri à bulle
1 3 2 5 6 4 7
107

Tri à bulle
1 3 2 5 6 4 7
108

Tri à bulle
1 3 2 5 4 6 7
109

Tri à bulle
1 3 2 5 4 6 7
110

Tri à bulle
1 3 2 5 4 6 7
111

Tri à bulle
1 2 3 5 4 6 7
112

Tri à bulle
1 2 3 5 4 6 7
113

Tri à bulle
1 2 3 4 5 6 7
114

Tri à bulle
1 2 3 4 5 6 7
115

Tri à bulle
1 2 3 4 5 6 7
116

Tri à bulle
1 2 3 4 5 6 7
117

Programme - Tri à bulle sur Python
import random
def bubble_sort(arr, n):
for i in range(n):
## iterating from 0 to n-i-1 as last i elements are already sorted
for j in range(n - i - 1):
## checking the next element
if arr[j] > arr[j + 1]:
## swapping the adjucent elements
arr[j], arr[j + 1] = arr[j + 1], arr[j]
if __name__ == '__main__':
## array initialization
#arr = [3, 4, 7, 8, 1, 9, 5, 2, 6]
arr = random.sample(range(0, 100), 10)
print("Liste avant tri : ")
print(arr)
bubble_sort(arr, 10)
## printing the array
print("Liste après tri : ")
print(str(arr))
118

8.2 Algorithme de tri ‘Sélection’ :
Le principe du tri par sélection (Selection Sort en Anglais) est de déterminer quel est le maximum du tableau,
de le déplacer à l’endroit qu’il devrait occuper si le tableau était trié, puis de continuer avec les valeurs restantes :
1. On cherche la plus grande valeur du tableau.
2. On déplace cette valeur dans le tableau afin de la placer au bon endroit, c'est-à-dire à la dernière place
(case 𝑁−1).
3. On cherche la 2ème plus grande valeur du tableau : on cherche donc la plus grande valeur du sous-tableau
allant de la case 0 à la case 𝑁−2 incluse.
4. On déplace cette valeur dans le tableau afin de la placer au bon endroit, c'est-à-dire à l’avant-dernière place
(case 𝑁−2), soit la 2ème case en partant de la fin du tableau.
5. On cherche la 3ème plus grande valeur du tableau : on cherche donc la plus grande valeur du sous-tableau
allant de la case 0 à la case 𝑁−3 incluse.
6. On déplace cette valeur dans le tableau afin de la placer au bon endroit, c'est-à-dire à l’antépénultième
place (case 𝑁−3), soit la 3ème case en partant de la fin du tableau.
7. On répète ce traitement jusqu’à ce que le sous-tableau à traiter ne contienne plus qu’une seule case (la case
0), qui contiendra obligatoirement le minimum de tout le tableau.
119

Tri par sélection
7 6 1 2 4 3 5
120

Tri par sélection
7 6 1 2 4 3 5
121

Tri par sélection
7 6 1 2 4 3 5
122

Tri par sélection
7 6 1 2 4 3 5
123

Tri par sélection
7 6 1 2 4 3 5
124

Tri par sélection
7 6 1 2 4 3 5
125

Tri par sélection
7 6 1 2 4 3 5
126

Tri par sélection
7 6 1 2 4 3 5
127

Tri par sélection
7 6 1 2 4 3 5
128

Tri par sélection
7 6 1 2 4 3 5
129

Tri par sélection
1 6 7 2 4 3 5
130

Tri par sélection
1 6 7 2 4 3 5
131

Tri par sélection
1 6 7 2 4 3 5
132

Tri par sélection
1 6 7 2 4 3 5
133

Tri par sélection
1 6 7 2 4 3 5
134

Tri par sélection
1 6 7 2 4 3 5
135

Tri par sélection
1 6 7 2 4 3 5
136

Tri par sélection
1 6 7 2 4 3 5
137

Tri par sélection
1 2 7 6 4 3 5
138

Tri par sélection
1 2 7 6 4 3 5
139

Tri par sélection
1 2 7 6 4 3 5
140

Tri par sélection
1 2 7 6 4 3 5
141

Tri par sélection
1 2 7 6 4 3 5
142

Tri par sélection
1 2 7 6 4 3 5
143

Tri par sélection
1 2 7 6 4 3 5
144

Tri par sélection
1 2 3 6 4 7 5
145

Tri par sélection
1 2 3 4 5 6 7
146

Programme - Tri par sélection sur Python
import random
def bubble_sort(arr, n):
for i in range(n):
## iterating from 0 to n-i-1 as last i elements are already sorted
for j in range(n - i - 1):
## checking the next element
if arr[j] > arr[j + 1]:
## swapping the adjucent elements
arr[j], arr[j + 1] = arr[j + 1], arr[j]
if __name__ == '__main__':
#arr = [3, 4, 7, 8, 1, 9, 5, 2, 6]
print(arr)
bubble_sort(arr, 10)
print(str(arr))
147

8.3 Algorithme de tri ‘Insertion’ :
Le tri par insertion (Insertion Sort en Anglais) effectue un découpage du tableau en deux parties :
▪ Une partie non triée ;
▪ Une partie déjà triée.
Initialement, la partie triée est constituée d’un seul élément : le premier élément du tableau. Le
principe de l’algorithme consiste alors à répéter le traitement suivant :
1. Sélectionner le premier élément de la partie non-triée ;
2. L’insérer à la bonne place dans la partie triée ;
3. Jusqu’à ce qu’il n’y ait plus aucun élément dans la partie non-triée.
148

Tri par insertion
6 5 3 1 8 7 4
149

Tri par insertion
6
5
3 1 8 7 4
150

Tri par insertion
6
5 3 1 8 7 4
151

Tri par insertion
6
5 3 1 8 7 4
152

Tri par insertion
6
5
3
1 8 7 4
153

Tri par insertion
6
5
3
1 8 7 4
154

Tri par insertion
6
5
3
1 8 7 4
155

Tri par insertion
6
5
3 1 8 7 4
156

Tri par insertion
6
5
3 1 8 7 4
157

Tri par insertion
6
5
3
1
8 7 4
158

Tri par insertion
6
5
3
1
8 7 4
159

Tri par insertion
6
5
3
1
8 7 4
160

Tri par insertion
6
5
3
1
8 7 4
161

Tri par insertion
6
5
3
1 8 7 4
162

Tri par insertion
6
5
3
1 8 7 4
163

Tri par insertion
6
5
3
1
8
7 4
164

Tri par insertion
6
5
3
1 8 7 4
165

Tri par insertion
6
5
3
1 8
7
4
166

Tri par insertion
6
5
3
1 8
7
4
167

Tri par insertion
6
5
3
1 8
7 4
168

Tri par insertion
6
5
3
1 8
7 4
169

Tri par insertion
6
5
3
1 8
7
4
170

Tri par insertion
6
5
3
1 8
7
4
171

Tri par insertion
6
5
3
1 8
7
4
172

Tri par insertion
6
5
3
1 8
7
4
173

Tri par insertion
6
5
3
1 8
7
4
174

Tri par insertion
6
5
3
1 8
7
4
175

Tri par insertion
6
5
3
1 8
7
4
176

Programme - Tri par insertion sur Python
import random
def insertion_sort(arr, n):
for i in range(1, n):
## current position and element
current_position = i
current_element = arr[i]
## iteratin until
### it reaches the first element or
### the current element is smaller than the previous element
while current_position > 0 and current_element < arr[current_position - 1]:
## updating the current element with previous element
arr[current_position] = arr[current_position - 1]
## moving to the previous position
current_position -= 1
## updating the current position element
arr[current_position] = current_element
if __name__ == '__main__':
#arr = [3, 4, 7, 8, 1, 9, 5, 2, 6]
print(arr)
insertion_sort(arr, 10)
print(str(arr))
177

8.4 Algorithme de tri ‘Fusion’ :
Le tri fusion (Merge Sort en Anglais) fonctionne sur le principe diviser-pour-régner : plusieurs petits problèmes
sont plus faciles à résoudre qu’un seul gros problème.
Le tri se déroule en trois étapes :
1. Division : le tableau est coupé en deux (à peu près à la moitié) ;
2. Tri : chaque moitié est triée séparément récursivement ;
3. Fusion : les deux moitiés triées sont fusionnées pour obtenir une version triée du tableau initial.
178

Tri par fusion
6 4 1 3 2 5
179

Tri par fusion
6 4 1 3 2 5
1er étape : deviser
2éme étape : trier
6 4 1 3 2 5
1 4 6 2 3 5
180

Tri par fusion
1 4 6 2 3 5
3éme étape : comparer et fusionner
i=0 j=0
k=0
181

Tri par fusion
1 4 6 2 3 5
1
i=0 j=0
k=0
182

Tri par fusion
1 4 6 2 3 5
1
i=1 j=0
k=1
183

Tri par fusion
1 4 6 2 3 5
1 2
i=1 j=0
k=1
184

Tri par fusion
1 4 6 2 3 5
1 2
i=1 j=1
k=2
185

Tri par fusion
1 4 6 2 3 5
1 2 3
i=1 j=1
k=2
186

Tri par fusion
1 4 6 2 3 5
1 2 3
i=1 j=2
k=3
187

Tri par fusion
1 4 6 2 3 5
1 2 3 4
i=1 j=2
k=3
188

Tri par fusion
1 4 6 2 3 5
1 2 3 4 5
i=1 j=2
k=4
189

Tri par fusion
1 4 6 2 3 5
1 2 3 4 5 6
i=1 j=3
k=5
190

Tri par fusion
1 4 6 2 3 5
1 2 3 4 5 6
i=3 j=3
k=5
191

def merge(arr, left_index, mid_index, right_index):
## left and right arrays
left_array = arr[left_index:mid_index+1]
right_array = arr[mid_index+1:right_index+1]
## getting the left and right array lengths
left_array_length = mid_index - left_index + 1
right_array_length = right_index - mid_index
## indexes for merging two arrays
i = j = 0
## index for array elements replacement
k = left_index
## iterating over the two sub-arrays
while i < left_array_length and j < right_array_length:
## comapring the elements from left and right arrays
if left_array[i] < right_array[j]:
arr[k] = left_array[i]
i += 1
else:
arr[k] = right_array[j]
j += 1
k += 1
## adding remaining elements from the left and right arrays
while i < left_array_length:
arr[k] = left_array[i]
i += 1
k += 1
while j < right_array_length:
j += 1
k += 1
Programme - Tri par fusion sur Python
def merge_sort(arr, left_index, right_index):
## base case for recursive function
if left_index >= right_index:
return
## finding the middle index
mid_index = (left_index + right_index) // 2
## recursive calls
merge_sort(arr, left_index, mid_index)
merge_sort(arr, mid_index + 1, right_index)
## merging the two sub-arrays
merge(arr, left_index, mid_index, right_index)
if __name__ == '__main__':
arr = [3, 4, 7, 8, 1, 9, 5, 2, 6]
merge_sort(arr, 0, 8)
print(str(arr))
192

8.5 Algorithme de tri ‘Rapide’ :
Le tri rapide (Quick Sort en Anglais) est également appelé : tri de Hoare, tri par segmentation, tri des bijoutiers…
L’algorithme est le suivant :
1. On choisit un élément du tableau qui servira de pivot.
2. On effectue des échanges de valeurs dans le tableau, de manière à ce que :
o Les valeurs inférieures au pivot soient placées à sa gauche.
o Les valeurs supérieures au pivot soient placées à sa droite.
3. On applique récursivement ce traitement sur les deux parties du tableau (i.e. à gauche et à droite du pivot).
Remarque : on peut remarquer que le choix du pivot est essentiel. L’idéal est un pivot qui partage le tableau en deux parties de tailles égales.
Mais déterminer un tel pivot prend beaucoup de temps, c’est pourquoi il est en général choisi de façon arbitraire. Ici par exemple, on prend la
première case du tableau. Entre ces deux extrêmes, des méthodes d’approximation existent pour faire un choix de compromis.
193

Tri Rapide
Un pivot est simplement l'un des éléments du tableau, ce qui signifie les trois conditions suivantes
après l'avoir trié:
‣ The pivot is in its correct position in the final sorted array
‣ all items to the left of the pivot are smaller
‣ all items to the right of the pivot are larger
Tri Rapide = pivot
194

Tri Rapide
0
3
5
2 1
6
4
195

Tri Rapide
0
3
5
2 1
6
4
pivot
196

Tri Rapide
0 3
5
2 1
6
4
197

Tri Rapide
0 3
5
2 1
6
4
Ensuite, nous allons chercher deux éléments:
⮚ Un élément 1 de gauche qui est le premier élément, à partir de la gauche, qui est
plus grand que notre pivot.
⮚ Un élément 2 de droite qui est le premier élément à partir de la droite, qui est plus
petit que notre pivot.
198

Tri Rapide
0 3
5
2 1
6
4
Elément Elément
199

Tri Rapide
0 3
5
2 1
6
4
200

Tri Rapide
0 3
1
2 5
6
4
201

Tri Rapide
0 3
1
2 5
6
4
Elément Elément
202

Tri Rapide
0 3
1
2 5
6
4
203

Tri Rapide
4 3
1
2 5
6
0
204

Tri Rapide
4 3
1
2 5
6
0
205

Tri Rapide
4 3
1
2 5
6
0
206

Tri Rapide
4
3
1
2 5
6
0
207

Tri Rapide
4
3
1
2 5
6
0
Pivot
208

Tri Rapide
4
3
1
2 5
6
0
209

Tri Rapide
4
3
1
2 5
6
0
Elément Elément
210

Tri Rapide
4
3
1
2 5
6
0
211

Tri Rapide
6
3
1
2 5
4
0
212

Tri Rapide
6
3
1
2 5
4
0
213

Tri Rapide
6
3
1
2 5
4
0
214

Tri Rapide
6
3
1
2 5
4
0
215

Tri Rapide
6
3
1
0 5
4
2
216

def qsort(u):
'''Quick-Sort : Algo du tri rapide''‘
if u == []: return []
pivot, g, d = u[0], [], []
for x in u[1:]: g.append(x) if x<pivot else d.append(x)
return qsort(g)+[u[0]]+qsort(d)
# Exemple de liste initiale
liste=[-6, - 3, 5, 2, 6, 8, -6, 1, 3]
liste_tri=qsort(liste)
print('liste initiale : ',liste)
# Liste triée
print('liste triee : ',liste_tri)
Programme - Tri rapide sur Python
217

9. Développement des algorithmes de la recherche séquentielle et binaire :
9.1 Recherche séquentielle :
La recherche séquentielle ou recherche linéaire est un algorithme pour trouver une valeur dans une liste. Elle consiste
simplement à considérer les éléments de la liste les uns après les autres, jusqu'à ce que l'élément soit trouvé, ou que toutes
les cases aient été lues.
L'algorithme:
• Voyons les étapes pour implémenter l'algorithme de recherche linéaire.
• Initialisez un tableau d'éléments.
• Ecrivez une fonction appelée élément_recherche(), qui accepte trois arguments, tableau, longueur du tableau et
élément à rechercher.
• search_element (arr, n, élément):
• Itérez sur le tableau donné.
• Vérifiez si l'élément actuel est égal à l'élément requis.
• Si oui, retournez Les véritables.
• Après avoir terminé la boucle, si l'exécution est toujours dans la fonction, alors l'élément n'est pas présent dans le
tableau. D'où le retour Faux.
• Imprimez le message en fonction de la valeur de retour de la fonction élément_recherche.
218

9.1 Recherche séquentielle :
Code:
def search_element(arr, n, element):
## iterating through the array
for i in range(n):
## checking the current element with required element
if arr[i] == element:
## returning True on match
return True
## element is not found hence the execution comes here
return False
if __name__ == '__main__':
## initializing the array, length, and element to be searched
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
n = 10
element_to_be_searched = 6
# element_to_be_searched = 11
if search_element(arr, n, element_to_be_searched):
print(element_to_be_searched, "is found")
else:
print(element_to_be_searched, "is not found")
219

9.2 Recherche binaire :
L'algorithme:
• suivez les valeurs indicatrices qui se trouvent au début et à la fin de la liste qui vont être incrémentées où décrémentées
pour limiter la partie de la liste ou effectuer la recherche.
• trouvez le milieu de la liste: milieu= (la longueur de la liste)/2.
• comparez la valeur du milieu avec la valeur recherchée.
• vérifiez si la valeur du milieu est inférieur à la valeur recherchée:
• si oui, la valeur recherchée doit sûrement être dans la deuxième moitié de la liste.
• si non, la valeur recherchée doit sûrement être dans la première moitié de la liste.
• répétez la même démarche jusqu'à trouver la valeur recherchée ou arriver à la fin de la liste.
L'algorithme de recherche binaire vérifie toujours l'élément du milieu du tableau.
Cet algorithme recherche l'élément dans un tableau trié.
L'idée est de comparer l'élément avec la valeur qui se trouve au milieu.
Ainsi, chaque recherche permettra d'éliminer la moitié de la liste
220

9.2 Recherche binaire :
Note:
la liste continue à se diviser en deux et la valeur du milieu est comparée à la valeur recherchée jusqu'à ce qu'on trouve la
valeur recherchée ou qu'il n'y ait plus des éléments pour comparer la valeur en question.
Code:
def bin_search(nums, x):
low, high = 0, len(nums) - 1
while low <= high :
mid = (low + high) // 2
print(low, high, mid)
if nums[mid] == x :
return mid
elif nums[mid] > x :
high = mid - 1
else :
low = mid + 1
return -1
S = [11, 17, 26, 28, 37, 45, 53, 59]
x = int(input("Input the number to search : "))
pos = bin_search(S, x)
print(f"In S, {x} is at position {pos}.")
221

Écrire un programme qui permet de lire un nombre entier de secondes au clavier, et l’exprimer sous forme
d’heures, minutes et seconde en utilisant trois variables : S, M, H.
10. Exercices et Challenges:
222

Écrire un programme qui lit la moyenne d’un étudiant et affiche
la mention correspondante. La mention est définie comme suit :
223

Écrire un programme qui simule le fonctionnement d’une calculatrice : il
demande à l’utilisateur de saisir deux nombres et un opérateur arithmétique ( + ,
-, * , / ) et affiche le résultat correspondant.
224

Écrire un programme permettant de résoudre l’équation 𝑎 𝑥2
+ 𝑏𝑥 + 𝑐 = 0 en fonction des valeurs de a,b et c.
225

Écrire un programme qui permet de saisir un entier N de trois chiffres non nuls, de déterminer et d’afficher tous
les nombres qui peuvent êtres formés par les chiffres de N
Afficher ensuite leur somme et leur produit
Exemple : si N=427 : Les nombres formés par les chiffres N sont : 427, 472, 724, 742, 247 ,274
226

Écrire un script qui permet de lire un entier N et calcule la somme des entiers impairs inférieurs à N.
227

Ecrire l'algorithme permettant d’afficher le
triangle suivant, le nombre de lignes étant donné par
l'utilisateur :
228

Ecrire un algorithme qui permet de déterminer la somme des chiffres d’un nombre entier donné
(Exemple : pour N=123465, on aura 1+2+3+4+6+5=21)
229

Pour un entier naturel n donné, écrire un algorithme qui calcule la suite :
230

Écrire un programme qui demande à l’utilisateur de saisir un texte, ensuite d'afficher le nombre d’occurrence
de chaque caractère dans le texte, par exemple :
231

Créer une fonction « list_aleat » qui retourne une liste de taille n (définie par l’utilisateur) remplie par des
nombres aléatoires compris entre 0 et 20 (utiliser la fonction randrange). Écrire le programme principal qui
demande à l’utilisateur de choisir la taille de la liste à générer, ensuite de supprimer les doubles et de réafficher la
liste :
232

1. Écrire une fonction nommée «CODAGE_CESAR» qui prend comme paramètre une chaîne de caractères ch
et retourne une chaine sh où chaque caractère de ch est décalé de trois crans dans l’alphabet. Par exemple
a devient d, b devient e, c devient f.
2. On utilisera pour cela les méthodes ord et chr qui permettent la conversion des caractères en code ascii .
3. Écrire un programme principal qui demande à l’utilisateur de saisir une chaine de caractère, ensuite faire
appel à la fonction CODAGE_CESAR qui permettra de coder la chaine ensuite l’afficher.
233

Leur demander d'écrire le pseudocode et le flowchart du problème suivant :
1 - La moyenne de n notes entre 1 et 20.
2 - La saisie du nombre 0 permet d'arrêter la saisie des notes d'où la détermination de n.
3 - Faites un affichage des messages selon un seuil choisi (Ex : Si la moyenne es supérieure à 12, on affiche Validé)
4 - Trouvez la note maximale et minimale
235

* Afficher la valeur 100 de la somme de la lettre "50" et le nombre 50, puis afficher la valeur suivante "5050"
*Avec les lettres "1" et "0" afficher le nombre 1000.
* Calculer 5!
236

* Leur demander de créer une liste pour calculer les notes d'un élève :
- la première position de la liste est réservée au nom d'étudiant.
- de la position 1 jusqu'à l'avant dernière position pour les notes des matières, les notes sont comprises entre 0
et 20.
- la dernière position est réservée aux remarques du professeur.
* Leur demander de créer une deuxième liste pour les coefficients des matières.
* Leur demander de calculer la moyenne des notes et l'ajouter après la dernière position (après la position des
remarques) de la première liste).
* Leur demander de trouver les valeurs maximale et minimale des notes.
* Leur demander de retravailler le même exercice en utilisant un seule dictionnaire..
237

238

* Leur demander de retravailler le même exercice en utilisant un seul dictionnaire..
239

Leur demander de développer une fonction pour résoudre le problème d'une équation quadratique.
240

Leur demande de créer une fonction pour calculer la surface et périmètre d'un cercle en utilisant un retour
multiple.
241

Implémentons la pile en utilisant deque du collections module..
242

Implémentons la file en utilisant deque du collections module.
243

244

Support Formation Samsung - Python - Session 1 - 2022.pptx

Recommandé

Recommandé

Contenu connexe

Similaire à Support Formation Samsung - Python - Session 1 - 2022.pptx

Similaire à Support Formation Samsung - Python - Session 1 - 2022.pptx (20)

Dernier

Dernier (15)

Support Formation Samsung - Python - Session 1 - 2022.pptx

Notes de l'éditeur