แกนในแพนด้าหมายถึงอะไร

นี่คือรหัสของฉันเพื่อสร้าง dataframe:

import pandas as pd
import numpy as np

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

จากนั้นฉันได้รับ dataframe:

+------------+---------+--------+
|            |  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

ดังนั้นนี่คือคำถามของฉัน: แกนในแพนด้าหมายถึงอะไร

มันระบุแกนตามที่หมายถึงการคำนวณ 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  |
             ↓         ↓

คำตอบเหล่านี้ช่วยอธิบายสิ่งนี้ แต่ก็ยังไม่สามารถใช้งานได้อย่างสมบูรณ์แบบสำหรับผู้ที่ไม่ได้เขียนโปรแกรม (คือคนอย่างฉันที่กำลังเรียนรู้ Python เป็นครั้งแรกในบริบทของหลักสูตรวิทยาศาสตร์ข้อมูล) ฉันยังพบว่าการใช้คำว่า "ไปตาม" หรือ "สำหรับแต่ละ" wrt ไปยังแถวและคอลัมน์ทำให้เกิดความสับสน

สิ่งที่สมเหตุสมผลสำหรับฉันคือการพูดแบบนี้:

• Axis 0 จะทำหน้าที่เกี่ยวกับ ROWS ทั้งหมดในแต่ละคอลัมน์
• ฝ่ายอักษะ 1 จะดำเนินการกับคอลัมน์ทั้งหมดในแต่ละแถว

ดังนั้นค่าเฉลี่ยของแกน 0 จะเป็นค่าเฉลี่ยของแถวทั้งหมดในแต่ละคอลัมน์และค่าเฉลี่ยของแกน 1 จะเป็นค่าเฉลี่ยของคอลัมน์ทั้งหมดในแต่ละแถว

ท้ายที่สุดนี่คือสิ่งที่พูดเช่นเดียวกับ @zhangxaochen และ @Michael แต่ในทางที่ง่ายกว่าสำหรับฉันที่จะทำให้เป็นเขต

ลองนึกภาพ (คุณจะจำได้เสมอ)

ในนุ่น:

1. Axis = 0 หมายถึง "ดัชนี" มันเป็นการดำเนินงานแถวที่ชาญฉลาด

สมมติว่าในการดำเนินการ concat () ใน dataframe1 & dataframe2 เราจะใช้ dataframe1 และนำแถวที่ 1 จาก dataframe1 และใส่ลงใน DF ใหม่จากนั้นเราจะเอาแถวอื่นจาก dataframe1 และใส่ DF ใหม่เข้าไปใหม่ เราไปถึงด้านล่างของ dataframe1 จากนั้นเราทำขั้นตอนเดียวกันสำหรับ dataframe2

โดยพื้นฐานแล้วการซ้อน dataframe2 ที่ด้านบนของ dataframe1 หรือในทางกลับกัน

เช่นทำหนังสือกองไว้บนโต๊ะหรือพื้น

2. Axis = 1 หมายถึง "คอลัมน์" มันเป็นการดำเนินการที่คอลัมน์ฉลาด

สมมติว่าในการดำเนินการ concat () ใน dataframe1 & dataframe2 เราจะนำคอลัมน์ที่สมบูรณ์ 1 ชุด (aka ชุดที่ 1) ของ dataframe1 และวางลงใน DF ใหม่จากนั้นเราจะนำคอลัมน์ที่สองของ dataframe1 ไปด้านข้าง )เราต้องทำซ้ำการดำเนินการนี้จนกว่าคอลัมน์ทั้งหมดจะเสร็จสิ้น จากนั้นเราทำซ้ำกระบวนการเดียวกันกับ dataframe2 โดยพื้นฐานแล้วการ ซ้อน dataframe2 ไปด้านข้าง

เช่นการจัดเรียงหนังสือบนชั้นวางหนังสือ

ยิ่งไปกว่านั้นเนื่องจากอาร์เรย์เป็นตัวแทนที่ดีกว่าในการนำเสนอโครงสร้าง n-dimension ที่ซ้อนกันเมื่อเปรียบเทียบกับเมทริกซ์! ดังนั้นด้านล่างจะช่วยให้คุณเห็นภาพว่าแกนมีบทบาทสำคัญอย่างไรเมื่อคุณวางแนวทั่วไปมากกว่าหนึ่งมิติ นอกจากนี้คุณสามารถพิมพ์ / เขียน / วาด / แสดงภาพอาร์เรย์ใด ๆ ของ n-dim ได้ แต่การเขียนหรือการแสดงภาพเดียวกันในการแสดงเมทริกซ์ (3-dim) นั้นเป็นไปไม่ได้บนกระดาษมากกว่า 3 มิติ

axisอ้างถึงมิติของอาเรย์ในกรณีของpd.DataFrames axis=0คือขนาดที่ชี้ลงและaxis=1ที่ชี้ไปทางขวา

ตัวอย่าง:คิดว่าของที่มีรูปร่าง ndarray(3,5,7)

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

aคือ 3 มิติndarrayคือมี3 แกน ("แกน" คือพหูพจน์ของ "แกน") การกำหนดค่าของaจะมีลักษณะ 3 ชิ้นขนมปังที่แต่ละชิ้นมีขนาด 5 x 7 a[0,:,:]จะหมายถึงชิ้นที่ 0 a[1,:,:]จะหมายถึงชิ้นที่ 1 เป็นต้น

a.sum(axis=0)จะนำไปใช้sum()ตามแกน 0 TH 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.]])

ใน a pd.DataFrame, แกนทำงานเช่นเดียวกับในnumpy.arrays: axis=0จะใช้sum()หรือฟังก์ชันการลดอื่น ๆ สำหรับแต่ละคอลัมน์

NBในคำตอบของ @ zhangxaochen ฉันพบวลี "ตามแถว" และ "ตามคอลัมน์" ทำให้สับสนเล็กน้อย axis=0ควรอ้างถึง "ตามแต่ละคอลัมน์" และaxis=1"ตามแต่ละแถว"

วิธีที่ง่ายที่สุดสำหรับฉันที่จะเข้าใจคือการพูดคุยเกี่ยวกับว่าคุณกำลังคำนวณสถิติสำหรับแต่ละคอลัมน์ ( axis = 0) หรือแต่ละแถว ( axis = 1) หากคุณคำนวณสถิติให้พูดว่าค่าเฉลี่ยaxis = 0คุณจะได้รับสถิตินั้นสำหรับแต่ละคอลัมน์ ดังนั้นหากการสังเกตแต่ละครั้งเป็นแถวและแต่ละตัวแปรอยู่ในคอลัมน์คุณจะได้ค่าเฉลี่ยของตัวแปรแต่ละตัว หากคุณตั้งค่าไว้axis = 1คุณจะคำนวณสถิติของคุณสำหรับแต่ละแถว ในตัวอย่างของเราคุณจะได้รับค่าเฉลี่ยสำหรับการสังเกตแต่ละครั้งของตัวแปรทั้งหมดของคุณ (บางทีคุณอาจต้องการค่าเฉลี่ยของมาตรการที่เกี่ยวข้อง)

axis = 0: by column = column-wise = ตามแถว

axis = 1: by row = row-wise = ตามคอลัมน์

ลองดูที่ตารางจาก Wiki นี่เป็นประมาณการ GDP ของกองทุนการเงินระหว่างประเทศตั้งแต่ปี 2010 ถึง 2019 สำหรับสิบประเทศ

1. แกน 1 จะทำหน้าที่ของแต่ละแถวในคอลัมน์ทั้งหมด
หากคุณต้องการที่จะคำนวณค่าเฉลี่ย (ค่าเฉลี่ย) จีดีพีของประเทศแต่ละกว่าทศวรรษที่ผ่านมา (2010-2019), df.mean(axis=1)คุณต้องทำ ตัวอย่างเช่นหากคุณต้องการคำนวณค่าเฉลี่ย GDP ของสหรัฐอเมริกาตั้งแต่ปี 2010 ถึงปี 2019df.loc['United States','2010':'2019'].mean(axis=1)

2. แกน 0 จะทำหน้าที่สำหรับแต่ละคอลัมน์ในแถวทั้งหมด
ถ้าผมต้องการที่จะคำนวณค่าเฉลี่ย (ค่าเฉลี่ย) GDP df.mean(axis=0)ในแต่ละปีสำหรับทุกประเทศที่คุณต้องทำ ตัวอย่างเช่นหากคุณต้องการคำนวณค่าเฉลี่ยจีดีพีของปี 2558 สำหรับสหรัฐอเมริกาจีนญี่ปุ่นเยอรมนีและอินเดียdf.loc['United States':'India','2015'].mean(axis=0)

หมายเหตุ:รหัสด้านบนจะทำงานหลังจากตั้งค่าคอลัมน์ "ประเทศ (หรือดินแดนที่ขึ้นต่อกัน)" เป็นดัชนีโดยใช้set_indexวิธี.

แกนในมุมมองของการเขียนโปรแกรมเป็นตำแหน่งใน tuple รูปร่าง นี่คือตัวอย่าง:

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) การใช้ axis = 1 จะเปลี่ยนรูปร่างเป็น (1,)

Wes McKinney ผู้ออกแบบแพนด้าใช้ในการทำงานอย่างหนักกับข้อมูลทางการเงิน คิดว่าคอลัมน์เป็นชื่อหุ้นและดัชนีเป็นราคารายวัน จากนั้นคุณสามารถเดาได้ว่าพฤติกรรมเริ่มต้นคืออะไร (เช่นaxis=0) ที่เกี่ยวกับข้อมูลทางการเงินนี้ axis=1สามารถคิดได้ง่ายๆว่า 'ทิศทางอื่น'

ยกตัวอย่างเช่นฟังก์ชั่นสถิติเช่นmean(), sum(), describe(), count()เริ่มต้นทุกคอลัมน์ที่ชาญฉลาดเพราะมันทำให้รู้สึกมากขึ้นจะทำพวกเขาสำหรับแต่ละหุ้น sort_index(by=)เริ่มต้นที่คอลัมน์ fillna(method='ffill')จะเติมคอลัมน์ตามเพราะมันเป็นหุ้นเดียวกัน dropna()เริ่มต้นที่แถวเพราะคุณอาจต้องการทิ้งราคาในวันนั้นแทนที่จะทิ้งราคาทั้งหมดของหุ้นนั้น

ในทำนองเดียวกันการทำดัชนีวงเล็บเหลี่ยมหมายถึงคอลัมน์เนื่องจากมันเป็นเรื่องธรรมดามากกว่าที่จะเลือกหุ้นแทนที่จะเลือกวัน

หนึ่งในวิธีที่ง่ายต่อการจดจำแกน 1 (คอลัมน์), เทียบกับแกน 0 (แถว) คือผลลัพธ์ที่คุณคาดหวัง

• หากคุณคาดหวังเอาต์พุตสำหรับแต่ละแถวคุณใช้ axis = 'column'
• ในทางกลับกันถ้าคุณต้องการเอาท์พุทสำหรับแต่ละคอลัมน์คุณใช้ axis = 'rows'

ปัญหาเกี่ยวกับการใช้axis=อย่างถูกต้องมีไว้สำหรับการใช้งานสำหรับ 2 กรณีหลักที่แตกต่างกัน:

1. สำหรับการคำนวณค่าสะสมหรือจัดเรียงข้อมูล (เช่นการเรียงลำดับ)
2. สำหรับจัดการเอนทิตี ( "กำลังเล่น" กับ) (เช่นดาต้าเกม )

แนวคิดหลักที่อยู่เบื้องหลังคำตอบนี้คือเพื่อหลีกเลี่ยงความสับสนเราเลือกตัวเลขหรือชื่อเพื่อระบุแกนที่เฉพาะเจาะจงใดก็ตามที่มีความชัดเจนมากขึ้นมีความชาญฉลาดและมีความหมาย

นุ่นอยู่บนพื้นฐานของ NumPy ซึ่งขึ้นอยู่กับคณิตศาสตร์โดยเฉพาะอย่างยิ่งในการฝึกอบรมมิติ นี่คือรูปภาพสำหรับการใช้งานทั่วไปของชื่อแกนในคณิตศาสตร์ในพื้นที่ 3 มิติ:

รูปภาพนี้ใช้สำหรับจดจำหมายเลขลำดับของแกนเท่านั้น:

• 0 สำหรับแกน x
• 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'เพื่อระบุการเปลี่ยนแปลงผลลัพธ์ - ดัชนี ( แถว ) หรือคอลัมน์ตามลำดับ
   (สำหรับการต่อข้อมูลคุณจะได้ดัชนีที่ยาวขึ้น (= แถวมากขึ้น)หรือหลายคอลัมน์ตามลำดับ)

นี่เป็นไปตามคำตอบของ @ Safak วิธีที่ดีที่สุดในการทำความเข้าใจกับแกนใน pandas / numpy คือการสร้างอาร์เรย์ 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.]])

ฉันเข้าใจวิธีนี้:

กล่าวว่าหากการดำเนินการของคุณต้องการการข้ามผ่านจากซ้ายไปขวา / ขวาไปซ้ายในดาต้าเฟรมคุณจะเห็นว่าเป็นการผสานคอลัมน์เช่น คุณกำลังทำงานในคอลัมน์ต่างๆ นี่คือแกน = 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

จุดที่ควรทราบที่นี่คือเรากำลังดำเนินการกับคอลัมน์

ในทำนองเดียวกันหากการดำเนินการของคุณต้องการการสำรวจจากด้านบนสู่ด้านล่าง / ล่างสู่บนใน dataframe คุณกำลังรวมแถว นี่คือแกน = 0

axis = 0 หมายถึงแกนขึ้นลง = 1 หมายถึงจากซ้ายไปขวา

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

ตัวอย่างที่ได้รับคือการรวมของข้อมูลทั้งหมดในคอลัมน์ == สำคัญ

ความคิดของฉัน: Axis = n โดยที่ n = 0, 1 ฯลฯ หมายความว่าเมทริกซ์นั้นยุบ (พับ) ตามแนวแกนนั้น ดังนั้นในเมทริกซ์ 2 มิติเมื่อคุณยุบตาม 0 (แถว) คุณกำลังทำงานกับคอลัมน์หนึ่งครั้ง เช่นเดียวกันสำหรับเมทริกซ์คำสั่งที่สูงขึ้น

สิ่งนี้ไม่เหมือนกับการอ้างอิงปกติถึงมิติในเมทริกซ์โดยที่คอลัมน์ 0 -> และคอลัมน์ 1 -> ในทำนองเดียวกันสำหรับมิติอื่น ๆ ในอาร์เรย์มิติ N

ฉันเป็นมือใหม่สำหรับแพนด้า แต่นี่คือวิธีที่ฉันเข้าใจแกนในหมีแพนด้า:

แกน คง แม่เหล็ก ทิศทาง

0 คอลัมน์แถวลง

1 แถวคอลัมน์ไปทางขวา ->

ดังนั้นในการคำนวณค่าเฉลี่ยของคอลัมน์คอลัมน์นั้นควรคงที่แต่แถวใต้นั้นสามารถเปลี่ยนแปลงได้(แปรผัน)ดังนั้นมันจึงเป็นแกน = 0

ในการคำนวณหาค่าเฉลี่ยของแถวนั้นแถวนั้นคงที่แต่มันสามารถเคลื่อนที่ผ่านคอลัมน์ต่าง ๆ (แปรเปลี่ยน) , Axis = 1

ฉันคิดว่ามีวิธีอื่นที่จะเข้าใจ

สำหรับ np.array ถ้าเราต้องการกำจัดคอลัมน์เราใช้ axis = 1; ถ้าเราต้องการกำจัดแถวเราใช้ axis = 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

ฉันจะหลีกเลี่ยงการใช้ 'แถวที่ชาญฉลาด' หรือ 'ตามแนวคอลัมน์' อย่างชัดเจนเนื่องจากผู้คนอาจตีความพวกเขาในทางที่ผิด

อุปมาก่อน โดยสังเขปคุณคาดหวังว่าpandas.DataFrame.drop(axis='column')จะลดลงคอลัมน์จากคอลัมน์ N และให้คอลัมน์ (N - 1) ดังนั้นคุณจึงไม่ต้องใส่ใจกับแถวในตอนนี้ (และลบคำว่า 'row' ออกจากพจนานุกรมภาษาอังกฤษของคุณ) ในทางกลับกันdrop(axis='row')ทำงานได้กับแถว

ในทำนองเดียวกันsum(axis='column')ทำงานในหลายคอลัมน์และให้ 1 คอลัมน์ ในทำนองเดียวกันsum(axis='row')ผลลัพธ์ใน 1 แถว สิ่งนี้สอดคล้องกับคำจำกัดความรูปแบบที่ง่ายที่สุดโดยลดรายการตัวเลขให้เป็นตัวเลขเดียว

โดยทั่วไปaxis=columnคุณจะเห็นคอลัมน์ทำงานกับคอลัมน์และรับคอลัมน์ ลืมแถว

ด้วยaxis=rowเปลี่ยนมุมมองและทำงานกับแถว

0 และ 1 เป็นเพียงนามแฝงสำหรับ 'แถว' และ 'คอลัมน์' มันเป็นหลักการของการทำดัชนีเมทริกซ์

ฉันพยายามหาแกนสำหรับชั่วโมงที่แล้วเช่นกัน ภาษาในคำตอบข้างต้นทั้งหมดรวมถึงเอกสารไม่เป็นประโยชน์

เพื่อตอบคำถามตามที่ฉันเข้าใจในตอนนี้ใน Pandas, Axis = 1 หรือ 0 หมายความว่าคุณต้องการให้ส่วนหัวของแกนคงที่เมื่อใช้ฟังก์ชัน

หมายเหตุ: เมื่อฉันพูดส่วนหัวฉันหมายถึงชื่อดัชนี

ขยายตัวอย่างของคุณ:

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

สำหรับแกน = 1 = คอลัมน์: เรารักษาค่าคงที่ส่วนหัวของคอลัมน์และใช้ฟังก์ชัน Mean โดยการเปลี่ยนข้อมูล ในการสาธิตเราคงค่าคงที่ของส่วนหัวคอลัมน์ดังนี้

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

ตอนนี้เราเติมค่า A และ B หนึ่งชุดแล้วหาค่าเฉลี่ย

|            | 0.626386| 1.52325|  

จากนั้นเราเติมค่าชุด A และ B ชุดถัดไปและค้นหาค่าเฉลี่ย

|            | 0.626386| 1.52325|

ในทำนองเดียวกันสำหรับแกน = แถวเราจะคงที่ส่วนหัวของแถวและการเปลี่ยนแปลงข้อมูล: ในการสาธิตก่อนอื่นให้แก้ไขส่วนหัวของแถว:

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

ทีนี้เติมค่า X และ Y ชุดแรกแล้วหาค่าเฉลี่ย

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

จากนั้นใส่ค่า X และ Y ชุดถัดไปจากนั้นหาค่าเฉลี่ย:

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

สรุป,

เมื่อแกน = คอลัมน์คุณแก้ไขส่วนหัวของคอลัมน์และเปลี่ยนข้อมูลซึ่งจะมาจากแถวที่แตกต่างกัน

เมื่อแกน = แถวคุณแก้ไขส่วนหัวของแถวและเปลี่ยนข้อมูลซึ่งจะมาจากคอลัมน์ที่แตกต่างกัน

แกน = 1 มันจะให้ผลรวมแถวที่ชาญฉลาด keepdims = จริงจะรักษามิติ 2D หวังว่ามันจะช่วยคุณ

คำตอบมากมายที่นี่ช่วยฉันได้มาก!

ในกรณีที่คุณสับสนกับพฤติกรรมที่แตกต่างของaxisใน Python และMARGINใน R (เช่นในapplyฟังก์ชั่น) คุณอาจพบโพสต์บล็อกที่ฉันเขียนน่าสนใจ: https://accio.github.io/programming/2020/05/ 19

ในสาระสำคัญ:

• พฤติกรรมของพวกเขาน่าสนใจและเข้าใจง่ายกว่าด้วยอาเรย์สามมิติมากกว่าอาเรย์สองมิติ
• ในแพ็กเกจ Python numpyและpandasพารามิเตอร์แกนโดยรวมระบุ numpy เพื่อคำนวณค่าเฉลี่ยของค่าทั้งหมดที่สามารถดึงข้อมูลในรูปแบบของอาร์เรย์ [0, 0, ... , i, ... , 0] โดยที่ฉันทำซ้ำผ่าน ค่าที่เป็นไปได้ทั้งหมด กระบวนการซ้ำกับตำแหน่งของฉันคงที่และดัชนีของมิติอื่น ๆ จะแตกต่างกันไปตามลำดับ (จากองค์ประกอบที่อยู่ด้านขวาสุด) ผลลัพธ์คืออาร์เรย์ n-1 มิติ
• ใน R พารามิเตอร์ MARGINS อนุญาตให้applyฟังก์ชันคำนวณค่าเฉลี่ยของค่าทั้งหมดที่สามารถดึงข้อมูลได้ในรูปแบบของอาร์เรย์ [, ... , i, ... ,] ซึ่งฉันทำซ้ำผ่านค่าที่เป็นไปได้ทั้งหมด กระบวนการไม่ซ้ำกันเมื่อทุกค่า i ถูกวนซ้ำแล้ว ดังนั้นผลลัพธ์จึงเป็นเวกเตอร์ง่าย ๆ

อาร์เรย์ได้รับการออกแบบด้วยแกนที่เรียกว่า = 0 และแถวที่อยู่ในแนวตั้งเมื่อเทียบกับแกน = 1 และคอลัมน์ในแนวนอน Axis หมายถึงขนาดของอาร์เรย์