Che cosa significa axis in panda?

Ecco il mio codice per generare un frame di dati:

import pandas as pd
import numpy as np

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

poi ho ottenuto il frame di dati:

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

Quando scrivo il comando:

dff.mean(axis=1)

Ho ottenuto :

0    1.074821
dtype: float64

Secondo il riferimento di Panda, axis = 1 sta per colonne e mi aspetto che il risultato del comando sia

A    0.626386
B    1.523255
dtype: float64

Quindi, ecco la mia domanda: cosa significa asse in panda?

Specifica l'asse lungo il quale vengono calcolati i mezzi. Di default axis=0. Ciò è coerente con l' numpy.meanuso quando axisè specificato esplicitamente (in numpy.mean, axis == None per impostazione predefinita, che calcola il valore medio sull'array appiattito), in cui axis=0lungo le righe (vale a dire, indice in panda) e axis=1lungo le colonne . Per maggiore chiarezza, si può scegliere di specificare axis='index'(invece di axis=0) o axis='columns'(invece di axis=1).

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

Queste risposte aiutano a spiegarlo, ma non è ancora perfettamente intuitivo per un non programmatore (vale a dire qualcuno come me che sta imparando Python per la prima volta nel contesto dei corsi di scienza dei dati). Trovo ancora confuso l'uso dei termini "insieme" o "per ogni" scritto su righe e colonne.

Ciò che ha più senso per me è dirlo in questo modo:

• L'asse 0 agirà su tutte le file di ogni COLONNA
• L'Asse 1 agirà su tutte le COLONNE di ogni FILA

Quindi una media sull'asse 0 sarà la media di tutte le righe di ciascuna colonna e una media sull'asse 1 sarà la media di tutte le colonne di ciascuna riga.

In definitiva questo sta dicendo la stessa cosa di @zhangxaochen e @Michael, ma in un modo che è più facile per me interiorizzare.

Visualizziamo (ricorderai per sempre),

In panda:

1. asse = 0 significa lungo "indici". È un'operazione saggia .

Supponiamo che, per eseguire l'operazione concat () su dataframe1 e dataframe2, prenderemo dataframe1 ed elimineremo la 1a riga da dataframe1 e la inseriremo nel nuovo DF, quindi elimineremo un'altra riga da dataframe1 e inseriremo un nuovo DF, ripetiamo questo processo fino a arriviamo alla fine di dataframe1. Quindi, facciamo lo stesso processo per dataframe2.

Fondamentalmente, impilando dataframe2 sopra dataframe1 o viceversa.

Ad esempio fare una pila di libri su un tavolo o un pavimento

2. asse = 1 significa lungo "colonne". È un'operazione basata su colonne.

Supponiamo, per eseguire l'operazione concat () su dataframe1 e dataframe2, elimineremo la prima colonna completa (nota anche come prima serie) di dataframe1 e la inseriremo in un nuovo DF, quindi elimineremo la seconda colonna di dataframe1 e ci adotteremo adiacente (lateralmente ) , dobbiamo ripetere questa operazione fino al termine di tutte le colonne. Quindi, ripetiamo lo stesso processo su dataframe2. Fondamentalmente, impilando dataframe2 lateralmente.

Ad esempio organizzare libri su uno scaffale.

Inoltre, poiché le matrici sono rappresentazioni migliori per rappresentare una struttura nidimensionale nidificata rispetto alle matrici! quindi di seguito ti può aiutare di più a visualizzare come l'asse gioca un ruolo importante quando generalizzi a più di una dimensione. Inoltre, puoi effettivamente stampare / scrivere / disegnare / visualizzare qualsiasi array n-dim ma, scrivere o visualizzare lo stesso in una rappresentazione a matrice (3-dim) è impossibile su un foglio più di 3-dimensioni.

axissi riferisce alla dimensione dell'array, nel caso di pd.DataFrames axis=0è la dimensione che punta verso axis=1il basso e quella che punta verso destra.

Esempio: pensa a un ndarraycon la forma (3,5,7).

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

aè un 3 dimensionale ndarray, cioè ha 3 assi ("assi" è plurale di "asse"). La configurazione di aapparirà come 3 fette di pane in cui ogni fetta ha dimensione 5 per 7. a[0,:,:]farà riferimento alla fetta 0, a[1,:,:]farà riferimento alla fetta 1 ecc.

a.sum(axis=0)verrà applicato sum()lungo l'asse 0 ° di a. Aggiungerai tutte le fette e finirai con una fetta di forma (5,7).

a.sum(axis=0) è equivalente a

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

be a.sum(axis=0)sembreranno entrambi così

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

In a pd.DataFrame, gli assi funzionano allo stesso modo di in numpy.arrays: axis=0si applicherà sum()o qualsiasi altra funzione di riduzione per ogni colonna.

NB Nella risposta di @ zhangxaochen, trovo le frasi "lungo le file" e "lungo le colonne" leggermente confuse. axis=0dovrebbe fare riferimento a "lungo ogni colonna" e axis=1"lungo ogni riga".

Il modo più semplice per me di capire è parlare se stai calcolando una statistica per ogni colonna ( axis = 0) o ogni riga ( axis = 1). Se si calcola una statistica, dire una media, con axis = 0si otterrà quella statistica per ogni colonna. Quindi se ogni osservazione è una riga e ogni variabile è in una colonna, otterresti la media di ogni variabile. Se imposti axis = 1, calcolerai la tua statistica per ogni riga. Nel nostro esempio, otterresti la media per ogni osservazione attraverso tutte le tue variabili (forse vuoi la media delle misure correlate).

axis = 0: per colonna = colonna-saggio = lungo le file

axis = 1: per riga = riga-saggio = lungo le colonne

Diamo un'occhiata al tavolo di Wiki. Questa è una stima del FMI del PIL dal 2010 al 2019 per i primi dieci paesi.

1. L'asse 1 agirà per ogni riga su tutte le colonne
Se si desidera calcolare il PIL (medio) medio per OGNI paesi nel decennio (2010-2019), è necessario farlo df.mean(axis=1),. Ad esempio, se desideri calcolare il PIL medio degli Stati Uniti dal 2010 al 2019,df.loc['United States','2010':'2019'].mean(axis=1)

2. L'asse 0 funzionerà per ogni colonna su tutte le righe
Se voglio calcolare il PIL (medio) medio per OGNI anno per tutti i paesi, devi farlo df.mean(axis=0),. Ad esempio, se si desidera calcolare il PIL medio dell'anno 2015 per Stati Uniti, Cina, Giappone, Germania e India, df.loc['United States':'India','2015'].mean(axis=0)

Nota: il codice sopra funzionerà solo dopo aver impostato la colonna "Paese (o territorio dipendente)" come Indice, usando set_indexmetodo.

L'asse in vista della programmazione è la posizione nella tupla di forma. Ecco un esempio:

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)

La media sull'asse causerà la rimozione di quella dimensione.

Facendo riferimento alla domanda originale, la forma dff è (1,2). L'uso di axis = 1 cambierà la forma in (1,).

Il designer dei panda, Wes McKinney, lavorava intensamente sui dati finanziari. Pensa alle colonne come nomi di titoli e indicizza come prezzi giornalieri. È quindi possibile indovinare quale sia il comportamento predefinito (ovvero, axis=0) rispetto a questi dati finanziari. axis=1può essere semplicemente pensato come "l'altra direzione".

Ad esempio, le funzioni statistiche, ad esempio mean(), sum(), describe(), count()tutti di default colonna-saggio perché rende più senso fare loro per ogni stock. sort_index(by=)il valore predefinito è anche colonna. fillna(method='ffill')riempirà lungo la colonna perché è lo stesso stock. dropna()il valore predefinito è remare perché probabilmente vuoi semplicemente scartare il prezzo in quel giorno invece di buttare via tutti i prezzi di quel titolo.

Allo stesso modo, l'indicizzazione delle parentesi quadre si riferisce alle colonne poiché è più comune scegliere uno stock invece di scegliere un giorno.

uno dei modi più semplici per ricordare l'asse 1 (colonne) e l'asse 0 (righe) è l'output previsto.

• se ti aspetti un output per ogni riga che usi axis = 'colonne',
• d'altra parte, se si desidera un output per ogni colonna, si utilizza axis = 'righe'.

Il problema con l'uso axis=corretto è per il suo utilizzo per 2 casi diversi principali:

1. Per calcolare un valore accumulato o riorganizzare (ad esempio l'ordinamento) dei dati.
2. Per manipolare ("giocare" con) entità (ad es. Frame di dati ).

L'idea principale alla base di questa risposta è che per evitare la confusione, selezioniamo un numero o un nome per specificare il particolare asse, a seconda di quale sia più chiaro, intuitivo e descrittivo.

Panda si basa su NumPy, che si basa sulla matematica, in particolare su matrici n-dimensionali. Ecco un'immagine per l'uso comune dei nomi degli assi in matematica nello spazio tridimensionale:

Questa immagine serve solo per memorizzare i numeri ordinali degli assi :

• 0 per asse x,
• 1 per l'asse y e
• 2 per asse z.

L' asse z è solo per i pannelli ; per i frame di dati limiteremo il nostro interesse al piano di base bidimensionale di colore verde con asse x ( 0, verticale) e asse y ( 1, orizzontale).

È tutto per i numeri come potenziali valori del axis=parametro.

I nomi degli assi sono 'index'(puoi usare l'alias 'rows') e 'columns', e per questa spiegazione NON è importante la relazione tra questi nomi e numeri ordinali (degli assi), poiché tutti sanno cosa significano le parole "righe" e "colonne" ( e tutti qui - suppongo - sanno cosa significa la parola "indice" in panda).

E ora, la mia raccomandazione:

1. Se si desidera calcolare un valore accumulato , è possibile calcolarlo dai valori situati lungo l'asse 0 (o lungo l'asse 1 ) - utilizzare axis=0(o axis=1).

   Allo stesso modo, se si desidera riorganizzare i valori , utilizzare il numero dell'asse dell'asse, lungo il quale sono posizionati i dati per riorganizzare (ad es. Per l' ordinamento ).

2. Se si vuole manipolare (ad esempio concatenate ) le entità (ad es dataframes ) - uso axis='index'(sinonimo: axis='rows') o axis='columns'per specificare il conseguente cambiamento - Indice ( righe ) o colonne , rispettivamente.
   (Per la concatenazione , otterrai un indice più lungo (= più righe) o più colonne , rispettivamente.)

Questo si basa sulla risposta di @ Safak. Il modo migliore per comprendere gli assi in panda / numpy è creare un array 3d e controllare il risultato della funzione somma lungo i 3 diversi assi.

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

a sarà:

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

Ora controlla la somma degli elementi dell'array lungo ciascuno degli assi:

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

ti darà i seguenti risultati:

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

Capisco in questo modo:

Di 'se la tua operazione richiede l'attraversamento da sinistra a destra / da destra a sinistra in un frame di dati, apparentemente stai unendo colonne, ad es. stai operando su varie colonne. Questo è axis = 1

Esempio

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

Nota qui che stiamo operando su colonne

Allo stesso modo, se l'operazione richiede il passaggio dall'alto verso il basso / dal basso verso l'alto in un frame di dati, si stanno unendo le righe. Questo è axis = 0 .

axis = 0 significa up to down axis = 1 significa left to right

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

L'esempio dato sta prendendo la somma di tutti i dati nella colonna == chiave.

Il mio pensiero: Asse = n, dove n = 0, 1, ecc. Significa che la matrice è compressa (piegata) lungo quell'asse. Quindi in una matrice 2D, quando collassi lungo 0 (righe), stai realmente operando su una colonna alla volta. Allo stesso modo per matrici di ordine superiore.

Questo non è lo stesso del normale riferimento a una dimensione in una matrice, dove 0 -> riga e 1 -> colonna. Allo stesso modo per altre dimensioni in un array di dimensioni N.

Sono un principiante per i panda. Ma è così che capisco l'asse nei panda:

Axis Costante Variabile Direzione

0 Riga di colonne verso il basso |

1 colonna di fila verso destra ->

Quindi, per calcolare la media di una colonna, quella particolare colonna dovrebbe essere costante, ma le righe sottostanti possono cambiare (variando), quindi è axis = 0.

Allo stesso modo, per calcolare la media di una riga, quella particolare riga è costante ma può attraversare colonne diverse (variabili) , asse = 1.

Penso che ci sia un altro modo di capirlo.

Per un np.array, se vogliamo eliminare le colonne usiamo axis = 1; se vogliamo eliminare le righe, usiamo 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,)

Per oggetto Panda, axis = 0sta per operazione di riga e axis = 1per operazione di colonna. Questo è diverso dalla numpydefinizione, possiamo controllare le definizioni da numpy.doc e pandas.doc

Eviterò esplicitamente l'uso di "righe" o "lungo le colonne", poiché le persone potrebbero interpretarle esattamente nel modo sbagliato.

Prima l'analogia. Intuitivamente, ti aspetteresti che pandas.DataFrame.drop(axis='column')rilasci una colonna da N colonne e ti dia (N - 1) colonne. Quindi non puoi prestare attenzione alle righe per ora (e rimuovere la parola "riga" dal tuo dizionario inglese.) Viceversa, drop(axis='row')funziona sulle righe.

Allo stesso modo, sum(axis='column')funziona su più colonne e ti dà 1 colonna. Allo stesso modo, sum(axis='row')risulta in 1 riga. Ciò è coerente con la sua forma più semplice di definizione, riducendo un elenco di numeri a un singolo numero.

In generale, con axis=column, vedi colonne, lavori su colonne e ottieni colonne. Dimentica le righe.

Con axis=row, cambia prospettiva e lavora su file.

0 e 1 sono solo alias per "riga" e "colonna". È la convenzione dell'indicizzazione delle matrici.

Ho cercato di capire l'asse anche per l'ultima ora. La lingua in tutte le risposte sopra e anche la documentazione non sono affatto utili.

Per rispondere alla domanda come la capisco adesso, in Panda, axis = 1 o 0 significa quali intestazioni degli assi vuoi mantenere costante quando applichi la funzione.

Nota: quando dico le intestazioni, intendo i nomi degli indici

Espandi il tuo esempio:

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

Per axis = 1 = colonne: manteniamo costanti le intestazioni delle colonne e applichiamo la funzione media modificando i dati. Per dimostrare, manteniamo le intestazioni delle colonne costanti come:

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

Ora popoliamo un insieme di valori A e B e quindi troviamo la media

|            | 0.626386| 1.52325|  

Quindi popoliamo il prossimo set di valori A e B e troviamo la media

|            | 0.626386| 1.52325|

Allo stesso modo, per axis = righe, manteniamo costanti le intestazioni di riga e continuiamo a modificare i dati: Per dimostrare, innanzitutto correggi le intestazioni di riga:

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

Ora popola la prima serie di valori X e Y e quindi trova la media

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

Quindi popolare il prossimo set di valori X e Y e poi trova la media:

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

In sintesi,

Quando axis = colonne, correggi le intestazioni di colonna e cambi i dati, che verranno dalle diverse righe.

Quando axis = righe, correggi le intestazioni delle righe e cambi i dati, che verranno dalle diverse colonne.

axis = 1, darà la riga della somma saggia, keepdims = True manterrà la dimensione 2D. Spero che ti aiuti.

Molte risposte qui mi hanno aiutato molto!

Nel caso in cui vieni confuso dai diversi comportamenti di axisin Python e MARGINin R (come nella applyfunzione), potresti trovare un post sul blog che ho scritto di interesse: https://accio.github.io/programming/2020/05/ 19 / numpy-pandas-axis.html .

In sostanza:

• I loro comportamenti sono, in modo intrigante, più facili da comprendere con una matrice tridimensionale che con una matrice bidimensionale.
• Nei pacchetti Python numpye pandas, il parametro axis in somma in realtà specifica numpy per calcolare la media di tutti i valori che possono essere recuperati sotto forma di array [0, 0, ..., i, ..., 0] dove i iterate tutti i possibili valori. Il processo si ripete con la posizione di i fissa e gli indici di altre dimensioni variano uno dopo l'altro (dall'elemento più a destra). Il risultato è un array n-1-dimensionale.
• In R, il parametro MARGINS consente alla applyfunzione di calcolare la media di tutti i valori che possono essere recuperati sotto forma di array [, ..., i, ...,] dove scorre tutti i valori possibili. Il processo non si ripete quando tutti i valori i sono stati ripetuti. Pertanto, il risultato è un vettore semplice.

Le matrici sono progettate con il cosiddetto asse = 0 e le righe posizionate verticalmente rispetto all'asse = 1 e le colonne posizionate orizzontalmente. L'asse si riferisce alla dimensione dell'array.