Apa arti sumbu dalam panda?

Ini kode saya untuk menghasilkan dataframe:

import pandas as pd
import numpy as np

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

maka saya mendapatkan dataframe:

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

Saat saya mengetik perintah:

dff.mean(axis=1)

Saya mendapatkan :

0    1.074821
dtype: float64

Menurut referensi panda, sumbu = 1 adalah singkatan dari kolom dan saya mengharapkan hasil dari perintah menjadi

A    0.626386
B    1.523255
dtype: float64

Jadi, inilah pertanyaan saya: apa arti sumbu dalam panda?

Ini menentukan sumbu di mana cara dihitung. Secara default axis=0. Ini konsisten dengan numpy.meanpenggunaan ketika axisditentukan secara eksplisit (dalam numpy.mean, sumbu == Tidak ada secara default, yang menghitung nilai rata-rata di atas array yang diratakan), di mana di axis=0sepanjang baris (yaitu, indeks dalam panda), dan di axis=1sepanjang kolom . Untuk kejelasan tambahan, seseorang dapat memilih untuk menentukan axis='index'(bukan axis=0) atau axis='columns'(bukan axis=1).

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

Jawaban-jawaban ini memang membantu menjelaskan hal ini, tetapi masih belum sepenuhnya intuitif untuk non-programmer (yaitu seseorang seperti saya yang sedang belajar Python untuk pertama kalinya dalam konteks kursus ilmu data). Saya masih menemukan menggunakan istilah "sepanjang" atau "untuk masing-masing" wrt ke baris dan kolom menjadi membingungkan.

Yang lebih masuk akal bagi saya adalah mengatakannya seperti ini:

• Sumbu 0 akan bekerja pada semua BARIS di setiap KOLOM
• Sumbu 1 akan bertindak pada semua KOLOM di setiap ROW

Jadi rata-rata pada sumbu 0 akan menjadi rata-rata dari semua baris di setiap kolom, dan rata-rata pada sumbu 1 akan menjadi rata-rata dari semua kolom di setiap baris.

Pada akhirnya ini mengatakan hal yang sama dengan @zhangxaochen dan @Michael, tetapi dengan cara yang lebih mudah bagi saya untuk menginternalisasi.

Mari kita visualisasikan (Anda akan selalu ingat),

Dalam panda:

1. axis = 0 berarti sepanjang "indeks". Ini operasi bijaksana .

Misalkan, untuk melakukan operasi concat () pada dataframe1 & dataframe2, kami akan mengambil dataframe1 & mengambil baris ke-1 dari dataframe1 dan menempatkannya ke DF baru, kemudian kami mengambil baris lain dari dataframe1 dan dimasukkan ke dalam DF baru, kami ulangi proses ini sampai kita mencapai bagian bawah dataframe1. Kemudian, kami melakukan proses yang sama untuk dataframe2.

Pada dasarnya, susun dataframe2 di atas dataframe1 atau sebaliknya.

Misalnya membuat tumpukan buku di atas meja atau lantai

2. axis = 1 berarti sepanjang "kolom". Ini operasi bijaksana kolom.

Misalkan, untuk melakukan operasi concat () pada dataframe1 & dataframe2, kami akan mengeluarkan kolom lengkap 1 (alias seri 1) dari dataframe1 dan menempatkannya ke DF baru, kemudian kami mengambil kolom kedua dari dataframe1 dan tetap bersebelahan dengannya (menyamping) ) , kita harus mengulangi operasi ini sampai semua kolom selesai. Kemudian, kami mengulangi proses yang sama pada dataframe2. Pada dasarnya, susun dataframe2 ke samping.

Misalnya mengatur buku di rak buku.

Lebih dari itu, karena array adalah representasi yang lebih baik untuk mewakili struktur n-dimensi bersarang dibandingkan dengan matriks! jadi di bawah ini dapat membantu Anda lebih memvisualisasikan bagaimana sumbu memainkan peran penting ketika Anda menggeneralisasi lebih dari satu dimensi. Juga, Anda sebenarnya dapat mencetak / menulis / menggambar / memvisualisasikan array n-dim, tetapi, menulis atau memvisualisasikan yang sama dalam representasi matriks (3-redup) tidak mungkin pada kertas lebih dari 3-dimensi.

axismengacu pada dimensi array, dalam kasus pd.DataFrames axis=0adalah dimensi yang menunjuk ke bawah danaxis=1 yang menunjuk ke kanan.

Contoh: Pikirkan ndarraybentuk dengan (3,5,7).

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

aadalah 3 dimensi ndarray, yaitu memiliki 3 sumbu ("sumbu" adalah jamak dari "sumbu"). Konfigurasi aakan terlihat seperti 3 iris roti di mana setiap irisan adalah dimensi 5-oleh-7. a[0,:,:]akan merujuk pada irisan ke-0, a[1,:,:]akan merujuk pada irisan ke-1 dll.

a.sum(axis=0)akan berlaku sum()sepanjang sumbu ke-0 dari a. Anda akan menambahkan semua irisan dan berakhir dengan satu irisan bentuk (5,7).

a.sum(axis=0) setara dengan

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

bdan a.sum(axis=0)keduanya akan terlihat seperti ini

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.]])

Dalam a pd.DataFrame, sumbu bekerja dengan cara yang sama seperti dalam numpy.arrays: axis=0akan berlaku sum()atau fungsi reduksi lainnya untuk setiap kolom.

NB Dalam jawaban @ zhangxaochen, saya menemukan frasa "sepanjang baris" dan "di sepanjang kolom" sedikit membingungkan. axis=0harus merujuk ke "sepanjang setiap kolom", dan axis=1"di sepanjang setiap baris".

Cara termudah bagi saya untuk mengerti adalah berbicara tentang apakah Anda menghitung statistik untuk setiap kolom ( axis = 0) atau setiap baris ( axis = 1). Jika Anda menghitung statistik, katakan mean, dengan axis = 0Anda akan mendapatkan statistik itu untuk setiap kolom. Jadi jika setiap pengamatan adalah baris dan setiap variabel dalam kolom, Anda akan mendapatkan rata-rata dari setiap variabel. Jika Anda mengaturaxis = 1 maka Anda akan menghitung statistik Anda untuk setiap baris. Dalam contoh kami, Anda akan mendapatkan rata-rata untuk setiap pengamatan di semua variabel Anda (mungkin Anda ingin rata-rata ukuran terkait).

axis = 0: dengan kolom = kolom-bijaksana = di sepanjang baris

axis = 1: dengan baris = baris-bijaksana = di sepanjang kolom

Mari kita lihat tabel dari Wiki. Ini adalah perkiraan IMF untuk PDB dari 2010 hingga 2019 untuk sepuluh negara teratas.

1. Sumbu 1 akan berlaku untuk setiap baris pada semua kolom
Jika Anda ingin menghitung rata-rata (rata-rata) PDB untuk masing-masing negara selama satu dekade (2010-2019), Anda perlu melakukannya df.mean(axis=1),. Misalnya, jika Anda ingin menghitung rata-rata PDB Amerika Serikat dari 2010 hingga 2019,df.loc['United States','2010':'2019'].mean(axis=1)

2. Sumbu 0 akan berlaku untuk setiap kolom pada semua baris
Jika saya ingin menghitung rata-rata (rata-rata) PDB untuk setiap tahun untuk semua negara, Anda harus melakukan df.mean(axis=0),. Misalnya, jika Anda ingin menghitung PDB rata-rata tahun 2015 untuk Amerika Serikat, Cina, Jepang, Jerman, dan India, df.loc['United States':'India','2015'].mean(axis=0)

Catatan: Kode di atas hanya akan berfungsi setelah menetapkan kolom "Negara (atau wilayah dependen)" sebagai Indeks, menggunakan set_indexmetode.

Sumbu dalam pandangan pemrograman adalah posisi dalam bentuk tuple. Berikut ini sebuah contoh:

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)

Berarti pada sumbu akan menyebabkan dimensi itu dihapus.

Mengacu pada pertanyaan awal, bentuk dff adalah (1,2). Menggunakan sumbu = 1 akan mengubah bentuk ke (1,).

Perancang panda, Wes McKinney, dulu bekerja secara intensif pada data keuangan. Pikirkan kolom sebagai nama stok dan indeks sebagai harga harian. Anda kemudian dapat menebak apa perilaku default (yaitu, axis=0) sehubungan dengan data keuangan ini. axis=1dapat dengan mudah dianggap sebagai 'arah yang lain'.

Sebagai contoh, statistik fungsi, seperti mean(), sum(), describe(), count()semua default kolom-bijaksana karena lebih masuk akal untuk melakukannya untuk setiap saham. sort_index(by=)juga default ke kolom. fillna(method='ffill')akan mengisi kolom karena itu adalah stok yang sama.dropna()default ke baris karena Anda mungkin hanya ingin membuang harga pada hari itu daripada membuang semua harga saham itu.

Demikian pula, pengindeksan tanda kurung siku mengacu pada kolom karena lebih umum untuk memilih saham daripada memilih sehari.

salah satu cara mudah untuk mengingat sumbu 1 (kolom), vs sumbu 0 (baris) adalah output yang Anda harapkan.

• jika Anda mengharapkan output untuk setiap baris Anda menggunakan sumbu = 'kolom',
• di sisi lain jika Anda menginginkan output untuk setiap kolom Anda menggunakan sumbu = 'baris'.

Masalah dengan menggunakan dengan axis=benar adalah untuk penggunaannya untuk 2 kasus berbeda:

1. Untuk menghitung nilai yang terakumulasi , atau menyusun ulang (mis. Pengurutan) data.
2. Untuk memanipulasi ("bermain" dengan) entitas (mis. Dataframe ).

Gagasan utama di balik jawaban ini adalah untuk menghindari kebingungan, kami memilih salah satu angka , atau nama untuk menentukan sumbu tertentu, mana yang lebih jelas, intuitif, dan deskriptif.

Panda didasarkan pada NumPy, yang didasarkan pada matematika, terutama pada matriks n-dimensi. Berikut adalah gambar untuk penggunaan umum nama sumbu dalam matematika dalam ruang 3 dimensi:

Gambar ini hanya untuk mengingat nomor urut sumbu saja:

• 0 untuk sumbu x,
• 1 untuk sumbu y, dan
• 2 untuk sumbu z.

The z-axis hanya untuk panel ; untuk kerangka data, kami akan membatasi minat kami pada bidang dasar 2 dimensi berwarna hijau dengan sumbu x ( 0, vertikal) , dan sumbu y ( 1, horizontal).

Itu semua untuk angka sebagai nilai potensial dari axis=parameter.

Nama - nama sumbu adalah 'index'(Anda dapat menggunakan alias 'rows') dan 'columns', dan untuk penjelasan ini TIDAK penting hubungan antara nama-nama ini dan nomor urut (dari sumbu), karena semua orang tahu apa arti kata "baris" dan "kolom" ( dan semua orang di sini - saya kira - tahu apa arti kata "indeks" dalam panda).

Dan sekarang, rekomendasi saya:

1. Jika Anda ingin menghitung nilai akumulasi , Anda dapat menghitungnya dari nilai yang terletak di sepanjang sumbu 0 (atau sepanjang sumbu 1 ) - gunakan axis=0(atau axis=1).

   Demikian pula, jika Anda ingin mengatur ulang nilai , gunakan nomor sumbu dari sumbu, di sepanjang itu terdapat data untuk mengatur ulang (misalnya untuk menyortir ).

2. Jika Anda ingin memanipulasi (misalnya, menyatukan ) entitas (misalnya, kerangka data ) - gunakan axis='index'(sinonim :)axis='rows' atau axis='columns'untuk menentukan perubahan yang dihasilkan - indeks ( baris ) atau kolom , masing-masing.
   (Untuk penggabungan , Anda akan mendapatkan indeks yang lebih panjang (= lebih banyak baris) , atau lebih banyak kolom , masing-masing.)

Ini berdasarkan jawaban @ Safak. Cara terbaik untuk memahami sumbu dalam panda / numpy adalah membuat array 3d dan memeriksa hasil dari fungsi penjumlahan di sepanjang 3 sumbu yang berbeda.

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

a akan:

    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.]]])

Sekarang periksa jumlah elemen array di sepanjang masing-masing sumbu:

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

akan memberi Anda hasil berikut:

   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.]])

Saya mengerti seperti ini:

Katakanlah jika operasi Anda memerlukan traverse dari kiri ke kanan / kanan ke kiri dalam bingkai data, Anda tampaknya menggabungkan kolom. Anda beroperasi di berbagai kolom. Ini adalah sumbu = 1

Contoh

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

Poin yang perlu diperhatikan di sini adalah kami beroperasi pada kolom

Demikian pula, jika operasi Anda memerlukan lintasan dari atas ke bawah / bawah ke atas dalam kerangka data, Anda menggabungkan baris. Ini adalah sumbu = 0 .

sumbu = 0 berarti atas ke bawah sumbu = 1 berarti kiri ke kanan

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

Contoh yang diberikan adalah mengambil jumlah semua data dalam kolom == kunci.

Pemikiran saya: Sumbu = n, di mana n = 0, 1, dll. Berarti bahwa matriks diciutkan (dilipat) di sepanjang sumbu itu. Jadi dalam matriks 2D, ketika Anda runtuh sepanjang 0 (baris), Anda benar-benar beroperasi pada satu kolom pada suatu waktu. Demikian pula untuk matriks pesanan yang lebih tinggi.

Ini tidak sama dengan referensi normal ke dimensi dalam matriks, di mana 0 -> baris dan 1 -> kolom. Demikian pula untuk dimensi lain dalam larik dimensi N.

Saya seorang pemula untuk panda. Tapi ini adalah bagaimana saya memahami sumbu dalam panda:

Arah Memvariasikan Sumbu Konstan

0 Baris Kolom Ke Bawah |

1 Baris Kolom Menuju Kanan ->

Jadi untuk menghitung rata-rata kolom, kolom tertentu itu harus konstan tetapi baris di bawahnya dapat berubah (bervariasi) sehingga sumbu = 0.

Demikian pula, untuk menghitung rata-rata baris, baris tertentu itu konstan tetapi dapat melintasi kolom yang berbeda (bervariasi) , sumbu = 1.

Saya pikir ada cara lain untuk memahaminya.

Untuk np.array, jika kita ingin menghilangkan kolom kita menggunakan sumbu = 1; jika kita ingin menghilangkan baris, kita menggunakan sumbu = 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,)

Untuk objek panda, axis = 0singkatan dari operasi baris-bijaksana dan axis = 1singkatan dari operasi kolom-bijaksana. Ini berbeda dari numpydefinisi, kita dapat memeriksa definisi dari numpy.doc dan pandas.doc

Saya akan secara eksplisit menghindari penggunaan 'bijaksana baris' atau 'sepanjang kolom', karena orang mungkin menafsirkannya dengan cara yang salah.

Analogi dulu. Secara intuitif, Anda akan mengharapkan yang pandas.DataFrame.drop(axis='column')menjatuhkan kolom dari N kolom dan memberi Anda (N - 1) kolom. Jadi Anda tidak dapat memperhatikan baris untuk saat ini (dan menghapus kata 'baris' dari kamus bahasa Inggris Anda.) Begitu juga sebaliknya, drop(axis='row')berfungsi pada baris.

Dengan cara yang sama, sum(axis='column')bekerja pada banyak kolom dan memberi Anda 1 kolom. Demikian pula, sum(axis='row')menghasilkan 1 baris. Ini konsisten dengan bentuk definisi yang paling sederhana, mengurangi daftar angka menjadi angka tunggal.

Secara umum, dengan axis=column, Anda melihat kolom, mengerjakan kolom, dan mendapatkan kolom. Lupakan baris.

Dengan axis=row, ubah perspektif dan kerjakan baris.

0 dan 1 hanya alias untuk 'baris' dan 'kolom'. Ini adalah konvensi pengindeksan matriks.

Saya telah mencoba mencari tahu poros selama satu jam terakhir juga. Bahasa dalam semua jawaban di atas, dan juga dokumentasi sama sekali tidak membantu.

Untuk menjawab pertanyaan seperti yang saya mengerti sekarang, di Panda, sumbu = 1 atau 0 berarti header sumbu mana yang ingin Anda pertahankan konstan ketika menerapkan fungsi.

Catatan: Saat saya mengucapkan tajuk, maksud saya adalah nama indeks

Memperluas contoh Anda:

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

Untuk sumbu = 1 = kolom: Kami menjaga header kolom konstan dan menerapkan fungsi rata-rata dengan mengubah data. Untuk menunjukkan, kami menjaga header kolom konstan seperti:

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

Sekarang kita mengisi satu set nilai A dan B dan kemudian menemukan mean

|            | 0.626386| 1.52325|  

Kemudian kita mengisi set nilai A dan B berikutnya dan menemukan rerata

|            | 0.626386| 1.52325|

Demikian pula, untuk sumbu = baris, kami menjaga header baris tetap, dan terus mengubah data: Untuk menunjukkan, pertama-tama perbaiki header baris:

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

Sekarang isi set pertama nilai X dan Y dan kemudian temukan rerata

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

Kemudian mengisi set nilai X dan Y berikutnya dan kemudian menemukan mean:

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

Singkatnya,

Saat sumbu = kolom, Anda memperbaiki header kolom dan mengubah data, yang akan datang dari baris yang berbeda.

Saat sumbu = baris, Anda memperbaiki header baris dan mengubah data, yang akan datang dari kolom yang berbeda.

axis = 1, Ini akan memberikan jumlah baris yang bijaksana, keepdims = True akan mempertahankan dimensi 2D. Semoga ini bisa membantu Anda.

Banyak jawaban di sini banyak membantu saya!

Jika Anda bingung dengan perilaku yang berbeda axisdalam Python dan MARGINdalam R (seperti dalam applyfungsi), Anda dapat menemukan posting blog yang saya tulis menarik: https://accio.github.io/programming/2020/05// 19 / numpy-panda-axis.html .

Intinya:

• Perilaku mereka, secara menarik, lebih mudah dipahami dengan array tiga dimensi daripada dengan array dua dimensi.
• Dalam paket Python numpydan pandas, parameter sumbu dalam jumlah sebenarnya menentukan numpy untuk menghitung rata-rata semua nilai yang dapat diambil dalam bentuk array [0, 0, ..., i, ..., 0] di mana saya mengulangi semua nilai yang mungkin. Proses ini diulangi dengan posisi i fix dan indeks dimensi lain bervariasi satu demi satu (dari elemen paling kanan). Hasilnya adalah array n-1-dimensi.
• Dalam R, parameter MARGINS membiarkan applyfungsi menghitung rata-rata semua nilai yang dapat diambil dalam bentuk array [, ..., i, ...,] di mana saya mengulangi semua nilai yang mungkin. Proses tidak diulangi ketika semua nilai i telah diulang. Karena itu, hasilnya adalah vektor sederhana.

Array dirancang dengan apa yang disebut sumbu = 0 dan baris diposisikan secara vertikal versus sumbu = 1 dan kolom diposisikan secara horizontal. Sumbu mengacu pada dimensi array.