pandas.DataFrame, pandas.Series et le tableau NumPy numpy.ndarray peuvent être convertis les uns aux autres.
- Convertissez DataFrame, Series en ndarray :
values - Convertir ndarray en DataFrame, Series
- Remarques sur le partage de mémoire (afficher et copier)
- pandas 0.24.0 ou version ultérieure :
to_numpy()
Notez que pandas.DataFrame et pandas.Series ont également as_matrix() qui renvoie numpy.ndarray, mais il est obsolète depuis la version 0.23.0.
Consultez l’article suivant pour savoir comment convertir entre pandas.DataFrame, pandas.Series et la liste de types intégrée Python.
Convertissez DataFrame, Series en ndarray :values
pandas.DataFrame et pandas.Series ont tous deux un attribut de valeurs qui renvoie le tableau NumPy numpy.ndarray. Après pandas 0.24.0, il est recommandé d’utiliser la méthode to_numpy() introduite à la fin de cet article.
pandas.DataFrame :
import numpy as np
import pandas as pd
df = pd.DataFrame(data=[[1, 2, 3], [4, 5, 6]], columns=['a', 'b', 'c'])
print(df)
# a b c
# 0 1 2 3
# 1 4 5 6
a_df = df.values
print(a_df)
# [[1 2 3]
# [4 5 6]]
print(type(a_df))
# <class 'numpy.ndarray'>
print(a_df.dtype)
# int64
pandas.Série :
s = df['a']
print(s)
# 0 1
# 1 4
# Name: a, dtype: int64
a_s = s.values
print(a_s)
# [1 4]
print(type(a_s))
# <class 'numpy.ndarray'>
print(a_s.dtype)
# int64
Le type de données dtype de numpy.ndarray est le même que le dtype des pandas.DataFrame et pandas.Series d’origine.
df_f = pd.DataFrame([[0.1, 0.2, 0.3], [0.4, 0.5, 0.6]])
print(df_f)
# 0 1 2
# 0 0.1 0.2 0.3
# 1 0.4 0.5 0.6
a_df_f = df_f.values
print(a_df_f)
# [[0.1 0.2 0.3]
# [0.4 0.5 0.6]]
print(type(a_df_f))
# <class 'numpy.ndarray'>
print(a_df_f.dtype)
# float64
Pandas.DataFrame avec un mélange de nombres et de chaînes renvoie ndarray dont le dtype est object.
df_multi = pd.read_csv('data/src/sample_pandas_normal.csv')
print(df_multi)
# name age state point
# 0 Alice 24 NY 64
# 1 Bob 42 CA 92
# 2 Charlie 18 CA 70
# 3 Dave 68 TX 70
# 4 Ellen 24 CA 88
# 5 Frank 30 NY 57
a_df_multi = df_multi.values
print(a_df_multi)
# [['Alice' 24 'NY' 64]
# ['Bob' 42 'CA' 92]
# ['Charlie' 18 'CA' 70]
# ['Dave' 68 'TX' 70]
# ['Ellen' 24 'CA' 88]
# ['Frank' 30 'NY' 57]]
print(type(a_df_multi))
# <class 'numpy.ndarray'>
print(a_df_multi.dtype)
# object
Consultez l’article suivant pour plus d’informations sur le type d’objet de ndarray.
Si vous extrayez des colonnes et obtenez des valeurs, vous ne pouvez convertir que certaines colonnes en ndarray. Consultez l’article suivant pour savoir comment extraire des colonnes.
Si vous ne sélectionnez que des colonnes numériques, le type de ndarray sera ce type au lieu d’objet.
a_df_int = df_multi[['age', 'point']].values
print(a_df_int)
# [[24 64]
# [42 92]
# [18 70]
# [68 70]
# [24 88]
# [30 57]]
print(type(a_df_int))
# <class 'numpy.ndarray'>
print(a_df_int.dtype)
# int64
Si vous voulez transposer, utilisez T.
print(a_df_int.T)
# [[24 42 18 68 24 30]
# [64 92 70 70 88 57]]
Vous pouvez également extraire uniquement certains types de colonnes. Par exemple, si vous souhaitez extraire uniquement les colonnes int64, vous pouvez écrire :
a_df_int = df_multi.select_dtypes(include=int).values
print(a_df_int)
# [[24 64]
# [42 92]
# [18 70]
# [68 70]
# [24 88]
# [30 57]]
print(type(a_df_int))
# <class 'numpy.ndarray'>
print(a_df_int.dtype)
# int64
Consultez l’article suivant pour plus d’informations sur l’extraction de colonnes par dtype à l’aide de select_dtypes().
Vous pouvez également extraire des lignes/colonnes en fonction de leurs étiquettes. Voir l’article suivant.
Notez que le pandas.DataFrame d’origine et le convertnumpy.ndarray peuvent partager de la mémoire, et changer l’un peut changer l’autre. Il sera décrit plus tard.
Convertir ndarray en DataFrame, Series
Le tableau NumPy numpy.ndarray peut être spécifié comme première donnée d’argument des constructeurs pandas.DataFrame et pandas.Series. Comme décrit plus loin, numpy.ndarray et pandas.DataFrame généré, pandas.Series partagent la mémoire.
pandas.Series()
Si aucun autre argument n’est spécifié dans le constructeur, il s’agira d’une série du type ndarray d’origine.
import numpy as np
import pandas as pd
a = np.arange(4)
print(a)
# [0 1 2 3]
s = pd.Series(a)
print(s)
# 0 0
# 1 1
# 2 2
# 3 3
# dtype: int64
Vous pouvez spécifier l’index, le nom, le dtype, etc.
index = ['A', 'B', 'C', 'D']
name = 'sample'
s = pd.Series(data=a, index=index, name=name, dtype='float')
print(s)
# A 0.0
# B 1.0
# C 2.0
# D 3.0
# Name: sample, dtype: float64
Pour plus d’informations sur dtype dans les pandas, consultez l’article suivant.
La spécification d’un ndarray multidimensionnel en tant que données dans le constructeur Series entraîne une erreur.
a = np.arange(12).reshape((4, 3))
print(a)
# [[ 0 1 2]
# [ 3 4 5]
# [ 6 7 8]
# [ 9 10 11]]
# s = pd.Series(a)
# print(s)
# Exception: Data must be 1-dimensional
Il est possible de sélectionner des lignes ou des colonnes de ndarray bidimensionnel et de les convertir en séries.
s = pd.Series(a[2])
print(s)
# 0 6
# 1 7
# 2 8
# dtype: int64
s = pd.Series(a.T[2])
print(s)
# 0 2
# 1 5
# 2 8
# 3 11
# dtype: int64
pandas.DataFrame()
Comme avec Series, si vous ne spécifiez aucun autre argument dans le constructeur, vous obtenez un DataFrame du type ndarray d’origine.
a = np.arange(12).reshape((4, 3))
print(a)
# [[ 0 1 2]
# [ 3 4 5]
# [ 6 7 8]
# [ 9 10 11]]
df = pd.DataFrame(a)
print(df)
# 0 1 2
# 0 0 1 2
# 1 3 4 5
# 2 6 7 8
# 3 9 10 11
Vous pouvez spécifier l’index, les colonnes, le dtype, etc.
index = ['A', 'B', 'C', 'D']
columns = ['a', 'b', 'c']
df = pd.DataFrame(data=a, index=index, columns=columns, dtype='float')
print(df)
# a b c
# A 0.0 1.0 2.0
# B 3.0 4.0 5.0
# C 6.0 7.0 8.0
# D 9.0 10.0 11.0
Remarques sur le partage de mémoire (afficher et copier)
pandas.DataFrame ou pandas.Series et numpy.ndarray convertis l’un à l’autre par l’attribut de valeurs ou le constructeur peuvent partager la mémoire. Si la mémoire est partagée, la modification de l’une modifie l’autre. Soyez prudent si vous souhaitez les utiliser séparément.
L’exemple de code et les résultats suivants concernent pandas 0.25.1.
attribut de valeurs
Considérons d’abord le cas suivant.
df = pd.DataFrame(data=[[1, 2, 3], [4, 5, 6]], columns=['a', 'b', 'c'])
print(df)
# a b c
# 0 1 2 3
# 1 4 5 6
a_values = df.values
print(a_values)
# [[1 2 3]
# [4 5 6]]
valeurs renvoie une vue ; changer l’un change l’autre. Cela peut être vérifié avec np.shares_memory().
print(np.shares_memory(a_values, df))
# True
a_values[0, 0] = 100
print(a_values)
# [[100 2 3]
# [ 4 5 6]]
print(df)
# a b c
# 0 100 2 3
# 1 4 5 6
Il ne renvoie pas toujours une vue ; par exemple, si chaque colonne a un type de données différent dtype, une copie est renvoyée.
df_if = pd.DataFrame(data=[[1, 0.1], [2, 0.2]], columns=['int', 'float'])
print(df_if)
# int float
# 0 1 0.1
# 1 2 0.2
print(df_if.dtypes)
# int int64
# float float64
# dtype: object
a_values_if = df_if.values
print(a_values_if)
# [[1. 0.1]
# [2. 0.2]]
print(np.shares_memory(a_values_if, df_if))
# False
a_values_if[0, 0] = 100
print(a_values_if)
# [[100. 0.1]
# [ 2. 0.2]]
print(df_if)
# int float
# 0 1 0.1
# 1 2 0.2
De plus, lors de la sélection d’une plage, le retour de la vue ou de la copie dépend de la méthode de spécification.
print(df[['a', 'c']].values)
# [[100 3]
# [ 4 6]]
print(np.shares_memory(df[['a', 'c']].values, df))
# False
print(df.iloc[:, ::2].values)
# [[100 3]
# [ 4 6]]
print(np.shares_memory(df.iloc[:, ::2].values, df))
# True
Vous pouvez explicitement créer une copie avec copy() des valeurs.
a_values_copy = df.values.copy()
print(a_values_copy)
# [[100 2 3]
# [ 4 5 6]]
print(np.shares_memory(a_values_copy, df))
# False
a_values_copy[0, 0] = 10
print(a_values_copy)
# [[10 2 3]
# [ 4 5 6]]
print(df)
# a b c
# 0 100 2 3
# 1 4 5 6
pandas.DataFrame(), pandas.Series()
En passant numpy.ndarray au constructeur pandas.DataFrame() ou pandas.Series(), deux objets se partageront la mémoire. Changer une valeur change l’autre.
a = np.array([[1, 2, 3], [4, 5, 6]])
print(a)
# [[1 2 3]
# [4 5 6]]
df_a = pd.DataFrame(a, columns=['a', 'b', 'c'])
print(df_a)
# a b c
# 0 1 2 3
# 1 4 5 6
print(np.shares_memory(a, df_a))
# True
a[0, 0] = 100
print(a)
# [[100 2 3]
# [ 4 5 6]]
print(df_a)
# a b c
# 0 100 2 3
# 1 4 5 6
df_a.iat[1, 0] = 10
print(df_a)
# a b c
# 0 100 2 3
# 1 10 5 6
print(a)
# [[100 2 3]
# [ 10 5 6]]
Si vous ne voulez pas partager la mémoire, utilisez copy() de numpy.ndarray.
df_a_copy = pd.DataFrame(a.copy(), columns=['a', 'b', 'c'])
print(df_a_copy)
# a b c
# 0 100 2 3
# 1 10 5 6
a[0, 0] = 1
print(a)
# [[ 1 2 3]
# [10 5 6]]
print(df_a_copy)
# a b c
# 0 100 2 3
# 1 10 5 6
pandas 0.24.0 ou version ultérieure :to_numpy()
La méthode to_numpy() a été ajoutée à pandas.DataFrame et pandas.Series dans pandas 0.24.0. Cette méthode renvoie numpy.ndarray, similaire à l’attribut values ci-dessus.
La documentation officielle recommande d’utiliser la méthode to_numpy() au lieu de l’attribut values, mais depuis la version 0.25.1, l’utilisation de l’attribut values n’émet pas d’avertissement.
df = pd.DataFrame(data=[[1, 2, 3], [4, 5, 6]], columns=['a', 'b', 'c'])
print(df)
# a b c
# 0 1 2 3
# 1 4 5 6
a = df.to_numpy()
print(a)
# [[1 2 3]
# [4 5 6]]
print(type(a))
# <class 'numpy.ndarray'>
Par défaut, comme l’attribut values, il peut retourner une vue (numpy.ndarray qui partage la mémoire).
print(np.shares_memory(df, a))
# True
a[0, 0] = 100
print(a)
# [[100 2 3]
# [ 4 5 6]]
print(df)
# a b c
# 0 100 2 3
# 1 4 5 6
Définir la copie sur True renvoie une copie. La valeur par défaut est copy=False.
a_copy = df.to_numpy(copy=True)
print(a_copy)
# [[100 2 3]
# [ 4 5 6]]
print(np.shares_memory(df, a_copy))
# False
a_copy[0, 0] = 10
print(a_copy)
# [[10 2 3]
# [ 4 5 6]]
print(df)
# a b c
# 0 100 2 3
# 1 4 5 6
La valeur par défaut (copy=False) peut renvoyer une copie au lieu d’une vue. copy=True renvoie toujours une copie, mais copy=False ne renvoie pas toujours une vue.
Si l’attribut values renvoie une copie, to_numpy(copy=False) renvoie également une copie.
a_cols = df[['a', 'c']].to_numpy()
print(a_cols)
# [[100 3]
# [ 4 6]]
print(np.shares_memory(df, a_cols))
# False
Le type de données peut être spécifié avec le paramètre dtype. Une copie est également renvoyée si le type de données a changé.
a_f = df.to_numpy(dtype=float)
print(a_f)
# [[100. 2. 3.]
# [ 4. 5. 6.]]
print(np.shares_memory(df, a_f))
# False