Creazione di un data frame panda a riempimento zero

Qual è il modo migliore per creare un data frame di panda a riempimento zero di una determinata dimensione?

Ho usato:

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

C'è un modo migliore per farlo?

Puoi provare questo:

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

È meglio farlo con numpy secondo me

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

Simile a @Shravan, ma senza l'uso di numpy:

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

Quindi puoi fare quello che vuoi con esso:

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

Se desideri che il nuovo data frame abbia lo stesso indice e le stesse colonne di un data frame esistente, puoi semplicemente moltiplicare il data frame esistente per zero:

df_zeros = df * 0

Se hai già un dataframe, questo è il modo più veloce:

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

Confrontare 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

Supponendo di avere un modello DataFrame, che si vorrebbe copiare con zero valori riempiti qui ...

Se non hai NaN nel tuo set di dati, la moltiplicazione per zero può essere notevolmente più veloce:

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

Il miglioramento dipende dalle dimensioni di DataFrame, ma non è mai stato trovato più lento.

E solo per il gusto di farlo:

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

Ma:

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

MODIFICARE!!!

Supponendo che tu abbia un frame che usa float64, questo sarà il più veloce con un enorme margine! È anche in grado di generare qualsiasi valore sostituendo 0,0 al numero di riempimento desiderato.

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

A seconda del gusto, si può definire esternamente nan e fare una soluzione generale, indipendentemente dal particolare tipo di galleggiante:

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