Quiero convertir una tabla, representada como una lista de listas, en a Pandas DataFrame. Como un ejemplo extremadamente simplificado:

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

¿Cuál es la mejor manera de convertir las columnas a los tipos apropiados, en este caso las columnas 2 y 3 en flotantes? ¿Hay alguna manera de especificar los tipos al convertir a DataFrame? ¿O es mejor crear el DataFrame primero y luego recorrer las columnas para cambiar el tipo de cada columna? Idealmente, me gustaría hacer esto de forma dinámica porque puede haber cientos de columnas y no quiero especificar exactamente qué columnas son de qué tipo. Todo lo que puedo garantizar es que cada columna contiene valores del mismo tipo.

Tiene tres opciones principales para convertir tipos en pandas:

1. to_numeric()- proporciona funcionalidad para convertir de forma segura tipos no numéricos (por ejemplo, cadenas) a un tipo numérico adecuado. (Ver también to_datetime()y to_timedelta().)

2. astype()- convierte (casi) cualquier tipo a (casi) cualquier otro tipo (incluso si no es necesariamente sensato hacerlo). También le permite convertir a tipos categoriales (muy útil).

3. infer_objects() - un método de utilidad para convertir columnas de objetos que contienen objetos de Python a un tipo de pandas si es posible.

Siga leyendo para obtener explicaciones más detalladas y el uso de cada uno de estos métodos.

1) to_numeric()

La mejor manera de convertir una o más columnas de un DataFrame en valores numéricos es usar pandas.to_numeric().

Esta función intentará cambiar objetos no numéricos (como cadenas) en números enteros o números de coma flotante, según corresponda.

Uso básico

La entrada a to_numeric()es una serie o una sola columna de 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

Como puede ver, se devuelve una nueva serie. Recuerde asignar esta salida a una variable o nombre de columna para continuar usándola:

# convert Series
my_series = pd.to_numeric(my_series)

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

También puede usarlo para convertir varias columnas de un DataFrame a través del apply()método:

# 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)

Siempre y cuando todos sus valores se puedan convertir, eso es probablemente todo lo que necesita.

Manejo de errores

Pero, ¿qué pasa si algunos valores no se pueden convertir a un tipo numérico?

to_numeric()también toma un errorsargumento de palabra clave que le permite forzar valores no numéricos NaN, o simplemente ignorar las columnas que contienen estos valores.

Aquí hay un ejemplo usando una serie de cadenas sque tiene el tipo de objeto dtype:

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

El comportamiento predeterminado es aumentar si no puede convertir un valor. En este caso, no puede hacer frente a la cadena 'pandas':

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

En lugar de fallar, podríamos querer que los pandas se consideren un valor numérico faltante / incorrecto. Podemos forzar valores no válidos de la NaNsiguiente manera usando el errorsargumento de la palabra clave:

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

La tercera opción errorses simplemente ignorar la operación si se encuentra un valor no válido:

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

Esta última opción es particularmente útil cuando desea convertir su DataFrame completo, pero no sabe cuál de nuestras columnas se puede convertir de manera confiable a un tipo numérico. En ese caso solo escribe:

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

La función se aplicará a cada columna del DataFrame. Las columnas que se pueden convertir a un tipo numérico se convertirán, mientras que las columnas que no se pueden (por ejemplo, que contienen cadenas o fechas sin dígitos) se dejarán solas.

Abatido

Por defecto, la conversión con to_numeric()le dará a int64o float64dtype (o cualquier ancho entero nativo de su plataforma).

Por lo general, eso es lo que desea, pero ¿qué sucede si desea ahorrar algo de memoria y usar un tipo de letra más compacto, como float32, o int8?

to_numeric()le da la opción de bajar a 'entero', 'firmado', 'sin signo', 'flotante'. Aquí hay un ejemplo para una serie simple sde tipo entero:

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

Downcasting a 'integer' usa el entero más pequeño posible que puede contener los valores:

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

Downcasting to 'float' también elige un tipo flotante más pequeño de lo normal:

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

2) astype()

El astype()método le permite ser explícito sobre el tipo de letra que desea que tenga su DataFrame o Series. Es muy versátil ya que puedes probar y pasar de un tipo a otro.

Uso básico

Simplemente elija un tipo: puede usar un tipo de letra NumPy (por ejemplo np.int16), algunos tipos de Python (por ejemplo, bool) o tipos específicos de pandas (como el tipo de letra categórico).

Llame al método en el objeto que desea convertir e astype()intentará convertirlo por usted:

# 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')

Observe que dije "probar": si astype()no sabe cómo convertir un valor en la Serie o el Marco de datos, generará un error. Por ejemplo, si tiene un valor NaNo infobtendrá un error al intentar convertirlo en un entero.

A partir de pandas 0.20.0, este error se puede suprimir al pasar errors='ignore'. Su objeto original será devuelto intacto.

Ten cuidado

astype()es poderoso, pero a veces convertirá valores "incorrectamente". Por ejemplo:

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

Estos son enteros pequeños, entonces, ¿qué tal si se convierte a un tipo de 8 bits sin signo para ahorrar memoria?

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

¡La conversión funcionó, pero el -7 se envolvió para convertirse en 249 (es decir, 2 ⁸ - 7)!

Intentar bajar el uso usando en su pd.to_numeric(s, downcast='unsigned')lugar podría ayudar a prevenir este error.

3) infer_objects()

La versión 0.21.0 de pandas introdujo el método infer_objects()para convertir columnas de un DataFrame que tienen un tipo de datos de objeto a un tipo más específico (conversiones suaves).

Por ejemplo, aquí hay un DataFrame con dos columnas de tipo de objeto. Uno contiene enteros reales y el otro contiene cadenas que representan enteros:

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

Utilizando infer_objects(), puede cambiar el tipo de columna 'a' a int64:

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

La columna 'b' se ha dejado sola ya que sus valores eran cadenas, no enteros. Si desea tratar de forzar la conversión de ambas columnas a un tipo entero, puede usar df.astype(int)en su lugar.

¿Qué tal esto?

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

El siguiente código cambiará el tipo de datos de la columna.

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

en lugar del tipo de datos, puede dar su tipo de datos. ¿Qué desea, como str, float, int, etc.

Cuando solo necesito especificar columnas específicas, y quiero ser explícito, he usado (por DOCS LOCATION ):

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

Entonces, usando la pregunta original, pero proporcionándole nombres de columna ...

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'})

Aquí hay una función que toma como argumentos un DataFrame y una lista de columnas y coacciona todos los datos de las columnas a números.

# 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')

Entonces, para su ejemplo:

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'])

¿Qué tal crear dos marcos de datos, cada uno con diferentes tipos de datos para sus columnas, y luego agregarlos juntos?

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

Resultados

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

Después de crear el marco de datos, puede rellenarlo con variables de punto flotante en la primera columna y cadenas (o cualquier tipo de datos que desee) en la segunda columna.

pandas> = 1.0

Aquí hay un cuadro que resume algunas de las conversiones más importantes en pandas.

Las conversiones a cadenas son triviales .astype(str)y no se muestran en la figura.

Conversiones "duras" versus "suaves"

Tenga en cuenta que las "conversiones" en este contexto podrían referirse a la conversión de datos de texto en su tipo de datos real (conversión de hardware) o inferir tipos de datos más apropiados para los datos en columnas de objeto (conversión de software). Para ilustrar la diferencia, eche un vistazo a

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                                                     

Pensé que tenía el mismo problema, pero en realidad tengo una ligera diferencia que hace que el problema sea más fácil de resolver. Para otros que miran esta pregunta, vale la pena verificar el formato de su lista de entrada. En mi caso, los números son inicialmente flotantes, no cadenas como en la pregunta:

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

pero al procesar la lista demasiado antes de crear el marco de datos, pierdo los tipos y todo se convierte en una cadena.

Crear el marco de datos a través de una matriz 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')

da el mismo marco de datos que en la pregunta, donde las entradas en las columnas 1 y 2 se consideran cadenas. Sin embargo haciendo

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')

en realidad da un marco de datos con las columnas en el formato correcto

A partir de pandas 1.0.0, tenemos pandas.DataFrame.convert_dtypes. ¡Incluso puedes controlar qué tipos 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