Python Pandas - Guide rapide

Pandas est une bibliothèque Python open source fournissant un outil de manipulation et d'analyse de données haute performance à l'aide de ses puissantes structures de données. Le nom Pandas est dérivé du mot Panel Data - une économétrie à partir de données multidimensionnelles.

En 2008, le développeur Wes McKinney a commencé à développer des pandas lorsqu'il avait besoin d'un outil flexible et performant pour l'analyse des données.

Avant Pandas, Python était principalement utilisé pour la collecte et la préparation de données. Il a très peu contribué à l'analyse des données. Les pandas ont résolu ce problème. En utilisant Pandas, nous pouvons accomplir cinq étapes typiques dans le traitement et l'analyse des données, quelle que soit l'origine des données: charger, préparer, manipuler, modéliser et analyser.

Python with Pandas est utilisé dans un large éventail de domaines, y compris les domaines académiques et commerciaux, notamment la finance, l'économie, les statistiques, l'analyse, etc.

Principales caractéristiques des pandas

Objet DataFrame rapide et efficace avec indexation par défaut et personnalisée.
Outils de chargement de données dans des objets de données en mémoire à partir de différents formats de fichiers.
Alignement des données et traitement intégré des données manquantes.
Remodelage et pivotement des ensembles de dates.
Découpage, indexation et sous-ensemble basés sur des étiquettes de grands ensembles de données.
Les colonnes d'une structure de données peuvent être supprimées ou insérées.
Regrouper par données pour l'agrégation et les transformations.
Fusion et jonction de données haute performance.
Fonctionnalité de série temporelle.

La distribution Python standard n'est pas fournie avec le module Pandas. Une alternative légère consiste à installer NumPy à l'aide du programme d'installation de package Python populaire,pip.

pip install pandas

Si vous installez le package Anaconda Python, Pandas sera installé par défaut avec les éléments suivants -

les fenêtres

Anaconda (de https://www.continuum.io) est une distribution Python gratuite pour la pile SciPy. Il est également disponible pour Linux et Mac.
Canopy (https://www.enthought.com/products/canopy/) est disponible en tant que distribution gratuite et commerciale avec une pile SciPy complète pour Windows, Linux et Mac.
Python(x, y) est une distribution Python gratuite avec la pile SciPy et Spyder IDE pour Windows OS. (Téléchargeable depuishttp://python-xy.github.io/)

Linux

Les gestionnaires de packages des distributions Linux respectives sont utilisés pour installer un ou plusieurs packages dans la pile SciPy.

For Ubuntu Users

sudo apt-get install python-numpy python-scipy python-matplotlibipythonipythonnotebook
python-pandas python-sympy python-nose

For Fedora Users

sudo yum install numpyscipy python-matplotlibipython python-pandas sympy
python-nose atlas-devel

Pandas traite les trois structures de données suivantes -

Series
DataFrame
Panel

Ces structures de données sont construites au-dessus du tableau Numpy, ce qui signifie qu'elles sont rapides.

Dimension et description

La meilleure façon de penser à ces structures de données est que la structure de données de dimension supérieure est un conteneur de sa structure de données de dimension inférieure. Par exemple, DataFrame est un conteneur de Series, Panel est un conteneur de DataFrame.

Structure de données	Dimensions	La description
Séries	1	Tableau homogène marqué 1D, taille immuable.
Cadres de données	2	Structure tabulaire générale 2D étiquetée et modifiable en taille avec des colonnes de typage potentiellement hétérogène.
Panneau	3	Tableau général étiqueté 3D, taille modifiable.

La construction et la manipulation de tableaux à deux dimensions ou plus est une tâche fastidieuse, la charge incombe à l'utilisateur de prendre en compte l'orientation de l'ensemble de données lors de l'écriture des fonctions. Mais en utilisant les structures de données Pandas, l'effort mental de l'utilisateur est réduit.

Par exemple, avec des données tabulaires (DataFrame), il est plus sémantiquement utile de penser à la index (les rangées) et le columns plutôt que l'axe 0 et l'axe 1.

Mutabilité

Toutes les structures de données Pandas sont modifiables en valeur (peuvent être modifiées) et à l'exception des séries, toutes sont modifiables en taille. La série est de taille immuable.

Note- DataFrame est largement utilisé et l'une des structures de données les plus importantes. Le panneau est beaucoup moins utilisé.

Séries

La série est une structure de type tableau unidimensionnelle avec des données homogènes. Par exemple, la série suivante est une collection d'entiers 10, 23, 56,…

dix	23	56	17	52	61	73	90	26	72

Points clés

Données homogènes
Taille immuable
Valeurs de données mutables

Trame de données

DataFrame est un tableau à deux dimensions avec des données hétérogènes. Par exemple,

Nom	Âge	Le sexe	Évaluation
Steve	32	Masculin	3,45
Lia	28	Femme	4.6
Vin	45	Masculin	3,9
Katie	38	Femme	2,78

Le tableau représente les données d'une équipe de vente d'une organisation avec leur note de performance globale. Les données sont représentées en lignes et en colonnes. Chaque colonne représente un attribut et chaque ligne représente une personne.

Type de données des colonnes

Les types de données des quatre colonnes sont les suivants -

Colonne	Type
Nom	Chaîne
Âge	Entier
Le sexe	Chaîne
Évaluation	Flotte

Points clés

Données hétérogènes
Taille Mutable
Données mutables

Panneau

Panel est une structure de données tridimensionnelle avec des données hétérogènes. Il est difficile de représenter le panneau sous forme de représentation graphique. Mais un panneau peut être illustré comme un conteneur de DataFrame.

Points clés

Données hétérogènes
Taille Mutable
Données mutables

Series est un tableau étiqueté unidimensionnel capable de contenir des données de tout type (entier, chaîne, flottant, objets python, etc.). Les étiquettes des axes sont appelées collectivement index.

pandas.Série

Une série pandas peut être créée en utilisant le constructeur suivant -

pandas.Series( data, index, dtype, copy)

Les paramètres du constructeur sont les suivants -

Sr.Non	Paramètre et description
1	data les données prennent diverses formes comme ndarray, liste, constantes
2	index Les valeurs d'index doivent être uniques et hachables, de la même longueur que les données. Défautnp.arange(n) si aucun index n'est passé.
3	dtype dtype est pour le type de données. Si aucun, le type de données sera déduit
4	copy Copiez les données. Valeur par défaut False

Une série peut être créée en utilisant diverses entrées telles que -

Array
Dict
Valeur scalaire ou constante

Créer une série vide

Une série de base qui peut être créée est une série vide.

Exemple

#import the pandas library and aliasing as pd
import pandas as pd
s = pd.Series()
print s

Ses output est comme suit -

Series([], dtype: float64)

Créer une série à partir de ndarray

Si data est un ndarray, alors l'index passé doit être de la même longueur. Si aucun index n'est passé, l'index par défaut serarange(n) où n est la longueur du tableau, c'est-à-dire [0,1,2,3…. range(len(array))-1].

Exemple 1

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = np.array(['a','b','c','d'])
s = pd.Series(data)
print s

Ses output est comme suit -

0   a
1   b
2   c
3   d
dtype: object

Nous n'avons passé aucun index, donc par défaut, il a attribué les index allant de 0 à len(data)-1, c'est-à-dire de 0 à 3.

Exemple 2

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = np.array(['a','b','c','d'])
s = pd.Series(data,index=[100,101,102,103])
print s

Ses output est comme suit -

100  a
101  b
102  c
103  d
dtype: object

Nous avons transmis les valeurs d'index ici. Nous pouvons maintenant voir les valeurs indexées personnalisées dans la sortie.

Créer une série à partir de dict

UNE dictpeut être passé en entrée et si aucun index n'est spécifié, les clés du dictionnaire sont prises dans un ordre trié pour construire l'index. Siindex est passé, les valeurs des données correspondant aux étiquettes de l'index seront extraites.

Exemple 1

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data)
print s

Ses output est comme suit -

a 0.0
b 1.0
c 2.0
dtype: float64

Observe - Les clés de dictionnaire sont utilisées pour construire l'index.

Exemple 2

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data,index=['b','c','d','a'])
print s

Ses output est comme suit -

b 1.0
c 2.0
d NaN
a 0.0
dtype: float64

Observe - L'ordre d'index est conservé et l'élément manquant est rempli avec NaN (Not a Number).

Créer une série à partir de Scalar

Si les données sont une valeur scalaire, un index doit être fourni. La valeur sera répétée pour correspondre à la longueur deindex

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
s = pd.Series(5, index=[0, 1, 2, 3])
print s

Ses output est comme suit -

0  5
1  5
2  5
3  5
dtype: int64

Accès aux données d'une série avec position

L'accès aux données de la série est similaire à celui d'un ndarray.

Exemple 1

Récupérez le premier élément. Comme nous le savons déjà, le comptage commence à zéro pour le tableau, ce qui signifie que le premier élément est stocké à zéro ^ème position et ainsi de suite.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve the first element
print s[0]

Ses output est comme suit -

Exemple 2

Récupérez les trois premiers éléments de la série. Si un: est inséré devant lui, tous les éléments de cet index seront extraits. Si deux paramètres (avec: entre eux) sont utilisés, les éléments entre les deux index (sans compter l'index d'arrêt)

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve the first three element
print s[:3]

Ses output est comme suit -

a  1
b  2
c  3
dtype: int64

Exemple 3

Récupérez les trois derniers éléments.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve the last three element
print s[-3:]

Ses output est comme suit -

c  3
d  4
e  5
dtype: int64

Récupérer des données à l'aide de l'étiquette (index)

Une série est comme une taille fixe dict en ce que vous pouvez obtenir et définir des valeurs par étiquette d'index.

Exemple 1

Récupérez un seul élément à l'aide de la valeur d'étiquette d'index.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve a single element
print s['a']

Ses output est comme suit -

Exemple 2

Récupérez plusieurs éléments à l'aide d'une liste de valeurs d'étiquettes d'index.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve multiple elements
print s[['a','c','d']]

Ses output est comme suit -

a  1
c  3
d  4
dtype: int64

Exemple 3

Si aucune étiquette n'est contenue, une exception est déclenchée.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve multiple elements
print s['f']

Ses output est comme suit -

…
KeyError: 'f'

Une trame de données est une structure de données bidimensionnelle, c'est-à-dire que les données sont alignées de manière tabulaire en lignes et en colonnes.

Caractéristiques de DataFrame

Potentiellement, les colonnes sont de types différents
Taille - Mutable
Axes étiquetés (lignes et colonnes)
Peut effectuer des opérations arithmétiques sur les lignes et les colonnes

Structure

Supposons que nous créons une base de données avec les données des élèves.

Vous pouvez le considérer comme une table SQL ou une représentation de données de feuille de calcul.

pandas.DataFrame

Un DataFrame pandas peut être créé en utilisant le constructeur suivant -

pandas.DataFrame( data, index, columns, dtype, copy)

Les paramètres du constructeur sont les suivants -

Sr.Non	Paramètre et description
1	data les données prennent diverses formes comme ndarray, series, map, lists, dict, constants et aussi un autre DataFrame.
2	index Pour les étiquettes de ligne, l'index à utiliser pour l'image résultante est facultatif Par défaut np.arange (n) si aucun index n'est passé.
3	columns Pour les étiquettes de colonne, la syntaxe par défaut facultative est - np.arange (n). Ceci n'est vrai que si aucun index n'est passé.
4	dtype Type de données de chaque colonne.
5	copy Cette commande (ou quoi que ce soit) est utilisée pour copier des données, si la valeur par défaut est False.

Créer DataFrame

Un pandas DataFrame peut être créé en utilisant diverses entrées comme -

Lists
dict
Series
Numpy ndarrays
Un autre DataFrame

Dans les sections suivantes de ce chapitre, nous verrons comment créer un DataFrame en utilisant ces entrées.

Créer un DataFrame vide

Un DataFrame de base, qui peut être créé est un Dataframe vide.

Exemple

#import the pandas library and aliasing as pd
import pandas as pd
df = pd.DataFrame()
print df

Ses output est comme suit -

Empty DataFrame
Columns: []
Index: []

Créer un DataFrame à partir de listes

Le DataFrame peut être créé à l'aide d'une seule liste ou d'une liste de listes.

Exemple 1

import pandas as pd
data = [1,2,3,4,5]
df = pd.DataFrame(data)
print df

Ses output est comme suit -

Exemple 2

import pandas as pd
data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'])
print df

Ses output est comme suit -

Name      Age
0     Alex      10
1     Bob       12
2     Clarke    13

Exemple 3

import pandas as pd
data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'],dtype=float)
print df

Ses output est comme suit -

Name     Age
0     Alex     10.0
1     Bob      12.0
2     Clarke   13.0

Note - Observez, le dtype paramètre change le type de colonne Age en virgule flottante.

Créer un DataFrame à partir de Dict of ndarrays / Lists

Tous les ndarraysdoit être de même longueur. Si l'index est passé, la longueur de l'index doit être égale à la longueur des tableaux.

Si aucun index n'est passé, alors par défaut, l'index sera range (n), où n est la longueur du tableau.

Exemple 1

import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data)
print df

Ses output est comme suit -

Age      Name
0     28        Tom
1     34       Jack
2     29      Steve
3     42      Ricky

Note- Respectez les valeurs 0,1,2,3. Il s'agit de l'index par défaut attribué à chacun à l'aide de la plage de fonctions (n).

Exemple 2

Créons maintenant un DataFrame indexé à l'aide de tableaux.

import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data, index=['rank1','rank2','rank3','rank4'])
print df

Ses output est comme suit -

Age    Name
rank1    28      Tom
rank2    34     Jack
rank3    29    Steve
rank4    42    Ricky

Note - Observez, le index attribue un index à chaque ligne.

Créer un DataFrame à partir de la liste des dictionnaires

La liste des dictionnaires peut être transmise en tant que données d'entrée pour créer un DataFrame. Les clés du dictionnaire sont prises par défaut comme noms de colonne.

Exemple 1

L'exemple suivant montre comment créer un DataFrame en passant une liste de dictionnaires.

import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data)
print df

Ses output est comme suit -

a    b      c
0   1   2     NaN
1   5   10   20.0

Note - Observez, NaN (Not a Number) est ajouté dans les zones manquantes.

Exemple 2

L'exemple suivant montre comment créer un DataFrame en passant une liste de dictionnaires et les index de ligne.

import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data, index=['first', 'second'])
print df

Ses output est comme suit -

a   b       c
first   1   2     NaN
second  5   10   20.0

Exemple 3

L'exemple suivant montre comment créer un DataFrame avec une liste de dictionnaires, d'index de ligne et d'index de colonne.

import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]

#With two column indices, values same as dictionary keys
df1 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b'])

#With two column indices with one index with other name
df2 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b1'])
print df1
print df2

Ses output est comme suit -

#df1 output
         a  b
first    1  2
second   5  10

#df2 output
         a  b1
first    1  NaN
second   5  NaN

Note- Remarquez que df2 DataFrame est créé avec un index de colonne autre que la clé de dictionnaire; ainsi, ajouté les NaN en place. Alors que df1 est créé avec des index de colonne identiques aux clés de dictionnaire, NaN est donc ajouté.

Créer un DataFrame à partir de Dict of Series

Dictionary of Series peut être transmis pour former un DataFrame. L'index résultant est l'union de tous les index de séries passés.

Exemple

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df

Ses output est comme suit -

one    two
a     1.0    1
b     2.0    2
c     3.0    3
d     NaN    4

Note - Attention, pour la série un, il n'y a pas d'étiquette ‘d’ passé, mais dans le résultat, pour le d label, NaN est ajouté avec NaN.

Comprenons maintenant column selection, addition, et deletion à travers des exemples.

Sélection de colonne

Nous comprendrons cela en sélectionnant une colonne dans le DataFrame.

Exemple

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df ['one']

Ses output est comme suit -

a     1.0
b     2.0
c     3.0
d     NaN
Name: one, dtype: float64

Ajout de colonne

Nous comprendrons cela en ajoutant une nouvelle colonne à un bloc de données existant.

Exemple

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)

# Adding a new column to an existing DataFrame object with column label by passing new series

print ("Adding a new column by passing as Series:")
df['three']=pd.Series([10,20,30],index=['a','b','c'])
print df

print ("Adding a new column using the existing columns in DataFrame:")
df['four']=df['one']+df['three']

print df

Ses output est comme suit -

Adding a new column by passing as Series:
     one   two   three
a    1.0    1    10.0
b    2.0    2    20.0
c    3.0    3    30.0
d    NaN    4    NaN

Adding a new column using the existing columns in DataFrame:
      one   two   three    four
a     1.0    1    10.0     11.0
b     2.0    2    20.0     22.0
c     3.0    3    30.0     33.0
d     NaN    4     NaN     NaN

Suppression de colonne

Les colonnes peuvent être supprimées ou sautées; prenons un exemple pour comprendre comment.

Exemple

# Using the previous DataFrame, we will delete a column
# using del function
import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), 
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd']), 
   'three' : pd.Series([10,20,30], index=['a','b','c'])}

df = pd.DataFrame(d)
print ("Our dataframe is:")
print df

# using del function
print ("Deleting the first column using DEL function:")
del df['one']
print df

# using pop function
print ("Deleting another column using POP function:")
df.pop('two')
print df

Ses output est comme suit -

Our dataframe is:
      one   three  two
a     1.0    10.0   1
b     2.0    20.0   2
c     3.0    30.0   3
d     NaN     NaN   4

Deleting the first column using DEL function:
      three    two
a     10.0     1
b     20.0     2
c     30.0     3
d     NaN      4

Deleting another column using POP function:
   three
a  10.0
b  20.0
c  30.0
d  NaN

Sélection, ajout et suppression de lignes

Nous allons maintenant comprendre la sélection, l'ajout et la suppression de lignes à travers des exemples. Commençons par le concept de sélection.

Sélection par étiquette

Les lignes peuvent être sélectionnées en passant l'étiquette de ligne à un loc fonction.

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), 
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df.loc['b']

Ses output est comme suit -

one 2.0
two 2.0
Name: b, dtype: float64

Le résultat est une série avec des étiquettes comme noms de colonne du DataFrame. Et, le nom de la série est l'étiquette avec laquelle elle est récupérée.

Sélection par emplacement entier

Les lignes peuvent être sélectionnées en passant un emplacement entier à un iloc fonction.

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df.iloc[2]

Ses output est comme suit -

one   3.0
two   3.0
Name: c, dtype: float64

Trancher les lignes

Plusieurs lignes peuvent être sélectionnées à l'aide de l'opérateur ':'.

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), 
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df[2:4]

Ses output est comme suit -

one  two
c  3.0    3
d  NaN    4

Ajout de lignes

Ajouter de nouvelles lignes à un DataFrame à l'aide du appendfonction. Cette fonction ajoutera les lignes à la fin.

import pandas as pd

df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])

df = df.append(df2)
print df

Ses output est comme suit -

Suppression de lignes

Utilisez l'étiquette d'index pour supprimer ou supprimer des lignes d'un DataFrame. Si l'étiquette est dupliquée, plusieurs lignes seront supprimées.

Si vous observez, dans l'exemple ci-dessus, les étiquettes sont dupliquées. Laissez-nous déposer une étiquette et verrons combien de lignes seront supprimées.

import pandas as pd

df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])

df = df.append(df2)

# Drop rows with label 0
df = df.drop(0)

print df

Ses output est comme suit -

a b
1 3 4
1 7 8

Dans l'exemple ci-dessus, deux lignes ont été supprimées car ces deux contiennent la même étiquette 0.

UNE panelest un conteneur 3D de données. Le termePanel data est dérivé de l'économétrie et est en partie responsable du nom de pandas - pan(el)-da(ta)-s.

Les noms des 3 axes sont destinés à donner une signification sémantique à la description des opérations impliquant des données de panel. Ils sont -

items - axe 0, chaque élément correspond à un DataFrame contenu à l'intérieur.
major_axis - axe 1, c'est l'index (lignes) de chacun des DataFrames.
minor_axis - axe 2, ce sont les colonnes de chacun des DataFrames.

pandas.Panel ()

Un Panel peut être créé en utilisant le constructeur suivant -

pandas.Panel(data, items, major_axis, minor_axis, dtype, copy)

Les paramètres du constructeur sont les suivants -

Paramètre	La description
Les données	Les données prennent diverses formes telles que ndarray, séries, carte, listes, dict, constantes et également un autre DataFrame
articles	axe = 0
major_axis	axe = 1
axe_mineur	axe = 2
dtype	Type de données de chaque colonne
copie	Copiez les données. Défaut,false

Créer un panneau

Un panneau peut être créé de plusieurs façons comme -

Chez ndarrays
À partir de dict de DataFrames

À partir de 3D ndarray

# creating an empty panel
import pandas as pd
import numpy as np

data = np.random.rand(2,4,5)
p = pd.Panel(data)
print p

Ses output est comme suit -

<class 'pandas.core.panel.Panel'>
Dimensions: 2 (items) x 4 (major_axis) x 5 (minor_axis)
Items axis: 0 to 1
Major_axis axis: 0 to 3
Minor_axis axis: 0 to 4

Note - Observez les dimensions du panneau vide et du panneau ci-dessus, tous les objets sont différents.

À partir de dict d'objets DataFrame

#creating an empty panel
import pandas as pd
import numpy as np

data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), 
   'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p

Ses output est comme suit -

Dimensions: 2 (items) x 4 (major_axis) x 3 (minor_axis)
Items axis: Item1 to Item2
Major_axis axis: 0 to 3
Minor_axis axis: 0 to 2

Créer un panneau vide

Un panneau vide peut être créé à l'aide du constructeur Panel comme suit -

#creating an empty panel
import pandas as pd
p = pd.Panel()
print p

Ses output est comme suit -

<class 'pandas.core.panel.Panel'>
Dimensions: 0 (items) x 0 (major_axis) x 0 (minor_axis)
Items axis: None
Major_axis axis: None
Minor_axis axis: None

Sélection des données à partir du panneau

Sélectionnez les données du panneau en utilisant -

Items
Major_axis
Minor_axis

Utilisation des éléments

# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), 
   'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p['Item1']

Ses output est comme suit -

0          1          2
0    0.488224  -0.128637   0.930817
1    0.417497   0.896681   0.576657
2   -2.775266   0.571668   0.290082
3   -0.400538  -0.144234   1.110535

Nous avons deux articles et nous avons récupéré item1. Le résultat est un DataFrame avec 4 lignes et 3 colonnes, qui sont lesMajor_axis et Minor_axis dimensions.

Utilisation de major_axis

Les données sont accessibles en utilisant la méthode panel.major_axis(index).

# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), 
   'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p.major_xs(1)

Ses output est comme suit -

Item1       Item2
0   0.417497    0.748412
1   0.896681   -0.557322
2   0.576657       NaN

Utilisation de minor_axis

Les données sont accessibles en utilisant la méthode panel.minor_axis(index).

# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), 
   'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p.minor_xs(1)

Ses output est comme suit -

Item1       Item2
0   -0.128637   -1.047032
1    0.896681   -0.557322
2    0.571668    0.431953
3   -0.144234    1.302466

Note - Observez les changements de dimensions.

À présent, nous avons découvert les trois structures de données Pandas et comment les créer. Nous nous concentrerons principalement sur les objets DataFrame en raison de son importance dans le traitement des données en temps réel et discuterons également de quelques autres DataStructures.

Fonctionnalité de base de la série

Sr.No.	Attribut ou méthode et description
1	axes Renvoie une liste des étiquettes de l'axe des lignes
2	dtype Renvoie le dtype de l'objet.
3	empty Renvoie True si la série est vide.
4	ndim Renvoie le nombre de dimensions des données sous-jacentes, par définition 1.
5	size Renvoie le nombre d'éléments dans les données sous-jacentes.
6	values Renvoie la série sous la forme ndarray.
sept	head() Renvoie les n premières lignes.
8	tail() Renvoie les n dernières lignes.

Créons maintenant une série et voyons toutes les opérations d'attributs tabulés ci-dessus.

Exemple

import pandas as pd
import numpy as np

#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print s

Ses output est comme suit -

0   0.967853
1  -0.148368
2  -1.395906
3  -1.758394
dtype: float64

axes

Renvoie la liste des étiquettes de la série.

import pandas as pd
import numpy as np

#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print ("The axes are:")
print s.axes

Ses output est comme suit -

The axes are:
[RangeIndex(start=0, stop=4, step=1)]

Le résultat ci-dessus est un format compact d'une liste de valeurs de 0 à 5, c'est-à-dire [0,1,2,3,4].

vide

Renvoie la valeur booléenne indiquant si l'objet est vide ou non. True indique que l'objet est vide.

import pandas as pd
import numpy as np

#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print ("Is the Object empty?")
print s.empty

Ses output est comme suit -

Is the Object empty?
False

ndim

Renvoie le nombre de dimensions de l'objet. Par définition, une série est une structure de données 1D, elle renvoie donc

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print s

print ("The dimensions of the object:")
print s.ndim

Ses output est comme suit -

0   0.175898
1   0.166197
2  -0.609712
3  -1.377000
dtype: float64

The dimensions of the object:
1

Taille

Renvoie la taille (longueur) de la série.

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(2))
print s
print ("The size of the object:")
print s.size

Ses output est comme suit -

0   3.078058
1  -1.207803
dtype: float64

The size of the object:
2

valeurs

Renvoie les données réelles de la série sous forme de tableau.

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print s

print ("The actual data series is:")
print s.values

Ses output est comme suit -

0   1.787373
1  -0.605159
2   0.180477
3  -0.140922
dtype: float64

The actual data series is:
[ 1.78737302 -0.60515881 0.18047664 -0.1409218 ]

Tête et queue

Pour afficher un petit échantillon d'une série ou de l'objet DataFrame, utilisez les méthodes head () et tail ().

head() renvoie le premier nlignes (observez les valeurs d'index). Le nombre d'éléments à afficher par défaut est de cinq, mais vous pouvez transmettre un nombre personnalisé.

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print ("The original series is:")
print s

print ("The first two rows of the data series:")
print s.head(2)

Ses output est comme suit -

The original series is:
0   0.720876
1  -0.765898
2   0.479221
3  -0.139547
dtype: float64

The first two rows of the data series:
0   0.720876
1  -0.765898
dtype: float64

tail() renvoie le dernier nlignes (observez les valeurs d'index). Le nombre d'éléments à afficher par défaut est de cinq, mais vous pouvez transmettre un nombre personnalisé.

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print ("The original series is:")
print s

print ("The last two rows of the data series:")
print s.tail(2)

Ses output est comme suit -

The original series is:
0 -0.655091
1 -0.881407
2 -0.608592
3 -2.341413
dtype: float64

The last two rows of the data series:
2 -0.608592
3 -2.341413
dtype: float64

Fonctionnalité de base DataFrame

Voyons maintenant ce qu'est la fonctionnalité de base de DataFrame. Les tableaux suivants répertorient les attributs ou méthodes importants qui aident dans la fonctionnalité de base de DataFrame.

Sr.No.	Attribut ou méthode et description
1	T Transpose les lignes et les colonnes.
2	axes Renvoie une liste avec les étiquettes d'axe de ligne et d'axe de colonne comme seuls membres.
3	dtypes Renvoie les dtypes de cet objet.
4	empty Vrai si NDFrame est entièrement vide [aucun élément]; si l'un des axes est de longueur 0.
5	ndim Nombre d'axes / dimensions du tableau.
6	shape Renvoie un tuple représentant la dimensionnalité du DataFrame.
sept	size Nombre d'éléments dans le NDFrame.
8	values Représentation numpy de NDFrame.
9	head() Renvoie les n premières lignes.
dix	tail() Renvoie les n dernières lignes.

Créons maintenant un DataFrame et voyons comment fonctionnent les attributs mentionnés ci-dessus.

Exemple

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data series is:")
print df

Ses output est comme suit -

Our data series is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80

T (Transposer)

Renvoie la transposition du DataFrame. Les lignes et les colonnes seront échangées.

import pandas as pd
import numpy as np
 
# Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

# Create a DataFrame
df = pd.DataFrame(d)
print ("The transpose of the data series is:")
print df.T

Ses output est comme suit -

The transpose of the data series is:
         0     1       2      3      4      5       6
Age      25    26      25     23     30     29      23
Name     Tom   James   Ricky  Vin    Steve  Smith   Jack
Rating   4.23  3.24    3.98   2.56   3.2    4.6     3.8

axes

Renvoie la liste des étiquettes d'axe de ligne et d'axe de colonne.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("Row axis labels and column axis labels are:")
print df.axes

Ses output est comme suit -

Row axis labels and column axis labels are:

[RangeIndex(start=0, stop=7, step=1), Index([u'Age', u'Name', u'Rating'],
dtype='object')]

dtypes

Renvoie le type de données de chaque colonne.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("The data types of each column are:")
print df.dtypes

Ses output est comme suit -

The data types of each column are:
Age     int64
Name    object
Rating  float64
dtype: object

vide

Renvoie la valeur booléenne indiquant si l'objet est vide ou non; True indique que l'objet est vide.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Is the object empty?")
print df.empty

Ses output est comme suit -

Is the object empty?
False

ndim

Renvoie le nombre de dimensions de l'objet. Par définition, DataFrame est un objet 2D.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The dimension of the object is:")
print df.ndim

Ses output est comme suit -

Our object is:
      Age    Name     Rating
0     25     Tom      4.23
1     26     James    3.24
2     25     Ricky    3.98
3     23     Vin      2.56
4     30     Steve    3.20
5     29     Smith    4.60
6     23     Jack     3.80

The dimension of the object is:
2

forme

Renvoie un tuple représentant la dimensionnalité du DataFrame. Tuple (a, b), où a représente le nombre de lignes etb représente le nombre de colonnes.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The shape of the object is:")
print df.shape

Ses output est comme suit -

Our object is:
   Age   Name    Rating
0  25    Tom     4.23
1  26    James   3.24
2  25    Ricky   3.98
3  23    Vin     2.56
4  30    Steve   3.20
5  29    Smith   4.60
6  23    Jack    3.80

The shape of the object is:
(7, 3)

Taille

Renvoie le nombre d'éléments dans le DataFrame.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The total number of elements in our object is:")
print df.size

Ses output est comme suit -

Our object is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80

The total number of elements in our object is:
21

valeurs

Renvoie les données réelles du DataFrame sous la forme d'un NDarray.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The actual data in our data frame is:")
print df.values

Ses output est comme suit -

Our object is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80
The actual data in our data frame is:
[[25 'Tom' 4.23]
[26 'James' 3.24]
[25 'Ricky' 3.98]
[23 'Vin' 2.56]
[30 'Steve' 3.2]
[29 'Smith' 4.6]
[23 'Jack' 3.8]]

Tête et queue

Pour afficher un petit échantillon d'un objet DataFrame, utilisez le head() et les méthodes tail (). head() renvoie le premier nlignes (observez les valeurs d'index). Le nombre d'éléments à afficher par défaut est de cinq, mais vous pouvez transmettre un nombre personnalisé.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data frame is:")
print df
print ("The first two rows of the data frame is:")
print df.head(2)

Ses output est comme suit -

Our data frame is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80

The first two rows of the data frame is:
   Age   Name   Rating
0  25    Tom    4.23
1  26    James  3.24

tail() renvoie le dernier nlignes (observez les valeurs d'index). Le nombre d'éléments à afficher par défaut est de cinq, mais vous pouvez transmettre un nombre personnalisé.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]), 
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data frame is:")
print df
print ("The last two rows of the data frame is:")
print df.tail(2)

Ses output est comme suit -

Our data frame is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80

The last two rows of the data frame is:
    Age   Name    Rating
5   29    Smith    4.6
6   23    Jack     3.8

Un grand nombre de méthodes calculent collectivement des statistiques descriptives et d'autres opérations associées sur DataFrame. La plupart d'entre eux sont des agrégations commesum(), mean(), mais certains d'entre eux, comme sumsum(), produisent un objet de la même taille. De manière générale, ces méthodes prennent unaxisargument, tout comme ndarray. {sum, std, ...}, mais l'axe peut être spécifié par un nom ou un entier

DataFrame - «index» (axe = 0, par défaut), «colonnes» (axe = 1)

Créons un DataFrame et utilisons cet objet tout au long de ce chapitre pour toutes les opérations.

Exemple

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df

Ses output est comme suit -

Age  Name   Rating
0   25   Tom     4.23
1   26   James   3.24
2   25   Ricky   3.98
3   23   Vin     2.56
4   30   Steve   3.20
5   29   Smith   4.60
6   23   Jack    3.80
7   34   Lee     3.78
8   40   David   2.98
9   30   Gasper  4.80
10  51   Betina  4.10
11  46   Andres  3.65

somme()

Renvoie la somme des valeurs de l'axe demandé. Par défaut, l'axe est index (axe = 0).

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.sum()

Ses output est comme suit -

Age                                                    382
Name     TomJamesRickyVinSteveSmithJackLeeDavidGasperBe...
Rating                                               44.92
dtype: object

Chaque colonne individuelle est ajoutée individuellement (les chaînes sont ajoutées).

axe = 1

Cette syntaxe donnera la sortie comme indiqué ci-dessous.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
 
#Create a DataFrame
df = pd.DataFrame(d)
print df.sum(1)

Ses output est comme suit -

0    29.23
1    29.24
2    28.98
3    25.56
4    33.20
5    33.60
6    26.80
7    37.78
8    42.98
9    34.80
10   55.10
11   49.65
dtype: float64

signifier()

Renvoie la valeur moyenne

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.mean()

Ses output est comme suit -

Age       31.833333
Rating     3.743333
dtype: float64

std ()

Renvoie l'écart type de Bressel des colonnes numériques.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.std()

Ses output est comme suit -

Age       9.232682
Rating    0.661628
dtype: float64

Fonctions et description

Voyons maintenant les fonctions sous Statistiques descriptives dans Python Pandas. Le tableau suivant répertorie les fonctions importantes -

Sr.No.	Fonction	La description
1	compter()	Nombre d'observations non nulles
2	somme()	Somme des valeurs
3	signifier()	Moyenne des valeurs
4	médian()	Médiane des valeurs
5	mode()	Mode de valeurs
6	std ()	Écart type des valeurs
sept	min ()	Valeur minimum
8	max ()	Valeur maximum
9	abdos()	Valeur absolue
dix	prod ()	Produit de valeurs
11	jouir ()	Somme cumulative
12	cumprod ()	Produit cumulatif

Note- Puisque DataFrame est une structure de données hétérogène. Les opérations génériques ne fonctionnent pas avec toutes les fonctions.

Fonctions comme sum(), cumsum()travailler à la fois avec des éléments de données numériques et des chaînes de caractères (ou) sans aucune erreur. Bien quen pratique, les agrégations de caractères ne sont généralement jamais utilisées, ces fonctions ne lèvent aucune exception.
Fonctions comme abs(), cumprod() jette une exception lorsque le DataFrame contient des données de caractère ou de chaîne car ces opérations ne peuvent pas être effectuées.

Synthèse des données

le describe() La fonction calcule un résumé des statistiques relatives aux colonnes DataFrame.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.describe()

Ses output est comme suit -

Age         Rating
count    12.000000      12.000000
mean     31.833333       3.743333
std       9.232682       0.661628
min      23.000000       2.560000
25%      25.000000       3.230000
50%      29.500000       3.790000
75%      35.500000       4.132500
max      51.000000       4.800000

Cette fonction donne le mean, std et IQRvaleurs. Et, la fonction exclut les colonnes de caractères et un résumé donné sur les colonnes numériques.'include'est l'argument utilisé pour transmettre les informations nécessaires concernant les colonnes à prendre en compte pour la synthèse. Prend la liste des valeurs; par défaut, «nombre».

object - Résume les colonnes String
number - Résume les colonnes numériques
all - Résume toutes les colonnes ensemble (ne doit pas le passer comme valeur de liste)

Maintenant, utilisez l'instruction suivante dans le programme et vérifiez la sortie -

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.describe(include=['object'])

Ses output est comme suit -

Name
count       12
unique      12
top      Ricky
freq         1

Maintenant, utilisez l'instruction suivante et vérifiez la sortie -

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df. describe(include='all')

Ses output est comme suit -

Age          Name       Rating
count   12.000000        12    12.000000
unique        NaN        12          NaN
top           NaN     Ricky          NaN
freq          NaN         1          NaN
mean    31.833333       NaN     3.743333
std      9.232682       NaN     0.661628
min     23.000000       NaN     2.560000
25%     25.000000       NaN     3.230000
50%     29.500000       NaN     3.790000
75%     35.500000       NaN     4.132500
max     51.000000       NaN     4.800000

Pour appliquer vos propres fonctions ou celles d'une autre bibliothèque à des objets Pandas, vous devez être conscient des trois méthodes importantes. Les méthodes ont été discutées ci-dessous. La méthode appropriée à utiliser dépend de si votre fonction s'attend à fonctionner sur un DataFrame entier, par ligne ou par colonne, ou par élément.

Application de la fonction de table: pipe ()
Application de fonction de ligne ou de colonne Wise: apply ()
Application de fonction par élément: applymap ()

Application de fonction par table

Les opérations personnalisées peuvent être effectuées en passant la fonction et le nombre approprié de paramètres comme arguments de canal. Ainsi, l'opération est effectuée sur l'ensemble du DataFrame.

Par exemple, ajoutez une valeur 2 à tous les éléments du DataFrame. Ensuite,

fonction additionneur

La fonction additionneur ajoute deux valeurs numériques en tant que paramètres et renvoie la somme.

def adder(ele1,ele2):
   return ele1+ele2

Nous allons maintenant utiliser la fonction personnalisée pour effectuer des opérations sur le DataFrame.

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.pipe(adder,2)

Voyons le programme complet -

import pandas as pd
import numpy as np

def adder(ele1,ele2):
   return ele1+ele2

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.pipe(adder,2)
print df.apply(np.mean)

Ses output est comme suit -

col1       col2       col3
0   2.176704   2.219691   1.509360
1   2.222378   2.422167   3.953921
2   2.241096   1.135424   2.696432
3   2.355763   0.376672   1.182570
4   2.308743   2.714767   2.130288

Application de fonction de ligne ou de colonne Wise

Des fonctions arbitraires peuvent être appliquées le long des axes d'un DataFrame ou d'un Panel à l'aide du apply()qui, comme les méthodes de statistiques descriptives, prend un argument optionnel d'axe. Par défaut, l'opération s'effectue par colonne, en prenant chaque colonne comme un tableau.

Exemple 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(np.mean)
print df.apply(np.mean)

Ses output est comme suit -

col1   -0.288022
col2    1.044839
col3   -0.187009
dtype: float64

En passant axis paramètre, les opérations peuvent être effectuées par ligne.

Exemple 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(np.mean,axis=1)
print df.apply(np.mean)

Ses output est comme suit -

col1    0.034093
col2   -0.152672
col3   -0.229728
dtype: float64

Exemple 3

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(lambda x: x.max() - x.min())
print df.apply(np.mean)

Ses output est comme suit -

col1   -0.167413
col2   -0.370495
col3   -0.707631
dtype: float64

Application de la fonction Element Wise

Toutes les fonctions ne peuvent pas être vectorisées (ni les tableaux NumPy qui renvoient un autre tableau ni aucune valeur), les méthodes applymap() sur DataFrame et analogously map() on Series accepte toute fonction Python prenant une seule valeur et renvoyant une seule valeur.

Exemple 1

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])

# My custom function
df['col1'].map(lambda x:x*100)
print df.apply(np.mean)

Ses output est comme suit -

col1    0.480742
col2    0.454185
col3    0.266563
dtype: float64

Exemple 2

import pandas as pd
import numpy as np

# My custom function
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.applymap(lambda x:x*100)
print df.apply(np.mean)

Ses output est comme suit -

col1    0.395263
col2    0.204418
col3   -0.795188
dtype: float64

Reindexingmodifie les étiquettes de ligne et les étiquettes de colonne d'un DataFrame. Pour réindexer des moyens pour se conformer les données pour correspondre à un ensemble donné d'étiquettes le long d' un axe particulier.

Plusieurs opérations peuvent être accomplies grâce à l'indexation comme -

Réorganisez les données existantes pour qu'elles correspondent à un nouvel ensemble d'étiquettes.
Insérez des marqueurs de valeur manquante (NA) aux emplacements d'étiquette où aucune donnée pour l'étiquette n'existait.

Exemple

import pandas as pd
import numpy as np

N=20

df = pd.DataFrame({
   'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
   'x': np.linspace(0,stop=N-1,num=N),
   'y': np.random.rand(N),
   'C': np.random.choice(['Low','Medium','High'],N).tolist(),
   'D': np.random.normal(100, 10, size=(N)).tolist()
})

#reindex the DataFrame
df_reindexed = df.reindex(index=[0,2,5], columns=['A', 'C', 'B'])

print df_reindexed

Ses output est comme suit -

A    C     B
0  2016-01-01  Low   NaN
2  2016-01-03  High  NaN
5  2016-01-06  Low   NaN

Réindexer pour s'aligner avec d'autres objets

Vous souhaiterez peut-être prendre un objet et réindexer ses axes pour qu'ils soient étiquetés de la même manière qu'un autre objet. Prenons l'exemple suivant pour comprendre la même chose.

Exemple

import pandas as pd
import numpy as np

df1 = pd.DataFrame(np.random.randn(10,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(7,3),columns=['col1','col2','col3'])

df1 = df1.reindex_like(df2)
print df1

Ses output est comme suit -

col1         col2         col3
0    -2.467652    -1.211687    -0.391761
1    -0.287396     0.522350     0.562512
2    -0.255409    -0.483250     1.866258
3    -1.150467    -0.646493    -0.222462
4     0.152768    -2.056643     1.877233
5    -1.155997     1.528719    -1.343719
6    -1.015606    -1.245936    -0.295275

Note - Ici, le df1 DataFrame est modifié et réindexé comme df2. Les noms de colonne doivent correspondre, sinon NAN sera ajouté pour l'intégralité de l'étiquette de colonne.

Remplissage pendant la réindexation

reindex() prend une méthode de paramètre facultative qui est une méthode de remplissage avec des valeurs comme suit -

pad/ffill - Remplir les valeurs vers l'avant
bfill/backfill - Remplir les valeurs à l'envers
nearest - Remplir à partir des valeurs d'index les plus proches

Exemple

import pandas as pd
import numpy as np

df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])

# Padding NAN's
print df2.reindex_like(df1)

# Now Fill the NAN's with preceding Values
print ("Data Frame with Forward Fill:")
print df2.reindex_like(df1,method='ffill')

Ses output est comme suit -

col1        col2       col3
0    1.311620   -0.707176   0.599863
1   -0.423455   -0.700265   1.133371
2         NaN         NaN        NaN
3         NaN         NaN        NaN
4         NaN         NaN        NaN
5         NaN         NaN        NaN

Data Frame with Forward Fill:
         col1        col2        col3
0    1.311620   -0.707176    0.599863
1   -0.423455   -0.700265    1.133371
2   -0.423455   -0.700265    1.133371
3   -0.423455   -0.700265    1.133371
4   -0.423455   -0.700265    1.133371
5   -0.423455   -0.700265    1.133371

Note - Les quatre dernières lignes sont rembourrées.

Limites de remplissage lors de la réindexation

L'argument limit fournit un contrôle supplémentaire sur le remplissage lors de la réindexation. Limite spécifie le nombre maximum de correspondances consécutives. Prenons l'exemple suivant pour comprendre la même chose -

Exemple

import pandas as pd
import numpy as np
 
df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])

# Padding NAN's
print df2.reindex_like(df1)

# Now Fill the NAN's with preceding Values
print ("Data Frame with Forward Fill limiting to 1:")
print df2.reindex_like(df1,method='ffill',limit=1)

Ses output est comme suit -

col1        col2        col3
0    0.247784    2.128727    0.702576
1   -0.055713   -0.021732   -0.174577
2         NaN         NaN         NaN
3         NaN         NaN         NaN
4         NaN         NaN         NaN
5         NaN         NaN         NaN

Data Frame with Forward Fill limiting to 1:
         col1        col2        col3
0    0.247784    2.128727    0.702576
1   -0.055713   -0.021732   -0.174577
2   -0.055713   -0.021732   -0.174577
3         NaN         NaN         NaN
4         NaN         NaN         NaN
5         NaN         NaN         NaN

Note- Attention, seule la 7ème ligne est remplie par la 6ème ligne précédente. Ensuite, les lignes sont laissées telles quelles.

Renommer

La méthode rename () vous permet de renommer un axe en fonction d'un mappage (un dict ou une série) ou une fonction arbitraire.

Prenons l'exemple suivant pour comprendre cela -

import pandas as pd
import numpy as np

df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
print df1

print ("After renaming the rows and columns:")
print df1.rename(columns={'col1' : 'c1', 'col2' : 'c2'},
index = {0 : 'apple', 1 : 'banana', 2 : 'durian'})

Ses output est comme suit -

col1        col2        col3
0    0.486791    0.105759    1.540122
1   -0.990237    1.007885   -0.217896
2   -0.483855   -1.645027   -1.194113
3   -0.122316    0.566277   -0.366028
4   -0.231524   -0.721172   -0.112007
5    0.438810    0.000225    0.435479

After renaming the rows and columns:
                c1          c2        col3
apple     0.486791    0.105759    1.540122
banana   -0.990237    1.007885   -0.217896
durian   -0.483855   -1.645027   -1.194113
3        -0.122316    0.566277   -0.366028
4        -0.231524   -0.721172   -0.112007
5         0.438810    0.000225    0.435479

La méthode rename () fournit un inplaceparamètre nommé, qui par défaut est False et copie les données sous-jacentes. Passerinplace=True pour renommer les données en place.

Le comportement de l'itération de base sur les objets Pandas dépend du type. Lors de l'itération sur une série, elle est considérée comme un tableau et une itération de base produit les valeurs. D'autres structures de données, comme DataFrame et Panel, suivent ladict-like convention d'itération sur le keys des objets.

En bref, itération de base (pour i dans l'objet) produit -

Series - valeurs
DataFrame - étiquettes de colonne
Panel - étiquettes d'articles

Itérer un DataFrame

L'itération d'un DataFrame donne des noms de colonnes. Prenons l'exemple suivant pour comprendre la même chose.

import pandas as pd
import numpy as np
 
N=20
df = pd.DataFrame({
   'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
   'x': np.linspace(0,stop=N-1,num=N),
   'y': np.random.rand(N),
   'C': np.random.choice(['Low','Medium','High'],N).tolist(),
   'D': np.random.normal(100, 10, size=(N)).tolist()
   })

for col in df:
   print col

Ses output est comme suit -

A
C
D
x
y

Pour parcourir les lignes du DataFrame, nous pouvons utiliser les fonctions suivantes -

iteritems() - pour itérer sur les paires (clé, valeur)
iterrows() - itérer sur les lignes sous forme de paires (index, série)
itertuples() - itérer sur les lignes comme des tuples nommés

iteritems ()

Itère sur chaque colonne en tant que clé, paire de valeurs avec étiquette en tant que clé et valeur de colonne en tant qu'objet Series.

import pandas as pd
import numpy as np
 
df = pd.DataFrame(np.random.randn(4,3),columns=['col1','col2','col3'])
for key,value in df.iteritems():
   print key,value

Ses output est comme suit -

col1 0    0.802390
1    0.324060
2    0.256811
3    0.839186
Name: col1, dtype: float64

col2 0    1.624313
1   -1.033582
2    1.796663
3    1.856277
Name: col2, dtype: float64

col3 0   -0.022142
1   -0.230820
2    1.160691
3   -0.830279
Name: col3, dtype: float64

Notez que chaque colonne est itérée séparément en tant que paire clé-valeur dans une série.

iterrows ()

iterrows () renvoie l'itérateur produisant chaque valeur d'index avec une série contenant les données dans chaque ligne.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for row_index,row in df.iterrows():
   print row_index,row

Ses output est comme suit -

0  col1    1.529759
   col2    0.762811
   col3   -0.634691
Name: 0, dtype: float64

1  col1   -0.944087
   col2    1.420919
   col3   -0.507895
Name: 1, dtype: float64
 
2  col1   -0.077287
   col2   -0.858556
   col3   -0.663385
Name: 2, dtype: float64
3  col1    -1.638578
   col2     0.059866
   col3     0.493482
Name: 3, dtype: float64

Note - Parce que iterrows()itérer sur les lignes, cela ne conserve pas le type de données sur la ligne. 0,1,2 sont les indices de ligne et col1, col2, col3 sont les indices de colonne.

itertuples ()

La méthode itertuples () retournera un itérateur donnant un tuple nommé pour chaque ligne du DataFrame. Le premier élément du tuple sera la valeur d'index correspondante de la ligne, tandis que les valeurs restantes sont les valeurs de la ligne.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for row in df.itertuples():
    print row

Ses output est comme suit -

Pandas(Index=0, col1=1.5297586201375899, col2=0.76281127433814944, col3=-
0.6346908238310438)

Pandas(Index=1, col1=-0.94408735763808649, col2=1.4209186418359423, col3=-
0.50789517967096232)

Pandas(Index=2, col1=-0.07728664756791935, col2=-0.85855574139699076, col3=-
0.6633852507207626)

Pandas(Index=3, col1=0.65734942534106289, col2=-0.95057710432604969,
col3=0.80344487462316527)

Note- N'essayez pas de modifier un objet pendant l'itération. L'itération est destinée à la lecture et l'itérateur renvoie une copie de l'objet d'origine (une vue), ainsi les modifications ne seront pas reflétées sur l'objet d'origine.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])

for index, row in df.iterrows():
   row['a'] = 10
print df

Ses output est comme suit -

col1       col2       col3
0  -1.739815   0.735595  -0.295589
1   0.635485   0.106803   1.527922
2  -0.939064   0.547095   0.038585
3  -1.016509  -0.116580  -0.523158

Observez, aucun changement n'est reflété.

Il existe deux types de tri disponibles dans Pandas. Ils sont -

Par label
Par valeur réelle

Prenons un exemple avec une sortie.

import pandas as pd
import numpy as np

unsorted_df=pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
mns=['col2','col1'])
print unsorted_df

Ses output est comme suit -

col2       col1
1  -2.063177   0.537527
4   0.142932  -0.684884
6   0.012667  -0.389340
2  -0.548797   1.848743
3  -1.044160   0.837381
5   0.385605   1.300185
9   1.031425  -1.002967
8  -0.407374  -0.435142
0   2.237453  -1.067139
7  -1.445831  -1.701035

Dans unsorted_df, la labels et le valuesne sont pas triés. Voyons comment ils peuvent être triés.

Par étiquette

En utilisant le sort_index()méthode, en passant les arguments de l'axe et l'ordre de tri, DataFrame peut être trié. Par défaut, le tri est effectué sur les étiquettes de ligne dans l'ordre croissant.

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
   mns = ['col2','col1'])

sorted_df=unsorted_df.sort_index()
print sorted_df

Ses output est comme suit -

col2       col1
0   0.208464   0.627037
1   0.641004   0.331352
2  -0.038067  -0.464730
3  -0.638456  -0.021466
4   0.014646  -0.737438
5  -0.290761  -1.669827
6  -0.797303  -0.018737
7   0.525753   1.628921
8  -0.567031   0.775951
9   0.060724  -0.322425

Ordre de tri

En passant la valeur booléenne au paramètre croissant, l'ordre du tri peut être contrôlé. Prenons l'exemple suivant pour comprendre la même chose.

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
   mns = ['col2','col1'])

sorted_df = unsorted_df.sort_index(ascending=False)
print sorted_df

Ses output est comme suit -

col2        col1
9    0.825697    0.374463
8   -1.699509    0.510373
7   -0.581378    0.622958
6   -0.202951    0.954300
5   -1.289321   -1.551250
4    1.302561    0.851385
3   -0.157915   -0.388659
2   -1.222295    0.166609
1    0.584890   -0.291048
0    0.668444   -0.061294

Trier les colonnes

En passant l'argument axe avec une valeur 0 ou 1, le tri peut être effectué sur les étiquettes de colonne. Par défaut, axis = 0, triez par ligne. Prenons l'exemple suivant pour comprendre la même chose.

import pandas as pd
import numpy as np
 
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
   mns = ['col2','col1'])
 
sorted_df=unsorted_df.sort_index(axis=1)

print sorted_df

Ses output est comme suit -

col1        col2
1   -0.291048    0.584890
4    0.851385    1.302561
6    0.954300   -0.202951
2    0.166609   -1.222295
3   -0.388659   -0.157915
5   -1.551250   -1.289321
9    0.374463    0.825697
8    0.510373   -1.699509
0   -0.061294    0.668444
7    0.622958   -0.581378

Par valeur

Comme le tri par index, sort_values()est la méthode de tri par valeurs. Il accepte un argument «par» qui utilisera le nom de colonne du DataFrame avec lequel les valeurs doivent être triées.

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
   sorted_df = unsorted_df.sort_values(by='col1')

print sorted_df

Ses output est comme suit -

col1  col2
1    1    3
2    1    2
3    1    4
0    2    1

Observez, les valeurs col1 sont triées et la valeur col2 et l'index de ligne respectifs seront modifiés avec col1. Ainsi, ils ne semblent pas triés.

'by' L'argument prend une liste de valeurs de colonne.

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
   sorted_df = unsorted_df.sort_values(by=['col1','col2'])

print sorted_df

Ses output est comme suit -

Algorithme de tri

sort_values()fournit une disposition permettant de choisir l'algorithme parmi le tri par fusion, le tri en tas et le tri rapide. Mergesort est le seul algorithme stable.

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by='col1' ,kind='mergesort')

print sorted_df

Ses output est comme suit -

col1 col2
1    1    3
2    1    2
3    1    4
0    2    1

Dans ce chapitre, nous discuterons des opérations sur les chaînes avec notre série / index de base. Dans les chapitres suivants, nous apprendrons comment appliquer ces fonctions de chaîne sur le DataFrame.

Pandas fournit un ensemble de fonctions de chaîne qui facilitent l'utilisation des données de chaîne. Plus important encore, ces fonctions ignorent (ou excluent) les valeurs / NaN manquantes.

Presque toutes ces méthodes fonctionnent avec des fonctions de chaîne Python (voir: https://docs.python.org/3/library/stdtypes.html#string-methods). Donc, convertissez l'objet série en objet chaîne, puis effectuez l'opération.

Voyons maintenant comment chaque opération se déroule.

Sr.Non	Description de la fonction
1	lower() Convertit les chaînes de la série / index en minuscules.
2	upper() Convertit les chaînes de la série / de l'index en majuscules.
3	len() Calcule la longueur de la chaîne ().
4	strip() Aide à supprimer les espaces (y compris les sauts de ligne) de chaque chaîne de la série / index des deux côtés.
5	split(' ') Divise chaque chaîne avec le modèle donné.
6	cat(sep=' ') Concatène les éléments series / index avec un séparateur donné.
sept	get_dummies() Renvoie le DataFrame avec des valeurs One-Hot Encoded.
8	contains(pattern) Renvoie une valeur booléenne True pour chaque élément si la sous-chaîne contient dans l'élément, sinon False.
9	replace(a,b) Remplace la valeur a avec la valeur b.
dix	repeat(value) Répète chaque élément avec un nombre de fois spécifié.
11	count(pattern) Renvoie le nombre d'apparitions du motif dans chaque élément.
12	startswith(pattern) Renvoie true si l'élément de la série / de l'index commence par le modèle.
13	endswith(pattern) Renvoie true si l'élément de la série / de l'index se termine par le modèle.
14	find(pattern) Renvoie la première position de la première occurrence du modèle.
15	findall(pattern) Renvoie une liste de toutes les occurrences du modèle.
16	swapcase Permute le boîtier inférieur / supérieur.
17	islower() Vérifie si tous les caractères de chaque chaîne de la série / de l'index sont en minuscules ou non. Renvoie Boolean
18	isupper() Vérifie si tous les caractères de chaque chaîne de la série / de l'index sont en majuscules ou non. Renvoie Boolean.
19	isnumeric() Vérifie si tous les caractères de chaque chaîne de la série / de l'index sont numériques. Renvoie Boolean.

Créons maintenant une série et voyons comment fonctionnent toutes les fonctions ci-dessus.

import pandas as pd
import numpy as np

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])

print s

Ses output est comme suit -

0            Tom
1   William Rick
2           John
3        Alber@t
4            NaN
5           1234
6    Steve Smith
dtype: object

inférieur()

import pandas as pd
import numpy as np

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])

print s.str.lower()

Ses output est comme suit -

0            tom
1   william rick
2           john
3        alber@t
4            NaN
5           1234
6    steve smith
dtype: object

plus haut()

import pandas as pd
import numpy as np

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])

print s.str.upper()

Ses output est comme suit -

0            TOM
1   WILLIAM RICK
2           JOHN
3        ALBER@T
4            NaN
5           1234
6    STEVE SMITH
dtype: object

len ()

import pandas as pd
import numpy as np

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])
print s.str.len()

Ses output est comme suit -

0    3.0
1   12.0
2    4.0
3    7.0
4    NaN
5    4.0
6   10.0
dtype: float64

bande()

import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("After Stripping:")
print s.str.strip()

Ses output est comme suit -

0            Tom
1   William Rick
2           John
3        Alber@t
dtype: object

After Stripping:
0            Tom
1   William Rick
2           John
3        Alber@t
dtype: object

split (motif)

import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("Split Pattern:")
print s.str.split(' ')

Ses output est comme suit -

0            Tom
1   William Rick
2           John
3        Alber@t
dtype: object

Split Pattern:
0   [Tom, , , , , , , , , , ]
1   [, , , , , William, Rick]
2   [John]
3   [Alber@t]
dtype: object

chat (sep = motif)

import pandas as pd
import numpy as np

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.cat(sep='_')

Ses output est comme suit -

Tom _ William Rick_John_Alber@t

get_dummies ()

import pandas as pd
import numpy as np

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.get_dummies()

Ses output est comme suit -

William Rick   Alber@t   John   Tom
0             0         0      0     1
1             1         0      0     0
2             0         0      1     0
3             0         1      0     0

contient ()

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.contains(' ')

Ses output est comme suit -

0   True
1   True
2   False
3   False
dtype: bool

remplacer (a, b)

import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("After replacing @ with $:") print s.str.replace('@','$')

Ses output est comme suit -

0   Tom
1   William Rick
2   John
3   Alber@t
dtype: object

After replacing @ with $: 0 Tom 1 William Rick 2 John 3 Alber$t
dtype: object

répéter (valeur)

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.repeat(2)

Ses output est comme suit -

0   Tom            Tom
1   William Rick   William Rick
2                  JohnJohn
3                  Alber@tAlber@t
dtype: object

count (modèle)

import pandas as pd
 
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print ("The number of 'm's in each string:")
print s.str.count('m')

Ses output est comme suit -

The number of 'm's in each string:
0    1
1    1
2    0
3    0

commence avec (motif)

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print ("Strings that start with 'T':")
print s.str. startswith ('T')

Ses output est comme suit -

0  True
1  False
2  False
3  False
dtype: bool

se termine avec (motif)

import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print ("Strings that end with 't':")
print s.str.endswith('t')

Ses output est comme suit -

Strings that end with 't':
0  False
1  False
2  False
3  True
dtype: bool

trouver (motif)

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.find('e')

Ses output est comme suit -

0  -1
1  -1
2  -1
3   3
dtype: int64

"-1" indique qu'un tel modèle n'est pas disponible dans l'élément.

findall (modèle)

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.findall('e')

Ses output est comme suit -

0 []
1 []
2 []
3 [e]
dtype: object

La liste nulle ([]) indique qu'aucun modèle de ce type n'est disponible dans l'élément.

casier ()

import pandas as pd

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])
print s.str.swapcase()

Ses output est comme suit -

0  tOM
1  wILLIAM rICK
2  jOHN
3  aLBER@T
dtype: object

est plus bas()

import pandas as pd

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])
print s.str.islower()

Ses output est comme suit -

0  False
1  False
2  False
3  False
dtype: bool

isupper ()

import pandas as pd

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])

print s.str.isupper()

Ses output est comme suit -

0  False
1  False
2  False
3  False
dtype: bool

isnumérique ()

import pandas as pd

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])

print s.str.isnumeric()

Ses output est comme suit -

0  False
1  False
2  False
3  False
dtype: bool

Pandas fournit une API pour personnaliser certains aspects de son comportement, l'affichage est principalement utilisé.

L'API est composée de cinq fonctions pertinentes. Ils sont -

get_option()
set_option()
reset_option()
describe_option()
option_context()

Voyons maintenant comment fonctionnent les fonctions.

get_option (paramètre)

get_option prend un seul paramètre et renvoie la valeur donnée dans la sortie ci-dessous -

display.max_rows

Affiche le nombre de valeur par défaut. L'interpréteur lit cette valeur et affiche les lignes avec cette valeur comme limite supérieure à afficher.

import pandas as pd
print pd.get_option("display.max_rows")

Ses output est comme suit -

display.max_columns

Affiche le nombre de valeur par défaut. L'interpréteur lit cette valeur et affiche les lignes avec cette valeur comme limite supérieure à afficher.

import pandas as pd
print pd.get_option("display.max_columns")

Ses output est comme suit -

Ici, 60 et 20 sont les valeurs par défaut des paramètres de configuration.

set_option (paramètre, valeur)

set_option prend deux arguments et définit la valeur sur le paramètre comme indiqué ci-dessous -

display.max_rows

En utilisant set_option(), nous pouvons modifier le nombre de lignes par défaut à afficher.

import pandas as pd

pd.set_option("display.max_rows",80)

print pd.get_option("display.max_rows")

Ses output est comme suit -

display.max_columns

En utilisant set_option(), nous pouvons modifier le nombre de lignes par défaut à afficher.

import pandas as pd

pd.set_option("display.max_columns",30)

print pd.get_option("display.max_columns")

Ses output est comme suit -

reset_option (paramètre)

reset_option prend un argument et redéfinit la valeur sur la valeur par défaut.

display.max_rows

En utilisant reset_option (), nous pouvons remettre la valeur au nombre par défaut de lignes à afficher.

import pandas as pd

pd.reset_option("display.max_rows")
print pd.get_option("display.max_rows")

Ses output est comme suit -

describe_option (param)

describe_option imprime la description de l'argument.

display.max_rows

En utilisant reset_option (), nous pouvons remettre la valeur au nombre par défaut de lignes à afficher.

import pandas as pd
pd.describe_option("display.max_rows")

Ses output est comme suit -

display.max_rows : int
   If max_rows is exceeded, switch to truncate view. Depending on
   'large_repr', objects are either centrally truncated or printed as
   a summary view. 'None' value means unlimited.

   In case python/IPython is running in a terminal and `large_repr`
   equals 'truncate' this can be set to 0 and pandas will auto-detect
   the height of the terminal and print a truncated object which fits
   the screen height. The IPython notebook, IPython qtconsole, or
   IDLE do not run in a terminal and hence it is not possible to do
   correct auto-detection.
   [default: 60] [currently: 60]

option_context ()

Le gestionnaire de contexte option_context est utilisé pour définir l'option dans with statementtemporairement. Les valeurs des options sont restaurées automatiquement lorsque vous quittez lewith block -

display.max_rows

En utilisant option_context (), nous pouvons définir la valeur temporairement.

import pandas as pd
with pd.option_context("display.max_rows",10):
   print(pd.get_option("display.max_rows"))
   print(pd.get_option("display.max_rows"))

Ses output est comme suit -

10
10

Voyez, la différence entre la première et la deuxième instructions d'impression. La première instruction imprime la valeur définie paroption_context() qui est temporaire dans le with contextlui-même. Après lewith context, la deuxième instruction d'impression imprime la valeur configurée.

Paramètres fréquemment utilisés

Sr.Non	Paramètre et description
1	display.max_rows Affiche le nombre maximum de lignes à afficher
2	2 display.max_columns Affiche le nombre maximum de colonnes à afficher
3	display.expand_frame_repr Affiche les DataFrames pour étirer les pages
4	display.max_colwidth Affiche la largeur maximale de la colonne
5	display.precision Affiche la précision des nombres décimaux

Dans ce chapitre, nous allons discuter de la façon de découper et de découper la date et d'obtenir généralement le sous-ensemble d'objets pandas.

Les opérateurs d'indexation Python et NumPy "[]" et l'opérateur d'attribut "." fournissent un accès rapide et facile aux structures de données Pandas dans un large éventail de cas d'utilisation. Cependant, comme le type de données à accéder n'est pas connu à l'avance, l'utilisation directe d'opérateurs standard présente certaines limites d'optimisation. Pour le code de production, nous vous recommandons de tirer parti des méthodes optimisées d'accès aux données pandas expliquées dans ce chapitre.

Pandas prend désormais en charge trois types d'indexation multi-axes; les trois types sont mentionnés dans le tableau suivant -

Sr.Non	Indexation et description
1	.loc() Basé sur des étiquettes
2	.iloc() Basé sur un entier
3	.ix() Basé sur les étiquettes et les entiers

.loc ()

Les pandas fournissent diverses méthodes pour avoir purement label based indexing. Lors du découpage, la limite de départ est également incluse. Les nombres entiers sont des étiquettes valides, mais ils font référence à l'étiquette et non à la position.

.loc() a plusieurs méthodes d'accès comme -

Une seule étiquette scalaire
Une liste d'étiquettes
Un objet de tranche
Un tableau booléen

locprend deux opérateurs simples / liste / plage séparés par ','. Le premier indique la ligne et le second indique les colonnes.

Exemple 1

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

#select all rows for a specific column
print df.loc[:,'A']

Ses output est comme suit -

a   0.391548
b  -0.070649
c  -0.317212
d  -2.162406
e   2.202797
f   0.613709
g   1.050559
h   1.122680
Name: A, dtype: float64

Exemple 2

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

# Select all rows for multiple columns, say list[]
print df.loc[:,['A','C']]

Ses output est comme suit -

A           C
a    0.391548    0.745623
b   -0.070649    1.620406
c   -0.317212    1.448365
d   -2.162406   -0.873557
e    2.202797    0.528067
f    0.613709    0.286414
g    1.050559    0.216526
h    1.122680   -1.621420

Exemple 3

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

# Select few rows for multiple columns, say list[]
print df.loc[['a','b','f','h'],['A','C']]

Ses output est comme suit -

A          C
a   0.391548   0.745623
b  -0.070649   1.620406
f   0.613709   0.286414
h   1.122680  -1.621420

Exemple 4

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

# Select range of rows for all columns
print df.loc['a':'h']

Ses output est comme suit -

A           B          C          D
a    0.391548   -0.224297   0.745623   0.054301
b   -0.070649   -0.880130   1.620406   1.419743
c   -0.317212   -1.929698   1.448365   0.616899
d   -2.162406    0.614256  -0.873557   1.093958
e    2.202797   -2.315915   0.528067   0.612482
f    0.613709   -0.157674   0.286414  -0.500517
g    1.050559   -2.272099   0.216526   0.928449
h    1.122680    0.324368  -1.621420  -0.741470

Exemple 5

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

# for getting values with a boolean array
print df.loc['a']>0

Ses output est comme suit -

A  False
B  True
C  False
D  False
Name: a, dtype: bool

.iloc ()

Les pandas fournissent diverses méthodes afin d'obtenir une indexation basée uniquement sur des nombres entiers. Comme python et numpy, ce sont0-based indexage.

Les différentes méthodes d'accès sont les suivantes -

Un nombre entier
Une liste d'entiers
Une plage de valeurs

Exemple 1

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

# select all rows for a specific column
print df.iloc[:4]

Ses output est comme suit -

A          B           C           D
0   0.699435   0.256239   -1.270702   -0.645195
1  -0.685354   0.890791   -0.813012    0.631615
2  -0.783192  -0.531378    0.025070    0.230806
3   0.539042  -1.284314    0.826977   -0.026251

Exemple 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

# Integer slicing
print df.iloc[:4]
print df.iloc[1:5, 2:4]

Ses output est comme suit -

A          B           C           D
0   0.699435   0.256239   -1.270702   -0.645195
1  -0.685354   0.890791   -0.813012    0.631615
2  -0.783192  -0.531378    0.025070    0.230806
3   0.539042  -1.284314    0.826977   -0.026251

           C          D
1  -0.813012   0.631615
2   0.025070   0.230806
3   0.826977  -0.026251
4   1.423332   1.130568

Exemple 3

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

# Slicing through list of values
print df.iloc[[1, 3, 5], [1, 3]]
print df.iloc[1:3, :]
print df.iloc[:,1:3]

Ses output est comme suit -

B           D
1   0.890791    0.631615
3  -1.284314   -0.026251
5  -0.512888   -0.518930

           A           B           C           D
1  -0.685354    0.890791   -0.813012    0.631615
2  -0.783192   -0.531378    0.025070    0.230806

           B           C
0   0.256239   -1.270702
1   0.890791   -0.813012
2  -0.531378    0.025070
3  -1.284314    0.826977
4  -0.460729    1.423332
5  -0.512888    0.581409
6  -1.204853    0.098060
7  -0.947857    0.641358

.ix ()

Outre la base d'étiquettes et de nombres entiers purs, Pandas fournit une méthode hybride pour les sélections et le sous-ensemble de l'objet à l'aide de l'opérateur .ix ().

Exemple 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

# Integer slicing
print df.ix[:4]

Ses output est comme suit -

A          B           C           D
0   0.699435   0.256239   -1.270702   -0.645195
1  -0.685354   0.890791   -0.813012    0.631615
2  -0.783192  -0.531378    0.025070    0.230806
3   0.539042  -1.284314    0.826977   -0.026251

Exemple 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
# Index slicing
print df.ix[:,'A']

Ses output est comme suit -

0   0.699435
1  -0.685354
2  -0.783192
3   0.539042
4  -1.044209
5  -1.415411
6   1.062095
7   0.994204
Name: A, dtype: float64

Utilisation de notations

Obtenir des valeurs de l'objet Pandas avec l'indexation multi-axes utilise la notation suivante -

Objet	Indexeurs	Type de retour
Séries	s.loc [indexeur]	Valeur scalaire
Trame de données	df.loc [index_ligne, index_col]	Objet série
Panneau	p.loc [item_index, major_index, minor_index]	p.loc [item_index, major_index, minor_index]

Note − .iloc() & .ix() applique les mêmes options d'indexation et la même valeur de retour.

Voyons maintenant comment chaque opération peut être effectuée sur l'objet DataFrame. Nous utiliserons l'opérateur d'indexation de base '[]' -

Exemple 1

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
print df['A']

Ses output est comme suit -

0  -0.478893
1   0.391931
2   0.336825
3  -1.055102
4  -0.165218
5  -0.328641
6   0.567721
7  -0.759399
Name: A, dtype: float64

Note - Nous pouvons passer une liste de valeurs à [] pour sélectionner ces colonnes.

Exemple 2

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

print df[['A','B']]

Ses output est comme suit -

A           B
0  -0.478893   -0.606311
1   0.391931   -0.949025
2   0.336825    0.093717
3  -1.055102   -0.012944
4  -0.165218    1.550310
5  -0.328641   -0.226363
6   0.567721   -0.312585
7  -0.759399   -0.372696

Exemple 3

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
print df[2:2]

Ses output est comme suit -

Columns: [A, B, C, D]
Index: []

Accès aux attributs

Les colonnes peuvent être sélectionnées à l'aide de l'opérateur d'attribut «.».

Exemple

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

print df.A

Ses output est comme suit -

0   -0.478893
1    0.391931
2    0.336825
3   -1.055102
4   -0.165218
5   -0.328641
6    0.567721
7   -0.759399
Name: A, dtype: float64

Les méthodes statistiques aident à comprendre et à analyser le comportement des données. Nous allons maintenant apprendre quelques fonctions statistiques, que nous pouvons appliquer sur les objets Pandas.

Percent_change

Série, DatFrames et Panel, tous ont la fonction pct_change(). Cette fonction compare chaque élément avec son élément précédent et calcule le pourcentage de changement.

import pandas as pd
import numpy as np
s = pd.Series([1,2,3,4,5,4])
print s.pct_change()

df = pd.DataFrame(np.random.randn(5, 2))
print df.pct_change()

Ses output est comme suit -

0        NaN
1   1.000000
2   0.500000
3   0.333333
4   0.250000
5  -0.200000
dtype: float64

            0          1
0         NaN        NaN
1  -15.151902   0.174730
2  -0.746374   -1.449088
3  -3.582229   -3.165836
4   15.601150  -1.860434

Par défaut, le pct_change()fonctionne sur des colonnes; si vous souhaitez appliquer la même ligne par ligne, utilisezaxis=1() argument.

Covariance

La covariance est appliquée aux données de série. L'objet Series a une méthode cov pour calculer la covariance entre les objets série. NA sera automatiquement exclu.

Série Cov

import pandas as pd
import numpy as np
s1 = pd.Series(np.random.randn(10))
s2 = pd.Series(np.random.randn(10))
print s1.cov(s2)

Ses output est comme suit -

-0.12978405324

Méthode de covariance lorsqu'elle est appliquée à un DataFrame, calcule cov entre toutes les colonnes.

import pandas as pd
import numpy as np
frame = pd.DataFrame(np.random.randn(10, 5), columns=['a', 'b', 'c', 'd', 'e'])
print frame['a'].cov(frame['b'])
print frame.cov()

Ses output est comme suit -

-0.58312921152741437

           a           b           c           d            e
a   1.780628   -0.583129   -0.185575    0.003679    -0.136558
b  -0.583129    1.297011    0.136530   -0.523719     0.251064
c  -0.185575    0.136530    0.915227   -0.053881    -0.058926
d   0.003679   -0.523719   -0.053881    1.521426    -0.487694
e  -0.136558    0.251064   -0.058926   -0.487694     0.960761

Note - Observez le cov entre a et b colonne dans la première instruction et la même chose est la valeur retournée par cov sur DataFrame.

Corrélation

La corrélation montre la relation linéaire entre deux tableaux de valeurs (séries). Il existe plusieurs méthodes pour calculer la corrélation, comme pearson (par défaut), spearman et kendall.

import pandas as pd
import numpy as np
frame = pd.DataFrame(np.random.randn(10, 5), columns=['a', 'b', 'c', 'd', 'e'])

print frame['a'].corr(frame['b'])
print frame.corr()

Ses output est comme suit -

-0.383712785514

           a          b          c          d           e
a   1.000000  -0.383713  -0.145368   0.002235   -0.104405
b  -0.383713   1.000000   0.125311  -0.372821    0.224908
c  -0.145368   0.125311   1.000000  -0.045661   -0.062840
d   0.002235  -0.372821  -0.045661   1.000000   -0.403380
e  -0.104405   0.224908  -0.062840  -0.403380    1.000000

Si une colonne non numérique est présente dans le DataFrame, elle est automatiquement exclue.

Classement des données

Le classement des données produit un classement pour chaque élément du tableau d'éléments. En cas d'égalité, attribue le rang moyen.

import pandas as pd
import numpy as np

s = pd.Series(np.random.np.random.randn(5), index=list('abcde'))
s['d'] = s['b'] # so there's a tie
print s.rank()

Ses output est comme suit -

a  1.0
b  3.5
c  2.0
d  3.5
e  5.0
dtype: float64

Rank prend facultativement un paramètre croissant qui par défaut est vrai; lorsqu'il est faux, les données sont classées inversement, avec des valeurs plus élevées affectées à un rang plus petit.

Rank prend en charge différentes méthodes de départage, spécifiées avec le paramètre method -

average - rang moyen du groupe à égalité
min - rang le plus bas du groupe
max - rang le plus élevé du groupe
first - les rangs attribués dans l'ordre d'apparition dans le tableau

Pour travailler sur des données numériques, les pandas fournissent quelques variantes telles que les poids roulants, exponentiels et exponentiels pour les statistiques de fenêtre. Parmi ceux-ci sontsum, mean, median, variance, covariance, correlation, etc.

Nous allons maintenant apprendre comment chacun d'entre eux peut être appliqué sur des objets DataFrame.

Fonction .rolling ()

Cette fonction peut être appliquée à une série de données. Spécifie lewindow=n argument et appliquez la fonction statistique appropriée par-dessus.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df.rolling(window=3).mean()

Ses output est comme suit -

A           B           C           D
2000-01-01        NaN         NaN         NaN         NaN
2000-01-02        NaN         NaN         NaN         NaN
2000-01-03   0.434553   -0.667940   -1.051718   -0.826452
2000-01-04   0.628267   -0.047040   -0.287467   -0.161110
2000-01-05   0.398233    0.003517    0.099126   -0.405565
2000-01-06   0.641798    0.656184   -0.322728    0.428015
2000-01-07   0.188403    0.010913   -0.708645    0.160932
2000-01-08   0.188043   -0.253039   -0.818125   -0.108485
2000-01-09   0.682819   -0.606846   -0.178411   -0.404127
2000-01-10   0.688583    0.127786    0.513832   -1.067156

Note - Puisque la taille de la fenêtre est de 3, pour les deux premiers éléments il y a des valeurs nulles et à partir du troisième la valeur sera la moyenne des n, n-1 et n-2éléments. Ainsi, nous pouvons également appliquer diverses fonctions comme mentionné ci-dessus.

Fonction .expanding ()

Cette fonction peut être appliquée à une série de données. Spécifie lemin_periods=n argument et appliquez la fonction statistique appropriée par-dessus.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df.expanding(min_periods=3).mean()

Ses output est comme suit -

A           B           C           D
2000-01-01        NaN         NaN         NaN         NaN
2000-01-02        NaN         NaN         NaN         NaN
2000-01-03   0.434553   -0.667940   -1.051718   -0.826452
2000-01-04   0.743328   -0.198015   -0.852462   -0.262547
2000-01-05   0.614776   -0.205649   -0.583641   -0.303254
2000-01-06   0.538175   -0.005878   -0.687223   -0.199219
2000-01-07   0.505503   -0.108475   -0.790826   -0.081056
2000-01-08   0.454751   -0.223420   -0.671572   -0.230215
2000-01-09   0.586390   -0.206201   -0.517619   -0.267521
2000-01-10   0.560427   -0.037597   -0.399429   -0.376886

Fonction .ewm ()

ewmest appliqué sur une série de données. Spécifiez l'un des com, span,halflifeargument et appliquez la fonction statistique appropriée par-dessus. Il attribue les poids de manière exponentielle.

import pandas as pd
import numpy as np
 
df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df.ewm(com=0.5).mean()

Ses output est comme suit -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   0.865131   -0.453626   -1.137961    0.058747
2000-01-03  -0.132245   -0.807671   -0.308308   -1.491002
2000-01-04   1.084036    0.555444   -0.272119    0.480111
2000-01-05   0.425682    0.025511    0.239162   -0.153290
2000-01-06   0.245094    0.671373   -0.725025    0.163310
2000-01-07   0.288030   -0.259337   -1.183515    0.473191
2000-01-08   0.162317   -0.771884   -0.285564   -0.692001
2000-01-09   1.147156   -0.302900    0.380851   -0.607976
2000-01-10   0.600216    0.885614    0.569808   -1.110113

Les fonctions de fenêtre sont principalement utilisées pour trouver les tendances dans les données graphiquement en lissant la courbe. S'il y a beaucoup de variations dans les données quotidiennes et que beaucoup de points de données sont disponibles, alors le prélèvement d'échantillons et le traçage sont une méthode et l'application des calculs de fenêtre et le traçage du graphique sur les résultats est une autre méthode. Par ces méthodes, nous pouvons lisser la courbe ou la tendance.

Une fois le roulement, l'expansion et ewm des objets sont créés, plusieurs méthodes sont disponibles pour effectuer des agrégations sur les données.

Application d'agrégations sur DataFrame

Créons un DataFrame et appliquons-y des agrégations.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])

print df
r = df.rolling(window=3,min_periods=1)
print r

Ses output est comme suit -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   0.790670   -0.387854   -0.668132    0.267283
2000-01-03  -0.575523   -0.965025    0.060427   -2.179780
2000-01-04   1.669653    1.211759   -0.254695    1.429166
2000-01-05   0.100568   -0.236184    0.491646   -0.466081
2000-01-06   0.155172    0.992975   -1.205134    0.320958
2000-01-07   0.309468   -0.724053   -1.412446    0.627919
2000-01-08   0.099489   -1.028040    0.163206   -1.274331
2000-01-09   1.639500   -0.068443    0.714008   -0.565969
2000-01-10   0.326761    1.479841    0.664282   -1.361169

Rolling [window=3,min_periods=1,center=False,axis=0]

Nous pouvons agréger en passant une fonction à l'ensemble du DataFrame, ou sélectionner une colonne via le standard get item méthode.

Appliquer l'agrégation sur une trame de données entière

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r.aggregate(np.sum)

Ses output est comme suit -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469

                    A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469

Appliquer l'agrégation sur une seule colonne d'un Dataframe

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r['A'].aggregate(np.sum)

Ses output est comme suit -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469
2000-01-01   1.088512
2000-01-02   1.879182
2000-01-03   1.303660
2000-01-04   1.884801
2000-01-05   1.194699
2000-01-06   1.925393
2000-01-07   0.565208
2000-01-08   0.564129
2000-01-09   2.048458
2000-01-10   2.065750
Freq: D, Name: A, dtype: float64

Appliquer l'agrégation sur plusieurs colonnes d'un DataFrame

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r[['A','B']].aggregate(np.sum)

Ses output est comme suit -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469
                    A           B
2000-01-01   1.088512   -0.650942
2000-01-02   1.879182   -1.038796
2000-01-03   1.303660   -2.003821
2000-01-04   1.884801   -0.141119
2000-01-05   1.194699    0.010551
2000-01-06   1.925393    1.968551
2000-01-07   0.565208    0.032738
2000-01-08   0.564129   -0.759118
2000-01-09   2.048458   -1.820537
2000-01-10   2.065750    0.383357

Appliquer plusieurs fonctions sur une seule colonne d'un DataFrame

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r['A'].aggregate([np.sum,np.mean])

Ses output est comme suit -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469
                  sum       mean
2000-01-01   1.088512   1.088512
2000-01-02   1.879182   0.939591
2000-01-03   1.303660   0.434553
2000-01-04   1.884801   0.628267
2000-01-05   1.194699   0.398233
2000-01-06   1.925393   0.641798
2000-01-07   0.565208   0.188403
2000-01-08   0.564129   0.188043
2000-01-09   2.048458   0.682819
2000-01-10   2.065750   0.688583

Appliquer plusieurs fonctions sur plusieurs colonnes d'un DataFrame

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r[['A','B']].aggregate([np.sum,np.mean])

Ses output est comme suit -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469
                    A                      B
                  sum       mean         sum        mean
2000-01-01   1.088512   1.088512   -0.650942   -0.650942
2000-01-02   1.879182   0.939591   -1.038796   -0.519398
2000-01-03   1.303660   0.434553   -2.003821   -0.667940
2000-01-04   1.884801   0.628267   -0.141119   -0.047040
2000-01-05   1.194699   0.398233    0.010551    0.003517
2000-01-06   1.925393   0.641798    1.968551    0.656184
2000-01-07   0.565208   0.188403    0.032738    0.010913
2000-01-08   0.564129   0.188043   -0.759118   -0.253039
2000-01-09   2.048458   0.682819   -1.820537   -0.606846
2000-01-10   2.065750   0.688583    0.383357    0.127786

Appliquer différentes fonctions à différentes colonnes d'un Dataframe

import pandas as pd
import numpy as np
 
df = pd.DataFrame(np.random.randn(3, 4),
   index = pd.date_range('1/1/2000', periods=3),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r.aggregate({'A' : np.sum,'B' : np.mean})

Ses output est comme suit -

A          B          C         D
2000-01-01  -1.575749  -1.018105   0.317797  0.545081
2000-01-02  -0.164917  -1.361068   0.258240  1.113091
2000-01-03   1.258111   1.037941  -0.047487  0.867371
                    A          B
2000-01-01  -1.575749  -1.018105
2000-01-02  -1.740666  -1.189587
2000-01-03  -0.482555  -0.447078

Les données manquantes sont toujours un problème dans les scénarios de la vie réelle. Des domaines tels que l'apprentissage automatique et l'exploration de données sont confrontés à de graves problèmes de précision de leurs prédictions de modèle en raison de la mauvaise qualité des données due à des valeurs manquantes. Dans ces domaines, le traitement des valeurs manquantes est un objectif majeur pour rendre leurs modèles plus précis et valides.

Quand et pourquoi des données sont-elles manquées?

Prenons une enquête en ligne pour un produit. Souvent, les gens ne partagent pas toutes les informations les concernant. Peu de gens partagent leur expérience, mais pas depuis combien de temps ils utilisent le produit; peu de gens partagent la durée d'utilisation du produit, leur expérience mais pas leurs coordonnées. Ainsi, d'une manière ou d'une autre, une partie des données est toujours manquante, ce qui est très courant en temps réel.

Voyons maintenant comment nous pouvons gérer les valeurs manquantes (disons NA ou NaN) à l'aide de Pandas.

# import the pandas library
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df

Ses output est comme suit -

one        two      three
a   0.077988   0.476149   0.965836
b        NaN        NaN        NaN
c  -0.390208  -0.551605  -2.301950
d        NaN        NaN        NaN
e  -2.000303  -0.788201   1.510072
f  -0.930230  -0.670473   1.146615
g        NaN        NaN        NaN
h   0.085100   0.532791   0.887415

En utilisant la réindexation, nous avons créé un DataFrame avec des valeurs manquantes. Dans la sortie,NaN veux dire Not a Number.

Vérifier les valeurs manquantes

Pour faciliter la détection des valeurs manquantes (et pour différents types de baie), Pandas fournit le isnull() et notnull() fonctions, qui sont également des méthodes sur les objets Series et DataFrame -

Exemple 1

import pandas as pd
import numpy as np
 
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df['one'].isnull()

Ses output est comme suit -

a  False
b  True
c  False
d  True
e  False
f  False
g  True
h  False
Name: one, dtype: bool

Exemple 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df['one'].notnull()

Ses output est comme suit -

a  True
b  False
c  True
d  False
e  True
f  True
g  False
h  True
Name: one, dtype: bool

Calculs avec des données manquantes

Lors de la sommation des données, NA sera traité comme zéro
Si les données sont toutes NA, alors le résultat sera NA

Exemple 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df['one'].sum()

Ses output est comme suit -

2.02357685917

Exemple 2

import pandas as pd
import numpy as np

df = pd.DataFrame(index=[0,1,2,3,4,5],columns=['one','two'])
print df['one'].sum()

Ses output est comme suit -

nan

Nettoyage / remplissage des données manquantes

Pandas fournit diverses méthodes pour nettoyer les valeurs manquantes. La fonction fillna peut «remplir» les valeurs NA avec des données non nulles de plusieurs manières, que nous avons illustrées dans les sections suivantes.

Remplacez NaN par une valeur scalaire

Le programme suivant montre comment remplacer "NaN" par "0".

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(3, 3), index=['a', 'c', 'e'],columns=['one',
'two', 'three'])

df = df.reindex(['a', 'b', 'c'])

print df
print ("NaN replaced with '0':")
print df.fillna(0)

Ses output est comme suit -

one        two     three
a  -0.576991  -0.741695  0.553172
b        NaN        NaN       NaN
c   0.744328  -1.735166  1.749580

NaN replaced with '0':
         one        two     three
a  -0.576991  -0.741695  0.553172
b   0.000000   0.000000  0.000000
c   0.744328  -1.735166  1.749580

Ici, nous remplissons avec la valeur zéro; à la place, nous pouvons également remplir avec toute autre valeur.

Remplir NA en avant et en arrière

En utilisant les concepts de remplissage discutés dans le chapitre sur la réindexation, nous remplirons les valeurs manquantes.

Sr.Non	Méthode et action
1	pad/fill Méthodes de remplissage Suivant
2	bfill/backfill Méthodes de remplissage vers l'arrière

Exemple 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df.fillna(method='pad')

Ses output est comme suit -

one        two      three
a   0.077988   0.476149   0.965836
b   0.077988   0.476149   0.965836
c  -0.390208  -0.551605  -2.301950
d  -0.390208  -0.551605  -2.301950
e  -2.000303  -0.788201   1.510072
f  -0.930230  -0.670473   1.146615
g  -0.930230  -0.670473   1.146615
h   0.085100   0.532791   0.887415

Exemple 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df.fillna(method='backfill')

Ses output est comme suit -

one        two      three
a   0.077988   0.476149   0.965836
b  -0.390208  -0.551605  -2.301950
c  -0.390208  -0.551605  -2.301950
d  -2.000303  -0.788201   1.510072
e  -2.000303  -0.788201   1.510072
f  -0.930230  -0.670473   1.146615
g   0.085100   0.532791   0.887415
h   0.085100   0.532791   0.887415

Supprimer les valeurs manquantes

Si vous souhaitez simplement exclure les valeurs manquantes, utilisez le dropna fonction avec le axisargument. Par défaut, axis = 0, c'est-à-dire le long de la ligne, ce qui signifie que si une valeur dans une ligne est NA, alors la ligne entière est exclue.

Exemple 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.dropna()

Ses output est comme suit -

one        two      three
a   0.077988   0.476149   0.965836
c  -0.390208  -0.551605  -2.301950
e  -2.000303  -0.788201   1.510072
f  -0.930230  -0.670473   1.146615
h   0.085100   0.532791   0.887415

Exemple 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.dropna(axis=1)

Ses output est comme suit -

Empty DataFrame
Columns: [ ]
Index: [a, b, c, d, e, f, g, h]

Remplacer les valeurs génériques manquantes (ou)

Plusieurs fois, nous devons remplacer une valeur générique par une valeur spécifique. Nous pouvons y parvenir en appliquant la méthode replace.

Le remplacement de NA par une valeur scalaire est un comportement équivalent du fillna() fonction.

Exemple 1

import pandas as pd
import numpy as np

df = pd.DataFrame({'one':[10,20,30,40,50,2000], 'two':[1000,0,30,40,50,60]})

print df.replace({1000:10,2000:60})

Ses output est comme suit -

one  two
0   10   10
1   20    0
2   30   30
3   40   40
4   50   50
5   60   60

Exemple 2

import pandas as pd
import numpy as np

df = pd.DataFrame({'one':[10,20,30,40,50,2000], 'two':[1000,0,30,40,50,60]})
print df.replace({1000:10,2000:60})

Ses output est comme suit -

one  two
0   10   10
1   20    0
2   30   30
3   40   40
4   50   50
5   60   60

Tout groupbyl'opération implique l'une des opérations suivantes sur l'objet d'origine. Ils sont -

Splitting L'object
Applying une fonction
Combining Les resultats

Dans de nombreuses situations, nous divisons les données en ensembles et nous appliquons certaines fonctionnalités à chaque sous-ensemble. Dans la fonctionnalité d'application, nous pouvons effectuer les opérations suivantes -

Aggregation - calculer une statistique récapitulative
Transformation - effectuer une opération spécifique au groupe
Filtration - rejet des données avec certaines conditions

Créons maintenant un objet DataFrame et effectuons toutes les opérations dessus -

#import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df

Ses output est comme suit -

Points   Rank     Team   Year
0      876      1   Riders   2014
1      789      2   Riders   2015
2      863      2   Devils   2014
3      673      3   Devils   2015
4      741      3    Kings   2014
5      812      4    kings   2015
6      756      1    Kings   2016
7      788      1    Kings   2017
8      694      2   Riders   2016
9      701      4   Royals   2014
10     804      1   Royals   2015
11     690      2   Riders   2017

Diviser les données en groupes

L'objet Pandas peut être divisé en n'importe lequel de leurs objets. Il existe plusieurs façons de diviser un objet comme -

obj.groupby('key')
obj.groupby(['key1','key2'])
obj.groupby(key,axis=1)

Voyons maintenant comment les objets de regroupement peuvent être appliqués à l'objet DataFrame

Exemple

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df.groupby('Team')

Ses output est comme suit -

<pandas.core.groupby.DataFrameGroupBy object at 0x7fa46a977e50>

Afficher les groupes

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df.groupby('Team').groups

Ses output est comme suit -

{'Kings': Int64Index([4, 6, 7],      dtype='int64'),
'Devils': Int64Index([2, 3],         dtype='int64'),
'Riders': Int64Index([0, 1, 8, 11],  dtype='int64'),
'Royals': Int64Index([9, 10],        dtype='int64'),
'kings' : Int64Index([5],            dtype='int64')}

Exemple

Group by avec plusieurs colonnes -

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df.groupby(['Team','Year']).groups

Ses output est comme suit -

{('Kings', 2014): Int64Index([4], dtype='int64'),
 ('Royals', 2014): Int64Index([9], dtype='int64'),
 ('Riders', 2014): Int64Index([0], dtype='int64'),
 ('Riders', 2015): Int64Index([1], dtype='int64'),
 ('Kings', 2016): Int64Index([6], dtype='int64'),
 ('Riders', 2016): Int64Index([8], dtype='int64'),
 ('Riders', 2017): Int64Index([11], dtype='int64'),
 ('Devils', 2014): Int64Index([2], dtype='int64'),
 ('Devils', 2015): Int64Index([3], dtype='int64'),
 ('kings', 2015): Int64Index([5], dtype='int64'),
 ('Royals', 2015): Int64Index([10], dtype='int64'),
 ('Kings', 2017): Int64Index([7], dtype='int64')}

Itérer à travers les groupes

Avec le groupby objet en main, nous pouvons parcourir l'objet comme itertools.obj.

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Year')

for name,group in grouped:
   print name
   print group

Ses output est comme suit -

2014
   Points  Rank     Team   Year
0     876     1   Riders   2014
2     863     2   Devils   2014
4     741     3   Kings    2014
9     701     4   Royals   2014

2015
   Points  Rank     Team   Year
1     789     2   Riders   2015
3     673     3   Devils   2015
5     812     4    kings   2015
10    804     1   Royals   2015

2016
   Points  Rank     Team   Year
6     756     1    Kings   2016
8     694     2   Riders   2016

2017
   Points  Rank    Team   Year
7     788     1   Kings   2017
11    690     2  Riders   2017

Par défaut, le groupby l'objet a le même nom d'étiquette que le nom de groupe.

Sélectionnez un groupe

En utilisant le get_group() méthode, nous pouvons sélectionner un seul groupe.

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Year')
print grouped.get_group(2014)

Ses output est comme suit -

Points  Rank     Team    Year
0     876     1   Riders    2014
2     863     2   Devils    2014
4     741     3   Kings     2014
9     701     4   Royals    2014

Agrégations

Une fonction agrégée renvoie une seule valeur agrégée pour chaque groupe. Une fois lagroup by objet est créé, plusieurs opérations d'agrégation peuvent être effectuées sur les données groupées.

Une évidence est l'agrégation via l'agrégat ou équivalent agg méthode -

# import the pandas library
import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Year')
print grouped['Points'].agg(np.mean)

Ses output est comme suit -

Year
2014   795.25
2015   769.50
2016   725.00
2017   739.00
Name: Points, dtype: float64

Une autre façon de voir la taille de chaque groupe consiste à appliquer la fonction size () -

import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

Attribute Access in Python Pandas
grouped = df.groupby('Team')
print grouped.agg(np.size)

Ses output est comme suit -

Points   Rank   Year
Team
Devils        2      2      2
Kings         3      3      3
Riders        4      4      4
Royals        2      2      2
kings         1      1      1

Application de plusieurs fonctions d'agrégation à la fois

Avec les séries groupées, vous pouvez également passer un list ou dict of functions faire une agrégation avec, et générer DataFrame en sortie -

# import the pandas library
import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Team')
print grouped['Points'].agg([np.sum, np.mean, np.std])

Ses output est comme suit -

Team      sum      mean          std
Devils   1536   768.000000   134.350288
Kings    2285   761.666667    24.006943
Riders   3049   762.250000    88.567771
Royals   1505   752.500000    72.831998
kings     812   812.000000          NaN

Transformations

La transformation sur un groupe ou une colonne renvoie un objet indexé de la même taille que celui en cours de regroupement. Ainsi, la transformation doit renvoyer un résultat de la même taille que celui d'un bloc de groupe.

# import the pandas library
import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Team')
score = lambda x: (x - x.mean()) / x.std()*10
print grouped.transform(score)

Ses output est comme suit -

Points        Rank        Year
0   12.843272  -15.000000  -11.618950
1   3.020286     5.000000   -3.872983
2   7.071068    -7.071068   -7.071068
3  -7.071068     7.071068    7.071068
4  -8.608621    11.547005  -10.910895
5        NaN          NaN         NaN
6  -2.360428    -5.773503    2.182179
7  10.969049    -5.773503    8.728716
8  -7.705963     5.000000    3.872983
9  -7.071068     7.071068   -7.071068
10  7.071068    -7.071068    7.071068
11 -8.157595     5.000000   11.618950

Filtration

La filtration filtre les données sur un critère défini et renvoie le sous-ensemble de données. lefilter() La fonction est utilisée pour filtrer les données.

import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df.groupby('Team').filter(lambda x: len(x) >= 3)

Ses output est comme suit -

Points  Rank     Team   Year
0      876     1   Riders   2014
1      789     2   Riders   2015
4      741     3   Kings    2014
6      756     1   Kings    2016
7      788     1   Kings    2017
8      694     2   Riders   2016
11     690     2   Riders   2017

Dans la condition de filtre ci-dessus, nous demandons de renvoyer les équipes qui ont participé trois fois ou plus à l'IPL.

Pandas propose des opérations de jointure en mémoire hautes performances et complètes, idiomatiquement très similaires aux bases de données relationnelles telles que SQL.

Pandas fournit une seule fonction, merge, comme point d'entrée pour toutes les opérations de jointure de base de données standard entre les objets DataFrame -

pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
left_index=False, right_index=False, sort=True)

Ici, nous avons utilisé les paramètres suivants -

left - Un objet DataFrame.
right - Un autre objet DataFrame.
on- Colonnes (noms) à rejoindre. Doit être trouvé dans les objets DataFrame gauche et droit.
left_on- Colonnes du DataFrame gauche à utiliser comme clés. Il peut s'agir de noms de colonnes ou de tableaux de longueur égale à la longueur du DataFrame.
right_on- Colonnes du bon DataFrame à utiliser comme clés. Il peut s'agir de noms de colonnes ou de tableaux de longueur égale à la longueur du DataFrame.
left_index - Si True,utilisez l'index (étiquettes de ligne) du DataFrame gauche comme clé (s) de jointure. Dans le cas d'un DataFrame avec un MultiIndex (hiérarchique), le nombre de niveaux doit correspondre au nombre de clés de jointure du DataFrame droit.
right_index - Même usage que left_index pour le bon DataFrame.
how- Un parmi «gauche», «droite», «extérieur», «intérieur». La valeur par défaut est interne. Chaque méthode a été décrite ci-dessous.
sort- Trier le résultat DataFrame par les clés de jointure dans l'ordre lexicographique. La valeur par défaut est True, la définition sur False améliorera considérablement les performances dans de nombreux cas.

Créons maintenant deux DataFrames différents et effectuons les opérations de fusion dessus.

# import the pandas library
import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame(
   {'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print left
print right

Ses output est comme suit -

Name  id   subject_id
0   Alex   1         sub1
1    Amy   2         sub2
2  Allen   3         sub4
3  Alice   4         sub6
4  Ayoung  5         sub5

    Name  id   subject_id
0  Billy   1         sub2
1  Brian   2         sub4
2  Bran    3         sub3
3  Bryce   4         sub6
4  Betty   5         sub5

Fusionner deux DataFrames sur une clé

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
	'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left,right,on='id')

Ses output est comme suit -

Name_x   id  subject_id_x   Name_y   subject_id_y
0  Alex      1          sub1    Billy           sub2
1  Amy       2          sub2    Brian           sub4
2  Allen     3          sub4     Bran           sub3
3  Alice     4          sub6    Bryce           sub6
4  Ayoung    5          sub5    Betty           sub5

Fusionner deux DataFrames sur plusieurs clés

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
	'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left,right,on=['id','subject_id'])

Ses output est comme suit -

Name_x   id   subject_id   Name_y
0    Alice    4         sub6    Bryce
1   Ayoung    5         sub5    Betty

Fusionner en utilisant l'argument «comment»

le howL'argument à fusionner spécifie comment déterminer les clés à inclure dans la table résultante. Si aucune combinaison de touches n'apparaît dans les tables de gauche ou de droite, les valeurs de la table jointe seront NA.

Voici un résumé de la how options et leurs noms équivalents SQL -

Merge, méthode	Equivalent SQL	La description
la gauche	JOINTURE EXTERNE GAUCHE	Utiliser les clés de l'objet gauche
droite	JOINTURE EXTÉRIEURE DROITE	Utiliser les clés de l'objet droit
extérieur	JOINTURE EXTÉRIEURE COMPLÈTE	Utiliser l'union des clés
interne	JOINTURE INTERNE	Utiliser l'intersection des clés

Joint gauche

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='left')

Ses output est comme suit -

Name_x   id_x   subject_id   Name_y   id_y
0     Alex      1         sub1      NaN    NaN
1      Amy      2         sub2    Billy    1.0
2    Allen      3         sub4    Brian    2.0
3    Alice      4         sub6    Bryce    4.0
4   Ayoung      5         sub5    Betty    5.0

Jointure droite

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='right')

Ses output est comme suit -

Name_x  id_x   subject_id   Name_y   id_y
0      Amy   2.0         sub2    Billy      1
1    Allen   3.0         sub4    Brian      2
2    Alice   4.0         sub6    Bryce      4
3   Ayoung   5.0         sub5    Betty      5
4      NaN   NaN         sub3     Bran      3

Jointure externe

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, how='outer', on='subject_id')

Ses output est comme suit -

Name_x  id_x   subject_id   Name_y   id_y
0     Alex   1.0         sub1      NaN    NaN
1      Amy   2.0         sub2    Billy    1.0
2    Allen   3.0         sub4    Brian    2.0
3    Alice   4.0         sub6    Bryce    4.0
4   Ayoung   5.0         sub5    Betty    5.0
5      NaN   NaN         sub3     Bran    3.0

Jointure interne

L'inscription sera effectuée sur l'index. L'opération de jointure honore l'objet sur lequel elle est appelée. Alors,a.join(b) n'est pas égal à b.join(a).

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='inner')

Ses output est comme suit -

Name_x   id_x   subject_id   Name_y   id_y
0      Amy      2         sub2    Billy      1
1    Allen      3         sub4    Brian      2
2    Alice      4         sub6    Bryce      4
3   Ayoung      5         sub5    Betty      5

Pandas fournit diverses installations pour se combiner facilement Series, DataFrame, et Panel objets.

pd.concat(objs,axis=0,join='outer',join_axes=None,
ignore_index=False)

objs - Il s'agit d'une séquence ou d'un mappage d'objets Series, DataFrame ou Panel.
axis - {0, 1, ...}, par défaut 0. Il s'agit de l'axe à concaténer.
join- {'interne', 'externe'}, par défaut 'externe'. Comment gérer les index sur d'autres axes. Extérieur pour union et intérieur pour intersection.
ignore_index- booléen, False par défaut. Si True, n'utilisez pas les valeurs d'index sur l'axe de concaténation. L'axe résultant sera étiqueté 0, ..., n - 1.
join_axes- Ceci est la liste des objets Index. Index spécifiques à utiliser pour les autres (n-1) axes au lieu d'exécuter une logique d'ensemble interne / externe.

Concaténation d'objets

le concatfunction fait tout le gros du travail des opérations de concaténation le long d'un axe. Créons différents objets et faisons la concaténation.

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print pd.concat([one,two])

Ses output est comme suit -

Marks_scored     Name   subject_id
1             98     Alex         sub1
2             90      Amy         sub2
3             87    Allen         sub4
4             69    Alice         sub6
5             78   Ayoung         sub5
1             89    Billy         sub2
2             80    Brian         sub4
3             79     Bran         sub3
4             97    Bryce         sub6
5             88    Betty         sub5

Supposons que nous voulions associer des clés spécifiques à chacun des morceaux du DataFrame découpé. Nous pouvons le faire en utilisant lekeys argument -

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print pd.concat([one,two],keys=['x','y'])

Ses output est comme suit -

x  1  98    Alex    sub1
   2  90    Amy     sub2
   3  87    Allen   sub4
   4  69    Alice   sub6
   5  78    Ayoung  sub5
y  1  89    Billy   sub2
   2  80    Brian   sub4
   3  79    Bran    sub3
   4  97    Bryce   sub6
   5  88    Betty   sub5

L'index de la résultante est dupliqué; chaque index est répété.

Si l'objet résultant doit suivre sa propre indexation, définissez ignore_index à True.

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print pd.concat([one,two],keys=['x','y'],ignore_index=True)

Ses output est comme suit -

Marks_scored     Name    subject_id
0             98     Alex          sub1
1             90      Amy          sub2
2             87    Allen          sub4
3             69    Alice          sub6
4             78   Ayoung          sub5
5             89    Billy          sub2
6             80    Brian          sub4
7             79     Bran          sub3
8             97    Bryce          sub6
9             88    Betty          sub5

Observez, l'index change complètement et les clés sont également remplacées.

Si deux objets doivent être ajoutés axis=1, puis les nouvelles colonnes seront ajoutées.

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print pd.concat([one,two],axis=1)

Ses output est comme suit -

Marks_scored    Name  subject_id   Marks_scored    Name   subject_id
1           98      Alex      sub1         89         Billy         sub2
2           90       Amy      sub2         80         Brian         sub4
3           87     Allen      sub4         79          Bran         sub3
4           69     Alice      sub6         97         Bryce         sub6
5           78    Ayoung      sub5         88         Betty         sub5

Concaténation à l'aide d'ajout

Les méthodes d'instance append sur Series et DataFrame sont un raccourci utile pour concaténer. Ces méthodes étaient en fait antérieures à concat. Ils s'enchaînentaxis=0, à savoir l'indice -

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print one.append(two)

Ses output est comme suit -

Marks_scored    Name  subject_id
1           98      Alex      sub1
2           90       Amy      sub2
3           87     Allen      sub4
4           69     Alice      sub6
5           78    Ayoung      sub5
1           89     Billy      sub2
2           80     Brian      sub4
3           79      Bran      sub3
4           97     Bryce      sub6
5           88     Betty      sub5

le append la fonction peut également prendre plusieurs objets -

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print one.append([two,one,two])

Ses output est comme suit -

Marks_scored   Name    subject_id
1           98     Alex          sub1
2           90      Amy          sub2
3           87    Allen          sub4
4           69    Alice          sub6
5           78   Ayoung          sub5
1           89    Billy          sub2
2           80    Brian          sub4
3           79     Bran          sub3
4           97    Bryce          sub6
5           88    Betty          sub5
1           98     Alex          sub1
2           90      Amy          sub2
3           87    Allen          sub4
4           69    Alice          sub6
5           78   Ayoung          sub5
1           89    Billy          sub2
2           80    Brian          sub4
3           79     Bran          sub3
4           97    Bryce          sub6
5           88    Betty          sub5

Des séries chronologiques

Les pandas fournissent un outil robuste pour le temps de travail avec des données de séries chronologiques, en particulier dans le secteur financier. Lorsque nous travaillons avec des données de séries chronologiques, nous rencontrons fréquemment les éléments suivants:

Générer une séquence de temps
Convertir la série chronologique en différentes fréquences

Pandas fournit un ensemble d'outils relativement compact et autonome pour effectuer les tâches ci-dessus.

Obtenir l'heure actuelle

datetime.now() vous donne la date et l'heure actuelles.

import pandas as pd

print pd.datetime.now()

Ses output est comme suit -

2017-05-11 06:10:13.393147

Créer un horodatage

Les données horodatées sont le type le plus élémentaire de données chronologiques qui associent des valeurs à des points dans le temps. Pour les objets pandas, cela signifie utiliser les points dans le temps. Prenons un exemple -

import pandas as pd

print pd.Timestamp('2017-03-01')

Ses output est comme suit -

2017-03-01 00:00:00

Il est également possible de convertir des temps d'époque entiers ou flottants. L'unité par défaut pour ceux-ci est les nanosecondes (puisque c'est ainsi que les horodatages sont stockés). Cependant, les époques sont souvent stockées dans une autre unité qui peut être spécifiée. Prenons un autre exemple

import pandas as pd

print pd.Timestamp(1587687255,unit='s')

Ses output est comme suit -

2020-04-24 00:14:15

Créer une plage de temps

import pandas as pd

print pd.date_range("11:00", "13:30", freq="30min").time

Ses output est comme suit -

[datetime.time(11, 0) datetime.time(11, 30) datetime.time(12, 0)
datetime.time(12, 30) datetime.time(13, 0) datetime.time(13, 30)]

Changer la fréquence du temps

import pandas as pd

print pd.date_range("11:00", "13:30", freq="H").time

Ses output est comme suit -

[datetime.time(11, 0) datetime.time(12, 0) datetime.time(13, 0)]

Conversion en horodatages

Pour convertir une série ou un objet de type liste d'objets de type date, par exemple des chaînes, des époques ou un mélange, vous pouvez utiliser le to_datetimefonction. Une fois passé, cela renvoie une série (avec le même index), tandis qu'unlist-like est converti en DatetimeIndex. Jetez un œil à l'exemple suivant -

import pandas as pd

print pd.to_datetime(pd.Series(['Jul 31, 2009','2010-01-10', None]))

Ses output est comme suit -

0  2009-07-31
1  2010-01-10
2         NaT
dtype: datetime64[ns]

NaT veux dire Not a Time (équivalent à NaN)

Prenons un autre exemple.

import pandas as pd

print pd.to_datetime(['2005/11/23', '2010.12.31', None])

Ses output est comme suit -

DatetimeIndex(['2005-11-23', '2010-12-31', 'NaT'], dtype='datetime64[ns]', freq=None)

En élargissant les séries chronologiques, les fonctionnalités de date jouent un rôle majeur dans l'analyse des données financières. En travaillant avec des données de date, nous rencontrerons fréquemment les éléments suivants:

Générer une séquence de dates
Convertir la série de dates en différentes fréquences

Créer une plage de dates

En utilisant le date.range()fonction en spécifiant les périodes et la fréquence, nous pouvons créer la série de dates. Par défaut, la fréquence de la plage est de jours.

import pandas as pd

print pd.date_range('1/1/2011', periods=5)

Ses output est comme suit -

DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
   dtype='datetime64[ns]', freq='D')

Changer la fréquence de la date

import pandas as pd

print pd.date_range('1/1/2011', periods=5,freq='M')

Ses output est comme suit -

DatetimeIndex(['2011-01-31', '2011-02-28', '2011-03-31', '2011-04-30', '2011-05-31'],
   dtype='datetime64[ns]', freq='M')

bdate_range

bdate_range () représente les plages de dates commerciales. Contrairement à date_range (), il exclut le samedi et le dimanche.

import pandas as pd

print pd.date_range('1/1/2011', periods=5)

Ses output est comme suit -

DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
   dtype='datetime64[ns]', freq='D')

Observez, après le 3 mars, la date saute au 6 mars hors 4 et 5. Vérifiez simplement votre calendrier pour les jours.

Fonctions pratiques telles que date_range et bdate_rangeutilisent une variété d'alias de fréquence. La fréquence par défaut pour date_range est un jour calendaire tandis que la valeur par défaut pour bdate_range est un jour ouvrable.

import pandas as pd
start = pd.datetime(2011, 1, 1)
end = pd.datetime(2011, 1, 5)

print pd.date_range(start, end)

Ses output est comme suit -

DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
   dtype='datetime64[ns]', freq='D')

Alias de décalage

Un certain nombre d'alias de chaîne sont attribués à des fréquences de séries chronologiques communes utiles. Nous appellerons ces alias des alias décalés.

Alias	La description	Alias	La description
B	fréquence des jours ouvrables	BQS	fréquence de démarrage du trimestre d'affaires
ré	fréquence des jours civils	UNE	fréquence de fin annuelle (année)
W	fréquence hebdomadaire	BA	fréquence de fin d'exercice
M	fréquence de fin de mois	BAS	fréquence de début d'année commerciale
SM	fréquence de fin de semestre	BH	fréquence des heures ouvrables
BM	fréquence de fin de mois ouvrable	H	fréquence horaire
SP	fréquence de début du mois	T, min	fréquence minutieuse
SMS	Fréquence de début des SMS par semestre	S	deuxièmement, la fréquence
BMS	fréquence de début du mois ouvrable	L, ms	millisecondes
Q	fréquence de fin de trimestre	U, nous	microsecondes
BQ	fréquence de fin de trimestre	N	nanosecondes
QS	fréquence de début du trimestre

Les timedeltas sont des différences de temps, exprimées en unités de différence, par exemple, jours, heures, minutes, secondes. Ils peuvent être à la fois positifs et négatifs.

Nous pouvons créer des objets Timedelta en utilisant divers arguments comme indiqué ci-dessous -

Chaîne

En passant une chaîne littérale, nous pouvons créer un objet timedelta.

import pandas as pd

print pd.Timedelta('2 days 2 hours 15 minutes 30 seconds')

Ses output est comme suit -

2 days 02:15:30

Entier

En passant une valeur entière avec l'unité, un argument crée un objet Timedelta.

import pandas as pd

print pd.Timedelta(6,unit='h')

Ses output est comme suit -

0 days 06:00:00

Décalages de données

Les décalages de données tels que: semaines, jours, heures, minutes, secondes, millisecondes, microsecondes, nanosecondes peuvent également être utilisés dans la construction.

import pandas as pd

print pd.Timedelta(days=2)

Ses output est comme suit -

2 days 00:00:00

to_timedelta ()

Utilisation du niveau supérieur pd.to_timedelta, vous pouvez convertir un scalaire, un tableau, une liste ou une série d'un format / valeur timedelta reconnu en un type Timedelta. Il construira Series si l'entrée est une Series, un scalaire si l'entrée est de type scalaire, sinon produira unTimedeltaIndex.

import pandas as pd

print pd.Timedelta(days=2)

Ses output est comme suit -

2 days 00:00:00

Opérations

Vous pouvez opérer sur Series / DataFrames et construire timedelta64[ns] Série à travers des opérations de soustraction sur datetime64[ns] Série ou horodatage.

Créons maintenant un DataFrame avec des objets Timedelta et datetime et effectuons des opérations arithmétiques dessus -

import pandas as pd

s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))

print df

Ses output est comme suit -

A      B
0  2012-01-01 0 days
1  2012-01-02 1 days
2  2012-01-03 2 days

Opérations d'addition

import pandas as pd

s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))
df['C']=df['A']+df['B']

print df

Ses output est comme suit -

A      B          C
0 2012-01-01 0 days 2012-01-01
1 2012-01-02 1 days 2012-01-03
2 2012-01-03 2 days 2012-01-05

Opération de soustraction

import pandas as pd

s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))
df['C']=df['A']+df['B']
df['D']=df['C']+df['B']

print df

Ses output est comme suit -

A      B          C          D
0 2012-01-01 0 days 2012-01-01 2012-01-01
1 2012-01-02 1 days 2012-01-03 2012-01-04
2 2012-01-03 2 days 2012-01-05 2012-01-07

Souvent en temps réel, les données incluent les colonnes de texte, qui sont répétitives. Les fonctionnalités telles que le sexe, le pays et les codes sont toujours répétitives. Voici les exemples de données catégorielles.

Les variables catégorielles ne peuvent prendre qu'un nombre limité et généralement fixe de valeurs possibles. Outre la longueur fixe, les données catégorielles peuvent avoir un ordre mais ne peuvent pas effectuer d'opérations numériques. Les catégories sont un type de données Pandas.

Le type de données catégorielles est utile dans les cas suivants -

Variable chaîne constituée de quelques valeurs différentes seulement. La conversion d'une telle variable chaîne en une variable catégorielle économisera de la mémoire.
L'ordre lexical d'une variable n'est pas le même que l'ordre logique («un», «deux», «trois»). En convertissant en un catégoriel et en spécifiant un ordre sur les catégories, le tri et min / max utiliseront l'ordre logique au lieu de l'ordre lexical.
Pour signaler aux autres bibliothèques Python que cette colonne doit être traitée comme une variable catégorielle (par exemple pour utiliser des méthodes statistiques ou des types de tracé appropriés).

Création d'objets

Un objet catégoriel peut être créé de plusieurs manières. Les différentes manières ont été décrites ci-dessous -

Catégorie

En spécifiant le dtype comme "category" dans la création d'objets pandas.

import pandas as pd

s = pd.Series(["a","b","c","a"], dtype="category")
print s

Ses output est comme suit -

0  a
1  b
2  c
3  a
dtype: category
Categories (3, object): [a, b, c]

Le nombre d'éléments transmis à l'objet série est de quatre, mais les catégories ne sont que de trois. Observez la même chose dans les catégories de sortie.

pd.Catégorique

En utilisant le constructeur catégorique pandas standard, nous pouvons créer un objet de catégorie.

pandas.Categorical(values, categories, ordered)

Prenons un exemple -

import pandas as pd

cat = pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c'])
print cat

Ses output est comme suit -

[a, b, c, a, b, c]
Categories (3, object): [a, b, c]

Prenons un autre exemple -

import pandas as pd

cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'])
print cat

Ses output est comme suit -

[a, b, c, a, b, c, NaN]
Categories (3, object): [c, b, a]

Ici, le deuxième argument signifie les catégories. Ainsi, toute valeur qui n'est pas présente dans les catégories sera traitée commeNaN.

Maintenant, jetez un œil à l'exemple suivant -

import pandas as pd

cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'],ordered=True)
print cat

Ses output est comme suit -

[a, b, c, a, b, c, NaN]
Categories (3, object): [c < b < a]

Logiquement, la commande signifie que, a est supérieur à b et b est supérieur à c.

La description

En utilisant le .describe() commande sur les données catégorielles, nous obtenons une sortie similaire à un Series ou DataFrame du type chaîne.

import pandas as pd
import numpy as np

cat = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
df = pd.DataFrame({"cat":cat, "s":["a", "c", "c", np.nan]})

print df.describe()
print df["cat"].describe()

Ses output est comme suit -

cat s
count    3 3
unique   2 2
top      c c
freq     2 2
count     3
unique    2
top       c
freq      2
Name: cat, dtype: object

Obtenez les propriétés de la catégorie

obj.cat.categories commande est utilisée pour obtenir le categories of the object.

import pandas as pd
import numpy as np

s = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
print s.categories

Ses output est comme suit -

Index([u'b', u'a', u'c'], dtype='object')

obj.ordered La commande est utilisée pour obtenir l'ordre de l'objet.

import pandas as pd
import numpy as np

cat = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
print cat.ordered

Ses output est comme suit -

False

La fonction retournée false car nous n'avons spécifié aucune commande.

Renommer les catégories

Le changement de nom des catégories s'effectue en attribuant de nouvelles valeurs au series.cat.categoriespropriété series.cat.categories.

import pandas as pd

s = pd.Series(["a","b","c","a"], dtype="category")
s.cat.categories = ["Group %s" % g for g in s.cat.categories]
print s.cat.categories

Ses output est comme suit -

Index([u'Group a', u'Group b', u'Group c'], dtype='object')

Catégories initiales [a,b,c] sont mis à jour par le s.cat.categories propriété de l'objet.

Ajout de nouvelles catégories

En utilisant la méthode Categorical.add.categories (), de nouvelles catégories peuvent être ajoutées.

import pandas as pd

s = pd.Series(["a","b","c","a"], dtype="category")
s = s.cat.add_categories([4])
print s.cat.categories

Ses output est comme suit -

Index([u'a', u'b', u'c', 4], dtype='object')

Suppression de catégories

En utilisant le Categorical.remove_categories() méthode, les catégories indésirables peuvent être supprimées.

import pandas as pd

s = pd.Series(["a","b","c","a"], dtype="category")
print ("Original object:")
print s

print ("After removal:")
print s.cat.remove_categories("a")

Ses output est comme suit -

Original object:
0  a
1  b
2  c
3  a
dtype: category
Categories (3, object): [a, b, c]

After removal:
0  NaN
1  b
2  c
3  NaN
dtype: category
Categories (2, object): [b, c]

Comparaison des données catégoriques

La comparaison des données catégorielles avec d'autres objets est possible dans trois cas -

comparer l'égalité (== et! =) à un objet de type liste (liste, série, tableau, ...) de même longueur que les données catégorielles.
toutes les comparaisons (==,! =,>,> =, <et <=) de données catégorielles à une autre série catégorielle, lorsqu'elles sont ordonnées == True et les catégories sont les mêmes.
toutes les comparaisons d'une donnée catégorielle à un scalaire.

Jetez un œil à l'exemple suivant -

import pandas as pd

cat = pd.Series([1,2,3]).astype("category", categories=[1,2,3], ordered=True)
cat1 = pd.Series([2,2,2]).astype("category", categories=[1,2,3], ordered=True)

print cat>cat1

Ses output est comme suit -

0  False
1  False
2  True
dtype: bool

Tracé de base: tracé

Cette fonctionnalité sur Series et DataFrame n'est qu'un simple wrapper autour du matplotlib libraries plot() méthode.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10,4),index=pd.date_range('1/1/2000',
   periods=10), columns=list('ABCD'))

df.plot()

Ses output est comme suit -

Si l'index se compose de dates, il appelle gct().autofmt_xdate() pour formater l'axe des x comme indiqué dans l'illustration ci-dessus.

Nous pouvons tracer une colonne par rapport à une autre en utilisant le x et y mots clés.

Les méthodes de traçage autorisent une poignée de styles de tracé autres que le tracé linéaire par défaut. Ces méthodes peuvent être fournies comme argument de mot-clé kind pourplot(). Ceux-ci comprennent -

bar ou barh pour les parcelles à barres
hist pour l'histogramme
boîte pour boxplot
'zone' pour les parcelles de surface
'scatter' pour les nuages de points

Bar Plot

Voyons maintenant ce qu'est un Bar Plot en en créant un. Un graphique à barres peut être créé de la manière suivante -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.bar()

Ses output est comme suit -

Pour produire un graphique à barres empilées, pass stacked=True -

import pandas as pd
df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.bar(stacked=True)

Ses output est comme suit -

Pour obtenir des graphiques à barres horizontales, utilisez le barh méthode -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')

df.plot.barh(stacked=True)

Ses output est comme suit -

Histogrammes

Les histogrammes peuvent être tracés à l'aide de plot.hist()méthode. Nous pouvons spécifier le nombre de bacs.

import pandas as pd
import numpy as np

df = pd.DataFrame({'a':np.random.randn(1000)+1,'b':np.random.randn(1000),'c':
np.random.randn(1000) - 1}, columns=['a', 'b', 'c'])

df.plot.hist(bins=20)

Ses output est comme suit -

Pour tracer différents histogrammes pour chaque colonne, utilisez le code suivant -

import pandas as pd
import numpy as np

df=pd.DataFrame({'a':np.random.randn(1000)+1,'b':np.random.randn(1000),'c':
np.random.randn(1000) - 1}, columns=['a', 'b', 'c'])

df.diff.hist(bins=20)

Ses output est comme suit -

Boîtes à moustaches

Boxplot peut être dessiné appelant Series.box.plot() et DataFrame.box.plot(), ou DataFrame.boxplot() pour visualiser la distribution des valeurs dans chaque colonne.

Par exemple, voici un boxplot représentant cinq essais de 10 observations d'une variable aléatoire uniforme sur [0,1).

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(10, 5), columns=['A', 'B', 'C', 'D', 'E'])
df.plot.box()

Ses output est comme suit -

Tracé de zone

Le tracé de surface peut être créé à l'aide du Series.plot.area() ou la DataFrame.plot.area() méthodes.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.rand(10, 4), columns=['a', 'b', 'c', 'd'])
df.plot.area()

Ses output est comme suit -

Nuage de points

Le nuage de points peut être créé à l'aide du DataFrame.plot.scatter() méthodes.

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(50, 4), columns=['a', 'b', 'c', 'd'])
df.plot.scatter(x='a', y='b')

Ses output est comme suit -

Diagramme circulaire

Le graphique à secteurs peut être créé à l'aide du DataFrame.plot.pie() méthode.

import pandas as pd
import numpy as np

df = pd.DataFrame(3 * np.random.rand(4), index=['a', 'b', 'c', 'd'], columns=['x'])
df.plot.pie(subplots=True)

Ses output est comme suit -

le Pandas I/O API est un ensemble de fonctions de lecteur de haut niveau accessibles comme pd.read_csv() qui renvoient généralement un objet Pandas.

Les deux fonctions performantes de lecture des fichiers texte (ou des fichiers plats) sont read_csv() et read_table(). Ils utilisent tous les deux le même code d'analyse pour convertir intelligemment les données tabulaires en unDataFrame objet -

pandas.read_csv(filepath_or_buffer, sep=',', delimiter=None, header='infer',
names=None, index_col=None, usecols=None

pandas.read_csv(filepath_or_buffer, sep='\t', delimiter=None, header='infer',
names=None, index_col=None, usecols=None

Voici comment le csv les données du fichier ressemblent à -

S.No,Name,Age,City,Salary
1,Tom,28,Toronto,20000
2,Lee,32,HongKong,3000
3,Steven,43,Bay Area,8300
4,Ram,38,Hyderabad,3900

Enregistrez ces données sous temp.csv et mener des opérations dessus.

S.No,Name,Age,City,Salary
1,Tom,28,Toronto,20000
2,Lee,32,HongKong,3000
3,Steven,43,Bay Area,8300
4,Ram,38,Hyderabad,3900

Enregistrez ces données sous temp.csv et mener des opérations dessus.

read.csv

read.csv lit les données des fichiers csv et crée un objet DataFrame.

import pandas as pd

df=pd.read_csv("temp.csv")
print df

Ses output est comme suit -

S.No     Name   Age       City   Salary
0     1      Tom    28    Toronto    20000
1     2      Lee    32   HongKong     3000
2     3   Steven    43   Bay Area     8300
3     4      Ram    38  Hyderabad     3900

index personnalisé

Ceci spécifie une colonne dans le fichier csv pour personnaliser l'index à l'aide de index_col.

import pandas as pd

df=pd.read_csv("temp.csv",index_col=['S.No'])
print df

Ses output est comme suit -

S.No   Name   Age       City   Salary
1       Tom    28    Toronto    20000
2       Lee    32   HongKong     3000
3    Steven    43   Bay Area     8300
4       Ram    38  Hyderabad     3900

Convertisseurs

dtype des colonnes peuvent être passées comme dict.

import pandas as pd

df = pd.read_csv("temp.csv", dtype={'Salary': np.float64})
print df.dtypes

Ses output est comme suit -

S.No       int64
Name      object
Age        int64
City      object
Salary   float64
dtype: object

Par défaut, le dtype de la colonne Salaire est int, mais le résultat le montre comme float car nous avons explicitement casté le type.

Ainsi, les données ressemblent à float -

S.No   Name   Age      City    Salary
0   1     Tom   28    Toronto   20000.0
1   2     Lee   32   HongKong    3000.0
2   3  Steven   43   Bay Area    8300.0
3   4     Ram   38  Hyderabad    3900.0

header_names

Spécifiez les noms de l'en-tête à l'aide de l'argument names.

import pandas as pd
 
df=pd.read_csv("temp.csv", names=['a', 'b', 'c','d','e'])
print df

Ses output est comme suit -

a        b    c           d        e
0   S.No     Name   Age       City   Salary
1      1      Tom   28     Toronto    20000
2      2      Lee   32    HongKong     3000
3      3   Steven   43    Bay Area     8300
4      4      Ram   38   Hyderabad     3900

Remarquez que les noms d'en-tête sont ajoutés avec les noms personnalisés, mais l'en-tête du fichier n'a pas été supprimé. Maintenant, nous utilisons l'argument d'en-tête pour supprimer cela.

Si l'en-tête se trouve dans une ligne autre que la première, transmettez le numéro de ligne à l'en-tête. Cela sautera les lignes précédentes.

import pandas as pd 

df=pd.read_csv("temp.csv",names=['a','b','c','d','e'],header=0)
print df

Ses output est comme suit -

a        b    c           d        e
0  S.No     Name   Age       City   Salary
1     1      Tom   28     Toronto    20000
2     2      Lee   32    HongKong     3000
3     3   Steven   43    Bay Area     8300
4     4      Ram   38   Hyderabad     3900

skiprows

skiprows ignore le nombre de lignes spécifié.

import pandas as pd

df=pd.read_csv("temp.csv", skiprows=2)
print df

Ses output est comme suit -

2      Lee   32    HongKong   3000
0   3   Steven   43    Bay Area   8300
1   4      Ram   38   Hyderabad   3900

Les objets épars sont «compressés» lorsqu'une donnée correspondant à une valeur spécifique (NaN / valeur manquante, bien que n'importe quelle valeur puisse être choisie) est omise. Un objet SparseIndex spécial suit où les données ont été «sparsifiées». Cela aura beaucoup plus de sens dans un exemple. Toutes les structures de données Pandas standard appliquent leto_sparse méthode -

import pandas as pd
import numpy as np

ts = pd.Series(np.random.randn(10))
ts[2:-2] = np.nan
sts = ts.to_sparse()
print sts

Ses output est comme suit -

0   -0.810497
1   -1.419954
2         NaN
3         NaN
4         NaN
5         NaN
6         NaN
7         NaN
8    0.439240
9   -1.095910
dtype: float64
BlockIndex
Block locations: array([0, 8], dtype=int32)
Block lengths: array([2, 2], dtype=int32)

Les objets rares existent pour des raisons d'efficacité de la mémoire.

Supposons maintenant que vous ayez un grand NA DataFrame et exécutez le code suivant -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10000, 4))
df.ix[:9998] = np.nan
sdf = df.to_sparse()

print sdf.density

Ses output est comme suit -

0.0001

Tout objet épars peut être reconverti en forme dense standard en appelant to_dense -

import pandas as pd
import numpy as np
ts = pd.Series(np.random.randn(10))
ts[2:-2] = np.nan
sts = ts.to_sparse()
print sts.to_dense()

Ses output est comme suit -

0   -0.810497
1   -1.419954
2         NaN
3         NaN
4         NaN
5         NaN
6         NaN
7         NaN
8    0.439240
9   -1.095910
dtype: float64

Dtypes clairsemés

Les données éparses doivent avoir le même dtype que leur représentation dense. Actuellement,float64, int64 et booldtypessont pris en charge. Selon l'originaldtype, fill_value default changements -

float64 - np.nan
int64 - 0
bool - Faux

Exécutons le code suivant pour comprendre la même chose -

import pandas as pd
import numpy as np

s = pd.Series([1, np.nan, np.nan])
print s

s.to_sparse()
print s

Ses output est comme suit -

0   1.0
1   NaN
2   NaN
dtype: float64

0   1.0
1   NaN
2   NaN
dtype: float64

Les mises en garde signifie avertissement et gotcha signifie un problème invisible.

Utilisation de la déclaration If / Truth avec les pandas

Pandas suit la convention numpy de générer une erreur lorsque vous essayez de convertir quelque chose en bool. Cela se produit dans unif ou when en utilisant les opérations booléennes, et, or, ou not. On ne sait pas quel devrait être le résultat. Doit-il être vrai parce que ce n'est pas une longueur nulle? False parce qu'il y a des valeurs False? Ce n'est pas clair, donc à la place, Pandas soulève unValueError -

import pandas as pd

if pd.Series([False, True, False]):
   print 'I am True'

Ses output est comme suit -

ValueError: The truth value of a Series is ambiguous. 
Use a.empty, a.bool() a.item(),a.any() or a.all().

Dans ifcondition, on ne sait pas quoi en faire. L'erreur suggère s'il faut utiliser unNone ou any of those.

import pandas as pd

if pd.Series([False, True, False]).any():
   print("I am any")

Ses output est comme suit -

I am any

Pour évaluer des objets pandas à un seul élément dans un contexte booléen, utilisez la méthode .bool() -

import pandas as pd

print pd.Series([True]).bool()

Ses output est comme suit -

True

Booléen au niveau du bit

Opérateurs booléens au niveau du bit comme == et != retournera une série booléenne, ce qui est presque toujours ce qui est requis de toute façon.

import pandas as pd

s = pd.Series(range(5))
print s==4

Ses output est comme suit -

0 False
1 False
2 False
3 False
4 True
dtype: bool

isin Operation

Cela renvoie une série booléenne indiquant si chaque élément de la série est exactement contenu dans la séquence de valeurs transmise.

import pandas as pd

s = pd.Series(list('abc'))
s = s.isin(['a', 'c', 'e'])
print s

Ses output est comme suit -

0 True
1 False
2 True
dtype: bool

Réindexation vs ix Gotcha

De nombreux utilisateurs se retrouveront à utiliser le ix indexing capabilities comme moyen concis de sélectionner des données à partir d'un objet Pandas -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))

print df
print df.ix[['b', 'c', 'e']]

Ses output est comme suit -

one        two      three       four
a   -1.582025   1.335773   0.961417  -1.272084
b    1.461512   0.111372  -0.072225   0.553058
c   -1.240671   0.762185   1.511936  -0.630920
d   -2.380648  -0.029981   0.196489   0.531714
e    1.846746   0.148149   0.275398  -0.244559
f   -1.842662  -0.933195   2.303949   0.677641

          one        two      three       four
b    1.461512   0.111372  -0.072225   0.553058
c   -1.240671   0.762185   1.511936  -0.630920
e    1.846746   0.148149   0.275398  -0.244559

Ceci est bien entendu tout à fait équivalent dans ce cas à l'utilisation du reindex méthode -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))

print df
print df.reindex(['b', 'c', 'e'])

Ses output est comme suit -

one        two      three       four
a    1.639081   1.369838   0.261287  -1.662003
b   -0.173359   0.242447  -0.494384   0.346882
c   -0.106411   0.623568   0.282401  -0.916361
d   -1.078791  -0.612607  -0.897289  -1.146893
e    0.465215   1.552873  -1.841959   0.329404
f    0.966022  -0.190077   1.324247   0.678064

          one        two      three       four
b   -0.173359   0.242447  -0.494384   0.346882
c   -0.106411   0.623568   0.282401  -0.916361
e    0.465215   1.552873  -1.841959   0.329404

Certains pourraient conclure que ix et reindexsont 100% équivalents sur cette base. Ceci est vrai sauf dans le cas de l'indexation d'entiers. Par exemple, l'opération ci-dessus peut également être exprimée par -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))

print df
print df.ix[[1, 2, 4]]
print df.reindex([1, 2, 4])

Ses output est comme suit -

one        two      three       four
a   -1.015695  -0.553847   1.106235  -0.784460
b   -0.527398  -0.518198  -0.710546  -0.512036
c   -0.842803  -1.050374   0.787146   0.205147
d   -1.238016  -0.749554  -0.547470  -0.029045
e   -0.056788   1.063999  -0.767220   0.212476
f    1.139714   0.036159   0.201912   0.710119

          one        two      three       four
b   -0.527398  -0.518198  -0.710546  -0.512036
c   -0.842803  -1.050374   0.787146   0.205147
e   -0.056788   1.063999  -0.767220   0.212476

    one  two  three  four
1   NaN  NaN    NaN   NaN
2   NaN  NaN    NaN   NaN
4   NaN  NaN    NaN   NaN

Il est important de se rappeler que reindex is strict label indexing only. Cela peut conduire à des résultats potentiellement surprenants dans les cas pathologiques où un index contient, par exemple, des entiers et des chaînes.

Étant donné que de nombreux utilisateurs potentiels de Pandas ont une certaine familiarité avec SQL, cette page est destinée à fournir des exemples de la manière dont diverses opérations SQL peuvent être effectuées à l'aide de pandas.

import pandas as pd

url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'

tips=pd.read_csv(url)
print tips.head()

Ses output est comme suit -

total_bill   tip      sex  smoker  day     time  size
0        16.99  1.01   Female      No  Sun  Dinner      2
1        10.34  1.66     Male      No  Sun  Dinner      3
2        21.01  3.50     Male      No  Sun  Dinner      3
3        23.68  3.31     Male      No  Sun  Dinner      2
4        24.59  3.61   Female      No  Sun  Dinner      4

SÉLECTIONNER

En SQL, la sélection se fait à l'aide d'une liste de colonnes séparées par des virgules que vous sélectionnez (ou d'un * pour sélectionner toutes les colonnes) -

SELECT total_bill, tip, smoker, time
FROM tips
LIMIT 5;

Avec Pandas, la sélection des colonnes se fait en passant une liste de noms de colonnes à votre DataFrame -

tips[['total_bill', 'tip', 'smoker', 'time']].head(5)

Vérifions le programme complet -

import pandas as pd

url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'
 
tips=pd.read_csv(url)
print tips[['total_bill', 'tip', 'smoker', 'time']].head(5)

Ses output est comme suit -

total_bill   tip  smoker     time
0       16.99  1.01      No   Dinner
1       10.34  1.66      No   Dinner
2       21.01  3.50      No   Dinner
3       23.68  3.31      No   Dinner
4       24.59  3.61      No   Dinner

L'appel du DataFrame sans la liste des noms de colonne affichera toutes les colonnes (semblable à SQL *).

OÙ

Le filtrage en SQL se fait via une clause WHERE.

SELECT * FROM tips WHERE time = 'Dinner' LIMIT 5;

Les DataFrames peuvent être filtrés de plusieurs manières; le plus intuitif est l'utilisation de l'indexation booléenne.

tips[tips['time'] == 'Dinner'].head(5)

Vérifions le programme complet -

import pandas as pd

url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'

tips=pd.read_csv(url)
print tips[tips['time'] == 'Dinner'].head(5)

Ses output est comme suit -

total_bill   tip      sex  smoker  day    time  size
0       16.99  1.01   Female     No   Sun  Dinner    2
1       10.34  1.66     Male     No   Sun  Dinner    3
2       21.01  3.50     Male     No   Sun  Dinner    3
3       23.68  3.31     Male     No   Sun  Dinner    2
4       24.59  3.61   Female     No   Sun  Dinner    4

L'instruction ci-dessus transmet une série d'objets True / False au DataFrame, renvoyant toutes les lignes avec True.

Par groupe

Cette opération récupère le nombre d'enregistrements dans chaque groupe dans un ensemble de données. Par exemple, une requête nous récupérant le nombre de pourboires laissés par sexe -

SELECT sex, count(*)
FROM tips
GROUP BY sex;

L'équivalent Pandas serait -

tips.groupby('sex').size()

Vérifions le programme complet -

import pandas as pd

url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'

tips=pd.read_csv(url)
print tips.groupby('sex').size()

Ses output est comme suit -

sex
Female   87
Male    157
dtype: int64

N premières rangées

SQL renvoie le top n rows en utilisant LIMIT -

SELECT * FROM tips
LIMIT 5 ;

L'équivalent Pandas serait -

tips.head(5)

Vérifions l'exemple complet -

import pandas as pd

url = 'https://raw.github.com/pandas-dev/pandas/master/pandas/tests/data/tips.csv'

tips=pd.read_csv(url)
tips = tips[['smoker', 'day', 'time']].head(5)
print tips

Ses output est comme suit -

smoker   day     time
0      No   Sun   Dinner
1      No   Sun   Dinner
2      No   Sun   Dinner
3      No   Sun   Dinner
4      No   Sun   Dinner

Ce sont les quelques opérations de base que nous avons comparées, que nous avons apprises dans les chapitres précédents de la bibliothèque Pandas.