Résultat de l'exécution


Pandas

Pandas est un paquet Python qui permet de manipuler des données sous forme de tableaux à une ou plusieurs dimensions. Un tableau à une dimension est appelé Series alors qu'un tableau à deux dimensions est qualifié de Dataframe. On peut également manipuler des tableaux à trois dimensions (Panel) ou à quatre dimensions (Panel4D).

Pandas permet notamment d'extraire ou de remplacer des données de manière simple, de récupérer des données depuis des fichiers CSV et d'analyser les données en interagissant avec d'autres paquets.

1.1. Définition d'un DataFrame

Il existe une multitude de manières de définir un DataFrame avec Pandas. Voici un exemple concret avec des personnes dont on connait les caractéristiques (nom, age, sexe, poids, taille).

Le DataFrame est une matrice dont les lignes sont des individus ou des objets et les colonnes sont les propriétés associées à ces individus. L'intérêt des Dataframe et qu'ils permettent de manipuler plusieurs colonnes avec des types différents (entier, réel, chaîne de caractères) alors qu'avec numpy> les données doivent être du même type.

1.1.1. Description des données sous forme de listes

  1. import pandas as pd
  2.  
  3. # listes des ages, poids, sexe, noms
  4. ages = [ 20, 10, 15, 30, 45, 18 ]
  5. poids = [ 80, 25, 35, 120, 75, 41 ]
  6. sexe = [ 'M', 'F', 'F', 'M', 'M', 'F' ]
  7. noms = [ 'John', 'Julia', 'Janet', 'Jack', 'Jeff', 'Jane' ]
  8.  
  9. # création d'une matrice de 6 lignes par 4 colonnes sous forme
  10. # de tuples
  11. l = list(zip(noms,sexe,ages,poids))
  12. print("zip = ", l)
  13.  
  14. df = pd.DataFrame( data = l , columns=['nom','sexe','age','poids'])
  15. print(df)

1.1.2. Sous forme de fichier CSV

Attention : ne surtout pas mettre d'espace entre les champs dans la définition de StringIO sinon certaines valeurs ne serons pas reconnues. Par exemple pour :

"John","M",20,80

La chaine "M" sera reconnue comme tel, mais si on écrit :

"John", "M",20,80

La même valeur sera reconnue en tant que ' "M"'

  1. from io import StringIO
  2. import pandas as pd
  3.  
  4. donnees = StringIO("""nom,sexe,age,poids
  5. "John","M",20,80
  6. "Julia","F",10,25
  7. "Janet","F",15,35
  8. "Jack","M",30,120
  9. "Jeff","M",45,75
  10. "Jane","F",18,41
  11. """)
  12.  
  13. df = pd.read_csv( data = donnees, sep=",")
  14. print(df)

1.2. Informations d'un DataFrame

Les informations concernant le DataFrame sont par exemple :

  1. from io import StringIO
  2. import pandas as pd
  3.  
  4. donnees = StringIO("""nom,sexe,age,poids
  5. "John","M",20,80
  6. "Julia","F",10,25
  7. "Janet","F",15,35
  8. "Jack","M",30,120
  9. "Jeff","M",45,75
  10. "Jane","F",18,41
  11. """)
  12.  
  13. df = pd.read_csv(donnees, sep=",")
  14.  
  15. print("shape=", df.shape)
  16. print("index=", df.index)
  17. print("=== types ====\n", df.dtypes)
  18. print("=== description ===\n", df.describe())
shape= (6, 4)
index= RangeIndex(start=0, stop=6, step=1)
=== types ====
 nom      object
sexe     object
age       int64
poids     int64
dtype: object
=== description ===
              age       poids
count   6.000000    6.000000   # nombre de données
mean   23.000000   62.666667   # moyenne des données
std    12.649111   35.758449   # écart type
min    10.000000   25.000000   # valeur minimum
25%    15.750000   36.500000   # centiles
50%    19.000000   58.000000   # 
75%    27.500000   78.750000   # 
max    45.000000  120.000000   # valeur maximum

1.3. Manipulation d'un DataFrame

1.3.1. Renommer les colonnes

La variable inplace à vrai permet de ne pas refaire l'assignation du DataFrame.

  1. from io import StringIO
  2. import pandas as pd
  3.  
  4. donnees = StringIO("""nom,sexe,age,poids
  5. "John","M",20,80
  6. "Julia","F",10,25
  7. "Janet","F",15,35
  8. "Jack","M",30,120
  9. "Jeff","M",45,75
  10. "Jane","F",18,41
  11. """)
  12.  
  13. df = pd.read_csv(donnees, sep=",")
  14.  
  15. df.rename(columns={'nom': 'name', 'sexe': 'sex'}, inplace=True)
  16. print(df.head())

1.3.2. Supprimer des colonnes

La variable inplace à vrai permet de ne pas refaire l'assignation du DataFrame.

  1. from io import StringIO
  2. import pandas as pd
  3.  
  4. donnees = StringIO("""nom,sexe,age,poids
  5. "John","M",20,80
  6. "Julia","F",10,25
  7. "Janet","F",15,35
  8. "Jack","M",30,120
  9. "Jeff","M",45,75
  10. "Jane","F",18,41
  11. """)
  12.  
  13. df = pd.read_csv(donnees, sep=",")
  14.  
  15. df1 = df.drop(['nom','sexe'], 1)
  16. print(df1)
  17.  
  18. #
  19. # ou utiliser :
  20. #
  21. df.drop(['nom','sexe'], 1, inplace=True)
  22. print(df.head())

1.3.3. Extraire des colonnes

  1. from io import StringIO
  2. import pandas as pd
  3.  
  4. donnees = StringIO("""nom,sexe,age,poids
  5. "John","M",20,80
  6. "Julia","F",10,25
  7. "Janet","F",15,35
  8. "Jack","M",30,120
  9. "Jeff","M",45,75
  10. "Jane","F",18,41
  11. """)
  12.  
  13. df = pd.read_csv(donnees, sep=",")
  14.  
  15. df_age_poids = df[ ['age', 'poids'] ]
  16. print(df_age_poids)

1.3.4. Sélectionner des lignes

  1. from io import StringIO
  2. import pandas as pd
  3.  
  4. donnees = StringIO("""nom,sexe,age,poids
  5. "John","M",20,80
  6. "Julia","F",10,25
  7. "Janet","F",15,35
  8. "Jack","M",30,120
  9. "Jeff","M",45,75
  10. "Jane","F",18,41
  11. """)
  12.  
  13. df = pd.read_csv(donnees, sep=",")
  14.  
  15. # sélection des lignes paires
  16. df1 = df.loc[ 0:6:2 ]
  17. print(df1)
  18.  
  19. # sélection des colonnes 'sexe' à 'poids'
  20. # pour les lignes paires
  21. df2 = df.loc[ 0:6:2, 'sexe':'poids' ]
  22. print(df2)
  23.  
  24. # sélection des colonnes 'sexe' et 'poids'
  25. # pour les lignes impaires
  26. df3 = df.loc[ 1:7:2, ['sexe','poids'] ]
  27. print(df3)

1.3.5. Sélection suivant critères

  1. from io import StringIO
  2. import pandas as pd
  3.  
  4. donnees = StringIO("""nom,sexe,age,poids
  5. "John","M",20,80
  6. "Julia","F",10,25
  7. "Janet","F",15,35
  8. "Jack","M",30,120
  9. "Jeff","M",45,75
  10. "Jane","F",18,41
  11. """)
  12.  
  13. df = pd.read_csv(donnees, sep=",")
  14.  
  15. #
  16. # Sélection des hommes de plus de 20 ans
  17. # on réalise le traitement de deux manières différentes
  18. #
  19. df1 = df.loc[ (df.sexe.str.contains("M")) & (df.age > 20)]
  20. print(df1)
  21. df2 = df[ (df.sexe == "M") & (df.age > 20)]
  22. print(df2)

1.4. Modification des données

Le fichier CSV suivant qui contient des données sur les iris de Fisher possède des noms de colonnes que l'on désire modifier et une colonne "variety" que l'on désire transformer en une valeur : 0 pour Setosa, 1 pour Versicolor et 2 pour Virginica.

"sepal.length","sepal.width","petal.length","petal.width","variety"
5.1,3.5,1.4,.2,"Setosa"
4.9,3,1.4,.2,"Setosa"
4.7,3.2,1.3,.2,"Setosa"
4.6,3.1,1.5,.2,"Setosa"
...
6.3,2.5,5,1.9,"Virginica"
6.5,3,5.2,2,"Virginica"
6.2,3.4,5.4,2.3,"Virginica"
5.9,3,5.1,1.8,"Virginica"
  1. import pandas as pd
  2.  
  3. iris = pd.read_csv("http://www.info.univ-angers.fr/~richer/polytech/iris.csv", sep=",")
  4. print(iris.head())
  5.  
  6. iris.columns = ["sl","sw","pl","pw","sp"]
  7. print(iris.head())
  8.  
  9. def conv_species(x):
  10.     if x == "Setosa":
  11.         return 0
  12.     if x == "Versicolor":
  13.         return 1
  14.     if x == "Virginica":
  15.         return 2
  16.  
  17. iris.sp = iris.sp.apply( conv_species )
  18.  
  19. print(iris)

1.5. Interaction avec seaborn

Le paquet seaborn est une librairie de visualisation de données basée sur matplotlib. Elle permet par exemple d'afficher une matrice de corrélation des données ou des pairplot qui donne un aperçu visuel des relations existantes entre les données.

  1. import pandas as pd
  2. import seaborn as sns
  3. import matplotlib.pyplot as plt
  4.  
  5. iris = pd.read_csv("http://www.info.univ-angers.fr/~richer/polytech/iris.csv", sep=",")
  6. print(iris.head())
  7.  
  8. iris.columns = ["sl","sw","pl","pw","sp"]
  9. print(iris.head())
  10.  
  11. def conv_species(x):
  12.     if x == "Setosa":
  13.         return 0
  14.     if x == "Versicolor":
  15.         return 1
  16.     if x == "Virginica":
  17.         return 2
  18.  
  19. iris.sp = iris.sp.apply( conv_species )
  20.  
  21. # correlation matrix
  22. corr = iris.corr()
  23. sns.heatmap(corr, cmap=sns.color_palette("coolwarm"), linewidths=.5, \
  24.         annot=True, xticklabels=corr.columns.values, \
  25.         yticklabels=corr.columns.values)
  26. plt.title("Matrice de corrélation")
  27. plt.show()
  28.  
  29. # relational plot
  30. cmap = sns.color_palette("hls", len(set(iris.sp)))
  31. g = sns.relplot(data=iris, x="pw", y="pl",
  32.     hue="sp", size="sl", palette=cmap)
  33. plt.show()
  34.  
  35. # pairplots
  36. sns.pairplot(iris, corner=True)
  37. sns.pairplot(iris, hue="sp", palette= 'Set2', kind='scatter')
  38. sns.pairplot(iris, hue="sp", palette= 'cividis', kind='reg')
  39. plt.show()

On voit notamment la corrélation entre :