pandas 0.23 - pandas.wide_to_long()

pandas.wide_to_long




pandas

pandas.wide_to_long

pandas.wide_to_long(df, stubnames, i, j, sep='', suffix='\\d+') [source]

चौड़े पैनल लंबे प्रारूप के लिए। कम लचीला लेकिन पिघल की तुलना में अधिक उपयोगकर्ता के अनुकूल।

Stubnames ['A', 'B'] के साथ, यह फ़ंक्शन फॉर्मेट Asuffix1, Asuffix2,…, Bsuffix1, Bsuffix2,… के साथ कॉलम के एक या अधिक समूह को खोजने की उम्मीद करता है… j साथ (उदाहरण के लिए j='year' )

इन चौड़े चरों की प्रत्येक पंक्ति को विशिष्ट रूप से i से पहचाना जाता है (एकल स्तंभ नाम या स्तंभ नामों की सूची हो सकती है)

डेटा फ्रेम में शेष सभी चर बरकरार हैं।

पैरामीटर:

df : DataFrame

विस्तृत प्रारूप DataFrame

stubnames : str या list-like

ठूंठ का नाम। विस्तृत प्रारूप चर को स्टब नामों के साथ शुरू करने के लिए माना जाता है।

i : str या लिस्ट-लाइक

आईडी के रूप में उपयोग करने के लिए कॉलम (एस)

j : str

उपसमूह चर का नाम। आप लंबे प्रारूप में अपने प्रत्यय का नाम क्या चाहते हैं।

sep : str, डिफ़ॉल्ट ""

एक वर्ण जो विस्तृत प्रारूप में चर नामों को अलग करने का संकेत देता है, दीर्घ प्रारूप में नामों से छीन लिया जाता है। उदाहरण के लिए, यदि आपके कॉलम के नाम A-प्रत्यय 1, A-प्रत्यय 2 हैं, तो आप sep='-' निर्दिष्ट करके हाइफ़न को हटा सकते हैं

संस्करण में नया 0.20.0।

प्रत्यय : str, डिफ़ॉल्ट 'd +'

वांछित प्रत्ययों को पकड़ने वाला एक नियमित अभिव्यक्ति। '\ d +' संख्यात्मक प्रत्ययों को पकड़ता है। बिना किसी संख्या वाले प्रत्ययों को नकारात्मक चरित्र वर्ग '\ D +' के साथ निर्दिष्ट नहीं किया जा सकता है। उदाहरण के लिए, आप प्रत्ययों की संख्या को और भी कम कर सकते हैं, यदि आपके विस्तृत चर एओन, बीटवो, .. के रूप में हैं, और आपके पास एक असंबंधित कॉलम है Arating, तो आप suffix='(!?one|two)' निर्दिष्ट करके पिछले एक को अनदेखा कर सकते हैं suffix='(!?one|two)'

संस्करण में नया 0.20.0।

संस्करण में परिवर्तित किया गया 0.23.0: जब सभी प्रत्यय संख्यात्मक होते हैं, तो उन्हें int64 / float64 पर डाला जाता है।

यह दिखाता है:

डेटा ढांचा

एक डेटाफ़्रेम जिसमें प्रत्येक स्टब का नाम एक चर के रूप में होता है, नए सूचकांक (i, j) के साथ

टिप्पणियाँ

सभी अतिरिक्त चर अछूते रह गए हैं। यह केवल हुड के नीचे pandas.melt का उपयोग करता है, लेकिन एक विशिष्ट मामले में "सही काम करने के लिए" कठिन-कोडित है।

उदाहरण

>>> import pandas as pd
>>> import numpy as np
>>> np.random.seed(123)
>>> df = pd.DataFrame({"A1970" : {0 : "a", 1 : "b", 2 : "c"},
...                    "A1980" : {0 : "d", 1 : "e", 2 : "f"},
...                    "B1970" : {0 : 2.5, 1 : 1.2, 2 : .7},
...                    "B1980" : {0 : 3.2, 1 : 1.3, 2 : .1},
...                    "X"     : dict(zip(range(3), np.random.randn(3)))
...                   })
>>> df["id"] = df.index
>>> df
  A1970 A1980  B1970  B1980         X  id
0     a     d    2.5    3.2 -1.085631   0
1     b     e    1.2    1.3  0.997345   1
2     c     f    0.7    0.1  0.282978   2
>>> pd.wide_to_long(df, ["A", "B"], i="id", j="year")
... 
                X  A    B
id year
0  1970 -1.085631  a  2.5
1  1970  0.997345  b  1.2
2  1970  0.282978  c  0.7
0  1980 -1.085631  d  3.2
1  1980  0.997345  e  1.3
2  1980  0.282978  f  0.1

मल्टीपल आईडी कॉलम के साथ

>>> df = pd.DataFrame({
...     'famid': [1, 1, 1, 2, 2, 2, 3, 3, 3],
...     'birth': [1, 2, 3, 1, 2, 3, 1, 2, 3],
...     'ht1': [2.8, 2.9, 2.2, 2, 1.8, 1.9, 2.2, 2.3, 2.1],
...     'ht2': [3.4, 3.8, 2.9, 3.2, 2.8, 2.4, 3.3, 3.4, 2.9]
... })
>>> df
   birth  famid  ht1  ht2
0      1      1  2.8  3.4
1      2      1  2.9  3.8
2      3      1  2.2  2.9
3      1      2  2.0  3.2
4      2      2  1.8  2.8
5      3      2  1.9  2.4
6      1      3  2.2  3.3
7      2      3  2.3  3.4
8      3      3  2.1  2.9
>>> l = pd.wide_to_long(df, stubnames='ht', i=['famid', 'birth'], j='age')
>>> l
... 
                  ht
famid birth age
1     1     1    2.8
            2    3.4
      2     1    2.9
            2    3.8
      3     1    2.2
            2    2.9
2     1     1    2.0
            2    3.2
      2     1    1.8
            2    2.8
      3     1    1.9
            2    2.4
3     1     1    2.2
            2    3.3
      2     1    2.3
            2    3.4
      3     1    2.1
            2    2.9

लंबे समय से पीछे की ओर जाने से बस कुछ unstack का रचनात्मक उपयोग unstack

>>> w = l.unstack()
>>> w.columns = w.columns.map('{0[0]}{0[1]}'.format)
>>> w.reset_index()
   famid  birth  ht1  ht2
0      1      1  2.8  3.4
1      1      2  2.9  3.8
2      1      3  2.2  2.9
3      2      1  2.0  3.2
4      2      2  1.8  2.8
5      2      3  1.9  2.4
6      3      1  2.2  3.3
7      3      2  2.3  3.4
8      3      3  2.1  2.9

कम फ़ील्ड वाले कॉलम नामों को भी नियंत्रित किया जाता है

>>> np.random.seed(0)
>>> df = pd.DataFrame({'A(quarterly)-2010': np.random.rand(3),
...                    'A(quarterly)-2011': np.random.rand(3),
...                    'B(quarterly)-2010': np.random.rand(3),
...                    'B(quarterly)-2011': np.random.rand(3),
...                    'X' : np.random.randint(3, size=3)})
>>> df['id'] = df.index
>>> df 
   A(quarterly)-2010  A(quarterly)-2011  B(quarterly)-2010  ...
0           0.548814           0.544883           0.437587  ...
1           0.715189           0.423655           0.891773  ...
2           0.602763           0.645894           0.963663  ...
   X  id
0  0   0
1  1   1
2  1   2
>>> pd.wide_to_long(df, ['A(quarterly)', 'B(quarterly)'], i='id',
...                 j='year', sep='-')
... 
         X  A(quarterly)  B(quarterly)
id year
0  2010  0      0.548814     0.437587
1  2010  1      0.715189     0.891773
2  2010  1      0.602763     0.963663
0  2011  0      0.544883     0.383442
1  2011  1      0.423655     0.791725
2  2011  1      0.645894     0.528895

यदि हमारे पास कई कॉलम हैं, तो हम अपने स्टब्नेम्स को खोजने के लिए एक regex का उपयोग भी कर सकते हैं और उस सूची को wide_to_long पर पास कर सकते हैं

>>> stubnames = sorted(
...     set([match[0] for match in df.columns.str.findall(
...         r'[A-B]\(.*\)').values if match != [] ])
... )
>>> list(stubnames)
['A(quarterly)', 'B(quarterly)']

उपरोक्त सभी उदाहरणों में प्रत्यय के रूप में पूर्णांक हैं। प्रत्यय के रूप में गैर-पूर्णांक होना संभव है।

>>> df = pd.DataFrame({
...     'famid': [1, 1, 1, 2, 2, 2, 3, 3, 3],
...     'birth': [1, 2, 3, 1, 2, 3, 1, 2, 3],
...     'ht_one': [2.8, 2.9, 2.2, 2, 1.8, 1.9, 2.2, 2.3, 2.1],
...     'ht_two': [3.4, 3.8, 2.9, 3.2, 2.8, 2.4, 3.3, 3.4, 2.9]
... })
>>> df
   birth  famid  ht_one  ht_two
0      1      1     2.8     3.4
1      2      1     2.9     3.8
2      3      1     2.2     2.9
3      1      2     2.0     3.2
4      2      2     1.8     2.8
5      3      2     1.9     2.4
6      1      3     2.2     3.3
7      2      3     2.3     3.4
8      3      3     2.1     2.9
>>> l = pd.wide_to_long(df, stubnames='ht', i=['famid', 'birth'], j='age',
                        sep='_', suffix='\w')
>>> l
... 
                  ht
famid birth age
1     1     one  2.8
            two  3.4
      2     one  2.9
            two  3.8
      3     one  2.2
            two  2.9
2     1     one  2.0
            two  3.2
      2     one  1.8
            two  2.8
      3     one  1.9
            two  2.4
3     1     one  2.2
            two  3.3
      2     one  2.3
            two  3.4
      3     one  2.1
            two  2.9