Creación de un marco de datos de pandas relleno de cero

¿Cuál es la mejor manera de crear un marco de datos de pandas lleno de ceros de un tamaño determinado?

He usado:

zero_data = np.zeros(shape=(len(data),len(feature_list)))
d = pd.DataFrame(zero_data, columns=feature_list)

Hay una mejor manera de hacerlo?

Puedes probar esto:

d = pd.DataFrame(0, index=np.arange(len(data)), columns=feature_list)

Es mejor hacer esto con numpy en mi opinión

import numpy as np
import pandas as pd
d = pd.DataFrame(np.zeros((N_rows, N_cols)))

Similar a @Shravan, pero sin el uso de numpy:

  height = 10
  width = 20
  df_0 = pd.DataFrame(0, index=range(height), columns=range(width))

Entonces puedes hacer lo que quieras con él:

post_instantiation_fcn = lambda x: str(x)
df_ready_for_whatever = df_0.applymap(post_instantiation_fcn)

Si desea que el nuevo marco de datos tenga el mismo índice y columnas que un marco de datos existente, puede simplemente multiplicar el marco de datos existente por cero:

df_zeros = df * 0

Si ya tiene un marco de datos, esta es la forma más rápida:

In [1]: columns = ["col{}".format(i) for i in range(10)]
In [2]: orig_df = pd.DataFrame(np.ones((10, 10)), columns=columns)
In [3]: %timeit d = pd.DataFrame(np.zeros_like(orig_df), index=orig_df.index, columns=orig_df.columns)
10000 loops, best of 3: 60.2 µs per loop

Comparar con:

In [4]: %timeit d = pd.DataFrame(0, index = np.arange(10), columns=columns)
10000 loops, best of 3: 110 µs per loop

In [5]: temp = np.zeros((10, 10))
In [6]: %timeit d = pd.DataFrame(temp, columns=columns)
10000 loops, best of 3: 95.7 µs per loop

Suponiendo que tenga una plantilla DataFrame, que le gustaría copiar con valores cero llenos aquí ...

Si no tiene NaN en su conjunto de datos, multiplicar por cero puede ser significativamente más rápido:

In [19]: columns = ["col{}".format(i) for i in xrange(3000)]                                                                                       

In [20]: indices = xrange(2000)

In [21]: orig_df = pd.DataFrame(42.0, index=indices, columns=columns)

In [22]: %timeit d = pd.DataFrame(np.zeros_like(orig_df), index=orig_df.index, columns=orig_df.columns)
100 loops, best of 3: 12.6 ms per loop

In [23]: %timeit d = orig_df * 0.0
100 loops, best of 3: 7.17 ms per loop

La mejora depende del tamaño de DataFrame, pero nunca lo encontré más lento.

Y solo por el gusto de hacerlo:

In [24]: %timeit d = orig_df * 0.0 + 1.0
100 loops, best of 3: 13.6 ms per loop

In [25]: %timeit d = pd.eval('orig_df * 0.0 + 1.0')
100 loops, best of 3: 8.36 ms per loop

Pero:

In [24]: %timeit d = orig_df.copy()
10 loops, best of 3: 24 ms per loop

¡¡¡EDITAR!!!

Suponiendo que tiene un marco que usa float64, ¡este será el más rápido por un gran margen! También puede generar cualquier valor reemplazando 0.0 por el número de llenado deseado.

In [23]: %timeit d = pd.eval('orig_df > 1.7976931348623157e+308 + 0.0')
100 loops, best of 3: 3.68 ms per loop

Dependiendo del gusto, uno puede definir externamente nan y hacer una solución general, independientemente del tipo de flotador particular:

In [39]: nan = np.nan
In [40]: %timeit d = pd.eval('orig_df > nan + 0.0')
100 loops, best of 3: 4.39 ms per loop