web-dev-qa-db-fra.com

Création d'un bloc de données pandas rempli de zéros

Quel est le meilleur moyen de créer un bloc de données pandas rempli de zéros d'une taille donnée?

J'ai utilisé:

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

Y a-t-il une meilleure façon de le faire?

pythonpandasdataframe
69
niedakh

Vous pouvez essayer ceci:

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

C'est mieux de le faire avec numpy à mon avis

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

Similaire à @Shravan, mais sans utiliser numpy:

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

Ensuite, vous pouvez faire ce que vous voulez avec:

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

Si vous souhaitez que le nouveau cadre de données ait le même index et les mêmes colonnes qu'un cadre de données existant, vous pouvez simplement multiplier le cadre de données existant par zéro:

df_zeros = df * 0
2
chakuRak

Si vous avez déjà un cadre de données, c'est le moyen le plus rapide:

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

Comparer aux:

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
1
mtd

En supposant qu’il existe un modèle DataFrame, que l’on voudrait copier avec zéro valeur renseignée ici ...

Si vous n'avez pas de NaN dans votre ensemble de données, multiplier par zéro peut être beaucoup plus rapide:

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

L'amélioration dépend de la taille de DataFrame, mais ne l'a jamais trouvée plus lente.

Et juste pour le plaisir:

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

Mais:

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

EDIT !!!

En supposant que vous ayez un cadre utilisant float64, ce sera le plus rapide de loin! Il est également capable de générer n'importe quelle valeur en remplaçant 0.0 par le numéro de remplissage souhaité.

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

Selon le goût, on peut définir extérieurement nan et faire une solution générale, quel que soit le type de flotteur utilisé:

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
1
Mark Horvath