Les Piles - Créer son blog

Les Piles
Piles et files
Les piles apparaissent tôt dans le monde de l’informatique en
permettant une description théorique et une modélisation du
fonctionnement des ordinateurs.
Lycée Blaise Pascal
Septembre 2015
1 / 23
Les Piles
2 / 23
Les Piles
Définition
Une pile (en anglais a stack) est une structure de données reposant
sur le principe de "dernier arrivé, premier sorti".
"Stack overflow"
On parle également de mode LIFO : Last In, First Out.
3 / 23
4 / 23
Les Piles
Les fonctions de base
Pour utiliser une pile, il suffit de savoir :
I
Créer une pile (initialement vide)
I
Empiler un élément (en anglais push)
I
Dépiler un élément (en anglais pop)
5 / 23
Les fonctions presque de base
6 / 23
Et en Python ?
Nous créons sous Python une structure de pile à l’aide des listes.
Ici, le sommet de la pile est le dernier élément.
On peut compléter ces fonctions de base par d’autres :
I
Tester si la pile est vide
I
Demander le sommet de la pile, sans le retirer de celle-ci
I
Afficher la pile
def creer_pile () :
return []
def empile (a , p ) :
p . append ( a )
def depile ( p ) :
return p . pop ()
7 / 23
8 / 23
Et en Python ?
Capacité d’une pile
Le sommet de la pile est le dernier élément.
Dans l’implémentation d’une pile, on distinguera deux cas :
def est_vide ( p ) :
return ( p ==[])
def sommet ( p ) :
return p [ -1]
Remarque
I
Les piles à capacité non bornée :
Il n’y a pas de limite (autre que celle de l’ordinateur lui-même)
au nombre d’objets empilables.
I
Les piles à capacité bornée :
La taille de la pile est bornée à l’initialisation.
L’accès à un élément d’une liste Python étant en O(1), les
fonctions ci-dessus sont également en O(1).
10 / 23
9 / 23
Exemple d’utilisation
>>>
>>>
>>>
>>>
>>>
[3 ,
>>>
5
>>>
>>>
3
>>>
Un peu de POO
p = creer_pile
p = creer_pile ()
empile (3 , p )
empile (5 , p )
p
5]
depile ( p )
Telle que nous l’avons créée, une pile est une liste. . .
Et on pourrait alors tricher. . .
Nous allons construire un objet de type Pile :
a = depile ( p )
a
depile ( p )
IndexError : pop from empty list
11 / 23
12 / 23
Un peu de POO
Un peu de POO
class Pile :
def empile ( self , a ) :
self . liste . insert (0 , a )
def __init__ ( self ) :
# Initialisation d ’ une pile
self . liste = []
def estVide ( self ) :
return len ( self . liste ) == 0
def __repr__ ( self ) :
Aff = ’ Haut \ n ’
longueur = len ( self . liste )
i = 0
while i < longueur :
Aff = Aff + str ( self . liste [ i ]) + ’\ n
’
i += 1
Aff = Aff + ’ Bas \ n ----- ’
return Aff
def sommet ( self ) :
assert not ( self . estVide () ) , ’ La pile est
vide : pas de sommet ’
return self . liste [0]
def depile ( self ) :
assert not ( self . estVide () ) , ’ La pile est
vide : on ne peut pas la d é piler ’
return self . liste . pop (0)
13 / 23
Un peu de POO
14 / 23
Les Files
>>> p = Pile ()
>>> p . empile (3)
>>> p . empile (5)
>>> print ( p )
Haut
5
3
Bas
---->>> p . depile ()
5
>>> p . estVide ()
False
Définition
Une file (en anglais a queue) est une structure de données reposant
sur le principe de "premier arrivé, premier sorti".
On parle également de mode FIFO : First In, First Out.
15 / 23
16 / 23
Les Files
Les fonctions de base
C’est le principe d’une file d’attente. . .
Pour utiliser une file, il suffit de savoir :
I
Créer une file (initialement vide)
I
Emfiler un élément (en anglais enqueue)
I
Défiler un élément (en anglais dequeue)
I
...
17 / 23
En Python
18 / 23
double-ended queue
Dans le module collections, on trouve la classe deque
spécialement conçue pour ajouter et extraire des éléments à droite
et à gauche, de façon plus efficace qu’avec une liste.
On pourra consulter la documentation officielle :
Python » Documentation » The Python Standard Library
» 8.3 collections » 8.3.3 deque objects
https://docs.python.org/3/library/collections.html#
module-collections
def creer_file () :
return []
def enfile (a , f ) :
f . append ( a )
def defile ( f ) :
return f . pop (0)
19 / 23
20 / 23
deque
deque
>>> from collections import deque
>>> d = deque ( ’ ghi ’)
>>> for elem in d :
...
print ( elem . upper () )
G
H
I
>>> d
deque ([ ’f ’ , ’g ’ , ’h ’ , ’i ’ , ’j ’ ])
>>> d . pop ()
’j ’
>>> d . popleft ()
’f ’
>>> list ( d )
[ ’g ’ , ’h ’ , ’i ’]
>>> d [0]
’g ’
>>> d [ -1]
’i ’
>>> d . append ( ’j ’)
>>> d . appendleft ( ’f ’)
>>> d
deque ([ ’f ’ , ’g ’ , ’h ’ , ’i ’ , ’j ’ ])
21 / 23
deque
>>> from collections import deque
>>> d = deque ([0 ,1 ,2] ,4) # Taille max à 4
>>> d
deque ([0 , 1 , 2] , maxlen =4)
>>> d . append (3)
>>> d
deque ([0 , 1 , 2 , 3] , maxlen =4)
>>> d . append (4)
>>> d
deque ([1 , 2 , 3 , 4] , maxlen =4)
23 / 23
22 / 23