Algorithmique avancée en Python

Algorithmique avanc´ee en Python
. . . et non pas Python avanc´e
Denis Robilliard
sept. 2014
1 Introduction
Objectifs du cours
•connaˆıtre un panel d’algorithmes standards : ´enum´eration, tris, backtracking, listes, etc;
•avoir cod´e et compris ces algorithmes, sans utiliser de librairies ”toutes faites”;
•consolider les bases de la conception d’applications dans le paradigme dit de ”programmation proc´edurale” avec
analyse descendante.
Avertissement Le langage support dans ce cours est le langage python 3. C’est cette version pr´ecise qui est suppos´ee
dans toute expression comme ”le langage python”, ou ”en python”, ... Attention la version 2 du langage est encore
tr`es r´epandue lors de la r´edaction de ce cours, et n’est pas tout `a fait compatible avec les codes donn´es ici (quoique
les modifications soient g´en´eralement mineures).
2 Les bases de Python
Le plus important : le commentaire
’’’ ceci est un comme ntair e
qui
s ’ ´e tend
sur p lusieur s
lignes ’’’
# ceci est un comme ntair e jusqu ’`a la fin de ligne
Le commentaire sert `a d´ecrire l’algorithme en fran¸cais (ou anglais, ou ...). Rappel : il existait des algorithmes avant
les ordinateurs et le langage Python...
L’affectation : (nom de) variable =expression
a = 2+3
print (a ) # affi che 5 `a l ’´e cran
Ici la variable are¸coit la valeur r´esultant du calcul de l’expression arithm´etique. L’affectation peut, dans certains cas,
ˆetre un peu plus compliqu´ee que cela, nous le verrons plus loin.
Entr´ee/sortie de base :
’’’ progra mme perro quet ’’’
a = input (’ entrez un message : ’)
print (a)
Attention, le message est m´emoris´e comme une chaˆıne de caract`eres. Si vous voulez saisir un nombre pour faire des
calculs, il faut une conversion :
’’’ progra mme additio n ’’’
a = input ( ’ entrez un entier a : ’)
a = int ( a) # je r emplace la cha ^ı ne par un entier
b = int ( input (’ entrez un entier b : ’))
print (’ a + b vaut : ’, a+b )
1

L’alternative : si condition alors action sinon autre action Attention, le test d’´egalit´e se note == pour se
diff´erencier de l’affectation.
a = 2+3
if a == 4:
print (’ la var iable a ’)
print (’ conti ent la valeur 4 ’)
else:
’’’ notez l ’ ut ilisa tion de " pour p ermettr e
d ’ i nclure une a postr ophe dans la cha ^ı ne ’’’
print (" a n ’ est pas p lu s grand q ue 4")
Notez l’indentation (d´ecalage de l’alignement) du code des actions. Ce d´ecalage doit ˆetre identique en nombre d’espace
ou de tabulation pour chaque ligne de l’action dans tout votre code. Un alignement incorrect est une erreur pour
Python :
’’’ ce code ne fonc tionn e pas ’’’
a = 2+3
if a > 4:
print ( ’a e st plus grand que 4 ’)
print (’ st rictemen t plus grand , en fait ’) # mal indent ´e !
else:
print (" a n ’ est pas p lu s grand q ue 4")
Il n’y a pas forc´ement une partie sinon :
’’’ je ne m ’ int ´e resse qu ’ aux entiers pairs ’’’
a = int ( input (’ entrez un entier : ’))
if a % 2 == 0:
print (" l ’ e ntier " , a , " est pair ")
’’’ `a partir d’ ici le reste de mon code ’’’
La boucle tant que : tant que condition faire action fintq
’’’ ´e num `e re et affiche les entiers de 1 `a 10 ’’’
i=1
while i < 11:
print (i)
i += 1 # raccou rci pour i = i + 1
’’’ code hors boucle signal ´e par son in dentatio n ’’’
print (’ termin ´e ’)
La boucle pour : pour variable dans enumeration faire action finpour
’’’ ´e num `e re et affiche les entiers de 1 `a 10 ’’’
’’’ range (a , b) donne la s ´e quence des entiers de a `a b (b exclus ) ’’’
for i in range (1 ,11):
print (i)
’’’ code hors boucle signal ´e par son in dentatio n ’’’
print (’ termin ´e ’)
Note : on ne doit pas changer la valeur de i dans les actions de la boucle.
Le 2nd plus important : la fonction
’’’ retourne le max de ses 2 param `e tres
( qui doiven t ^e tre c ompar ables ) ’’’
def ma xi mum ( a , b ):
if a > b:
return a
else:
return b
def main ():
print ( maximum (2 ,12))
main ()
2

La fonction sert `a organiser le code en petits blocs que l’on peut mettre au point ind´ependamment les uns des autres
: la complexit´e du probl`eme diminue. Note : le code d’une fonction peut aussi ˆetre appel´e plusieurs fois, mais c’est
un int´erˆet secondaire.
Ne pas confondre retourner et afficher/”sortir `a l’´ecran” La fonction du paragraphe pr´ec´edent retourne une
valeur dont on fait ce qu’on veut : on peut l’afficher bien sˆur, mais aussi l’utiliser dans un calcul, la stocker en m´emoire,
etc.
Dans l’exemple suivant la fonction affiche directement le r´esultat:
’’’ sortir `a l ’ ´e cran le max de ses 2 param `e tres
( qui doiven t ^e tre c ompar ables ) ’’’
def ma xi mum ( a , b ):
if a > b:
print (a)
else:
print (b)
def main ():
maximum (2 ,12)
main ()
Notez que cette fonction est plus limit´ee : on ne peut plus r´ecup´erer le r´esultat dans la fonction main() pour le
stocker dans une variable. Par cons´equent pr´ef´erer la solution avec retour du r´esultat, sauf si le but de la fonction est
sp´ecifiquement d’afficher un message.
3 Types de donn´ees
Les variables ne sont pas typ´ees, mais par contre les donn´ees sont typ´ees. ainsi les 3 affectations suivantes sont l´egales,
mais l’op´eration qui suit est erron´ee :
a = 2 # entier
a = 3.14 # flotta nt
a = ’ bonjour ’ # cha ^ı ne
a = a + 1 # erreur : pas d ’ op´e ration + entre une cha ^ıne et un entier
types de bases Les types de base classiques que l’on trouve dans la plupart des langages sont :
•bool´eens / bool : True, False
•entiers / int : 1 ; -12
•r´eels / float : 3.14 ; .4 ; 1.3E5
•chaˆınes / str : ’bonjour’
3.1 tableaux
Les tableaux sont la repr´esentation informatique de la notion de vecteurs et de matrices math´ematiques. Les tableaux
ne sont pas un type de base en python, mais comme c’est une structure de donn´ees tr`es pratique, plusieurs modules
ont ´et´e introduits pour les implanter, dont le module array, et le module numpy. C’est numpy que nous utiliserons.
Ces tableaux seront limit´es `a contenir des ´el´ements de types num´eriques et bool´eens.
Cr´eation de tableau Il faut importer le module numpy pour pouvoir l’utiliser. On cr´ee un tableau sans mod`ele
avec zeros ou ones, initialisant respectivement les ´el´ements `a 0 ou 1 (dans le cas bool´een respectivement False ou
True), ou encore empty qui cr´ee un tableau non initialis´e.
import numpy # impo rter numpy
tab = numpy . array ([1 ,2 ,3]) # `a p artir d ’ un ex pressi on mod `e le
autre_ tab = numpy . array ( tab ) # cr ´e ation d ’une copie de tab
tab = numpy . empty (3 , dtype = int ) # tableau de 3 entiers non initi alis ´e s
tab = numpy . zeros (3, dtype = int ) # tableau de 3 entiers init ialis ´e s `a 0
tab = numpy . ones (3, dtype = int ) # tableau de 3 entiers ini tialis ´es `a 1
tab = numpy . zeros (3 , dtype = float ) # tableau de 3 r ´e els i nitialis ´es `a 0.0
t ab = numpy . zeros ((2 ,2) , dtype = int ) # matrice 2 x2 d ’ entiers
3

tab = numpy . zeros ((3 ,5) , dtype = float ) # matrice 3 x5 de r´eels
tab = numpy . zeros ((2 ,2 ,2) , dtype = bool ) # cube 2 x2x2 de bool ´e ens `a False
Acc`es aux ´el´ements de tableau Tous les tableaux sont indic´es `a partir de 0.
import numpy # impo rter numpy
tab = numpy . zeros (3, dtype = int ) # tableau de 3 entiers , initialis ´e s `a 0
tab [0] = 12 # acc `e s au 1 er ´e l´e ment
tab [2] = -1 # acc `es au dernie r ´el ´e ment
tab [1] = tab [0] # copie du 1 er dans le 2`e me
tab_bool = numpy . zeros ((2 ,2 ,2) , dtype = bool )
tab_bool [1 ,1 ,1] = True
tab_bool [1][1] [1] = True # ´e criture al terna tive
Attributs de tableaux La taille d’un tableau unidimensionnel peut ˆetre obtenue avec l’op´erateur len, mais les
tableaux numpy poss`edent aussi un attribut size qui donne le nombre d’´el´ements notamment pour les tableaux multi-
dimensionnels.
Tranches de tableaux On peut manipuler directement un morceau de tableau o`u tous les ´el´ements ont des indices
successifs : une tranche (ou slice).
tab = numpy . array ([1 ,2 ,3 ,4 ,5 ,6])
print ( tab [0:2]) # affiche les 2 p remiers ´el ´e ments : [1 2]
print ( tab [:2]) # m ^e me chose que le pr ´e c ´e dent
print ( tab [3:]) # a ffiche d epuis l ’ i ndice 3 j usque la fin du t ableau
tab [:3]= tab [3:] # copie les 3 de rniers ´el ´e ms dans les 3 premi ers
3.2 Notion de type ”conteneur”
Un tableau est un type ”conteneur” : il a un contenu (ses ´el´ements) qui est modifiable. Par opposition; un entier
n’a pas de contenu modifiable en python : il se comporte comme une valeur litt´erale (´ecrite en toutes lettres). Pour
les types conteneurs, l’affectation prend un sens particulier : ce n’est pas une copie qui est cr´e´ee, mais un alias (un
synonyme). Si on veut une copie, il faut utiliser le constructeur numpy.array(tableau `a copier) vu plus haut.
tab = numpy . array ([1 ,2 ,3 ,4 ,5 ,6])
tab2 = tab # tab2 n ’ est PAS une copie de tab
tab [0] = 10 # ATTENTI ON : modifie tab ET tab2 , qui sont le meme objet
3.3 Liste
Python poss`ede nativement un type liste, qui est un conteneur et qui se comporte comme un tableau avec des op´erateurs
plus souples (on peut ins´erer au milieu d’une liste, l’agrandir, ...). La mani`ere dont les listes sont implant´ees rend
moins efficace l’acc`es `a un ´el´ement donn´e, mais plus efficace l’insertion et l’agrandissement. Par ailleurs les listes
peuvent contenir des ´el´ements de types diff´erents, contrairement aux tableaux : l’utilisation des listes ou des tableaux
d´epend donc des besoins.
L’op´erateur len, l’indi¸cage par [] et les tranches fonctionnent aussi sur les liste. On acc`ede au dernier ´el´ement par
l’indice -1 (ce qui fonctionne aussi sur les tableau mais est peu portable dans les autres langages)
Quelques uns des op´erateurs sp´ecifiques sont :
•liste.append(truc) : ajoute truc en fin de liste
•liste.extend(liste2) : concat`ene liste2 en fin de liste
•liste.insert(indice, truc) : ins`ere truc dans liste `a l’indice donn´e (l’indice 0 ins`ere en d´ebut de liste)
•liste.remove(truc) : retire la 1`ere occurrence de truc trouv´ee dans la liste (erreur si non trouv´e)
•liste.pop(indice) : retire et retourne l’´el´ement `a l’indice donn´e (si pas d’indice fourni retire le dernier ´elem).
•liste.index(truc) : donne l’indice de la 1`ere occurrrence de truc dans la liste
4

l = [] # cr ´e ation d’ une liste vide
l = [1 , 2, 3] # liste de 3 ent iers
l = [1, ’ bonjour ’, 3.14] # liste m´e langea nt des types
l2 = [[2]] # cr´e ation d’ une liste cont enant le 3`e me ´e lem de l
l2 . a pp end ( 2.718) # a jo ut d ’ un ´e l ´e ment en fin de l is te
l3 = l2 # AT TENTION : pas une copie mais un alias
l3 = l2 [:] # cr´e ation d’ une copie ( NE fo nctio nne PAS avec les tabl eaux !)
print ( l3 [ -1]) # affiche le dernier ´e l´e ment
4 Notion de Pile
Une pile est un type abstrait (mais pensez `a une pile d’assiette), c’est une collection de donn´ee telle que :
•on peut ajouter un ´el´ement `a la pile (”empiler”).
•on peut tester si la pile est vide (parfois aussi si elle est pleine — plus de place disponible)
•on peut r´ecup´erer un ´el´ement sur la pile (”d´epiler”), et c’est le dernier ajout´e (principe LIFO : Last In First
Out — dernier entr´e premier sorti). Souvent par commodit´e on peut consulter le dernier ajout´e sans avoir `a le
d´epiler.
En python on cr´ee facilement une pile en prenant une liste et en se limitant aux op´erateurs append, et pop() sans
indice.
5 Notion de File
Une file est un type abstrait cousin de la pile (mais cette fois pensez `a la file `a la caisse d’un commerce), c’est une
collection de donn´ee telle que :
•on peut ajouter un ´el´ement `a la pile (”enfiler”).
•on peut tester si la file est vide (parfois aussi si elle est pleine — plus de place disponible)
•on peut r´ecup´erer un ´el´ement sur la file (”d´efiler”), et c’est le premier ajout´e (principe FIFO : First In First Out
— premier entr´e premier sorti). Souvent par commodit´e on peut consulter le premier sans avoir `a le d´efiler.
Comme pour la pile, une file en python peut ˆetre cr´e´ee en prenant une liste et en se limitant aux op´erateurs append,
et pop(0).
6 R´ecursivit´e
On parle de r´ecursivit´e et d’appel r´ecursif lorsqu’une fonction s’appelle elle-mˆeme, directement ou indirectement. Un
appel r´ecursif lance une nouvelle invocation de la fonction, dont le code va ˆetre `a nouveau ex´ecut´e : on obtient donc
l’´equivalent d’une boucle. Si chaque invocation de la fonction effectue l’appel r´ecursif, alors la boucle est infinie et le
programme est erron´e. Par cons´equent l’appel r´ecursif doit se faire seulement sous condition (par exemple dans un
”if”), afin que la r´ecursion se termine. La condition porte typiquement sur un ou plusieurs param`etres de la fonction,
qui jouent un rˆole similaire `a celui des variables contrˆolant une it´eration classique.
Compraison r´ecursion/it´eration :
def itere ( N ):
i=1
while i <= N:
print (i)
i += 1
def re cu rse ( N ):
i=1
au xRecur se ( i , N )
def a uxRec urse ( i , N ):
if i > N:
return
# nota : ici nous sommes dans le " else " sans avoir `a le dire ...
print (i)
5