पंडों की सूचियों का स्तंभ, प्रत्येक सूची तत्व के लिए एक पंक्ति बनाएँ

163

मेरे पास एक डेटाफ्रेम है जहां कुछ कोशिकाओं में कई मानों की सूची होती है। एक सेल में कई मानों को संग्रहीत करने के बजाय, मैं डेटाफ्रेम का विस्तार करना चाहूंगा ताकि सूची में प्रत्येक आइटम को अपनी पंक्ति (सभी अन्य स्तंभों में समान मान के साथ) मिल जाए। तो अगर मेरे पास है:

import pandas as pd
import numpy as np

df = pd.DataFrame(
    {'trial_num': [1, 2, 3, 1, 2, 3],
     'subject': [1, 1, 1, 2, 2, 2],
     'samples': [list(np.random.randn(3).round(2)) for i in range(6)]
    }
)

df
Out[10]: 
                 samples  subject  trial_num
0    [0.57, -0.83, 1.44]        1          1
1    [-0.01, 1.13, 0.36]        1          2
2   [1.18, -1.46, -0.94]        1          3
3  [-0.08, -4.22, -2.05]        2          1
4     [0.72, 0.79, 0.53]        2          2
5    [0.4, -0.32, -0.13]        2          3

मैं लंबे रूप में कैसे परिवर्तित करूँ, जैसे:

   subject  trial_num  sample  sample_num
0        1          1    0.57           0
1        1          1   -0.83           1
2        1          1    1.44           2
3        1          2   -0.01           0
4        1          2    1.13           1
5        1          2    0.36           2
6        1          3    1.18           0
# etc.

इंडेक्स महत्वपूर्ण नहीं है, मौजूदा कॉलम को इंडेक्स के रूप में सेट करना ठीक है और अंतिम ऑर्डरिंग महत्वपूर्ण नहीं है।

python  pandas  list 
— मारिअस
स्रोत
11
पांडा 0.25 से आप इसे df.explode('samples')हल करने के लिए भी उपयोग कर सकते हैं । explodeअभी के लिए केवल एक कॉलम में विस्फोट का समर्थन कर सकते हैं।
— सीएस 9595

जवाबों:

48 
lst_col = 'samples'

r = pd.DataFrame({
      col:np.repeat(df[col].values, df[lst_col].str.len())
      for col in df.columns.drop(lst_col)}
    ).assign(**{lst_col:np.concatenate(df[lst_col].values)})[df.columns]

परिणाम:

In [103]: r
Out[103]:
    samples  subject  trial_num
0      0.10        1          1
1     -0.20        1          1
2      0.05        1          1
3      0.25        1          2
4      1.32        1          2
5     -0.17        1          2
6      0.64        1          3
7     -0.22        1          3
8     -0.71        1          3
9     -0.03        2          1
10    -0.65        2          1
11     0.76        2          1
12     1.77        2          2
13     0.89        2          2
14     0.65        2          2
15    -0.98        2          3
16     0.65        2          3
17    -0.30        2          3

PS यहाँ आपको थोड़ा और जेनेरिक समाधान मिल सकता है

अद्यतन: कुछ स्पष्टीकरण: IMO इस कोड को समझने का सबसे आसान तरीका है कि इसे चरण-दर-चरण निष्पादित करने का प्रयास करें:

निम्नलिखित पंक्ति में हम एक कालम में मान दोहरा रहे हैं Nजहां N- संबंधित सूची की लंबाई है:

In [10]: np.repeat(df['trial_num'].values, df[lst_col].str.len())
Out[10]: array([1, 1, 1, 2, 2, 2, 3, 3, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3], dtype=int64)

इसे सभी स्तंभों के लिए सामान्यीकृत किया जा सकता है, जिसमें स्केलर मान शामिल हैं:

In [11]: pd.DataFrame({
    ...:           col:np.repeat(df[col].values, df[lst_col].str.len())
    ...:           for col in df.columns.drop(lst_col)}
    ...:         )
Out[11]:
    trial_num  subject
0           1        1
1           1        1
2           1        1
3           2        1
4           2        1
5           2        1
6           3        1
..        ...      ...
11          1        2
12          2        2
13          2        2
14          2        2
15          3        2
16          3        2
17          3        2

[18 rows x 2 columns]

उपयोग करके np.concatenate()हम listकॉलम के सभी मानों को समतल कर सकते हैं ( samples) और 1 डी वेक्टर प्राप्त कर सकते हैं:

In [12]: np.concatenate(df[lst_col].values)
Out[12]: array([-1.04, -0.58, -1.32,  0.82, -0.59, -0.34,  0.25,  2.09,  0.12,  0.83, -0.88,  0.68,  0.55, -0.56,  0.65, -0.04,  0.36, -0.31])

यह सब एक साथ रखना:

In [13]: pd.DataFrame({
    ...:           col:np.repeat(df[col].values, df[lst_col].str.len())
    ...:           for col in df.columns.drop(lst_col)}
    ...:         ).assign(**{lst_col:np.concatenate(df[lst_col].values)})
Out[13]:
    trial_num  subject  samples
0           1        1    -1.04
1           1        1    -0.58
2           1        1    -1.32
3           2        1     0.82
4           2        1    -0.59
5           2        1    -0.34
6           3        1     0.25
..        ...      ...      ...
11          1        2     0.68
12          2        2     0.55
13          2        2    -0.56
14          2        2     0.65
15          3        2    -0.04
16          3        2     0.36
17          3        2    -0.31

[18 rows x 3 columns]

उपयोग करने pd.DataFrame()[df.columns]की गारंटी होगी कि हम मूल क्रम में कॉलम का चयन कर रहे हैं ...

— MaxU
स्रोत
3
यह स्वीकृत उत्तर होना चाहिए। वर्तमान में स्वीकृत उत्तर इसके मुकाबले बहुत धीमा है।
— इरने
1
मैं यह पता नहीं लगा सकता कि इसे कैसे ठीक किया जा सकता है: TypeError: dtype ('float64') से dtype ('int64') में अरेंज डेटा को नियम 'सुरक्षित' के अनुसार नहीं डाल सकते हैं
— ग्रेग
1
यह एकमात्र उत्तर है जो मेरे लिए काम करता है, स्टैक की खोज के पूरे एक घंटे के दौरान पाए गए 10+ में से। धन्यवाद MaxU 🙏
— olisteadman
1
ध्यान दें कि यह उन पंक्तियों को छोड़ देता है जिनकी lst_colपूरी तरह से एक खाली सूची है ; इन पंक्तियों को रखने और उनके lst_colसाथ आबाद करने के लिए np.nan, आप df[lst_col] = df[lst_col].apply(lambda x: x if len(x) > 0 else [np.nan])इस विधि का उपयोग करने से पहले कर सकते हैं । जाहिर है .mask, इसलिए सूची नहीं लौटेगी, इसलिए .apply।
— चार्ल्स डेविस
यह एक उत्कृष्ट उत्तर है जिसे स्वीकार किया जाना चाहिए। हालांकि, यह एक काला-जादू स्तर का उत्तर है, और मैं, एक के लिए, वास्तव में इन चरणों के लिए कुछ स्पष्टीकरण की सराहना करता हूं।
— ifly6
129

मुझे उम्मीद से थोड़ा अधिक समय:

>>> df
                samples  subject  trial_num
0  [-0.07, -2.9, -2.44]        1          1
1   [-1.52, -0.35, 0.1]        1          2
2  [-0.17, 0.57, -0.65]        1          3
3  [-0.82, -1.06, 0.47]        2          1
4   [0.79, 1.35, -0.09]        2          2
5   [1.17, 1.14, -1.79]        2          3
>>>
>>> s = df.apply(lambda x: pd.Series(x['samples']),axis=1).stack().reset_index(level=1, drop=True)
>>> s.name = 'sample'
>>>
>>> df.drop('samples', axis=1).join(s)
   subject  trial_num  sample
0        1          1   -0.07
0        1          1   -2.90
0        1          1   -2.44
1        1          2   -1.52
1        1          2   -0.35
1        1          2    0.10
2        1          3   -0.17
2        1          3    0.57
2        1          3   -0.65
3        2          1   -0.82
3        2          1   -1.06
3        2          1    0.47
4        2          2    0.79
4        2          2    1.35
4        2          2   -0.09
5        2          3    1.17
5        2          3    1.14
5        2          3   -1.79

यदि आप अनुक्रमिक सूचकांक चाहते हैं, तो आप reset_index(drop=True)परिणाम के लिए आवेदन कर सकते हैं ।

अपडेट :

>>> res = df.set_index(['subject', 'trial_num'])['samples'].apply(pd.Series).stack()
>>> res = res.reset_index()
>>> res.columns = ['subject','trial_num','sample_num','sample']
>>> res
    subject  trial_num  sample_num  sample
0         1          1           0    1.89
1         1          1           1   -2.92
2         1          1           2    0.34
3         1          2           0    0.85
4         1          2           1    0.24
5         1          2           2    0.72
6         1          3           0   -0.96
7         1          3           1   -2.72
8         1          3           2   -0.11
9         2          1           0   -1.33
10        2          1           1    3.13
11        2          1           2   -0.65
12        2          2           0    0.10
13        2          2           1    0.65
14        2          2           2    0.15
15        2          3           0    0.64
16        2          3           1   -0.10
17        2          3           2   -0.76
— रोमन पाकर
स्रोत
धन्यवाद, यहां तक ​​कि प्रत्येक आइटम को अपने कॉलम में प्राप्त करने के लिए आवेदन करने का पहला चरण एक बड़ी मदद है। मैं इसे करने के लिए थोड़ा अलग तरीके से आने में सक्षम था, लेकिन इसमें अभी भी कुछ कदम शामिल हैं। जाहिरा तौर पर यह पंडों में करने के लिए सीधा नहीं है!
— मारियस
1
बहुत बढ़िया जवाब। के df.apply(lambda x: pd.Series(x['samples']),axis=1)साथ बदलकर आप इसे थोड़ा छोटा कर सकते हैं df.samples.apply(pd.Series)।
— डेनिस गोलोमेज़ोव
1
पाठकों पर ध्यान दें: यह प्रदर्शन के मुद्दों से बुरी तरह ग्रस्त है। सुन्न का उपयोग करते हुए बहुत अधिक प्रदर्शनकारी समाधान के लिए यहां देखें ।
— CS95
2
जब सभी पंक्तियों के लिए नमूनों की संख्या समान नहीं होती है तो क्या उपाय है?
— सराहा
@SarahData का उपयोग यहांdf.explode() दिखाया गया है।
— cs95
63

पंडों> = 0.25

श्रृंखला और डेटाफ्रेम विधियों एक .explode()विधि को परिभाषित करती है जो अलग-अलग पंक्तियों में सूचियों को विस्फोट करती है। सूची-जैसे कॉलम को विस्फोट करने पर डॉक्स अनुभाग देखें ।

df = pd.DataFrame({
    'var1': [['a', 'b', 'c'], ['d', 'e',], [], np.nan], 
    'var2': [1, 2, 3, 4]
})
df
        var1  var2
0  [a, b, c]     1
1     [d, e]     2
2         []     3
3        NaN     4

df.explode('var1')

  var1  var2
0    a     1
0    b     1
0    c     1
1    d     2
1    e     2
2  NaN     3  # empty list converted to NaN
3  NaN     4  # NaN entry preserved as-is

# to reset the index to be monotonically increasing...
df.explode('var1').reset_index(drop=True)

  var1  var2
0    a     1
1    b     1
2    c     1
3    d     2
4    e     2
5  NaN     3
6  NaN     4

ध्यान दें कि यह सूचियों और स्केलरों के मिश्रित स्तंभों के साथ-साथ खाली सूचियों और NaN को भी उचित रूप से संभालता है (यह एक repeatसमाधान आधारित समाधान है)।

हालांकि, आपको ध्यान देना चाहिए कि explodeकेवल एक कॉलम (अभी के लिए) पर काम करता है ।

पुनश्च: यदि आप तार के एक स्तंभ को विस्फोट करना चाहते हैं , तो आपको पहले एक विभाजक पर विभाजित करने की आवश्यकता है, फिर उपयोग करें explode। यह (बहुत) मेरे द्वारा संबंधित जवाब देखें ।

— cs95
स्रोत
8
अंत में, पंडों के लिए एक विस्फोट ()!
— काई
2
आखिरकार! होश उड़ जाना! @MaxU ऊपर से महान जवाब लेकिन यह चीजों को और अधिक सरल बनाता है।
— आदी
12

आप इसका उपयोग कर सकते हैं pd.concatऔर इसके pd.meltलिए:

>>> objs = [df, pd.DataFrame(df['samples'].tolist())]
>>> pd.concat(objs, axis=1).drop('samples', axis=1)
   subject  trial_num     0     1     2
0        1          1 -0.49 -1.00  0.44
1        1          2 -0.28  1.48  2.01
2        1          3 -0.52 -1.84  0.02
3        2          1  1.23 -1.36 -1.06
4        2          2  0.54  0.18  0.51
5        2          3 -2.18 -0.13 -1.35
>>> pd.melt(_, var_name='sample_num', value_name='sample', 
...         value_vars=[0, 1, 2], id_vars=['subject', 'trial_num'])
    subject  trial_num sample_num  sample
0         1          1          0   -0.49
1         1          2          0   -0.28
2         1          3          0   -0.52
3         2          1          0    1.23
4         2          2          0    0.54
5         2          3          0   -2.18
6         1          1          1   -1.00
7         1          2          1    1.48
8         1          3          1   -1.84
9         2          1          1   -1.36
10        2          2          1    0.18
11        2          3          1   -0.13
12        1          1          2    0.44
13        1          2          2    2.01
14        1          3          2    0.02
15        2          1          2   -1.06
16        2          2          2    0.51
17        2          3          2   -1.35

अंतिम, यदि आपको आवश्यकता है तो आप पहले तीन कॉलमों के आधार को छाँट सकते हैं।

— behzad.nouri
स्रोत
1
यह केवल तभी काम करता है जब आप एक प्राथमिकता जानते हैं कि सूचियों की लंबाई क्या होगी और / या यदि वे सभी की लंबाई समान होगी?
— Chill2Macht
9

इसे बेहतर ढंग से समझने के लिए रोमन पाकर के समाधान चरण-दर-चरण के माध्यम से काम करने की कोशिश करते हुए, मैं अपने स्वयं के समाधान के साथ आया, जो meltकुछ भ्रमित स्टैकिंग और इंडेक्स रीसेटिंग से बचने के लिए उपयोग करता है। मैं यह नहीं कह सकता कि यह स्पष्ट रूप से एक स्पष्ट समाधान है:

items_as_cols = df.apply(lambda x: pd.Series(x['samples']), axis=1)
# Keep original df index as a column so it's retained after melt
items_as_cols['orig_index'] = items_as_cols.index

melted_items = pd.melt(items_as_cols, id_vars='orig_index', 
                       var_name='sample_num', value_name='sample')
melted_items.set_index('orig_index', inplace=True)

df.merge(melted_items, left_index=True, right_index=True)

आउटपुट (जाहिर है कि हम अब मूल नमूने कॉलम को छोड़ सकते हैं):

                 samples  subject  trial_num sample_num  sample
0    [1.84, 1.05, -0.66]        1          1          0    1.84
0    [1.84, 1.05, -0.66]        1          1          1    1.05
0    [1.84, 1.05, -0.66]        1          1          2   -0.66
1    [-0.24, -0.9, 0.65]        1          2          0   -0.24
1    [-0.24, -0.9, 0.65]        1          2          1   -0.90
1    [-0.24, -0.9, 0.65]        1          2          2    0.65
2    [1.15, -0.87, -1.1]        1          3          0    1.15
2    [1.15, -0.87, -1.1]        1          3          1   -0.87
2    [1.15, -0.87, -1.1]        1          3          2   -1.10
3   [-0.8, -0.62, -0.68]        2          1          0   -0.80
3   [-0.8, -0.62, -0.68]        2          1          1   -0.62
3   [-0.8, -0.62, -0.68]        2          1          2   -0.68
4    [0.91, -0.47, 1.43]        2          2          0    0.91
4    [0.91, -0.47, 1.43]        2          2          1   -0.47
4    [0.91, -0.47, 1.43]        2          2          2    1.43
5  [-1.14, -0.24, -0.91]        2          3          0   -1.14
5  [-1.14, -0.24, -0.91]        2          3          1   -0.24
5  [-1.14, -0.24, -0.91]        2          3          2   -0.91
— मारिअस
स्रोत
6

रोमन पाइकर के उत्तर के एक संस्करण की तलाश करने वालों के लिए जो मैनुअल कॉलम के नामकरण से बचते हैं:

column_to_explode = 'samples'
res = (df
       .set_index([x for x in df.columns if x != column_to_explode])[column_to_explode]
       .apply(pd.Series)
       .stack()
       .reset_index())
res = res.rename(columns={
          res.columns[-2]:'exploded_{}_index'.format(column_to_explode),
          res.columns[-1]: '{}_exploded'.format(column_to_explode)})
— चार्ल्स डेविस
स्रोत
4

मैंने पाया कि सबसे आसान तरीका यह था:

  1. कन्वर्ट samplesएक DataFrame में स्तंभ
  2. मूल df के साथ जुड़ना
  3. गलन

यहाँ दिखाया गया है:

    df.samples.apply(lambda x: pd.Series(x)).join(df).\
melt(['subject','trial_num'],[0,1,2],var_name='sample')

        subject  trial_num sample  value
    0         1          1      0  -0.24
    1         1          2      0   0.14
    2         1          3      0  -0.67
    3         2          1      0  -1.52
    4         2          2      0  -0.00
    5         2          3      0  -1.73
    6         1          1      1  -0.70
    7         1          2      1  -0.70
    8         1          3      1  -0.29
    9         2          1      1  -0.70
    10        2          2      1  -0.72
    11        2          3      1   1.30
    12        1          1      2  -0.55
    13        1          2      2   0.10
    14        1          3      2  -0.44
    15        2          1      2   0.13
    16        2          2      2  -1.44
    17        2          3      2   0.73

यह ध्यान देने योग्य है कि यह केवल काम कर सकता है क्योंकि प्रत्येक परीक्षण में समान नमूनों की संख्या (3) है। विभिन्न नमूने आकारों के परीक्षणों के लिए कुछ अधिक चतुर आवश्यक हो सकता है।

— माइकल सिल्वरस्टीन
स्रोत
2

बहुत देर से जवाब लेकिन मैं इसे जोड़ना चाहता हूं:

वेनिला पायथन का उपयोग करते हुए एक तेज़ समाधान sample_numजो ओपी के उदाहरण में कॉलम का भी ध्यान रखता है । 10 मिलियन से अधिक पंक्तियों के साथ मेरे अपने बड़े डेटासेट पर और 28 मिलियन पंक्तियों के साथ परिणाम में केवल 38 सेकंड लगते हैं। स्वीकृत समाधान डेटा की मात्रा के साथ पूरी तरह से टूट जाता है और memory errorमेरे सिस्टम पर होता है जिसमें 128GB RAM होती है।

df = df.reset_index(drop=True)
lstcol = df.lstcol.values
lstcollist = []
indexlist = []
countlist = []
for ii in range(len(lstcol)):
    lstcollist.extend(lstcol[ii])
    indexlist.extend([ii]*len(lstcol[ii]))
    countlist.extend([jj for jj in range(len(lstcol[ii]))])
df = pd.merge(df.drop("lstcol",axis=1),pd.DataFrame({"lstcol":lstcollist,"lstcol_num":countlist},
index=indexlist),left_index=True,right_index=True).reset_index(drop=True)
— Khris
स्रोत
2

इसके अलावा बहुत देर से, लेकिन यहां कार्वी 1 का एक जवाब है जो मेरे लिए अच्छा काम करता है अगर आपके पास पांडा नहीं है = = 0.25 संस्करण: https://stackoverflow.com/a/52511166/10740287

ऊपर दिए गए उदाहरण के लिए आप लिख सकते हैं: 

data = [(row.subject, row.trial_num, sample) for row in df.itertuples() for sample in row.samples]
data = pd.DataFrame(data, columns=['subject', 'trial_num', 'samples'])

गति परीक्षण: 

%timeit data = pd.DataFrame([(row.subject, row.trial_num, sample) for row in df.itertuples() for sample in row.samples], columns=['subject', 'trial_num', 'samples'])

1.33 एमएस 33 74.8 ms प्रति लूप (मतलब dev एसटीडी। 7 रन का देव, प्रत्येक 1000 लूप)

%timeit data = df.set_index(['subject', 'trial_num'])['samples'].apply(pd.Series).stack().reset_index()

4.9 एमएस ± 189 (प्रति लूप (मतलब। एसटीडी। 7 रन का देवता, प्रत्येक 100 लूप)

%timeit data = pd.DataFrame({col:np.repeat(df[col].values, df['samples'].str.len())for col in df.columns.drop('samples')}).assign(**{'samples':np.concatenate(df['samples'].values)})

1.38 एमएस 38 25 (प्रति लूप (मतलब। एसटीडी। 7 रन का देव, 1000 लूप प्रत्येक)

— रेमी पीट्रेमैंड
स्रोत
1 
import pandas as pd
df = pd.DataFrame([{'Product': 'Coke', 'Prices': [100,123,101,105,99,94,98]},{'Product': 'Pepsi', 'Prices': [101,104,104,101,99,99,99]}])
print(df)
df = df.assign(Prices=df.Prices.str.split(',')).explode('Prices')
print(df)

पंडों में यह प्रयास करें = = 0.25 संस्करण

— तपस
स्रोत
1
इसके लिए कोई ज़रूरत नहीं है .str.split(',')क्योंकि Pricesपहले से ही एक सूची है।
— ओरेन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.