Licence ECO

« Python & algorithmie »

Sébastien PARIS - UTLN

 Avant-propos
Objectif de cours : Vous familiarisez avec la programmation
informatique et les bases de l’algorithmie. La programmation sera
faite avec le langage Python
Pourquoi Python ? Python depuis une dizaine d’année est devenu le
langage extrêmement utilisé en manipulation de données,
d’apprentissage statistique et d’intelligence artificielle. Il sera un
pré-requis pour la L3 et plus
Il est entièrement gratuit et disponible sur n’importe quel type de
machine (ordinateurs/tablettes/smartphone) et système d’exploitation
(Windows/Linux/Mac OS)
Les outils logiciels pour la
programmation en Python
 Anaconda (1/5)
Python se télécharge librement à https://www.python.org/

Mais il est conseillé de plutôt d’ installer Anaconda à :

https://www.anaconda.com/distribution/
 Anaconda (2/5)
Anaconda est un gestionnaire d’environnements. Il permet de créer
des environnements propres et indépendants les uns des autres.
Idéal pour gérer les différentes versions de logiciels et modules
python.
Anaconda crée par défaut un environnement « base » avec python,
spyder installés dedans. Cet environnement est celui actif par
défaut
 Anaconda (3/5)
Anaconda peut se lancer en ligne de commandes

Puis python par la commande « python »

Anaconda intègre un éditeur de développement « spyder »

qui se lance directement
ou par « spyder » depuis
le prompt anaconda
 Anaconda (4/5)
Depuis spyder, dans la console python on peut vérifier dans quel
environnement on est avec la commande :
import sys; sys.executable

L’intérêt principal est de créer un nouvel environnement « test »

conda avec la commande : conda create -- name test

Depuis l’environnement de base, une fois « test » crée on « rentre »

dedans avec : conda activate test
 Anaconda (5/5)
Depuis l’environnement « test », on peut installer par exemple
python : conda install python
spyder : conda install spyder

Avec cette pratique vous pouvez installer différentes versions de

python de façon indépendantes grâce à des environnements
personnalisés
 Spyder (1/1 )
Spyder est un éditeur/debeuggeur de codes python
 Google colab
Google colab est un jupiter en ligne gratuit. Seule une connexion
internet est requise. Les fichiers sont enregistrés dans Google drive
Python
 Python : les imports
Un programme python aura l’extension de fichier .py
Des milliers de modules/bibliothèques Python ont été développés.
Notamment numpy, matplotlib, pendas, etc..
Les premières lignes d’un code python sont dédiées à l’importation
des modules nécessaires pour le reste du programme

import nom_du_module as raccourci

Pour commenter un code python (écritures qui ne sera considérer

comme du code), on utilise le #
 Les variables
En mathématique lorsque l’on écrit x = 3, cela veut dire que la valeur
3 est mise dans la variable x. Autrement dit le terme de droite, ici 3,
doit être connu avant et le résultat de l’affectation (par le symbole =)
est écrit dans la variable à gauche du = ici dans x. En résumé, avant
de faire une affectation, on doit connaître avant ce qu’il y a à droite
du =
x = 3.20 # nombre décimal appelé float en informatique
s = "ceci n'est pas une chaine" # chaîne de caractère entourée par
les " "
● Attention, l’erreur que je vois souvent est 3.20 = x par exemple
● Autre erreur courante, les variables sont sensibles à la case, i.e. les
variables X et x ne sont pas identiques !!!
● Enfin en python, les indentations (tabulations) sont très
importants !!!
 Opérations de bases
Toutes les opérations arithmétiques de base sont directement
accessible
x = 3.20
y=x+3
z = x*y Attention comme en math avec y=f(x), on doit connaître x
Z = z/2 afin de calculer y <=> la variable à gauche du signe égal
print(y) est mis à jour après avoir effectuer le calcul f(x)
print(z)
print(Z) La commande print affiche à l’écran le contenu de la
variable.
Les noms des variables peuvent être des mots mais ne doivent pas
commencer par des chiffres et ne doivent pas contenir des
caractères spéciaux (!#@& »….)
Masolution = x*x + y*y
print(Masolution)
 Booléens et conditions
Certaines variables ne peuvent prendre que deux états possibles :
vrai(true) ou faux(false). Elles vont être très utiles pour tester des
conditions
cond = True
print(cond)
cond_duale = not(cond)
print(cond_duale)

Les opérateurs sur les variables booléennes sont

● not
● or
● and
● < , > , <= , >= , ==,!=
 Booléens et conditions
Les variables booléennes peuvent récupérer la réponse à une
question simple. Exemple
cond = (x < 17) #Est-ce que le contenu de la variable x est inférieur
à 17 ?
Test si une variable x appartient à l’intervalle [a,b[
cond = (x >=a) and (x < b)

Ils peuvent être combinés pour réaliser un test plus complexe :

exemple. Tester si un nombre x n’appartient pas à l’ensemble [a,b[ U
[c,d[
cond = not( ((x >=a) and (x < b)) or ((x>=c) and (x<d)) )
 Python : numpy
Python possède un module mathématique très utilisé : numpy. Il
permet de définir par exemple des vecteurs, matrices et faire des
opérations avec ces objets. Il faudra donc commencer notre
programme .py par l’import associé
import numpy as np
Chaque module possède des fonctions/méthodes qui s’appellent de
la façon suivante :

raccourci.nom_fonction
 Python : numpy
Il est possible via numpy de réaliser des opérations plus complexes
cosx = np.cos(x)
dist = np.sqrt(x*x + y*y) #distance euclidienne à l’origine
Il est possible de définir des vecteurs/tableaux/matrices et plus
encore à l’aide de la méthode array de numpy. Définissons un
vecteur horizontal à 3 éléments [1 , 2 , 3] (taille (1,3))
vect = np.array([[1 , 2 , 3]])
print(vect)
● print(vect.shape) #taille
Attention : Il y a la présence de
deux niveaux de [ ] pour avoir
un vecteur de taille (1,3). Si
défini par un seul niveau, on
obtient une taille (3, )
 Python : numpy
Ici la variable vect contient un vecteur (1 x 3) avec des données
entières (type int32), i.e. chaque élément du vecteur est à valeur
dans N
La commande print(vect) affiche à l’écran le contenu de vect.
Erreur du débutant : en général vous oubliez de faire afficher le
résultat d’un calcul à la fin de votre programme.
On peut changer le typage des données avec la méthode
astype(dtype), où dtype=("int32","int64","float32", "float64") Par
exemple :
vect = np.array([[1 , 2 , 3]]).astype("float64")
print(vect)
 Python : numpy
Attention au changement de type qui peut faire prendre en précision
<=> troncation
vect = np.array([1.6 , 2.2 , 3.94]).astype("int64")
print(vect)
 Python : numpy
● On accède à un élément du tableau vect par vect[i] où i=0,…, N-1

Exemple (N=3) :
vect = np.array([[1.6] , [2.2] , [3.94]]).astype("int64")
print(vect[0])
print(vect[1])
● L’indice 0 est toujours le premier élément d’un tableau. L’indice N-1
est le dernier.
● vect[-1] désigne toujours le dernier élément du vecteur
● vect[a:b] extrait une partie du tableau vect où a et b représentent
des indices. a<=b et a = 0,…,N-1 ; b=1,…,N
print(vect[0:1,0])
print(vect[1:3,0])
 Python : numpy
Grâce à numpy, on peut faire des opérations vectorielles, matricielles
très simplement
vect1 = np.array([[1.6 , 2.2 , 3.94]])
vect2 = np.array([[4.3 , 8.90 , - 2.78]])
res = vect1 + vect2
print(res)
 Python : numpy
Le sous-module random de numpy, permet de générer des
échantillons selon différentes distributions
vect1 = np.random.rand(1 , 3) # 3 échantillons uniforme sur [0,1]
vect2 = np.random.randn(1 , 5) #5 échantillons gaussien m=0,sigma=1
Les méthodes zeros et ones permettent de générer des
vecteurs/matrices remplis de 0 ou 1 respectivement
vect3 = np.ones((1 , 3) , dtype="float64") #[1.0 , 1.0 , 1.0]
 Python : numpy
Grâce à des variables numpy, il est possible de calculer facilement
des statistiques de base
import numpy as np
x = np.random.randn(10000,1)
moyx = np.mean(x)
stdx = np.std(x)
print(moyx)
print(stdx)
Il est possible d’exécuter la méthode « moyenne » directement sur
un objet numy par
moyx1 = x.mean()
stdx1 = x.std()
print(moyx1)
print(stdx1)
 Python : matplotlib
Le module matplotlib de python permet d’afficher une grande
variété de graphes
import numpy as np
import matplotlib.pyplot as plt
fig = plt.figure(1)
plt.plot(x)
fig = plt.figure(2)
plt.plot(x , 'r' , linewidth=2, markersize=12 , marker='o', linestyle='dashed')
 Python : matplotlib
Voici un exemple où l’on trace deux histogrammes côte à côte
 Les variables dictionnaires
A partir de types de base (int, float, bool,etc.), il est possible de
définir des variables dictionnaire avec un type « construit »
L’originalité est que les indices des éléments eux-même peuvent
être définis avec un type autre qu’entier, typiquement une chaîne de
caractères
mon_dico = {"pioches": 3 , "scies": "hors stock"}
print(mon_dico["scies"])
Il est possible de créer une variable dictionnaire à la volée

mon_dico = {}
mon_dico["pioches"]=3
mon_dico["scies"]="hors stock"
 Continuons avec numpy
Nous avons vu les premières méthodes avec numpy pour générér
des vecteurs/matrices (array, zeros, ones, etc..) et comment
extraire des sous-parties de ceux-ci
np.newaxis : permet de modifier/d’ajouter une dimension à un
vecteur/matrice sans rajouter de nouveau élément
exemple : soit un vecteur np.array définit avec un seul niveau de []
vect = np.array([1 , 4 , 8 , 9])
print(vect.shape) #affiche la taille du vecteur (4, ) et pas
#(4,1) ou (1,4)
vect1 = vect[: , np.newaxis]
print(vect1.shape) # (4,1) maintenant
vect2 = vect[np.newaxis ,:]
print(vect2.shape) #(1,4)
 Continuons avec numpy
np.arange(a,[b],[c]) : permet de créer un np.array commençant par a
allant jusqu’en b par pas c
Remarque : les paramètres mis entre [ ] sont optionnels. Si vous les
utilisez, il ne faudra pas mettre les crochets
Remarque : si utilisé avec un seul argument on a
np.arange(d)=np.arange(0,d,1)
Exemple :
vect = np.arange(10)
print(vect)
vect1 = np.arange(1,10,3)
print(vect1)

Attention : ne pas confondre np.arange avec range. La première

renvoie un np.array alors que range renvoie une liste
 Continuons avec numpy
np.linspace(a,b,c) : permet de créer un np.array commençant par a
allant jusqu’en b avec c élements
Exemple :
vect = np.linspace(1,15,7)
print(vect)
print(vect.shape)
 Continuons avec numpy
np.concatenate((array1,array2,….,[arrayn]),[axis=]) : permet de
« concatener »/coller côte à côte (verticalement ou horizontalement
les tableaux array1, array2, …, arrayn. On peut choisir la dimension du
collage avec axis (par défaut axis=0)
Exemple :
a = np.array([[1,2],[3,4]])
print(a)
print(a.shape)
b = np.array([[5,6],[7,8]])
print(b)
print(b.shape)
c = np.concatenate((a,b))
print(c)
print(c.shape)
d = np.concatenate((a,b),axis=1)
print(d)
print(d.shape)
 Continuons avec numpy
np.reshape(array,(dim1,dim2,…,dimn)) : permet de changer les
dimensions d’un tableau tout en conservant le même nombre
d’éléments. Permet de transformer un vecteur en matrice en le
« dépliant » par exemple.
Exemple :
a = np.arange(10)
print(a)
print(a.shape)
b = np.reshape(a,(2,5))
print(b)
print(b.shape)
c = a.reshape(5,2)
print(c)
print(c.shape)
 Continuons avec numpy
np.matmul(A,B) : permet de faire le produit de matrice entre la matrice
A(nxp) et B(pxm). Le résultat sera une matrice (nxm)

Exemple :
A = np.arange(10).reshape(2,5)
print(A)
B = (np.arange(15)+3).reshape(5,3)
print(B)
C = np.matmul(A,B)
print(C)
print(C.shape)
 Continuons avec numpy
np.mean(A,[axis=]) : calcule la moyenne empirique sur la première
dimension de A (axis=0) par défaut.
Exemple :
A = np.random.randn(100,3)
meanA0 = A.mean(axis=0).reshape(1,3) #vecteur (1x3)
meanA1 = A.mean(axis=1).reshape(100,1) #vecteur (100x1)
print(meanA0)
print(meanA1)
np.std(A,[axis=]) : calcule l’écart-type empirique sur la première
dimension (axis=0) par défaut.
Exemple :
A = np.random.randn(100,3)
stdA0 = A.std(axis=0).reshape(1,3) #vecteur (1x3)
stdA1 = A.std(axis=1).reshape(100,1) #vecteur (100x1)
print(stdA0)
print(stdA1)
 Continuons avec numpy
Il est souvent très important de calculer la covariance empirique de
donnée stockées dans une matrice X (d x n) où d (d>1) est la
dimension des données et n le nombre de données
np.cov(A) : calcule la covariance empirique de données A (dxn).
retourne la matrice (dxd)
Exemple :
A = np.random.randn(3,100)
covA = np.cov(A)
print(covA) #matrice (3x3
A1 = np.random.randn(100,3)
covA1 = np.cov(np.transpose(A1))
print(covA1) #matrice (3,3)
 Les branchements conditionnelles : if, elif,
else
En algorithmie, selon la valeur d’une variable, il est important de
différencier le traitement selon celle-ci.
Syntaxe :
if condition_principale: #tester en premier la condition qui se
bloc instruction₁ #réalise le plus souvent
elif condition_secondaire:
bloc instruction_2
.
.
elif condtion_{n-1}:
bloc instruction_{n-1}
else:
bloc instruction_n
 Les branchements conditionnelles : if, elif,
else
Exemple :

a = 200
b = 33
if b>a:
print(‘b est plus grand que a’)
elif a==b:
print(‘a,b sont égaux’)
else:
print(‘a est plus grand que b’)
 Les boucles for inconditionnelles
Il est souvent très important de répéter l’exécution d’un bloc
d’instructions python un certain nombre de fois prédéfini
L’instruction for permet cela.

Syntaxe :
for variable in range(a,b,c): #pas d’espace avant le :
bloc d’instructions à répéter #attention à bien tabuler les
#instructions à répéter
range(a,b,c) désigne un intervalle [a,b[ d’entier commençant par a se
terminant en b (exclu) par pas de c.
Exemple :
for i in range(0,10,2): 
print(i)
 Les boucles for inconditionnelles
Exemple :
for i in range(10):
print(‘3 *’ , i , ’=’ , 3*i)
 Les boucles for inconditionnelles
Il est également possible de définir des boucles for sur des
variables dictionnaires. Pour cela on utilisera la méthode items() sur
un objet dictionnaire
mon_dico = {"pioches": 3 , "scies": "hors stock", "rateau": 12}
for clef,valeur in mon_dico.items():
print("l’élement de cléf",clef, "vaut",valeur)
 Boucles for pour le calcul
Associés à des algorithmes il est souvent demandé de calculer des
sommes, des produits ou des combinaisons de sommes et produits
i=N i=N j=K i=N

s N =∑ f (x i ) p N =∏ f (x i ) e N =∏ ∑ f j ( x i )
i=1 i=1 j=1 i=1

Les x i sont les éléments d’un vecteur x np.array par exemple

i=N

Exemple : s N =∑ x 2i
i=1

L’idée est calculer le résultat y de façon récursive

i=N i=N i=N i=N
s N =∑ f (x i )=f ( x 1)+ ∑ f ( x i )=s1 + ∑ f ( x i )=s2 + ∑ f ( x i )=... .
i=1 i=2 i=2 i=3

s N =s N −1 + f ( x N ) s 0=0.0
 Boucles for pour le calcul
Il faudra donc pour utiliser une boucle for en pensant bien à
initialiser s 0=0 ou p 0 =1
i=N

Exemple (suite) : s N =∑ x i
2

i=1

somme = 0.0 #TRES IMPORTANT d’initialiser avant la boucle

for i in range(N):
somme = somme + x[0,i]*x[0,i]

si si−1 2
f ( x i )=x i
 Boucles for pour le calcul
Même relation de récurrence

p N = p N−1∗f ( x N ) p 0 =1.0
i=N 1
Exemple : p N =∏ x i
i

i=1

produit = 1.0 #TRES IMPORTANT d’initialiser avant la boucle

for i in range(N):
produit = produit * np.power( x[0,i] , (1.0/i) )
 Les boucles while
Avec les boucles while, le bloc d’instruction est répété dans que la
condition du while reste vraie
Syntaxe :

i = valeur initiale # NE PAS OUBLIER D’INITIALISER le compteur

# avec le while
while (condition avec i):
bloc d’instructions à répéter
mise à jour de la condition
 Les boucles while
Exemple : affiche les éléments d’un vecteur x
i=0
while (i < N): #tant que i est inférieur à N, on boucle
print( x([0,i]) )
i=i+1
On peut également sortir d’une boucle while (ou for) avec
l’instruction break
while (True): #ici avec True, c’est une boucle infinie !!! attention
n = int(input(‘donnez un entier > 0 : ‘)) #permet la saisie au clavier
print(‘vous avez saisi ‘,n)
if (n > 0):
break #on sort de la boucle while (pour afficher le print
#final)
print(‘réponse correcte’)
 Un petit exercice orienté statistique
Générer 500 échantillons gaussiens (de moyennes m=2 et de
variance s=9) x i ∼N (2,9) puis calculer la moyenne arithmétique de
ces échantillons à l’aide d’une boucle
m=2
s=9
N = 500
x= m + np.sqrt(s)*np.random.randn(N , 1) #génération des données
m_exp = 0.0
for i in range(N):
m_exp = m_exp + x[i,0]
m_exp = m_exp/N
print(‘la moyenne théorique vaut’ , m, ‘la moyenne empirique vaut’ ,
m_exp)
print(x.mean()) #calculée avec les fonctions de numpy
 Python : fonctions
● En mathématique lorsque l’on écrit y=f(x), x représente l’entrée que
l’on doit connaître, f le nom de la fonction qui va prendre la valeur de
l’entrée x pour la transformer puis mettre le résultat du calcul dans
la variable y
● Dans un cadre multivarié, lorsque l’on a besoin de plusieurs entrées
pour obtenir y, on a y=g(x1,x2,…,xn)
● Enfin dans un cadre plus général, on peut avoir plusieurs sorties et
plusieurs entrées pour obtenir y1,y2,...yp=h(x1,x2,…,xn)

● Python permets de définir des fonctions sous la forme générale

y1,y2,...yp=h(x1,x2,…,xn)
 Python : fonctions
● Le formalisme des fonctions est définie de la façon suivante :
def nom_fonction(x1,x2,…,xn):
début code python
…..
fin code python
return y1, y2,…,yp
 Python : fonctions
● Si les fonctions sont écrites dans un fichier malib.py alors pour
réutiliser ces fonctions dans un fichier python il faudra utiliser un
import