कॉलम मानों के आधार पर पंक्तियों की संख्या बनाएं - पांडा/पायथन

हम उपयोग कर सकते हैं pd.Index.repeat index_end - index_start + 1 बार दोहराने के लिए rel="nofollow noreferrer">df.reindex। फिर index_start और index_end के बीच डेटा जेनरेट करें >itertools.starmap.

from itertools import starmap

rep = (df['index_end'] - df['index_start']) + 1
idx = df.index.repeat(rep)
vals = df.to_numpy()[:, 1:]
vals[:, 1] += 1
index = np.hstack([*starmap(np.arange, vals)])
df.reindex(idx).assign(index=index)

  item  index_start  index_end  index
0    A            1          3      1
0    A            1          3      2
0    A            1          3      3
1    B            4          7      4
1    B            4          7      5
1    B            4          7      6
1    B            4          7      7

@Andreas का एक अच्छा पठनीय समाधान है लेकिन दो अड़चन संचालन हैं जो रनटाइम को बढ़ाएंगे एक df.apply अक्ष 1 और df.explode पर।

समय विश्लेषण:

बेंचमार्किंग सेटअप:

df = pd.concat([df]*1000, ignore_index=True)

# @Ch3steR's solution
In [130]: %%timeit 
     ...: rep = (df['index_end'] - df['index_start']) + 1 
     ...: idx = df.index.repeat(rep) 
     ...: vals = df.to_numpy()[:, 1:] 
     ...: vals[:, 1] += 1 
     ...: index = np.hstack([*starmap(np.arange, vals)]) 
     ...: df.reindex(idx).assign(index=index) 
     ...:  
     ...:                                                                       
4.82 ms ± 72.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

# @Andreas' solution
In [131]: %%timeit 
     ...: df['index'] = df.apply(lambda row: list(range(row['index_start'], row[
     ...: 'index_end']+1)), axis=1) 
     ...: df.explode('index') 
     ...:  
     ...:                                                                       
20.4 ms ± 796 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

मैंने कुछ बार परीक्षण चलाया, मेरा समाधान लगभग ~ 4 गुना तेज है। हम गति में और सुधार कर सकते हैं यदि हम किसी तरह index = np.hstack([*starmap(np.arange, vals)]) इस ऑपरेशन को वेक्टरकृत कर सकें।

FWIW, Ch3steR का अच्छा जवाब पर एक छोटा सा अनुकूलन एक ग्रुपबाय करके और एक लेकर index कॉलम बनाना है प्रत्येक समूह की संचयी गणना, और फिर index_start द्वारा गणना की भरपाई करना:

rep = (df['index_end'] - df['index_start']) + 1
res = df.loc[df.index.repeat(rep)]
res['index'] = res.groupby(res.index).cumcount() + res['index_start']

आउटपुट (res):

  item  index_start  index_end  index
0    A            1          3      1
0    A            1          3      2
0    A            1          3      3
1    B            4          7      4
1    B            4          7      5
1    B            4          7      6
1    B            4          7      7

और समय, एक ला Ch3steR:

df = pd.concat([df]*1000, ignore_index=True)

%%timeit
rep = (df['index_end'] - df['index_start']) + 1
res = df.loc[df.index.repeat(rep)]
res['index'] = res.groupby(res.index).cumcount() + res['index_start']
# 1.66 ms ± 38.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

आपको विश्वास करना होगा कि अन्य दृष्टिकोणों के लिए मेरा समय पोस्ट किए गए के समान है:)

लेकिन मेरे लिए, यह एक इंडेक्स बनाने के लिए ओवरकिल जैसा लगता है। यदि आपकी मूल पंक्तियों में संदर्भित सूचकांक हमेशा सन्निहित और गैर-अतिव्यापी होते हैं (अर्थात यदि एक प्रविष्टि i से j तक फैली हुई है, तो अगली j + 1< से शुरू होती है। /em>), तो index केवल पूर्णांकों की एक श्रृंखला होने जा रहा है। तो इसे range के साथ बनाना सही होना चाहिए:

res['index'] = np.arange(1, len(df) + 1)

res = res.reset_index(drop=True)

# now there are gaps in the indices, and it doesn't start at 1
df = pd.DataFrame({'item':['A','B'],
                   'index_start':[3, 5],
                   'index_end':[19, 22]})