पांडा में अक्ष का क्या अर्थ है?

Question

डेटाफ़्रेम जेनरेट करने के लिए मेरा कोड यहाँ है:

import pandas as pd
import numpy as np

dff = pd.DataFrame(np.random.randn(1,2),columns=list('AB'))

तब मुझे डेटाफ़्रेम मिला:

+------------+---------+--------+
|            |  A      |  B     |
+------------+---------+---------
|      0     | 0.626386| 1.52325|
+------------+---------+--------+

जब मैं कमोड टाइप करता हूँ:

dff.mean(axis=1)

मुझे मिला :

0    1.074821
dtype: float64

पांडा के संदर्भ के अनुसार, अक्ष = 1 स्तंभों के लिए खड़ा है और मुझे कमांड के परिणाम की उम्मीद है

A    0.626386
B    1.523255
dtype: float64

तो यहाँ मेरा सवाल है: पांडा में अक्ष का क्या अर्थ है?

Answer 1

यह उस अक्ष को निर्दिष्ट करता है जिसके साथ साधनों की गणना की जाती है। डिफ़ॉल्ट रूप से axis=0। इस के साथ संगत है numpy.meanउपयोग जब axisनिर्दिष्ट किया जाता है स्पष्ट रूप से (में numpy.mean, डिफ़ॉल्ट रूप से == कोई नहीं है, जो चपटा सरणी पर औसत मूल्य की गणना करता अक्ष), जिसमें axis=0साथ पंक्तियों (यानी, सूचकांक पांडा में), और axis=1साथ कॉलम । अतिरिक्त स्पष्टता के लिए, कोई व्यक्ति axis='index'( axis=0या के axis='columns'बजाय ) निर्दिष्ट करने ( या के बजाय ) का चयन कर सकता है axis=1।

+------------+---------+--------+
|            |  A      |  B     |
+------------+---------+---------
|      0     | 0.626386| 1.52325|----axis=1----->
+------------+---------+--------+
             |         |
             | axis=0  |
             ↓         ↓

Comments

आमतौर पर अक्ष = 0 को "स्तंभ-वार" (और अक्ष = 1 "पंक्ति-वार") कहा जाता है, मुझे लगता है कि "पंक्तियों के साथ" भ्रामक है। (अच्छा "चित्र" हालांकि :))

— एंडी हेडन

@AndyHayden हाँ, लेकिन शायद दोनों थोड़ा भ्रमित कर रहे हैं, उन लोगों के लिए जो इस समय आने वाले हैं;)

— zhangxaochen

इसके अलावा, कारण जो axis=0पंक्तियों के साथ एकत्रीकरण को इंगित करता है और axis=1स्तंभों के साथ एकत्रीकरण को इंगित करता है, क्योंकि आप डेटाफ्रेम में कैसे सूचकांक करते हैं। में df.iloc[row, column], rowइंडेक्स स्थिति में है 0 और columnइंडेक्स स्थिति में है। Numpy इसे N आयामों के लिए सामान्यीकृत करता है, जो कि उस अक्ष के संदर्भ में सोच रहा है कि एकत्रीकरण ढहने "पंक्ति-वार" या "कॉलम-वार" की तुलना में अधिक समझ में आता है "।

— टॉम क्यू।

मुझे अभी भी भ्रम हो रहा है। अगर मैं करता हूं df.drop("A", axis = 1)तो ए कॉलम को हटा दिया जाएगा। यह "पंक्ति के साथ" नहीं है और न ही "पंक्ति-वार" है, लेकिन स्तंभ ए को छोड़ रहा है

— ytu

@ytu का axis=0अर्थ है प्रत्येक पंक्ति एक बल्क के रूप में, हम केवल आंतरिक-पंक्ति के बजाय DataFrame अंतर-पंक्ति में हेरफेर कर सकते हैं। axis=1इसका मतलब है कि प्रत्येक स्तंभ एक बल्क के रूप में है, हम केवल आंतरिक-स्तंभ के बजाय DataFrame इंटर-कॉलम में हेरफेर कर सकते हैं। इसलिए यदि आप उपयोग करते हैं df.drop("A", axis = 1), तो यह एक संपूर्ण कॉलम छोड़ देगा।

— बेल्टर

Answer 2

ये उत्तर इसे समझाने में मदद करते हैं, लेकिन यह अभी भी एक गैर-प्रोग्रामर (यानी मेरे जैसा कोई व्यक्ति जो डेटा साइंस कोर्सवर्क के संदर्भ में पहली बार अजगर सीख रहा है) के लिए पूरी तरह से सहज नहीं है। मैं अभी भी पंक्तियों और स्तंभों को भ्रमित करने के लिए प्रत्येक "wrt" के लिए "साथ" या "शब्दों का उपयोग करता हूं।

मेरे लिए इस तरह से कहना ज्यादा मायने रखता है:

• एक्सिस 0 प्रत्येक कोलम में सभी रोल्स पर कार्य करेगा
• एक्सिस 1 प्रत्येक ROW में सभी COLUMNS पर कार्य करेगा

तो अक्ष 0 पर एक मतलब प्रत्येक कॉलम में सभी पंक्तियों का मतलब होगा, और अक्ष 1 पर एक मतलब प्रत्येक पंक्ति में सभी स्तंभों का एक मतलब होगा।

अंतत: यह @zhangxaochen और @Michael के रूप में एक ही बात कह रहा है, लेकिन एक तरह से मेरे लिए आंतरिक करना आसान है।

Comments

मुझे लगता है कि भ्रम प्रत्येक तथाकथित "अधिनियम" की जटिलता से आता है। df.dropna (धुरी = 0) पहले प्रत्येक ROW में सभी COLUMNS की जाँच करेगा और फिर उन ROWS को एक अशक्त के साथ छोड़ देगा। अक्ष अंतिम चरण के बारे में बात करता है लेकिन हमारा मस्तिष्क पहले भाग पर ध्यान केंद्रित करेगा।

— शॉन चेन

Answer 3

आइए कल्पना करें (आप हमेशा याद रखें),

पंडों में:

1. धुरी = 0 का अर्थ "अनुक्रमित" के साथ है। यह एक पंक्ति-वार ऑपरेशन है ।

मान लीजिए, डेटाफ्रेम 1 और डेटाफ्रेम 2 पर कॉन्कटैट () ऑपरेशन करने के लिए, हम डेटाफ्रेम 1 ले लेंगे और डेटाफ्रेम 1 से पहली पंक्ति निकालेंगे और नए डीएफ में जगह लेंगे, फिर हम डेटाफ्रेम 1 से एक और पंक्ति निकालते हैं और नए डीएफ में डालते हैं, हम इस प्रक्रिया को दोहराते हैं। हम डेटाफ्रेम 1 के निचले हिस्से तक पहुँचते हैं। फिर, हम डेटाफ्रेम 2 के लिए भी यही प्रक्रिया करते हैं।

मूलतः, dataframe1 के शीर्ष पर dataframe2 को स्टैक करना या इसके विपरीत।

जैसे टेबल या फर्श पर किताबों का ढेर बनाना

2. अक्ष = 1 का अर्थ है "कॉलम"। यह कॉलम-वार ऑपरेशन है।

मान लीजिए, डेटाफ्रेम 1 और डेटाफ्रेम 2 पर कॉनसैट () ऑपरेशन करने के लिए, हम डेटाफ्रेम 1 के 1 पूर्ण स्तंभ (उर्फ 1 श्रृंखला) को निकालेंगे और नए डीएफ में जगह देंगे, फिर हम डेटाफ्रेम 1 के दूसरे कॉलम को बाहर निकालते हैं और इसे बगल में रखते हैं (बग़ल में) ) , हमें इस ऑपरेशन को तब तक दोहराना है जब तक कि सभी कॉलम समाप्त न हो जाएं। उसके बाद, हम डेटाफ्रेम 2 पर भी यही प्रक्रिया दोहराते हैं। मूल रूप से, dataframe2 बग़ल में स्टैकिंग।

उदा। एक बुकशेल्फ़ पर पुस्तकों की व्यवस्था करना।

इससे अधिक, चूंकि मैट्रिस की तुलना में नेस्टेड एन-आयामी संरचना का प्रतिनिधित्व करने के लिए एरे बेहतर प्रतिनिधित्व है! जब आप एक से अधिक आयामों के लिए सामान्यीकरण करते हैं तो अक्ष कैसे महत्वपूर्ण भूमिका निभाता है, यह देखने के लिए आप अधिक मदद कर सकते हैं। इसके अलावा, आप वास्तव में किसी भी n- डिम सरणी को प्रिंट / राइट / ड्रॉ / विज़ुअलाइज़ कर सकते हैं लेकिन, मैट्रिक्स प्रतिनिधित्व (3-डिम) में उसी को लिखना या विज़ुअलाइज़ करना 3-आयामों से अधिक एक पेपर पर असंभव है।

Comments

मुझे लगता है कि यह उत्तर उचित है। आपको इसकी कल्पना करने की आवश्यकता है। अक्ष = 0 (या अक्ष = 'पंक्तियों' क्षैतिज अक्ष है। अक्ष = 1 (या अक्ष = 'कॉलम') ऊर्ध्वाधर अक्ष है। इसे आगे ले जाने के लिए, यदि आप निर्दिष्ट करते हैं, तो स्तंभ या पंक्तियों को हटाने के लिए यदि आप पांडा विधि ड्रॉप का उपयोग करते हैं। धुरी = 1 आप कॉलम निकाल रहे होंगे। यदि आप अक्ष = 0 निर्दिष्ट करते हैं, तो आप डेटासेट से पंक्तियाँ निकाल रहे होंगे। इसलिए यदि हमारे पास चर df में कुछ पैंडा डेटाफ़्रेम हैं: df.drop (0, धुरी = 0) पूरी पहली पंक्ति को हटा देगा डेटासेट का df.drop ('ग्रेड', अक्ष = 1) डेटासेट से कॉलम 'ग्रेड' को हटा देगा। आशा है कि यह इसे थोड़ा और स्पष्ट करता है ...

— Roboblob

@ रोबोब्लोब - अभी भी भ्रमित। df.drop (n, axis = 1) एक कॉलम पर कार्य करता है। किसी कॉलम पर df.mean (अक्ष = 1) कार्रवाई क्यों नहीं करता है?

— मैटी

@ प्रथम, प्रथम! तुम्हारे हाथ गंदे हैं !, यह इतना सीधा है। आपके संदर्भ के लिए, ड्रॉप एंड मीन , अक्ष = 1 दोनों के लिए समान है, कृपया एक नया प्रश्न पूछें यदि आपने अपने उदाहरण में कुछ नहीं समझा है!

— अनु

@anu - हाथ गंदे? हमें डुप्लिकेट प्रश्नों के साथ SO को अव्यवस्थित करने की आवश्यकता नहीं है। मुझे विश्वास है कि इस भ्रम को कम करने के लिए इस पृष्ठ पर एक या अधिक उत्तर स्पष्ट किए जा सकते हैं। यदि मैं कर सकता था, तो मैं इसे स्वयं करूँगा, लेकिन अभी के लिए, मैं केवल उनका उपयोग करना जानता हूँ। मैं समझता हूं कि मुझे जो डेटा चाहिए उसे प्राप्त करने के लिए किस अक्ष का उपयोग करना है। हालाँकि भ्रम इस बात का है कि क्यों मीन () और ड्रॉप () ऐसा महसूस करते हैं कि वे विरोधी अक्षों को प्रभावित करते हैं।

— मैटी

मुझे डर है कि यह जवाब अविश्वसनीय रूप से भ्रामक है। आप धुरी के रूप में पंक्तियों पर अभिनय के बारे में बात करते हैं = 0 फिर भी आप स्तंभों के नीचे जा रहे लाल तीर खींचते हैं। आप स्तंभों पर अक्ष = 1 अभिनय के बारे में बात करते हैं, फिर भी आप एक पंक्ति में जाने वाले तीर खींचते हैं। जो कोई भी इस प्रणाली के साथ आया था उसने इसे बहुत अच्छी तरह से नहीं सोचा था।

— चट्टानेनवीस

Answer 4

axisसरणी के आयाम को संदर्भित करता है, pd.DataFrameएस के मामले में axis=0आयाम है जो नीचे की ओर इंगित करता है और axis=1जो दाईं ओर इंगित करता है।

उदाहरण:ndarray आकृति के साथ सोचें (3,5,7)।

a = np.ones((3,5,7))

aएक 3 आयामी है ndarray, अर्थात इसमें 3 अक्ष हैं ("अक्ष" "अक्ष" का बहुवचन है)। aवसीयत का विन्यास रोटी के 3 स्लाइस की तरह दिखेगा जहां प्रत्येक स्लाइस 5-बाय -7 के आयाम की है। a[0,:,:]0-वें स्लाइस a[1,:,:]को संदर्भित करेगा , 1-सेंट स्लाइस आदि को संदर्भित करेगा।

a.sum(axis=0)sum()0-वें अक्ष के साथ लागू होगा a। आप सभी स्लाइस जोड़ देंगे और आकार के एक स्लाइस के साथ समाप्त हो जाएंगे (5,7)।

a.sum(axis=0) के बराबर है

b = np.zeros((5,7))
for i in range(5):
    for j in range(7):
        b[i,j] += a[:,i,j].sum()

bऔर a.sum(axis=0)दोनों इस तरह दिखेंगे

array([[ 3.,  3.,  3.,  3.,  3.,  3.,  3.],
       [ 3.,  3.,  3.,  3.,  3.,  3.,  3.],
       [ 3.,  3.,  3.,  3.,  3.,  3.,  3.],
       [ 3.,  3.,  3.,  3.,  3.,  3.,  3.],
       [ 3.,  3.,  3.,  3.,  3.,  3.,  3.]])

एक में pd.DataFrame, कुल्हाड़ियों में के रूप में उसी तरह काम numpy.array: रों axis=0लागू होगी sum()या प्रत्येक स्तंभ के लिए किसी अन्य कमी समारोह।

NB @ @ zhangxaochen के उत्तर में, मैं वाक्यांशों को "पंक्तियों के साथ" और "स्तंभों के साथ" थोड़ा भ्रमित करता हूं। axis=0"प्रत्येक स्तंभ के साथ", और axis=1"प्रत्येक पंक्ति के साथ " का उल्लेख करना चाहिए ।

Comments

यह स्वीकार किए जाते हैं की तुलना में एक बेहतर जवाब है - चूंकि सफ़क का उल्लेख है कि वहां उपयोग किए जाने वाले वाक्यांश खराब रूप से लिखे गए हैं और अभी तक अधिक भ्रम की स्थिति में हैं।

— जवदाबा

इसका बेहतर जवाब है

— रवि जी

Answer 5

मेरे लिए समझने का सबसे आसान तरीका यह है कि आप प्रत्येक कॉलम ( axis = 0) या प्रत्येक पंक्ति ( axis = 1) के लिए एक आंकड़े की गणना कर रहे हैं । यदि आप एक आँकड़ा की गणना करते हैं, तो एक माध्य कहें, जिसके साथ axis = 0आपको प्रत्येक स्तंभ के लिए वह आँकड़ा मिल जाएगा। इसलिए यदि प्रत्येक अवलोकन एक पंक्ति है और प्रत्येक चर एक कॉलम में है, तो आपको प्रत्येक चर का मतलब मिलेगा। यदि आप सेट करते हैं axis = 1तो आप प्रत्येक पंक्ति के लिए अपने आंकड़े की गणना करेंगे। हमारे उदाहरण में, आपको अपने सभी चर में प्रत्येक अवलोकन के लिए माध्य मिलेगा (शायद आप संबंधित उपायों का औसत चाहते हैं)।

axis = 0: स्तंभ = स्तंभ-वार = पंक्तियों के साथ

axis = 1: पंक्ति = पंक्ति-वार = स्तंभों के साथ

Comments

मुझे लगता है कि "साथ" को "आर-पार" से बदल दिया जाना चाहिए। मेरे साथ किसी चीज़ (जैसे सड़क) पर जाने का मतलब उस पर बने रहना है, लेकिन जब axis=0हम माध्य की गणना करते हैं, तो हम कहने वाली पंक्ति पर नहीं रहते हैं; बल्कि हम एक कॉलम में सभी पंक्तियों के पार जाते हैं।

— चकित

Answer 6

आइए विकी की तालिका देखें। यह शीर्ष दस देशों के लिए 2010 से 2019 तक जीडीपी का आईएमएफ का अनुमान है।

1. एक्सिस 1 सभी स्तंभों पर प्रत्येक पंक्ति के लिए कार्य करेगा
, आप दशक (2010-2019), तो आप क्या करने की जरूरत पर एक देशों के लिए औसत (माध्य) सकल घरेलू उत्पाद की गणना करना चाहते हैं df.mean(axis=1)। उदाहरण के लिए, यदि आप 2010 से 2019 तक संयुक्त राज्य अमेरिका की औसत जीडीपी की गणना करना चाहते हैं,df.loc['United States','2010':'2019'].mean(axis=1)

2. एक्सिस 0 सभी पंक्तियों पर प्रत्येक कॉलम के लिए कार्य करेगा।
यदि मैं सभी देशों के लिए EACH वर्ष के औसत (औसत) जीडीपी की गणना करना चाहता हूं, तो आपको करने की आवश्यकता है df.mean(axis=0)। उदाहरण के लिए, यदि आप संयुक्त राज्य अमेरिका, चीन, जापान, जर्मनी और भारत के लिए वर्ष 2015 के औसत जीडीपी की गणना करना चाहते हैं, तो df.loc['United States':'India','2015'].mean(axis=0)

नोट: उपरोक्त कोड "देश (या आश्रित क्षेत्र)" कॉलम को इंडेक्स के रूप में सेट करने के बाद ही काम करेगा, set_indexतरीका।

Answer 7

प्रोग्रामिंग के मद्देनजर एक्सिस आकार टपल में स्थिति है। यहाँ एक उदाहरण है:

import numpy as np

a=np.arange(120).reshape(2,3,4,5)

a.shape
Out[3]: (2, 3, 4, 5)

np.sum(a,axis=0).shape
Out[4]: (3, 4, 5)

np.sum(a,axis=1).shape
Out[5]: (2, 4, 5)

np.sum(a,axis=2).shape
Out[6]: (2, 3, 5)

np.sum(a,axis=3).shape
Out[7]: (2, 3, 4)

धुरी पर मीन उस आयाम को हटा देगा।

मूल प्रश्न का उल्लेख करते हुए, dff आकार (1,2) है। अक्ष = 1 का उपयोग करने से आकृति (1,) में बदल जाएगी।

Answer 8

पांडा के डिजाइनर, वेस मैककिनी, वित्त डेटा पर गहन रूप से काम करते थे। स्टॉक के नाम और दैनिक मूल्यों के रूप में सूचकांक के रूप में कॉलम के बारे में सोचो। फिर आप अनुमान लगा सकते हैं कि axis=0इस वित्त डेटा के संबंध में डिफ़ॉल्ट व्यवहार (यानी ) क्या है । axis=1बस 'दूसरी दिशा' के रूप में सोचा जा सकता है।

उदाहरण के लिए, जैसे आंकड़ों में काम करता है, mean(), sum(), describe(), count()स्तंभ-वार करने के लिए सभी डिफ़ॉल्ट क्योंकि इससे उन्हें प्रत्येक शेयर के लिए क्या करने के लिए और अधिक समझ में आता है। sort_index(by=)स्तंभ के लिए भी चूक। fillna(method='ffill')कॉलम के साथ भर जाएगा क्योंकि यह एक ही स्टॉक है। dropna()पंक्ति में चूक क्योंकि आप शायद उस दिन की कीमत को छोड़ना चाहते हैं बजाय उस शेयर के सभी मूल्य फेंक दें।

इसी तरह, वर्ग कोष्ठक अनुक्रमण स्तंभों को संदर्भित करता है क्योंकि किसी दिन को चुनने के बजाय स्टॉक चुनना अधिक सामान्य है।

Comments

आपका तर्क सही लगता है, लेकिन इसका मतलब है (), योग () और अन्य फ़ंक्शन डिफ़ॉल्ट (अक्ष = 0) जो पंक्ति-वार है और ऊपर उल्लिखित नहीं है। और पंक्ति-वार ऐसा व्यवहार करने लगता है जैसे हम स्तंभ-वार की अपेक्षा करते हैं :) और यह भ्रम प्रतीत होता है।

— बिंकोब

Answer 9

अक्ष 1 (कॉलम), बनाम अक्ष 0 (पंक्तियाँ) को याद रखने के आसान तरीकों में से एक वह आउटपुट है जिसकी आप अपेक्षा करते हैं।

• यदि आप प्रत्येक पंक्ति के लिए एक आउटपुट की उम्मीद करते हैं जो आप अक्ष = 'कॉलम' का उपयोग करते हैं,
• दूसरी ओर यदि आप प्रत्येक स्तंभ के लिए एक आउटपुट चाहते हैं जो आप अक्ष = 'पंक्तियों' का उपयोग करते हैं।

Comments

धन्यवाद। यह, हालांकि, केवल गणना के अधिकार के लिए काम करता है? यह इस तरह के तरीकों के लिए काम नहीं करेगा pd.concatया df.dropna(), जो पहचान क्षमता के अधिक में kewarg अक्ष का उपयोग करता है।

— बोवेन लियू

Answer 10

axis=ठीक से उपयोग करने के साथ समस्या 2 मुख्य विभिन्न मामलों के लिए इसके उपयोग के लिए है:

1. एक संचित मूल्य की गणना के लिए , या डेटा को फिर से व्यवस्थित करना (जैसे क्रमबद्ध करना)।
2. के लिए जोड़ तोड़ (के साथ "खेल रहे हैं") संस्थाओं (जैसे dataframes )।

इस उत्तर के पीछे मुख्य विचार यह है कि भ्रम से बचने के लिए, हम या तो एक संख्या का चयन करते हैं , या किसी विशेष अक्ष को निर्दिष्ट करने के लिए एक नाम , जो भी अधिक स्पष्ट, सहज और वर्णनात्मक है।

पंडों की संख्या NumPy पर आधारित है, जो कि गणित पर आधारित है, विशेष रूप से n- आयामी मैट्रिक्स पर। 3-आयामी अंतरिक्ष में गणित में कुल्हाड़ियों के नामों के सामान्य उपयोग के लिए एक छवि है:

यह चित्र केवल कुल्हाड़ियों की क्रम संख्या याद करने के लिए है :

• 0 एक्स-अक्ष के लिए,
• 1 y- अक्ष के लिए, और
• 2 z- अक्ष के लिए।

Z- अक्ष के लिए ही है पैनलों ; के लिए dataframes हम हरे रंग, के लिए हमारे हित को प्रतिबंधित करेगा 2-आयामी बुनियादी विमान के साथ x- अक्ष ( 0ऊर्ध्वाधर) , और y- अक्ष ( 1क्षैतिज)।

यह सभी मापदंडों के संभावित मूल्यों के रूप में संख्याओं के लिए है axis=।

नाम कुल्हाड़ियों के हैं 'index'(आप अन्य नाम का उपयोग कर सकते हैं 'rows') और 'columns', और इस स्पष्टीकरण के लिए यह नहीं महत्वपूर्ण इन नामों और क्रमसूचक संख्या के बीच संबंध है (कुल्हाड़ियों का), के रूप में सब जानते क्या शब्द "पंक्तियाँ" और "कॉलम" मतलब ( और यहां हर कोई - मुझे लगता है - जानता है कि पांडा में "इंडेक्स" शब्द का क्या मतलब है)।

और अब, मेरा पुनर्मूल्यांकन:

1. यदि आप संचित मूल्य की गणना करना चाहते हैं , तो आप इसे अक्ष 0 (या अक्ष 1 ) के साथ स्थित मानों से उपयोग कर सकते हैं - उपयोग axis=0(या axis=1)।

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

2. यदि आप हेरफेर करना चाहते हैं (उदाहरण के लिए समवर्ती ) इकाइयां (उदाहरण के लिए डेटाफ्रेम ) - उपयोग axis='index'(समानार्थक शब्द axis='rows') या परिणामस्वरूप परिवर्तनaxis='columns' को निर्दिष्ट करने के लिए - सूचकांक ( पंक्तियाँ ) या कॉलम , क्रमशः। ( समवर्ती के लिए , आप क्रमशः एक लंबा सूचकांक (= अधिक पंक्तियाँ) , या अधिक स्तंभ प्राप्त करेंगे ।)
   

Comments

यह सबसे अच्छा उत्तर है, और शायद ऑप द्वारा सही उत्तर के रूप में चिह्नित किया जाना चाहिए!

— ऐज

Answer 11

यह @ सफ़क के उत्तर पर आधारित है। पांडा / सुन्न में कुल्हाड़ियों को समझने का सबसे अच्छा तरीका 3 डी सरणी बनाना और 3 अलग-अलग कुल्हाड़ियों के साथ योग फ़ंक्शन के परिणाम की जांच करना है।

 a = np.ones((3,5,7))

एक होगा:

    array([[[1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.]],

   [[1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.]],

   [[1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.],
    [1., 1., 1., 1., 1., 1., 1.]]])

अब कुल्हाड़ियों में से प्रत्येक के साथ सरणी के तत्वों का योग देखें:

 x0 = np.sum(a,axis=0)
 x1 = np.sum(a,axis=1)
 x2 = np.sum(a,axis=2)

आपको निम्न परिणाम देगा:

   x0 :
   array([[3., 3., 3., 3., 3., 3., 3.],
        [3., 3., 3., 3., 3., 3., 3.],
        [3., 3., 3., 3., 3., 3., 3.],
        [3., 3., 3., 3., 3., 3., 3.],
        [3., 3., 3., 3., 3., 3., 3.]])

   x1 : 
   array([[5., 5., 5., 5., 5., 5., 5.],
   [5., 5., 5., 5., 5., 5., 5.],
   [5., 5., 5., 5., 5., 5., 5.]])

  x2 :
   array([[7., 7., 7., 7., 7.],
        [7., 7., 7., 7., 7.],
        [7., 7., 7., 7., 7.]])

Answer 12

मैं इस तरह से समझता हूं:

यह कहें कि यदि आपके ऑपरेशन को डेटाफ़्रेम में बाएं से दाएं / दाएं से बाएं की ओर ट्रेसिंग की आवश्यकता है , तो आप जाहिरा तौर पर कॉलम को मर्ज कर रहे हैं। आप विभिन्न स्तंभों पर काम कर रहे हैं। यह अक्ष = 1 है

उदाहरण

df = pd.DataFrame(np.arange(12).reshape(3,4),columns=['A', 'B', 'C', 'D'])
print(df)
   A  B   C   D
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11 

df.mean(axis=1)

0    1.5
1    5.5
2    9.5
dtype: float64

df.drop(['A','B'],axis=1,inplace=True)

    C   D
0   2   3
1   6   7
2  10  11

ध्यान देने योग्य बात यह है कि हम स्तंभों पर काम कर रहे हैं

इसी तरह, यदि आपके ऑपरेशन को डेटाफ़्रेम में ऊपर से नीचे / नीचे से ऊपर तक ट्रैवर्सिंग की आवश्यकता होती है , तो आप पंक्तियों को मर्ज कर रहे हैं। यह अक्ष = ० है ।

Answer 13

धुरी = 0 का अर्थ है नीचे की ओर अक्ष = 1 का अर्थ है दाएं से बाएं

sums[key] = lang_sets[key].iloc[:,1:].sum(axis=0)

दिया गया उदाहरण कॉलम == कुंजी के सभी डेटा का योग ले रहा है।

Answer 14

मेरी सोच: एक्सिस = एन, जहां एन = 0, 1, आदि का मतलब है कि मैट्रिक्स उस अक्ष के साथ ढह गई (मुड़ा हुआ) है। तो एक 2 डी मैट्रिक्स में, जब आप 0 (पंक्तियों) के साथ गिरते हैं, तो आप वास्तव में एक समय में एक कॉलम पर काम कर रहे होते हैं। इसी तरह उच्चतर आदेश के लिए।

यह मैट्रिक्स में एक आयाम के सामान्य संदर्भ के समान नहीं है, जहां 0 -> पंक्ति और 1 -> कॉलम है। इसी तरह एक एन आयाम सरणी में अन्य आयामों के लिए।

Answer 15

मैं पांडा के लिए नौसिखिया हूं। लेकिन इस तरह से मैं पांडा में धुरी को समझता हूं:

---

एक्सिस कांस्टेंट वेरिंग दिशा

---

0 कॉलम पंक्ति नीचे की ओर |

---

1 पंक्ति स्तंभ की ओर दाहिनी ओर ->

---

तो किसी स्तंभ के माध्य की गणना करने के लिए, वह विशेष स्तंभ स्थिर होना चाहिए लेकिन उसके नीचे की पंक्तियाँ बदल सकती हैं (भिन्न हो सकती हैं ) इसलिए यह अक्ष = 0 है।

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

Answer 16

मुझे लगता है कि इसे समझने का एक और तरीका है।

Np.array के लिए, यदि हम स्तंभों को समाप्त करना चाहते हैं तो हम अक्ष = 1 का उपयोग करते हैं; यदि हम पंक्तियों को समाप्त करना चाहते हैं, तो हम अक्ष = 0 का उपयोग करते हैं।

np.mean(np.array(np.ones(shape=(3,5,10))),axis = 0).shape # (5,10)
np.mean(np.array(np.ones(shape=(3,5,10))),axis = 1).shape # (3,10)
np.mean(np.array(np.ones(shape=(3,5,10))),axis = (0,1)).shape # (10,)

पांडा वस्तु axis = 0के लिए, पंक्ति-वार ऑपरेशन axis = 1के लिए और स्तंभ-वार ऑपरेशन के लिए खड़ा है। यह numpyपरिभाषा से अलग है , हम numpy.doc और pandas.doc से परिभाषाओं की जांच कर सकते हैं

Answer 17

मैं स्पष्ट रूप से 'पंक्ति-वार' या 'कॉलम के साथ' का उपयोग करने से बचूँगा, क्योंकि लोग उनकी व्याख्या बिल्कुल गलत तरीके से कर सकते हैं।

सादृश्य पहले। सहज रूप से, आप अपेक्षा करेंगे कि pandas.DataFrame.drop(axis='column')एन कॉलम से एक कॉलम ड्रॉप करता है और आपको (एन - 1) कॉलम देता है। तो आप अब के लिए पंक्तियों पर कोई ध्यान नहीं दे सकते हैं (और अपने अंग्रेजी शब्दकोश से 'पंक्ति' शब्द हटा दें।) इसके विपरीत, drop(axis='row')पंक्तियों पर काम करता है।

उसी तरह, sum(axis='column')कई कॉलम पर काम करता है और आपको 1 कॉलम देता है। इसी तरह, sum(axis='row')1 पंक्ति में परिणाम। यह परिभाषा के अपने सरलतम रूप के अनुरूप है, संख्याओं की सूची को एक संख्या में कम करता है।

सामान्य तौर पर, axis=columnआप कॉलम देखते हैं, स्तंभों पर काम करते हैं, और कॉलम प्राप्त करते हैं। पंक्तियों को भूल जाओ।

के साथ axis=row, परिप्रेक्ष्य बदलें और पंक्तियों पर काम करें।

0 और 1 'पंक्ति' और 'कॉलम' के लिए सिर्फ उपनाम हैं। यह मैट्रिक्स इंडेक्सिंग का सम्मेलन है।

Comments

यह व्याख्या अक्ष = 'कॉलम' का उपयोग करके सही नहीं है जो आपको कॉलम नहीं देता है।

— user3065757 12

@ user3065757 टिप्पणी के लिए धन्यवाद। क्या आप उदाहरणों के साथ विस्तृत कर सकते हैं?

— lqu

वह नहीं जो आप जवाब दे रहे हैं, लेकिन जब मैं pd.concatआपके स्पष्टीकरण के साथ जानने की कोशिश करता हूं , तो यह काफी काम नहीं करता है। आप 2 कुल्हाड़ियों के साथ संक्षिप्त व्यवहार की व्याख्या कर सकते हैं? धन्यवाद।

— बोवेन लियू

@BowenLiu जब आप सेब की 2 सूचियों को प्राप्त करते हैं, तो आपको 1 और सेब की सूची मिलती है (लेकिन बड़े सेब नहीं)। जब आप पंक्तियों को जोड़ते हैं (अक्ष = 0), तो आपको अधिक पंक्तियाँ मिलती हैं (लंबी पंक्तियाँ नहीं); जब आप कॉलम (एक्सिस = 1) को गुप्त करते हैं, तो आपको अधिक कॉलम (लंबे कॉलम नहीं) मिलते हैं। विचार अक्ष = 0 पंक्तियों के बीच संचालित होता है, एक पंक्ति के अंदर नहीं।

— lqu

Answer 18

मैं पिछले एक घंटे से भी धुरी का पता लगाने की कोशिश कर रहा हूं। उपरोक्त सभी उत्तरों में भाषा, और प्रलेखन भी बिल्कुल भी मददगार नहीं है।

प्रश्न का उत्तर देने के लिए जैसा कि मैं इसे अब समझता हूं, पंडों में, अक्ष = 1 या 0 का अर्थ है कि आप फ़ंक्शन को लागू करते समय किस हेडर को स्थिर रखना चाहते हैं।

नोट: जब मैं हेडर कहता हूं, तो मेरा मतलब है इंडेक्स नाम

अपने उदाहरण का विस्तार:

+------------+---------+--------+
|            |  A      |  B     |
+------------+---------+---------
|      X     | 0.626386| 1.52325|
+------------+---------+--------+
|      Y     | 0.626386| 1.52325|
+------------+---------+--------+

अक्ष = 1 = कॉलम के लिए: हम कॉलम हेडर को स्थिर रखते हैं और डेटा को बदलकर औसत फ़ंक्शन को लागू करते हैं। प्रदर्शित करने के लिए, हम कॉलम हेडर को स्थिर रखते हैं:

+------------+---------+--------+
|            |  A      |  B     |

अब हम A और B मानों के एक सेट को पॉप्युलेट करते हैं और फिर माध्य ज्ञात करते हैं

|            | 0.626386| 1.52325|  

तब हम ए और बी मूल्यों के अगले सेट को आबाद करते हैं और माध्य पाते हैं

|            | 0.626386| 1.52325|

इसी तरह, अक्ष = पंक्तियों के लिए, हम पंक्ति हेडर को स्थिर रखते हैं, और डेटा को बदलते रहते हैं: प्रदर्शित करने के लिए, पहले पंक्ति हेडर को ठीक करें:

+------------+
|      X     |
+------------+
|      Y     |
+------------+

अब X और Y मान के पहले सेट को आबाद करें और फिर माध्य ज्ञात करें

+------------+---------+
|      X     | 0.626386
+------------+---------+
|      Y     | 0.626386
+------------+---------+

फिर X और Y मान के अगले सेट को पॉप्युलेट करें और फिर माध्य खोजें:

+------------+---------+
|      X     | 1.52325 |
+------------+---------+
|      Y     | 1.52325 |
+------------+---------+

संक्षेप में,

जब अक्ष = कॉलम, आप कॉलम हेडर को ठीक करते हैं और डेटा बदलते हैं, जो विभिन्न पंक्तियों से आएगा।

जब अक्ष = पंक्तियाँ, आप पंक्ति हेडर को ठीक करते हैं और डेटा बदलते हैं, जो विभिन्न स्तंभों से आएगा।

Answer 19

धुरी = 1, यह योग पंक्ति को बुद्धिमान बनाए रखेगा, रख-रखाव = सत्य 2D आयाम को बनाए रखेगा। आशा है कि यह आपकी मदद करता है।

Comments

ओपी नहीं बल्कि धन्यवाद। मुझे लगता है कि पंडों की डॉक्यूमेंट्री में अक्ष, 1 = कॉलम से मेल खाती है, इस बारे में लोगों का अधिकांश भ्रम है। हालाँकि, यहाँ यह 'पंक्ति-वार' गणना कर रहा है।

— बोवेन लियू

Answer 20

यहाँ कई जवाबों ने मेरी बहुत मदद की!

यदि आप axisपायथन और MARGINआर ( applyफ़ंक्शन में) के विभिन्न व्यवहारों से भ्रमित हो जाते हैं, तो आपको एक ब्लॉग पोस्ट मिल सकती है जिसे मैंने रुचि के बारे में लिखा था: https://accio.github.io/programming/2020/05/ 19 / अंक-पांडा-अक्ष । html ।

संक्षेप में:

• उनके व्यवहार, दो आयामी सरणियों की तुलना में त्रि-आयामी सरणी के साथ समझने के लिए, सरल रूप से, आसान हैं।
• पायथन पैकेज में numpyऔरpandas , योग में अक्ष पैरामीटर वास्तव में उन सभी मूल्यों की गणना करने के लिए सुन्न निर्दिष्ट करता है जिन्हें सरणी के रूप में प्राप्त किया जा सकता है [0, 0, ..., i, ..., 0] जहां मैं इसके माध्यम से पुनरावृत्ति करता हूं सभी संभव मूल्य। प्रक्रिया को i की स्थिति के साथ दोहराया जाता है और अन्य आयामों के सूचकांक एक के बाद एक (सबसे दूर-सही तत्व से) भिन्न होते हैं। परिणाम n-1-आयामी सरणी है।
• आर में, MARGINS पैरामीटर applyफ़ंक्शन को उन सभी मानों के माध्य की गणना करने देता है, जिन्हें सरणी [, ..., i, ...,] के रूप में प्राप्त किया जा सकता है, जहां मैं सभी संभावित मूल्यों के माध्यम से पुनरावृत्त करता हूं। प्रक्रिया को दोहराया नहीं जाता है जब सभी i मान पुनरावृत्त हो गए हैं। इसलिए, परिणाम एक साधारण वेक्टर है।

Answer 21

ऐरे तथाकथित अक्ष = 0 और पंक्तियों को लंबवत बनाम अक्ष = 1 और क्षैतिज रूप से तैनात कॉलम के साथ डिज़ाइन किया गया है। एक्सिस सरणी के आयाम को संदर्भित करता है।

Comments

axis=0थोक के रूप में प्रत्येक पंक्ति का मतलब है, हम केवल आंतरिक-पंक्ति के बजाय DataFrame अंतर-पंक्ति में हेरफेर कर सकते हैं। axis=1इसका मतलब है कि प्रत्येक स्तंभ एक बल्क के रूप में है, हम केवल आंतरिक-स्तंभ के बजाय DataFrame इंटर-कॉलम में हेरफेर कर सकते हैं।

— बेल्टर

क्या इस पृष्ठ पर लगभग सभी अन्य विवरणों के अनुसार (और जुपिटर में पांडा के साथ एक त्वरित परीक्षण के अनुसार) यह बिल्कुल गलत तरीका नहीं है?

— मार्क लियायनज

यह ठीक इसके विपरीत है। कृपया अपना उत्तर सही करें।

— सुमित पोखरेल