CPGE Alcachy MP/MP* 2015-2016

Les Piles et les files en python

1. Définitions

Les piles (stack) et les files (queue) constituent des structures de données. Elles vont, comme leur nom
l'indique, nous permettre de stocker diverses données, comme pourrait le faire un tableau.
Une pile permet de réaliser ce que l'on nomme une LIFO (Last In First Out), ce qui signifie en clair que
les derniers éléments à être ajoutés à la pile seront les premiers à être récupérés. Il est possible de
comparer cela à une pile d'assiettes. Lorsqu'on ajoute une assiette en haut de la pile, on retire toujours en
premier celle qui se trouve en haut de la pile, c'est-à-dire celle qui a été ajoutée en dernier, sinon tout le
reste s'écroule.

Dernier élément Premier élément

empilé (ajouté) dépilé (supprimé)
Last In First Out

La pile est une structure de données

………………… pour laquelle l’ajout et la suppression
d’un élément ne sont autorisés qu’à
Premier élément une seule extrémité, appelée sommet
empilé (ajouté) de la pile.

Une file, quant à elle, permet de réaliser une FIFO (First In First Out), ce qui veut dire que les premiers
éléments ajoutés à la file seront aussi les premiers à être récupérés.

Dernier élément
empilé (ajouté)

…………………

Premier élément
Premier élément
empilé (ajouté)
dépilé (supprimé)
First In
First Out
Les piles peuvent être utilisées dans des algorithmes d'évaluation d'expressions mathématiques.
Les files peuvent être utilisées afin de mémoriser des données en attente de traitement. (guichets
d’attente par exemple)

2. Implémentation des Piles en python :

En langage pthon, l'implémentation des piles est basée sur les listes.
1. Implémenter le type abstrait « Pile » à l’aide d’une liste def pilevide ()
2. Fonctions préliminaires :
2.1 def empiler(p, e ) qui empile un élément e à la fin de la pile p
2.2 def sommet( p) qui retourne le sommet de la pile
2.3 def depiler (p) qui dépile le dernier élément de la pile p
2.4 def estvide(p) qui retourne True si la pile est vide False sinon

A.Lagrioui Page 1/3

 CPGE Alcachy MP/MP* 2015-2016
2.5 def copierpile (p) qui retourne la copie de la pile p
2.6 def affichepile(p) qui affiche la pile p
3. Écrire une fonction qui permet d'inverser une pile. def inverser ( p )
4. Fonctions avancées sur les piles : application sur l’évaluation des expressions
mathématiques [((5+4)/2)+12)]
Écrire une fonction qui prend en entrée un texte composé de différentes parenthèses,
accolades, crochets, ouvrants ou fermants, et qui vérifie que l'expression est bien parenthésée.
On pourra par exemple suivre les étapes suivantes :
4.1 une fonction qui prend en entrée un caractère et renvoie vrai s'il s'agit d'un symbole
ouvrant et faux sinon, def estouvrant(c)
4.2 une fonction qui prend un symbole ouvrant et fournit en retour le caractère fermant
correspondant, def fermant(c)
4.3 enfin, la fonction de vérification. def verifierparenthese(texte)
4.4 Écrire une fonction qui évalue une expression polonaise inversée, composée d'entiers
entre 0 et 9 et des quatre opérations élémentaires (+, - ,* et / ).
On pourra par exemple suivre les étapes suivantes :
a. une fonction qui prend en entrée un caractère et renvoie vrai s'il s'agit d'une
opération élémentaire et faux sinon, def operation(c)
b. une fonction qui prend un symbole-opération et deux entiers et qui renvoie le
résultat de l'opération, def calculer (op, a, b)
c. enfin, la fonction d'évaluation def evaluerpostfixe(expression)
d. enfin, la fonction d'évaluation def evaluerprefixe(expression)
e. enfin, la fonction d'évaluation def evaluerinfixe(expression)
5. Ecrire le programme qui appelle et teste les fonctions déjà définie.
Une même expression a au moins trois représentations naturelles.
• La représentation infixe est la forme usuelle, où l’on place les opérateurs entre les opérandes : (3 + 2) × 5.
• La représentation préfixe est celle dans laquelle on place les opérateurs avant les opérandes : * + 3 2 5. Dans
ce cas, les parenthèses sont superflues : si l’on avait voulu dire 3 + (2 × 5), on aurait écrit + 3 * 2 5.
• On peut également placer les opérateurs après les opérandes : c’est la forme postfixe. Si l’on part toujours de
(3 + 2) × 5, on obtiendra alors 3 2 + 5 *.
Exercice : Donner les deux autres formes des expressions suivantes. 1 : 2 + (3 − (5 + 1) × 2)
2: 2 3 4 5 + - * 6 POW et 3 : SIN - Pi x

SOLUTION :

### implémentation du type abstrait Pile avec des listes Python

def pilevide ():
return []
# choix : sommet de pile en fin de liste
def ajoute (e,p) :
p.append(e)

A.Lagrioui Page 2/3

 CPGE Alcachy MP/MP* 2015-2016
def sommet(p) :
return p[len(p)-1]
#return p[-1]
def depile (p) :
return p.pop()
def estvide(p):
return len(p)==0
#return p==[]
def copiepile(p) :
return list(p)
# version 2
def copiepile_bis(p) :
p1= pilevide ()
while not estvide(p):
ajoute (depile(p),p1)
p2= pilevide ()
while not estvide(p):
ajoute (depile(p1),p2)
return p2

def affichepile(p):
print()
print('| |')
i = len(p)-1
while i>=0:
print('|---|')
print('|',p[i],'|')
i = i-1
print(' ---')
### fonctions avancées sur les piles
# inversion d'une pile
def inversepile(p):
q = copiepile(p)
r = pilevide()
while (not(estvide(q))):
ajoute(depile(q),r)
return r
# vérification parenthésage
def estouvrante (c) :
return (c=='(') or (c=='{') or (c=='[')
def fermante (c) :
if c=='(':
return ')'
elif c=='{':
return '}'
elif c=='[':
return ']'

A.Lagrioui Page 3/3

 CPGE Alcachy MP/MP* 2015-2016
else:
return '?'
def verifparenthese (texte):
print()
print("-> vérification de «",texte,"»")
# on commence avec une pile vide
p = pilevide()
# parcours du texte caractère par caractère
for i in range(0,len(texte)):
if estouvrante(texte[i]):
# si le caractère est une ouvrante...
# ... on empile la fermante associée
ajoute(fermante(texte[i]),p)
else:
# sinon la fermante rencontrée doit
# être la même que celle sur la pile
if (estvide(p) or (texte[i] != sommet(p))):
print("erreur caractère",i)
else:
depile(p)
# à la fin du texte, la pile doit être vide
if (estvide(p)):
print("fin de vérification")
else:
# sinon il y a un problème
print("pile non vide !")
affichepile(p)
print()

# évaluation d'une expression arithmétique

def estoperation(c):
return (c=='+') or (c=='-') or (c=='*') or (c=='/')
def petitcalcul (o,a,b):
if (o=='+'):
return a+b
elif (o=='-'):
return a-b
elif (o=='*'):
return a*b
elif (o=='/'):
return a/b
def evaluepostfix (expression):
print()
print("-> évaluation de «",expression,"»")
# on commence avec une pile vide
p = pilevide()
# parcours de l'expression caractère par caractère

A.Lagrioui Page 4/3

 CPGE Alcachy MP/MP* 2015-2016
for i in range(0,len(expression)):
if estoperation(expression[i]):
# si c'est un opérateur,on dépile un premier entier
a= depile(
# et puis un autre
b = depile(p)
# on effectue le calcul
r = ptitcalcul(expression[i],a ,b)
# et on empile le résultat
ajoute(r,p)
else: # c'est une opérande et on l'empile
ajoute(int(expression[i]),p)
# à la fin, le résultat est sur la pile
print("résultat :",sommet(p))

print()
### tests

mapile = pilevide()
ajoute(2,mapile)
ajoute(8,mapile)
ajoute(5,mapile)
ajoute(0,mapile)
ajoute(3,mapile)
ajoute(7,mapile)
ajoute(9,mapile)

affichepile(mapile)
affichepile(inversepile(mapile))
verifparenthese("coucou")
verifparenthese("([{{{}}}]{)(()})")
verifparenthese("([{{{}}}]{()()})")
verifparenthese("(([{{{}}}]{()()})")
verifparenthese("([{{{}}}]{()()}))")
evaluepostfix("12+4*3+")

3. Implémentation des Files en python :

En langage pthon, l'implémentation des files est basée sur les listes.
3.1 Fonctions préliminaires :
a. Une fonction def creer_queue(): qui crée et retourne une file vide
b. Une fonction def en_queue (q,e): qui insert l’élément e en queue de la file
c. Une fonction def de_queue(q): qui défile un élément de la file
d. Une function def est_vide(q): qui retourne True si la file est vide, False sinon
e. Une fonction def afficher(q): qui affiche leFile
contenu
Vide de la file

A.Lagrioui Page 5/3

 CPGE Alcachy MP/MP* 2015-2016

3.2 Application des Files : Gestion de la mémoire

Une mémoire organisée en file respecte en sortie l’ordre chronologique d’entrée : FIFO. La figure suivante
montre que la file initialement vide reçoit d’abord trois nombres (4, 6 et 3) puis on emet deux ( 4 et 6) et on
reçoit enfin un autre (10).
AE
AR 0 AE 4 0 0 0
1 6 1 1 1
2 3 2 AE 3 2 AE 3 2
3 AR 3 AR 3 10 3
4 4 4 AR 4
5 5 5 5
6 6 6 6
7 7 7 7
Réception de Emission de Réception du
File Vide deux nombres nombre 10
trois nombres
Deux variables AR pour la réception des nombres et AE pour leur émission gèrent les adresses dans la file.
A chaque réception ou émission d’un nombre, les variables correspondantes sont incrémentées. Lorsque ces
variables dépassent leur valeur maximale, elles passent à zéro, et la réception ou l’émission a lieu au début de
la file. La figure suivante montre comment une file se remplit. On remarque qu’une file est déclarée pleine si
après réception d’un nombre, la variable AR rattrape la variable AE.

0 AR 0 4 0 4 0
1 1 21 1 21 1
2 2 AR 2 13 2
AR
AE 1 3 AE 1 3 AE 1 3 1 3
AE
5 4 5 4 5 4 5 4
7 5 7 5 7 5 7 5
AR 6 2 6 2 6 2 6
7 19 7 19 7 19 7
Etat Initial Réception de deux Réception de deux Réception du nombre 13
nombres 2 et 19 nombres 4 et 21 la file est déclarée pleine
Symétriquement la figure suivante montre comment une file se vide. La file est vide si , après émission d’un nombre, la
variable AE rattrape la variable AR.
0
4 0 AE 4 0 0
1
21 1 21 1 1
2
13 2 13 2 AE 13 2 AR
3
AR 3 AR 3 AR 3 AE
4
4 4 4
5
5 5 5
6
AE 2 6 6 6
7
19 7 7 7 Emission du nombre 13 la
Etat Initial émission de deux Emission de deux
file est déclarée vide
nombres 2 et 19 nombres 4 et 21

On demande de définir:
- Une fonction CrerFile (Dmax) qui crée une file (tableau vide de taille Dmax) et initialise AE et AR
- Une fonction EstVide(F) qui retourne True si la file F est vide ei False sinon
- Une fonction EstPleine(F) qui retourne True si la file F est pleine et False sinon
- Une fonction Ajouter(F,v) qui permet d’ajouter la valeur v dans la file F

A.LAGRIOUI Page 6/6

 CPGE Alcachy MP/MP* 2015-2016
- Une fonction supprimer(F) qui supprime l’élément en tête de la file et retourne sa valeur
- Une fonction afficherFile(F) qui affiche les éléments de la file F
- Ecrire le programme principal qui propose le menu suivant :

1. Créer une File vide

2. Ajouter un élément dans la file
3. Supprimer un élément de la file
4. Afficher le contenu de la file
5. Quitter le programme
Veuillez entrer votre choix !!
L’utilisateur entre son choix et le programme exécute la fonction correspondante. Si le choix est hors
liste le programme affiche un message lui indiquant qu’il doit entrer en entier entre 1 et 5 et quitte le
programme.

Il existe un type supplémentaire : deque, dans le module collections permettant de simuler les files
(queue en anglais) : from collections import deque pour utiliser le module
 d=deque() : création d'une file vide ou d=deque( (4,5,6) ) : création d'une file à partir d'un tuple
 len(d) permet de savoir si la file est vide et d.pop() renoie l'élément de tête de file
 d.appendleft(v) ajoute un élément un fin de file. Début et fin sont interchangeables car il existe aussi
les fonctions suivante qui s'exécutent en temps constant : d.popleft() et d.append(v) . Le type
de deque permet en outre de construire des files d'une certaines longueur maximum si bien que
l'ajout en fin de file de nouveaux éléments éjecte les éléments de début de liste (ou l'inverse)
Exemple.

Solution

Remarque : lorsqu’on dépasse la taille max , l’ajout d’un élément provoque la sortie de l’élément qui
est en entête de la file.

A.LAGRIOUI Page 7/11

 CPGE Alcachy MP/MP* 2015-2016

Solution :
Solution du Problème : gestion de la mémoire en utilisant les files

A.LAGRIOUI Page 8/11

 CPGE Alcachy MP/MP* 2015-2016

Programme principal :
Test de la File

Application2 :
On se propose de simuler une file d’attente. La situation est la suivante :
 Des clients arrivent dans un bureau de poste qui a trois guichets, A, B et C (on suppose pour
commencer que les guichets réalisent les mêmes opérations). Toutes les dt secondes (par
exemple dt=10),
 On ajoute les clients qui sont insérés dans la file d’attente,
 on libère les guichets qui peuvent l’être (si la date d’arrivée du client augmentée du temps de
 Traitement a dépassé la date courante, le client est parti depuis le dernier examen de la
situation) ;
 On déplace les clients en tête de file vers les guichets libres.

On travaillera en deux temps : architecture générale du programme puis détails d’implémentation (et
on finira avec un programme de simulation).
Ce programme met en place des variables globales qui seront gérées au cours d’itérations simulant
un décompte discret du temps (actualisation en t0= 0, t1 = t0 + dt, t2 = t1 + dt, ...).

A.LAGRIOUI Page 9/11

 CPGE Alcachy MP/MP* 2015-2016

Le tableau qui suit présente ce que pourraient être ces variables (on fera avec) et ce que pourrait être
une fonction d’examen des guichets...
>>>nbre_total_clients = 0
>>>guichets = [[’A’, 0, 0, None], [’B’, 0, 0, None], [’C’, 0, 0, None]]
’’’ liste de guichets, avec nom, date d’arrivée du dernier client (en secondes), temps de traitement
prévu, identité client.’’’
>>>file_attente = creer_queue() # ’’la structure de file (ou de queue) qui contient les clients’’’
>>>#----------- un exemple de fonction ------------

def liberer_guichets(G, t):

’’’G une liste de guichets, t le temps courant, on libère les guichets pour lesquels ...’’’
for g in G:
if g[1]+g[2] <= t:
g[1], g[2], g[3] = t, 0, None
return G

#-------------------------- guichets = **’A’, 0, 20, ’C_1’+, *’B’, 0, 12, ’C_1’+, *’C’, 0, 11, ’C_1’++
>>> liberer_guichets (guichets, 14)
>>> print(guichets)
[[ ’A’ , 14 , 0, None ], *’B’, 0, 12, ’C_1’+, *’C’, 0, 11, ’C_1’++

3.2.1 On compte écrire la simulation avec trois fonctions :

 def liberer_guichets(G,t), comme ci-dessus, dans laquelle G est une liste de guichets et t
représente le temps courant.
 def arrivees (F, ...) dans laquelle F est un fille d’attente (un queue). Cette fonction appelle
une fonction qui utilise le module random pour d´eterminer aléatoirement le nombre de
clients qui entrent dans la fille entre T et T + dt.
 def remplir_guichet(G, F, T) dans laquelle G est une liste de guichets et F une file d’attente...

a. A quoi sert T dans remplir_guichet(G, F, T) ?

b. Proposer une simulation sur le schéma :

def simulation(G, F, alpha):

’’’ G et F sont une liste de guichets et une file initialisees ’’’
global ... Tm, dt = 3600*4, 10 ’’’toutes les 10s pendant 4 h’’’
while T < Tm:
...
...
T = T +dt
return None
3.2.2 . Les détails
a. Définir Une fonction remplir_guichets (G,F,T) permettant de remplir une file de guichets

A.LAGRIOUI Page 10/11

 CPGE Alcachy MP/MP* 2015-2016

b. On suppose que dans la fonction def LoiPoisson(D) , D est une distribution de probabilités sur N
(ou sur {0, 1, ..., N }), que random.random() renvoie un nombre aléatoire de loi uniforme sur [0,1].
Démonter que LoiPoisson(D) est une variable aléatoire telle que P ( LoiPoisson(D) = k) = D[k]).

def LoiPoisson(alpha):
'''Variable aleatoire de loi de Poisson de paramètre alpha '''
e = np.exp(-alpha)
U = random.random()
s, k, f = e, 0, 1
while s < U:
k , f = k +1, f*k
s = s + e*alpha**k/f
return k
3.2.3 On suppose que l’on sait écrire une fonction simulant le nombre d’arrivées par unité de temps
(ici dt) dans un bureau de poste
a. Définir une fonction arrivees (file, alpha) qui construit la file d’attente avec les clients arrivant
sur le bureau de poste de façon aléatoire.
b. Compléter la fonction de simulation.

A.LAGRIOUI Page 11/11