01 - CHAPITRE 1 Les Bases de Python Pour Data Science

Intelligence Artificielle 2020-2021
Chapitre 1 :
Les bases de python pour data science
1.1. VARIABLES ET FONCTIONS.................................................................................................................................. 2
1.2. STRUCTURE DE CONTRÔLE............................................................................................................................... 10
1.3. STRUCTURE DE DONNÉE LISTE ET TUPLE..................................................................................................... 18
1.4. LES FONTIONS PRÉDEFINIES............................................................................................................................. 38
1.5. MODULES............................................................................................................................................................... 39
1.6. PROGRAMMATION ORIENTÉE OBJET............................................................................................................. 39
Page 1
Dans ce chapitre nous allons voir ce qu'il y a à la base de la programmation

scientifique c'est à dire les variables et les fonctions.
1.1. Variables et fonctions

Nous allons commencer par créer une variable x et immédiatement lui affecter une
valeur.
x=1
Pour afficher cette variable dans la console on écrit :
print(x)
Quand le programme s'exécute il affiche dans la console la valeur de la variable x et

non pas la variable x elle-même.
Maintenant une variable varie d'où son nom donc on peut changer à n'importe quel
moment dans notre programme la valeur de x. On peut dire que maintenant x est
égal à 2 puis on va réimprimer x
x=1
print(x)
x=2
print(x)
et en exécutant un nouveau notre programme on a successivement 1 et 2 qui

s'affiche à l'écran.
maintenant une réaffectation qui pourrait être plus intéressante est de simplement
écrire
x=1
print(x)
x=2
print(x)
x=x+1
print(x)
Page 2
Si on exécute le code il s’affiche 1 2 3 deux trois
une façon plus condensée plus courte de l'écrire x = x + 1 est : x += 1
x=1
print(x)
x=2
print(x)
x += 1
print(x)
tout ça c'est bien mais c'est pas avec une seule variable qu'on va réussir à faire
grand-chose donc nous allons créer une deuxième variable disons y égale 2,5 et a
maintenant nous allons pouvoir faire des calculs.
Voici les différentes opérations de base pour faire de l'arithmétique.
Opérateurs de base
En plus d'attribuer une valeur initiale à une variable, nous pouvons également
effectuer les opérations mathématiques habituelles sur les variables. Les opérateurs
de base en Python incluent +, -,*, /, //,% et ** qui représentent respectivement
l'addition, la soustraction, la multiplication, la division, la division de plancher, le
module et l'exposant.
Exemple:
Supposons que x = 5, y = 2
Addition: x + y = 7
Soustraction: x - y = 3
Multiplication: x * y = 10
Division: x / y = 2,5
Division du sol: x // y = 2 (arrondit la réponse au nombre entier le plus proche)
Module: x% y = 1 (donne le reste lorsque 5 est divisé par 2)
Exposant: x ** y = 25 (5 à la puissance 2)
maintenant en plus de faire des opérations du type x plus y quand on a deux

variables on peut aussi les comparer l'une avec l'autre.
Page 3
Si nous voulons voir si deux variables sont identiques, nous utilisons le signe ==
(double =). Par exemple, si vous écrivez x == y, vous demandez au programme de
vérifier si la valeur de x est égale à la valeur de y. S'ils sont égaux, la condition est
remplie et l'instruction sera évaluée à True. Sinon, l'instruction sera évaluée à False.
D'autres signes de comparaison incluent

! = (Différent de),
< (inférieur à),
> (supérieur à),
<= (inférieur ou égal à) et
> = (supérieur ou égal à).
La liste ci-dessous montre comment ces signes peuvent être utilisés et donne des
exemples d'énoncés qui donneront la valeur True.
Pas égal à: 5! = 2
Supérieur à: 5 > 2
inférieur à: 2 < 5
Supérieur ou égal à: 5 > = 2 ; 5 > = 5
inférieur ou égal à: 2 <= 5 ; 2 <= 2
x=1
y = 2.5
# Arithmétique
print(x + y)
print(x - y)
print(x * y)
print(x / y)
print(x ** y)
# Comparaison
print(x <= y)
print(x >= y)
print(x == y)
print(x != y)
Dans le code, on a écrit :

# Arithmétique
# Comparaison
Page 4
c'est ce qu'on appelle des commentaires. et les commentaires c'est des petites lignes
de code qui ne sont pas pris en compte par l'ordinateur au moment d'exécuter le
programme et ainsi on peut écrire dans des commentaires absolument tout ce qu'on
veut pour documenter notre code et rendre notre code plus compréhensible
Nous avons également trois opérateurs logiques, et (and), ou (or), non (not) qui sont
utiles si nous voulons combiner plusieurs conditions.
L'opérateur and renvoie True si toutes les conditions sont remplies. Sinon, il
retournera False.
Par exemple, l'instruction 5 == 5 and 2 > 1 renverra True puisque les deux
conditions sont True.
L'opérateur or renvoie True si au moins une condition est remplie. Sinon, il

retournera False.
L'instruction 5> 2 or 7> 10 or 3 == 2 renverra True puisque la première condition 5
> 2 est True.
L'opérateur not renvoie True si la condition après le mot clé not est false. Sinon, il
retournera False. L'instruction not 2> 5 renverra True puisque 2 n'est pas supérieur
à 5.
voici les différentes opérations de logique pour respectivement faire l'opération and
or et le ou exclusifs
# Logique
print(False & True) # AND
print(False | True) # OR
print(False ^ True) # XOR
Affichage :
False
True
True
existe d'autres types de variables tels que les types numérique et le type string ça
ce sont des variables qui nous permettent de stocker des chaînes de caractères et
Page 5
pour ça on crée ces variables en mettant la chaîne de caractères soit entre guillemets
soit entre apostrophe par exemple une chaîne de caractères guillaume
et bien sûr ces variables on peut également les imprimés à l'écran en utilisant print
et maintenant j'exécute mon code et voilà on a dans l'explorateur une variable
prénom de type string qui s'affiche et dans notre console on a la valeur guillaume 0
qui s’affiche
il nous arrive de vouloir créer deux variables sur la même ligne simultanément ou
alors d'affecter deux valeurs à deux variables de façon simultanée pour ça on écrit
tout simplement les deux variables sur la même ligne x, y = 1, 4
Maintenant qu'on a dit tout ce qu'ils avaient à dire sur les variables on va passer aux
fonctions. dans python quand on veut créer une fonction du type par exemple ( x )=x 2 ,
on utilise l'expression lambda
f = lambda x : x**2
print(f(3))
print(f(4))
print(f(5))
Affichage :
9
16
25
par exemple on peut écrire f(3) et imprimer les résultats et alors on va obtenir neuf.
on peut l'utiliser autant de fois qu'on veut. bien entendu on peut écrire une fonction
mathématique aussi complexes qu'on désire.
par exemple peut rajouter un deuxième argument y écrire la fonction suivante :

f ( x , y )=x 2+ y
f = lambda x, y : x**2 + y
print(f(3, 5))
Affichage :
14
Page 6
pour créer des fonctions en général on n'utilise pas lambda parce que lambda ça nous
permet simplement de créer une fonction de type mathématiques exactement.
mais nous en programmation alors qu'on développe des fonctions on cherche à

développer une fonctionnalité c'est à dire qu'on veut qu'une fonctionnelles nous
permettent de faire quelque chose par exemple d'imprimer à l'écran plusieurs
résultats etc. pour développer des fonctions plus complexe on utilise une autre
méthode
def e_potentielle (masse, hauteur, g) :

E = masse * hauteur * g
print(E)
print('bonjour')
si j'exécute mon code alors on se rend compte que bonjour est affiché à l'écran ce qui
veut dire que cette ligne a été exécuté.
en revanche les lignes :
def e_potentielle(masse, hauteur, g) :

print(E)
n'ont pas été exécutés parce que ces lignes sont simplement la définition de notre
fonction. On n'a pas encore utilisé notre fonction on l'a seulement défini.
si on veut utiliser notre fonction, il faut l'appeler et ensuite lui passer des valeurs
(des parametres effectifs masse, hauteur et g).
e_potentielle(80, 5, 9.81)
maintenant si j'exécute mon code et bien j'obtiens bonjour puis j'obtiens 3924.
On peut écrire plusieurs choses dans print à condition qu'on sépare les différents
éléments d'une virgule.

print(E , 'Joules')
Page 7
Affichage :
3924.0 Joules
Variable locales vs Variables globales
Esayons d’afficher la valeur du paramettre formel masse :
masse
Affichage :
NameError: name 'masse' is not defined
vous devez comprendre les parametres formels comme étant simplement des prête
noms qui nous permettent de faire passer des valeurs ou des variables à l'intérieur de
notre fonction. Il en est de meme de la variable E. Ce sont des variables locales.
Pour recuperer la valeur de la variable locale E, il suffit d’utiliser l’instruction

return.

return E
Resultat = e_potentielle(80, 5, 9.81)

print(Resultat, 'Joules')
Affichage :
3924.0 Joules
On peut aussi présiser explicitement les paramettres formels lors de l’appel de la

fonction. Cela permet de bien comprendre ce qu’on est en train de faire.
Resultat = e_potentielle(masse = 80, hauteur = 5, g = 9.81)

Affichage :
3924.0 Joules
Page 8
Le paramettre formel g étant une constante, on peut le créer comme valeur par
défaut à l’interieur de la fonction comme suit.
def e_potentielle(masse, hauteur, g = 9.81) :

return E
Resultat = e_potentielle(80, 5)
Affichage :
3924.0 Joules
EXERCICE
Reprendre cette fonction énergie potentielle et d'y ajouter un quatrième argument
qui serait par exemple un argument energie_limite, de modifier un petit peu
l'intérieur de cette fonction afin de retourner VRAI si l'énergie calculé est inférieure
à l'énergie limite qui est passé en arguments et FAUX si non.
Page 9
1.2. Structure de contrôle
Dans le paragraphe précédant, nous avons vue les variables et les fonctions. Tout cela ne
suffit pas encore pour créer des algorithmes. Dans ce paragraphe nous allons voir les trois
structures de contrôle les plus populaires du monde de la programmation :
SI … ALORS … SINON … FINSI
POUR … FAIRE …FINPOUR
TANTQUE … FAIRE …FINTANTQUE
1.2.1. La structure de contrôle SI … ALORS … SINON … FINSI

Cette structure nous permet d’écrire des algorithmes dans lesquels certaines instructions
sont exécutées lorsque certaines conditions sont vérifiées.
La structure de contrôle SI … ALORS …FINSI
Illustration :
x=1
if x > 0 :
print(x, 'positif')
Affichage :
1 positif
Si on suppose que x = -1 alors rien ne se produit
x = -1
Page 10
if x > 0 :
print(x, 'positif')
La structure de contrôle SI … ALORS … SINON … FINSI
x = -1
if x > 0 :
print(x, 'positif')
else :
print(x, 'negatif')
Affichage :
-1 negatif
La structure de contrôle SI … ALORS … SINON SI… FINSI
x=0
if x > 0 :
print(x, 'positif')
elif x == 0 :
print(x, 'nul')
else :
print(x, 'negatif')
Affichage :
Page 11
0 nul
Maintenant que vous avez compris la structure de contrôle SI … ALORS … SINON …

FINSI, nous allons allez encore plus loin.
x > 0 et x == 0 sont ce qu’on appelle des expressions booleennes. Car si on suppose que x
= 0 alors elles vallent respectivement FAUX (false) et VRAI (true).
x=1
x>0
Affichage :
True
x == 0
Affichage :
False
On peut donc introduire des opérateurs booleens tels que ET, OU, NON
x=1
y=2
if (x > 0) & (y > x) :
print(x, y, 'positif')
elif x == 0 :
Page 12
print(x, 'nul')
else :
print(x, 'negatif')
Affichage :
1 2 positif
Nous allons maintenant crréer une FONCTION qui va intégrer tout ce qu’on vient de
voir.
def signe(x) :
if (x > 0) :
print(x, 'positif')
elif x == 0 :
print(x, 'nul')
else :
print(x, 'negatif')
signe(5)
Affichage :
5 positif
signe(0)
Affichage :
0 nul
1.2.2. La structure de contrôle POUR … FINPOUR
for i in range(10) :
print('bonjour')
Affichage :
bonjour
bonjour
bonjour
bonjour
bonjour
bonjour
bonjour
bonjour
bonjour
bonjour
Page 13
Autre exemple :
print(i)
Affichage :
0
1
2
3
4
5
6
7
8
9
Autre exemple :
for i in range(5, 10) :

print(i)
Affichage :
5
6
7
8
9
On peut introduire une variable pas permettant de sauter de 2 en 2 jusqu’à 10.

Page 14
for i in range(5, 10, 2) :

print(i)
Affichage :
5
7
9
for i in range(10, -10, -1) :

print(i)
Affichage :
10
9
8
7
6
5
4
3
2
1
0
-1
-2
-3
-4
-5
-6
-7
-8
-9
for i in range(10, -10, -1) :

signe(i)
Affichage :
10 positif
9 positif
8 positif
7 positif
6 positif
5 positif
4 positif
3 positif
2 positif
1 positif
0 nul
-1 negatif
-2 negatif
-3 negatif
-4 negatif
-5 negatif
Page 15
-6 negatif
-7 negatif
-8 negatif
-9 negatif
for i in range(10, -10, -3) :

signe(i)
Affichage :
10 positif
7 positif
4 positif
1 positif
-2 negatif
-5 negatif
-8 negatif
1.2.3. La structure de contrôle TANTQUE … FAIRE … FINTANTQUE
x=0
while x < 10 :
print(x)
x += 1
Affichage :
0
1
2
3
4
5
6
7
8
9
Correction de l’exercice du chapitre precedent.
Page 16
def e_potentielle_limite(masse, hauteur, limite, g = 9.81) :
return E < limite
e_potentielle_limite (50, 10, 6000)
Affichage :
True
EXERCICE
Ecrire une fonction la suite de fibonacci
def fibonacci (n) :

retourne la suite de fibonacci jusqu’à la valeur de n
Page 17
1.3. Structure de donnée Liste et Tuple
Jusqu’à present les variables que nous avons manipulées ne contiennent qu’une seule
valeur à la fois. Dans cette section, nous allons parler des structures de données qui
peuvent contenir plusieurs valeurs à la fois.
1.3.1. Les listes

Pour créer une liste par exemple liste_1 c’est très simple il suffit de mettre entre crochets
les différents éléments qu'on veut avoir dans notre liste.
liste_1 = [1, 4, 2, 7, 35, 84] # liste de taille 6

villes = ['Paris', 'Berlin', 'Londre', 'Bruxelles'] # liste de taille 4
liste_2 = [liste_1, villes] # liste de taille 2
liste_3 = [] # liste de taille 0
liste_1
Affichage :
[1, 4, 2, 7, 35, 84]
villes
Affichage :
['Paris', 'Berlin', 'Londre', 'Bruxelles']
liste_2
Affichage :
[[1, 4, 2, 7, 35, 84], ['Paris', 'Berlin', 'Londre', 'Bruxelles']]
liste_3
Affichage :
[]
Page 18
1.3.2. Les tuples

Qu’est ce que c'est qu'un tuple et bien c'est comme une liste sauf que une fois qu'on l'a
créée on ne peut pas le modifier. Alors à quoi ça sert si on ne peut pas modifier un tuple ?
Un tuple utilise moins de mémoire sur l’ordinateur qu’une liste. Il est utile pour stocker un
grand nombre de données. En pratique, on se sert très rarement des tuples.
tuple_1 = (1, 4, 2, 7, 35, 84)
tuple_1
Affichage :
(1, 4, 2, 7, 35, 84)
1.3.3. Les strings
prenom = 'Nicolas'
prenom
Affichage :
'Nicolas'
Les listes, les tuples et les strings sont tous les trois des structures de données qui forment
des séquences. Une séquence est une structure de données qui suit ORDRE. Dans une
séquence les valeurs sont indexées. Grace à ce système d’indexe, on peut acceder à chaque
élément de la séquence.
print(villes[0]) # le premier élément est à l’index 0
Affichage :
Paris
Page 19
print(villes[1]) # le deuxième élément est à l’index 1
Affichage :
Berlin
Pour acceder au dernier élément d’une liste, on utilise l’index -1
print(villes[-1]) # le dernier élément est à l’index -1
Affichage :
Bruxelles
print(villes[-2]) # l’avant dernier élément est à l’index -2
Affichage :
Londre
1.3.4. La technique du slicing

Cette technique nous permet d'accéder à une FOURCHETTE D'ELEMENTS dans notre
séquence en indiquant une fourchette d'index. pour cela on désigne entre crochets un
INDEX DE DEBUT un INDEX DE FIN et en option on peut aussi désigner un PAS et
on sépare tout ça à chaque fois d'un double point. ça vous rappelle peut-être la fonction
print(villes[0:3])
Affichage :
['Paris', 'Berlin', 'Londre']
Page 20
L’index de debut (0) est implicite
print(villes[:3])
Affichage :
['Paris', 'Berlin', 'Londre']
L’index de fin (-1) est implicite
print(villes[2:])
Affichage :
['Londre', 'Bruxelles']
print(villes[1:3])
Affichage :
['Berlin', 'Londre']
print(villes[::2])
Affichage :
['Paris', 'Londre']
print(villes[::-1])
Affichage :
['Bruxelles', 'Londre', 'Berlin', 'Paris']
Page 21
1.3.5. Les méthodes de sequence
villes = ['Paris', 'Berlin', 'Londre', 'Bruxelles']
Saisissez : villes. Puis appuyer sur la touche tabulation. La liste des différentes méthodes
apparait. Ce sont les différentes actions que nous pouvons réaliser sur cette liste.
Commencons par l’action append permettant d’ajouter un élément à la fin de la liste.
villes.append('Dublin')
villes
Affichage :
['Paris', 'Berlin', 'Londre', 'Bruxelles', 'Dublin']
Parfois on a envie d’ajouter un élément à la liste, mais pas à la fin. Pour cela on utilise la
méthode insert.
villes.insert(2, 'Madrid')
villes
Affichage :
['Paris', 'Berlin', 'Madrid', 'Londre', 'Bruxelles', 'Dublin']
Page 22
Si on veut ajouter une liste à la fin d’une liste, alors on utilise la méthode extend.
villes_2 = ['Amsterdam', 'Rome']

villes.extend(villes_2)
villes
Affichage :
['Paris',
'Berlin',
'Madrid',
'Londre',
'Bruxelles',
'Dublin',
'Amsterdam',
'Rome']
Maintenant on a pas mal d’éléments dans notre liste. On n’a pas envie de les compter. On
utilise pour cela la méthode len.
len(villes)
Affichage :
8
Maintenant ce qu’on peut faire de très important sur les listes c’est le tri. Pour cela on
utilise la méthode sort.
villes.sort()
villes
Affichage :
['Amsterdam',
'Berlin',
'Bruxelles',
'Dublin',
'Londre',
'Madrid',
'Paris',
Page 23
'Rome']
villes.sort(reverse = True)
villes
Affichage :
['Rome',
'Paris',
'Madrid',
'Londre',
'Dublin',
'Bruxelles',
'Berlin',
'Amsterdam']
liste_2 = [52, 51, 23, 61, 3, 2, 78, 24]

liste_2.sort()
liste_2
Affichage :
[2, 3, 23, 24, 51, 52, 61, 78]
1.3.6. Les sequences dans les boucle
if 'Paris' in villes :
print('Oui')
else :
print('Non')
Affichage :
Oui
Page 24
if 'Belfast' in villes :
print('Oui')
else :
print('Non')
Affichage :
Non
En ce qui concerne la boucle for, c’est absolument génial
for i in villes :
print(i)
Affichage :
Rome
Paris
Madrid
Londre
Dublin
Bruxelles
Berlin
Amsterdam
Page 25
Pour extraire les index, c’est possible en utilisant enumerate.
for index, valeur in enumerate(villes) :

print(index, valeur)
Affichage :
0 Rome
1 Paris
2 Madrid
3 Londre
4 Dublin
5 Bruxelles
6 Berlin
7 Amsterdam
liste_2 = [10, 20, 30, 40]

for a, b in zip(villes, liste_2) :
print(a, b)
Affichage :
Rome 10
Paris 20
Madrid 30
Londre 40
Page 26
1.3.7. Les dictionnaires
Le dictionnaire est une structure de donnée qui n’est pas ordonnée. A la plce des index, ils
ont ce qu’on appelle des clé.
traduction = {
"chien" : "dog",
"chat" : "cat",
"souris" : "mouse",
"oiseau" : "bird"
}
traduction
Affichage :
{'chien': 'dog', 'chat': 'cat', 'souris': 'mouse', 'oiseau': 'bird'}
Dans un dictionnaire, chaque clé est unique
inventaire = {
"bananes" : 5000,
"pommes" : 2094,
"poires" : 412809
}
inventaire
Affichage :
{'bananes': 5000, 'pommes': 2094, 'poires': 412809}
On peut avoir des dictionnaires dans un dictionnaire
dictionnaire_3 = {
"dict_1" : traduction,
" dict_2" : inventaire,
}
dictionnaire_3
Page 27
Affichage :
{
'dict_1': {'chien': 'dog', 'chat': 'cat', 'souris': 'mouse', 'oiseau': 'bird'},
'dict_2': {'bananes': 5000, 'pommes': 2094, 'poires': 412809}
}
Certains developpeur utilisent les dictionnaires pour stocker les parametres de leurs
réseaux de neurones.
import numpy as np
parametres = {
"W1" : np.random.randn(10, 100),
"b1" : np.random.randn(10, 1),
"W2" : np.random.randn(10, 10),
"b2" : np.random.randn(10, 1)
}
parametres
Affichage :
{'W1': array([[-0.29296497, -1.23179249, 0.96555974, 0.23892485, -0.43666369],
[ 0.21962975, -1.24535934, 0.1186961 , -0.62560256, 0.47972845],
[-0.962823 , 0.16769856, 1.02074075, 1.29811239, -0.13233589],
[ 0.61388966, 1.49110421, -1.06916032, -2.17395663, -2.14957359],
[-0.16697841, -0.35815909, -0.02627559, 0.70212555, -0.81205697],
[-0.15858304, -0.20331961, 0.77373126, 0.10435334, 0.79791264],
[-0.49117606, -0.09399364, -1.30556228, 1.01282227, 1.48703755],
[-0.68955066, -1.39178894, 1.39661323, 1.52258544, 1.06531198],
[ 1.00285583, 1.39707159, 1.08020902, 0.3051774 , 0.53615398],
[ 2.67639704, 0.89956046, -0.60535741, 0.6564401 , -0.13610098]]),
'b1': array([[-1.56675747],
[-1.34588719],
[ 0.10984012],
[-0.7316115 ],
[-0.4903927 ],
[ 1.25854733],
[-1.80314722],
[-0.10097639],
[-2.04065917],
[-0.34794164]]),
'W2': array([[ 0.84661047, -1.14610015, 0.14559382, 0.12156519, 1.0341293 ],
[-1.71077658, -0.12799756, -0.49782403, -1.82171235, 1.96090075],
[-1.36787297, -0.93369914, 0.84908575, 0.27493435, 1.50721343],
[ 2.24777913, -1.19377328, -1.27719467, 0.96614847, 1.4032403 ],
[-0.90168933, 0.49509232, -1.16480164, 0.31313356, -0.49582453],
[ 2.37258087, -1.00458706, -0.39741044, -0.92039934, 0.40198067],
[-0.06315536, -0.39865967, -0.39301307, -0.50526146, 0.24169101],
[ 0.72069994, -0.05700464, 0.5925811 , -0.10701013, 1.03254448],
[ 1.76737731, 0.85470206, -0.14853319, -0.45400093, -1.69504521],
[ 1.08746455, 0.25990343, 0.26431439, 0.69433954, -0.98224949]]),
'b2': array([[-0.43810317],
[ 2.08451425],
[ 0.86419883],
[-1.67671645],
[ 1.62174103],
Page 28
[ 1.9035228 ],
[ 0.05148822],
[ 0.37283925],
[-1.0359044 ],
[ 1.41473245]])}
Pour afficher les valeur d’un dictionnaire, on utilise la méthode values()
inventaire.values()
Affichage :
dict_values([5000, 2094, 412809])
Pour afficher les clés d’un dictionnaire, on utilise la méthode keys()
inventaire.keys()
Affichage :
dict_keys(['bananes', 'pommes', 'poires'])
Pour afficher la longueur d’un dictionnaire, on utilise la méthode len()
len(inventaire)
Affichage :
3
Pour ajouter une association dans un dictionnaire, on utilise la sytaxe suivante :
inventaire["Abricot"] = 4902
inventaire
Affichage :
{'bananes': 5000, 'pommes': 2094, 'poires': 412809, 'Abricot': 4902}
Page 29
Les méthodes pour les dictionnaires
print(inventaire.get("Peche"))
Affichage :
None
print(inventaire.get("Peche", 1))
Affichage :
1
print(inventaire.get("pommes"))
Affichage :
2094
liste_1 = ['Paris', 'londre', 'Bruxelles']

inventaire.fromkeys(liste_1, 'defaut')
Affichage :
{'Paris': 'defaut', 'londre': 'defaut', 'Bruxelles': 'defaut'}
Page 30
Pour extraire une association d’un dictionnaire, on utilise la méthode pop :
inventaire
Affichage :
{'bananes': 5000, 'pommes': 2094, 'poires': 412809, 'Abricot': 4902}
inventaire.pop('Abricot')
Affichage :
4902
inventaire
Affichage :
{'bananes': 5000, 'pommes': 2094, 'poires': 412809}
Les dictionnaires et les boucles
for i in inventaire :
print(i)
Affichage :
bananes
pommes
poires
Cette instruction n’affiche que les clés

Page 31
Pour afficher les valeurs on utilise la méthode values()
for i in inventaire.values() :
print(i)
Affichage :
5000
2094
412809
Pour afficher les clé et les valeurs on utilise la méthode items()
for k, v in inventaire.items() :
print(k, v)
Affichage :
bananes 5000
pommes 2094
poires 412809
Page 32
Correction EXERCICE
def fibonacci(n) :
# retourne une liste contenant la suite de fibonacci jusqu’à n
a=0
b=1
fib = [a]
while b < n :
a, b = b, a+b
fib.append(a)
return fib
print(fibonacci(1000))
Affichage :
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987]
EXERCICE
def trier(classeur, nombre) :

# classeur : dictionnaire de taille 2
# nombre : entier
# range nombre dans "positif" ou "negatif" de classeur selon son signe
return classeur
Page 33
1.3.8. Listes et dictionnaires en comprehension
Dans les sections précedentes, on a vu les listes et les dictionnaires ainsi que tout un tas
de techniques à utiliser sur ces différentes structures de données.
Maintenant il y a encore une technique très importante que l'on n'a pas encore vu sur listes
les dictionnaires. C’est la technique des listes en comprhenssion et les dictionnaires en
comprhenssion.
1. listes en comprhenssion
Imaginez que vous ayez une liste complètement vide et que vous vouliez écrire tous les
nombres carrés de 0 à 9 à l'intérieur de cette liste pour ça vous pourriez avoir l'algorithme
suivant.
# tous les carrés de 0 à 9
liste_1 = []
liste_1.append(i**2)
print(liste_1)
Affichage :
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Une liste comprehenssion consiste à inserer la boucle for à l’intérieur de la boucle elle-
même.
liste_2 = [i**2 for i in range(10)]

print(liste_2)
Affichage :
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Quel est le plus rapide ?
import time
import time
start = time.time()
liste_1 = []
liste_1.append(i**2)
Page 34
print(liste_1)
end = time.time()
print(end - start)
Affichage :
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
0.0010025501251220703
import time
start = time.time()
liste_2 = [i**2 for i in range(10)]
print(liste_2)
end = time.time()
print(end - start)
Affichage :
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
0.0008230209350585938
Liste comprehension dans une liste comprehension
liste_3 = [i for i in range(3)]

print(liste_3)
Affichage :
[0, 1, 2]
liste_3 =[ [i for i in range(3)] for j in range(3)]

print(liste_3)
Affichage :
[[0, 1, 2], [0, 1, 2], [0, 1, 2]]
2. dictionnaires en comprhenssion
dictionnaire = {
'0' : 'pierre',
'1' : 'jean',
'2' : 'julie',
'3' : 'sophie'
}
dictionnaire
Page 35
Affichage :
{'0': 'pierre', '1': 'jean', '2': 'julie', '3': 'sophie'}
prenoms = ['pierre', 'jean' , 'julie', 'sophie']

dico = {k : v for k, v in enumerate(prenoms)}
print(dico)
Affichage :
{'0': 'pierre', '1': 'jean', '2': 'julie', '3': 'sophie'}
ages = [23, 14 , 36, 63]

dico_2 = { prenom : age for prenom, age in zip(prenoms, ages)}
print(dico_2)
Affichage :
{'pierre': 23, 'jean': 14, 'julie': 36, 'sophie': 63}
dico_2 = { prenom : age for prenom, age in zip(prenoms, ages) if age > 30}
print(dico_2)
Affichage :
{'julie': 36, 'sophie': 63}
En resumé
L’interet :
Un code plus professionnel, plus court et plus facile à exécuter
Page 36
Correction EXERCICE
EXERCICE
Créer un dictionnaire comprehension
Clé : nombres allant de 0 à 20
Valleur : la clé au carré
Page 37
1.4. Les fontions prédefinies
La fonction abs()
x = -3
abs(x)
Affichage :
3
La fonction round()
x = 3.14
round(x)
Affichage :
3
Les fonctions max()
Liste_1 = [0, 23, 14, -19]

print('le maximum de la liste est :', max(Liste_1))
print('le minimum de la liste est :', min(Liste_1))
print('la longueur de la liste est :', len(Liste_1))
print('la somme de la liste est :', sum(Liste_1))
Affichage :
le maximum de la liste est : 23
le minimum de la liste est : -19
la longueur de la liste est : 4
la somme de la liste est : 18
La fonction all() (ils sont tous nul (True, 0))
Liste_2 = [True, True, False]

all(Liste_2)
Affichage :
False
Liste_1 = [0, 23, 14, -19]

all(Liste_1)
Affichage :
False
Page 38
La fonction any() (il existe au moins un qui est non nul)

any(Liste_2)
Affichage :
True
Liste_1 = [0, 23, 14, -19]

any(Liste_1)
Affichage :
True
La fonction any()

any(Liste_1)
Affichage :
1.5. Modules
1.6. Programmation Orientée Objet
Page 39

01 - CHAPITRE 1 Les Bases de Python Pour Data Science

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

01 - CHAPITRE 1 Les Bases de Python Pour Data Science

Transféré par

Droits d'auteur :

Formats disponibles

Intelligence Artificielle 2020-2021

1.1. VARIABLES ET FONCTIONS.................................................................................................................................. 2

1.2. STRUCTURE DE CONTRÔLE............................................................................................................................... 10

1.3. STRUCTURE DE DONNÉE LISTE ET TUPLE..................................................................................................... 18

1.4. LES FONTIONS PRÉDEFINIES............................................................................................................................. 38

1.6. PROGRAMMATION ORIENTÉE OBJET............................................................................................................. 39

Dans ce chapitre nous allons voir ce qu'il y a à la base de la programmation

1.1. Variables et fonctions

Pour afficher cette variable dans la console on écrit :

Quand le programme s'exécute il affiche dans la console la valeur de la variable x et

et en exécutant un nouveau notre programme on a successivement 1 et 2 qui

Si on exécute le code il s’affiche 1 2 3 deux trois

une façon plus condensée plus courte de l'écrire x = x + 1 est : x += 1

Voici les différentes opérations de base pour faire de l'arithmétique.

maintenant en plus de faire des opérations du type x plus y quand on a deux

D'autres signes de comparaison incluent

Dans le code, on a écrit :

L'opérateur or renvoie True si au moins une condition est remplie. Sinon, il

par exemple peut rajouter un deuxième argument y écrire la fonction suivante :

mais nous en programmation alors qu'on développe des fonctions on cherche à

def e_potentielle (masse, hauteur, g) :

en revanche les lignes :

def e_potentielle(masse, hauteur, g) :

def e_potentielle(masse, hauteur, g) :

Variable locales vs Variables globales

Esayons d’afficher la valeur du paramettre formel masse :

Pour recuperer la valeur de la variable locale E, il suffit d’utiliser l’instruction

def e_potentielle(masse, hauteur, g) :

Resultat = e_potentielle(80, 5, 9.81)

On peut aussi présiser explicitement les paramettres formels lors de l’appel de la

Resultat = e_potentielle(masse = 80, hauteur = 5, g = 9.81)

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

1.2.1. La structure de contrôle SI … ALORS … SINON … FINSI

La structure de contrôle SI … ALORS …FINSI

Si on suppose que x = -1 alors rien ne se produit

La structure de contrôle SI … ALORS … SINON … FINSI

La structure de contrôle SI … ALORS … SINON SI… FINSI

Maintenant que vous avez compris la structure de contrôle SI … ALORS … SINON …

1.2.2. La structure de contrôle POUR … FINPOUR

for i in range(5, 10) :

On peut introduire une variable pas permettant de sauter de 2 en 2 jusqu’à 10.

for i in range(5, 10, 2) :

for i in range(10, -10, -1) :

for i in range(10, -10, -1) :

for i in range(10, -10, -3) :

1.2.3. La structure de contrôle TANTQUE … FAIRE … FINTANTQUE

Correction de l’exercice du chapitre precedent.

e_potentielle_limite (50, 10, 6000)

def fibonacci (n) :

1.3.1. Les listes

liste_1 = [1, 4, 2, 7, 35, 84] # liste de taille 6

1.3.2. Les tuples

tuple_1 = (1, 4, 2, 7, 35, 84)

1.3.3. Les strings

print(villes[0]) # le premier élément est à l’index 0

print(villes[1]) # le deuxième élément est à l’index 1

Pour acceder au dernier élément d’une liste, on utilise l’index -1

print(villes[-1]) # le dernier élément est à l’index -1

print(villes[-2]) # l’avant dernier élément est à l’index -2

1.3.4. La technique du slicing

L’index de debut (0) est implicite

L’index de fin (-1) est implicite

1.3.5. Les méthodes de sequence