Elements de programmation Printemps 18-19

Séance 1 – Généralités sur Python

Un langage informatique a :

• Une syntaxe : règles de constitution de phrases correctes du langage.

• Une sémantique : règles d’interprétations des phrases du langage par l’ordinateur, l’effet produit.

Pour savoir manipuler Python, on va devoir maitriser :

• Les mots de vocabulaires : variables et mots réservés

• La structure de phrase : modèles de syntaxe valides
• La structure de l’histoire : construire un programme dans un but

On a deux modes de travail, l’interactif et le script. Dans

l’interactif, Python va seulement nous répondre une ligne à la
fois. C’est comparable à une discussion. Avec un script on va
pouvoir faire plusieurs lignes. Le programme utilisé pour cela est
IDLE. Python va nous répondre à tous à la fin.

Il est souvent difficile de retracer ce que l’on a fait dans Python,

c’est pour ceci que l’on va utiliser notebooks. On va les retrouver
sur la plateforme jupyter de la HEC : isi-jupyterhub.unil.ch. On va également trouver les TP sur ce site. Les étapes
d’un TP sont :

On peut rendre un TP (submit) autant de

fois que l’on veut, mais seule la dernière
version sera corrigée.

La syntaxe de python veut que les nombres

peuvent être directement écrit tandis que
les chaines de caractères doivent être écrit
entre deux apostrophes ou deux guillemets. Il y a un certain nombre de mots réservés que l’on ne peut pas utiliser les
mots réservés :

False, class, return, is, finally, None, if, for, lambda, continue, True, def, from, while, nonlocal, and, del, global, not,
with, as, elif, try, or, yield, assert, else, import, pass, break, except, in, raise.

Les variables ont seulement une seule valeur a la fois, une fois qu’elle est changée, elle est oubliée. Il existe certaines
règles pour les noms de variables dans Python :

• Doit commencer par une lettre ou un trait de soulignement (_)

• Doit être composé de lettres, de chiffres et de traits de soulignement
• Sensible aux majuscules et minuscules

1
Elements de programmation Printemps 18-19

Opérateur Opération

+ Addition

- Soustraction

* Multiplication

/ Division

** Puissance

% Reste (de la
division entière)
Il existe les nombre « integer » (entier) et « Float » (avec décimales). On peut passer d’un nombre integer a float et
vice-versa en utilisant les commandes « class’’ » et « type() » ou « int() » et « float() ».

Séance 2 – Sémantique de Base

Une déclaration conditionnelle est symbolisée par 𝑝 → 𝑞 où p est une hypothèse, q une conclusion et la flèche une
instruction conditionnelle. Les étapes et les commandes sont comme suit :

Python Signification
< Inférieur à
<= Inférieur ou égal à
== Égal à
>= Plus grand ou égal à
> Plus grand que
!= Inégal
= Affectation

Ces commandes sont du type booléennes (expressions logiques), elles vont donc répondre en Vrai/Faux ou Oui/Non.

L’indentation est importante pour créer des « blocs » dans notre code et est nécessaire dans certaines situations. Cela
rend le code également beaucoup plus facile à lire.

On va également utiliser les structures conditionnelles suivantes :

• If : permet d’ajouter une condition.

• Else : ne s’applique que lorsque la condition if est fausse.
• Elif : ne s’applique que lorsque la condition if est fausse et
permet d’ajouter une autre condition. Il s’agit d’une sorte de
condition de deuxième ordre.
• Try/Except que l’on utilise pour anticiper une erreur de code.
Python va essayer le code avec try et s’il marche, except est
ignoré, mais s’il ne fonctionne pas, c’est l’except qui va
s’appliquer.

2
Elements de programmation Printemps 18-19

En Python, une fonction est un code réutilisable auquel on donne un nom. On va définir
une fonction en utilisant le mot réservé « def ». Lorsque nous voulons utiliser la
fonction, on va simplement utiliser son nom. La syntaxe pour en créer une est comme
suit :

Les boucles sont beaucoup utilisées. On les utilise pour les tâches répétitives. On va utiliser le mot réservé « while »
pour en créer. L’instruction « break » arrête la boucle en cours et passe à l’instruction qui est après la boucle.
L’instruction « continue » met fin à l’itération en cours et passe au début de la boucle et lance l’itération suivante. Les
boucles indéfinies sont celle qui continue jusqu’à ce qu’une condition logique soit réalisée, tandis que les boucles
définies s’exécutent un nombre exact de fois.

Séance 3 – Types de Données

Avec Python, on sait qu’une chaine de caractères (String Data Type) est une
séquence de caractères avec des guillemets. Python va évaluer s’il est possible
des lire ces chaines en nombre. Si c’est possibles et qu’on veut faire des
opérations avec ces nombres, il faut d’abord les faires passer d’une chaine en un
entier en utilisant « int() ». Nous pouvons obtenir n’importe quel caractère dans
une chaine en utilisant un index spécifié (0, 1, …) entre crochets. Pour savoir
quelle longueur la chaine de caractère a, on va utiliser la fonction « len() ». Il y a
une autre fonction très importante qui nous sert prendre en compte seulement
une tranche d’une chaine de caractère :

Comme vu précédemment, on peut tout simplement mettre des chaines de caractères ensembles. C’est la
concaténation de chaines. On peut également utiliser « in » pour savoir si une chaine est présente dans une autre
chaine de caractère. On va recevoir une réponse « true » ou « false ». La fonction « replace » va remplacer une chaine
de caractère (ou une partie de celle-ci) définie par une autre. Voici une liste de fonctions :

Pour convertir un nombre en chaine de caractères : « str() ».

Une collection nous permet de mettre plusieurs valeurs dans une seule. On peut
donc transporter toutes les valeurs en un paquet (ex : friends = [‘Joseph’, ‘Glenn’,
‘Sally’]). Les listes sont entourées de crochets et les éléments sont séparés par des
virgules. Les listes sont mutables, on peut donc changer un élément d’une liste en
utilisant l’opérateur index. Ceci était impossible avec les chaines qui sont
immutables. Nous pouvons concaténer des listes, comme avec les chaines de
caractères (+). On peut demander à une liste de se trier elle-même avec « sort() ».
La fonction « split » coupe les chaines de caractères aux espaces et en fait une liste
avec les mots qui en ressortent.

3
Elements de programmation Printemps 18-19

Les dictionnaires sont la collection de données la plus puissante de

Python. Ils nous permettent d’effectuer rapidement des opérations de
type base de données en Python. Les listent indexent leurs valeurs en
fonction de la position dans la liste, mais les dictionnaires sont comme
des sacs, il n’y a pas d’ordre. Nous indexons donc les valeurs que nous
mettons dans le dictionnaire avec une « balise de recherche » : une clé.

Séance 4 – Input/Output
Les tuples sont comme des listes et ont une fonction similaire. Néanmoins, dès qu’ils sont créés, on ne peut plus les
modifier (contrairement aux listes). Les éléments de ceux-ci sont également indexés à partir de 0. Rappel : les listes
ont des crochets carrés, tandis que les tuples ont des parenthèses. On peut faire les opérations suivantes sur les
tuples :

Si on un dictionnaire, avec logiquement de clés et des valeurs, et que l’on utilise les fonctions suivantes :

• d.keys() → retourne toutes les clés : [‘csev’ , ‘cwen’])

• d.values() → retourne toutes les valeurs : [2 , 4]
• d.items() → retourne les pairs (clé, valeur) : [(‘csev’ , 2) , (‘cwen’ , 4)]

Les tuples ne peuvent pas être triés (parce qu’ils ne sont pas modifiables), mais on peut trier les listes de tuples avec
la fonction sorted().

En résumé :

Les files sont là pour faire le lien entre python et les données qui sont souvent sauvegardées dans une mémoire
secondaire (de type Excel, etc.). Avant que nous puissions lire le contenu du fichier, nous devons dire à Python quel
fichier nous allons utiliser et ce que nous allons faire avec le ficher. La fonction qui fait cela est open(), qui retourne un
« handle de fichier », une variable utilisée pour effectuer des opérations sur le fichier. Ces opérations sont similaires à
« Fichier → ouvrir → etc. ». \n est utilisé pour passer à la ligne suivante et il compte comme un caractère. Ceci nous
permet d’itérer pour chaque ligne en utilisant « for line in … : » (line, pas \n).

Les exceptions sont là pour que le programme n’indique pas

une erreur à chaque petite situation exceptionnelle, mais se
poursuive. On va utiliser les fonctions « try » et « except ». Il va
donc d’abord tenter de faire la ligne qui suit le try et si elle ne
marche pas, il va exécuter celle qui suit le except.
4
Elements de programmation Printemps 18-19

Si l’on veut délibérément créer une erreur si une certaine

chose arrive, on utilise « raise » :

Séance 5 – Collections de Données

Numpy : Ce sont des tableaux du style de vecteurs pour
stocker des données. Les calcules sont plus rapides qu’avec
des listes, car on peut facilement effectuer des opérations
sur les matrices. Il y a quelques fonctions de base :

• M.ndim → nombre de dimensions

• M.shape → géométrie de la matrice (nxm)
• M.size → nombre d’éléments
• M.reshape(n, m) → change la géométrie de la matrice en nxm)
• Np.arange(start, stop, step) → génère des valeurs vectorielles
• Np.linespace(start, stop, nb_values) → génère des valeurs vectorielles
• M.plot → fait un graphique
• Random.rand(nb_values) → génère des valeurs aléatoires uniformément sur [0, 1[
• Random.randn(nb_values) → génère des valeurs aléatoires selon une loi normale standard
• M.max/min/sum/prod() → calcule respectivement le max, le min, la somme cumulée ou le produit cumulé
• M.mean/median/var/std() → calcule respectivement la moyenne, la médiane, la variance ou l’écart type

Python va faire lui-même l’addition, la soustraction, la

multiplication (pas le produit scalaire) et la division de matrice
(élément par élément) :

Pandas : C’est un moyen de stocker des données en les

référençant avec des clés, comme des dictionnaires. En
d’autres termes, c’est une bibliothèque open source
Python fournissant des‘DataFrames’, une structure de
données représentant des observations (lignes), chacune
consistant en un certain nombre d'observations ou de
mesures (colonnes). Les séries de données sont comme
des vecteurs avec des index. La fonction pd.read_csv() va
prendre les données qui sont dans un fichier de type Excel
et le mettre dans un DataFrame. Voir dans les slides comment trancher (projeter) un DataFrame. On peut également
ajouter une colonne supplémentaire à un DataFrame existant.

5
Elements de programmation Printemps 18-19

Séance 6 – Classes et Objets

Pour l’instant, on a manipulé différents types de valeurs ; des valeurs élémentaires (nombre, chaine de caractère,
valeur logique), des listes, des dictionnaires et des tuples. Puis on a vu numpy et pandas. Python nous permet de
construire et définir toutes sortes de types de données. Cela se fait en déclarant d’abord une classe de valeur avec le
mot réservé class. Puis on va créer des valeurs qu’on appelle objets de cette classe.

On peut faire des attributions

qui fonctionnent comme les
clés étrangères/inner join vu
dans SQL. On parlera
d’imbrication, qui est une
référence entre objets.

La Classe comme constructeur d’objets : Le constructeur [__init__()] a le

rôle de fixer, au moment de la création de tout objet de cette classe, la liste
et la valeur des attributs initiaux. Avec le constructeur, on peut être sûr que
chaque élément de cette classe aura tous les attributs (on peut donc
compter sur le fait que chacun a un nom, un prénom et un sport).

Les Méthodes sont des fonctions attachées à la définition de la classe. Ceci se fait en rajoutant une définition en
dessous du premier bloc de la classe. Ceci est utile lorsque l’on a des attributs qui sont dépendant des autres, qui
varient en fonction de ceux-ci (ex : l’aire d’un rectangle dépend de sa hauteur et de sa largeur).

6
Elements de programmation Printemps 18-19

Séance 7 – Régression Linéaire

Une régression linéaire est une tentative de trouver une relation linéaire entre n
ensemble de variables [x] d’input et une variable [y] d’output. On va tenter de trouver
une combinaison linéaire [C] suivante tel que l’erreur [ϵ] soit la plus petite depuis un
échantillon : 𝑦 = 𝐶 ∗ 𝑋 + 𝜖. La méthode des moindres carrés : 𝑆 = ∑ 𝜖𝑖2 , puis il faudra
utiliser les conditions de premier ordre [CPO] en faisant des dérivées partielles par
rapport aux variables pour trouver les estimateurs de celles-ci.

Python va procéder à une régression linéaire en étapes :

1. Calculer la moyenne et la variance : [.mean()]

∑(𝑥𝑖 − 𝑥̅ )2
𝑣=
𝑛−1
2. Calculer la covariance entre les deux variables :
∑(𝑥𝑖 − 𝑥̅ )(𝑦𝑖 − 𝑦̅)
𝑐𝑜𝑣𝑥,𝑦 =
𝑛−1
3. Estimer les coefficients a et b :
𝑐𝑜𝑣𝑎𝑟𝑖𝑎𝑛𝑐𝑒(𝑥, 𝑦) ∑(𝑥𝑖 − 𝑥̅ )(𝑦𝑖 − 𝑦̅)
𝑎 𝑜𝑢 𝑏 = =
𝑣𝑎𝑟𝑖𝑎𝑛𝑐𝑒(𝑥, 𝑦) ∑(𝑥𝑖 − 𝑥̅ )2
4. Prédiction de valeurs :
𝑦̂ = 𝑎𝑥 + 𝑏
5. Qualité des prédictions :
∑(𝑦̂ − 𝑦)2
𝑆𝑢 = √
𝑛−2
6. Application à une série temporelle : [.sort_index()]
7. Régression linéaire par monceaux : indicer

Séance 8 – Trier des données

On peut trier des objets sur un critère ou une propriété comparable. Comme on a vu, on peut utiliser la fonction .sort()
ou .sorted() pour trier par exemple. La différence entre les deux est que [sorted] crée une nouvelle liste, tandis que
[sort] change la liste de départ. Si l’on souhaite trier un grand nombre de données, cela peut prendre beaucoup de
temps et dans ce cas, il peut être utile de mesurer celui-ci. On utilisera la commande [%time] au début de la ligne.
Avec cela, on peut donc comparer la taille de deux listes.

On va maintenant s’intéresser à l’algorithme qui se trouve derrière le tri. Enfaite, Python va lire les données et
permuter à chaque fois deux élément consécutifs s’ils ne sont pas de le bon ordre (l’un par rapport à l’autre). Une fois
que ceci est fait, Python va passer aux valeurs suivantes et recommencer une fois qu’il arrive à la fin. Tout cela se
répète jusqu’à ce qu’il arrive à examiner toute la liste sans devoir faire de permutations. Ça s’appelle le tri à bulle et
se traduit en langage Python de la façon suivante :

7
Elements de programmation Printemps 18-19

La complexité d’un algorithme permet de calculer le nombre de ressources nécessaire à son exécution. Plus les
ressources nécessaires sont élevées, plus la complexité est importante. La complexité est exprimée en fonction d’un
paramètre [n] et est calculé par : 𝑂(𝑛3 )

Une autre façon de trier est le tri par sélection, dans lequel python va créer une nouvelle liste en retirant d’abord la
plus petite valeur de l’ancienne lise, et refaire ce processus jusqu’à ce que cette dernière soit vide. On pourra s’aider
de la fonction min(). La complexité est donnée par 𝑂(𝑛2 ).

Au tri par insertion, on va prendre les éléments de l’ancienne liste comme ils viennent, mais on les ajoute à la nouvelle
en cherchant à chaque fois le bon endroit pour les insérer.

Il existe une façon de trier simple et très efficace, c’est le « Quicksort ». On va d’abord chercher de trier
approximativement et répéter ce processus une multitude de fois, ce qui résulter en un tri parfait.

Séance 9 – Visualisation de données

Il est important d’avoir des bonnes méthodes pour visualiser les données que l’on a traité. En faisant plusieurs bonnes
représentations, on pourra encore mieux analyser les données. La librairies Matpotlib, comme pandas ou numpy, va
nous aider à faire des visualisations. [plyplot] est une collection de commande qui font que matplotlib fonctionne
comme MATLAB. On a un certain nombre de commandes de base.

• plt.plot() crée une ligne • plt.xlabel() donne un nom à l’axe x

• plt.scatter() crée un nuage de points • plt.ylabel() donne un nom à l’axe y
• plt.bar() crée un histogramme • plt.tick_params() modifie la graduation sur les
• plt.boxplot() crée un boxplot axes
• plt.pie() crée un pie chart • plt.xtricks() permet de définir l’ordre sur
• plt.show() montre le graphique l’abscisse
• plt.title() donne un titre au graphique
Il existe également un certain nombre de commandes que l’on utilise à l’intérieur de celles qui sont au-dessus.

• fontsize détermine la taille de la police • color détermine la couleur des lignes

• linewidth change l’épaisseur de la ligne • cmap=plt.cm détermine la couleur des lignes
• labelsize change la taille de la police de avec un dégradé
la graduation

Séance 10 – Accès à une base de données, contenu interactif

Comme au premier semestre, on va s’intéresser aux relations dans les bases de données. Or, cette fois on va travailler
avec Python et pas avec SQL. On va utiliser des fonctions Python qui s’occupent d’effectuer tout le travail auprès de
l’application SQL Explorer. On les importera de la façon suivante :

from info1ereDB import get_raw_data, read_SQL

intéressons-nous d’abord à la fonction get_raw_data(dbname, sql)

• dbname : le nom de la base de données à interroger sur le serveur.

• sql : la requête à effectuer sur cette base de données. C’est véritablement une requête comme on les a vues au
premier semestre (Select, From, etc.).
• Une fois que l’on a exécuté cette fonction, on va devoir traiter la liste avant de pouvoir la lire correctement. Les
données qui sortent sont dans un dictionnaire contenant trois items ; content (données sous forme de liste),

8
Elements de programmation Printemps 18-19

header (titre des colonnes) et numrows (#lignes). On va passer les différents arguments à la méthode format, ce
qui veut dire qu’ils sont placés ans l’ordre entre les {} présents dans la chaîne de caractère que l’on donne.

• On peut également afficher le contenu obtenu dans un DataFrame de Pandas avec la fonction suivante : data_df
= pd.DataFrame(data['content'], columns=data['header']).

Les widgets sont des objets Python qui ont une représentation visuelle dans le
navigateur, souvent sous forme de contrôle comme un curseur, une zone de texte, des
boutons à cliquer, etc. On peut les utiliser pour créer des interfaces graphiques
interactifs. En voici une : w = widgets.IntSlider(), la valeur crée [w] peut être changée à
tout moment et la variable attribuée à celle-ci se modifie directement. Il a les propriétés
keys, description et disabled.

Interact génère un interface utilisateur pour contrôler les arguments d’une fonction.
Chaque fois que l’utilisateur touche le widget, interact va utiliser la fonction
automatiquement.

Séance 11 – Récursivité et arbre binaires

Une fonction récursive est une fonction [f] dont le calcul s’appuie
sur un schéma de récurrence. Donc dans ces fonctions on va faire
appel à une valeur qui est sortie d’une fonction précédente [f(xk)]
pour définir [f(xi)], donc k < i. Il nous faut donc impérativement une
valeur x0, qui ne fait pas recours à une fonction précédente, pour
commencer notre récurrence. Dans la récursivité, on n’utilise pas
les boucles, mais on va réutiliser la définition que l’on est en train
de construire à l’intérieur d’elle-même.

Toutes les variables et paramètres d’une fonction sont stockées sur un espace appelé la pile d’exécution. À chaque
appel d’une fonction, on ajoute sur la pile un espace pour stocker les valeurs de tous les paramètres et toutes les
variables locales de [f]. Quand on quitte la fonction (avec le return), on enlève cet espace du sommet de la pile, et
l’exécution se poursuit avec les variables et paramètres qui sont en dessous. Elles s’enlèvent, parce que l’on n’a plus
besoins de ces valeurs vu qu’elles sont simplement les valeurs internes/intermédiaires de la fonction.

Un arbre binaire est une structure de données qui peut se représenter sous la
forme d’une hiérarchie dont chaque élément est appelé nœud, le nœud initial
est appelé racine. Chaque élément possède au plus deux éléments filaus au
niveau inférieur, habituellement appelés gauche et droit. La distance entre la
feuille la plus éloignée et la racine est appelée la hauteur de l’arbre. Le niveau
d’un nœud est appelé profondeur. Lorsque l’on insère un nœud, on part de la racine, on choisit gauche/droite à la
racine et à chaque nœud qui vient après jusqu’à ce qu’on trouve une place libre et que l’on insère le nœud.

Une fois l'arbre binaire de recherche créé, nous pouvons l'imprimer avec la méthode print_tree. Comme mentionné
précédemment : un arbre binaire de recherche est un arbre binaire ordonné. Il doit donc y avoir un moyen simple de
l'imprimer dans l'ordre puisqu'il est ordonné. Tout comme la construction de l'arbre binaire de recherche est récursive,
l'impression de son contenu l'est également. Plus d’intuition ici.

9
Elements de programmation Printemps 18-19

[self.data] sont les valeurs

qui sont déjà dans l’arbre
binaire et [data] est la
nouvelle valeur que l’on
cherche à insérer.
[self.right] et [self.left]
désignent respectivement
les branches droites et
gauches.

Pour recherche un nœud

dans un arbre binaire de
recherche, on va utiliser
[search(root, key)]. On
cherche une valeur [key]
dans un arbre [root]. Si
[root] est vide (pas trouvé)
c’est terminé.

10