पंडों डेटाफ़्रेम / नेम्पी ऐरे "अक्ष" परिभाषा में अस्पष्टता

Question 1

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

>>> df = pd.DataFrame([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3]], columns=["col1", "col2", "col3", "col4"])
>>> df
   col1  col2  col3  col4
0     1     1     1     1
1     2     2     2     2
2     3     3     3     3

इसलिए अगर हम बुलाते हैं df.mean(axis=1) , पंक्तियों में एक मतलब मिलेगा:

>>> df.mean(axis=1)
0    1
1    2
2    3

हालांकि, अगर हम कॉल करते हैं df.drop(name, axis=1), तो हम वास्तव में एक कॉलम छोड़ते हैं , न कि एक पंक्ति:

>>> df.drop("col4", axis=1)
   col1  col2  col3
0     1     1     1
1     2     2     2
2     3     3     3

क्या कोई मुझे यह समझने में मदद कर सकता है कि पंडों / सुन्न / डांट में "अक्ष" से क्या मतलब है?

एक साइड नोट, DataFrame.meanबस गलत परिभाषित किया जा सकता है। यह दस्तावेज में कहते हैं के लिए DataFrame.meanहै कि axis=1कॉलम, नहीं पंक्तियों पर एक मतलब मतलब माना जाता है ...

Question 2

संभवतः इसे 0 = डाउन और 1 = पार के रूप में याद रखना सबसे सरल है ।

इसका मतलब है की:

axis=0प्रत्येक स्तंभ के नीचे, या पंक्ति लेबल (इंडेक्स) के लिए एक विधि लागू करने के लिए उपयोग करें ।
axis=1प्रत्येक पंक्ति में या स्तंभ लेबल पर एक विधि लागू करने के लिए उपयोग करें ।

डेटाफ्रैम के उन हिस्सों को दिखाने के लिए यहां एक तस्वीर दी गई है जो प्रत्येक अक्ष को संदर्भित करता है:

यह याद रखना भी उपयोगी है कि पंडों ने नुम्पी शब्द का उपयोग किया है axis। उपयोग को NumPy की शब्दावली में समझाया गया है :

अक्ष को एक से अधिक आयाम वाले सरणियों के लिए परिभाषित किया गया है। एक 2-आयामी सरणी में दो संगत कुल्हाड़ी होती हैं: पहली पंक्तियों में पूरी तरह से नीचे की ओर (अक्ष 0) , और दूसरी क्षैतिज रूप से कॉलम (अक्ष 1) के पार चलती है । [ मेरा जोर ]

इसलिए, प्रश्न में विधि के विषय में, df.mean(axis=1)सही ढंग से परिभाषित किया गया लगता है। यह स्तंभों में क्षैतिज रूप से प्रविष्टियों का मतलब लेता है, अर्थात् प्रत्येक व्यक्तिगत पंक्ति के साथ। दूसरी तरफ, पंक्तियों मेंdf.mean(axis=0) लंबवत नीचे की ओर एक ऑपरेशन होगा ।

इसी तरह, df.drop(name, axis=1)कॉलम लेबल पर एक कार्रवाई को संदर्भित करता है, क्योंकि वे सहजता से क्षैतिज अक्ष पर जाते हैं। निर्दिष्ट axis=0करने के बजाय पंक्तियों पर विधि कार्य करेगा।

Question 3

समझाने का दूसरा तरीका:

// Not realistic but ideal for understanding the axis parameter 
df = pd.DataFrame([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3]],
                  columns=["idx1", "idx2", "idx3", "idx4"],
                  index=["idx1", "idx2", "idx3"]
                 )

---------------------------------------1
|          idx1  idx2  idx3  idx4
|    idx1     1     1     1     1
|    idx2     2     2     2     2
|    idx3     3     3     3     3
0

के बारे में df.drop(अक्ष स्थिति का मतलब है)

A: I wanna remove idx3.
B: **Which one**? // typing while waiting response: df.drop("idx3",
A: The one which is on axis 1
B: OK then it is >> df.drop("idx3", axis=1)

// Result
---------------------------------------1
|          idx1  idx2     idx4
|    idx1     1     1     1
|    idx2     2     2     2
|    idx3     3     3     3
0

के बारे में df.apply(अक्ष का अर्थ है दिशा)

A: I wanna apply sum.
B: Which direction? // typing while waiting response: df.apply(lambda x: x.sum(),
A: The one which is on *parallel to axis 0*
B: OK then it is >> df.apply(lambda x: x.sum(), axis=0)

// Result
idx1    6
idx2    6
idx3    6
idx4    6

Question 4

पहले से ही उचित उत्तर हैं, लेकिन मैं आपको> 2 आयामों के साथ एक और उदाहरण देता हूं।

पैरामीटर का axisमतलब है अक्ष को बदलना ।
उदाहरण के लिए, विचार करें कि आयाम axbxc के साथ एक डेटाफ्रेम है ।

df.mean(axis=1)डायमेन्स्टियन कुल्हाड़ी 1 एक्ससी के साथ एक डेटाफ्रेम लौटाता है ।
df.drop("col4", axis=1)आयाम कुल्हाड़ी (बी -1) xc के साथ एक डेटाफ्रेम देता है ।

यहाँ, axis=1दूसरी धुरी का मतलब है b, इसलिए bइन उदाहरणों में मूल्य को बदल दिया जाएगा।

Question 5

यह अधिक व्यापक रूप से ज्ञात होना चाहिए कि स्ट्रिंग उपनाम 'सूचकांक' और 'कॉलम' का उपयोग पूर्णांक 0/1 के स्थान पर किया जा सकता है। उपनाम बहुत अधिक स्पष्ट हैं और मुझे याद रखने में मदद करते हैं कि गणना कैसे होती है। 'अनुक्रमणिका' के लिए एक अन्य उपनाम 'पंक्तियाँ' है ।

जब axis='index'उपयोग किया जाता है, तो गणना स्तंभों के नीचे होती है, जो भ्रामक है। लेकिन, मुझे याद है कि यह एक परिणाम के रूप में है जो दूसरी पंक्ति के समान आकार है।

आइए स्क्रीन पर कुछ डेटा देखें कि मैं किस बारे में बात कर रहा हूं:

df = pd.DataFrame(np.random.rand(10, 4), columns=list('abcd'))
          a         b         c         d
0  0.990730  0.567822  0.318174  0.122410
1  0.144962  0.718574  0.580569  0.582278
2  0.477151  0.907692  0.186276  0.342724
3  0.561043  0.122771  0.206819  0.904330
4  0.427413  0.186807  0.870504  0.878632
5  0.795392  0.658958  0.666026  0.262191
6  0.831404  0.011082  0.299811  0.906880
7  0.749729  0.564900  0.181627  0.211961
8  0.528308  0.394107  0.734904  0.961356
9  0.120508  0.656848  0.055749  0.290897

जब हम सभी स्तंभों का अर्थ लेना चाहते हैं, तो हम axis='index'निम्नलिखित प्राप्त करने के लिए उपयोग करते हैं:

df.mean(axis='index')
a    0.562664
b    0.478956
c    0.410046
d    0.546366
dtype: float64

एक ही परिणाम द्वारा प्राप्त किया जाएगा:

df.mean() # default is axis=0
df.mean(axis=0)
df.mean(axis='rows')

पंक्तियों पर दाएं से बाएं किसी ऑपरेशन का उपयोग करने के लिए, अक्ष = 'कॉलम' का उपयोग करें। मुझे यह सोचकर याद है कि मेरे DataFrame में एक अतिरिक्त कॉलम जोड़ा जा सकता है:

df.mean(axis='columns')
0    0.499784
1    0.506596
2    0.478461
3    0.448741
4    0.590839
5    0.595642
6    0.512294
7    0.427054
8    0.654669
9    0.281000
dtype: float64

एक ही परिणाम द्वारा प्राप्त किया जाएगा:

df.mean(axis=1)

अक्ष = 0 / सूचकांक / पंक्तियों के साथ एक नई पंक्ति जोड़ें

आइए स्पष्टीकरण को पूरा करने के लिए अतिरिक्त पंक्तियों या स्तंभों को जोड़ने के लिए इन परिणामों का उपयोग करें। इसलिए, जब भी अक्ष = 0 / सूचकांक / पंक्तियों का उपयोग किया जा रहा है, तो डेटाफ्रैम की एक नई पंक्ति प्राप्त करना पसंद है। आइए एक पंक्ति जोड़ें:

df.append(df.mean(axis='rows'), ignore_index=True)

           a         b         c         d
0   0.990730  0.567822  0.318174  0.122410
1   0.144962  0.718574  0.580569  0.582278
2   0.477151  0.907692  0.186276  0.342724
3   0.561043  0.122771  0.206819  0.904330
4   0.427413  0.186807  0.870504  0.878632
5   0.795392  0.658958  0.666026  0.262191
6   0.831404  0.011082  0.299811  0.906880
7   0.749729  0.564900  0.181627  0.211961
8   0.528308  0.394107  0.734904  0.961356
9   0.120508  0.656848  0.055749  0.290897
10  0.562664  0.478956  0.410046  0.546366

अक्ष = 1 / कॉलम के साथ एक नया स्तंभ जोड़ें

इसी तरह, जब धुरी = 1 / कॉलम यह ऐसा डेटा बनाएगा जिसे आसानी से अपने कॉलम में बनाया जा सकता है:

df.assign(e=df.mean(axis='columns'))

          a         b         c         d         e
0  0.990730  0.567822  0.318174  0.122410  0.499784
1  0.144962  0.718574  0.580569  0.582278  0.506596
2  0.477151  0.907692  0.186276  0.342724  0.478461
3  0.561043  0.122771  0.206819  0.904330  0.448741
4  0.427413  0.186807  0.870504  0.878632  0.590839
5  0.795392  0.658958  0.666026  0.262191  0.595642
6  0.831404  0.011082  0.299811  0.906880  0.512294
7  0.749729  0.564900  0.181627  0.211961  0.427054
8  0.528308  0.394107  0.734904  0.961356  0.654669
9  0.120508  0.656848  0.055749  0.290897  0.281000

ऐसा प्रतीत होता है कि आप निम्नलिखित निजी चर के साथ सभी उपनामों को देख सकते हैं:

df._AXIS_ALIASES
{'rows': 0}

df._AXIS_NUMBERS
{'columns': 1, 'index': 0}

df._AXIS_NAMES
{0: 'index', 1: 'columns'}

Question 6

जब अक्ष = 'पंक्तियाँ' या धुरी = 0, इसका अर्थ है पंक्तियों की दिशा में पहुँच तत्व नीचे तक। यदि अक्ष = 0 के साथ योग लागू होता है, तो यह हमें प्रत्येक स्तंभ के योग देगा।

जब अक्ष = 'कॉलम' या अक्ष = 1 होता है, तो इसका अर्थ है स्तंभों की दिशा में एक्सेस तत्व, बाएं से दाएं। यदि धुरी = 1 के साथ योग लगाने पर, हमें प्रत्येक पंक्ति के योग मिलेंगे।

अभी भी भ्रमित! लेकिन ऊपर यह मेरे लिए थोड़ा आसान बनाता है।

Question 7

मुझे अन्य सभी उत्तर भ्रामक लगते हैं। यहां बताया गया है कि मैं इसके बारे में कैसे सोचता हूं:

axis=0: परिणाम का आकार क्षैतिज है (एक पंक्ति)
axis=1: परिणाम का आकार लंबवत (एक स्तंभ) है

इसलिए

df.drop(name, axis=1): एक कॉलम ड्रॉप करता है
df.mean(axis=1): एक कॉलम की गणना करता है (परिणाम को नए कॉलम के रूप में जोड़ा जा सकता है)