016 - Les piles et les files

September 3, 2023

1 Les piles et les files

1.1 Les files (FIFO)
Une file est structure de donnée fondée sur le principe “Premier arrivé, Premier sorti” (En anglais
First In, First Out - FIFO). En effet, les premiers éléments ajoutées à la file seront les premiers à
être récupérés.
Sur Python, on utilise les listes pour représenter les files.

[22]: # Une file vide

F=[]

[23]: # Enfiler une file : Remplir une file, autrement, ajouter des éléments à la file
# On le fait en utilisant la méthode .append()
F.append(5)
F.append(17)
F.append(6)

[24]: # Un aperçu sur la file

print(F)

[5, 17, 6]

[25]: # Défiler une file : Supprimer l'élément le plus agé de la file

x=F.pop(0)
print(F)
print(x)

[17, 6]
5

1.1.1 Exercice 1
1. Ecrire une fonction qui enfile une file et affiche son état actualisé ;
2. Ecrire une fonction qui défile une file et affiche l’élément quittant la file et l’état actualisé de
la file ;
3. Ecrire une fonction qui affiche le remplissage d’une file ;
4. Ecrire une fonction qui teste si une file est vide ou non, la fonction retourne True si la file est
vide et False sinon.

1
[26]: #1
def enfiler(file,element):
file.append(element)
print("file =",file)

[27]: #2
def defiler(file):
if file == []:
print("La file est vide")
else:
element = file.pop(0)
print(element,"quitte la file")
print("file =",file)

[28]: #3
def remplissage(F):
return len(F)

[29]: #4
def vide(F):
return F==[]

1.1.2 Exercice 2
Nous voulons modéliser une file d’attente dans un cabinet d’un médecin. Nous devons écrire un
programme qui à chaque fois demande à l’utilisateur (l’assistant du médecin) de saisir une tache
(Ajouter un nouveau patient à la file d’attente, Faire sortir un patient de la file d’attente, Fermer
le cabinet ce qui signifie l’arrêt du programme). A chaque fois ou l’assistant execute une tache le
programme affiche l’état de la file d’attente.

[ ]: # On crée une fonction qui demande à l'assistant d'effectuer une tâche

def lire_tache():
print('----------------------------------------------------------------')
print('Veuillez choisir le nombre correspondant à la tache désirée')
print('1 - Ajouter un patient à la file d attente')
print('2 - Supprimer un patient de la file d attente')
print('3 - Fermer le cabinet')
print('----------------------------------------------------------------')
tache = int(input('Numero de la tache : '))
liste_tache = [1,2,3]
while not tache in liste_tache:
tache = int(input('Numero de la tache (1, 2 ou 3) : '))
return tache

# On crée une file d'attente

file_attente = []

# On demande à l'assistant de saisir la première tache

2
 tache = lire_tache()
while tache != 3:
if tache == 1:
nom = input("Veuillez saisir le nom du patient : ")
enfiler(file_attente,nom)
else:
defiler(file_attente)
tache = lire_tache()

1.2 Les piles (LIFO)

Une pile est structure de donnée fondée sur le principe “Dernier arrivé, Premier sorti” (En anglais
Last In, First Out - LIFO). En effet, les derniers éléments ajoutées à la file seront les premiers à
être récupérés.
Sur Python, on utilise les listes pour représenter les piles.

[30]: # Une pile vide

P=[]

[31]: # Empiler une pile : Ajouter des éléments dans la pile

P.append(45)
P.append(16)
P.append(39)

[32]: # Un aperçu sur la pile

print(P)

[45, 16, 39]

[33]: # Dépiler la pile : Supprimer le dernier élément ajouté à la pile

x=P.pop()
print(P)
print(x)

[45, 16]
39

1.2.1 Exercice 3
1. Ecrire une fonction qui permet d’empiler une pile ;
2. Ecrire une fonction qui permet de dépiler une pile ;
3. Ecrire une fonction qui affiche le remplissage d’une pile ;
4. Ecrire une fonction qui teste si une pile est vide ou non, la fonction retourne True si la pile
est vide et False sinon.

[34]: #1
def empiler(P,x):
P.append(x)

3
[35]: #2
def depiler(P):
if P!=[]:
x=P.pop()
return x

[36]: #3
def remplissage(P):
return len(P)

[37]: #4
def vide(P):
return P==[]

1.2.2 Exercice 4
Il s’agit de vérifier si une expression est bien parenthèsé.
Nous devons écrire un programme qui :
• Accepte les mots comme : (xxx),(xxx)(xx(xxx)x) ou (xx(xx(xxx)(xxx)xx)(xxx)xx)
• Rejette les mots comme : xx)xx(xx,(xx)x)xx(xx(xxx)xx ou (((xxx)x(xxx))))
Travail à faire :
Ecrire une fonction qui prend en paramètre une expression parenthèsés et retourne True s’elle est
acceptée et False si non. Utilisez une pile de caractères.

[38]: def parentheses(ch):

pile=[]
for x in ch:
if x=="(":
pile.append("(")
elif x==")":
if pile==[]:
return False
x=pile.pop()
if pile==[]:
return True
return False

[39]: s="(abc(efg(hij))kl)"
parentheses(s)

[39]: True

[40]: p="(abc(ef)g(hij)(i))kl)"
parentheses(p)

4
[40]: False

1.2.3 Exercice 5
L’ordre dans la pile permet d’éviter l’usage des parenthèses. La notation postfixée (polonaise)
consiste à placer les opérandes devant l’opérateur. La notation infixée (parenthèsée) consiste à en-
tourer les opérateurs par leurs opérandes. Les parenthèses sont nécessaires uniquement en notation
infixée.
La notation postfixée est d’un emploi plus facile puisqu’on sait immédiatement combien d’opérandes
il faut rechercher.
Détaillons ici la saisie et l’évaluation d’une expression postfixée : La notation usuelle, comme (3 +
5) * 2, est dite infixée. Son défaut est de nécessiter l’utilisation de parenthèses pour éviter toute
ambiguïté (ici, avec 3 + (5 * 2)). Pour éviter le parenthésage, il est possible de transformer une
expression infixée en une expression postfixée en faisant “glisser” les opérateurs arithmétiques à la
suite des expressions auxquelles ils s’appliquent.
Exemples : - (3 + 5) * 2 s’écrira en notation postfixée (notation polonaise) : 3 5 + 2 - 3 + (5 2)
s’écrira: 3 5 2 * + - (A * B)/C En notation postfixe est: AB * C/ - Notation postfixe : 6 5 2 3 +
8 * + 3 + * En notation infixe est : (6 * ((5 + (2 + 3) * 8 ) + 3) )
Travail à faire : Ecrire une fonction qui prend en paramètre une expression arithmétique postfixée
sous forme de liste (les nombres en int et float et les opérateurs en chaîne de caractères) et retourne
le résultat du calcule.
Exemple : L’expression 3 5 + 2 * sera représenté par [3,5,“+”,2,“*”]

[41]: def operation(L):

pile=[]
op=["+","-","*","/"]
for x in L:
if not x in op:
pile.append(x)
else:
a=pile.pop()
b=pile.pop()
if x=="+":
pile.append(a+b)
elif x=="-":
pile.append(a-b)
elif x=="*":
pile.append(a*b)
else:
pile.append(a/b)
return pile[0]

[42]: operation([3,5,"+",2,"*"])

[42]: 16