Création de Dataframes

Création d'un dataframe :

un dataframe se comporte comme un dictionnaire dont les clefs sont les noms des colonnes et les valeurs sont des séries.

on peut le créer à partir d'une array numpy (mais ce n'est pas très pratique et le type des données est le même pour toutes les colonnes, ici float64) :

ar = numpy.array([[1.1, 2, 3.3, 4], [2.7, 10, 5.4, 7], [5.3, 9, 1.5, 15]])
df = pandas.DataFrame(ar, index = ['a1', 'a2', 'a3'], columns = ['A', 'B', 'C', 'D'])

donne :


      A   B    C   D
a1  1.1   2  3.3   4
a2  2.7  10  5.4   7
a3  5.3   9  1.5  15

attention : si on modifie l'array numpy, cela modifie aussi le dataframe.

on peut aussi créer le dataframe avec un dictionnaire :

df = pandas.DataFrame({'A': [1.1, 2.7, 5.3], 'B': [2, 10, 9], 'C': [3.3, 5.4, 1.5], 'D': [4, 7, 15]},
                      index = ['a1', 'a2', 'a3'])

donne :


      A   B    C   D
a1  1.1   2  3.3   4
a2  2.7  10  5.4   7
a3  5.3   9  1.5  15

Pour définir un dataframe avec les colonnes dans l'ordre que l'on veut : df = pandas.DataFrame({'A': [1.1, 2.7, 5.3], 'B': [2, 10, 9], 'C': [3.3, 5.4, 1.5], 'D': [4, 7, 15]}, columns = ['A', 'B', 'C', 'D'])

on peut aussi donner une liste de dictionnaires :

pandas.DataFrame([{'A': 1.1, 'B': 2, 'C': 3.3, 'D': 4},
    {'A': 2.7, 'B': 10, 'C': 5.4, 'D': 7},
    {'A': 5.3, 'B': 9, 'C': 1.5, 'D': 15}])

donne la même chose.

on peut aussi donner un dictionnaire dont les clefs seront les index plutôt que les colonnes :

pandas.DataFrame.from_dict({'A': [1.1, 2.7, 5.3], 'B': [2, 10, 9],
    'C': [3.3, 5.4, 1.5], 'D': [4, 7, 15]}, orient = 'index')

donne :


     0     1     2
A  1.1   2.7   5.3
C  3.3   5.4   1.5
B  2.0  10.0   9.0
D  4.0   7.0  15.0

un index ou les colonnes d'un dataframe peuvent avoir un nom :
- df.index.name = 'myIndexName' (si on imprime le frame dans un fichier csv avec l'index, la colonne sera nommée avec le nom de l'index).
- df.columns.name = 'myColumnName'
Autres initialisations de dataframes :
- df = pandas.DataFrame(columns = ['A', 'B']) : dataframe avec 0 lignes
- df = pandas.DataFrame(columns = ['A', 'B'], index = ['a', 'b']) : dataframe avec 2 lignes et que des NA
- df = pandas.DataFrame(0, index = [0, 1], columns = ['a', 'b']) : dataframe initialisé avec que des 0.
- df.fillna(0, inplace = True) : le remplit avec des 0 plutot que des NaN
- mais, attention ! : initialement, les types des colonnes sont "object" et une colonne peut avoir des valeurs de types héterogènes !
- pour éviter ça, on peut donner un type à la création : df = pandas.DataFrame(columns = ['A', 'B'], index = ['a', 'b'], dtype = float) (ou numpy.float64, ça revient au même)
on peut réindexer un dataframe pour changer l'ordre des lignes et/ou des colonnes, ou n'en récupérer que certaines : df.reindex(columns = ['C', 'B', 'A'], index = ['a2', 'a3'])
df.dtypes : les types des différentes colonnes du dataframe, ici :
```
A    float64
B      int64
C    float64
D      int64
    
```
détermination du type d'une colonne :
- df['myCol'].dtype : donne le type
- pandas.api.types.is_numeric_dtype(df[col].dtype) : renvoie True uniquement si le type est numérique.
- pandas.api.types.is_string_dtype(df[col].dtype) : renvoie True uniquement si le type est une chaîne de caractères.
si les series ont des index, le dataframe utilise ces index pour construire le dataframe : df = pandas.DataFrame({'col1': pandas.Series([2, 3, 4], index = ['a', 'b', 'c']), 'col2': pandas.Series([6, 7, 8], index = ['b', 'a', 'd'])}) donne :
```
   col1  col2
a     2     7
b     3     6
c     4   NaN
d   NaN     8
    
```
On peut mettre une seule valeur pour une colonne dans la définition d'un dataframe : df = pandas.DataFrame({'a': 1, 'b': [2, 3, 4], 'c': [5, 6, 7]})
df.info() : imprime des infos sur le dataframe : les noms et types des colonnes, le nombre de valeurs non nulles et la place occupée.
df.head(2) : renvoie un dataframe avec les 2 premières lignes. Idem avec df.tail(2) pour les deux dernières.
df.head(), df.tail() : les 5 premières ou les 5 dernières.
df.columns : les noms des colonnes, par exemple Index(['A', 'B', 'C', 'D'], dtype='object').
df.columns.values : le nom des colonnes sous forme d'array numpy.
df.index : les noms des lignes (individus), par exemple Index(['a1', 'a2', 'a3'], dtype='object').
df.index.values : le nom des lignes sous forme d'array numpy.
df.values : pour récupérer le dataframe sous forme d'array numpy 2d.

df.describe() : renvoie un dataframe donnant des statistiques sur les valeurs (nombres de valeurs, moyenne, écart-type, ...), mais uniquement sur les colonnes numériques (faire df.describe(include = 'all') pour avoir toutes les colonnes) :


              A          B         C          D
count  3.000000   3.000000  3.000000   3.000000
mean   3.033333   7.000000  3.400000   8.666667
std    2.119748   4.358899  1.951922   5.686241
min    1.100000   2.000000  1.500000   4.000000
25%    1.900000   5.500000  2.400000   5.500000
50%    2.700000   9.000000  3.300000   7.000000
75%    4.000000   9.500000  4.350000  11.000000
max    5.300000  10.000000  5.400000  15.000000

df.describe(include = 'all').to_csv(sys.stdout, sep = '\t') : permet d'imprimer les stats sur toutes les colonnes (numériques ou non).
on peut régler la largeur d'impression quand on imprime un dataframe avec : pandas.set_option('display.width', 120)
on peut lire et modifier le nombre de ligne affichées :
- pandas.get_option('display.max_rows')
- pandas.set_option('display.max_rows', None) : pas de maximu,m.

Dimension d'un dataframe :

df.shape : renvoie la dimension du dataframe sous forme (nombre de lignes, nombre de colonnes)
on peut aussi faire len(df) pour avoir le nombre de lignes (ou également len(df.index)).
on peut aussi faire len(df.columns) pour avoir le nombre de colonnes.
df.memory_usage() : donne une série avec la place occupeée par chaque colonne (sum(df.memory_usage()) donne la mémoire totale occupée).

Un dataframe peut avoir un nom pour son index de ligne et son index de colonnes :

df.index.name = 'myRow'; df.columns.name = 'myCol'
ce nom sera utilisé comme nom de colonne si on fait df.stack().reset_index()

On peut réaligner 2 dataframes entre eux :

df1.align(df2) : renvoie un tuple de 2 dataframes réalignés, avec par défaut, une jointure externe sur les colonnes et les lignes (index) : ils contiennent la réunion des colonnes et la réunion des lignes, dans le même ordre.
df1.align(df2, join = 'inner') : les colonnes et les index communs.
il y a aussi la possibilité de faire des jointures externes gauche ou droite avec join = 'left' ou join = 'right'
on peut faire l'alignement que sur les lignes avec df1.align(df2, axis = 0) (idem pour les colonnes avec axis = 1).

un dataframe peut avoir 0 colonne, par exemple df0 = pandas.DataFrame({}, index = ['a', 'b', 'c'])

Quand on a un dataframe avec une seule colonne ou une seule ligne, on peut le transformer en series par : df.squeeze() (ne fait rien sur une series ou sur un dataframe avec plusieurs colonnes)

df.memory_usage() : la place mémoire occupée par chaque colonne.

programmer en python, tutoriel python, graphes en python, Aymeric Duclert