Python Inter B3 - 1

Python Avancé : pour la Data-science, l’IA, le machine et le Deep Learning
Enseignant : M. EBOA Michel Anicet

Enseignant – Chercheur, LGIA - ENSET DOUALA
eboamichelanicet@gmail.com
Tel / WhatsApp: +237 693 759 733
Pour valider le module :

• CC : Présence, TP et TPE
• Un examen de fin de semestre
Code B3014
Volume Horaire 32 h
Crédits 2
Niveau 3
Semestre 1
Pré-requis Bases du C
Plan du cours :
1 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA


Chapitre 1 : Variables et fonctions

Introduction
Pour faire du machine Learning avec python, il faut bien sur installer python. Pour cela nous pouvons :
- Installer Visual studio code et y installer le distribuable python
- Installer Anaconda python
a) Installer Python Anaconda : le meilleur outil de Machine Learning
Il existe deux façons d’installer les outils de Machine Learning sur votre ordinateur : La bonne et la
mauvaise. En installant Anaconda, vous vous épargnez des heures de souffrance à taper des commandes
en mode ‘geek’ à installer les packages, librairies et éditeur de texte indispensables pour faire du Machine
Learning. Pourquoi faire simple quand on peut faire compliquer ?
Anaconda contient tous les outils et librairies dont vous avez besoin pour faire du Machine Learning :
Numpy, Matplotlib, Sklearn, etc. Commencez par télécharger puis installer Anaconda depuis le site
officiel : https://www.anaconda.com/distribution/#download-section
Note: Téléchargez toujours la version la plus récente de Python
Une fois Anaconda installé, vous pouvez lancer l’application Jupyter Notebook depuis votre barre de
recherche Windows/Mac/Linux.
b) Utilisation de Jupyter Notebook

Pour vos projets Jupyter Notebook est une application Web qui permet de créer et de partager des codes
Python.
Note : C’est une application Web, mais il n’est pas nécessaire d’avoir une connexion Internet pour vous
servir de Jupyter. Aussi, vos données/codes ne sont à aucun moment stockés sur Internet (ce n’est pas du
Cloud).
Lorsque vous démarrez Jupyter, il est possible que 2 fenêtres s’ouvrent, auquel cas ne vous occupez pas
de la fenêtre noire (la console) et surtout ne la fermez pas (ceci déconnecterait Jupyter de votre disque
dur).

La fenêtre principale de Jupyter n’est ni plus ni moins qu’un explorateur de fichier relié à votre disque
dur, vous pouvez ouvrir tous vos fichiers, Dataset, codes, etc. depuis cette fenêtre. Cliquez sur le bouton
‘New’ situé en haut à droite de cette fenêtre pour commencer à écrire un nouveau programme (puis
cliquez sur Python 3). La fenêtre suivante s’affiche alors : Vous êtes prêts à coder !
I.1. La programmation : une nouvelle vision du monde

En programmation, on choisit d’adopter une certaine vision du monde dans lequel nous vivons. On peut
considérer que le monde peut être modélisé à partir de 2 concepts :
• Des objets
• Des actions, qui modifient l’état des objets. Regardez autour de vous. Vous êtes entourés d’objets.
En réalisant une action, des objets peuvent apparaitre, disparaitre, se combiner, se transformer, etc.
D’ailleurs, quand nous nous exprimons, il est nécessaire et suffisant de dire un nom (objet) et un verbe
(action) pour faire une phrase. Exemple : « Le chien boit. » ou bien « Le chien boit de l’eau. »
Chien : Objet
Boit : Action
Eau : Objet, qui diminue avec l’action boire.
En programmation, ces deux notions prennent le nom de variable et de fonction, les fonctions
transformant la valeur des variables.

Le plus souvent, il n’est pas nécessaire de développer ses propres fonctions car celles-ci sont déjà
développées dans des librairies open source. Par exemple, la librairie Sklearn contient toutes les
fonctions mathématiques et l’algorithme de Gradient Descent que nous verrons plus tard !
En pratique, il est donc inutile d’écrire la moindre équation mathématique. Génial, non ?! Au fil des
exemples dans ce cours, vous allez naturellement apprendre comment programmer en Python
spécialement pour le Machine Learning. Mon but est de vous épargner une avalanche de détails inutiles,
pour vous montrer les fonctions essentielles et utiles qui vous aideront réellement à résoudre des
problèmes dans votre travail après la lecture de ce cours.
I.2. Les commentaires

Dans tout langage de programmation, il est possible d’écrire des commentaires. Un commentaire n’est
pas lu par la machine et vous pouvez donc y écrire ce que vous voulez pour documenter votre code. Dans
Python, il suffit de précéder votre code du symbole « # » pour le transformer en commentaire.
# Ceci est un commentaire
Il est parfois nécessaire de faire un bloc de code en commentaire, le plus simple c’est de créer une zone de
commentaire sur plusieurs lignes. Pour le faire, il suffit d’encadrer votre code des triples guillemets
«"""» ou sectionner le bloc de code et taper la commande shift + Alt + a pour le transformer en
commentaire.
"""Ceci
Est
Un
Commentaire
Sur plusieurs lignes"""
I.3. Les variables

Pour définir une variable dans Jupyter, il suffit de lui donner un nom et de lui assigner une valeur. Par
exemple, vous pouvez choisir de créer la variable « vitesse » et de lui assigner la valeur 90.
Note : les accents et chiffres sont à bannir pour le nom d’une variable ! Vous pouvez effectuer des
opérations mathématiques entre les
variables numériques. Une fois le code
écrit, appuyez sur CTRL + Entrée pour
exécuter votre code. Le résultat est affiché
et une nouvelle cellule s’ouvre en bas
pour continuer à écrire du code.
Il existe de nombreux types de variables : les variables numériques, les listes, les matrices, les chaines de
caractères… on peut les regrouper en 4 grands types de variables
- int (nombre entier)
- float (nombre décimal)
- string (chaine de caractères)

- bool (booléen)
x = 3# type int
y = 2.5# type float
prenom = 'Pierre'# type string
z = True # type Bool
On peut également déclarer et affecter les valeurs à plusieurs variables sur la même ligne :
x, y = 3, 2.5
Résultats :
x = 3
y = 2.5
a.1) Opérations arithmétiques

print('x + y =', x + y)
print('x - y =', x - y)
print('x / y =', x / y)
print('x // y =', x // y) # division entière (très utile pour les tableaux Numpy)
print('x * y =', x * y)
print('x ^ y =', x ** y) # x puissance y
Résultats :
x + y = 5.5
x - y = 0.5
x / y = 1.2
x // y = 1.0
x * y = 7.5
x ^ y = 15.588457268119896
Note : dans Spyder ou sur Visual studio code l’instruction print est obligatoire pour afficher le résultat
des opérations, par contre sur jupyter il suffit d’écrire le code et exécuter.
a.2) Opérations de comparaison

print('égalité :', x == y)
print('inégalité :', x != y)
print('inférieur ou égal :', x <= y)
print('supérieur ou égal :', x >= y)
Résultats :
égalité : False
inégalité : True
inférieur ou égal : False
supérieur ou égal : True
a.3) Opérations Logiques

print('ET :', False and True)
print('OU :', False or True)
print('OU exclusif :', False ^ True)
Résultats :
ET : False
OU : True
OU exclusif : True
Note: - Les opérations de comparaison et de logique utilisées ensemble permettent de construire des
structures algorithmiques de bases (if/esle, while, ...)
-Les operateurs logiques répondent aux structures des tables de vérité : ET, OU, Non, Ou-
Exclusif.

I.4. Les fonctions

Comme énoncé plus haut, Python contient déjà de nombreuses librairies remplies de fonctions très utiles
et il n’est pas nécessaire de coder ses propres fonctions pour faire du Machine Learning. Cependant, je
vais tout de même vous montrer la structure d’une fonction dans Python, pour votre connaissance
personnelle.
a.1) Fonction lambda

Une fonction anonyme est une fonction créée avec lambda. Ce type de fonction est basique et est utile
pour être intégrée au milieu de structures de contrôles ou bien d'autres fonctions mais principalement pour
des opérations mathématiques. On l'utilise rarement.
# Exemple d'une fonction f(x) = x^2
f = lambda x : x**2
print(f(5))
# Exemple d'une fonction g(x, y) = x^2 - y^2

g = lambda x, y : x**2 - y**2
print(g(4, 2))
a.2) Fonction def

Rappelez-vous qu’une fonction transforme le
plus souvent une entrée en sortie :
Pour créer une fonction dans Python, il faut commencer par écrire « def » en début de ligne, puis donner
un nom à la fonction, écrire les inputs entre parenthèse, et finir la ligne par un « : ». Les lignes suivantes
font partie de la fonction, vous pouvez y écrire des commentaires, créés de nouvelles variables, faire des
opérations mathématiques etc. La fonction s’arrête à la ligne « return » qui indique quelle sortie la
fonction doit produire. Une fois la fonction créée, il est possible de l’utiliser à l’infini !
# une fonction à un nom, prend des entrées (arguments) et les transforme pour retourner un résultat
defnom_de_la_fonction(argument_1, argument_2):
restultat = argument_1 + argument_2
return restultat
nom_de_la_fonction(3, 2) #appel de la fonction
Exemples :

# Exemple concret : fonction qui calcul l'énergie potentielle d'un corps
def e_potentielle(masse, hauteur, g=9.81):

energie = masse * hauteur * g
return energie
# Ici g a une valeur par défaut donc nous ne sommes pas oblige de lui donner une autre valeur
e_potentielle(masse=10, hauteur=10)
Note : rappeler les noms des keywords de nos paramètres avant de passer les valeurs n’est pas
obligatoire, mais nécessaire pour modifier par exemple la valeur par de défaut d’un paramètre.
# Exemple concret : fonction qui calcul l'énergie potentielle d'un corps
def e_potentielle(masse, hauteur, g=9.81):

energie = masse * hauteur * g
return energie
# Ici g a une valeur par défaut, mais nous pouvons modifier la valeur pour cette appel
e_potentielle(masse=10, hauteur=10, g=5)
a.3) Exercice : fonction e_potentielle

Modifiez la fonction e_potentielle définie plus haut pour retourner une valeur indiquant si l'énergie
calculée est supérieure ou inférieur a une energie_limite passée en tant que 4eme argument !
I.5. Les 4 librairies à maîtriser pour le Machine Learning

Pour importer une librairie dans Python, rien de plus simple. Il suffit d’écrire le nom de la librairie
précédé de « import » en tête de votre programme. Il est également possible d’importer certaines
fonctions de la librairie en écrivant from « librairie » import « alias ». Exemple :
Numpy est la librairie qui permet de créer et manipuler des

matrices simplement et avec efficacité. En Machine Learning, on
insère le plus souvent notre Dataset dans des
matrices. Ainsi le calcul matriciel représente l’essentiel du
Machine Learning. Il est important de le comprendre, mais les fonctions présentes dans Numpy font les
calculs matriciels à notre place… Magique !
Matplotlib est la librairie qui permet de visualiser nos

Datasets, nos fonctions, nos résultats sous forme de graphes,
courbes et nuages de points.
Pandas est une excellente librairie pour

importer vos tableaux Excel (et autres
formats) dans Python dans le but de tirer

des statistiques et de charger votre Dataset dans Sklearn.
Sklearn est la librairie qui contient toutes les fonctions de l’état de l’art
du Machine Learning. On y trouve les algorithmes les plus importants
ainsi que diverses fonctions de pré-processing.
Chapitre 2 : Structures de contrôle

Dans le monde de la programmation, il existe 3 principales structures de contrôle pour créer des
algorithmes.
- Les alternatives If / Else
- Les boucles For
- Les boucles While
II.1) Comparaisons
Avant de passer aux structures, nous abordons tout de suite les comparaisons. Python est capable
d’effectuer toute une série de comparaisons entre le contenu de différentes variables, telles que :
Syntaxe Python signification
== égal à
!= différent de
> Supérieur à
>= supérieur ou égal à
< Inférieur à
<= inférieur ou égal à
II.2) Alternatives If / Else :

Cette structure permet de tester une séquence d'alternatives. Si une condition est respectée, alors les
instructions qui la suivent sont exécutées et la structure de contrôle est stoppée, sinon la condition
suivante est testée. Exemple :
Def test_du_signe(valeur):
if valeur <0:
print('négatif')
elif valeur == 0:
print('nul')
else:
print('positif')
test_du_signe(-2) # appel de la fonction
Une condition est respectée si et seulement si elle correspond au résultat booléen True.

valeur = -2
print(valeur <0) # le résultat de cette comparaison est True
if valeur <0:
print('négatif')
Résultat :
True
Négatif
Cela permet de développer des algorithmes avec des mélanges d'opérations Logiques et d'opérations de
comparaisons. Par exemple : si il fait beau et qu'il faut chaud, alors j'irai me baigner
x = 3
y = -1
if (x>0) and (y>0):
print('x et y sont positifs')
else:
print('x et y ne sont pas tous les 2 positifs')
II.3) Boucle For

Une boucle for permet de créer des algorithmes itératifs (qui effectuent une certaine tache plusieurs fois
de suite). Pour ça, la boucle parcourt tous les éléments d'un objet dit itérable. Il peut s'agir d'une liste, d'un
dictionnaire, d'un range, d'un tableau Numpy, ou de bien d'autres objets...
a.1) La fonction range

# range(début, fin, pas) est une built-in fonction très utile de python qui retourne un itérable.
for i in range(0, 10):
print(i)
L’instruction range() fonctionne sur le modèle range([début,] fin[, pas]). Les arguments entre crochets
sont optionnels.
# On peut s'amuser à combiner cette boucle avec notre fonction de tout à l'heure.
for i in range(-10, 10, 2):
print(i)
test_du_signe(i)
a.2) La fonction len

L’instruction len() vous permet d e connaître la longueur d’une liste, ce qui parfois est bien pratique
lorsqu’on lit un fichier par exemple, et que l’on ne connaît pas a priori la longueur des lignes. Voici un
exemple d’utilisation :
animaux = ['girafe', 'tigre', 'singe', 'souris']
print (len(animaux)) #résultat : 4
print (len(range(10))) #résultat : 10
a.3) Parcours d’un liste

Imaginez que vous ayez une liste de quatre éléments dont vous voulez afficher les éléments les uns après
les autres. Dans l’état actuel de vos connaissances, il faudrait taper quelque chose du style :
animaux = ['girafe','tigre','singe','souris']
print(animaux[0])
print(animaux[1])
print(animaux[2])
print(animaux[3])

Si votre liste ne contient que quatre éléments, ceci est encore faisable mais imaginez qu’elle en contienne
100 voire 1000 ! Pour remédier à cela, il faut utiliser les boucles. Regardez l’exemple suivant :
for animal in animaux:
print (animal)
En fait, la variable animal va prendre successivement les différentes valeurs de la liste desanimaux à
chaque itération de la boucle. Notez bien les types de variable : animaux est une liste sur laquelle on itère,
et animal est une chaîne de caractère qui à chaque itération de la boucle prendra les valeurs successives de
la liste animaux (car les éléments de la liste sont des chaînes de caractère, mais on verra plus loin que cela
est valable pour n’importe quel type de variable).
Il est aussi possible d’utiliser une tranche d’une liste :
for animal in animaux[1:3]:
print (animal) #on va afficher le 1 et le 2e element de la liste
Nous allons maintenant parcourir cette liste, mais cette fois par une itération sur ses indices :
for i in range(4):
print(animaux[i])
La variable i prendra successivement les valeurs 0, 1, 2 et 3 et on accèdera à chaque élément de la liste

animaux par son indice (i.e. animaux[i]). Sur ces différentes méthodes de parcours de liste, quelle est la
plus efficace ? La méthode à utiliser pour parcourir avec une boucle for les éléments d’une liste est celle
qui réalise les itérations directement sur les éléments.
a.4) La fonction enumerate

Enfin, si vous avez besoin de l’indice d’un élément d’une liste et de l’élément lui-même, la fonction
enumerate() est pratique.
for i, ani in enumerate(animaux):
print (i, ani)# ou i contient l'indice et ani l’élément
II.4) Boucle While

Une autre alternative à l’instruction for couramment utilisée en informatique est la boucle while. Le
principe est simple. Une série d’instructions est exécutée tant qu’une condition d'exécution est valide,
vraie (tant que la condition est True).
x = 0
while x <10:
print(x)
x += 1# incrémente x de 1 (équivalent de x = x+1)
Une boucle while nécessite trois éléments pour fonctionner correctement :

- l’initialisation de la variable de test avant la boucle ;
- le test de la variable associé à l’instruction while ;
- l’incrémentation de la variable de test dans le corps de la boucle.

Faites bien attention aux tests et à l’incrémentation que vous utilisez car une erreur mène souvent à des
boucles infinies qui ne s’arrêtent pas. Vous pouvez néanmoins toujours stopper l’exécution d’un script
Python à l’aide de la combinaison de touches Ctrl-C.
II.5) Instructions break et continue

Ces deux instructions permettent de modifier le comportement d’une boucle (for ou while) avec un test.
L’instruction break stoppe la boucle.
For i in range(5):
if i>2:
break
print(i) # 0 1 2
L’instruction continue saute à l’itération suivante.

For i in range(5):
if i == 2:
continue
print(i) # 0 1 3 4
II.6) Exercice: Suite de Fibonacci.

La suite de Fibonacci est une suite mathématique qui porte le nom de Leonardo Fibonacci, un
mathématicien italien du XIIIe siècle. Initialement, cette suite a été utilisée pour décrire la croissance
d’une population de lapins mais elle est peut également être utilisée pour décrire certains motifs
géométriques retrouvés dans la nature (coquillages, fleurs de tournesol...).
Par définition, les deux premiers termes de la suite de Fibonacci sont 0 et 1. Ensuite, le terme au rang n
est la somme des nombres aux rangs n - 1 et n - 2. Par exemple, les 10 premiers termes de la suite de
Fibonacci sont 0, 1, 1, 2, 3, 5, 8, 13, 21, 34.
1. Écrivez un script qui construit la suite de Fibonacci puis l’affiche pour des nombre compris entre
0 et n.
Indice :
- Pour cet exercice vous aurez besoin d'une boucle While
- Vous pouvez imprimer cette suite jusqu'a atteindre un nombre n que vous aurez choisit
- dans python il est possible de mettre à jour 2 variables simultanément sur les mêmes lignes : a, b = b,
a+b
2. Refaire la fonction en utilisant les listes. Cette fois on aura une fonction qui retourne une liste qui
contient tous les éléments de la suite de Fibonacci.
3. Écrivez un script qui construit la liste des n premiers termes de la suite de Fibonacci puis
l’affiche.

Chapitre 3 : Structures de donnes : Listes, Tuples et Dictionnaire

Une structure de données est une variable capable de contenir plusieurs valeurs à la fois. Une structure de
données peut former une séquence si les valeurs qui la composent sont rangées dans un certains ordre.
C'est le cas des listes et des Tuples. A l'inverse un Dictionnaire ne forme pas une séquence.
III.1. Listes
Une liste est une structure de données qui contient une série de valeurs. Python autorise la construction de
liste contenant des valeurs de type différent (par exemple entier et chaîne de caractères), ce qui leur
confère une grande flexibilité. Une liste est déclarée par une série de valeurs (ne pas oublier les
guillemets, simples ou doubles, s’il s’agit de chaînes de caractères) séparées par des virgules, et le tout
encadré par des crochets. En voici quelques exemples :
tailles = [5, 2.5, 1.75, 0.15]
mixte = ['girafe', 5, 'souris', 0.15]
print(animaux)
print(tailles)
print(mixte)
a.1) Utilisation
Un des gros avantages d’une liste est que vous pouvez appeler ses éléments par leur position. Ce numéro
est appelé indice (ou index) de la liste.
Liste : ['girafe', 'tigre', 'singe', 'souris']
Indice : 0 1 2 3
Soyez très attentifs au fait que les indices d’une liste de n éléments commence à 0 et se termine à n-1.
Voyez l’exemple suivant :
print(animaux[0])
print(animaux[1])
print(animaux[2])
print(animaux[3])
print(animaux[4]) #Par conséquent, si on appelle l’élément d’indice 4 de notre liste, Python renverra un message
d’erreur :
a.2) Opération sur les listes

Tout comme les chaînes de caractères, les listes supportent l’opérateur + de concaténation, ainsi que
l’opérateur * pour la duplication :
ani1 = ['girafe','tigre']
ani2 = ['singe','souris']
ani3 = ani1 + ani2
print(ani3)
ani4 = ani1 * 3
print(ani4)
a.3) Indexing et Slicing : Indiçage négatif et tranches

Dans une séquence, chaque élément est rangé selon un index (le premier index étant l'index 0)
Pour accéder a un élément d'une liste ou d'un Tuple, on utilise une technique appelée Indexing
Pour accéder a plusieurs éléments d'une liste ou d'un Tuple, on utilise une technique appelée Slicing

villes = ['Paris', 'Berlin', 'Londres', 'Bruxelles']

# INDEXING
print('séquence complète:', villes)
print('index 0:', villes[0])
print('index 1:', villes[1])
print('dernier index (-1):', villes[-1])
# SLICING [début (inclus) : fin (exclus) : pas]

print('séquence complète:', villes)
print('index 0-2:', villes[0:3])
print('index 1-2:', villes[1:3])
print('ordre inverse:', villes[::-1])
La liste peut également être indexée avec des nombres négatifs selon le modèle suivant :
Liste : ['girafe', 'tigre', 'singe', 'souris']
Indice positif : 0 1 2 3
Indice négatif : -4 -3 -2 -1
Ou encore :
Liste : ['A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L']
Indice positif : 0 1 2 3 4 5 6 7 8 9
Indice négatif : -10 -9 -8 -7 -6 -5 -4 -3 - 2 -1
Les indices négatifs reviennent à compter à partir de la fin. Leur principal avantage est que vous pouvez
appeler le dernier élément d’une liste à l’aide de l’indice -1 sans pour autant connaître la longueur de la
liste.
print(animaux[-1])
Un autre avantage des listes est la possibilité de sélectionner une partie en utilisant un Slicing construit
sur le modèle [m:n+1] pour récupérer tous les éléments, du émième au énième (de l’élément m inclus à
l’élément nexclus). On dit alors qu’on récupère une tranche de la liste, par exemple :
print(animaux[0:2])
print(animaux[0:3])
print(animaux[0:])
print(animaux[:])
print(animaux[1:])
print(animaux[1:-1])
print(animaux[1:-1])
On peut aussi préciser le pas en ajoutant un« : » supplémentaire et en indiquant le pas par un entier.
print(animaux[::2])
Finalement, on voit que l’accès au contenu d’une liste avec des crochets fonctionne sur le modèle
liste[début : fin : pas].
a.4) Listes de listes

Pour finir, sachez qu’il est tout-à-fait possible de construire des listes de listes. Cette fonctionnalité peut
être parfois très pratique. Par exemple :
enclos1 = ['girafe', 4]
enclos2 = ['tigre', 2]
enclos3 = ['singe', 5]
zoo = [enclos1, enclos2, enclos3]

print(zoo) # [['girafe', 4], ['tigre', 2], ['singe', 5]]
Dans cet exemple, chaque sous-liste contient une catégorie d’animal et le nombre d’animaux pour chaque
catégorie. Pour accéder à un élément de la sous-liste, on utilise un double indiçage.
print(zoo[1]) #['tigre', 2]
print(zoo[1][0]) #'tigre'
print(zoo[1][1]) #2
On verra un peu plus loin qu’il existe en Python les dictionnaires qui sont très pratiques pour faire ce
genre de choses. On verra aussi qu’il existe un module nommé Numpy permettant de gérer des listes ou
tableaux de nombres (vecteurs et matrices), ainsi que de faire des opérations dessus.
a.5) Actions utiles sur les listes

villes = ['Paris', 'Berlin', 'Londres', 'Bruxelles'] # liste initiale
print(villes)
villes.append('Dublin') # Rajoute un élément à la fin de la liste

print(villes)
villes.insert(2, 'Madrid') # Rajoute un élément a l'index indiqué

print(villes)
villes.extend(['Amsterdam', 'Rome']) # Rajoute une liste à la fin de notre liste

print(villes)
print('longueur de la liste:', len(villes)) #affiche la longueur de la liste
villes.sort(reverse=False) # trie la liste par ordre alphabétique / numérique

print(villes)
print(villes.count('Paris')) # compte le nombre de fois qu'un élément apparait dans la liste
Les listes et les Tuples fonctionnent en harmonies avec les structures de contrôle if/else et For
If 'Paris' in villes:
print('oui')
else:
print('non')
for element in villes:

print(element)
La fonction enumerate est très utile pour sortir à la fois les éléments d'une liste et leurs index. C'est une
fonction très utilisée en data-science :
for index, element in enumerate(villes):
print(index, element)
La fonction zip est aussi très utile pour itérée à travers 2 listes en parallèles. Si une liste est plus courte
que l'autre, la boucle for s'arrête a la liste la plus courte :
villes = ['Paris', 'Berlin', 'Londres', 'Bruxelles'] # liste initiale
liste_2 = [312, 52, 654, 23, 65, 12, 678]
for element_1, element_2 inzip(villes, liste_2):
print(element_1, element_2)
III.2. Tuples
Une liste ou un Tuple peuvent contenir tous types de valeurs (int, float, bool, string). On dit que ce sont
des structures hétérogenèses. La différence entre les 2 est qu'une liste est mutable alors qu'un Tuple ne
l'est pas (on ne peut pas le changer après qu'il soit crée)

#Tuples
tuple_1 = (1, 2, 6, 2)
print(tuple_1)
tuple_villes = ('Paris', 'Berlin', 'Londres', 'Bruxelles') # Tuple initiale
print(tuple_ villes)
Note : toutes les opérations, l’indexing, le Slicing et les actions possibles sur les listes sont également
possible sur les Tuples avec les mêmes syntaxes à l’exception de celles qui pourraient modifier le Tuple.
Car il ne faut pas oublier qu’un Tuple ne peux pas être modifié âpres sa déclaration, toutefois il est plus
raide en temps d’exécution qu’une liste pour de grande quantité de données.
III.3. Dictionnaires
Les dictionnaires sont des structures de contrôle non-ordonnées, c'est-a-dire que les valeurs qu'ils
contiennent ne sont pas rangées selon un index, mais suivant une clef unique.
Une utilisation parfaite des dictionnaires est pour regrouper ensemble des "variables" dans un même
conteneur (Ces variables ne sont pas de vraies variables, mais des keys).
On peut par exemple crée un dictionnaire inventaire qui regroupe plusieurs produits (les clefs) et leur
quantités (les valeurs)
inventaire = {'pommes': 100,
'bananes': 80,
'poires': 120}
print(inventaire.values())
print(inventaire.keys())
print(len(inventaire)) #nombre d'enregistrement dans le dictionnaire
Voici comment ajouter une association key/value dans notre dictionnaire (attention si la clef existe déjà
elle est remplacée)
inventaire['abricots'] = 30
print(inventaire)
Attention : si vous cherchez une clef qui n'existe pas dans un dictionnaire, python vous retourne une
erreur. Pour éviter cela, vous pouvez utiliser la méthode get()
print(inventaire.get('peches') ) # n'existe pas
print(inventaire.get('pommes')) # pomme existe
On peut définir une valeur par défaut si la clef n’existe pas

print(inventaire.get('peches', 0) ) # n'existe pas et retourne 0 comme valeur par défaut
La méthode pop() permet de retirer une clef d'un dictionnaire tout en retournant la valeur associée a la
clef.
abricots = inventaire.pop("abricots")
print(inventaire) # ne contient plus de clef abricots
print(abricots) # abricots contient la valeur du dictionnaire
Pour utiliser une boucle for avec un dictionnaire, il est utile d'utiliser la méthode items() qui retourne à la
fois les clefs et les valeurs
for key, value in inventaire.items():
print(key, value)
On peut également avoir des dictionnaires contenant d’autres dictionnaires :

traduction = {

'chien' : 'dog',
'chat' : "cat",
'souris' : 'mouse',
'oiseau' :'birth'
}
fruit = {
'banane' : 2000,
'pommes' : 2500,
'poires' : 1500
}
dictionnaire = {
'dict_1' : traduction,
'dict_2' : fruit
}
print(dictionnaire)
print(dictionnaire.items())
print(dictionnaire.keys())
print(dictionnaire.values())
Les dictionnaires peuvent être utilisés pour stocker les paramètres des réseaux de neurone au fur et à
mesure qu’on entraine les modèles.
Exercice : fonction trier

1. Implémentez une fonction trier(classeur, valeur) qui place une valeur dans un dictionnaire en
fonction de son signe. La fonction prend en paramètre un classeur (dictionnaire) et une valeur et
va donc range les valeurs dans le dictionnaire selon leurs signes. Puis on affichera le classeur.
classeur = {'négatifs':[],
'positifs':[]
}
Def trier(classeur, valeur):
return classeur
2. Modifier le programme de la question 1 pour donner nom pas une valeur, mais plutôt une liste de
valeur en paramètre. La fonction prendra donc en paramètre un classeur (dictionnaire) et une liste
de valeurs qui seront rangées selon leurs signes. Puis on affichera le classeur.
III.4. List Comprehension

Les listes compréhension sont une façon habile de créer des listes sur une seule ligne de code, ce qui rend
le code beaucoup plus rapide (car python est un langage assez lent). Les deux codes ci-dessous effectuent
chacun la même opération. On peut voir (grâce au module time) que le temps d'exécution avec liste
compréhension est bien inférieur au temps d'exécution avec la méthode append()
import time
#Liste compréhension: permet de mettre des boucles for dans la liste
#plus rapide dans l'exécution et en une ligne
#code normal
start = time.time()
liste_1 = []
for i in range(10000000):
liste_1.append(i**2)
end = time.time()
print(end-start) #durée : 5.985000133514404 secondes
#équivalent en List compréhension

start = time.time()
liste_2 = [i**2 for i in range(10000000)]
end = time.time()
print(end-start) #durée : 3.934999942779541 secondes

On peut rajouter des conditions if dans les listes compréhensions, par exemple :
liste = [i**2 for i in range(100000) if (i % 2) == 0] # calcule i**2 seulement pour les nombres pairs.
print(liste[:10]) #affiche les 10 premiers éléments de la liste
On peut aussi créer des Nested List ou listes dans une liste :
liste = [[i for i in range(3)] for j in range(4) ] #permet de répéter la liste générée par i, en fonction du range
de j
print(liste)
Dans ce cas, nous aurons une liste répétée 4 fois. On peut également s’amuser avec i et j
liste = [[i+j for i in range(3)] for j in range(4) ] #n peut s’amuser a modifier la valeur de i
print(liste)
III.5. Dictionnaire compréhension

Le même principe s'applique aux dictionnaires :
#code normale pour le dictionnaire
dictionnaire = {'0' : 'Pierre',
'1' : 'Jean',
'2' : 'Julie',
'3' : 'Sophie'}
On peut utiliser la fonction enumarate() pour parcourir la liste et range les données dans le dictionnaire
prenoms = ['Pierre', 'Jean', 'Julie','Sophie']
dico = {key : value for key, value in enumerate(prenoms)}
print(dico)
Si on veut convertir les clefs en string

dico = {str(key) : value for key, value in enumerate(prenoms)}
print(dico)
print(dico.keys())
print(dico.values())
Si nous avons deux listes qui contiennent nos données on peut utiliser la fonction zip
ages = [10, 21, 32, 53]
dico_2 = {prenom : age for prenom, age in zip(prenoms, ages)}
print(dico_2)
On peut ajouter des conditions dans notre dictionnaire compréhension

dico_2 = {prenom : age for prenom, age in zip(prenoms, ages) if age>25} #le dictionnaire ne va contenir les données
que pour age > à 20 ans
print(dico_2)
III.6. Tuple compréhension

Bien qu’on ne puisse modifier un Tuple après son initialisation, le même principe s'applique aux Tuples :
tuple_1 = tuple(i**2 for i in range(10))
print(tuple_1)
Exercice : dictionnaire
Essayez-donc de créer un dictionnaire qui contienne des clefs de 1 à 20, avec comme valeur le carré de
chaque clef.
# SOLUTION
dictionnaire = {k : k**2 for k in range(1, 21)}
print(dictionnaire)

Python Inter B3 - 1

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Python Inter B3 - 1

Transféré par

Droits d'auteur :

Formats disponibles

Python Avancé : pour la Data-science, l’IA, le machine et le Deep Learning

Enseignant : M. EBOA Michel Anicet

Pour valider le module :

1 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

2 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

Chapitre 1 : Variables et fonctions

b) Utilisation de Jupyter Notebook

3 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

I.1. La programmation : une nouvelle vision du monde

4 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

I.2. Les commentaires

I.3. Les variables

5 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

a.1) Opérations arithmétiques

a.2) Opérations de comparaison

a.3) Opérations Logiques

6 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

I.4. Les fonctions

a.1) Fonction lambda

# Exemple d'une fonction g(x, y) = x^2 - y^2

a.2) Fonction def

nom_de_la_fonction(3, 2) #appel de la fonction

7 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

# Exemple concret : fonction qui calcul l'énergie potentielle d'un corps

def e_potentielle(masse, hauteur, g=9.81):

def e_potentielle(masse, hauteur, g=9.81):

a.3) Exercice : fonction e_potentielle

I.5. Les 4 librairies à maîtriser pour le Machine Learning

Numpy est la librairie qui permet de créer et manipuler des

Matplotlib est la librairie qui permet de visualiser nos

Pandas est une excellente librairie pour

8 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

des statistiques et de charger votre Dataset dans Sklearn.

Chapitre 2 : Structures de contrôle

II.2) Alternatives If / Else :

9 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

II.3) Boucle For

a.1) La fonction range

a.2) La fonction len

a.3) Parcours d’un liste

10 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

La variable i prendra successivement les valeurs 0, 1, 2 et 3 et on accèdera à chaque élément de la liste

a.4) La fonction enumerate

II.4) Boucle While

Une boucle while nécessite trois éléments pour fonctionner correctement :

11 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

II.5) Instructions break et continue

L’instruction continue saute à l’itération suivante.

II.6) Exercice: Suite de Fibonacci.

12 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

Chapitre 3 : Structures de donnes : Listes, Tuples et Dictionnaire

a.2) Opération sur les listes

a.3) Indexing et Slicing : Indiçage négatif et tranches

13 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

villes = ['Paris', 'Berlin', 'Londres', 'Bruxelles']

# SLICING [début (inclus) : fin (exclus) : pas]

a.4) Listes de listes

14 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

print(zoo) # [['girafe', 4], ['tigre', 2], ['singe', 5]]

a.5) Actions utiles sur les listes

villes.append('Dublin') # Rajoute un élément à la fin de la liste

villes.insert(2, 'Madrid') # Rajoute un élément a l'index indiqué

villes.extend(['Amsterdam', 'Rome']) # Rajoute une liste à la fin de notre liste