Le code source de ce cours est disponible sur https://github.com/asardell/programmation-python

Rappels du langage Python🐍

Les bases de la programmation

Variables

On peut définir des variables locales

a = 2

b = "Hello"

On peut supprimer une variable de la mémoire

del a

a

Structure conditionnelle

⛔ Il faut bien respecter une indentation sinon on sort de la structure conditionnelle

if (2 > 1):
    print("C'est vrai")

if (2 > 3):
    print("C'est vrai")
else:
    print("c'est faux")

La fonction input() permet à l'utilisateur de renseigner une valeur

input()

valeur = int(input())
if valeur < 5:
    print(str(valeur) + " est plus petit que 5")
elif valeur <= 10:
    print(str(valeur) + " est compris entre 5 et 10")
else :
    print(str(valeur) + " est plus grand que 10")

Construire une fonction

def calcul_IMC(poids = 60, taille = 1.70):
    imc = poids / taille**2
    return(imc)

calcul_IMC(poids = float(input("Quel poids (en kg) ? ")) ,
           taille = float(input("Quelle taille (en metres) ? ")))

On est pas obligé de renseigner le nom des arguments s'ils sont renseignés dans le même ordre de l'implémentation de la fonction

calcul_IMC(50,1.66)

L'ordre des arguments n'est pas important si on les renseigne

calcul_IMC(taille = 1.66, poids = 50)

Avec des arguments par défaut

def calcul_IMC(poids = 60, taille = 1.70):
    imc = poids / taille**2
    return(imc)

calcul_IMC()

calcul_IMC(poids = 80)

Boucles

FOR

La variable nb correspond au nombre d'itération de la boucle

⛔ Il faut bien respecter une indentation sinon on sort de la structure

nb = int(input())
for i in range(1,nb):
    un_poids = float(input("Quel poids (en kg) ? "))
    une_taille = float(input("Quelle taille (en metres) ? "))
    print(calcul_IMC(un_poids,une_taille))

⚠ La valeur de la borne droite d'une fonction range() est ouverte. Donc quand nb = 3, la boucle est lancée deux fois.

WHILE

⚠ Il est important d'exprimer une condition d'arrêt pour ne pas avoir de boucle infinie

nb = int(input())
i = 1
while i <= nb:
    un_poids = float(input("Quel poids (en kg) ? "))
    une_taille = float(input("Quelle taille (en metres) ? "))
    print(calcul_IMC(un_poids,une_taille))
    i=i+1

Liste

On utilis les crochets [ ] pour définir une liste

liste = [1,2,3,4]
liste

[1, 2, 3, 4]

La méthode append( ) permet d'ajouter un élément à une liste

liste.append(8)
liste

[1, 2, 3, 4, 8]

La méthode extend( ) permet d'ajouter une liste à la fin d'une liste

liste.extend([1,2,3])
liste

[1, 2, 3, 4, 8, 1, 2, 3]

La fonction len( ) renvoie la longueur d'une liste

len(liste)

8

Pour acceder aux éléments d'une liste on utilise les crochets [ ] .
⚠ L'indexation commence à 0

liste[0]

1

liste[0:5]

[1, 2, 3, 4, 8]

Librairies

Lorsqu'on installe python, plusieurs librairies sont installées par défaut. Généralement, il est nécessaire d'en installer d'autres. Par exemple la librairie numpy permet de manipuler des matrices et des listes. Il est recommandé d'installer des libraries via le terminal avec la commande pip install nom_librairie ou par un navigateur. Une fois installé, il faut import la librairie pour l'utiliser.

import numpy

On recommande souvent de mettre un alias pour une librairie et éviter d'avoir à saisir le nom complet de la librairie à chaque usage de ses fonctions

import numpy as np

Numpy

Voici quelques fonctions utiles de la librairie numpy

La fonction linspace( ) génère une séquence de n nombre

np.linspace(start= 0 , stop = 1, num = 9)

array([0.   , 0.125, 0.25 , 0.375, 0.5  , 0.625, 0.75 , 0.875, 1.   ])

La fonction arange( ) génère une séquence avec un step n
⚠ La valeur stop n'est pas prise en compte

np.arange(start= 0 , stop = 1, step = 0.1)

array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])

L'essentiel de 🐼

Dans ce notebook, nous allons voir l'essentiel de la manipulation de tableaux sous Python. Des notions importantes dans une démarche data science !

Importer la librairie pandas

on peut donc charger la librairie, la plupart du temps on lui associe un alias

import pandas as pd

⚠ Certaines fonctionnalités sont disponibles qu'à partir de certaines versions de pandas.

#Afficher la version de pandas
pd.__version__

'1.2.3'

Importer un jeu de données

On importe le jeu de données avec la méthode read_mon_format() selon l'extension du fichier

df = pd.read_csv("../Dataset/Titanic.csv")

On affiche un extrait du tableau avec la méthode head()

df.head(2)

	Unnamed: 0	Name	PClass	Age	Sex	Survived	SexCode
0	1	Allen, Miss Elisabeth Walton	1st	29.0	female	1	1
1	2	Allison, Miss Helen Loraine	1st	2.0	female	0	1

On supprime la première colonne inutile

df.drop(['Unnamed: 0'], axis=1, inplace=True)

On utilise la méthode shape pour afficher le nombre de lignes et colonnes

df.shape

(1313, 6)

On utilise la méthode info() ou dtypes pour afficher une description du data frame

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1313 entries, 0 to 1312
Data columns (total 6 columns):
 #   Column    Non-Null Count  Dtype  
---  ------    --------------  -----  
 0   Name      1313 non-null   object 
 1   PClass    1313 non-null   object 
 2   Age       756 non-null    float64
 3   Sex       1313 non-null   object 
 4   Survived  1313 non-null   int64  
 5   SexCode   1313 non-null   int64  
dtypes: float64(1), int64(2), object(3)
memory usage: 61.7+ KB

df.dtypes

Name         object
PClass       object
Age         float64
Sex          object
Survived      int64
SexCode       int64
dtype: object

Manipuler un jeu de données

Interroger le data frame avec le nom des colonnes

df.PClass

0       1st
1       1st
2       1st
3       1st
4       1st
       ... 
1308    3rd
1309    3rd
1310    3rd
1311    3rd
1312    3rd
Name: PClass, Length: 1313, dtype: object

df['PClass']

0       1st
1       1st
2       1st
3       1st
4       1st
       ... 
1308    3rd
1309    3rd
1310    3rd
1311    3rd
1312    3rd
Name: PClass, Length: 1313, dtype: object

Tester le type de l'objet que renvoie la méthode type() sur une colonne du dataframe

type(df['PClass'])

pandas.core.series.Series

Nous n'avons pas l'information sur le type des données que rassemble cette colonne. En revanche, l'objet est une série pandas. Avec pandas, les différents vecteurs ou colonnes d''une dataframe sont appelées "Series". Un DataFrame pandas est donc une collection de pd.Series.

Sélectionner deux colonnes en mêmes temps

df[['Name','PClass']]

	Name	PClass
0	Allen, Miss Elisabeth Walton	1st
1	Allison, Miss Helen Loraine	1st
2	Allison, Mr Hudson Joshua Creighton	1st
3	Allison, Mrs Hudson JC (Bessie Waldo Daniels)	1st
4	Allison, Master Hudson Trevor	1st
...	...	...
1308	Zakarian, Mr Artun	3rd
1309	Zakarian, Mr Maprieder	3rd
1310	Zenni, Mr Philip	3rd
1311	Lievens, Mr Rene	3rd
1312	Zimmerman, Leo	3rd

1313 rows × 2 columns

Il suffit de donner une liste avec des noms de colonnes.
⚠ L'ordre des colonnes renvoyé est le même que celles de la liste

df[['PClass','Name']]

	PClass	Name
0	1st	Allen, Miss Elisabeth Walton
1	1st	Allison, Miss Helen Loraine
2	1st	Allison, Mr Hudson Joshua Creighton
3	1st	Allison, Mrs Hudson JC (Bessie Waldo Daniels)
4	1st	Allison, Master Hudson Trevor
...	...	...
1308	3rd	Zakarian, Mr Artun
1309	3rd	Zakarian, Mr Maprieder
1310	3rd	Zenni, Mr Philip
1311	3rd	Lievens, Mr Rene
1312	3rd	Zimmerman, Leo

1313 rows × 2 columns

Des lors que l'objet retouné a plus de 1 une colonne, c'est un objet pandas DataFrame et non pandas Series

type(df[['PClass','Name']])

pandas.core.frame.DataFrame

Interroger le data frame avec les indices lignes/colonnes

La méthode iloc[ ] permet d'interroger un data frame Pandas avec les indices

#Afficher la première ligne
df.iloc[0]

Name        Allen, Miss Elisabeth Walton
PClass                               1st
Age                                 29.0
Sex                               female
Survived                               1
SexCode                                1
Name: 0, dtype: object

#Afficher la première colonne
df.iloc[:,0]

0                        Allen, Miss Elisabeth Walton
1                         Allison, Miss Helen Loraine
2                 Allison, Mr Hudson Joshua Creighton
3       Allison, Mrs Hudson JC (Bessie Waldo Daniels)
4                       Allison, Master Hudson Trevor
                            ...                      
1308                               Zakarian, Mr Artun
1309                           Zakarian, Mr Maprieder
1310                                 Zenni, Mr Philip
1311                                 Lievens, Mr Rene
1312                                   Zimmerman, Leo
Name: Name, Length: 1313, dtype: object

#Afficher les 3 premières lignes de la première colonne
df.iloc[:3,0]

0           Allen, Miss Elisabeth Walton
1            Allison, Miss Helen Loraine
2    Allison, Mr Hudson Joshua Creighton
Name: Name, dtype: object

#Afficher les 3 premières lignes
df.iloc[0:3,:]

	Name	PClass	Age	Sex	Survived	SexCode
0	Allen, Miss Elisabeth Walton	1st	29.0	female	1	1
1	Allison, Miss Helen Loraine	1st	2.0	female	0	1
2	Allison, Mr Hudson Joshua Creighton	1st	30.0	male	0	0

⚠ En python, la borne extérieure d'une plage est toujours ouverte, c'est pourquoi la ligne d'indice 3 correspondant à la ligne 4 ne s'affiche pas contrairement à une liste

#Afficher les 3 premières lignes
df.iloc[ [0,1,2,3] ,:]

	Name	PClass	Age	Sex	Survived	SexCode
0	Allen, Miss Elisabeth Walton	1st	29.0	female	1	1
1	Allison, Miss Helen Loraine	1st	2.0	female	0	1
2	Allison, Mr Hudson Joshua Creighton	1st	30.0	male	0	0
3	Allison, Mrs Hudson JC (Bessie Waldo Daniels)	1st	25.0	female	0	1

#Afficher la dernière lignes
df.iloc[-1,:]

Name        Zimmerman, Leo
PClass                 3rd
Age                   29.0
Sex                   male
Survived                 0
SexCode                  0
Name: 1312, dtype: object

La méthode loc[ ] permet d'interroger un data frame Pandas avec le nom des lignes et des colonnes

df.loc[:, ['PClass','Name']]

	PClass	Name
0	1st	Allen, Miss Elisabeth Walton
1	1st	Allison, Miss Helen Loraine
2	1st	Allison, Mr Hudson Joshua Creighton
3	1st	Allison, Mrs Hudson JC (Bessie Waldo Daniels)
4	1st	Allison, Master Hudson Trevor
...	...	...
1308	3rd	Zakarian, Mr Artun
1309	3rd	Zakarian, Mr Maprieder
1310	3rd	Zenni, Mr Philip
1311	3rd	Lievens, Mr Rene
1312	3rd	Zimmerman, Leo

1313 rows × 2 columns

L'association des méthodes columns et difference permet d'afficher toutes les colonnes d'un data frame exceptées celles mentionnées

df.columns.difference(['Age','SexCode'])

Index(['Name', 'PClass', 'Sex', 'Survived'], dtype='object')

On réutilise cette liste sans les variables mentionnées directement dans l'indexation du data frame

df[  df.columns.difference(['Age','SexCode'])  ].head(3)

	Name	PClass	Sex	Survived
0	Allen, Miss Elisabeth Walton	1st	female	1
1	Allison, Miss Helen Loraine	1st	female	0
2	Allison, Mr Hudson Joshua Creighton	1st	male	0

📢 Attention : Lorqu'on utilise cette méthode, la liste des colonnes affichées est triée par ordre alphabetique ce qui conduit à une réorganisation du tableau de départ

df.columns

Index(['Name', 'PClass', 'Age', 'Sex', 'Survived', 'SexCode'], dtype='object')

df.columns.difference([''])

Index(['Age', 'Name', 'PClass', 'Sex', 'SexCode', 'Survived'], dtype='object')

Interroger le data frame avec des filtres

Pour cela on utilise les opérateurs logiques qui permettent de renvoyer des booléens.

#Tester une égalité
df.PClass == "1st"

0        True
1        True
2        True
3        True
4        True
        ...  
1308    False
1309    False
1310    False
1311    False
1312    False
Name: PClass, Length: 1313, dtype: bool

df[df.PClass == "1st"]

	Name	PClass	Age	Sex	Survived	SexCode
0	Allen, Miss Elisabeth Walton	1st	29.00	female	1	1
1	Allison, Miss Helen Loraine	1st	2.00	female	0	1
2	Allison, Mr Hudson Joshua Creighton	1st	30.00	male	0	0
3	Allison, Mrs Hudson JC (Bessie Waldo Daniels)	1st	25.00	female	0	1
4	Allison, Master Hudson Trevor	1st	0.92	male	1	0
...	...	...	...	...	...	...
317	Robbins, Mr Victor	1st	NaN	male	0	0
318	Segesser, Mlle Emma	1st	NaN	female	1	1
319	Seredeca, Ms	1st	NaN	female	0	1
320	Ward, Ms Anna	1st	NaN	female	0	1
321	Wilson, Ms Helen	1st	NaN	female	1	1

322 rows × 6 columns

#Tester une différence
df.PClass != "3rd"

0        True
1        True
2        True
3        True
4        True
        ...  
1308    False
1309    False
1310    False
1311    False
1312    False
Name: PClass, Length: 1313, dtype: bool

df[df.PClass != "3rd"]

	Name	PClass	Age	Sex	Survived	SexCode
0	Allen, Miss Elisabeth Walton	1st	29.00	female	1	1
1	Allison, Miss Helen Loraine	1st	2.00	female	0	1
2	Allison, Mr Hudson Joshua Creighton	1st	30.00	male	0	0
3	Allison, Mrs Hudson JC (Bessie Waldo Daniels)	1st	25.00	female	0	1
4	Allison, Master Hudson Trevor	1st	0.92	male	1	0
...	...	...	...	...	...	...
597	Yrois, Miss Henriette	2nd	NaN	female	0	1
598	Aldworth, Mr Charles Augustus	2nd	30.00	male	0	0
599	Brown, Miss Mildred	2nd	24.00	female	1	1
600	Pernot, Mr Rene	2nd	NaN	male	0	0
601	Swane, Mr George	2nd	18.00	male	0	0

602 rows × 6 columns

#Tester si supérieur
df.Age > 20

0        True
1       False
2        True
3        True
4       False
        ...  
1308     True
1309     True
1310     True
1311     True
1312     True
Name: Age, Length: 1313, dtype: bool

df[df.Age > 20]

	Name	PClass	Age	Sex	Survived	SexCode
0	Allen, Miss Elisabeth Walton	1st	29.0	female	1	1
2	Allison, Mr Hudson Joshua Creighton	1st	30.0	male	0	0
3	Allison, Mrs Hudson JC (Bessie Waldo Daniels)	1st	25.0	female	0	1
5	Anderson, Mr Harry	1st	47.0	male	1	0
6	Andrews, Miss Kornelia Theodosia	1st	63.0	female	1	1
...	...	...	...	...	...	...
1308	Zakarian, Mr Artun	3rd	27.0	male	0	0
1309	Zakarian, Mr Maprieder	3rd	26.0	male	0	0
1310	Zenni, Mr Philip	3rd	22.0	male	0	0
1311	Lievens, Mr Rene	3rd	24.0	male	0	0
1312	Zimmerman, Leo	3rd	29.0	male	0	0

584 rows × 6 columns

#Tester si comris dans des bornes
(df.Age > 15) & (df.Age < 30)

0        True
1       False
2       False
3        True
4       False
        ...  
1308     True
1309     True
1310     True
1311     True
1312     True
Name: Age, Length: 1313, dtype: bool

df[(df.Age > 15) & (df.Age < 30)]

	Name	PClass	Age	Sex	Survived	SexCode
0	Allen, Miss Elisabeth Walton	1st	29.0	female	1	1
3	Allison, Mrs Hudson JC (Bessie Waldo Daniels)	1st	25.0	female	0	1
11	Astor, Mrs John Jacob (Madeleine Talmadge Force)	1st	19.0	female	1	1
16	Baxter, Mr Quigg Edmond	1st	24.0	male	0	0
20	Behr, Mr Karl Howell	1st	26.0	male	1	0
...	...	...	...	...	...	...
1308	Zakarian, Mr Artun	3rd	27.0	male	0	0
1309	Zakarian, Mr Maprieder	3rd	26.0	male	0	0
1310	Zenni, Mr Philip	3rd	22.0	male	0	0
1311	Lievens, Mr Rene	3rd	24.0	male	0	0
1312	Zimmerman, Leo	3rd	29.0	male	0	0

328 rows × 6 columns

#Tester avec deux valeurs possibles 
(df.PClass == "1st") | (df.PClass == "2nd")

0        True
1        True
2        True
3        True
4        True
        ...  
1308    False
1309    False
1310    False
1311    False
1312    False
Name: PClass, Length: 1313, dtype: bool

df[(df.PClass == "1st") | (df.PClass == "2nd")]

	Name	PClass	Age	Sex	Survived	SexCode
0	Allen, Miss Elisabeth Walton	1st	29.00	female	1	1
1	Allison, Miss Helen Loraine	1st	2.00	female	0	1
2	Allison, Mr Hudson Joshua Creighton	1st	30.00	male	0	0
3	Allison, Mrs Hudson JC (Bessie Waldo Daniels)	1st	25.00	female	0	1
4	Allison, Master Hudson Trevor	1st	0.92	male	1	0
...	...	...	...	...	...	...
597	Yrois, Miss Henriette	2nd	NaN	female	0	1
598	Aldworth, Mr Charles Augustus	2nd	30.00	male	0	0
599	Brown, Miss Mildred	2nd	24.00	female	1	1
600	Pernot, Mr Rene	2nd	NaN	male	0	0
601	Swane, Mr George	2nd	18.00	male	0	0

602 rows × 6 columns

#Tester si compris dans la liste
df.PClass.isin(['1st', '2nd'])

0        True
1        True
2        True
3        True
4        True
        ...  
1308    False
1309    False
1310    False
1311    False
1312    False
Name: PClass, Length: 1313, dtype: bool

df[df.PClass.isin(['1st', '2nd'])]

	Name	PClass	Age	Sex	Survived	SexCode
0	Allen, Miss Elisabeth Walton	1st	29.00	female	1	1
1	Allison, Miss Helen Loraine	1st	2.00	female	0	1
2	Allison, Mr Hudson Joshua Creighton	1st	30.00	male	0	0
3	Allison, Mrs Hudson JC (Bessie Waldo Daniels)	1st	25.00	female	0	1
4	Allison, Master Hudson Trevor	1st	0.92	male	1	0
...	...	...	...	...	...	...
597	Yrois, Miss Henriette	2nd	NaN	female	0	1
598	Aldworth, Mr Charles Augustus	2nd	30.00	male	0	0
599	Brown, Miss Mildred	2nd	24.00	female	1	1
600	Pernot, Mr Rene	2nd	NaN	male	0	0
601	Swane, Mr George	2nd	18.00	male	0	0

602 rows × 6 columns

#Tester si n'est pas compris dans la liste
~ df.PClass.isin(['1st', '2nd'])

0       False
1       False
2       False
3       False
4       False
        ...  
1308     True
1309     True
1310     True
1311     True
1312     True
Name: PClass, Length: 1313, dtype: bool

~pd.Series([True,False,True,True])

0    False
1     True
2    False
3    False
dtype: bool

En réalité, l'opérateur ~ permet de renvoyer l'inverse des tests logiques effectués

df[~ df.PClass.isin(['1st', '2nd'])]

	Name	PClass	Age	Sex	Survived	SexCode
602	Abbing, Mr Anthony	3rd	42.0	male	0	0
603	Abbott, Master Eugene Joseph	3rd	13.0	male	0	0
604	Abbott, Mr Rossmore Edward	3rd	16.0	male	0	0
605	Abbott, Mrs Stanton (Rosa)	3rd	35.0	female	1	1
606	Abelseth, Miss Anna Karen	3rd	16.0	female	1	1
...	...	...	...	...	...	...
1308	Zakarian, Mr Artun	3rd	27.0	male	0	0
1309	Zakarian, Mr Maprieder	3rd	26.0	male	0	0
1310	Zenni, Mr Philip	3rd	22.0	male	0	0
1311	Lievens, Mr Rene	3rd	24.0	male	0	0
1312	Zimmerman, Leo	3rd	29.0	male	0	0

711 rows × 6 columns

Les méthodes isna() et notna() permettent d'effectuer des filtres sur des valeurs manquantes

df.Age.isna()

0       False
1       False
2       False
3       False
4       False
        ...  
1308    False
1309    False
1310    False
1311    False
1312    False
Name: Age, Length: 1313, dtype: bool

df[df.Age.isna()]

	Name	PClass	Age	Sex	Survived	SexCode
12	Aubert, Mrs Leontine Pauline	1st	NaN	female	1	1
13	Barkworth, Mr Algernon H	1st	NaN	male	1	0
14	Baumann, Mr John D	1st	NaN	male	0	0
29	Borebank, Mr John James	1st	NaN	male	0	0
32	Bradley, Mr George	1st	NaN	male	1	0
...	...	...	...	...	...	...
1300	Wiseman, Mr Phillippe	3rd	NaN	male	0	0
1302	Yalsevac, Mr Ivan	3rd	NaN	male	1	0
1305	Youssef, Mr Gerios	3rd	NaN	male	0	0
1306	Zabour, Miss Hileni	3rd	NaN	female	0	1
1307	Zabour, Miss Tamini	3rd	NaN	female	0	1

557 rows × 6 columns

df.Age.notna()

0       True
1       True
2       True
3       True
4       True
        ... 
1308    True
1309    True
1310    True
1311    True
1312    True
Name: Age, Length: 1313, dtype: bool

df[df.Age.notna()]

	Name	PClass	Age	Sex	Survived	SexCode
0	Allen, Miss Elisabeth Walton	1st	29.00	female	1	1
1	Allison, Miss Helen Loraine	1st	2.00	female	0	1
2	Allison, Mr Hudson Joshua Creighton	1st	30.00	male	0	0
3	Allison, Mrs Hudson JC (Bessie Waldo Daniels)	1st	25.00	female	0	1
4	Allison, Master Hudson Trevor	1st	0.92	male	1	0
...	...	...	...	...	...	...
1308	Zakarian, Mr Artun	3rd	27.00	male	0	0
1309	Zakarian, Mr Maprieder	3rd	26.00	male	0	0
1310	Zenni, Mr Philip	3rd	22.00	male	0	0
1311	Lievens, Mr Rene	3rd	24.00	male	0	0
1312	Zimmerman, Leo	3rd	29.00	male	0	0

756 rows × 6 columns

Trier un jeu de données

On utilise la méthode sort_values() pour trier un data frame ou une série pandas

#On trie la série Age
df.Age.sort_values()

763     0.17
751     0.33
544     0.80
616     0.83
358     0.83
        ... 
1300     NaN
1302     NaN
1305     NaN
1306     NaN
1307     NaN
Name: Age, Length: 1313, dtype: float64

#On trie la série Age par ordre décroissant
df.Age.sort_values(ascending=False)

505     71.0
119     71.0
9       71.0
72      70.0
73      69.0
        ... 
1300     NaN
1302     NaN
1305     NaN
1306     NaN
1307     NaN
Name: Age, Length: 1313, dtype: float64

# On trie le data frame
df.sort_values(by = 'Age', ascending=False)

	Name	PClass	Age	Sex	Survived	SexCode
505	Mitchell, Mr Henry Michael	2nd	71.0	male	0	0
119	Goldschmidt, Mr George B	1st	71.0	male	0	0
9	Artagaveytia, Mr Ramon	1st	71.0	male	0	0
72	Crosby, Captain Edward Gifford	1st	70.0	male	0	0
73	Crosby, Mrs Edward Gifford (Catherine Elizabet...	1st	69.0	female	1	1
...	...	...	...	...	...	...
1300	Wiseman, Mr Phillippe	3rd	NaN	male	0	0
1302	Yalsevac, Mr Ivan	3rd	NaN	male	1	0
1305	Youssef, Mr Gerios	3rd	NaN	male	0	0
1306	Zabour, Miss Hileni	3rd	NaN	female	0	1
1307	Zabour, Miss Tamini	3rd	NaN	female	0	1

1313 rows × 6 columns

# On trie le data frame avec selon plusieurs colonnes
df.sort_values(by = ['PClass','Age'], ascending=[True,False])

	Name	PClass	Age	Sex	Survived	SexCode
9	Artagaveytia, Mr Ramon	1st	71.0	male	0	0
119	Goldschmidt, Mr George B	1st	71.0	male	0	0
72	Crosby, Captain Edward Gifford	1st	70.0	male	0	0
73	Crosby, Mrs Edward Gifford (Catherine Elizabet...	1st	69.0	female	1	1
252	Straus, Mr Isidor	1st	67.0	male	0	0
...	...	...	...	...	...	...
1300	Wiseman, Mr Phillippe	3rd	NaN	male	0	0
1302	Yalsevac, Mr Ivan	3rd	NaN	male	1	0
1305	Youssef, Mr Gerios	3rd	NaN	male	0	0
1306	Zabour, Miss Hileni	3rd	NaN	female	0	1
1307	Zabour, Miss Tamini	3rd	NaN	female	0	1

1313 rows × 6 columns

Exploration statistique sur un jeu de données

On utilise souvent la librairie numpy avec pandas

import numpy as np

Indicateurs statistiques

df.Age.mean()

30.397989417989415

df.Age.median()

28.0

df.Age.max()

71.0

df.Age.std()

14.259048710359023

df.Age.var()

203.32047012439133

df.Age.quantile([.1, .5])

0.1    16.0
0.5    28.0
Name: Age, dtype: float64

df.Age.quantile(np.linspace(start = 0, stop = 1, num= 11))

0.0     0.17
0.1    16.00
0.2    20.00
0.3    22.00
0.4    25.00
0.5    28.00
0.6    32.00
0.7    36.00
0.8    43.00
0.9    50.00
1.0    71.00
Name: Age, dtype: float64

La méthode describe() calcule des statistiques élémentaires sur les données

df.describe()

	Age	Survived	SexCode
count	756.000000	1313.000000	1313.000000
mean	30.397989	0.342727	0.351866
std	14.259049	0.474802	0.477734
min	0.170000	0.000000	0.000000
25%	21.000000	0.000000	0.000000
50%	28.000000	0.000000	0.000000
75%	39.000000	1.000000	1.000000
max	71.000000	1.000000	1.000000

L'argument include permet de prendre en compte toutes les colonnes quelques soit leur type

df.describe(include = "all")

	Name	PClass	Age	Sex	Survived	SexCode
count	1313	1313	756.000000	1313	1313.000000	1313.000000
unique	1310	3	NaN	2	NaN	NaN
top	Carlsson, Mr Frans Olof	3rd	NaN	male	NaN	NaN
freq	2	711	NaN	851	NaN	NaN
mean	NaN	NaN	30.397989	NaN	0.342727	0.351866
std	NaN	NaN	14.259049	NaN	0.474802	0.477734
min	NaN	NaN	0.170000	NaN	0.000000	0.000000
25%	NaN	NaN	21.000000	NaN	0.000000	0.000000
50%	NaN	NaN	28.000000	NaN	0.000000	0.000000
75%	NaN	NaN	39.000000	NaN	1.000000	1.000000
max	NaN	NaN	71.000000	NaN	1.000000	1.000000

df.describe(exclude=[np.number])

	Name	PClass	Sex
count	1313	1313	1313
unique	1310	3	2
top	Carlsson, Mr Frans Olof	3rd	male
freq	2	711	851

df.describe(include=[np.number])

	Age	Survived	SexCode
count	756.000000	1313.000000	1313.000000
mean	30.397989	0.342727	0.351866
std	14.259049	0.474802	0.477734
min	0.170000	0.000000	0.000000
25%	21.000000	0.000000	0.000000
50%	28.000000	0.000000	0.000000
75%	39.000000	1.000000	1.000000
max	71.000000	1.000000	1.000000

L'argument percentiles permet d'avoir la main sur les quantiles affichés

df.describe(percentiles=np.linspace(start = 0, stop = 1, num= 11))

	Age	Survived	SexCode
count	756.000000	1313.000000	1313.000000
mean	30.397989	0.342727	0.351866
std	14.259049	0.474802	0.477734
min	0.170000	0.000000	0.000000
0%	0.170000	0.000000	0.000000
10%	16.000000	0.000000	0.000000
20%	20.000000	0.000000	0.000000
30%	22.000000	0.000000	0.000000
40%	25.000000	0.000000	0.000000
50%	28.000000	0.000000	0.000000
60%	32.000000	0.000000	0.000000
70%	36.000000	1.000000	1.000000
80%	43.000000	1.000000	1.000000
90%	50.000000	1.000000	1.000000
100%	71.000000	1.000000	1.000000
max	71.000000	1.000000	1.000000

La méthode unique() renvoie une liste des valeurs uniques d'une Series pandas

df.PClass.unique()

array(['1st', '2nd', '3rd'], dtype=object)

La méthode nunique() compte le nombre de valeurs uniques d'une Series pandas

df.PClass.nunique()

3

Cela fonctionne aussi sur un data frame

df.nunique()

Name        1310
PClass         3
Age           75
Sex            2
Survived       2
SexCode        2
dtype: int64

La méthode value_counts() renvoie un tri à plat d'une Series pandas

df.PClass.value_counts()

3rd    711
1st    322
2nd    280
Name: PClass, dtype: int64

#en pourcentage
df.PClass.value_counts(normalize=True)

3rd    0.541508
1st    0.245240
2nd    0.213252
Name: PClass, dtype: float64

Grouper les données

Tableaux croisés

La méthode crosstab() permet de calculer un tableau croisé

pd.crosstab(df.PClass, df.Sex, margins=True)

Sex	female	male	All
PClass
1st	143	179	322
2nd	107	173	280
3rd	212	499	711
All	462	851	1313

#pourcentage total général
pd.crosstab(df.PClass, df.Sex, margins=True, normalize = True)

Sex	female	male	All
PClass
1st	0.108911	0.136329	0.245240
2nd	0.081493	0.131759	0.213252
3rd	0.161462	0.380046	0.541508
All	0.351866	0.648134	1.000000

Pour un tableau croisé en pourcentage on utilise la méthode apply() permet de mapper une fonction sur tout les éléments de l'objet

#pourcentage colonne
pd.crosstab(df.PClass, df.Sex).apply(lambda x: x/x.sum(), axis=0)

Sex	female	male
PClass
1st	0.309524	0.210341
2nd	0.231602	0.203290
3rd	0.458874	0.586369

#pourcentage ligne
pd.crosstab(df.PClass, df.Sex).apply(lambda x: x/x.sum(), axis=1)

Sex	female	male
PClass
1st	0.444099	0.555901
2nd	0.382143	0.617857
3rd	0.298172	0.701828

Agrégation

On utilise la méthode groupby() pour grouper les données. Il faut ensuite utiliser agg() pour calculer des indicateurs pour chaque groupe

df.groupby(['PClass']).Age.agg([min, max])

	min	max
PClass
1st	0.92	71.0
2nd	0.80	71.0
3rd	0.17	65.0

On peut grouper les données selon plusieurs variables

df.groupby(['PClass','Sex']).Age.agg([min, max])

		min	max
PClass	Sex
1st	female	2.00	69.0
	male	0.92	71.0
2nd	female	1.00	57.0
	male	0.80	71.0
3rd	female	0.17	63.0
	male	0.33	65.0

On peut aussi utiliser un dictionnaire

df_agg = df.groupby(['PClass','Sex']).agg( { 'Age' : ['min','max'] , 'PClass' : 'count'  })
df_agg

		Age		PClass
		min	max	count
PClass	Sex
1st	female	2.00	69.0	143
	male	0.92	71.0	179
2nd	female	1.00	57.0	107
	male	0.80	71.0	173
3rd	female	0.17	63.0	212
	male	0.33	65.0	499

Ce code permet d'éliminer les deux niveaux d'index colonne en concatenant les noms

df_agg.columns = ['_'.join(col) for col in df_agg.columns]
df_agg

		Age_min	Age_max	PClass_count
PClass	Sex
1st	female	2.00	69.0	143
	male	0.92	71.0	179
2nd	female	1.00	57.0	107
	male	0.80	71.0	173
3rd	female	0.17	63.0	212
	male	0.33	65.0	499

⚠ Le résultat utilise plusieurs index pour chaque ligne et colonne.

On utilise la méthode reset_index() pour mettre les index ligne en colonne

df.groupby(['PClass','Sex']).Age.agg([min, max]).reset_index()

	PClass	Sex	min	max
0	1st	female	2.00	69.0
1	1st	male	0.92	71.0
2	2nd	female	1.00	57.0
3	2nd	male	0.80	71.0
4	3rd	female	0.17	63.0
5	3rd	male	0.33	65.0

Modifier un jeu de données

Changement de type des variables

df.dtypes

Name         object
PClass       object
Age         float64
Sex          object
Survived      int64
SexCode       int64
dtype: object

On transforme la variable Survived en caractère

df.Survived = df.Survived.astype('str')
df.dtypes

Name         object
PClass       object
Age         float64
Sex          object
Survived     object
SexCode       int64
dtype: object

On la repasse en numérique

df.Survived = df.Survived.astype('int')
df.dtypes

Name         object
PClass       object
Age         float64
Sex          object
Survived      int64
SexCode       int64
dtype: object

Renommer des colonnes

df.columns

Index(['Name', 'PClass', 'Age', 'Sex', 'Survived', 'SexCode'], dtype='object')

On utilise la méthode rename() pour renommer une colonne

df.rename(columns={'PClass': 'Classe passager',
                  'Age': 'Age passager'}, inplace=True)

df.columns

Index(['Name', 'Classe passager', 'Age passager', 'Sex', 'Survived',
       'SexCode'],
      dtype='object')

💡 Quelques fois, il est pénible de manipuler des variables avec des espaces, voici une commande pour remplacer les espaces par un '_'

df.columns = df.columns.str.replace(' ', '_')
df.columns

Index(['Name', 'Classe_passager', 'Age_passager', 'Sex', 'Survived',
       'SexCode'],
      dtype='object')

On remet le nom des colonnes d'origine

df.rename(columns={'Classe_passager': 'PClass',
                  'Age_passager': 'Age'}, inplace=True)

Gerer les valeurs manquantes

Remplacer avec fillna()

On observe les valeurs manquantes présentent dans la variable age

df.rename(columns={'Age_passager': 'Age'}, inplace=True)

df.Age.isna().value_counts()

False    756
True     557
Name: Age, dtype: int64

df.Age.describe()

count    756.000000
mean      30.397989
std       14.259049
min        0.170000
25%       21.000000
50%       28.000000
75%       39.000000
max       71.000000
Name: Age, dtype: float64

On remplace les valeurs manquantes par des 0 avec la méthode fillna() dans une nouvelle colonne

df['Age_fillna_0'] = df.Age.fillna(0)

On remarque qu'il n'y a plus de valeurs manquantes

df.Age_fillna_0.isna().value_counts()

False    1313
Name: Age_fillna_0, dtype: int64

⚠ Cela modifie la structure des données (ex : moyenne)

df.Age_fillna_0.describe()

count    1313.000000
mean       17.502574
std        18.516945
min         0.000000
25%         0.000000
50%        18.000000
75%        30.000000
max        71.000000
Name: Age_fillna_0, dtype: float64

L'astuce pourrait-être de remplacer les valeurs manquantes par la moyenne ?

#calcul de la moyenne
mean = df.Age.mean()

On remplace par la moyenne

df['Age_fillna_mean'] = df.Age.fillna(mean)

⚠ Cela modifie la structure des données sauf la moyenne

df.Age_fillna_mean.describe()

count    1313.000000
mean       30.397989
std        10.816758
min         0.170000
25%        26.000000
50%        30.397989
75%        30.397989
max        71.000000
Name: Age_fillna_mean, dtype: float64

Récapitulatif des méthodes utilisées

df[df.Age.isna()].iloc[:,[2,6,7]]

	Age	Age_fillna_0	Age_fillna_mean
12	NaN	0.0	30.397989
13	NaN	0.0	30.397989
14	NaN	0.0	30.397989
29	NaN	0.0	30.397989
32	NaN	0.0	30.397989
...	...	...	...
1300	NaN	0.0	30.397989
1302	NaN	0.0	30.397989
1305	NaN	0.0	30.397989
1306	NaN	0.0	30.397989
1307	NaN	0.0	30.397989

557 rows × 3 columns

On supprime les colonnes crées

df.drop(columns=['Age_fillna_0', 'Age_fillna_mean'], inplace=True)

Supprimer avec dropna()

Une autre méthode plus radicale consiste à supprimer les observations ou colonnes avec des valeurs manquantes. On utilise la méthode dropna() avec :

• axis = 0 pour les lignes et 1 pour les colonnes
• how = 'all' si des NaN sur l'ensemble des les lignes/ colonne ouf how = 'any' si au moins un NaN sur l'ensemble des les lignes/ colonne

df.dropna(axis=0, how="all").shape

(1313, 6)

df.dropna(axis=0, how="any").shape

(756, 6)

⚠ On peut utiliser l'argument inplace = True pour modifier directement le data frame

#avant le dropna()
df.shape

(1313, 6)

df.dropna(axis=0, how="any", inplace=True)

#après le dropna()
df.shape

(756, 6)

Remplacer avec KNNImputer()

Cette méthode consiste à utiliser l'algorithme des K-plus proches voisins.
https://scikit-learn.org/stable/modules/generated/sklearn.impute.KNNImputer.html

d = {'x': [5, 10, np.nan, 20], 'y': [np.nan,4,6,9]}
X = pd.DataFrame(d)
X

	x	y
0	5.0	NaN
1	10.0	4.0
2	NaN	6.0
3	20.0	9.0

💡 L'argument weights permet de pondérer la moyenne des voisins les plus proches leur distance de proximité.

from sklearn.impute import KNNImputer
imputer = KNNImputer(n_neighbors=2, weights="distance")
X = pd.DataFrame(imputer.fit_transform(X), columns = X.columns)
X

	x	y
0	5.0	5.25
1	10.0	4.00
2	14.0	6.00
3	20.0	9.00

⚠ Cette méthode ne fonctionne que sur des variables numériques !

Gérer les doublons

On remarque que certaines personnes sont présentes deux fois

df_counts_name = df.Name.value_counts()
df_counts_name

Connolly, Miss Kate                     2
Carlsson, Mr Frans Olof                 2
Kelly, Mr James                         2
Ryerson, Miss Susan (Suzette) Parker    1
Kenyon, Mr Frederick R                  1
                                       ..
Bishop, Mr Dickinson H                  1
Andersson, Miss Ingeborg Constancia     1
Walker, Mr William Anderson             1
Brown, Miss Mildred                     1
Badt, Mr Mohamed                        1
Name: Name, Length: 753, dtype: int64

On récupère le nom des personnes en doublon avec la méthode index

doublons = df_counts_name[ df_counts_name > 1].index
print(doublons)

Index(['Connolly, Miss Kate', 'Carlsson, Mr Frans Olof', 'Kelly, Mr James'], dtype='object')

On filtre le data frame sur les doublons pour observer s'il y a bien une erreur ou s'il s'agit d'homonyme

df_doublons = df[df.Name.isin(doublons)]
df_doublons

	Name	PClass	Age	Sex	Survived	SexCode
44	Carlsson, Mr Frans Olof	1st	33.0	male	0	0
707	Carlsson, Mr Frans Olof	3rd	33.0	male	0	0
728	Connolly, Miss Kate	3rd	30.0	female	0	1
729	Connolly, Miss Kate	3rd	22.0	female	1	1
921	Kelly, Mr James	3rd	44.0	male	0	0
922	Kelly, Mr James	3rd	42.0	male	0	0

Pour illustrer les méthodes pour dédoubloner, on travaille sur le dataset df_doublons

La première méthode consiste à supprimer les doublons basés sur une seule colonne

df_doublons.drop_duplicates(subset=['Name'])

	Name	PClass	Age	Sex	Survived	SexCode
44	Carlsson, Mr Frans Olof	1st	33.0	male	0	0
728	Connolly, Miss Kate	3rd	30.0	female	0	1
921	Kelly, Mr James	3rd	44.0	male	0	0

La deuxième méthode consiste à supprimer les doublons basés sur plusieurs colonnes à la fois

df_doublons

	Name	PClass	Age	Sex	Survived	SexCode
44	Carlsson, Mr Frans Olof	1st	33.0	male	0	0
707	Carlsson, Mr Frans Olof	3rd	33.0	male	0	0
728	Connolly, Miss Kate	3rd	30.0	female	0	1
729	Connolly, Miss Kate	3rd	22.0	female	1	1
921	Kelly, Mr James	3rd	44.0	male	0	0
922	Kelly, Mr James	3rd	42.0	male	0	0

df_doublons.drop_duplicates(subset=['Name',"PClass"])

	Name	PClass	Age	Sex	Survived	SexCode
44	Carlsson, Mr Frans Olof	1st	33.0	male	0	0
707	Carlsson, Mr Frans Olof	3rd	33.0	male	0	0
728	Connolly, Miss Kate	3rd	30.0	female	0	1
921	Kelly, Mr James	3rd	44.0	male	0	0

Les deux dernières méthodes consistent à supprimer les doublons selon leur position dans le data frame en utilisant la méthode groupby() avec tail() ou nth()

On sélectionne la première ligne ou apparaît le doublon

df_doublons.groupby('Name').nth(0)

	PClass	Age	Sex	Survived	SexCode
Name
Carlsson, Mr Frans Olof	1st	33.0	male	0	0
Connolly, Miss Kate	3rd	30.0	female	0	1
Kelly, Mr James	3rd	44.0	male	0	0

On sélectionne les x dernières lignes ou apparaît le doublon

df_doublons.groupby('Name').tail(1)

	Name	PClass	Age	Sex	Survived	SexCode
707	Carlsson, Mr Frans Olof	3rd	33.0	male	0	0
729	Connolly, Miss Kate	3rd	22.0	female	1	1
922	Kelly, Mr James	3rd	42.0	male	0	0

Créer de nouvelle variables

Discrétisation

La méthode cut() permet de découper une variable numérique en tranche

pd.cut(df.Age, bins = [0,18,40,150])

0       (18, 40]
1        (0, 18]
2       (18, 40]
3       (18, 40]
4        (0, 18]
          ...   
1308    (18, 40]
1309    (18, 40]
1310    (18, 40]
1311    (18, 40]
1312    (18, 40]
Name: Age, Length: 756, dtype: category
Categories (3, interval[int64]): [(0, 18] < (18, 40] < (40, 150]]

⚠ L'argument include_lowest est important pour prendre en compte la plus petite borne inférieure

pd.cut(df.Age, bins = [0,18,40,150], include_lowest=True)

0         (18.0, 40.0]
1       (-0.001, 18.0]
2         (18.0, 40.0]
3         (18.0, 40.0]
4       (-0.001, 18.0]
             ...      
1308      (18.0, 40.0]
1309      (18.0, 40.0]
1310      (18.0, 40.0]
1311      (18.0, 40.0]
1312      (18.0, 40.0]
Name: Age, Length: 756, dtype: category
Categories (3, interval[float64]): [(-0.001, 18.0] < (18.0, 40.0] < (40.0, 150.0]]

On crée une colonne avec ce découpage en ajoutant des labels

df['Age_cut'] = pd.cut(df.Age, bins = [0,18,40,150],
                       labels=['moins de 18','entre 19 et 40','plus de 40'],
                       include_lowest=True)

On affiche un tri à plat en triant selon les index avec la méthode sort_index()

df['Age_cut'].value_counts().sort_index()

moins de 18       126
entre 19 et 40    456
plus de 40        174
Name: Age_cut, dtype: int64

Recodage de variables

On peut utiliser la méthode where() de la librarie numpy

df['PClass_category'] = np.where(df['PClass'] == '1st', '1st', '2nd and 3rd')
df['PClass_category'].value_counts()

2nd and 3rd    530
1st            226
Name: PClass_category, dtype: int64

La méthode get_dummies() permet de construire un condage disjonctif complet (appelé aussi one-hot encoding). Cela est trés utilisé en data science pour traiter les variables qualitatives en machine learning

pd.get_dummies(df, columns=['PClass','Sex']).head(3)

	Name	Age	Survived	SexCode	Age_cut	PClass_category	PClass_1st	PClass_2nd	PClass_3rd	Sex_female	Sex_male
0	Allen, Miss Elisabeth Walton	29.0	1	1	entre 19 et 40	1st	1	0	0	1	0
1	Allison, Miss Helen Loraine	2.0	0	1	moins de 18	1st	1	0	0	1	0
2	Allison, Mr Hudson Joshua Creighton	30.0	0	0	entre 19 et 40	1st	1	0	0	0	1

⚠ Créer autant de colonne que de modalité est problématique car on ajoute des colonnes qui ne sont plus indépendante. C'est pourquoi en machine learning on crée plutot K-1 indicatrices, la dernière modalité étant déduite des autres. L'argument drop_first permet de gérer cela.

df = pd.get_dummies(df, columns=['PClass','Sex'], drop_first=True)
df.head(3)

	Name	Age	Survived	SexCode	Age_cut	PClass_category	PClass_2nd	PClass_3rd	Sex_male
0	Allen, Miss Elisabeth Walton	29.0	1	1	entre 19 et 40	1st	0	0	0
1	Allison, Miss Helen Loraine	2.0	0	1	moins de 18	1st	0	0	0
2	Allison, Mr Hudson Joshua Creighton	30.0	0	0	entre 19 et 40	1st	0	0	1

Exporter le jeu de données

On exporte le data frame avec la méthode to_mon_format() selon l'extension du fichier

#df.to_csv("mon_Titanic.csv", index = False)

# df.to_excel(excel_writer = "Titanic.xlsx" , 
#             sheet_name = "Feuil1", index=False)

Créer un objet pandas

Pour céer une Series pandas on utilise la méthode Series()

#Creation des Séries   
ls_prenom = pd.Series(["Wilfried", "Alex", "Morgane", "Etienne", "Célia", "Baptiste", "Anthony", "Fred"])
ls_bi = pd.Series([15,9,12,15,6,14,11,19])
ls_dataviz = pd.Series([14,7,15,13,15,10,12,14])

print(ls_prenom)

0    Wilfried
1        Alex
2     Morgane
3     Etienne
4       Célia
5    Baptiste
6     Anthony
7        Fred
dtype: object

Pour céer un DataFrame pandas on utilise la méthode DataFrame()

d = {'Prenom': ls_prenom, 'BI': ls_bi, 'Dataviz' : ls_dataviz, 'Maths' : [5,20,11,13,5,14,12,16]}
df = pd.DataFrame(data=d)
df

	Prenom	BI	Dataviz	Maths
0	Wilfried	15	14	5
1	Alex	9	7	20
2	Morgane	12	15	11
3	Etienne	15	13	13
4	Célia	6	15	5
5	Baptiste	14	10	14
6	Anthony	11	12	12
7	Fred	19	14	16

Les options pandas

Il est possible de modifier les options d'affichage avec la gestion des options de la librairie pandas

#gerer le nombre de ligne à afficher
pd.set_option("display.min_rows", 2)

#gérer le nombre de colonne à afficher
pd.set_option("display.max_columns", 4)

#gérer la largeur des colonnes
pd.set_option('max_colwidth', 5)

df

	Prenom	BI	Dataviz	Maths
0	W...	15	14	5
1	Alex	9	7	20
2	M...	12	15	11
3	E...	15	13	13
4	C...	6	15	5
5	B...	14	10	14
6	A...	11	12	12
7	Fred	19	14	16

La méthode reset_option() permet de réinitialiser les paramètres

pd.reset_option(("^display"))

df

	Prenom	BI	Dataviz	Maths
0	Wilfried	15	14	5
1	Alex	9	7	20
2	Morgane	12	15	11
3	Etienne	15	13	13
4	Célia	6	15	5
5	Baptiste	14	10	14
6	Anthony	11	12	12
7	Fred	19	14	16

Plus d'information sur la librairie pandas avec le cours de Kaggle : https://www.kaggle.com/learn/pandas

Pandas Profiling

Lancer la ligne de commande dans un terminal, une mise à jour de conda est peut être nécessaire

#conda install -c conda-forge pandas-profiling

# import pandas_profiling

# profile = pandas_profiling.ProfileReport(df, title='Pandas Profiling Report', explorative=True)

# profile