Que signifie l'axe chez les pandas?

Voici mon code pour générer une trame de données:

import pandas as pd
import numpy as np

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

alors j'ai eu le dataframe:

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

Quand je tape la commande:

dff.mean(axis=1)

J'ai eu :

0    1.074821
dtype: float64

Selon la référence des pandas, axe = 1 représente les colonnes et je m'attends à ce que le résultat de la commande soit

A    0.626386
B    1.523255
dtype: float64

Voici donc ma question: que signifie l'axe des pandas?

Il spécifie l'axe selon lequel les moyennes sont calculées. Par défaut axis=0. Cela est cohérent avec l' numpy.meanutilisation lorsque axisest spécifié explicitement (dans numpy.mean, axe == Aucun par défaut, qui calcule la valeur moyenne sur le tableau aplati), dans lequel le axis=0long des lignes (à savoir, l' index dans les pandas) et le axis=1long des colonnes . Pour plus de clarté, on peut choisir de spécifier axis='index'(au lieu de axis=0) ou axis='columns'(au lieu de axis=1).

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

Ces réponses aident à expliquer cela, mais ce n'est toujours pas parfaitement intuitif pour un non-programmeur (c'est-à-dire quelqu'un comme moi qui apprend Python pour la première fois dans le contexte d'un cours de science des données). Je trouve toujours que l'utilisation des termes «le long» ou «pour chaque» par rapport aux lignes et aux colonnes prête à confusion.

Ce qui est plus logique pour moi, c'est de le dire ainsi:

• L'axe 0 agira sur toutes les RANGS de chaque COLONNE
• L'axe 1 agira sur toutes les COLONNES de chaque ligne

Ainsi, une moyenne sur l'axe 0 sera la moyenne de toutes les lignes de chaque colonne, et une moyenne sur l'axe 1 sera la moyenne de toutes les colonnes de chaque ligne.

En fin de compte, cela signifie la même chose que @zhangxaochen et @Michael, mais d'une manière qui m'est plus facile à internaliser.

Visualisons (tu te souviendras toujours),

Dans Pandas:

1. axe = 0 signifie le long des "index". C'est une opération en ligne .

Supposons que, pour effectuer l'opération concat () sur dataframe1 et dataframe2, nous prendrons dataframe1 et sortirons la 1ère ligne de dataframe1 et la placerons dans le nouveau DF, puis nous retirerons une autre ligne de dataframe1 et la placerons dans un nouveau DF, nous répétons ce processus jusqu'à nous atteignons le bas de dataframe1. Ensuite, nous faisons le même processus pour dataframe2.

Fondamentalement, empiler dataframe2 au-dessus de dataframe1 ou vice versa.

Par exemple, faire une pile de livres sur une table ou un sol

2. axe = 1 signifie le long de "colonnes". C'est un opération colonne colonne.

Supposons que pour effectuer l'opération concat () sur dataframe1 et dataframe2, nous allons retirer la 1ère colonne complète (aka 1ère série) de dataframe1 et la placer dans le nouveau DF, puis nous retirons la deuxième colonne de dataframe1 et nous la maintenons à côté (latéralement) ) , nous devons répéter cette opération jusqu'à ce que toutes les colonnes soient terminées. Ensuite, nous répétons le même processus sur dataframe2. Fondamentalement, empilement latéral de dataframe2.

Par exemple, organiser des livres sur une étagère.

Plus encore, puisque les tableaux sont de meilleures représentations pour représenter une structure nidimensionnelle imbriquée par rapport aux matrices! donc ci-dessous peut vous aider davantage à visualiser comment l'axe joue un rôle important lorsque vous généralisez à plus d'une dimension. En outre, vous pouvez réellement imprimer / écrire / dessiner / visualiser n'importe quel tableau n-dim mais, l'écrire ou le visualiser dans une représentation matricielle (3-dim) est impossible sur un papier de plus de 3 dimensions.

axisfait référence à la dimension du tableau, dans le cas de pd.DataFrames axis=0est la dimension qui pointe vers axis=1le bas et celle qui pointe vers la droite.

Exemple: pensez à une ndarrayforme (3,5,7).

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

aest un 3 dimensions ndarray, c'est-à-dire qu'il a 3 axes ("axes" est pluriel de "axe"). La configuration de aressemblera à 3 tranches de pain où chaque tranche est de dimension 5 par 7. a[0,:,:]se référera à la 0-ème tranche, a[1,:,:]se référera à la 1ère tranche etc.

a.sum(axis=0)s'appliquera le sum()long de l'axe 0-ème de a. Vous ajouterez toutes les tranches et vous vous retrouverez avec une tranche de forme (5,7).

a.sum(axis=0) est équivalent à

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

bet a.sum(axis=0)ressemblera tous les deux à ceci

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

Dans a pd.DataFrame, les axes fonctionnent de la même manière que dans numpy.arrays: axis=0appliquera sum()ou toute autre fonction de réduction pour chaque colonne.

NB Dans la réponse de @ zhangxaochen, je trouve les phrases "le long des lignes" et "le long des colonnes" un peu déroutantes. axis=0doit faire référence à "le long de chaque colonne" et axis=1"le long de chaque ligne".

La façon la plus simple pour moi de comprendre est de dire si vous calculez une statistique pour chaque colonne ( axis = 0) ou chaque ligne ( axis = 1). Si vous calculez une statistique, disons une moyenne, axis = 0vous obtiendrez cette statistique pour chaque colonne. Donc, si chaque observation est une ligne et chaque variable est dans une colonne, vous obtiendrez la moyenne de chaque variable. Si vous définissezaxis = 1 vous calculez votre statistique pour chaque ligne. Dans notre exemple, vous obtiendrez la moyenne de chaque observation pour toutes vos variables (peut-être voulez-vous la moyenne des mesures connexes).

axis = 0: par colonne = par colonne = le long des lignes

axis = 1: par ligne = par ligne = le long des colonnes

Regardons le tableau du Wiki. Il s'agit d'une estimation du PIB du FMI de 2010 à 2019 pour les dix premiers pays.

1. Axe 1 agira pour chaque ligne sur toutes les colonnes
Si vous voulez calculer le PIB moyen (moyenne) pour chaque pays au cours de la décennie (2010-2019), vous devez faire, df.mean(axis=1). Par exemple, si vous souhaitez calculer le PIB moyen des États-Unis de 2010 à 2019,df.loc['United States','2010':'2019'].mean(axis=1)

2. Axe 0 agira pour chaque colonne sur toutes les lignes
Si je veux calculer le PIB moyen (moyenne) pour chaque année pour tous les pays, vous devez faire, df.mean(axis=0). Par exemple, si vous souhaitez calculer le PIB moyen de l'année 2015 pour les États-Unis, la Chine, le Japon, l'Allemagne et l'Inde, df.loc['United States':'India','2015'].mean(axis=0)

Remarque: Le code ci-dessus ne fonctionnera qu'après avoir défini la colonne "Pays (ou territoire dépendant)" comme Index, en utilisant set_indexméthode.

L'axe en vue de la programmation est la position dans le tuple de forme. Voici un exemple:

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 moyenne sur l'axe entraînera la suppression de cette dimension.

En se référant à la question d'origine, la forme dff est (1,2). L'utilisation d'axe = 1 changera la forme en (1,).

Le concepteur de pandas, Wes McKinney, travaillait intensivement sur les données financières. Considérez les colonnes comme des noms d'actions et les indices comme des prix quotidiens. Vous pouvez alors deviner quel est le comportement par défaut (c'est-à-dire axis=0) par rapport à ces données financières. axis=1peut être simplement considéré comme «l'autre sens».

Par exemple, les fonctions statistiques, telles que mean(), sum(), describe(), count()tout défaut en colonne , car il est plus logique de les faire pour chaque stock. sort_index(by=)prend également par défaut la colonne. fillna(method='ffill')se remplira le long de la colonne car il s'agit du même stock.dropna()par défaut à la ligne parce que vous voulez probablement juste jeter le prix ce jour-là au lieu de jeter tous les prix de ce stock.

De même, l'indexation entre crochets fait référence aux colonnes, car il est plus courant de choisir un stock au lieu de choisir un jour.

l'un des moyens faciles de mémoriser l'axe 1 (colonnes), par rapport à l'axe 0 (lignes) est la sortie que vous attendez.

• si vous attendez une sortie pour chaque ligne que vous utilisez axis = 'colonnes',
• d'autre part, si vous voulez une sortie pour chaque colonne, vous utilisez axe = «lignes».

Le problème avec une utilisation axis=correcte est pour son utilisation dans 2 cas différents:

1. Pour calculer une valeur cumulée ou réorganiser (par exemple, trier) des données.
2. Pour manipuler ("jouer") avec des entités (par exemple des trames de données ).

L'idée principale derrière cette réponse est que pour éviter la confusion, nous sélectionnons soit un nombre , soit un nom pour spécifier l'axe particulier, selon le plus clair, le plus intuitif et le plus descriptif.

Pandas est basé sur NumPy, qui est basé sur les mathématiques, en particulier sur les matrices à n dimensions. Voici une image pour une utilisation courante des noms d'axes en mathématiques dans l'espace tridimensionnel:

Cette image sert uniquement à mémoriser les nombres ordinaux des axes :

• 0 pour l'axe x,
• 1 pour l'axe y, et
• 2 pour l'axe z.

L' axe z est uniquement pour les panneaux ; pour les trames de données, nous limiterons notre intérêt au plan de base bidimensionnel de couleur verte avec l' axe x ( 0, vertical) et l' axe y ( 1, horizontal).

C'est tout pour les nombres comme valeurs potentielles de axis=paramètre.

Les noms des axes sont 'index'(vous pouvez utiliser l'alias 'rows') et 'columns', et pour cette explication, la relation entre ces noms et les nombres ordinaux (des axes) n'est PAS importante , car tout le monde sait ce que signifient les mots "lignes" et "colonnes" ( et tout le monde ici - je suppose - sait ce que signifie le mot "index" dans les pandas).

Et maintenant, ma recommandation:

1. Si vous souhaitez calculer une valeur cumulée , vous pouvez la calculer à partir de valeurs situées le long de l'axe 0 (ou le long de l'axe 1 ) - utilisez axis=0(ou axis=1).

   De même, si vous souhaitez réorganiser les valeurs , utilisez le numéro d'axe de l'axe, le long duquel se trouvent les données pour le réarrangement (par exemple pour le tri ).

2. Si vous souhaitez manipuler (par exemple concaténer ) des entités (par exemple des cadres de données ) - utilisez axis='index'(synonyme :)axis='rows' ou axis='columns'pour spécifier le changement résultant - index ( lignes ) ou colonnes , respectivement.
   (Pour concaténer , vous obtiendrez respectivement un index plus long (= plus de lignes) ou plus de colonnes .)

Ceci est basé sur la réponse de @ Safak. La meilleure façon de comprendre les axes dans pandas / numpy est de créer un tableau 3D et de vérifier le résultat de la fonction somme le long des 3 axes différents.

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

un sera:

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

Maintenant, vérifiez la somme des éléments du tableau le long de chacun des axes:

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

vous donnera les résultats suivants:

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

Je comprends de cette façon:

Supposons que si votre opération nécessite une traversée de gauche à droite / de droite à gauche dans une trame de données, vous fusionnez apparemment des colonnes, par exemple. vous opérez sur différentes colonnes. C'est axe = 1

Exemple

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

Le point à noter ici est que nous fonctionnons sur des colonnes

De même, si votre opération nécessite une traversée de haut en bas / de bas en haut dans une trame de données, vous fusionnez des lignes. Il s'agit de l' axe = 0 .

axe = 0 signifie de haut en bas axe = 1 signifie de gauche à droite

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

L'exemple donné prend la somme de toutes les données de la colonne == clé.

Ma pensée: Axe = n, où n = 0, 1, etc. signifie que la matrice est repliée (pliée) le long de cet axe. Ainsi, dans une matrice 2D, lorsque vous vous réduisez le long de 0 (lignes), vous opérez réellement sur une colonne à la fois. De même pour les matrices d'ordre supérieur.

Ce n'est pas la même chose que la référence normale à une dimension dans une matrice, où 0 -> ligne et 1 -> colonne. De même pour les autres dimensions d'un tableau de dimensions N.

Je suis un débutant pour les pandas. Mais c'est ainsi que je comprends l'axe des pandas:

Direction variable constante de l' axe

0 ligne de colonne vers le bas |

Colonne à 1 rangée vers la droite ->

Donc, pour calculer la moyenne d'une colonne, cette colonne particulière doit être constante, mais les lignes en dessous peuvent changer (varier) donc c'est axe = 0.

De même, pour calculer la moyenne d'une ligne, cette ligne particulière est constante mais elle peut traverser différentes colonnes (variables) , axe = 1.

Je pense qu'il y a une autre façon de le comprendre.

Pour un tableau np., Si nous voulons éliminer les colonnes, nous utilisons axis = 1; si nous voulons éliminer les lignes, nous utilisons axe = 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,)

Pour un objet pandas, axis = 0signifie un fonctionnement en ligne et un fonctionnement en axis = 1colonne. Ceci est différent de numpypar définition, nous pouvons vérifier les définitions de numpy.doc et pandas.doc

J'éviterai explicitement d'utiliser «par ligne» ou «le long des colonnes», car les gens peuvent les interpréter exactement de la mauvaise façon.

L'analogie d'abord. Intuitivement, vous vous attendriez à ce que pandas.DataFrame.drop(axis='column')supprime une colonne de N colonnes et vous donne (N - 1) colonnes. Vous ne pouvez donc pas faire attention aux lignes pour l'instant (et supprimer le mot «ligne» de votre dictionnaire anglais.) Vice versa, drop(axis='row')fonctionne sur les lignes.

De la même manière, sum(axis='column')fonctionne sur plusieurs colonnes et vous donne 1 colonne. De même,sum(axis='row') résultats sur 1 ligne. Ceci est cohérent avec sa forme de définition la plus simple, réduisant une liste de nombres à un seul nombre.

En général, avec axis=column, vous voyez des colonnes, travaillez sur des colonnes et obtenez des colonnes. Oubliez les rangées.

Avec axis=row, changez de perspective et travaillez sur les lignes.

0 et 1 ne sont que des alias pour «ligne» et «colonne». C'est la convention de l'indexation matricielle.

J'essaie également de comprendre l'axe depuis la dernière heure. La langue dans toutes les réponses ci-dessus, ainsi que la documentation ne sont pas du tout utiles.

Pour répondre à la question telle que je la comprends maintenant, dans Pandas, axis = 1 ou 0 signifie quels en - têtes d'axe voulez-vous garder constants lors de l'application de la fonction.

Remarque: quand je dis des en-têtes, je veux dire des noms d'index

Élargir votre exemple:

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

Pour axe = 1 = colonnes: nous gardons les en-têtes de colonnes constants et appliquons la fonction moyenne en modifiant les données. Pour démontrer, nous gardons les en-têtes de colonnes constants comme:

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

Maintenant, nous remplissons un ensemble de valeurs A et B, puis trouvons la moyenne

|            | 0.626386| 1.52325|  

Ensuite, nous remplissons l'ensemble suivant de valeurs A et B et trouvons la moyenne

|            | 0.626386| 1.52325|

De même, pour axe = lignes, nous gardons les en-têtes de ligne constants et continuons de modifier les données: Pour démontrer, fixez d'abord les en-têtes de ligne:

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

Remplissez maintenant le premier ensemble de valeurs X et Y, puis trouvez la moyenne

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

Remplissez ensuite l'ensemble suivant de valeurs X et Y, puis trouvez la moyenne:

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

En résumé,

Lorsque axe = colonnes, vous fixez les en-têtes de colonne et modifiez les données, qui proviendront des différentes lignes.

Lorsque axe = lignes, vous corrigez les en-têtes de ligne et modifiez les données, qui proviendront des différentes colonnes.

axe = 1, il donnera la ligne de somme sage, keepdims = True conservera la dimension 2D. J'espère que cela vous aide.

Beaucoup de réponses ici m'ont beaucoup aidé!

Dans le cas où vous êtes confus par les différents comportements de axisPython et MARGINde R (comme dans la applyfonction), vous pouvez trouver un article de blog que j'ai écrit d'intérêt: https://accio.github.io/programming/2020/05/ 19 / numpy-pandas-axis.html .

En substance:

• Leurs comportements sont, curieusement, plus faciles à comprendre avec un tableau en trois dimensions qu'avec des tableaux en deux dimensions.
• Dans les packages Python numpyetpandas , le paramètre d'axe en somme spécifie en fait numpy pour calculer la moyenne de toutes les valeurs qui peuvent être récupérées sous forme de tableau [0, 0, ..., i, ..., 0] où i itère à travers toutes les valeurs possibles. Le processus est répété avec la position de i fixe et les indices des autres dimensions varient l'un après l'autre (à partir de l'élément le plus à droite). Le résultat est un tableau à n-1 dimensions.
• Dans R, le paramètre MARGINS permet à la applyfonction de calculer la moyenne de toutes les valeurs pouvant être extraites sous la forme d'un tableau [, ..., i, ...,] où i parcourt toutes les valeurs possibles. Le processus n'est pas répété lorsque toutes les valeurs i ont été itérées. Par conséquent, le résultat est un simple vecteur.

Les tableaux sont conçus avec ce que l'on appelle l'axe = 0 et les lignes positionnées verticalement par rapport à l'axe = 1 et les colonnes positionnées horizontalement. L'axe fait référence à la dimension du tableau.