डेटाफ़्रेम सेल के अंदर एक सूची को अलग-अलग पंक्तियों में कैसे विस्फोट किया जाए

Question

मैं उन मूल्यों में से प्रत्येक के लिए पंक्तियों में एक सूची वाले एक पांडा सेल को चालू करना चाहता हूं।

तो, यह लो:

अगर मैं nearest_neighborsकॉलम में मानों को अनपैक और स्टैक करना चाहता हूं, ताकि प्रत्येक मूल्य प्रत्येक opponentइंडेक्स के भीतर एक पंक्ति हो , तो मैं इस बारे में सबसे अच्छा कैसे करूंगा? क्या इस तरह के संचालन के लिए पंडों के तरीके हैं?

Comments

क्या आप अपने वांछित आउटपुट का उदाहरण दे सकते हैं, और आपने अब तक क्या प्रयास किया है? दूसरों के लिए आपकी मदद करना सबसे आसान है यदि आप कुछ नमूना डेटा प्रदान करते हैं जो कट और चिपकाया जा सकता है, साथ ही साथ।

— 23

आप pd.DataFrame(df.nearest_neighbors.values.tolist())इस कॉलम को अनपैक करने और फिर pd.mergeइसे दूसरों के साथ गोंद करने के लिए उपयोग कर सकते हैं।

— हेलपांडेर

@helpanderr मुझे नहीं लगता कि values.tolist()यहां कुछ भी है; कॉलम पहले से ही एक सूची है

— मैक्सिमू

@maxymoo i.imgur.com/YGQAYOY.png

— नरकपांडेर

संबंधित लेकिन अधिक विवरण stackoverflow.com/questions/53218931/…

— BEN_YO

Answer 1

नीचे दिए गए कोड में, मैं पहले पंक्ति पुनरावृत्ति को आसान बनाने के लिए सूचकांक को रीसेट करता हूं।

मैं उन सूचियों की सूची बनाता हूं जहां बाहरी सूची का प्रत्येक तत्व लक्ष्य डेटाफ्रेम की एक पंक्ति है और आंतरिक सूची का प्रत्येक तत्व स्तंभों में से एक है। वांछित डेटाफ़्रेम बनाने के लिए इस नेस्टेड सूची को अंततः संक्षिप्त किया जाएगा।

मैं प्रासंगिक और के साथ युग्मित के lambdaप्रत्येक तत्व के लिए एक पंक्ति बनाने के लिए सूची पुनरावृत्ति के साथ एक फ़ंक्शन का उपयोग करता हूं । nearest_neighborsnameopponent

अंत में, मैं इस सूची में से एक नया डेटाफ़्रेम बनाता हूं (मूल कॉलम नामों का उपयोग करके और सूचकांक को वापस nameऔर opponent) पर सेट करता हूं ।

df = (pd.DataFrame({'name': ['A.J. Price'] * 3, 
                    'opponent': ['76ers', 'blazers', 'bobcats'], 
                    'nearest_neighbors': [['Zach LaVine', 'Jeremy Lin', 'Nate Robinson', 'Isaia']] * 3})
      .set_index(['name', 'opponent']))

>>> df
                                                    nearest_neighbors
name       opponent                                                  
A.J. Price 76ers     [Zach LaVine, Jeremy Lin, Nate Robinson, Isaia]
           blazers   [Zach LaVine, Jeremy Lin, Nate Robinson, Isaia]
           bobcats   [Zach LaVine, Jeremy Lin, Nate Robinson, Isaia]

df.reset_index(inplace=True)
rows = []
_ = df.apply(lambda row: [rows.append([row['name'], row['opponent'], nn]) 
                         for nn in row.nearest_neighbors], axis=1)
df_new = pd.DataFrame(rows, columns=df.columns).set_index(['name', 'opponent'])

>>> df_new
                    nearest_neighbors
name       opponent                  
A.J. Price 76ers          Zach LaVine
           76ers           Jeremy Lin
           76ers        Nate Robinson
           76ers                Isaia
           blazers        Zach LaVine
           blazers         Jeremy Lin
           blazers      Nate Robinson
           blazers              Isaia
           bobcats        Zach LaVine
           bobcats         Jeremy Lin
           bobcats      Nate Robinson
           bobcats              Isaia

EDIT JUNE 2017

एक वैकल्पिक विधि इस प्रकार है:

>>> (pd.melt(df.nearest_neighbors.apply(pd.Series).reset_index(), 
             id_vars=['name', 'opponent'],
             value_name='nearest_neighbors')
     .set_index(['name', 'opponent'])
     .drop('variable', axis=1)
     .dropna()
     .sort_index()
     )

Comments

apply(pd.Series)फ्रेम के सबसे अच्छे पर ठीक है, लेकिन किसी भी उचित आकार के फ्रेम के लिए, आपको अधिक प्रदर्शन करने वाले समाधान पर पुनर्विचार करना चाहिए। देखें कि मुझे अपने कोड में कभी भी पांडा का उपयोग कब करना चाहिए ()? (एक बेहतर उपाय है कि पहले कॉलम को सूचीबद्ध किया जाए।)

— cs95

विधि के अतिरिक्त के साथ पंडों 0.25 में एक सूची जैसे स्तंभ को सरल बनाया गया है explode()। मैंने यहां एक ही df सेटअप का उपयोग करके एक उदाहरण के साथ एक उत्तर जोड़ा ।

— जोएलोस्टब्लम

@joelostblom सुनने में अच्छा लगता है। वर्तमान उपयोग के साथ उदाहरण जोड़ने के लिए धन्यवाद।

— सिकंदर

Answer 2

का प्रयोग करें apply(pd.Series)और stack, तो reset_indexऔरto_frame

In [1803]: (df.nearest_neighbors.apply(pd.Series)
              .stack()
              .reset_index(level=2, drop=True)
              .to_frame('nearest_neighbors'))
Out[1803]:
                    nearest_neighbors
name       opponent
A.J. Price 76ers          Zach LaVine
           76ers           Jeremy Lin
           76ers        Nate Robinson
           76ers                Isaia
           blazers        Zach LaVine
           blazers         Jeremy Lin
           blazers      Nate Robinson
           blazers              Isaia
           bobcats        Zach LaVine
           bobcats         Jeremy Lin
           bobcats      Nate Robinson
           bobcats              Isaia

विवरण

In [1804]: df
Out[1804]:
                                                   nearest_neighbors
name       opponent
A.J. Price 76ers     [Zach LaVine, Jeremy Lin, Nate Robinson, Isaia]
           blazers   [Zach LaVine, Jeremy Lin, Nate Robinson, Isaia]
           bobcats   [Zach LaVine, Jeremy Lin, Nate Robinson, Isaia]

Comments

अपने समाधान की लालित्य से प्यार करो! क्या आपने इसे किसी भी मौके पर अन्य तरीकों के खिलाफ बेंचमार्क किया है?

— rpyzh

का परिणाम df.nearest_neighbors.apply(pd.Series)मेरे लिए बहुत आश्चर्यजनक है;

— कैलम यू

@rpyzh हां, यह काफी सुरुचिपूर्ण है, लेकिन धैर्यपूर्वक धीमा है।

— cs95

Answer 3

• एक सूची की तरह के कॉलम को विस्फोट करना विधि के अतिरिक्त के साथ पांडा 0.25 में काफी सरल किया गया है explode():

df = (pd.DataFrame({'name': ['A.J. Price'] * 3, 
                    'opponent': ['76ers', 'blazers', 'bobcats'], 
                    'nearest_neighbors': [['Zach LaVine', 'Jeremy Lin', 'Nate Robinson', 'Isaia']] * 3})
      .set_index(['name', 'opponent']))

df.explode('nearest_neighbors')

बाहर:

                    nearest_neighbors
name       opponent                  
A.J. Price 76ers          Zach LaVine
           76ers           Jeremy Lin
           76ers        Nate Robinson
           76ers                Isaia
           blazers        Zach LaVine
           blazers         Jeremy Lin
           blazers      Nate Robinson
           blazers              Isaia
           bobcats        Zach LaVine
           bobcats         Jeremy Lin
           bobcats      Nate Robinson
           bobcats              Isaia

Comments

ध्यान दें कि यह केवल एकल कॉलम (0.25 तक) के लिए काम करता है। अधिक सामान्य समाधानों के लिए यहां और यहां देखें ।

— cs95

Answer 4

मुझे लगता है कि यह वास्तव में एक अच्छा सवाल है, हाइव में आप उपयोग करेंगे EXPLODE, मुझे लगता है कि एक ऐसा मामला बनना है कि पंडों को इस कार्यक्षमता को डिफ़ॉल्ट रूप से शामिल करना चाहिए। मैं शायद इस तरह से नेस्टेड जनरेटर समझ के साथ सूची कॉलम को विस्फोट करूंगा:

pd.DataFrame({
    "name": i[0],
    "opponent": i[1],
    "nearest_neighbor": neighbour
    }
    for i, row in df.iterrows() for neighbour in row.nearest_neighbors
    ).set_index(["name", "opponent"])

Comments

मुझे पसंद है कि यह समाधान प्रत्येक पंक्ति के लिए अलग-अलग सूची आइटम की संख्या के लिए कैसे अनुमति देता है।

— user1718097

क्या इस विधि के साथ मूल सूचकांक रखने का कोई तरीका है?

— ग्रीष्मकाल

@SummerEla यह एक बहुत पुराना जवाब था, मैंने यह दिखाने के लिए अद्यतन किया है कि मैं इसे अब कैसे करूंगा

— अधिकतम ११'१oo

@ maxymoo यह अभी भी एक महान सवाल है, हालांकि। अपडेट करने के लिए धन्यवाद!

— ग्रीष्मकाल

मैंने इसे उपयोगी पाया और इसे एक पैकेज

— ओरेन

Answer 5

सबसे तेजी से विधि मैंने पाया अब तक के साथ DataFrame प्रदान कर रहा है .ilocऔर वापस बताए चपटी लक्ष्य स्तंभ।

सामान्य इनपुट को देखते हुए (थोड़ा सा दोहराया गया):

df = (pd.DataFrame({'name': ['A.J. Price'] * 3, 
                    'opponent': ['76ers', 'blazers', 'bobcats'], 
                    'nearest_neighbors': [['Zach LaVine', 'Jeremy Lin', 'Nate Robinson', 'Isaia']] * 3})
      .set_index(['name', 'opponent']))
df = pd.concat([df]*10)

df
Out[3]: 
                                                   nearest_neighbors
name       opponent                                                 
A.J. Price 76ers     [Zach LaVine, Jeremy Lin, Nate Robinson, Isaia]
           blazers   [Zach LaVine, Jeremy Lin, Nate Robinson, Isaia]
           bobcats   [Zach LaVine, Jeremy Lin, Nate Robinson, Isaia]
           76ers     [Zach LaVine, Jeremy Lin, Nate Robinson, Isaia]
           blazers   [Zach LaVine, Jeremy Lin, Nate Robinson, Isaia]
...

निम्नलिखित सुझाए गए विकल्पों को देखते हुए:

col_target = 'nearest_neighbors'

def extend_iloc():
    # Flatten columns of lists
    col_flat = [item for sublist in df[col_target] for item in sublist] 
    # Row numbers to repeat 
    lens = df[col_target].apply(len)
    vals = range(df.shape[0])
    ilocations = np.repeat(vals, lens)
    # Replicate rows and add flattened column of lists
    cols = [i for i,c in enumerate(df.columns) if c != col_target]
    new_df = df.iloc[ilocations, cols].copy()
    new_df[col_target] = col_flat
    return new_df

def melt():
    return (pd.melt(df[col_target].apply(pd.Series).reset_index(), 
             id_vars=['name', 'opponent'],
             value_name=col_target)
            .set_index(['name', 'opponent'])
            .drop('variable', axis=1)
            .dropna()
            .sort_index())

def stack_unstack():
    return (df[col_target].apply(pd.Series)
            .stack()
            .reset_index(level=2, drop=True)
            .to_frame(col_target))

मुझे लगता है कि extend_iloc()है सबसे तेजी से :

%timeit extend_iloc()
3.11 ms ± 544 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit melt()
22.5 ms ± 1.25 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit stack_unstack()
11.5 ms ± 410 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Comments

अच्छा मूल्यांकन

— javadba

इसके लिए धन्यवाद, इसने वास्तव में मेरी मदद की। मैं extend_iloc समाधान का इस्तेमाल किया और पाया कि cols = [c for c in df.columns if c != col_target] होना चाहिए: त्रुटियों यदि स्तंभ अनुक्रमणिका के साथ प्रस्तुत नहीं। cols = [i for i,c in enumerate(df.columns) if c != col_target]df.iloc[ilocations, cols].copy()

— २१:

Iloc सुझाव के लिए फिर से धन्यवाद। मैंने यहां कैसे काम करता है, इसकी विस्तृत व्याख्या लिखी है: medium.com/@johnadungan/… । आशा है कि यह एक समान चुनौती के साथ किसी को भी मदद करता है।

— जादुंगन

Answer 6

लागू के साथ अच्छे वैकल्पिक समाधान (pd.Series):

df = pd.DataFrame({'listcol':[[1,2,3],[4,5,6]]})

# expand df.listcol into its own dataframe
tags = df['listcol'].apply(pd.Series)

# rename each variable is listcol
tags = tags.rename(columns = lambda x : 'listcol_' + str(x))

# join the tags dataframe back to the original dataframe
df = pd.concat([df[:], tags[:]], axis=1)

Comments

यह एक पंक्तियों का विस्तार करता है न कि पंक्तियों का।

— ओलेग

@ सही है, लेकिन आप हमेशा DataFrame को स्थानांतरित कर सकते हैं और फिर pd.Series लागू कर सकते हैं-सबसे सरल अन्य सुझावों की तुलना में

— फिलिप श्वार्ज़

Answer 7

हाइव की अत्यधिक कार्यक्षमता के समान:

import copy

def pandas_explode(df, column_to_explode):
    """
    Similar to Hive's EXPLODE function, take a column with iterable elements, and flatten the iterable to one element 
    per observation in the output table

    :param df: A dataframe to explod
    :type df: pandas.DataFrame
    :param column_to_explode: 
    :type column_to_explode: str
    :return: An exploded data frame
    :rtype: pandas.DataFrame
    """

    # Create a list of new observations
    new_observations = list()

    # Iterate through existing observations
    for row in df.to_dict(orient='records'):

        # Take out the exploding iterable
        explode_values = row[column_to_explode]
        del row[column_to_explode]

        # Create a new observation for every entry in the exploding iterable & add all of the other columns
        for explode_value in explode_values:

            # Deep copy existing observation
            new_observation = copy.deepcopy(row)

            # Add one (newly flattened) value from exploding iterable
            new_observation[column_to_explode] = explode_value

            # Add to the list of new observations
            new_observations.append(new_observation)

    # Create a DataFrame
    return_df = pandas.DataFrame(new_observations)

    # Return
    return return_df

Comments

जब मैं इसे चलाता हूं, तो मुझे निम्नलिखित त्रुटि मिलती है:NameError: global name 'copy' is not defined

— frmsaul

Answer 8

तो ये सभी उत्तर अच्छे हैं, लेकिन मैं कुछ चाहता था ^ वास्तव में सरल ^ तो यहां मेरा योगदान है:

def explode(series):
    return pd.Series([x for _list in series for x in _list])                               

यह बात है .. बस इसका उपयोग तब करें जब आप एक नई श्रृंखला चाहते हैं जहाँ सूचियाँ 'विस्फोटित' हों। यहाँ एक उदाहरण है जहाँ हम taco विकल्पों पर value_counts () करते हैं :)

In [1]: my_df = pd.DataFrame(pd.Series([['a','b','c'],['b','c'],['c']]), columns=['tacos'])      
In [2]: my_df.head()                                                                               
Out[2]: 
   tacos
0  [a, b, c]
1     [b, c]
2        [c]

In [3]: explode(my_df['tacos']).value_counts()                                                     
Out[3]: 
c    3
b    2
a    1

Answer 9

यहाँ बड़े डेटाफ़्रेम के लिए एक संभावित अनुकूलन है। यह तेजी से चलता है जब "विस्फोट" क्षेत्र में कई समान मूल्य होते हैं। (डेटाफ़्रेम जितना बड़ा होता है, उसकी तुलना फ़ील्ड में अद्वितीय मूल्य गणना से की जाती है, यह कोड बेहतर प्रदर्शन करेगा।)

def lateral_explode(dataframe, fieldname): 
    temp_fieldname = fieldname + '_made_tuple_' 
    dataframe[temp_fieldname] = dataframe[fieldname].apply(tuple)       
    list_of_dataframes = []
    for values in dataframe[temp_fieldname].unique().tolist(): 
        list_of_dataframes.append(pd.DataFrame({
            temp_fieldname: [values] * len(values), 
            fieldname: list(values), 
        }))
    dataframe = dataframe[list(set(dataframe.columns) - set([fieldname]))]\ 
        .merge(pd.concat(list_of_dataframes), how='left', on=temp_fieldname) 
    del dataframe[temp_fieldname]

    return dataframe

Answer 10

.ilocसभी सूची-स्तंभों को स्वचालित रूप से समतल करने के लिए ओलेग के उत्तर का विस्तार :

def extend_iloc(df):
    cols_to_flatten = [colname for colname in df.columns if 
    isinstance(df.iloc[0][colname], list)]
    # Row numbers to repeat 
    lens = df[cols_to_flatten[0]].apply(len)
    vals = range(df.shape[0])
    ilocations = np.repeat(vals, lens)
    # Replicate rows and add flattened column of lists
    with_idxs = [(i, c) for (i, c) in enumerate(df.columns) if c not in cols_to_flatten]
    col_idxs = list(zip(*with_idxs)[0])
    new_df = df.iloc[ilocations, col_idxs].copy()

    # Flatten columns of lists
    for col_target in cols_to_flatten:
        col_flat = [item for sublist in df[col_target] for item in sublist]
        new_df[col_target] = col_flat

    return new_df

यह मानता है कि प्रत्येक सूची-स्तंभ में समान सूची लंबाई है।

Answer 11

लागू (pd.Series) का उपयोग करने के बजाय आप कॉलम को समतल कर सकते हैं। इससे प्रदर्शन में सुधार होता है।

df = (pd.DataFrame({'name': ['A.J. Price'] * 3, 
                'opponent': ['76ers', 'blazers', 'bobcats'], 
                'nearest_neighbors': [['Zach LaVine', 'Jeremy Lin', 'Nate Robinson', 'Isaia']] * 3})
  .set_index(['name', 'opponent']))



%timeit (pd.DataFrame(df['nearest_neighbors'].values.tolist(), index = df.index)
           .stack()
           .reset_index(level = 2, drop=True).to_frame('nearest_neighbors'))

1.87 ms ± 9.74 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)


%timeit (df.nearest_neighbors.apply(pd.Series)
          .stack()
          .reset_index(level=2, drop=True)
          .to_frame('nearest_neighbors'))

2.73 ms ± 16.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Comments

IndexError: बहुत सारे लेवल: इंडेक्स में केवल 2 लेवल होते हैं, 3 नहीं, जब मैं अपना उदाहरण

— आज़माता हूँ

आपको अपने उदाहरण के अनुसार रीसेट_इंडेक्स में "स्तर" बदलना होगा

— कुमार