¿Qué significa axis en pandas?

Aquí está mi código para generar un marco de datos:

import pandas as pd
import numpy as np

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

entonces obtuve el marco de datos:

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

Cuando escribo el comando:

dff.mean(axis=1)

Tengo :

0    1.074821
dtype: float64

De acuerdo con la referencia de pandas, axis = 1 representa columnas y espero que el resultado del comando sea

A    0.626386
B    1.523255
dtype: float64

Así que aquí está mi pregunta: ¿qué significa eje en pandas?

Especifica el eje a lo largo del cual se calculan las medias. De manera predeterminada axis=0. Esto es coherente con el numpy.meanuso cuando axisse especifica explícitamente (en numpy.mean, axis == None por defecto, que calcula el valor medio sobre la matriz aplanada), en el que a lo axis=0largo de las filas (es decir, el índice en pandas), y a lo axis=1largo de las columnas . Para mayor claridad, uno puede elegir especificar axis='index'(en lugar de axis=0) o axis='columns'(en lugar de axis=1).

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

Estas respuestas ayudan a explicar esto, pero todavía no es perfectamente intuitivo para un no programador (es decir, alguien como yo que está aprendiendo Python por primera vez en el contexto del curso de ciencias de datos). Todavía encuentro confuso el uso de los términos "a lo largo" o "para cada" wrt a filas y columnas.

Lo que tiene más sentido para mí es decirlo de esta manera:

• El eje 0 actuará en todas las FILAS de cada COLUMNA
• El eje 1 actuará en todas las COLUMNAS en cada FILA

Entonces, una media en el eje 0 será la media de todas las filas en cada columna, y una media en el eje 1 será una media de todas las columnas en cada fila.

En última instancia, esto dice lo mismo que @zhangxaochen y @Michael, pero de una manera que es más fácil para mí internalizar.

Vamos a visualizar (recordarás siempre)

En pandas:

1. eje = 0 significa a lo largo de "índices". Es una operación en fila .

Supongamos que, para realizar la operación concat () en dataframe1 y dataframe2, tomaremos dataframe1 y sacaremos la primera fila de dataframe1 y la colocaremos en el nuevo DF, luego sacaremos otra fila de dataframe1 y la colocaremos en un nuevo DF, repetimos este proceso hasta llegamos al final del dataframe1. Luego, hacemos el mismo proceso para dataframe2.

Básicamente, apilar dataframe2 encima de dataframe1 o viceversa.

Por ejemplo, hacer una pila de libros sobre una mesa o piso

2. eje = 1 significa a lo largo de "columnas". Es una operación en columna.

Supongamos que, para realizar la operación concat () en dataframe1 y dataframe2, sacaremos la primera columna completa (también conocida como primera serie) de dataframe1 y la colocaremos en el nuevo DF, luego sacaremos la segunda columna de dataframe1 y nos mantendremos adyacentes (lateralmente) ) , tenemos que repetir esta operación hasta que todas las columnas estén terminadas. Luego, repetimos el mismo proceso en dataframe2. Básicamente, apilando dataframe2 de lado.

Por ejemplo, organizar libros en una estantería.

Más aún, ¡ya que las matrices son mejores representaciones para representar una estructura n-dimensional anidada en comparación con las matrices! a continuación, puede ayudarlo más a visualizar cómo el eje juega un papel importante cuando generaliza a más de una dimensión. Además, puede imprimir / escribir / dibujar / visualizar cualquier matriz n-dim pero, escribir o visualizar la misma en una representación matricial (3-dim) es imposible en un papel de más de 3 dimensiones.

axisse refiere a la dimensión de la matriz, en el caso de pd.DataFrames axis=0es la dimensión que apunta hacia abajo y axis=1la que apunta hacia la derecha.

Ejemplo: piense en un ndarraycon forma (3,5,7).

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

aes tridimensional ndarray, es decir, tiene 3 ejes ("ejes" es plural de "eje"). La configuración de ase verá como 3 rebanadas de pan donde cada rebanada tiene una dimensión de 5 por 7. a[0,:,:]se referirá a la rebanada 0, a[1,:,:]se referirá a la rebanada 1, etc.

a.sum(axis=0)se aplicará a lo sum()largo del eje 0 de a. Agregará todas las rebanadas y terminará con una rebanada de forma (5,7).

a.sum(axis=0) es equivalente a

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

by a.sum(axis=0)ambos se verán así

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

En a pd.DataFrame, los ejes funcionan de la misma manera que en numpy.arrays: axis=0se aplicará sum()o cualquier otra función de reducción para cada columna.

Nota: en la respuesta de @ zhangxaochen, encuentro las frases "a lo largo de las filas" y "a lo largo de las columnas" un poco confusas. axis=0debe referirse a "a lo largo de cada columna" y axis=1"a lo largo de cada fila".

La forma más fácil de entender es hablar sobre si está calculando una estadística para cada columna ( axis = 0) o cada fila ( axis = 1). Si calcula una estadística, diga una media, con axis = 0ella obtendrá esa estadística para cada columna. Entonces, si cada observación es una fila y cada variable está en una columna, obtendría la media de cada variable. Si establece axis = 1, calculará su estadística para cada fila. En nuestro ejemplo, obtendría la media de cada observación en todas sus variables (quizás desee el promedio de las medidas relacionadas).

axis = 0: por columna = column-wise = a lo largo de las filas

axis = 1: por row = row-wise = a lo largo de las columnas

Miremos la tabla de Wiki. Esta es una estimación del PIB del FMI entre 2010 y 2019 para los diez principales países.

1. El Eje 1 actuará para cada fila en todas las columnas.
Si desea calcular el PIB promedio (promedio) para CADA país durante la década (2010-2019), debe hacerlo df.mean(axis=1),. Por ejemplo, si desea calcular el PIB medio de Estados Unidos de 2010 a 2019,df.loc['United States','2010':'2019'].mean(axis=1)

2. El eje 0 actuará para cada columna en todas las filas.
Si deseo calcular el PIB promedio (promedio) para CADA año para todos los países, debe hacerlo df.mean(axis=0),. Por ejemplo, si desea calcular el PIB medio del año 2015 para Estados Unidos, China, Japón, Alemania e India, df.loc['United States':'India','2015'].mean(axis=0)

Nota: El código anterior funcionará solo después de establecer la columna "País (o territorio dependiente)" como el Índice, utilizando set_indexmétodo.

El eje en vista de la programación es la posición en la tupla de forma. Aquí hay un ejemplo:

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 en el eje hará que se elimine esa dimensión.

Refiriéndose a la pregunta original, la forma dff es (1,2). Usando axis = 1 cambiará la forma a (1,).

El diseñador de pandas, Wes McKinney, solía trabajar intensamente en datos financieros. Piense en las columnas como nombres de acciones e indexe como precios diarios. Luego puede adivinar cuál es el comportamiento predeterminado (es decir, axis=0) con respecto a estos datos financieros. axis=1puede ser simplemente pensado como "la otra dirección".

Por ejemplo, las funciones estadísticas, tales como mean(), sum(), describe(), count()todo defecto de columna en columna, ya que tiene más sentido para hacerlas para cada población. sort_index(by=)También predeterminado a la columna. fillna(method='ffill')se llenará a lo largo de la columna porque es el mismo stock. dropna()el valor predeterminado es remar porque probablemente solo desee descartar el precio ese día en lugar de descartar todos los precios de esa acción.

Del mismo modo, la indexación entre corchetes se refiere a las columnas, ya que es más común elegir una acción en lugar de elegir un día.

Una de las formas fáciles de recordar el eje 1 (columnas), frente al eje 0 (filas) es la salida que espera.

• si espera una salida para cada fila, usa axis = 'columnas',
• Por otro lado, si desea una salida para cada columna, utilice axis = 'rows'.

El problema con el uso axis=adecuado es su uso en 2 casos diferentes principales:

1. Para calcular un valor acumulado o reorganizar (por ejemplo, ordenar) datos.
2. Para manipular ("jugar" con) entidades (por ejemplo, marcos de datos ).

La idea principal detrás de esta respuesta es que para evitar la confusión, seleccionamos un número o un nombre para especificar el eje particular, el que sea más claro, intuitivo y descriptivo.

Pandas se basa en NumPy, que se basa en matemáticas, particularmente en matrices n-dimensionales. Aquí hay una imagen para el uso común de los nombres de los ejes en matemáticas en el espacio tridimensional:

Esta imagen es solo para memorizar los números ordinales de los ejes :

• 0 para el eje x,
• 1 para el eje y, y
• 2 para eje z.

El eje z es solo para paneles ; para tramas de datos vamos a restringir nuestro interés a la de color verde, plano básico de 2 dimensiones con el eje x ( 0vertical) , y el eje Y ( 1horizontal).

Todo es para números como valores potenciales de axis=parámetro.

Los nombres de los ejes son 'index'(puede usar el alias 'rows') y 'columns', para esta explicación , NO es importante la relación entre estos nombres y los números ordinales (de los ejes), ya que todo el mundo sabe lo que significan las palabras "filas" y "columnas" ( y todos aquí , supongo, saben lo que significa la palabra "índice" en pandas).

Y ahora, mi recomendación:

1. Si desea calcular un valor acumulado , puede calcularlo a partir de valores ubicados a lo largo del eje 0 (o a lo largo del eje 1 ) - use axis=0(oaxis=1 ).

   Del mismo modo, si desea reorganizar los valores , use el número de eje del eje, a lo largo del cual se encuentran los datos para reorganizar (por ejemplo, para ordenar ).

2. Si desea manipular (por ejemplo, concatenar ) entidades (por ejemplo, marcos de datos ), use axis='index'(sinónimo :)axis='rows' o axis='columns'para especificar el cambio resultante : índice ( filas ) o columnas , respectivamente.
   (Para concatenar , obtendrá un índice más largo (= más filas) o más columnas , respectivamente.)

Esto se basa en la respuesta de @ Safak. La mejor manera de comprender los ejes en pandas / numpy es crear una matriz 3D y verificar el resultado de la función de suma a lo largo de los 3 ejes diferentes.

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

a será:

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

Ahora revise la suma de elementos de la matriz a lo largo de cada uno de los ejes:

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

le dará los siguientes resultados:

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

Entiendo de esta manera:

Digamos que si su operación requiere recorrer de izquierda a derecha / derecha a izquierda en un marco de datos, aparentemente está fusionando columnas, es decir. Estás operando en varias columnas. Esto es eje = 1

Ejemplo

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

El punto a tener en cuenta aquí es que estamos operando en columnas

Del mismo modo, si su operación requiere recorrer de arriba a abajo / de abajo a arriba en un marco de datos, está fusionando filas. Este es el eje = 0 .

eje = 0 significa arriba a abajo eje = 1 significa de izquierda a derecha

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

El ejemplo dado es tomar la suma de todos los datos en la columna == clave.

Mi pensamiento: Eje = n, donde n = 0, 1, etc. significa que la matriz está colapsada (plegada) a lo largo de ese eje. Entonces, en una matriz 2D, cuando colapsas a lo largo de 0 (filas), realmente estás operando en una columna a la vez. De manera similar para matrices de orden superior.

Esto no es lo mismo que la referencia normal a una dimensión en una matriz, donde 0 -> fila y 1 -> columna. De manera similar para otras dimensiones en una matriz de dimensiones N.

Soy un novato en pandas. Pero así es como entiendo el eje en pandas:

Dirección constante variable del eje

0 fila de columna hacia abajo |

Columna de 1 fila hacia la derecha ->

Entonces, para calcular la media de una columna, esa columna en particular debe ser constante, pero las filas debajo de esa pueden cambiar (variando) por lo que es axis = 0.

Del mismo modo, para calcular la media de una fila, esa fila en particular es constante pero puede atravesar diferentes columnas (variables) , eje = 1.

Creo que hay otra forma de entenderlo.

Para un np.array, si queremos eliminar columnas usamos axis = 1; si queremos eliminar filas, usamos 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,)

Para el objeto pandas, axis = 0significa operación a nivel de fila y axis = 1significa operación a nivel de columna. Esto es diferente denumpy por definición, podemos verificar las definiciones de numpy.doc y pandas.doc

Evitaré explícitamente usar 'row-wise' o 'a lo largo de las columnas', ya que las personas pueden interpretarlas exactamente de la manera incorrecta.

Analogía primero. Intuitivamente, esperaría que pandas.DataFrame.drop(axis='column')suelte una columna de N columnas y le proporcione (N - 1) columnas. Por lo tanto, NO puede prestar atención a las filas por ahora (y eliminar la palabra 'fila' de su diccionario de inglés). Viceversa,drop(axis='row') funciona en filas.

De la misma manera, sum(axis='column')funciona en múltiples columnas y le da 1 columna. Del mismo modo, los sum(axis='row')resultados en 1 fila. Esto es consistente con su forma más simple de definición, reduciendo una lista de números a un solo número.

En general, con axis=column, verá columnas, trabajará en columnas y obtendrá columnas. Olvídate de las filas.

Con axis=row, cambie la perspectiva y trabaje en filas.

0 y 1 son solo alias para 'fila' y 'columna'. Es la convención de la indexación matricial.

He estado tratando de descubrir el eje durante la última hora también. El lenguaje en todas las respuestas anteriores, y también la documentación no es de ninguna ayuda.

Para responder la pregunta tal como la entiendo ahora, en Pandas, axis = 1 o 0 significa qué encabezados de eje desea mantener constantes al aplicar la función.

Nota: cuando digo encabezados, me refiero a los nombres de índice

Ampliando su ejemplo:

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

Para axis = 1 = columnas: mantenemos constantes los encabezados de las columnas y aplicamos la función media cambiando los datos. Para demostrar, mantenemos los encabezados de las columnas constantes como:

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

Ahora rellenamos un conjunto de valores A y B y luego encontramos la media

|            | 0.626386| 1.52325|  

Luego llenamos el siguiente conjunto de valores A y B y encontramos la media

|            | 0.626386| 1.52325|

Del mismo modo, para axis = rows, mantenemos constantes los encabezados de fila y seguimos cambiando los datos: Para demostrarlo, primero arregle los encabezados de fila:

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

Ahora complete el primer conjunto de valores X e Y y luego encuentre la media

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

Luego, complete el siguiente conjunto de valores X e Y y luego encuentre la media:

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

En resumen,

Cuando axis = columnas, arregla los encabezados de columna y cambia los datos, que vendrán de las diferentes filas.

Cuando axis = filas, arregla los encabezados de fila y cambia los datos, que vendrán de las diferentes columnas.

axis = 1, dará la suma de la fila sabia, keepdims = True mantendrá la dimensión 2D. Espero que te ayude.

¡Muchas respuestas aquí me ayudaron mucho!

En caso de que se confunda con los diferentes comportamientos de axisPython y MARGINR (como en la applyfunción), puede encontrar una publicación de blog que escribí de interés: https://accio.github.io/programming/2020/05/ 19 / numpy-pandas-axis.html .

En esencia:

• Sus comportamientos son, intrigantemente, más fáciles de entender con una matriz tridimensional que con matrices bidimensionales.
• En paquetes Python numpyypandas , el parámetro del eje en suma realmente especifica numpy para calcular la media de todos los valores que se pueden obtener en forma de matriz [0, 0, ..., i, ..., 0] donde itera Todos los valores posibles. El proceso se repite con la posición de i fija y los índices de otras dimensiones varían uno tras otro (desde el elemento más a la derecha). El resultado es una matriz n-1-dimensional.
• En R, el parámetro MARGINS permite que la applyfunción calcule la media de todos los valores que se pueden obtener en forma de matriz [, ..., i, ...,] donde itera a través de todos los valores posibles. El proceso no se repite cuando todos los valores i se han iterado. Por lo tanto, el resultado es un vector simple.

Las matrices están diseñadas con el denominado eje = 0 y las filas ubicadas verticalmente frente al eje = 1 y las columnas ubicadas horizontalmente. El eje se refiere a la dimensión de la matriz.