ALGORITHMIQUE AVANCÉE

Langage Python
• Langage développé par Guido Von Russom
• Python 0.9 : 1991, Python 1.0 : 1994, python 2.0 : 2000, python 3.0 : 2008 (pour
résoudre pbs de compatibilté) ^ rupture de syntaxe, coexistence de des versions
2 et 3 pendant 10 ans
• Langage de haut niveau ^ syntaxe simple et intuitive à l'aide de mots usuels
(en anglais) et d'opérateurs mathématiques
• Langage de programmation impérative (boucles, tests conditionnels), orienté
objet, permettant aussi la programmation fonctionnelle
• Mutli-plateformes peut être utilisé dans les environnements Unix, Mac-Os,
Windows, Android et iOS
 Python
• Installation : https://www.python.org/download
• Si déjà installé : vérifier le numéro de version, qui doit être au moins 3.6
• Il existe beaucoup de distributions alternatives qui incluent Python
ex : Anaconda, qui contient un grand nombre de bibliothèques de calcul scientifique
• IDE : idle, spyder, ...
• Terminal : Interpréteur python : taper python3 ^ Pour exécuter un fichier :
python3 fichier.py
 Intérêts
• Grosse base de code : nombreuses librairies : calcul scientifique (numpy,
matplotlib, scipy, ...), web (django, notebooks Jupyter), traitement de données
(pandas, ...)
• notebooks Jupyter : peut associer du code, des graphiques, des visualisations et
du texte dans des notebooks (cahiers) partageables qui s'exécutent dans un
navigateur web
^ favorise les partages et la vitesse de développement
• Types de base très puissants (dictionnaires, ensembles, tableaux numpy, ...)
• Gestion automatique de la mémoire
•

java vs python ^ JAVA

• Langage compilé : avant lexécution du programme, le compilateur traduit le code Java en
code machine via la JVM
-
multiplateformes, fonctionne partout, sans aucune dépendance
-
gère les programmes plus rapidement
• Langage typé statique : les types utilisés dans le code source (fonction, variable, etc.) sont
vérifiés au moment de la compilation
-
Le compilateur vérifie la cohérence des types et des données utilisées
-
contrôle de type : chaque variable a exactement un type qui est défini lors de sa déclaration
-
debug facilité
• Manières de définir et utiliser les variables plus strictes, donc syntaxes plus longues
• Langage objet : le moindre bout de code doit se situé dans une classe !
java vs python PYTHON
• Langage interprété : pas d’étape de compilation
-
On peut écrire des programmes incorrects et on s’en rend compte trop tard (à
l’exécution)
-
Incidence sur la vitesse d‘exécution
• Langage typé dynamique : le typage est réalisé dynamiquement par le
langage lors de l’exécution du code
-
Définit lui-même le type selon la nature de la valeur : une chaine de caractère, un entier,
une liste, etc
-
Codage plus souple et plus rapide
-
Consommation de mémoire et temps de processeur pour pouvoir typer à la volée
-
Debug difficile
 Typage dynamique en python
Instruction "a = 3" puis entrée
• Création de l'entier 3 (objet) dans l'espace des objets
• Création de la variable a dans l'espace des variables (espace des
nommages)
• Création d'une référence entre la variable a et l'entier 3 (a référence 3)
• Le type n'est pas lié à la variable qui référence l'objet mais à l'objet
• Un objet garde le même type au cours de l'exécution MAIS une variable
peut référencer des objets de types différents au cours de l'exécution

Types simples et expressions

• Expression : suite de caractères définissant une valeur (constante (nb),
 nom de variable, résultat d'une fonction appliquée à une expression, ...)
• La machine doit évaluer l'expression pour connaître cette valeur
• Les valeurs possèdent un type : entier, flottant, booléen, chaîne de
caractères, liste, fonction...
• Le type détermine :
- les propriétés formelles de la valeur (par ex, les opérations qu’elle peut subir)
- ses propriétés matérielles (par ex, la façon dont elle est représentée en mémoire et la
place qu’elle occupe)
• Pour connaître le type d’une expression après évaluation : type(expr)
 type
• type(1+4) ^ <class 'int'>
• type(2.i+7) <class 'float'>
• type(5/2) ^ <class 'float'>
• type(4<7) ^ <class 'bool'>
• type(‘blabla’) ^ <class 'str'>
• type([0,1,2]) <class 'list'>

ETC
 Différences de syntaxes avec java
• Pas de public class { ... } qui envelope tout le code
• Pas de public static void main(String args[]) { ... } pour la méthode principale
• Booléens : True et False
Opérateurs :
-
// pour la division entière
-
** pour l’exponentiation (a**b ^ ab)
-
not pour la négation
-
and pour le et logique
-
or pour le ou inclusif Ordre de priorité
Pas de point virgule pour séparer les instructions car une seule instruction
par ligne (possibilté de le faire un point virgule !) print() pour afficher à la place
de System.out.println()
 Structures de contrôle
• Pas d’accolades pour délimiter des blocs d'instructions
• Tout est basé sur l'indentation : le fait de laisser une marge devant un bloc
d'instructions
- Indentation standard est de quatre espaces, ou une tabulation
• Instructions conditionnelles : if, else, elif Ex : if note>=16:
bloc instructions
elif note>=14:
bloc instructions
else:
bloc instructions
 Boucles
• Boucle "tant que" :
- while <condition>: ^ pas de parenthèses autour de la condition

bloc instructions
- Pas d’instruction do ... while !
• Boucle "pour" :
- for element in iterable
- un itérable est une séquence de valeurs que l’on va pouvoir parcourir
- la variable element prend successivement toutes les valeurs que fournit l’itérable
^ utilisation de la fonction native range qui fournit des suites finies d’entiers
 range
syntaxe : range(start, end, step)
pour n ≥ 0, range(0,n,1) fournit tous les entiers de 0 inclus à n
exclus
start vaut 0 par défaut, et step
vaut 1 par défaut syntaxe for i in range(10,0,-2):
allégée : range(n) print(i, end=" ")
for i in range(0,10,2): print(i, end=" ") ^ affiche 0 ^ affiche 10 8 6 4 2
2468
 break et continue
• Dans une boucle, on peut utiliser les commandes break et continue :
- break sort de la boucle
-
continue poursuit l’itération en revenant « en haut de la boucle », en ignorant ce qu’il
y a derrière
-
i=0
-

while i<10:
print(i, end=" ") ^ affiche 0 1 2 3
i+=1 • A éviter, ces instructions rendent le code
difficilement compréhensible (on peut
if i>3: s’en passer facilement !)
break
continue
print("coucou")
 Type list
• Désigne un tableau redimensionnable inhomogène, appelé plus simplement
liste ex : L = [True, 4, 5, 3.0]
• La fonction len donne la longueur d'une liste : len(L) 4
• ^ les listes sont des séquences finies d'éléments, possiblement de types
différents
• On peut construire une liste de plusieurs manières :
-
par la donnée explicite des éléments, entre crochets, séparés par des
virgules
-
par concaténation de listes (à l'aide de +) : [1, 2, 3]+[4, 5, 6] s'évalue en
[1, 2, 3, 4, 5, 6]
-
par l'utilisation de l'opérateur * : [0]*4 crée la liste [0, 0, 0, 0]
 Suite
-
par la syntaxe list(iterable) ^ permet
de fabriquer une liste à partir d'un itérable :
• list(range(4)) s'évalue en [0, 1, 2, 3]

• list("chaine") s'évalue en ['c', 'h', 'a', 'i', 'n', 'e']

-
par compréhension, avec la syntaxe suivante : [f(x) for x
in iterable if P(x)] où f(x) est une expression
dépendant (ou non) de x, et P(x) est une expression
booléenne (facultative)
^ [x*x for x in range(5) if x%2==0] s'évalue en la liste [0, 4, 16]
-
par slicing
 Parcours d’une liste L
• Ex : comment aficher ses éléments ?
i=0
• while i < len(L):
print(L[i], end=" ")
i+=1
• for i in range(len(L)):
print(L[i], end=" ")
• for x in L:
print(x, end=” ")
• [print(x, end=" ") for x in L]
 Méthodes associées
• opérateur in : if x in teste si L contient l’élément x
• L.append(x) ajoute l’élément x à la fin de la liste L
• L.extend(T) ajoute les éléments de la liste T à la fin de L (équivalent à L+=T)
• L.insert(i, x) ajoute l’élément x en position i de L, en décalant les suivants vers la droite
• L.remove(x) supprime de la liste la première occurrence de x si x est présent, sinon
produit une erreur
• L.index(x) retourne l’indice de la première occurrence de x dans L si x est présent,
produit une erreur sinon
• L.pop() supprime le dernier élément de L, et le renvoie
• L.reverse() renverse la liste (miroir)
 Références
• Quand on écrit L=[5,2,3,-7], la variable L est une référence vers
l'emplacement mémoire où est stockée la liste
• Si on écrit ensuite M=L, on stocke dans la variable M la référence stockée
dans L l'emplacement mémoire désigné par L et M est le même
• Si on modifie un élément avec L[0] = 1, on va modifier directement la mémoire et
print(M) donnera [1,2,3,-7]
• Si par contre on écrit M=L[:], on crée une copie de L (appelée shallow
copy)
une liste dont les éléments sont les mêmes que ceux de L, mais ailleurs
en mémoire (les références L et M pointent vers des endroits différents en
mémoire), donc si on modifie l'une, l'autre n'est pas modifié
 Liste de listes
• Ex : L=[[0,2,3], [4,5], [-6,3,9.-2]]
• Permet de représenter des tableaux 2D, notamment des matrices (si les
sous- listes sont de même taille)
• Ex : création d'une matrice 2x3 (2 lignes, 3 colonnes) ne comportant que
des zéros : [[0]*3 for i in range(2)] crée la liste M=[[0, 0, 0], [0, 0, 0]]
• Attention encore aux références :
- si on crée une copie de M comme ceci : N=M[:], on recopie les éléments de M ... mais
comme ces éléments sont des références vers [0, 0, 0] et [0, 0, 0], le problème
persiste car ces listes-là n'ont pas été recopiées
Il faut écrire : N=[A[:] for A in M]
• Remarque : en python il existe un module copy dont la fonction deepcopy
permet de copier « en profondeur » un objet
 Type str
• Une chaîne de caractères est une suite de caractères quelconques
• On peut écrire ces caractères soit entre apostrophes, soit entre guillemets :
- ex : 'Coucou' et "Coucou" représentent la même chaine
• Une chaîne est immuable : on ne peut pas changer un caractère ^ Il faut créer
une nouvelle chaîne qu’on peut éventuellement réaffecter à la même variable
• Nombreuses méthodes :
-
opérateur * : "abc"*3 renvoie la chaîne "abcabcabc"
-
len(s) renvoie la longueur de la chaîne s (le nb de caractères qu'elle contient)
-
s.split(car) sépare la chaîne s autour du caractère car, en renvoyant une liste
de chaînes de caractères
^ ex : "coucou les amis".split(" ") renvoie "les","amis"
["coucou" ]
- s.join(L) fait l'inverse de la fonction précédente ^ ex. "_".join(["salut", "les",
"copains"]) renvoie "salut_les_copains"
 Affichage
• Pour afficher une chaîne de caractères : fonction print
• ^ passe automatiquement à la ligne (par défaut ajout du caractère '\n' en fin de ligne)
• Pour ne pas passer à la ligne, modifier la valeur du paramètre end : print("salut", end=" ")
• Pour concaténer des chaînes avec des valeurs de variables, utiliser la virgule : x = 32
nom = "John"
print(nom, "a", x, "ans") ^ affiche
"John a 32 ans" (par défaut print ajoute le séparateur " " lors des concaténations)
• Pour modifier le séparateur : print(nom, "a", x, "ans", sep="") ^ affiche "Johna32ans"
• Attention, l’opérateur + concatène uniquement des chaînes :
print(nom+ "a"+ x + "ans") ^ TypeError: can only concatenate str (not "int") to str ^ Il
faut alors convertir le type int en type str ... avec la fonction str print(nom+ "a"+
str(x) + "ans")
 input
• À l'inverse de print, input permet de récupérer quelque chose depuis l'entrée
standard (par défaut, le clavier)
• ^ Prend en paramètre optionnel une chaîne de caractères (prompt string), l'affiche avant de
récupérer ce qui a été tapé au clavier, sous forme d’une chaîne de caractères)
• On affecte souvent cette chaîne lue à une variable
• Ex : s=input("Quel temps fait-il ?")
^ affiche "Quel temps fait-il ?" et affecte la réponse (tapée au clavier) à s
• Les fonctions de conversions de type permettent de convertir une chaîne de
caractères en le type qui nous intéresse
• Une conversion de type se fait sous la forme t(x) où t est le type voulu et x
l'objet à convertir (t peut être int, float, str, bool, list, ou complex)
• Ex : n=int(input("Donner un entier : "))
 Type tuple
• Un tuple ressemble beaucoup à une liste, mais il est imuable, comme les chaînes de
caractères (on ne peut pas les modifier)
• Correspond à notion mathématique de n-uplet
• Compacts (ils occupent peu de mémoire) et l’accès à leurs éléments est rapide
• Création : écrire les éléments du tuple séparés par des virgules et encadrés par des parenthèses (l es
parenthèses peuvent être omises si pas d’ambiguïté) ex :
t=(5, False, (7,8), -6)
• Un tuple constitué d’un seul élément x s’écrit (x,)
• Le tuple sans élément se note ()
• On peut déconstruire un tuple par affectation simultanée à un tuple de variables de la
même taille, pour réaliser une affectation simultanée : t=(1,2) puis
(x,y)=t ou x,y=t
^ utilisation pour échanger les valeurs de deux variables : a, b = b, a
 Types list, tuple, str : accès aux
éléments
• Accès à lélément d’indice i : L[i]
• Possibilité d’accéder aux éléments par des indices négatifs
• Ex sur une chaîne de caractères : s = ’egg, bacon’
s[9] renvoie la même chose que s[-1] : le dernier caractère ’n’
• Slicing (découpage) : syntaxe ^ s[start:stop:step]
s[0:3] (ou s[:3]) renvoie ’egg’,
s[5:10] (ou s[5:]) renvoie ’bacon’
s[0:i0:2] (ou s[::2]) renvoie 'eg ao' egg, bacon
s[:8:3] renvoie ’e,a’ s[2::3] renvoie 0 1 2 3 4 5 6 7 8 9 - 1 0 - 9
’gbo’ s[-i0:-7] renvoie ’egg’ s[:-3] - 8 - 7 - 6 - 5 - 4 - 3 - 2 -
1
renvoie ’egg, ba’ s[::-i] renvoie
’nocab ,gge’
s[2:0:-i] renvoie ’gg’ s[2::-i] renvoie ’gge’
 Dictionnaires
• Objet permettant de stocker des couples (clé, valeur), chaque clé ne pouvant
être présente que dans un seul couple
• Utilisation d'accolades : D={'b':4, 0:9, (1,2):"truc"}
• Accès à un élément à partir de sa clé : D['b'] ^ 4, D[(1,2)] ^ "truc"
• Ajout : D['fin']=0, modification : D[0]=False
• on ne peut pas utiliser un objet mutable (comme une liste, ou un dictionnaire,
par exemple) comme clé d’un dictionnaire
^ clés parmi les objets immuables (entiers, flottants, chaînes de
• caractères, tuples, ...)
 •

Fonctions
• Une fonction est une séquence d’instructions, dépendant de paramètres d’entrée (arguments), et
retournant éventuellement un résultat
séquence d’instructions que l’on peut utiliser plusieurs fois
brique de base d’un problème plus complexe
• Syntaxe :
def mafonction(arg1, arg2, ...):
'''chaîne de documentation décrivant la fonction, qui peut être sur plusieurs lignes,
renvoyée par la commande help(mafonction)"' #facultatif, utile pour la commande 'help'
instructionl
instruction2 return res #facultatif
#retour à une indentation au même niveau que def ^ fin de la fonction
mafonction(5,7) #appel de mafonction avec deux arguments effectifs
 Fonctions
• En Python, les fonctions sont traitées comme des objets ^ elles peuvent être :
- stockées dans des structures de données
- utilisées dans des structures de contrôle

• Une fonction peut être donnée en paramètre d'une autre fonction

def f(x,g):
return g(x)+6
• Une fonction peut être définie dans une autre fonction
def f(a): a +=6 def g(): print(a)
g()
 Arguments
• On peut faire en sorte qu’une fonction prenne un nombre variable
d'arguments def somme(*args):
'"retourne la somme de tous les arguments"1
som = 0
for i in range(len(args)): som+= args[i] return
som
Appels possibles : somme(4,8,2,1) ^ 15 ; somme(7,3) - 10
• Certains arguments peuvent être déclarés comme optionnels en leur donnant une valeur par
défaut def f(x, y=7)
return x*y
Appels possibles : f(4,2) ^ 6 ; f(3) - 21
 Valeurs particulières
• Si la fonction ne comprend pas de return, la fonction ne renvoie rien (on qu’elle fonctionne
par effets de bord) ^ différence fondamentale avec les fonctions mathématiques
• Il existe un type pour ça : NoneType, qui comporte une unique valeur : None (~ équivalent
de null en java)
• Quand un calcul produit une erreur, la valeur renvoyée est NAN (signifie « not a number »)
^ pour vérifier si une valeur calculée "est un NaN", on peut utiliser la fonction isnan() du
module math
• Les infinis sont utilisés pour exprimer le fait qu’un calcul dépasse le plus grand nombre
représentable par valeur positive (on obtient alors +œ), ou le plus petit par valeur négative
(on obtient alors -œ)
^ Ils sont noté inf et -inf
 Fonction map, fonction lambda
• la fonction map() applique une fonction à chaque élément d’un itérable
(ex : une liste) et renvoit un nouvel itérateur pour récupérer les résultats
• nbs=[1, 2, 3, 4, 5] liste_carres =
list(map(lambda x: x 1 x, nbs)) print(liste_carres) ^ affiche
[1, 4, 9, 16, 25]
• Le mot-clé lambda est utilisé pour déclarer une fonction sans nom
• Les fonctions lambda se comportent de la même manière que les fonctions
régulières qui sont déclarées en utilisant le mot-clé def :

1 def somme(a,b): s2 = (lambda a,b : a + b)(5,6)

return a + b si =
somme(5,6) ^ si
et s2 référencent la même valeur : 11
Modules
• On appelle “module" tout fichier constitué de code Python (avec l’extension .py ) importé
dans un autre fichier ou script
^ Les modules permettent la séparation et donc une meilleure organisation du code
^ Utilisation du module math (importé par défaut par spyder)
• dir(math) pour voir toutes les fonctions du module
• Importation d'une fonction particulière : from math import sin
• Importation de toutes les fonctions : from math import *
• Importation du module entier : import math ^ les fonctions sont accessibles par
math.sin, ...
• Avec un alias : import math as m, les fonctions sont alors accessibles par
m.sin, ...
 Module math
• Fonctions utiles :
-
valeur absolue : abs
-
racine carrée : sqrt
Ex : for i in range(sqrt(n)): équivalent
à : for i in range(n**0.5): équivalent à :
i=0
while i*i<n:
i+=1
-
partie entière de x : int(x) ^ fonction de conversion de type, pas dans le module math !
-
arrondi de x à l'entier le plus proche : round(x)
 Autres modules
• Le module time permet de mesurer des temps d’exécution
-
fonction time mesure le temps absolu en secondes
-
fonction clock idem, donné par l'horloge du processeur
• Le module random permet de générer des nombres
aléatoires
-
randomQ fournit un flottant aléatoire de [0, 1[
-
randint(a,b) un entier aléatoire de [a, b]
-
shuffle(L) mélange les éléments d'une liste L
-
choice(L) tire au sort un des éléments de la liste L
-
sample(L,k) tire au sort k éléments de la liste L
Recherche d'un élément dans une
liste #parcours des
#parcours des indices éléments
def cherche(L,x): def cherche2(L,x): for
n=len(L) u in L: if u==x:
for i in range(n): return True
if L[i]==x: return False
return True
return False
# pas de else : return
False

^ Correspond à x in L en Python !
 Maximum d’une #variante : recherche de l'indice
liste non vide du max
def
def maxi(L): n=len(L) m=L[0] maxi(L)
for i in range(1,n): if L[i]>m: :
m=L[i] m=L[0]
return m imax=0
for i in range(1,len(L)):
^ correspond à max(L) en python if L[i]>m:
m=L[i
imax
=i
return imax

^ correspond à L.index(max(L))
 Somme/produit des éléments d’une
liste
def somme(L): def produit(L):
n=len(L) n=len(L)
s=0 p=1
for i in range(n): for i in range(n):
s+=L[i] P*=L[i]
return s return p

^ correspond à sum(L) en python pas de fonction python !

 Tester si une liste est croissante
def est_croissante(L): #variante sans return dans #le
n=len(L) for
for i in range(n-l): def est_croissante2(L):
if L[i]>L[i+1]: n=len(L) i=0
return False ok=True
return True while ok and i<n-
1: if L[i]>L[i+1]:
ok=False
^ pas de fonction python ! return ok
Recherche dichotomique dans une
liste triée
def cherche_dicho(L,x):
i, j = 0, len(L)-1 #initialisations
while i<=j: #balayage de i vers la droite, de j vers la
gauche m=(i+j)//2 #calcul de l’indice "du milieu” if
L[m]==x: #on a trouvé !
return True
elif L[m]<x: #x est dans la partie droite
i=m+1
else: #x est dans la partie gauche
j=m-1
return False
 Sources
• https://python.sdv.univ-paris-diderot.fr/
• https://docs.python.org/fr/3/tutorial/
• Cours d'Informatique pour Tous, Jules Svartz
• Cours de Richard Genestier
• Pour se former :
- Mooc "Python : des fondamentaux aux concepts avancés
du langage" sur funMooc