ESB - Librairie avec Python

September 17, 2024

1 La librairie Numpy
NumPy (Numerical Python) est la première bibliothèque à connaitre si vous utilisez Python pour
des domaines qui touchent les mathématiques.
NumPy est une extension fondamentale de Python qui permet de faire du calcul scientifique
en Python.

1.1 1. Installation et import de la bibliothèque

En utilisant la distribution Anaconda, on installe NumPy ainsi :
conda install numpy ou pip install numpy
On importe la bibliothèque NumPy :
[1]: import numpy as np

1.2 2. Tableaux
1.2.1 2.1. Créer un tableau d’une seule dimension (Vecteur)
Pour créer un tableau d’une seule dimension, il suffit de faire appel à la fonction array().
[2]: mylist = [1, 2, 3]
x = np.array(mylist)
x
[2]: array([1, 2, 3])
[3]: x * 3
[3]: array([3, 6, 9])
Ou simplement passer dans une liste directement
[4]: y = np.array([4, 5, 6])
y
[4]: array([4, 5, 6])

1.2.2 2.2. Créer un tableau de deux dimensions (Matrice)

Affichons un tableau de deux dimensions(Passez dans une liste de listes pour créer un tableau
multidimensionnel).

1
 [5]: import numpy as np
x = np.array([1, 2, 3])
y = np.array([4, 5, 6])
a = [7, 8, 9, 0]
b = [10, 11, 12, -1]
c = [13, 14, 15, 6]

m = np.array([a,b,c])
m
[5]: array([[ 7, 8, 9, 0],
[10, 11, 12, -1],
[13, 14, 15, 6]])
Utilisez shape pour trouver les dimensions du tableau.
[6]: m.shape
[6]: (3, 4)
[7]: list(range(5,30,3))
[7]: [5, 8, 11, 14, 17, 20, 23, 26, 29]
[8]: for i in range(5):
print(i)

0
1
2
3
4

Utilisez arange pour renvoie des valeurs uniformément espacées dans un intervalle donné.
[9]: dt = 1#1/24
a = 0
b = 80
n = np.arange(a, b, dt) # start at a count up by dt, stop before b
n
[9]: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79])
[10]: dt
[10]: 1
[11]: n.shape
[11]: (80,)

2
[12]: len(n)
[12]: 80
reshape renvoie un tableau contenant les mêmes données avec une nouvelle forme.
[13]: n = n.reshape(8, 10) # reshape array to be 8x10 = len(n)
n
[13]: array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
[20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
[30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
[40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
[50, 51, 52, 53, 54, 55, 56, 57, 58, 59],
[60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
[70, 71, 72, 73, 74, 75, 76, 77, 78, 79]])
ones renvoie un nouveau tableau de forme et de type donnés, rempli de uns.
zeros renvoie un nouveau tableau de forme et de type donnés, rempli de zéros.
eye renvoie un tableau 2-D avec des uns sur la diagonale et des zéros ailleurs.
diag extrait une diagonale ou construit un tableau de diagonales.
Créer un tableau en utilisant une liste répétitive (ou voir np.tile)
Répétez les éléments d’un tableau en utilisant repeat.
[14]: np.ones((3, 2))
[14]: array([[1., 1.],
[1., 1.],
[1., 1.]])
[15]: np.ones((3, 2),int)
[15]: array([[1, 1],
[1, 1],
[1, 1]])
[16]: np.zeros((5, 7))
[16]: array([[0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0.]])
[17]: np.eye(3) # matrice identitie I_n
[17]: array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
[18]: y = np.array([4, 5, 6])
np.diag(y)

3
[18]: array([[4, 0, 0],
[0, 5, 0],
[0, 0, 6]])
[19]: np.repeat([1, 2, 3], 3)
[19]: array([1, 1, 1, 2, 2, 2, 3, 3, 3])
vstack pour empiler les tableaux en séquence verticalement (par rangée).
[20]: p = np.ones([2, 3], int)
p
[20]: array([[1, 1, 1],
[1, 1, 1]])
[21]: b = 2*p
b
[21]: array([[2, 2, 2],
[2, 2, 2]])
[22]: np.vstack([p, b])
[22]: array([[1, 1, 1],
[1, 1, 1],
[2, 2, 2],
[2, 2, 2]])
hstack pour empiler les tableaux en séquence horizontalement (par colonne).
[23]: np.hstack([p, 2*p])
[23]: array([[1, 1, 1, 2, 2, 2],
[1, 1, 1, 2, 2, 2]])

1.3 3. Opérations
1.3.1 3.1. Opérations arithmétiques
NumPy propose des fonctions natives plus adaptées aux opérations arithmétiques sur les
tableaux.
Alors pour faire l’addition, on retrouve la fonction add().
Pour la soustraction, on fait appel à la fonction subtract().
Pour la multiplication, on a la fonction multiply().
Pour la division, vous l’avez peut-être deviné, on a la fonction divide().
Finalement, avec la fonction dot(), il est possible de faire le produit scalaire.
Exemple :
Dans cet exemple nous allons voir les opérations arithmétiques sur les tableaux à travers les
fonctions qu’on vient de mentionner.
[24]: a = np.array([[1,2,3],
[4,5,6]])
b = np.array([[7,8,9],
[10,11,12]])

4
 print("l'addition des deux tableaux:\n", np.add(a,b))
print("la soustraction de b de a:\n ", np.subtract(b,a))
print("la multiplication des deux tableaux:\n ", np.multiply(a,b))
print("la division de b par a:\n" ,np.divide(b,a))

l'addition des deux tableaux:

[[ 8 10 12]
[14 16 18]]
la soustraction de b de a:
[[6 6 6]
[6 6 6]]
la multiplication des deux tableaux:
[[ 7 16 27]
[40 55 72]]
la division de b par a:
[[7. 4. 3. ]
[2.5 2.2 2. ]]

[25]: a
[25]: array([[1, 2, 3],
[4, 5, 6]])
[26]: a.T
[26]: array([[1, 4],
[2, 5],
[3, 6]])
[27]: a.T.shape
[27]: (3, 2)
[28]: b.shape
[28]: (2, 3)
[29]: np.dot(b,a.T) # dim(2,3)*dim(3,2) = (2,2)
[29]: array([[ 50, 122],
[ 68, 167]])
[30]: np.dot(b,np.transpose(a))
[30]: array([[ 50, 122],
[ 68, 167]])
+, -, *, / et ** pour effectuer des additions, soustractions, multiplications, divisions et puis-
sances.
[31]: print(x + y) # elementwise addition array([1 2 3]) + [4 5 6] = [5 7 9]
print(x - y) # elementwise subtraction [1 2 3] - [4 5 6] = [-3 -3 -3]

5
 print(x * y) # elementwise multiplication [1 2 3] * [4 5 6] = [4 10 18]
print(x / y) # elementwise divison [1 2 3] / [4 5 6] = [0.25 0.4 0.5]

print(x**2) # elementwise power [1 2 3] ^2 = [1 4 9]

[5 7 9]
[-3 -3 -3]
[ 4 10 18]
[0.25 0.4 0.5 ]
[1 4 9]

Dot Product:
$  
[ ] y1
x1 x2 x3 ·  y2 
y3
= x_1 y_1 + x_2 y_2 + x_3 y_3$
[32]: x.dot(y) # dot product 1*4 + 2*5 + 3*6
[32]: 32

1.3.2 3.2. Math Functions

Numpy intègre de nombreuses fonctions mathématiques qui peuvent être exécutées sur des
tableaux.
[33]: a = np.array([-4, -2, 1, 3, 5,-10])
h = a.sum() #somme
print(h) # Afficher
abs(a) # valeur absolus

-7

[33]: array([ 4, 2, 1, 3, 5, 10])

[34]: a.max() # maximum
[34]: 5
[35]: a.min() # minimum
[35]: -10
[36]: moy= a.mean() # La moyenne
moy
[36]: -1.1666666666666667
[37]: a.sum()/len(a)
[37]: -1.1666666666666667
[38]: a.var() # variance

6
[38]: 24.472222222222225
[39]: s = 0
for i in range(len(a)):
s += (a[i] - moy)**2
s = s/len(a)
s
[39]: 24.472222222222225
[40]: ((a - moy)**2).sum()/len(a)
[40]: 24.472222222222225
[41]: a.std() # Ecart-type
[41]: 4.94694069321861
[42]: myliste = [1,2,3,4,5,6] #0 Jusqu'a len(myliste -1)
[43]: myliste[1:6:2]
[43]: [2, 4, 6]

1.4 4. Manipulation des tableaux NumPy

On peut accéder aux valeurs d’un tableau NumPy de la même manière que pour les listes Python.
En plus de ça, NumPy nous donne la possibilité de sélectionner des éléments du tableau selon
certaines conditions.
Exemple :
Dans cet exemple on parcourt le tableau en utilisant l’index de l’élément de la première ligne
qui se trouve sur la deuxième colonne.
[44]: a = np.array([[1,2,3],
[4,5,6]])
a
[44]: array([[1, 2, 3],
[4, 5, 6]])
[45]: a[0,2] #ligne 0 colonne 2
[45]: 3
[46]: a[0,] # ligne 0 : la première ligne
[46]: array([1, 2, 3])
[47]: a[:,1] # colonne 1 : la première colonne
[47]: array([2, 5])
[48]: a = np.array([[8,2,3],
[4,5,10],
[7,4,9]])
a[a>5]

7
[48]: array([ 8, 10, 7, 9])

2 La librairie Pandas
2.1 Introduction
C’est quoi Pandas ?
Pandas est une bibliothèque Python utilisée pour travailler avec des ensembles de données.
Il a des fonctions d’analyse, de nettoyage, d’exploration et de manipulation des données.
Le nom “Pandas” fait référence à la fois à “Panel Data” et à “Python Data Analysis” et a été
créé par Wes McKinney en 2008.
Pourquoi utiliser les pandas ?
Pandas nous permet d’analyser les mégadonnées et de tirer des conclusions basées sur des
théories statistiques.
Les pandas peuvent nettoyer des ensembles de données désordonnés et les rendre lisibles et
pertinents.
Les données pertinentes sont très importantes en science des données.*
Que peuvent faire les pandas ?
Pandas vous donne des réponses sur les données. Comme:
Existe-t-il une corrélation entre deux colonnes ou plus ?
Qu’est-ce que la valeur moyenne ?
Valeur max?
Valeur mini ?
Les pandas sont également capables de supprimer les lignes qui ne sont pas pertinentes ou
qui contiennent des valeurs erronées, comme des valeurs vides ou NULL. C’est ce qu’on appelle
nettoyer les données.

2.1.1 1.2. Importer des pandas

Une fois Pandas installé, importez-le dans vos applications en ajoutant le importmot clé :
[49]: import pandas as pd
[50]: mydataset = {
'cars' : ["BMW", "Volvo", "Ford"],
'passings': [3, 7, 2]
}

df = pd.DataFrame(mydataset)

df
[50]: cars passings
0 BMW 3
1 Volvo 7
2 Ford 2
[51]: df['Location'] = None
df

8
[51]: cars passings Location
0 BMW 3 None
1 Volvo 7 None
2 Ford 2 None
[52]: df['Location'] = [1,2,3]
df
[52]: cars passings Location
0 BMW 3 1
1 Volvo 7 2
2 Ford 2 3
[53]: #refer to the row index:
df.loc[2]
[53]: cars Ford
passings 2
Location 3
Name: 2, dtype: object
[54]: #use a list of indexes:
df.loc[[0, 1]]
[54]: cars passings Location
0 BMW 3 1
1 Volvo 7 2

Index nommés Avec l’ indexargument, vous pouvez nommer vos propres index.
Exemple : Ajoutez une liste de noms pour donner un nom à chaque ligne :
[55]: data = {
"calories": [420, 380, 390],
"duration": [50, 40, 45]
}

df = pd.DataFrame(data, index = ["day1", "day2", "day3"])

df
[55]: calories duration
day1 420 50
day2 380 40
day3 390 45
[56]: print(df.loc[['day1','day2']])

calories duration
day1 420 50
day2 380 40

9
[57]: df.loc[['day1','day2']]
[57]: calories duration
day1 420 50
day2 380 40
[58]: import seaborn as sns
import matplotlib.pyplot as plt
import plotly.express as px
import warnings
warnings.filterwarnings("ignore")
[59]: df = pd.read_csv("german_credit_data.csv", index_col=0)
df.head()
[59]: Age Sex Job Housing Saving_accounts Checking_account Credit_amount \
0 67 male 2 own NaN little 1169
1 22 female 2 own little moderate 5951
2 49 male 1 own little NaN 2096
3 45 male 2 free little little 7882
4 53 male 2 free little little 4870

Duration Purpose
0 6 radio/TV
1 48 radio/TV
2 12 education
3 42 furniture/equipment
4 24 car
[60]: df.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 1000 entries, 0 to 999
Data columns (total 9 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 Age 1000 non-null int64
1 Sex 1000 non-null object
2 Job 1000 non-null int64
3 Housing 1000 non-null object
4 Saving_accounts 817 non-null object
5 Checking_account 606 non-null object
6 Credit_amount 1000 non-null int64
7 Duration 1000 non-null int64
8 Purpose 1000 non-null object
dtypes: int64(4), object(5)
memory usage: 78.1+ KB

[61]: df.Housing

10
[61]: 0 own
1 own
2 own
3 free
4 free
...
995 own
996 own
997 own
998 free
999 own
Name: Housing, Length: 1000, dtype: object
[62]: df["Sex"]
[62]: 0 male
1 female
2 male
3 male
4 male
...
995 female
996 male
997 male
998 male
999 male
Name: Sex, Length: 1000, dtype: object
[63]: df.shape
[63]: (1000, 9)
[64]: df.columns.to_list()
[64]: ['Age',
'Sex',
'Job',
'Housing',
'Saving_accounts',
'Checking_account',
'Credit_amount',
'Duration',
'Purpose']
[65]: df.isnull().sum().sort_values(ascending=False)
[65]: Checking_account 394
Saving_accounts 183
Age 0
Sex 0
Job 0

11
 Housing 0
Credit_amount 0
Duration 0
Purpose 0
dtype: int64
[66]: df.isna().sum()
[66]: Age 0
Sex 0
Job 0
Housing 0
Saving_accounts 183
Checking_account 394
Credit_amount 0
Duration 0
Purpose 0
dtype: int64
[67]: columns = df.columns.to_list()
for col in columns:
unique_values = df[col].unique()
numeric = pd.api.types.is_numeric_dtype(df[col])
print(f"{col} ({df[col].dtype})")
if numeric:
unique_values = np.sort(unique_values)
if numeric and len(unique_values) > 20:
print(unique_values[:10], " ... ", unique_values[-10:])
else:
print(unique_values)
print("\n")

Age (int64)
[19 20 21 22 23 24 25 26 27 28] ... [62 63 64 65 66 67 68 70 74 75]

Sex (object)
['male' 'female']

Job (int64)
[0 1 2 3]

Housing (object)
['own' 'free' 'rent']

Saving_accounts (object)

12
 [nan 'little' 'quite rich' 'rich' 'moderate']

Checking_account (object)
['little' 'moderate' nan 'rich']

Credit_amount (int64)
[250 276 338 339 343 362 368 385 392 409] ... [14318 14421 14555 14782 14896
15653 15672 15857 15945 18424]

Duration (int64)
[ 4 5 6 7 8 9 10 11 12 13] ... [36 39 40 42 45 47 48 54 60 72]

Purpose (object)
['radio/TV' 'education' 'furniture/equipment' 'car' 'business'
'domestic appliances' 'repairs' 'vacation/others']

[68]: df["Sex"].value_counts() # effectif à partir de DataFrame 'pandas'

[68]: male 690
female 310
Name: Sex, dtype: int64
[69]: df["Sex"].value_counts(normalize=True) # fréquence relative 'pandas'
[69]: male 0.69
female 0.31
Name: Sex, dtype: float64
[70]: df["Sex"].unique() # modalité à partir de DataFrame 'pandas'
[70]: array(['male', 'female'], dtype=object)
[71]: df["Age"].describe() # moyenne, ecarttype, minimum, maximum, quantile
[71]: count 1000.000000
mean 35.546000
std 11.375469
min 19.000000
25% 27.000000
50% 33.000000
75% 42.000000
max 75.000000
Name: Age, dtype: float64

13
[72]: # Etendus : E = max(x)-min(x)
# variance : var(x) = std(x)**2
# coefficient de variation : cv = std(x)/mean(x) * 100
# coefficent de pearson unimodal : asp = (mean(x) - mod(x))/std(x)
# coefficent de pearson multimodal : asp = 3(mean(x) - median(x))/std(x)
[73]: df["Age"].mode() # mode
[73]: 0 27
dtype: int64
[74]: import scipy
scipy.stats.mode(df["Age"])
[74]: ModeResult(mode=array([27], dtype=int64), count=array([51]))
[85]: import math
Nc = 1+3.3*math.log10(1000)
Nc
[85]: 10.899999999999999
[87]: labels = ("J", "A", "S", "PA")
groups = pd.cut(df["Age"], labels=labels, bins=(18, 25, 35, 60, 120),␣
,→ordered=True)

groups
[87]: 0 PA
1 J
2 S
3 S
4 S
..
995 A
996 S
997 S
998 J
999 A
Name: Age, Length: 1000, dtype: category
Categories (4, object): ['J' < 'A' < 'S' < 'PA']
[89]: df["Agegroup"] = groups
df
[89]: Age Sex Job Housing Saving_accounts Checking_account Credit_amount \
0 67 male 2 own NaN little 1169
1 22 female 2 own little moderate 5951
2 49 male 1 own little NaN 2096
3 45 male 2 free little little 7882
4 53 male 2 free little little 4870
.. ... ... ... ... ... ... ...
995 31 female 1 own little NaN 1736

14
 996 40 male 3 own little little 3857
997 38 male 2 own little NaN 804
998 23 male 2 free little little 1845
999 27 male 2 own moderate moderate 4576

Duration Purpose Agegroup

0 6 radio/TV PA
1 48 radio/TV J
2 12 education S
3 42 furniture/equipment S
4 24 car S
.. ... ... ...
995 12 furniture/equipment A
996 30 car S
997 12 radio/TV S
998 45 radio/TV J
999 45 car A

[1000 rows x 10 columns]

[90]: sns.countplot(data=df, y="Agegroup", hue="Sex")
plt.show()

15
[78]: df.plot('Credit_amount','Duration', kind = 'hist');

Vous pouvez également choisir le type de tracé en utilisant les méthodes

DataFrame.plot.kind au lieu de fournir le mot-clé kind.
kind : - 'line' : line plot (default) - 'bar' : vertical bar plot - 'barh' : horizontal bar plot -
'hist' : histogram - 'box' : boxplot - 'kde' : Kernel Density Estimation plot - 'density' : same
as ‘kde’ - 'area' : area plot - 'pie' : pie plot - 'scatter' : scatter plot - 'hexbin' : hexbin plot
[79]: df.plot.scatter('Credit_amount','Duration', c='Age', s=df['Age'],␣
,→colormap='viridis')

[79]: <matplotlib.axes._subplots.AxesSubplot at 0x2687663a0b8>

16
[80]: df.Sex.unique() #modalité à partir pandas
[80]: array(['male', 'female'], dtype=object)
[81]: df.Sex.value_counts()
[81]: male 690
female 310
Name: Sex, dtype: int64
[82]: import numpy as np
np.unique(df.Sex , return_counts=True)
[82]: (array(['female', 'male'], dtype=object), array([310, 690], dtype=int64))
[ ]:

17