Je souhaite convertir un tableau, représenté sous forme de liste de listes, en un Pandas DataFrame. À titre d'exemple extrêmement simplifié:

a = [['a', '1.2', '4.2'], ['b', '70', '0.03'], ['x', '5', '0']]
df = pd.DataFrame(a)

Quelle est la meilleure façon de convertir les colonnes en types appropriés, dans ce cas les colonnes 2 et 3 en flottants? Existe-t-il un moyen de spécifier les types lors de la conversion en DataFrame? Ou est-il préférable de créer d'abord le DataFrame, puis de parcourir les colonnes pour changer le type de chaque colonne? Idéalement, je voudrais le faire de manière dynamique car il peut y avoir des centaines de colonnes et je ne veux pas spécifier exactement quelles colonnes sont de quel type. Tout ce que je peux garantir, c'est que chaque colonne contient des valeurs du même type.

Vous avez trois options principales pour convertir des types en pandas:

1. to_numeric()- fournit des fonctionnalités pour convertir en toute sécurité des types non numériques (par exemple des chaînes) en un type numérique approprié. (Voir aussi to_datetime()et to_timedelta().)

2. astype()- convertir (presque) tout type en (presque) tout autre type (même si cela n'est pas nécessairement judicieux). Vous permet également de convertir en types catégoriels (très utile).

3. infer_objects() - une méthode utilitaire pour convertir les colonnes d'objets contenant des objets Python en type pandas si possible.

Lisez la suite pour des explications plus détaillées et l'utilisation de chacune de ces méthodes.

1. to_numeric()

La meilleure façon de convertir une ou plusieurs colonnes d'un DataFrame en valeurs numériques est d'utiliser pandas.to_numeric().

Cette fonction essaiera de changer des objets non numériques (tels que des chaînes) en nombres entiers ou en virgule flottante, selon le cas.

Utilisation basique

L'entrée de to_numeric()est une série ou une seule colonne d'un DataFrame.

>>> s = pd.Series(["8", 6, "7.5", 3, "0.9"]) # mixed string and numeric values
>>> s
0      8
1      6
2    7.5
3      3
4    0.9
dtype: object

>>> pd.to_numeric(s) # convert everything to float values
0    8.0
1    6.0
2    7.5
3    3.0
4    0.9
dtype: float64

Comme vous pouvez le voir, une nouvelle série est retournée. N'oubliez pas d'affecter cette sortie à un nom de variable ou de colonne pour continuer à l'utiliser:

# convert Series
my_series = pd.to_numeric(my_series)

# convert column "a" of a DataFrame
df["a"] = pd.to_numeric(df["a"])

Vous pouvez également l'utiliser pour convertir plusieurs colonnes d'un DataFrame via la apply()méthode:

# convert all columns of DataFrame
df = df.apply(pd.to_numeric) # convert all columns of DataFrame

# convert just columns "a" and "b"
df[["a", "b"]] = df[["a", "b"]].apply(pd.to_numeric)

Tant que vos valeurs peuvent toutes être converties, c'est probablement tout ce dont vous avez besoin.

La gestion des erreurs

Mais que faire si certaines valeurs ne peuvent pas être converties en un type numérique?

to_numeric()prend également un errorsargument de mot clé qui vous permet de forcer les valeurs non numériques à être NaN, ou tout simplement ignorer les colonnes contenant ces valeurs.

Voici un exemple utilisant une série de chaînes squi a le type d'objet:

>>> s = pd.Series(['1', '2', '4.7', 'pandas', '10'])
>>> s
0         1
1         2
2       4.7
3    pandas
4        10
dtype: object

Le comportement par défaut consiste à augmenter s'il ne peut pas convertir une valeur. Dans ce cas, il ne peut pas faire face à la chaîne «pandas»:

>>> pd.to_numeric(s) # or pd.to_numeric(s, errors='raise')
ValueError: Unable to parse string

Plutôt que d'échouer, nous pourrions vouloir que «pandas» soit considéré comme une valeur numérique manquante / incorrecte. Nous pouvons contraindre les valeurs non valides NaNcomme suit à l'aide de l' errorsargument mot - clé:

>>> pd.to_numeric(s, errors='coerce')
0     1.0
1     2.0
2     4.7
3     NaN
4    10.0
dtype: float64

La troisième option pour errorsest simplement d'ignorer l'opération si une valeur non valide est rencontrée:

>>> pd.to_numeric(s, errors='ignore')
# the original Series is returned untouched

Cette dernière option est particulièrement utile lorsque vous souhaitez convertir l'intégralité de votre DataFrame, mais que vous ne savez pas laquelle de nos colonnes peut être convertie de manière fiable en un type numérique. Dans ce cas, écrivez simplement:

df.apply(pd.to_numeric, errors='ignore')

La fonction sera appliquée à chaque colonne du DataFrame. Les colonnes qui peuvent être converties en un type numérique seront converties, tandis que les colonnes qui ne peuvent pas (par exemple, elles contiennent des chaînes ou des dates non numériques) seront laissées seules.

Downcasting

Par défaut, la conversion avec to_numeric()vous donnera soit un int64oufloat64 dtype (ou quelle que soit la largeur entière native de votre plateforme).

C'est généralement ce que vous voulez, mais si vous vouliez économiser de la mémoire et utiliser un type plus compact, comme float32ouint8 ?

to_numeric()vous donne la possibilité de rétrograder en «entier», «signé», «non signé», «flottant». Voici un exemple pour une simple série sde type entier:

>>> s = pd.Series([1, 2, -7])
>>> s
0    1
1    2
2   -7
dtype: int64

La descente en «entier» utilise le plus petit entier possible pouvant contenir les valeurs:

>>> pd.to_numeric(s, downcast='integer')
0    1
1    2
2   -7
dtype: int8

La descente vers «flottant» choisit de la même manière un type flottant plus petit que la normale:

>>> pd.to_numeric(s, downcast='float')
0    1.0
1    2.0
2   -7.0
dtype: float32

2. astype()

le astype() méthode vous permet d'être explicite sur le dtype que vous voulez que votre DataFrame ou Series ait. Il est très polyvalent en ce sens que vous pouvez essayer de passer d'un type à l'autre.

Utilisation basique

Choisissez simplement un type: vous pouvez utiliser un type NumPy (par exemple np.int16 ), certains types Python (par exemple bool) ou des types spécifiques aux pandas (comme le type catégoriel).

Appelez la méthode sur l'objet que vous souhaitez convertir et astype()essayez de le convertir pour vous:

# convert all DataFrame columns to the int64 dtype
df = df.astype(int)

# convert column "a" to int64 dtype and "b" to complex type
df = df.astype({"a": int, "b": complex})

# convert Series to float16 type
s = s.astype(np.float16)

# convert Series to Python strings
s = s.astype(str)

# convert Series to categorical type - see docs for more details
s = s.astype('category')

Remarquez que j'ai dit "essayez" - si astype()ne sait pas comment convertir une valeur dans la série ou le DataFrame, cela soulèvera une erreur. Par exemple, si vous avez un NaNouinf valeur , vous obtiendrez une erreur en essayant de la convertir en entier.

Depuis pandas 0.20.0, cette erreur peut être supprimée en passant errors='ignore' . Votre objet d'origine sera retourné intact.

Faites attention

astype()est puissant, mais il convertit parfois des valeurs "incorrectement". Par exemple:

>>> s = pd.Series([1, 2, -7])
>>> s
0    1
1    2
2   -7
dtype: int64

Ce sont de petits entiers, alors que diriez-vous de convertir en un type 8 bits non signé pour économiser de la mémoire?

>>> s.astype(np.uint8)
0      1
1      2
2    249
dtype: uint8

La conversion a fonctionné, mais le -7 a été bouclé pour devenir 249 (soit 2 ⁸ - 7)!

Essayer de rétrograder à la pd.to_numeric(s, downcast='unsigned')place pourrait aider à éviter cette erreur.

3. infer_objects()

La version 0.21.0 de pandas a introduit la méthode infer_objects()de conversion des colonnes d'un DataFrame qui ont un type de données d'objet en un type plus spécifique (conversions logicielles).

Par exemple, voici un DataFrame avec deux colonnes de type d'objet. L'un contient des entiers réels et l'autre contient des chaînes représentant des entiers:

>>> df = pd.DataFrame({'a': [7, 1, 5], 'b': ['3','2','1']}, dtype='object')
>>> df.dtypes
a    object
b    object
dtype: object

En utilisant infer_objects(), vous pouvez changer le type de colonne 'a' en int64:

>>> df = df.infer_objects()
>>> df.dtypes
a     int64
b    object
dtype: object

La colonne 'b' a été laissée seule car ses valeurs étaient des chaînes, pas des entiers. Si vous souhaitez essayer de forcer la conversion des deux colonnes en un type entier, vous pouvez utiliser à la df.astype(int)place.

Que dis-tu de ça?

a = [['a', '1.2', '4.2'], ['b', '70', '0.03'], ['x', '5', '0']]
df = pd.DataFrame(a, columns=['one', 'two', 'three'])
df
Out[16]: 
  one  two three
0   a  1.2   4.2
1   b   70  0.03
2   x    5     0

df.dtypes
Out[17]: 
one      object
two      object
three    object

df[['two', 'three']] = df[['two', 'three']].astype(float)

df.dtypes
Out[19]: 
one       object
two      float64
three    float64

ce code ci-dessous changera le type de données de la colonne.

df[['col.name1', 'col.name2'...]] = df[['col.name1', 'col.name2'..]].astype('data_type')

au lieu du type de données, vous pouvez donner votre type de données. que voulez-vous comme str, float, int etc.

Lorsque je n'ai eu besoin que de spécifier des colonnes spécifiques et que je veux être explicite, j'ai utilisé (par DOCS LOCATION ):

dataframe = dataframe.astype({'col_name_1':'int','col_name_2':'float64', etc. ...})

Donc, en utilisant la question d'origine, mais en lui fournissant des noms de colonnes ...

a = [['a', '1.2', '4.2'], ['b', '70', '0.03'], ['x', '5', '0']]
df = pd.DataFrame(a, columns=['col_name_1', 'col_name_2', 'col_name_3'])
df = df.astype({'col_name_2':'float64', 'col_name_3':'float64'})

Voici une fonction qui prend comme arguments un DataFrame et une liste de colonnes et contraint toutes les données des colonnes à des nombres.

# df is the DataFrame, and column_list is a list of columns as strings (e.g ["col1","col2","col3"])
# dependencies: pandas

def coerce_df_columns_to_numeric(df, column_list):
    df[column_list] = df[column_list].apply(pd.to_numeric, errors='coerce')

Donc, pour votre exemple:

import pandas as pd

def coerce_df_columns_to_numeric(df, column_list):
    df[column_list] = df[column_list].apply(pd.to_numeric, errors='coerce')

a = [['a', '1.2', '4.2'], ['b', '70', '0.03'], ['x', '5', '0']]
df = pd.DataFrame(a, columns=['col1','col2','col3'])

coerce_df_columns_to_numeric(df, ['col2','col3'])

Que diriez-vous de créer deux cadres de données, chacun avec des types de données différents pour leurs colonnes, puis de les ajouter ensemble?

d1 = pd.DataFrame(columns=[ 'float_column' ], dtype=float)
d1 = d1.append(pd.DataFrame(columns=[ 'string_column' ], dtype=str))

Résultats

In[8}:  d1.dtypes
Out[8]: 
float_column     float64
string_column     object
dtype: object

Une fois la trame de données créée, vous pouvez la remplir avec des variables à virgule flottante dans la 1ère colonne et des chaînes (ou tout type de données souhaité) dans la 2ème colonne.

pandas> = 1.0

Voici un tableau qui résume certaines des conversions les plus importantes chez les pandas.

Les conversions en chaîne sont triviales .astype(str) et ne sont pas représentées sur la figure.

Conversions "dures" contre "douces"

Notez que les «conversions» dans ce contexte peuvent faire référence à la conversion de données texte en leur type de données réel (conversion matérielle) ou à l'inférence de types de données plus appropriés pour les données dans les colonnes d'objets (conversion logicielle). Pour illustrer la différence, jetez un œil à

df = pd.DataFrame({'a': ['1', '2', '3'], 'b': [4, 5, 6]}, dtype=object)
df.dtypes                                                                  

a    object
b    object
dtype: object

# Actually converts string to numeric - hard conversion
df.apply(pd.to_numeric).dtypes                                             

a    int64
b    int64
dtype: object

# Infers better data types for object data - soft conversion
df.infer_objects().dtypes                                                  

a    object  # no change
b     int64
dtype: object

# Same as infer_objects, but converts to equivalent ExtensionType
df.convert_dtypes().dtypes                                                     

Je pensais que j'avais le même problème mais en fait j'ai une légère différence qui rend le problème plus facile à résoudre. Pour ceux qui regardent cette question, il vaut la peine de vérifier le format de votre liste de saisie. Dans mon cas, les nombres sont initialement des flottants et non des chaînes comme dans la question:

a = [['a', 1.2, 4.2], ['b', 70, 0.03], ['x', 5, 0]]

mais en traitant trop la liste avant de créer la trame de données, je perds les types et tout devient une chaîne.

Création de la trame de données via un tableau numpy

df = pd.DataFrame(np.array(a))

df
Out[5]: 
   0    1     2
0  a  1.2   4.2
1  b   70  0.03
2  x    5     0

df[1].dtype
Out[7]: dtype('O')

donne le même bloc de données que dans la question, où les entrées dans les colonnes 1 et 2 sont considérées comme des chaînes. Cependant faire

df = pd.DataFrame(a)

df
Out[10]: 
   0     1     2
0  a   1.2  4.20
1  b  70.0  0.03
2  x   5.0  0.00

df[1].dtype
Out[11]: dtype('float64')

donne en fait un bloc de données avec les colonnes au format correct

À partir de pandas 1.0.0, nous l'avons pandas.DataFrame.convert_dtypes. Vous pouvez même contrôler quels types convertir!

In [40]: df = pd.DataFrame(
    ...:     {
    ...:         "a": pd.Series([1, 2, 3], dtype=np.dtype("int32")),
    ...:         "b": pd.Series(["x", "y", "z"], dtype=np.dtype("O")),
    ...:         "c": pd.Series([True, False, np.nan], dtype=np.dtype("O")),
    ...:         "d": pd.Series(["h", "i", np.nan], dtype=np.dtype("O")),
    ...:         "e": pd.Series([10, np.nan, 20], dtype=np.dtype("float")),
    ...:         "f": pd.Series([np.nan, 100.5, 200], dtype=np.dtype("float")),
    ...:     }
    ...: )

In [41]: dff = df.copy()

In [42]: df 
Out[42]: 
   a  b      c    d     e      f
0  1  x   True    h  10.0    NaN
1  2  y  False    i   NaN  100.5
2  3  z    NaN  NaN  20.0  200.0

In [43]: df.dtypes
Out[43]: 
a      int32
b     object
c     object
d     object
e    float64
f    float64
dtype: object

In [44]: df = df.convert_dtypes()

In [45]: df.dtypes
Out[45]: 
a      Int32
b     string
c    boolean
d     string
e      Int64
f    float64
dtype: object

In [46]: dff = dff.convert_dtypes(convert_boolean = False)

In [47]: dff.dtypes
Out[47]: 
a      Int32
b     string
c     object
d     string
e      Int64
f    float64
dtype: object