क्या पंडों में डेटाफ़्रेम में पिछली पंक्ति मूल्य का उपयोग करने का एक तरीका है। लागू होने में पिछले मूल्य की भी गणना की जाती है?

Question 1

मेरे पास निम्नलिखित डेटाफ़्रेम हैं:

 Index_Date    A    B    C    D
 ===============================
 2015-01-31    10   10   Nan  10
 2015-02-01     2    3   Nan  22 
 2015-02-02    10   60   Nan  280
 2015-02-03    10   100   Nan  250

आवश्यक है:

 Index_Date    A    B    C    D
 ===============================
 2015-01-31    10   10   10   10
 2015-02-01     2    3   23   22
 2015-02-02    10   60   290  280
 2015-02-03    10   100  3000 250

Column Cके 2015-01-31द्वारा लिया गया valueहै D।

तब मैं उपयोग करने की आवश्यकता valueके Cलिए 2015-01-31और गुणा valueके Aपर 2015-02-01और जोड़ने B।

मैंने एक प्रयास किया है applyऔर इसके द्वारा एक shiftप्रयोग if elseएक महत्वपूर्ण त्रुटि देता है।

Question 2

सबसे पहले, व्युत्पन्न मूल्य बनाएँ:

df.loc[0, 'C'] = df.loc[0, 'D']

फिर शेष पंक्तियों के माध्यम से पुनरावृति करें और परिकलित मान भरें:

for i in range(1, len(df)):
    df.loc[i, 'C'] = df.loc[i-1, 'C'] * df.loc[i, 'A'] + df.loc[i, 'B']


  Index_Date   A   B    C    D
0 2015-01-31  10  10   10   10
1 2015-02-01   2   3   23   22
2 2015-02-02  10  60  290  280

Question 3

संख्याओं के एक कॉलम को देखते हुए:

lst = []
cols = ['A']
for a in range(100, 105):
    lst.append([a])
df = pd.DataFrame(lst, columns=cols, index=range(5))
df

    A
0   100
1   101
2   102
3   103
4   104

आप पिछली पंक्ति को शिफ्ट के साथ संदर्भित कर सकते हैं:

df['Change'] = df.A - df.A.shift(1)
df

    A   Change
0   100 NaN
1   101 1.0
2   102 1.0
3   103 1.0
4   104 1.0

Question 4

`numba`

पुनरावर्ती गणनाओं के लिए numba, जो सदिश नहीं हैं , जो जेआईटी-संकलन का उपयोग करता है और निचले स्तर की वस्तुओं के साथ काम करता है, अक्सर बड़े प्रदर्शन में सुधार होता है। आपको केवल एक नियमित forलूप को परिभाषित करने और डेकोरेटर का उपयोग करने की आवश्यकता है @njitया (पुराने संस्करणों के लिए) @jit(nopython=True):

एक उचित आकार के डेटाफ्रेम के लिए, यह एक नियमित forलूप बनाम ~ 30x प्रदर्शन सुधार देता है :

from numba import jit

@jit(nopython=True)
def calculator_nb(a, b, d):
    res = np.empty(d.shape)
    res[0] = d[0]
    for i in range(1, res.shape[0]):
        res[i] = res[i-1] * a[i] + b[i]
    return res

df['C'] = calculator_nb(*df[list('ABD')].values.T)

n = 10**5
df = pd.concat([df]*n, ignore_index=True)

# benchmarking on Python 3.6.0, Pandas 0.19.2, NumPy 1.11.3, Numba 0.30.1
# calculator() is same as calculator_nb() but without @jit decorator
%timeit calculator_nb(*df[list('ABD')].values.T)  # 14.1 ms per loop
%timeit calculator(*df[list('ABD')].values.T)     # 444 ms per loop

Question 5

खस्ता सरणियों पर पुनरावर्ती कार्य को लागू करना वर्तमान उत्तर की तुलना में तेज होगा।

df = pd.DataFrame(np.repeat(np.arange(2, 6),3).reshape(4,3), columns=['A', 'B', 'D'])
new = [df.D.values[0]]
for i in range(1, len(df.index)):
    new.append(new[i-1]*df.A.values[i]+df.B.values[i])
df['C'] = new

उत्पादन

      A  B  D    C
   0  1  1  1    1
   1  2  2  2    4
   2  3  3  3   15
   3  4  4  4   64
   4  5  5  5  325

Question 6

हालाँकि इस प्रश्न को पूछे जाने में कुछ समय हो गया है, मैं अपना उत्तर इस उम्मीद से दूंगा कि यह किसी की मदद करता है।

अस्वीकरण: मुझे पता है कि यह समाधान मानक नहीं है , लेकिन मुझे लगता है कि यह अच्छी तरह से काम करता है।

import pandas as pd
import numpy as np

data = np.array([[10, 2, 10, 10],
                 [10, 3, 60, 100],
                 [np.nan] * 4,
                 [10, 22, 280, 250]]).T
idx = pd.date_range('20150131', end='20150203')
df = pd.DataFrame(data=data, columns=list('ABCD'), index=idx)
df
               A    B     C    D
 =================================
 2015-01-31    10   10    NaN  10
 2015-02-01    2    3     NaN  22 
 2015-02-02    10   60    NaN  280
 2015-02-03    10   100   NaN  250

def calculate(mul, add):
    global value
    value = value * mul + add
    return value

value = df.loc['2015-01-31', 'D']
df.loc['2015-01-31', 'C'] = value
df.loc['2015-02-01':, 'C'] = df.loc['2015-02-01':].apply(lambda row: calculate(*row[['A', 'B']]), axis=1)
df
               A    B     C     D
 =================================
 2015-01-31    10   10    10    10
 2015-02-01    2    3     23    22 
 2015-02-02    10   60    290   280
 2015-02-03    10   100   3000  250

इसलिए मूल रूप से हम applyपांडा से और एक वैश्विक वैरिएबल की मदद लेते हैं जो पिछले गणना मूल्य का ट्रैक रखता है।

एक forलूप के साथ समय की तुलना :

data = np.random.random(size=(1000, 4))
idx = pd.date_range('20150131', end='20171026')
df = pd.DataFrame(data=data, columns=list('ABCD'), index=idx)
df.C = np.nan

df.loc['2015-01-31', 'C'] = df.loc['2015-01-31', 'D']

%%timeit
for i in df.loc['2015-02-01':].index.date:
    df.loc[i, 'C'] = df.loc[(i - pd.DateOffset(days=1)).date(), 'C'] * df.loc[i, 'A'] + df.loc[i, 'B']

3.2 एस d 114 एमएस प्रति लूप (मतलब dev एसटीडी। 7 रन का। 1 लूप प्रत्येक)

data = np.random.random(size=(1000, 4))
idx = pd.date_range('20150131', end='20171026')
df = pd.DataFrame(data=data, columns=list('ABCD'), index=idx)
df.C = np.nan

def calculate(mul, add):
    global value
    value = value * mul + add
    return value

value = df.loc['2015-01-31', 'D']
df.loc['2015-01-31', 'C'] = value

%%timeit
df.loc['2015-02-01':, 'C'] = df.loc['2015-02-01':].apply(lambda row: calculate(*row[['A', 'B']]), axis=1)

1.82 s 82 64.4 एमएस प्रति लूप (मतलब dev एसटीडी। 7 रन का देवता, 1 लूप प्रत्येक)

तो औसतन 0.57 गुना तेज।

Question 7

सामान्य तौर पर, एक स्पष्ट लूप से बचने के लिए कुंजी पंक्ति में डेटाफ्रेम के 2 उदाहरणों को मिलाना (मर्ज करना) होगा।

तब आपके पास r और r-1 की पंक्तियों वाली एक बड़ी डेटाफ़्रेम होगी, जहाँ से आप df.apply () फ़ंक्शन कर सकते थे।

हालांकि बड़े डेटासेट बनाने के ओवरहेड समानांतर प्रसंस्करण के लाभों की भरपाई कर सकते हैं ...

एचटीएच मार्टिन