[Link]

com/panda-python/

[Link]

python : Pandas
I) Introduction
Le module pandas a été conçu pour l’analyse de données, tâche principale des Data
Analysts ou les Business Analysts en entreprise. Il est particulièrement puissant pour
manipuler des données structurées sous forme de tableau.

Cela implique par exemple le croisement de données à large échelle, l’uniformisation

de données, les jointures, la validation de données sur la base de contraintes
sémantiques, ou encore la connexion aux bases de données distantes.

Sous son nom d’animal, Pandas est une bibliothèque puissante et polyvalente qui
permet de réaliser des analyses complexes de données. Elle a été développée en
2008.

À la fin de l’année 2009, elle a été mise en open source et elle est utilisée dans le
domaine de Big data et de data science car elle offre des performances et une
productivité élevée aux utilisateurs.

L’une des forces de Pandas est qu’il se base sur NumPy, bibliothèque très populaire.

Elle fournit diverses structures de données et opérations pour le traitement de

données numériques et de séries chronologiques.

En plus, les données produites par Pandas sont souvent utilisées comme données
en entrée pour les fonctions de plotting de Matplotlib, l’analyse statistique
en SciPy, les algorithmes de machine learning en Scikit-learn.

Les data scientists l’utilisent pour le chargement, le traitement et l’analyse des

données tabulaires (données stockées sous format .csv, .tsv ou .xlsx) à l’aide de
requêtes de type SQL.

Il vaut mieux utiliser l’outil Jupyter Notebook pour écrire vos codes. Il est intégré
directement dans Anaconda.
Chargement
import pandas as pd

Structures de données
Pandas dispose de deux grandes structures de données, les séries et les
DataFrames

[Link] : Vecteur de données homogènes

labellisées

[Link] : Tableau structuré de colonnes

homogènes

1
Représentation

import pandas as pd
s=[Link](range(3)) # Série d'entiers sans indexation
print(s)

2
a = [1, 7, 2]
s = [Link](a)
print(s)

0 1
1 7
2 2
dtype: int64

import numpy as np
myvar = [Link]([Link](3, 4))
print(myvar)

II) Les series

Une série est un tableau étiqueté à une dimension pouvant contenir tout type de
données (entiers, String, nombres à virgule flottante, objets Python, etc.).

Création
import pandas as pd
a = [1, 7, 2]
myvar = [Link](a)
print(myvar)

0 1
1 7
2 2
dtype: int64

Syntaxe
class [Link](data=None, index=None, dtype=None, name=None
, copy=False, fastpath=False)

Étiquettes
Les étiquettes des axes représentent l’index de la série. Cette étiquette peut être
utilisée pour accéder à une valeur spécifiée.
Si rien n'est spécifié, les valeurs sont étiquetées avec leur numéro d'index. La
première valeur à l'indice 0, la deuxième valeur a l'indice 1, etc.
Une série est comme une colonne dans une feuille Excel.

La méthode de base pour créer une série est la suivante :

ser = [Link](data, index=index)

data
data peut être un dictionnaire Python, un ndarray (tableau multi-dimensionnel de
NumPy) ou même une valeur scalaire.

3
index
L'index passé en argument est une liste d’étiquettes correspondant à chaque ligne
de la série. s = [Link]([18, 20, 15, 7], [10,11,12,13])

10 18

11 20

12 15

13 7

dtype: int64

dtype
Type de données pour les éléments de la Série. S'il n'est pas spécifié, il sera déduit des
données.

Création d’un objet Series grâce à un dictionnaire

Nous pouvons créer une série à partir d’un dictionnaire. L’index de cette série aura
automatiquement les étiquettes correspondant aux clés du dictionnaire.

Exemple
import pandas as pd

notes = {"Mathématiques": 19, "Français": 12, "Dessin": 15}

ser = [Link](notes)

print(ser)

data = [Link](['a','b','c','d'])
s1 = [Link](data)
print(s1)

s1 = [Link](data,index=[10,11,12,13])

Modification de valeurs
[Link]({'a': 'A', 'b': 'B'}) : remplace les 'a' par des 'A' et 'b' par des
'B' et renvoie une série modifiée.
#vérifie si l'étiquette "Sciences Physiques" est présente dans
l'index
a = "Sciences Physiques" in ser
print(a)

Index d'une série : c'est le nom affecté à chaque valeur :

 [Link]([1, 2, 5, 7], index = ['a', 'b', 'c', 'd']) : permet
de donner des noms aux individus (i.e. à chaque valeur).

4
  Pour donner des noms, on peut aussi utiliser un dictionnaire :
[Link]({'a': 1, 'b': 2, 'c': 5, 'd': 7}) ce qui revient au
même (si on donne un dictionnaire, les éléments sont triés par ordre
alphabétique des clefs).

 l'index par défaut est [0, ..., n-1]

 [Link] : renvoie l'index d'une série qui est de la classe Index.

 on peut réindexer une série (dans le cas précédent) :

[Link](['c', 'b', 'a', 'e']) renvoie la série (5, 2, 1, NaN) (car pas
de valeur associée à l'index 'e').
Une série créée à partir d’un dictionnaire peut avoir un index de taille différente de la
taille du dictionnaire.
notes = {"Mathématiques": 19, "Français": 12, "Dessin": 15}
ser = [Link](notes, index=["Mathématiques", "Français", "Sciences
Physiques", "Dessin" ])

print(ser)

Création d'une série avec valeur répétée :

[Link](0, index = range(5)) : série avec cinq 0.
[Link](10, range(5)) : série avec cinq 10.

Accès aux éléments d'une series

 Pour une série avec des valeurs d'index définies comme
s = [Link]([20, 50, 70, 300], index = ['a', 'b', 'c', 'd'])

On peut accéder à une valeur par index :

o s[0] ou s['a'], [Link]['a'] ou [Link]['a'] ou [Link]('a') ou s.a
o la forme avec get renvoie None si le nom n'existe pas, alors
que les autres formes lèvent une exception.

s1[0]
# s1[9] erreur

 on peut accéder à une valeur par numéro (origine à 0) :

o s[0] ou [Link][0] ou [Link][0] ou [Link](0)

 attention, avec les formes s[0] et [Link](0) :

o si 0 fait partie des valeurs d'index, renvoie la valeur correspondante
pour cette valeur d'index.
o si 0 ne fait pas partie des valeurs index, renvoie la première valeur
(valeur pour le numéro d'ordre).
o Alors que iat, at, iloc et loc ne sont pas ambigus

5
  s[0:3] : renvoie une série avec les valeurs des indices 2 à 4 exclus,
mais cette-fois, ce sont bien des indices de ligne !
 s[[0, 2, 3]] : valeurs pour les indices donnés, avec les même
problèmes d'ambiguité que ci-dessus sur les indices, selon qu'ils sont
numériques ou non.
 [Link][1] : utilisation des numéros de lignes (origine à 0) sans
ambiguité !
 [Link][1:3] : avec un range sur les numéros de lignes (origine à 0)
sans ambiguité et renvoie une série.
 [Link][[1, 3]] : utilisation des numéros de lignes (origine à 0) sans
ambiguité et renvoie une série.
print ([Link]) #affiche l'index de la série
print ([Link]) #affiche la data de la série

len(s) ou [Link] : taille de la série.

 s2 = [Link]() : fait une copie indépendante de la série.

 s[s < 5] = 99 : met à 99 les valeurs inférieures à 5
 s[s == [Link]] = 99 : met à 99 les valeurs infinies.
 s[[Link](s)] = 99 : met à 99 les valeurs nan
 [Link]() : valeurs statistiques d'une série.
 [Link]()
 [Link] : # Retourne (nbre ligne, nbre colonnes)
 [Link]() : les valeurs uniques sous forme d'array numpy
 s.value_counts() # le compte de chacun des items uniques d'une Série peut être
obtenu en utilisant value_counts()
 [Link]()
 [Link](2)
 [Link]()

ind = [Link](['a','b','c','d','e','f','g','h','i','j'])
data = [Link]([12,52,41,16,43,85,74,74,95,23])
s1 = [Link](data, index=ind)
s1['a']
s1[2]
s1[['b', 'd']]

# 1° série
s1 = [Link]([10, 20, 30, 40], index=['a', 'b', 'c', 'd'])

# 2° série
s2 = [Link]([40, 30, 20, 10,200], index=['d', 'c', 'b', 'a','e'])

# Addiitonnnons les séries

s1 + s2
s1 * 3

Sous Series
s = [Link]([Link](0, 15))

6
# Quelles sont les lignes avec une valeur supérieure à 10
print(s > 5)

# Sélection des valeurs supérieures à 8

r = s > 8
s[r]

Il existe une façon raccourcie pour réaliser cette opération.

s=s[s > 8]

Vous pouvez combiner différents choix pour extraire vos données.

s=s[(s > 5) & (s < 8)]

On peut déterminer si toutes les valeurs d'une série correspondent à une expression donnée en
utilisant la méthode .all().

Le tableau suivant cherche tous les éléments de la série supérieurs ou égaux à 3 :

(s >= 3).all()

# Supérieur à zéro
(s >= 0).all()

La méthode .any() retourne True si des valeurs satisfont les expressions.

# as tu des valeurs > à 3 ?

s[s >=3].any()

Le résultat de ces expressions logiques est une sélection booléenne, une série de valeurs Vrai et
Faux.

Le .sum() d'une série, lorsqu'on lui donne une série de valeurs booléennes, traitera True comme
1 et False comme 0.

On peut ainsi connaître le nombre de valeur correspondants à notre recherche.

#Combien de valeur sont inférieures à 5 ?

(s < 5).sum()

Indexation de sous-séries : attention, quand on a extrait une sous-série avec par

exemple s1 = s[s > 4], les numéros d'index ne changent pas.
(s[1] pointe toujours vers la même valeur qu'avant s'il fait toujours partie de la
série, sinon, exception).

s = [Link]([Link](0, 15))
s1=s[s > 4]
print(s1[0]) ???

# On va créer une nouvelle ligne

s['z'] = 100

# on peut modifier cette valeur

s['z'] = -100

7
# On peut supprimer un item en utilisant la fonction del
del(s['z'])

Sélection d'éléments
s = [Link]([Link](50,60), index=[Link](10,20))

#Prenons les items de la position 1 à la position 7 avec un pas de 2

s[1:7:2]

#On peut aussi simuler ea même résultat que la fonction head

s[:n]

# Idem pour la fonciotn tail

s[-n:]

# Si on veut tout à partir d'une position donnée

s[n:]

# si on veut tout à partir de l'indice 3 avec un pas de 2

s[3::2]

# Une possibilité très utile pour inverser la série

s[::-1]

# En partant du 5° élément depuis la fin avec un pas de 2

s[5::-2]

# Tout sauf les 3 derniers

s[:-3]

# On peut ne garder que les 3 premiers des 4 derniers

s[-4:-1]

Opérations sur les séries

On peut utiliser les opérations comme sur les array numpy :
 s + s
 s * 2
 s + 1
 [Link](s); [Link](s)

 s1 = [Link]([1, 2, 3], ['a', 'b', 'c'])

 s2 = [Link]([4, 5, 6], ['a', 'd', 'c'])
 s=s1 + s2

 les index seulement présents dans l'une des deux series donnent NaN.
on peut éliminer les lignes ayant NaN par : (s1 + s2).dropna()

Minimum élément par élément de 2 séries :

 [Link](s1, s2)

8
Attribut name d'une série :
 on peut attribuer un nom à une série :
s = [Link]([2, 5, 7, 3], index = ['a', 'b', 'c', 'd'], name = 'val')

 on peut changer ce nom : [Link] = 'val2' ou [Link]('val2')

Comptage de valeurs :
 on suppose qu'on a défini la Serie (colonne de dataframe) :
s = [Link]([1, 3, 5, 3, 5, 2, 8, 3, 1, 7, 4, 2, 3, 6, 3]).

 s.value_counts() : renvoie une Serie avec pour chaque valeur le

nombre d'occurrence, trié par nombre d'occurrences décroissant, et
alors les index sont les valeurs, les valeurs de la série sont les comptes.
 s.value_counts(normalize = True) : pareil, mais normalise les valeurs
pour que la somme fasse 1

 [Link](), [Link](), [Link](), [Link](), [Link](), [Link]() : les valeurs

correspondantes.
 (s1 == s2).all() : teste si toutes les valeurs sont égales.
 (s1 == s2).any() : teste s'il y une position où les valeurs sont égales.
 s=s.sort_index() : renvoie la série triée par valeurs des index.
 s=s.sort_values() : renvoie la série triée par valeurs (les nan sont en
dernier, mais on peut les mettre en premier en donnant
l'option na_position = 'first').
 [Link]() : renvoie l'index correspondant à la valeur maximale (idem
avec idxmin).
 s=[Link](lambda x: 2 * x + 1) : renvoie le résultat de l'application
de la fonction.

Opérateur in
L'opérateur in pour une série ne teste pas l'appartenance à la série, mais à
son index !
s = [Link]([2, 5, 7, 3], index = ['a', 'b', 'c', 'd'])

 'a' in s : donne True

 5 in s : donne False
 5 in [Link] : donne True

Fonction isin
si s = [Link](['a', 'b', 'c'])

alors [Link](['a', 'c', 'x']) teste si chaque élément de la série est

dans la liste donnée (donc renvoie ici la Series [True, True, False]).
9
 Fonctions appliquées aux éléments d'une série
[Link](lambda x: x ** 2)

Fonction qui nécessite des arguments positionnels supplémentaires et

utilisation du mot-clé args.

def diff(x, arg1):

return x – arg1
[Link](diff, args=(5,))

Déterminer le numéro d'ordre de chaque valeur (rank) :

 [Link]() : renvoie les numéros d'ordre pour chaque valeur, dans l'ordre croissant.
Si des valeurs sont identiques, elle attribue à toutes ces valeurs la moyenne des
rangs possibles.
Si 2 valeurs identiques pour les rangs 2 et 3, leur attribue 2.5 à toutes les deux (le
champ method vaut 'average' par défaut).
 [Link](method = 'min') : renvoie aussi les numéros d'ordre de chaque valeur
(numéros entre 1 et n), mais en cas de valeurs identiques, donne le rang minimum,
puis saute au suivant.
Par exemple, si 2 valeurs identiques pour les rangs 2 et 3, leur attribue 2 à toutes
les deux, puis saute au rang 4.
 [Link](method = 'first') : idem, mais en cas de valeurs identiques, elle les
classe dans l'ordre initial.
Par exemple, si 2 valeurs identiques pour les rangs 2 et 3, la première aura le rang
2 et la seconde le rang 3.

 [Link](ascending = False) : renvoie les numéros d'ordre dans l'ordre

décroissant (défaut est ascending = True).

[Link]() : renvoie les index dans l'ordre croissant des valeurs (de telle sorte
que s[[Link]()] est trié par ordre croissant).

Attention : ce ne sont pas les numéros d'ordre pour chaque valeur, utiliser rank pour cela !

Fonctions vectorisées sur une série contenant des chaînes de caractères :

 accès se fait via le champ str.

Par exemple, [Link]('a') : renvoie une série de booléens

(idem avec endswith)

 [Link]() : renvoie une série avec les longueurs des chaînes.

10
  [Link] : convertit en minuscule (idem avec upper pour
majuscules).
 [Link]('(\w)(\d)') : renvoie une série numérique indiquant le
nombre de match avec le pattern de chaque élément.

 Slicing d'une series :

s = [Link](['ACBDE', 'acbde']);
[Link](start = 1, stop = 3) donne la series ['CB', 'cb']

Extrait des sous chaines de chaque élément de la série.

 si s= [Link](['ab-cd', 'ef-gh', 'ij-kl']) et qu'on veut

récupérer la series avec ce qu'il y a avant le tiret : [Link]('-').str[0]
donne la series ['ab', 'ef', 'ij'].
Sélection de valeurs :
Conversion d'une series :
 [Link](str) : en string
 [Link](float) : en float

Divers :
 s.to_frame() : convertit la série en DataFrame à une seule colonne
(dont le nom est le nom de la série).
 s.to_frame(name = 'A') : on peut donner un nom à la colonne.
 s.memory_usage() : donne la mémoire utilisée en nombre d'octets.

Création d’un objet Series par un [Link]

Si data est un [Link], l’index passé en paramètre doit être de la même longueur
que data.

Si aucun index n’est passé, un index sera créé avec les valeurs [0, …, len(data) – 1].

Exemple
s = [Link]([Link]([67060000, 83020000, 328200000]), index=["France",
"Allemagne", "Etats-Unis"])

s = [Link]([67060000, 83020000, 328200000], index=["France", "Allemagne",

"Etats-Unis"])

11
 Dataframe
[Link]

La Dataframe est une structure de données qui organise les données en lignes et en
colonnes, ce qui en fait une structure de données bidimensionnelle.

C'est une matrice individus-variables où les lignes correspondent à des observations

et les colonnes à des attributs décrivant les individus.

C'est comme une feuille de calcul Excel ou une table SQL, ou encore un
dictionnaire d’objets Series.

Un Dataframe, comme une série, peut être construit à partir de nombreux types :
 Un dict de ndarrays 1D, listes, dicts, ou Series ;
 Un [Link] bidimensionnelle ;
 Un ndarray strucuré ;
 Une série ;
 Ou encore un autre Dataframe.

Chaque ligne contient contient une valeur par colonne.

Le nom des lignes d’un DataFrame est appelé “index” qui, par défaut, commence
toujours par 0.

Cependant, il est possible d’indexer les lignes d’un DataFrame par n’importe
quelle valeur possible.

Création d'un dataFrame

La syntaxe de base pour créer un Dataframe est la suivante :
df= [Link](data, index=index, columns=columns)

L’index représente l’ensemble des étiquettes de lignes et columns l’ensemble des

étiquettes de colonnes.

12
Exemple
import numpy as np
myvar = [Link]([Link](3, 4))
print(myvar)

Exemple
data=[(1, [Link](1), 'un'), (2, [Link](2), 'deux'), (3, [Link](3),
'trois')]
myvar = [Link](data,index=list('abc'), columns='i val nom'.split())

Création d’une DataFrame à partir d’un dictionnaire de séries

L’index du Dataframe résultant sera l’union des index des différentes Series.

Exemple
notes = {
"Mathématiques": [Link]([18.0, 20.0, 17.0], index=["Sylvie", "Gilles", "Sylvain"]),
"Sciences Physiques": [Link]([15.0, 7.0, 10.0,20.0], index=["Sylvie", "Gilles",
"Sylvain", "Thomas"]),
}
df = [Link](notes)

Remarque
on peut aussi faire un dataframe avec les 2 séries, puis prendre le minimum
par ligne : [Link]([s1, s2], axis = 1).min(axis = 1)

s1= [Link]([18.0, 20.0, 17.0], index=["Sylvie", "Gilles", "Sylvain"])

s2= [Link]([15.0, 7.0, 10.0,20.0],index=["Sylvie", "Gilles", "Sylvain", "Thomas"])

s=[Link]([s1, s2], axis = 1).min(axis = 1)

df = [Link](s)
print(df)

Les étiquettes des lignes et des colonnes sont accessibles respectivement en

accédant aux attributs index et columns de la façon suivante

Exemple
notes ={"maths": [Link]([15.2, 10.5, 17.5], index=["e1","e2","e3"]),
"physiques": [Link]([14.0, 18.5, 9.5, 10.5], index=["e1", "e2", "e3", "e4"]) }
df = [Link](notes)

13
print(df)

print([Link])
print([Link])

Création d’un Dataframe à partir d’un dictionnaire de ndarray ou de liste

Les ndarrays doivent tous être de la même longueur. Si un index est passé, il doit
aussi être de la même longueur que les tableaux.
Si aucun index n’est passé, le résultat sera range(n), où n est la longueur du
tableau.

Exemple :
data = {"Prenom": ["Sylvie", "Gilles", "Sylvain", "Thomas"],
"Age": [18.0, 23.0, 25.0, 40.0]}
df = [Link](data)
print(df)

Quelques opérations sur les DataFrames

 Télécharger un fichier
df = pd.read_csv("[Link]", comment='#')
print(df)

 Numération des colonnes

print([Link])

 Afficher les types des colonnes

[Link]({'col': 'int32'})

 Changer le types des colonnes

[Link]({'col': 'int32'})

 Les dimensions de la matrice

[Link]

 Le nombre de colonnes de la matrice

len([Link])

 Le nombre de ligne de la matrice

[Link][0]

 Afficher des info sur le dataframe

[Link]

 Afficher des statistiques sur le dataframe

[Link]
[Link](include='all'))

 Afficher les n premières lignes du dataframe

[Link](n)

14
  Afficher les n dernières lignes du dataframe
[Link](n)

 Afficher n lignes aléatoires du dataframe

[Link](n)

 Le Slicing
Nous pouvons filtrer les données en utilisant le slice. Par
exemple, df[:n] renvoie les n premières lignes du DataFrame.

Accès aux données d’un Dataframe

Après avoir créé un objet Series ou un Dataframe il faut savoir comment accéder aux
données enregistrées dans ces structures.

Accès par colonne

L’accès par colonne retourne :

- une Series (avec la même indexation) pour une colonne unique,

- un nouveau DataFrame pour plusieurs colonnes

Au début il faut d'abord créer et remplir un dataFrame.

Considérons le tableau suivant dans un fichier appelé [Link] :
[Link]
M NGC Type Mag Size ... RA Dec Con Season Name
0 M1 1952 Sn 8.4 5.0 ... 5.575 22.017 Tau winter Crab Nebula
1 M2 7089 Gc 6.5 12.9 ... 21.558 0.817 Aqr autumn NaN
2 M3 5272 Gc 6.2 16.2 ... 13.703 28.383 CVn spring NaN
3 M4 6121 Gc 5.6 26.3 ... 16.393 -26.533 Sco summer NaN
4 M5 5904 Gc 5.6 17.4 ... 15.310 2.083 Ser summer NaN

df = pd.read_csv("[Link]", comment='#')
print(df)
Il existe principalement deux méthodes d’accès aux données spécifiques à Pandas :
 L’opérateur d’indexation [ ] ;
 Les méthodes fournis par Pandas .loc() et .iloc() ;

Utilisation de l’opérateur d’indexation (pour afficher des colonnes).

Rappelons qu’une série possède deux indices :
 Un index positionnel ou implicite, qui est toujours un RangeIndex ;
 Un index explicite, qui peut contenir n’importe quel objet.

Accès par colonne

print(df['M']) ou print(df.M)
print(df['M'].head())
print(df['M'].tail())
print(df['M'].describe())
print(df['M'].mean())

15
print(df['M'].value_counts())

Afficher les valeurs pour une colonne donnée (à saisir).

c = input("donner une colonne : ")
print(df[c])

Trier les valeurs d'une colonne de manière croissante

print(df['M'].sort_values())

On peut aussi obtenir les indices des valeurs triées

print(df['M'].argsort())

Le tri peut être généralisé aux DataFrame

par exemple : trier le tableau de données selon la taille (size) puis affichage des
premières lignes avec head()
print(df.sort_values(by='size').head())

Itérations sur les variables : boucler sur l'ensemble des colonnes

Exemple :
for col in [Link]:
print(df[col].dtype)
#print(df[col])
#print(col)

Afficher plusieurs colonnes

print(df[['RA' , 'Dec', 'Name']])
ou
cols=['RA', 'Dec', 'Name']
print(df[cols])

Accès par lignes

Utilisation des méthodes .loc() et .iloc()
L’opérateur d’indexation ([ ]) est pratique, mais il y aura une confusion. Que faire si
les étiquettes sont également des nombres ?
Supposons que vous ayez à travailler avec un objet Series comme celui-ci :

fleur=[Link](["rose","tournesol","muguet", "tulipe", "violette"], index=[1, 2, 3, 5, 8])

Que retournera fleur[1] ?

Si l’on se base sur les positions, fleur[1] renvoie « tournesol ».

Mais, si l’on se base sur les étiquettes, alors fleur[1] renvoie « rose ».

Pour éviter toute confusion, la bibliothèque Pandas fournit deux méthodes d’accès
aux données :

 loc() fait référence l’étiquette.

 iloc() fait référence à l’indice de position.

Si nous reprenons l’objet Series définit ci-dessus, les instructions suivantes :

16
print([Link][1]) renvoie « rose ».

print([Link][1]) renvoie « tournesol ».

.loc() et .iloc() prennent également en charge les fonctionnalités que vous attendez
des opérateurs d’indexation, comme le découpage en tranches.

Toutefois, ces méthodes d’accès aux données présentent une différence importante.
Alors que .iloc() exclut l’élément de fermeture, .loc() l’inclut.

Gestion des lignes

On utilise l’opérateur d’indexation pour les colonnes et les méthodes d’accès .loc() et
.iloc() pour les lignes.

 Sans indexation
M NGC Type Mag Size ... RA Dec Con Season Name
0 M1 1952 Sn 8.4 5.0 ... 5.575 22.017 Tau winter Crab Nebula
1 M2 7089 Gc 6.5 12.9 ... 21.558 0.817 Aqr autumn NaN
2 M3 5272 Gc 6.2 16.2 ... 13.703 28.383 CVn spring NaN
3 M4 6121 Gc 5.6 26.3 ... 16.393 -26.533 Sco summer NaN
4 M5 5904 Gc 5.6 17.4 ... 15.310 2.083 Ser summer NaN

Affichier une ligne

print([Link][0])
print([Link][0])

 Avec indexation
df1 = df.reset_index()
df1.set_index(['M'], inplace=True)
print(df1)

index NGC Type Mag Size ... RA Dec Con Season Name
M ...
M1 0 1952 Sn 8.4 5.0 ... 5.575 22.017 Tau winter Crab Nebula
M2 1 7089 Gc 6.5 12.9 ... 21.558 0.817 Aqr autumn NaN
M3 2 5272 Gc 6.2 16.2 ... 13.703 28.383 CVn spring NaN
M4 3 6121 Gc 5.6 26.3 ... 16.393 -26.533 Sco summer NaN
M5 4 5904 Gc 5.6 17.4 ... 15.310 2.083 Ser summer NaN
print([Link][0])
print([Link]['M1'])
print([Link][0]) #erreur

Afficher les valeurs pour une saison donnée (à lire).

saisons = df.reset_index()
saisons.set_index(['Season'], inplace=True)
c = input("donner une saison : ")
print([Link][c])

Afficher un élément
#accès à la valeur située en (i,j) : [Link][i][j]

17
print([Link][0][0]) #accès à la valeur située en (0,0)
print([Link][0,0])

#Avant indexation, accès à la valeur située en (i,j) : [Link][i][colj]

print([Link][0]['M']) #sans indexation
print([Link][2,'M'])

#Après indexation, accès à la valeur située en (i,j) : [Link][lignei][colj]

print([Link]['M1']['RA']) #après indexation
print([Link]['M1', 'RA'])

#valeur située en dernière ligne, première colonne : utilisation de l'indiçage négatif

print([Link][-1,0])

#valeur située en dernière ligne, première colonne : utilisation de shape[0]

print([Link][[Link][0]-1,0])

Affichage de plusieurs éléments

Une partie d'une colonne
print(df['M']) #toute la colonne

print(df['M'][0]) #un seul élément de la colonne

print(df['M'][0:3]) # plusieurs éléments ou print(df.M[0:3])

print(df['Dec'].sort_values()) # tri de valeurs d'une colonne

print(df['Dec'].argsort()) # valeurs triées par indices

#matrice contenant les n premières lignes et m premières colonnes

print([Link][0:n, 0:m])
# les n premières valeurs de toutes les colonnes (les n premières lignes)
print([Link][n:m, : ])
#lignes => n:m (de n à m [non inclus])
#colonnes = : (toutes les colonnes)

print([Link][0:5,:])

Afficher les n dernières lignes

print([Link][-n:,:])

#5 premières lignes et colonnes 0, 2 et 4

print([Link][0:5,[0,2,4]])

#5 premières lignes et colonnes 0, 2 et 4 (5 premières colonnes avec un pas de 2)

print([Link][0:5,0:5:2])

print(df[:n:k]) #toutes les lignes inférieures strictement à n par pas de k

print(df[:6:2])

Tri du dataFrame

18
Le tri peut être généralisé aux DataFrame, par exemple : trier le tableau de données selon une
colonne.
print(df.sort_values(by='RA')

[Link][30, 0] # 20× plus rapide que [Link][30][0]

[Link]['M31', 'NGC'] # 20× plus rapide que [Link]['M31']['NGC']

Accéder à tous les éléments de la matrice

Afficher toute la matrice

for i in range([Link][0]):
for j in range(len([Link])):
print([Link][i][j], end=' ')
print()

Les requêtes
Les projections

Afficher une colonne : select col form df

print(df['M'][0:3]) # plusieurs éléments ou print(df.M[0:3])

print([Link][0:3, 2]) select col 2 from df where index in {0,3}

[Link][0:3, [1, 2]] # select col 2, col 3 from df where index in { 0, 3}

print([Link]['spring', ['Name']]) # select Name from df where index

='spring'
[Link][['M31'], ['Type']] # elt se trouvant à la ligne M31 et la
col type

print([Link]['spring', ['Type','Name']]) # select Type, Name from df

where index ='spring'

print([Link][['spring','winter'], ['Type','Name']]) # select Type,

Name from df where index in {'spring', 'winter'}

[Link][['M31', 'M51'],['Type', 'Name']] # les lignes M31 et 'M51' avec

les col type et Name

[Link]['M31':'M33', ['Type', 'Name']] # De M31 à M33 *inclu*

19
Exemple
age sexe typedouleur sucre tauxmax angine depression coeur
0 70 masculin D A 109 non 24 presence
1 67 feminin C A 160 non 16 absence
2 57 masculin A A 141 non 3 presence
3 64 masculin D A 105 oui 2 absence
4 74 feminin B A 121 oui 2 absence

Liste des individus présentant une douleur de type A

print([Link][df['typedouleur']=="A",:])

print(df['typedouleur']=="A")

Combien ils sont ?

print((df['typedouleur']=="A").value_counts())

Liste des individus présentant une douleur de type A ou B

select * from df where 'typedouleur'in {'A','B' }
print([Link][df['typedouleur'].isin(['A','B']),:])

Liste des individus présentant une douleur de type A et ayant une angine
#liste des individus présentant une douleur de type A et angine ==
oui
print([Link][(df['typedouleur']=="A") & (df['angine'] ==
"oui"),:])

Liste des personnes de moins de 45 ans, de sexe masculin, présentant une

maladie cardiaque
print([Link][(df['age'] < 45) & (df['sexe'] == "masculin") & (df['coeur'] ==
"presence"),:])

On peut n'afficher qu'une partie des colonnes, on définit la projection dans une liste

colonnes = ['age','sexe','coeur','tauxmax']
print([Link][(df['age'] < 45) & (df['sexe'] == "masculin") & (df['coeur'] == "presence"),
colonnes])

Calculs récapitulatifs - Croisement des variables

Fréquences selon sexe et coeur : nombre de malades par sexe et par coeur
print([Link](df['sexe'],df['coeur']))

coeur absence presence

sexe
feminin 67 20

20
masculin 83 100
Multiplier les critères est possible mais la lecture devient compliquée
print([Link]([df['sexe'],df['sucre']],df['coeur']))

[Link]()
Permet de sélectionner des lignes par valeur de colonne.
[Link]("(Mag < 5) & (Size > 60)") # Select * from df where (Mag < 5) & (Size
> 60)

Quelques méthodes
Sélection Syntaxe Résultat

Colonne unique [Link] or df[col] [Link]

Liste de colonnes df[[c1, ...]] [Link]

Lignes par tranche df[slice] [Link]

Label unique [Link][label] [Link]

Liste de labels [Link][[lab1, ...]] [Link]

Labels par tranche [Link][lab1:lab2] [Link]

Ligne entière par n° [Link][i] [Link]

Ligne partielle par n° [Link][i, [j,...]] [Link]

Valeur par labels [Link][lab, col] Scalaire

Valeur par n° [Link][i, j] Scalaire

[Link][sel] or df[sel] or [Link]("sel

Ligne par sél. booléenne [Link]
")

Suppression de colonne
[Link]() permet d’éliminer une ou plusieurs colonnes
d’un dataframe:

[Link](['RA', 'Dec'], axis=1).head(3)

[Link](["M", "spring"], axis = 1, inplace = True)

Par défaut, beaucoup d’opérations retournent une copie de la structure, sauf si l’opération se fait
« sur place » (inplace=True).

D’autres opérations d’accès retournent seulement une nouvelle vue des mêmes données.

21
Exemple
df = [Link]([Link](12).reshape(3, 4), index=list('abc'), columns=
list('ABCD'));
print(df)

A B C D
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11

[Link]('A', axis=1) #supp la colonne A

colA = df['A'] # Nouvelle vue de la colonne 'A'

>>> colA += 1 #df['A']+=1 # Opération sur place
>>> df # la ligne 'a' est tjs là, la colonne 'A' a été modifiée

Filtrage
Noter qu’il existe une façon de filtrer les données sur les colonnes ou les
labels:
[Link](regex='M.7', axis='index').filter('RA Dec'.split())

On peut sélectionner des lignes de DataFrame sur la base d’une ou de plusieurs

valeurs de colonne.
Nous pouvons également obtenir des lignes de DataFrame satisfaisant ou non une
ou plusieurs conditions.

Cela peut être accompli en utilisant l’indexation booléenne, l’indexation positionnelle,

l’indexation par étiquette et la méthode de requête (query()).

Syntaxe
[Link](items=None, like=None, regex=None, axis=None)

Exemples
[Link](items=['one', 'three'] #select columns by name

[Link](regex='e$', axis=1) # select columns by regular expression

print([Link](like='M11', axis=0)) # select rows containing 'M11'

Les opérations sur un Dataframe : manipulation des données

Comme dans numpy, il est possible de modifier les valeurs, ajouter/retirer
des colonnes ou des lignes, tout en gérant les données manquantes.

Les opérations de statistique (sum, mean, median, etc.)

22
L’objectif principal visé lorsqu’on utilise la bibliothèque pandas est d’effectuer une
analyse statistique sur un ensemble de données.

L’analyse statistique peut être utilisée pour :

 Faire ressortir les points clés d’un ensemble de données
 Résumer les informations.
 Calculer des mesures de cohérence, de pertinence ou de diversité dans les données.
 Faire des prédictions futures basées sur des données enregistrées précédemment.

Un élément essentiel de l’analyse des données volumineuses est une synthèse

efficace : le calcul d’agrégations telles que sum(), mean(), min() et max(), dans
lesquelles un seul nombre donne un aperçu de la nature d’un ensemble de données
potentiellement volumineux.

Dans cette section, nous allons explorer les agrégations dans Pandas, à partir
d’opérations simples.

Exemple

Considérons le DataFrame suivant représentant les notes obtenues par des élèves
dans quatre formations différentes.

df_notes = [Link]({
"Introduction au Big data": [Link]([11.0, 15.0, 10.0,10.0],index=["Sylvie",
"Gilles", "Sylvain", "Thomas"]),
"Hadoop": [Link]([18.0, 20.0, 17.0,18.0], index=["Sylvie", "Gilles", "Sylvain",
"Thomas"]),
"Spark": [Link]([15.0, 7.0, 10.0,20.0],index=["Sylvie", "Gilles", "Sylvain",
"Thomas"]),
"Java": [Link]([18.0, 20.0, 10.0,8.0],index=["Sylvie", "Gilles", "Sylvain",
"Thomas"]),
})

Print(df_notes)

La méthode .sum()
Elle renvoie la somme des valeurs sur l’axe demandé (renvoie la somme des notes
obtenues pour chaque étudiant),

Exemple :

df_notes.sum(axis=1) # total des lignes

df_notes.sum(axis=0) #total des colonnes

La méthode .mean()

Elle renvoie la moyenne des valeurs de l’axe demandé (renvoie la moyenne obtenue
de chaque étudiant) :

df_notes.mean(axis=1)

La méthode .max()

23
Elle renvoie le maximum des valeurs de l’axe demandé (renvoie la note maximale
obtenue dans chaque formation).

df_notes.max(axis=0)

Les opérations de filtrage, groupage et de concaténation

Ces opérations sont très similaires aux opérations SQL qu’il est possible d’effectuer
sur une table d’une base de données. Si vous êtes un programmeur SQL, vous êtes
déjà familiarisé avec tout cela.

La seule complexité réside dans le fait que vous pouvez joindre des colonnes en plus
des lignes.

L’opération de filtrage
Les Dataframe Pandas permettent l’indexation booléenne, qui est un moyen assez
efficace de filtrer un dataframe pour plusieurs conditions.

Dans l’indexation booléenne, les vecteurs booléens générés en fonction des

conditions sont utilisés pour filtrer les données. Les conditions multiples impliquant
les opérateurs | (ou), & (et), et ~ (non) peuvent être regroupées à l’aide des
parenthèses ().

Considérons le DataFrame suivant représentant les notes obtenues par des élèves
dans quatre formations différentes.
df_notes = [Link]({
"Introduction au Big data": [Link]([11.0, 15.0, 10.0,10.0],index=["Sylvie",
"Gilles", "Sylvain", "Thomas"]),
"Hadoop": [Link]([18.0, 20.0, 17.0,18.0], index=["Sylvie", "Gilles", "Sylvain",
"Thomas"]),
"Spark": [Link]([15.0, 7.0, 10.0,20.0],index=["Sylvie", "Gilles", "Sylvain",
"Thomas"]),
"Java": [Link]([18.0, 20.0, 10.0,8.0],index=["Sylvie", "Gilles", "Sylvain",
"Thomas"]),
})

print(df_notes)

ex1 :
Extraire du les étudiants ayant obtenu une note supérieure ou égale à 15 en Java.
req1 = df_notes[(df_notes['Java']>=15)]
print(req1)

Ex 2 : En plus de connaitre les étudiants ayant une note supérieure ou égal à 15 en Java, nous
voulons, en plus connaître les étudiants ayant une note supérieure ou égale à 10 en Spark.

resultat = df_notes[(df_notes['Java']>=15)&(df_notes['Spark']>=10)]

print(resultat[["Spark", "Java"]])

L’opération de groupage

24
La fonction groupby() est l’une des fonctions les plus utiles lorsqu’il s’agit de traiter
des dataframes volumineux dans Pandas.

Une opération groupby consiste généralement à diviser la dataframe, à appliquer

une fonction et à combiner les résultats.

Considérons le dataframe suivant :

notes = {'Région': ['Nouvelle-Aquitaine','Normandie','Normandie',
'Ile-de-France','Ile-de-France','Grand Est','Grand Est','Grand Est'],
'Université': ['Université de Poitiers','Université de Rouen','Université de Rouen',
'Université de Paris','Université de Paris','Université de Reims','Université
de Reims','Université de Reims'],
'Nom': ['Gilles','Laura','Sylvain','Thomas', 'Sylvie','luc','Marc','Hugo'],
'Spark': [14,14.5, 15,7.5,18,20,19,14],
'Scala': [15,10,11,9,10.5,18.5,16,16]}

df = [Link](notes, columns = ['Région', 'Université', 'Nom', 'Spark', 'Scala'])

print(df)

Regroupons les données du dataframe par Région :

gp = [Link]('Région')

for region, group in gp:

print(region)
print("**********************")
print(group)
print()
Nous pouvons encore aller plus loin. Maintenant, recherchons les résultats moyens
en Scala et en Spark pour chaque Université :
gp=[Link](['Région', 'Université']).mean()
print(gp)

L’opération de concaténation
Vous pouvez concaténer des dataframes le long de l’axe des lignes ou des colonnes.
Supposons que vous ayez plusieurs dataframes comportant les mêmes champs et
que vous souhaitiez les combiner en un seul le long de l’axe des lignes. Ou encore,
si vous avez des champs supplémentaires pour vos données actuelles que vous
souhaitez ajouter, alors vous pouvez les concaténer le long de l’axe des colonnes.

Dans cette partie, nous allons voir comment concaténer deux ou plusieurs
dataframes avec Pandas.

Concaténation verticale
Considérons cet exemple :

# Création de deux Dataframes

df1 = [Link]({'Nom': ['Gilles', 'Sylvain'], 'Age': [25, 28]})
df2 = [Link]({'Nom': ['Sylvie', 'Luc'], 'Age': [35, 50]})

25
# Affichage des dataframes
print("DataFrame df1:\n")
print(df1)
print("\nDataFrame df2:\n")
print(df2)

# Concaténation verticale des dataframes

df_concat = [Link]([df1, df2])

# Affichage du résultat
print("\nRésultat de la concaténation:\n", df_concat)

Concaténation horizontale
Illustrons cela par les instructions qui suivent :

# Création de deux Dataframes

df1 = [Link]({'Nom': ['Gilles', 'Sylvain'], 'Age': [25, 28]})
df2 = [Link]({'Profession': ['Etudiant', 'Entrepreneur'], 'Statut Matrimoniale':
['Célibataire', 'Marié']})

# Affichage des dataframes

print("DataFrame df1:\n")
print(df1)
print("\nDataFrame df2:\n")
print(df2)

# Concaténation horizontale des dataframes

df_concat = [Link]([df1, df2],axis=1)

# Affichage du résultat
print("\nRésultat de la concaténation:\n", df_concat).

26
Lire les fichiers avec pandas
Une caractéristique de Pandas est sa capacité à écrire et à lire des fichiers Excel,
CSV et de nombreux autres types de fichiers.

Des fonctions telles que la méthode read_csv() permettent de travailler efficacement

avec des fichiers.

Vous pouvez les utiliser pour charger des données de vos fichiers dans les instances
Pandas Series ou DataFrame. Dans cette section nous verrons :

 Comment lire depuis des fichiers ?

 Comment travailler avec différents formats de fichiers ?
 Comment travailler efficacement avec des données volumineuses ?

Lire un fichier csv avec Pandas

Le format CSV (Comma Separated Values) est très populaire pour le stockage des
données. Un grand nombre de stockage de données se présentent sous la forme de
fichiers CSV qui peuvent être utilisés soit directement dans un tableur comme Excel,
soit chargés dans des langages de programmation comme R ou Python.

Les dataframes de Pandas sont assez puissants pour traiter des données tabulaires
bidimensionnelles.

Pour lire un fichier csv avec Pandas on utilise la fonction read_csv(). Elle est fournie
avec un certain nombre de paramètres différents pour personnaliser la façon dont
vous souhaitez lire le fichier.

Voici la syntaxe générale pour charger un fichier csv dans un dataframe :

import pandas as pd
df = pd.read_csv(path_to_file)
Elle renvoie un dataframe pandas.

Dans l’exemple suivant, nous chargerons un fichier csv stockant les données sur les espèces et le
poids des animaux capturés sur le site du désert de Chihuahuan près de Portal, Arizona, États-
Unis.
Chaque ligne contient les informations relatives à un seul animal, et les colonnes représentent les
caractéristiques étudiées.

import pandas as pd
df =
pd.read_csv("[Link]
print(df)

Sur le dataframe obtenu nous pouvons avoir des statistiques avec la méthode .describe()
comme ceci :
print([Link]());

Lire un fichier Excel avec Pandas

Un tableau Excel est l’une des formes de fichiers les plus omniprésentes dans l’industrie
informatique. Tous ceux qui utilisent un ordinateur à un moment ou à un autre ont rencontré

27
et travaillé avec des feuilles de calcul Excel. Cette popularité d’Excel est due à sa vaste
gamme d’applications dans le domaine du stockage et de la manipulation de données sous
forme de tableaux et de systèmes. De plus, les feuilles Excel sont très instinctives et
conviviales, ce qui les rend idéales pour la manipulation de grands ensembles de données,
même pour les personnes moins techniques.

Dans cette sous-section, vous allez apprendre à utiliser Pandas pour travailler avec des feuilles
de calcul Excel. L’objectif de cette sous-section est de vous apprendre à :
 Lire les données d’un fichier Excel dans pandas en utilisant Python.
 Explorer les données des fichiers Excel dans Pandas.

Supposons le fichier Excel suivant :

import pandas as pd
data = pd.read_excel("fichier_sauvegarde.xlsx")
data

La deuxième instruction lit les données d’Excel et les stocke dans un dataframe
pandas représenté par la variable data.

S’il y a plusieurs feuilles dans le classeur Excel, la commande importera les données
de la première feuille.

Pour sélectionner une feuille particulière on utilise l’argument sheet_name de la

méthode read_excel() comme suit :

import pandas as pd
d_Etudiants = pd.read_excel("[Link]",
sheet_name="Etudiants")
d_Etudiants

28
Visualisation des données
Pour que nous puissions analyser correctement nos données, nous devons les
représenter de manière tangible et complète afin que toutes les personnes
concernées puissent les comprendre.

La bibliothèque Pandas offre un large éventail d’outils. Dans cette section, nous
allons couvrir pas à pas tout ce dont on a besoin pour commencer à utiliser les outils
de visualisation de Pandas, notamment les diagrammes à barres,
les histogrammes et les pie chart.

import [Link] as plt

df['A'].[Link]()
[Link]()

29