L'ambiguïté dans les Pandas Dataframe / Tableau Numpy “axe” définition

J'ai été très confus sur la façon python axes sont définis, et qu'elles se réfèrent à un DataFrame de lignes ou de colonnes. Considérez le code ci-dessous:

>>> df = pd.DataFrame([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3]], columns=["col1", "col2", "col3", "col4"])
>>> df
   col1  col2  col3  col4
0     1     1     1     1
1     2     2     2     2
2     3     3     3     3

Donc, si nous appelons df.mean(axis=1), nous allons obtenir une moyenne pour les lignes:

>>> df.mean(axis=1)
0    1
1    2
2    3

Cependant, si nous appelons df.drop(name, axis=1), nous avons fait supprimer une colonne, pas une ligne:

>>> df.drop("col4", axis=1)
   col1  col2  col3
0     1     1     1
1     2     2     2
2     3     3     3

Quelqu'un peut-il m'aider à comprendre ce qu'on entend par un "axe" dans les pandas/numpy/scipy?

Une note de côté, DataFrame.mean pourrait être défini de mal. Il est dit dans la documentation de DataFrame.moyenne que axis=1 est censé signifier une moyenne sur les colonnes, pas les lignes...

Pour une explication détaillée de l'alias, 'colonnes' et 'index'/'lignes' voir cette réponse ci-dessous.
C'est juste bizarre. L'axe doit être uniforme à travers le mean et la drop. Il faut non linéaire de la pensée à l'arrivée au comportement réel.

InformationsquelleAutor hlin117 | 2014-09-10

153

C'est peut-être plus simple à retenir comme 0=bas et 1=à travers.

Cela signifie:
- Utilisation axis=0 d'appliquer une méthode en bas de chaque colonne ou de la ligne d'étiquettes (l'index).
- Utilisation axis=1 d'appliquer une méthode sur chaque ligne, ou à la colonne des étiquettes.
Voici une photo pour afficher les parties d'un DataFrame que chaque axe se réfère à:

Il est également utile de rappeler que les Pandas suit NumPy utilisation du mot axis. L'utilisation est expliquée dans NumPy est glossaire des termes:

Axes sont définis pour les tableaux à plus d'une dimension. Un tableau en 2 dimensions a deux axes: le premier vertical à la baisse sur les lignes (axe 0), et la deuxième course horizontalement à travers les colonnes (axe 1). [mon accent]

Donc, concernant la méthode en question, df.mean(axis=1), semble être correctement défini. Il prend la moyenne des entrées horizontalement à travers les colonnes, qui est, le long de chaque ligne. D'autre part, df.mean(axis=0) serait une opération agissant verticalement à la baisse sur les lignes.

De même, df.drop(name, axis=1) fait référence à une action sur les étiquettes de colonne, car intuitivement, ils passent à travers l'axe horizontal. La spécification de axis=0 rendrait la méthode de loi sur des lignes à la place.
- Ce qui m'a fait de la lutte a été, que le df.appliquer(..., axis=0), n'est-ce pas "exécuter en plus de" l'axe 0 (l'index), mais a couru sur les colonnes, returing Série contenant tous les index. L'idée est, que df.appliquer(..., axis=0) retourne la Série, donc VOUS pouvez appliquer une exploitation en cours d'exécution sur l'index complet.
- Je pense que il aide également si vous affichez df.apply comme similaire à une méthode comme df.sum. Par exemple, df.sum(axis=0) somme de chaque colonne de la DataFrame. De même, vous pouvez écrire df.apply(sum, axis=0) à faire exactement la même opération. Alors que l'opération est en effet appliqué à chaque colonne dans le DataFrame, la fonction s'exécute en bas de l'axe 0.
- Il est regrettable que les conventions de nommage et l'ordre sont les face de R appliquer la fonction -- dans R, la baisse des MARGIN (similaire à axis dans les pandas) valeur de "1" correspond à "lignes" qui signifie que la fonction est appliquée pour chaque ligne, alors que la plus grande valeur de "2" se réfère à des "colonnes", ce qui signifie que la fonction est appliquée pour chaque colonne.
- c'est un destructeur de bug dans les pandas
InformationsquelleAutor Alex Riley

Une autre façon de l'expliquer:

// Not realistic but ideal for understanding the axis parameter 
df = pd.DataFrame([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3]],
                  columns=["idx1", "idx2", "idx3", "idx4"],
                  index=["idx1", "idx2", "idx3"]
                 )

---------------------------------------1
|          idx1  idx2  idx3  idx4
|    idx1     1     1     1     1
|    idx2     2     2     2     2
|    idx3     3     3     3     3
0

Sur df.drop (axe moyen de la position)

A: I wanna remove idx3.
B: **Which one**? // typing while waiting response: df.drop("idx3",
A: The one which is on axis 1
B: OK then it is >> df.drop("idx3", axis=1)

// Result
---------------------------------------1
|          idx1  idx2     idx4
|    idx1     1     1     1
|    idx2     2     2     2
|    idx3     3     3     3
0

Sur df.apply (axe des moyens de la direction)

A: I wanna apply sum.
B: Which direction? // typing while waiting response: df.apply(lambda x: x.sum(),
A: The one which is on *parallel to axis 0*
B: OK then it is >> df.apply(lambda x: x.sum(), axis=0)

// Result
idx1    6
idx2    6
idx3    6
idx4    6

N'avez-vous pas pense, sur l'axe 1 et parallèle à l'axe 0 signifie même?

InformationsquelleAutor o0omycomputero0o

5

Il y a déjà de bonnes réponses, mais je vous donne un autre exemple avec > 2 dimensions.

Le paramètre axis signifie axe à changé.

Par exemple, considérer qu'il y a un dataframe, avec la dimension a x b x c.
- df.mean(axis=1) retourne un dataframe avec dimenstion a x 1 x c.
- df.drop("col4", axis=1) retourne un dataframe, avec la dimension a x (b-1) x c.
- Cette réponse est la plus intuitive pour moi que toute visualisation que j'ai vu sur ce sujet. Cependant, xarray est mieux pour le multi-dimensions des tableaux de pandas.
InformationsquelleAutor jeongmin.cha

Il devrait être plus largement connu que la chaîne alias 'index' et "colonnes" peut être utilisé à la place des nombres entiers 0/1. Les alias sont beaucoup plus explicites et m'aider à me rappeler comment les calculs prennent place. Un alias "index" est "rangées".

Quand axis='index' est utilisé, ensuite, les calculs peuvent se produire sur les colonnes, ce qui est source de confusion. Mais, je m'en souviens comme l'obtention d'un résultat qui est de la même taille que l'autre ligne.

Nous allons obtenir des données sur l'écran pour voir de quoi je parle:

df = pd.DataFrame(np.random.rand(10, 4), columns=list('abcd'))
          a         b         c         d
0  0.990730  0.567822  0.318174  0.122410
1  0.144962  0.718574  0.580569  0.582278
2  0.477151  0.907692  0.186276  0.342724
3  0.561043  0.122771  0.206819  0.904330
4  0.427413  0.186807  0.870504  0.878632
5  0.795392  0.658958  0.666026  0.262191
6  0.831404  0.011082  0.299811  0.906880
7  0.749729  0.564900  0.181627  0.211961
8  0.528308  0.394107  0.734904  0.961356
9  0.120508  0.656848  0.055749  0.290897

Lorsque nous voulons prendre la moyenne de toutes les colonnes, nous utilisons axis='index' pour obtenir le suivant:

df.mean(axis='index')
a    0.562664
b    0.478956
c    0.410046
d    0.546366
dtype: float64

Le même résultat pourrait être obtenu par:

df.mean() # default is axis=0
df.mean(axis=0)
df.mean(axis='rows')

À obtenir l'utilisation d'une opération de gauche à droite sur les lignes, l'utilisation de l'axe= "colonnes". Je me souviens d'elle en pensant qu'une colonne supplémentaire peut être ajouté à mon DataFrame:

df.mean(axis='columns')
0    0.499784
1    0.506596
2    0.478461
3    0.448741
4    0.590839
5    0.595642
6    0.512294
7    0.427054
8    0.654669
9    0.281000
dtype: float64

Le même résultat pourrait être obtenu par:

df.mean(axis=1)

Ajouter une nouvelle ligne avec l'axe=0/index/lignes

Nous allons utiliser ces résultats pour ajouter des lignes ou des colonnes pour compléter l'explication. Donc, chaque fois que l'aide de l'axe = 0/index/lignes, ses comme obtenir une nouvelle ligne de la DataFrame. Nous allons ajouter une ligne:

df.append(df.mean(axis='rows'), ignore_index=True)

           a         b         c         d
0   0.990730  0.567822  0.318174  0.122410
1   0.144962  0.718574  0.580569  0.582278
2   0.477151  0.907692  0.186276  0.342724
3   0.561043  0.122771  0.206819  0.904330
4   0.427413  0.186807  0.870504  0.878632
5   0.795392  0.658958  0.666026  0.262191
6   0.831404  0.011082  0.299811  0.906880
7   0.749729  0.564900  0.181627  0.211961
8   0.528308  0.394107  0.734904  0.961356
9   0.120508  0.656848  0.055749  0.290897
10  0.562664  0.478956  0.410046  0.546366

Ajouter une nouvelle colonne avec axis=1/les colonnes

De même, lors de l'axe=1/les colonnes, il va créer une base de données qui peut être facilement faite dans sa propre colonne:

df.assign(e=df.mean(axis='columns'))

          a         b         c         d         e
0  0.990730  0.567822  0.318174  0.122410  0.499784
1  0.144962  0.718574  0.580569  0.582278  0.506596
2  0.477151  0.907692  0.186276  0.342724  0.478461
3  0.561043  0.122771  0.206819  0.904330  0.448741
4  0.427413  0.186807  0.870504  0.878632  0.590839
5  0.795392  0.658958  0.666026  0.262191  0.595642
6  0.831404  0.011082  0.299811  0.906880  0.512294
7  0.749729  0.564900  0.181627  0.211961  0.427054
8  0.528308  0.394107  0.734904  0.961356  0.654669
9  0.120508  0.656848  0.055749  0.290897  0.281000

Il semble que vous pouvez voir tous les alias avec les variables privées suivantes:

df._AXIS_ALIASES
{'rows': 0}

df._AXIS_NUMBERS
{'columns': 1, 'index': 0}

df._AXIS_NAMES
{0: 'index', 1: 'columns'}

InformationsquelleAutor Ted Petrou

0

Lors de l'axe= "rangées" ou de l'axe=0, cela signifie accéder à des éléments dans la direction des lignes, du haut vers le bas. Si l'application de la somme le long de l'axe=0, il va nous donner les totaux de chaque colonne.

Lors de l'axe= "colonnes" ou axis=1, cela signifie accéder à des éléments dans la direction des colonnes, de gauche à droite. Si l'application de la somme le long de l'axe=1, nous obtenons un total de chaque ligne.

Encore confuse! Mais le rend un peu plus facile pour moi.

InformationsquelleAutor newbie

Vous devez vous connecter pour publier un commentaire.