अपने लिए इस सवाल का जवाब देने की प्रक्रिया में, मैंने कई चीजें सीखीं, और मैं उदाहरणों और कुछ स्पष्टीकरणों की एक सूची बनाना चाहता था।
levelsतर्क के बिंदु पर विशिष्ट उत्तर समाप्ति की ओर आएगा।
pandas.concat: द मिसिंग मैनुअल
वर्तमान दस्तावेज़ के लिए लिंक
आयात और वस्तुओं को परिभाषित करना
import pandas as pd
d1 = pd.DataFrame(dict(A=.1, B=.2, C=.3), index=[2, 3])
d2 = pd.DataFrame(dict(B=.4, C=.5, D=.6), index=[1, 2])
d3 = pd.DataFrame(dict(A=.7, B=.8, D=.9), index=[1, 3])
s1 = pd.Series([1, 2], index=[2, 3])
s2 = pd.Series([3, 4], index=[1, 2])
s3 = pd.Series([5, 6], index=[1, 3])
तर्क
objs
हमारा पहला तर्क है objs:
objs : सीरीज़, डेटाफ़्रेम, या पैनल ऑब्जेक्ट्स का एक अनुक्रम या मानचित्रण यदि एक तानाशाही पारित किया जाता है, तो सॉर्ट किए गए कुंजियों को कुंजी तर्क के रूप में उपयोग किया जाएगा, जब तक कि इसे पारित नहीं किया जाता है, जिस स्थिति में मूल्यों का चयन किया जाएगा (नीचे देखें)। जब तक वे सभी नहीं हैं, तब तक किसी भी वस्तु को चुपचाप नहीं गिराया जाएगा, इस मामले में एक वैल्यूएयर उठाया जाएगा
- हम आम तौर पर इसका उपयोग सूची
Seriesया DataFrameवस्तुओं की सूची के साथ करते हैं।
- मैं दिखाता हूं कि
dictयह बहुत उपयोगी हो सकता है।
- जेनरेटर का उपयोग भी किया जा सकता है और उपयोग के दौरान उपयोगी हो सकता
mapहैmap(f, list_of_df)
अभी के लिए, हम ऊपर बताई गई कुछ DataFrameऔर Seriesवस्तुओं की सूची से चिपके रहेंगे । मैं बताता हूं कि MultiIndexबाद में बहुत उपयोगी परिणाम देने के लिए शब्दकोशों का कैसे लाभ उठाया जा सकता है ।
pd.concat([d1, d2])
A B C D
2 0.1 0.2 0.3 NaN
3 0.1 0.2 0.3 NaN
1 NaN 0.4 0.5 0.6
2 NaN 0.4 0.5 0.6
axis
दूसरा तर्क axisजिसका हम सामना करते हैं वह है 0:
अक्ष : {0 / 'इंडेक्स', 1 / 'कॉलम'}, डिफॉल्ट 0 अक्ष को साथ ले जाने के लिए।
दो के DataFrameसाथ axis=0(ढेर)
0या indexहमारे कहने के मानों के लिए: "स्तंभों को संरेखित करें और सूचकांक में जोड़ें"।
जैसा कि हमने बताया कि हमने कहाँ उपयोग किया है axis=0, क्योंकि 0डिफ़ॉल्ट मान है, और हम देखते हैं कि मूल्य के ओवरलैप होने d2के d1बावजूद सूचकांक का विस्तार होता है 2:
pd.concat([d1, d2], axis=0)
A B C D
2 0.1 0.2 0.3 NaN
3 0.1 0.2 0.3 NaN
1 NaN 0.4 0.5 0.6
2 NaN 0.4 0.5 0.6
दो DataFrameएस axis=1( साथ-साथ )
मानों के लिए 1या columnsहमारे कहने का अर्थ है: "सूचकांक के साथ संरेखित करें और कॉलम में जोड़ें", "
pd.concat([d1, d2], axis=1)
A B C B C D
1 NaN NaN NaN 0.4 0.5 0.6
2 0.1 0.2 0.3 0.4 0.5 0.6
3 0.1 0.2 0.3 NaN NaN NaN
हम देख सकते हैं कि परिणामी सूचकांक सूचकांकों का संघ है और परिणामस्वरूप स्तंभों के स्तंभों से स्तंभों का विस्तार d1है d2।
दो (या तीन) Seriesके साथ axis=0(खड़ी)
pandas.Seriesसाथ संयोजन करते समय axis=0, हम वापस आ जाते हैं pandas.Series। परिणामी का नाम तब तक Seriesरहेगा Noneजब तक कि सभी Seriesको एक ही नाम न मिला हो। 'Name: A'जब हम परिणाम का प्रिंट आउट करते हैं तो ध्यान दें Series। जब यह मौजूद नहीं है, तो हम मान सकते हैं कि Seriesनाम है None।
| | | pd.concat(
| pd.concat( | pd.concat( | [s1.rename('A'),
pd.concat( | [s1.rename('A'), | [s1.rename('A'), | s2.rename('B'),
[s1, s2]) | s2]) | s2.rename('A')]) | s3.rename('A')])
-------------- | --------------------- | ---------------------- | ----------------------
2 1 | 2 1 | 2 1 | 2 1
3 2 | 3 2 | 3 2 | 3 2
1 3 | 1 3 | 1 3 | 1 3
2 4 | 2 4 | 2 4 | 2 4
dtype: int64 | dtype: int64 | Name: A, dtype: int64 | 1 5
| | | 3 6
| | | dtype: int64
दो (या तीन) के Seriesसाथ axis=1(कंधे से कंधा मिलाकर)
pandas.Seriesसाथ संयोजन करते समय axis=1, यह वह nameविशेषता है जिसे हम परिणाम में एक कॉलम नाम का अनुमान लगाने के लिए संदर्भित करते हैं pandas.DataFrame।
| | pd.concat(
| pd.concat( | [s1.rename('X'),
pd.concat( | [s1.rename('X'), | s2.rename('Y'),
[s1, s2], axis=1) | s2], axis=1) | s3.rename('Z')], axis=1)
---------------------- | --------------------- | ------------------------------
0 1 | X 0 | X Y Z
1 NaN 3.0 | 1 NaN 3.0 | 1 NaN 3.0 5.0
2 1.0 4.0 | 2 1.0 4.0 | 2 1.0 4.0 NaN
3 2.0 NaN | 3 2.0 NaN | 3 2.0 NaN 6.0
मिश्रित Seriesऔर DataFrameसाथ axis=0(ढेर)
जब एक साथ Seriesऔर DataFrameसाथ का प्रदर्शन करते हैं axis=0, तो हम सभी Seriesको एकल कॉलम DataFrames में परिवर्तित करते हैं ।
विशेष ध्यान रखें कि यह एक संगति है axis=0; इसका मतलब है कि कॉलम संरेखित करते समय सूचकांक (पंक्तियों) का विस्तार करना। नीचे दिए गए उदाहरणों में, हम देखते हैं कि सूचकांक बन जाता है [2, 3, 2, 3]जो सूचकांकों का अंधाधुंध मिश्रण है। जब तक मैं Seriesइस तर्क के साथ कॉलम के नामकरण को बल नहीं देता, तब तक कॉलम ओवरलैप नहीं होता है to_frame:
pd.concat( |
[s1.to_frame(), d1]) | pd.concat([s1, d1])
------------------------- | ---------------------
0 A B C | 0 A B C
2 1.0 NaN NaN NaN | 2 1.0 NaN NaN NaN
3 2.0 NaN NaN NaN | 3 2.0 NaN NaN NaN
2 NaN 0.1 0.2 0.3 | 2 NaN 0.1 0.2 0.3
3 NaN 0.1 0.2 0.3 | 3 NaN 0.1 0.2 0.3
आप देख सकते हैं कि परिणाम pd.concat([s1, d1])उसी तरह हैं जैसे मैंने to_frameखुद को सुगंधित किया था ।
हालाँकि, मैं एक पैरामीटर के साथ परिणामी कॉलम के नाम को नियंत्रित कर सकता हूं to_frame। विधि के Seriesसाथ नाम बदलना परिणाम में कॉलम नाम को नियंत्रित नहींrename करता है ।DataFrame
# Effectively renames | |
# `s1` but does not align | # Does not rename. So | # Renames to something
# with columns in `d1` | # Pandas defaults to `0` | # that does align with `d1`
pd.concat( | pd.concat( | pd.concat(
[s1.to_frame('X'), d1]) | [s1.rename('X'), d1]) | [s1.to_frame('B'), d1])
---------------------------- | -------------------------- | ----------------------------
A B C X | 0 A B C | A B C
2 NaN NaN NaN 1.0 | 2 1.0 NaN NaN NaN | 2 NaN 1.0 NaN
3 NaN NaN NaN 2.0 | 3 2.0 NaN NaN NaN | 3 NaN 2.0 NaN
2 0.1 0.2 0.3 NaN | 2 NaN 0.1 0.2 0.3 | 2 0.1 0.2 0.3
3 0.1 0.2 0.3 NaN | 3 NaN 0.1 0.2 0.3 | 3 0.1 0.2 0.3
मिश्रित Seriesऔर DataFrameसाथ axis=1( साथ - साथ )
यह काफी सहज है। Seriesस्तंभ का नाम ऐसी Seriesवस्तुओं की गणना करने के लिए चूक करता है जब एक nameविशेषता उपलब्ध नहीं होती है।
| pd.concat(
pd.concat( | [s1.rename('X'),
[s1, d1], | s2, s3, d1],
axis=1) | axis=1)
------------------- | -------------------------------
0 A B C | X 0 1 A B C
2 1 0.1 0.2 0.3 | 1 NaN 3.0 5.0 NaN NaN NaN
3 2 0.1 0.2 0.3 | 2 1.0 4.0 NaN 0.1 0.2 0.3
| 3 2.0 NaN 6.0 0.1 0.2 0.3
join
तीसरा तर्क यह है joinकि वर्णन करता है कि परिणामी मर्ज एक बाहरी मर्ज (डिफ़ॉल्ट) या एक आंतरिक मर्ज होना चाहिए।
शामिल हों : {'भीतर', 'बाहरी'}, डिफ़ॉल्ट 'बाहरी'
अन्य अक्ष पर अनुक्रमणिका को कैसे संभालना है (तों)।
यह पता चला है, कोई विकल्प leftया rightविकल्प नहीं है क्योंकि pd.concatविलय करने के लिए सिर्फ दो वस्तुओं से अधिक संभाल सकता है।
के मामले में d1और d2, विकल्प की तरह लग रहे:
outer
pd.concat([d1, d2], axis=1, join='outer')
A B C B C D
1 NaN NaN NaN 0.4 0.5 0.6
2 0.1 0.2 0.3 0.4 0.5 0.6
3 0.1 0.2 0.3 NaN NaN NaN
inner
pd.concat([d1, d2], axis=1, join='inner')
A B C B C D
2 0.1 0.2 0.3 0.4 0.5 0.6
join_axes
चौथा तर्क वह चीज है जो हमें हमारे leftमर्ज और अधिक करने की अनुमति देता है ।
join_axes : इंडेक्स ऑब्जेक्ट्स की सूची
अन्य n - 1 एक्सिस के लिए उपयोग करने के लिए विशिष्ट इंडेक्स आंतरिक / बाहरी सेट तर्क प्रदर्शन करने के बजाय।
मर्ज छोड़ दिया
pd.concat([d1, d2, d3], axis=1, join_axes=[d1.index])
A B C B C D A B D
2 0.1 0.2 0.3 0.4 0.5 0.6 NaN NaN NaN
3 0.1 0.2 0.3 NaN NaN NaN 0.7 0.8 0.9
सही मर्ज
pd.concat([d1, d2, d3], axis=1, join_axes=[d3.index])
A B C B C D A B D
1 NaN NaN NaN 0.4 0.5 0.6 0.7 0.8 0.9
3 0.1 0.2 0.3 NaN NaN NaN 0.7 0.8 0.9
ignore_index
ign_index : बूलियन, डिफ़ॉल्ट गलत
यदि सही है, तो अनुक्रमण अक्ष के साथ सूचकांक मूल्यों का उपयोग न करें। परिणामी अक्ष को 0, ..., n - 1 के रूप में लेबल किया जाएगा। यह तब उपयोगी होता है जब आप उन वस्तुओं को समेट रहे होते हैं, जहां संघनन अक्ष में सार्थक अनुक्रमण जानकारी नहीं होती है। नोट करें कि अन्य अक्षों पर सूचकांक मान अभी भी जुड़ने में सम्मानित हैं।
जैसे जब मैं d1शीर्ष पर ढेर करता हूं d2, अगर मैं सूचकांक मूल्यों के बारे में परवाह नहीं करता हूं, तो मैं उन्हें रीसेट कर सकता हूं या उन्हें अनदेखा कर सकता हूं।
| pd.concat( | pd.concat(
| [d1, d2], | [d1, d2]
pd.concat([d1, d2]) | ignore_index=True) | ).reset_index(drop=True)
--------------------- | ----------------------- | -------------------------
A B C D | A B C D | A B C D
2 0.1 0.2 0.3 NaN | 0 0.1 0.2 0.3 NaN | 0 0.1 0.2 0.3 NaN
3 0.1 0.2 0.3 NaN | 1 0.1 0.2 0.3 NaN | 1 0.1 0.2 0.3 NaN
1 NaN 0.4 0.5 0.6 | 2 NaN 0.4 0.5 0.6 | 2 NaN 0.4 0.5 0.6
2 NaN 0.4 0.5 0.6 | 3 NaN 0.4 0.5 0.6 | 3 NaN 0.4 0.5 0.6
और उपयोग करते समय axis=1:
| pd.concat(
| [d1, d2], axis=1,
pd.concat([d1, d2], axis=1) | ignore_index=True)
------------------------------- | -------------------------------
A B C B C D | 0 1 2 3 4 5
1 NaN NaN NaN 0.4 0.5 0.6 | 1 NaN NaN NaN 0.4 0.5 0.6
2 0.1 0.2 0.3 0.4 0.5 0.6 | 2 0.1 0.2 0.3 0.4 0.5 0.6
3 0.1 0.2 0.3 NaN NaN NaN | 3 0.1 0.2 0.3 NaN NaN NaN
keys
हम इसी MultiIndex के लिए tuple या scalar मान निर्दिष्ट करने के लिए अदिश मान या tuples की सूची पास कर सकते हैं। उत्तीर्ण सूची की लंबाई समान होनी चाहिए क्योंकि मदों की संख्या समाप्त हो रही है।
कुंजियाँ : अनुक्रम, डिफ़ॉल्ट कोई नहीं
यदि कई स्तर पास हुए, तो टुपल्स होने चाहिए। सबसे ऊपरी स्तर के रूप में पारित कुंजियों का उपयोग करके पदानुक्रमित सूचकांक का निर्माण करें
axis=0
जब समवर्ती Seriesवस्तुओं को साथ axis=0(सूचकांक को बढ़ाते हुए)।
उन कुंजियों, MultiIndexसूचकांक विशेषता में एक वस्तु का एक नया प्रारंभिक स्तर बन जाता है ।
# length 3 length 3 # length 2 length 2
# /--------\ /-----------\ # /----\ /------\
pd.concat([s1, s2, s3], keys=['A', 'B', 'C']) pd.concat([s1, s2], keys=['A', 'B'])
---------------------------------------------- -------------------------------------
A 2 1 A 2 1
3 2 3 2
B 1 3 B 1 3
2 4 2 4
C 1 5 dtype: int64
3 6
dtype: int64
हालाँकि, हम और keysभी गहरे बनाने के तर्क में स्केलर मानों से अधिक का उपयोग कर सकते हैं MultiIndex। यहाँ हम पारित tuplesलंबाई 2 आगे जोड़ते एक के दो नए स्तरों के MultiIndex:
pd.concat(
[s1, s2, s3],
keys=[('A', 'X'), ('A', 'Y'), ('B', 'X')])
-----------------------------------------------
A X 2 1
3 2
Y 1 3
2 4
B X 1 5
3 6
dtype: int64
axis=1
कॉलम के साथ विस्तार करते समय यह थोड़ा अलग होता है। जब हमने प्रयोग किया axis=0(ऊपर देखें) मौजूदा सूचकांक के अलावा हमारे स्तर के keysरूप MultiIndexमें कार्य किया । के लिए axis=1, हम एक अक्ष का उल्लेख कर रहे हैं जो Seriesऑब्जेक्ट्स के पास नहीं है, अर्थात् columnsविशेषता।
दो
Serieswtih की विविधता
axis=1
ध्यान दें कि नामकरण s1और s2मायने रखता है जब तक कोई keysपारित नहीं किया जाता है, लेकिन इसे keysपारित होने पर ओवरराइड हो जाता है ।
| | | pd.concat(
| pd.concat( | pd.concat( | [s1.rename('U'),
pd.concat( | [s1, s2], | [s1.rename('U'), | s2.rename('V')],
[s1, s2], | axis=1, | s2.rename('V')], | axis=1,
axis=1) | keys=['X', 'Y']) | axis=1) | keys=['X', 'Y'])
-------------- | --------------------- | ---------------------- | ----------------------
0 1 | X Y | U V | X Y
1 NaN 3.0 | 1 NaN 3.0 | 1 NaN 3.0 | 1 NaN 3.0
2 1.0 4.0 | 2 1.0 4.0 | 2 1.0 4.0 | 2 1.0 4.0
3 2.0 NaN | 3 2.0 NaN | 3 2.0 NaN | 3 2.0 NaN
MultiIndexके साथ
Seriesऔर
axis=1
pd.concat(
[s1, s2],
axis=1,
keys=[('W', 'X'), ('W', 'Y')])
-----------------------------------
W
X Y
1 NaN 3.0
2 1.0 4.0
3 2.0 NaN
दो के
DataFrameसाथ
axis=1
axis=0उदाहरणों के साथ , keysए में स्तर जोड़ते हैं MultiIndex, लेकिन इस बार columnsविशेषता में संग्रहीत ऑब्जेक्ट पर ।
pd.concat( | pd.concat(
[d1, d2], | [d1, d2],
axis=1, | axis=1,
keys=['X', 'Y']) | keys=[('First', 'X'), ('Second', 'X')])
------------------------------- | --------------------------------------------
X Y | First Second
A B C B C D | X X
1 NaN NaN NaN 0.4 0.5 0.6 | A B C B C D
2 0.1 0.2 0.3 0.4 0.5 0.6 | 1 NaN NaN NaN 0.4 0.5 0.6
3 0.1 0.2 0.3 NaN NaN NaN | 2 0.1 0.2 0.3 0.4 0.5 0.6
| 3 0.1 0.2 0.3 NaN NaN NaN
Seriesऔर के
DataFrameसाथ
axis=1
यह मुश्किल है। इस स्थिति में, एक स्केलर कुंजी मान Seriesऑब्जेक्ट के लिए अनुक्रमणिका के एकमात्र स्तर के रूप में कार्य नहीं कर सकता है जब यह एक स्तंभ बन जाता है, जबकि इसके लिए पहले स्तर के रूप में भी कार्य करता MultiIndexहै DataFrame। इसलिए पांडव फिर से स्तंभ नाम के स्रोत के रूप में वस्तु की nameविशेषता का उपयोग Seriesकरेंगे।
pd.concat( | pd.concat(
[s1, d1], | [s1.rename('Z'), d1],
axis=1, | axis=1,
keys=['X', 'Y']) | keys=['X', 'Y'])
--------------------- | --------------------------
X Y | X Y
0 A B C | Z A B C
2 1 0.1 0.2 0.3 | 2 1 0.1 0.2 0.3
3 2 0.1 0.2 0.3 | 3 2 0.1 0.2 0.3
keysऔर
MultiIndexबांझपन
की सीमा ।
पंडों को केवल नाम से स्तंभ नामों का अनुमान लगता है Series, लेकिन यह कॉलम के विभिन्न स्तरों के साथ डेटा फ़्रेमों के बीच एक अनुरूप संयोजन करते समय रिक्त स्थान को नहीं भरेगा।
d1_ = pd.concat(
[d1], axis=1,
keys=['One'])
d1_
One
A B C
2 0.1 0.2 0.3
3 0.1 0.2 0.3
फिर कॉलम ऑब्जेक्ट में केवल एक स्तर के साथ एक और डेटा फ़्रेम के साथ इसे संक्षिप्त करें और पांडस MultiIndexऑब्जेक्ट के ट्यूपल्स बनाने और प्रयास करने से इनकार करेंगे और सभी डेटा फ़्रेमों को संयोजित करेंगे जैसे कि ऑब्जेक्ट्स, स्केलर्स और ट्यूपल्स का एकल स्तर।
pd.concat([d1_, d2], axis=1)
(One, A) (One, B) (One, C) B C D
1 NaN NaN NaN 0.4 0.5 0.6
2 0.1 0.2 0.3 0.4 0.5 0.6
3 0.1 0.2 0.3 NaN NaN NaN
के dictबजाय एक गुजर रहा हैlist
शब्दकोश पारित करते समय, पैरामीटर के pandas.concatरूप में शब्दकोश से कुंजियों का उपयोग करेंगे keys।
# axis=0 | # axis=1
pd.concat( | pd.concat(
{0: d1, 1: d2}) | {0: d1, 1: d2}, axis=1)
----------------------- | -------------------------------
A B C D | 0 1
0 2 0.1 0.2 0.3 NaN | A B C B C D
3 0.1 0.2 0.3 NaN | 1 NaN NaN NaN 0.4 0.5 0.6
1 1 NaN 0.4 0.5 0.6 | 2 0.1 0.2 0.3 0.4 0.5 0.6
2 NaN 0.4 0.5 0.6 | 3 0.1 0.2 0.3 NaN NaN NaN
levels
इसका उपयोग keysतर्क के साथ संयोजन के रूप में किया जाता है। levelsजब इसके डिफ़ॉल्ट मान के रूप में छोड़ दिया जाता है None, तो पंडस परिणाम के प्रत्येक स्तर के अनूठे मूल्यों को ले जाएगा MultiIndexऔर उपयोग में लाए गए ऑब्जेक्ट के रूप में उपयोग करेगा index.levels।
स्तर : अनुक्रमों की सूची,
मल्टीएंडेक्स के निर्माण के लिए उपयोग करने के लिए डिफ़ॉल्ट कोई भी विशिष्ट स्तर (अद्वितीय मान) नहीं है। अन्यथा वे कुंजियों से हीन हो जाएंगे।
यदि पंडों ने पहले से ही इन स्तरों को प्रभावित किया है, तो इसे स्वयं निर्दिष्ट करने के लिए क्या लाभ है? मैं एक उदाहरण दिखाऊंगा और इसे छोड़ कर आप अन्य कारणों पर विचार करूंगा कि यह उपयोगी क्यों हो सकता है।
उदाहरण
प्रलेखन के अनुसार, levelsतर्क अनुक्रमों की एक सूची है। इसका मतलब है कि हम pandas.Indexउन दृश्यों में से एक के रूप में दूसरे का उपयोग कर सकते हैं ।
उस डेटा फ़्रेम पर विचार करें जो dfकि का संघटन है d1, d2और d3:
df = pd.concat(
[d1, d2, d3], axis=1,
keys=['First', 'Second', 'Fourth'])
df
First Second Fourth
A B C B C D A B D
1 NaN NaN NaN 0.4 0.5 0.6 0.7 0.8 0.9
2 0.1 0.2 0.3 0.4 0.5 0.6 NaN NaN NaN
3 0.1 0.2 0.3 NaN NaN NaN 0.7 0.8 0.9
कॉलम ऑब्जेक्ट के स्तर हैं:
print(df, *df.columns.levels, sep='\n')
Index(['First', 'Second', 'Fourth'], dtype='object')
Index(['A', 'B', 'C', 'D'], dtype='object')
अगर हम उपयोग करते sumहैं groupbyतो हम प्राप्त करते हैं:
df.groupby(axis=1, level=0).sum()
First Fourth Second
1 0.0 2.4 1.5
2 0.6 0.0 1.5
3 0.6 2.4 0.0
लेकिन क्या होगा अगर इसके बजाय ['First', 'Second', 'Fourth']एक और लापता श्रेणियों का नाम दिया गया है Thirdऔर Fifth? और मैं उन्हें एक groupbyएकत्रीकरण के परिणामों में शामिल करना चाहता था ? हम ऐसा कर सकते हैं अगर हमारे पास ए pandas.CategoricalIndex। और हम levelsतर्क के साथ समय से पहले निर्दिष्ट कर सकते हैं ।
इसलिए इसके बजाय, आइए परिभाषित करें df:
cats = ['First', 'Second', 'Third', 'Fourth', 'Fifth']
lvl = pd.CategoricalIndex(cats, categories=cats, ordered=True)
df = pd.concat(
[d1, d2, d3], axis=1,
keys=['First', 'Second', 'Fourth'],
levels=[lvl]
)
df
First Fourth Second
1 0.0 2.4 1.5
2 0.6 0.0 1.5
3 0.6 2.4 0.0
लेकिन कॉलम ऑब्जेक्ट का पहला स्तर है:
df.columns.levels[0]
CategoricalIndex(
['First', 'Second', 'Third', 'Fourth', 'Fifth'],
categories=['First', 'Second', 'Third', 'Fourth', 'Fifth'],
ordered=True, dtype='category')
और हमारा groupbyयोग ऐसा दिखता है:
df.groupby(axis=1, level=0).sum()
First Second Third Fourth Fifth
1 0.0 1.5 0.0 2.4 0.0
2 0.6 1.5 0.0 0.0 0.0
3 0.6 0.0 0.0 2.4 0.0
names
इसका उपयोग परिणाम के स्तरों को नाम देने के लिए किया जाता है MultiIndex। namesसूची की लंबाई परिणाम में स्तरों की संख्या से मेल खाना चाहिए MultiIndex।
नाम : सूची, डिफ़ॉल्ट कोई भी
नाम जिसके परिणामस्वरूप पदानुक्रमित सूचकांक में स्तरों के लिए
# axis=0 | # axis=1
pd.concat( | pd.concat(
[d1, d2], | [d1, d2],
keys=[0, 1], | axis=1, keys=[0, 1],
names=['lvl0', 'lvl1']) | names=['lvl0', 'lvl1'])
----------------------------- | ----------------------------------
A B C D | lvl0 0 1
lvl0 lvl1 | lvl1 A B C B C D
0 2 0.1 0.2 0.3 NaN | 1 NaN NaN NaN 0.4 0.5 0.6
3 0.1 0.2 0.3 NaN | 2 0.1 0.2 0.3 0.4 0.5 0.6
1 1 NaN 0.4 0.5 0.6 | 3 0.1 0.2 0.3 NaN NaN NaN
2 NaN 0.4 0.5 0.6 |
verify_integrity
स्व व्याख्यात्मक प्रलेखन
Ver_integrity : बूलियन, डिफ़ॉल्ट गलत
जाँचें कि क्या नए संघटित अक्ष में डुप्लिकेट हैं। यह वास्तविक डेटा संगति के सापेक्ष बहुत महंगा हो सकता है।
क्योंकि परिणामी अनुक्रमण से परिणामी d1और d2अद्वितीय नहीं है, यह अखंडता की जांच में विफल होगा।
pd.concat([d1, d2])
A B C D
2 0.1 0.2 0.3 NaN
3 0.1 0.2 0.3 NaN
1 NaN 0.4 0.5 0.6
2 NaN 0.4 0.5 0.6
तथा
pd.concat([d1, d2], verify_integrity=True)
> मूल्य: सूचकांक में अतिव्यापी मूल्य हैं: [२]