Was bedeutet Achse in Pandas?

Question

Hier ist mein Code zum Generieren eines DataFrames:

import pandas as pd
import numpy as np

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

dann habe ich das DataFrame erhalten:

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

Wenn ich den Befehl eingebe :

dff.mean(axis=1)

Ich erhielt :

0    1.074821
dtype: float64

Laut der Referenz von Pandas steht axis=1 für Spalten und ich erwarte, dass das Ergebnis des Befehls wie folgt aussieht:

A    0.626386
B    1.523255
dtype: float64

Also hier ist meine Frage: Was bedeutet axis in Pandas?

Answer 1

Einer der einfachen Wege, um sich an Achse 1 (Spalten) vs. Achse 0 (Zeilen) zu erinnern, ist die Ausgabe, die Sie erwarten.

• Wenn Sie eine Ausgabe für jede Zeile erwarten, verwenden Sie axis='columns',
• Wenn Sie andererseits eine Ausgabe für jede Spalte möchten, verwenden Sie axis='rows'.

Answer 2

Ich glaube, die richtige Antwort sollte "es ist kompliziert" sein

[1] Der Begriff "Achse" ruft bei verschiedenen Menschen unterschiedliche Vorstellungen hervor
nehmen wir die y-Achse, sollte das ein Bild von etwas Vertikalem hervorrufen. Denken Sie jedoch an eine vertikale Linie x=0. Das ist auch eine vertikale Linie, wird jedoch von einem Wert 0 auf der x-Achse angesprochen.

Ebenso, wenn wir axis='index' sagen (was axis=0 bedeutet), sagen wir dann die "vertikale" Richtung, auf der Indizes liegen? Oder sagt das, dass eine Datenreihe angesprochen wird durch einen Indexwert? Panda tendiert dazu, die erste Bedeutung, die vertikale Richtung, zu meinen.

[2] Auch Pandas selbst ist nicht zu 100% konsistent, beobachten Sie die folgenden Fälle, sie haben FAST alle dasselbe gemeinsame Thema:

# [1] Datenrahmen stapeln
pd.concat([df0, df1], axis='index') 
    # Datenrahmen vertikal übereinander stapeln wie das Stapeln einer Spalte,
    # aber wir werden das Wort 'index' verwenden

# [2] für jede Spalte in df: darauf operieren
df.apply(foo, axis='index')     # wende func foo auf eine Spalte nacheinander an
df.mean('A', axis='index')      # wende "mean()" nacheinander auf eine Spalte an
a_boolean_df.all(axis='index')  # prüfe, ob jede Spalte nur boolsches "True" enthält
    # wende eine Operation auf einen vertikalen Datenabschnitt an, d.h. eine Spalte,
    # dann wende dieselbe Operation auf die nächste rechtsstehende Spalte an
    # dann auf die Rechts stehende wieder... bis zur letzten Spalte
    # aber wir werden das Wort 'index' verwenden

# [3] Löschen einer Spalte oder Zeile mit Daten
df.drop(axis='index', ...)
df.dropna(axis='index', ...)
    # diesmal entfernen wir einen Index/eine Zeile, einen horizontalen Datenabschnitt.
    # also verwenden wir OFFENSICHTLICH das Wort 'index'

# [4] wenn Sie natürlich durch einen df iterieren, was würde zuerst auftauchen? eine Zeile oder eine Spalte?
für x in df:
    # x == Name einer Spalte

# [5] Duplikate löschen
df.drop_duplicates(subset=['meinespalte0', 'meinespalte1']...)
    # zum Glück müssen wir uns nicht mit dem "Axis"-Enkel herumschlagen

Answer 3

Dies basiert auf @Safaks Antwort. Der beste Weg, um die Achsen in pandas/numpy zu verstehen, ist die Erstellung eines 3D-Arrays und die Überprüfung des Ergebnisses der Summenfunktion entlang der 3 verschiedenen Achsen.

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

a wird sein:

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

Überprüfen Sie nun die Summe der Elemente des Arrays entlang jeder der Achsen:

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

werden Ihnen folgende Ergebnisse liefern:

   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.,

Answer 4

Eine wichtige Sache, die man im Hinterkopf behalten sollte, ist, dass wenn man Funktionen wie Mean, Median usw. verwendet, man im Grunde genommen eine numpy Aggregation durchführt. Denken Sie bei Aggregation an das Erhalten eines finalen einzelnen Outputs, der spaltenweise, zeilenweise oder als einzelne Zahl für das gesamte Dataset sein kann.

Also, wenn wir bei Arrays von Aggregation sprechen, wie z.B. numpy.sum(data, axis = 0), meinen wir eigentlich, dass wir diese bestimmte Achse entfernen wollen (hier Achse 0).

Beispiel: Für dieses spezielle Dataset, wenn wir die Summe mit Achse = 0 berechnen, wollen wir tatsächlich die Nullachse entfernen (aggregieren). Sobald wir die Nullachse entfernen, wird die Aggregation entlang der Nullachse dazu führen, dass [1,4,3] gleich 8, [2,3,6] gleich 11 und [5,7,9] gleich 21 werden. Ähnliche Logik kann auf Achse = 1 erweitert werden.

Im Fall von Drop, Concat und einigen anderen Funktionen aggregieren wir tatsächlich nicht die Ergebnisse.

Das mentale Modell, das ich zur Intuition verwende:

Stellen Sie sich vor, wir haben einen Känguru/Frosch in jeder Zelle der ersten Spalte platziert, wenn Achse = 0 oder entlang der ersten Zeile, wenn Achse = 1.

Fall: Wenn Achse = null

Das grüne Plus-Form als Frosch betrachten.

Achse null bedeutet Bewegung entlang der Zeilen

Summe: Angenommen, wir berechnen die Summe, dann werden sie zuerst die Summe ihrer Positionen berechnen (r1c1, r2c1, r3c1) [1,4,3] = [8]. Dann wird ihre nächste Bewegung ebenfalls entlang der Reihe sein, da Achse = 0. Ihre neuen Positionen sind im nächsten Bild (unten).

Drop: If if sie entlang der Reihe auf NaN in (r1c1, r2c1, r3c1) stoßen, werden sie die entsprechende Zeile entfernen, da Achse = 0

Summe: Jetzt werden sie wieder die Summe ihrer Positionen berechnen (r1c2, r2c2, r3c2) [2,3,6] = [11] und ähnlich werden sie einen Schritt vorwärts entlang der Reihe gehen und die Summe für die dritte Spalte berechnen [21].

Drop: If sie entlang der Reihe auf NaN in (r1c2, r2c2, r3c2) stoßen, werden sie die entsprechende Zeile entfernen, da Achse = 0. Ähnliche Logik kann auf verschiedene Achsen und zusätzliche Zeilen/Spalten erweitert werden.

Answer 5

Es gibt zwei häufige Verwendungen von Achsen in Pandas:

1. verwendet als Indexierung, wie df.iloc[0, 1]
2. verwendet als Argument innerhalb einer Funktion, wie df.mean(axis=1)

Beim Verwenden als Indexierung können wir interpretieren, dass axis=0 für Zeilen steht und axis=1 für Spalten steht, was df.iloc[Zeilen, Spalten] bedeutet. Also bedeutet df.iloc[0, 1], dass die Daten aus Zeile 0 und Spalte 1 ausgewählt werden, in diesem Fall gibt es 1,52325 zurück.

Beim Verwenden als Argument bedeutet axis=0, dass Objekte vertikal über Zeilen ausgewählt werden, und axis=1 bedeutet, dass Objekte horizontal über Spalten ausgewählt werden.

Also steht df.mean(axis=1) für das Berechnen des Mittelwerts horizontal über Spalten, und es gibt zurück:

0    1,074821
dtype: float64

Der allgemeine Zweck der Achse besteht darin, spezifische Daten zur Bearbeitung auszuwählen. Und der Schlüssel zum Verständnis der Achse liegt darin, den Prozess der "Auswahl" und "Operation" zu unterscheiden.

Lassen Sie uns dies anhand eines weiteren Beispiels erklären: df.drop('A', axis=1)

1. Die Operation ist df.drop(), sie erfordert den Namen der beabsichtigten Spalte, in diesem Fall 'A'. Es ist nicht dasselbe wie df.mean(), das auf den Dateninhalt operiert.
2. Die Auswahl ist der Name der Spalte, nicht der Dateninhalt der Spalte. Da alle Spaltennamen horizontal angeordnet sind, verwenden wir axis=1, um das Namensobjekt auszuwählen.

Kurz gesagt, wir sollten die "Auswahl" und "Operation" besser trennen, um ein klares Verständnis darüber zu haben:

1. welches Objekt ausgewählt werden soll
2. wie es angeordnet ist