शून्य-भरा पांडा डेटा फ्रेम बनाना

Question

किसी दिए गए आकार का शून्य-भरा पांडा डेटा फ्रेम बनाने का सबसे अच्छा तरीका क्या है?

मैंने उपयोग कर लिया है:

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

इसे करने का कोई बेहतर तरीका है?

Comments

नहीं, मैं उस पर कोई पर्याप्त सुधार के बारे में नहीं सोच सकता।

— दान एलन

मुझे np.zeros पर मेमोरी एरर मिल रहा है, क्योंकि डेटा एक बड़ा सेट है। मैं क्या कर सकता हूँ पर कोई संकेत? मुझे "MemoryError" के अलावा कोई अन्य आउटपुट नहीं मिला। मेरे पास 100GB RAM है और डेटा सिर्फ 20GB है लेकिन फिर भी विफल रहता है। कोई विचार नहीं है कि इसे कैसे डीबग करें, 64 बिट ubuntu सर्वर। मैं थोड़ा संभल गया लेकिन हर कोई कहता है - विखंडू में विभाजित है, लेकिन इस डेटा को विभाजित नहीं किया जा सकता है।

— niedakh

क्या आप सिर्फ साथ काम कर सकते हैं data? इसे धारण करने के लिए आपको एक और संरचना बनाने की आवश्यकता क्यों है?

— फिलिप बादल

Answer 1

आप यह कोशिश कर सकते हैं:

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

Comments

यह परीक्षण मुझे लगता %timeit temp = np.zeros((10, 11)); d = pd.DataFrame(temp, columns = ['col1', 'col2',...'col11'])है कि हमें 156 लगता है। लेकिन %timeit d = pd.DataFrame(0, index = np.arange(10), columns = ['col1', 'col2',...'col11'])हमें 171 लगते हैं। मुझे आश्चर्य है कि यह कोई तेज़ नहीं है।

— ईमशोर्श

ध्यान दें कि आप int / float समस्या में चल सकते हैं यदि आप 0 को समाहित d.set_value(params)करने के dलिए आरंभ करने के बाद कुछ ऐसा कर रहे हैं। एक आसान ठीक है: d = pd.DataFrame(0.0, index=np.arange(len(data)), columns=feature_list)।

— ximiki

Answer 2

मेरी राय में सुन्न के साथ ऐसा करना सबसे अच्छा है

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

Comments

जब मैंने इसे इस तरह किया, तो मैं "0" मानों को बदल नहीं सका। TypeError: 'numpy.float64' object does not support item assignment

— राइटमीयर

@RightmireM वास्तव में आप उन्हें कैसे बदलने की कोशिश कर रहे हैं? आप सही हैं, डेटाटाइप हैnp.float64

— एलेक्सजैन

Answer 3

@ श्रवण के समान, लेकिन बिना अंक के उपयोग के:

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

फिर आप इसके साथ जो चाहें कर सकते हैं:

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

Answer 4

यदि आप नए डेटा फ़्रेम को मौजूदा डेटा फ़्रेम के समान इंडेक्स और कॉलम चाहते हैं, तो आप मौजूदा डेटा स्लॉट को निम्न से गुणा कर सकते हैं:

df_zeros = df * 0

Comments

इस बात से अवगत रहें कि जहाँ भी df में NaN होते हैं, आपको शून्य के बजाय NaN मिलेंगे।

— काडे

Answer 5

यदि आपके पास पहले से ही डेटाफ़्रेम है, तो यह सबसे तेज़ तरीका है:

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

से तुलना:

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

Answer 6

एक टेम्पलेट DataFrame, जो एक शून्य यहाँ भरा मूल्यों के साथ कॉपी करना चाहते हैं मान लें ...

यदि आपके डेटा सेट में कोई NaN नहीं है, तो शून्य से गुणा करना काफी तेज हो सकता है:

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

सुधार DataFrame आकार पर निर्भर करता है, लेकिन यह कभी धीमा नहीं मिला।

और बस इसके लिए:

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

परंतु:

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

संपादित करें !!!

मान लें कि आपके पास float64 का उपयोग करके एक फ़्रेम है, यह एक विशाल मार्जिन द्वारा सबसे तेज़ होगा! यह वांछित भरण संख्या 0.0 को प्रतिस्थापित करके किसी भी मूल्य को उत्पन्न करने में सक्षम है।

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

स्वाद के आधार पर, कोई बाह्य रूप से नैनो को परिभाषित कर सकता है, और एक सामान्य समाधान कर सकता है, भले ही विशेष फ्लोट प्रकार के बावजूद:

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

Comments

यह निश्चित रूप से समय पर सबसे व्यापक उत्तर है, हालांकि ओपी के लिए ऐसा लगता है कि स्मृति की आवश्यकताएं मुद्दा थीं और गति नहीं ... वैसे, मेरे सिस्टम पर पहले दो सुझाव जो आपने लिखे थे, वही समय दे रहे हैं (पंडों 0.20.3 ), इसलिए शायद कुछ बदलाव हुए हैं।

— मूट