Was bedeutet Achse in Pandas?

Hier ist mein Code zum Generieren eines Datenrahmens:

import pandas as pd
import numpy as np

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

dann habe ich den Datenrahmen bekommen:

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

Wenn ich den Befehl eingebe:

dff.mean(axis=1)

Ich habe :

0    1.074821
dtype: float64

Nach der Referenz von Pandas steht Achse = 1 für Spalten und ich erwarte das Ergebnis des Befehls

A    0.626386
B    1.523255
dtype: float64

Hier ist meine Frage: Was bedeutet die Achse in Pandas?

Es gibt die Achse an, entlang der die Mittelwerte berechnet werden. Standardmäßig axis=0. Dies steht im Einklang mit der numpy.meanVerwendung, wenn explizitaxis angegeben wird (in , axis == Standardmäßig keine, die den Mittelwert über das abgeflachte Array berechnet), in der entlang der Zeilen (nämlich Index in Pandas) und entlang der Spalten . Für zusätzliche Klarheit kann man wählen (anstelle von ) oder (anstelle von ).numpy.meanaxis=0axis=1axis='index'axis=0axis='columns'axis=1

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

Diese Antworten helfen zwar, dies zu erklären, sind jedoch für Nicht-Programmierer (dh für jemanden wie mich, der Python zum ersten Mal im Rahmen von Data Science-Kursen lernt) nicht ganz intuitiv. Ich finde es immer noch verwirrend, die Begriffe "entlang" oder "für jedes" für Zeilen und Spalten zu verwenden.

Was für mich sinnvoller ist, ist es so zu sagen:

• Achse 0 wirkt auf alle REIHEN in jeder SPALTE
• Achse 1 wirkt auf alle SPALTEN in jeder REIHE

Ein Mittelwert auf Achse 0 ist also der Mittelwert aller Zeilen in jeder Spalte, und ein Mittelwert auf Achse 1 ist ein Mittelwert aller Spalten in jeder Zeile.

Letztendlich sagt dies dasselbe wie @zhangxaochen und @Michael, aber auf eine Weise, die für mich leichter zu verinnerlichen ist.

Lassen Sie uns visualisieren (Sie werden sich immer daran erinnern),

In Pandas:

1. Achse = 0 bedeutet entlang "Indizes". Es ist eine zeilenweise Operation .

Angenommen, um eine concat () - Operation für Datenrahmen1 und Datenrahmen2 auszuführen, nehmen wir Datenrahmen1 und nehmen die erste Zeile aus Datenrahmen1 heraus und platzieren sie in der neuen DF. Dann nehmen wir eine weitere Zeile aus Datenrahmen1 heraus und fügen sie in die neue DF ein. Wir wiederholen diesen Vorgang bis Wir erreichen den unteren Rand von dataframe1. Dann machen wir den gleichen Prozess für dataframe2.

Grundsätzlich kann der Datenrahmen2 auf den Datenrahmen1 gestapelt werden oder umgekehrt.

ZB einen Stapel Bücher auf einem Tisch oder Boden machen

2. Achse = 1 bedeutet entlang "Spalten". Es ist eine spaltenweise Operation.

Angenommen, um eine concat () - Operation für Datenrahmen1 und Datenrahmen2 auszuführen, nehmen wir die erste vollständige Spalte (auch bekannt als 1. Serie) von Datenrahmen1 heraus und platzieren sie in einem neuen DF. Dann nehmen wir die zweite Spalte von Datenrahmen1 heraus und bleiben neben ihr (seitwärts) ) müssen wir diesen Vorgang wiederholen, bis alle Spalten fertig sind. Dann wiederholen wir den gleichen Vorgang auf dataframe2. Grundsätzlich Datenrahmen2 seitlich stapeln.

ZB Bücher in einem Bücherregal arrangieren.

Mehr dazu, da Arrays im Vergleich zu Matrizen bessere Darstellungen sind, um eine verschachtelte n-dimensionale Struktur darzustellen! Im Folgenden können Sie besser veranschaulichen, wie die Achse eine wichtige Rolle spielt, wenn Sie auf mehr als eine Dimension verallgemeinern. Sie können auch jedes n-dim-Array drucken / schreiben / zeichnen / visualisieren, aber das Schreiben oder Visualisieren desselben in einer Matrixdarstellung (3-dim) ist auf einem Papier mit mehr als 3 Dimensionen nicht möglich.

axisbezieht sich auf die Dimension des Arrays, im Fall von pd.DataFrames axis=0ist die Dimension, die nach unten zeigt, und axis=1die Dimension, die nach rechts zeigt.

Beispiel: Denken Sie an eine ndarraymit Form (3,5,7).

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

aist eine 3-dimensionale ndarray, dh es hat 3 Achsen ("Achsen" ist Plural von "Achse"). Die Konfiguration von asieht aus wie 3 Scheiben Brot, wobei jede Scheibe die Größe 5 mal 7 hat. a[0,:,:]bezieht sich auf die 0. Scheibe, a[1,:,:]bezieht sich auf die 1. Scheibe usw.

a.sum(axis=0)gilt sum()entlang der 0-ten Achse von a. Sie werden alle Scheiben hinzufügen und am Ende eine Scheibe Form erhalten (5,7).

a.sum(axis=0) ist äquivalent zu

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

bund a.sum(axis=0)beide werden so aussehen

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.DataFramefunktionieren die Achsen genauso wie in numpy.arrays: axis=0gelten sum()oder jede andere Reduktionsfunktion für jede Spalte.

NB In der Antwort von @ zhangxaochen finde ich die Sätze "entlang der Zeilen" und "entlang der Spalten" etwas verwirrend. axis=0sollte sich auf "entlang jeder Spalte" und axis=1"entlang jeder Zeile" beziehen .

Für mich ist es am einfachsten zu verstehen, ob Sie für jede Spalte ( axis = 0) oder jede Zeile ( axis = 1) eine Statistik berechnen . Wenn Sie eine Statistik berechnen, sagen Sie einen Mittelwert, mit dem axis = 0Sie diese Statistik für jede Spalte erhalten. Wenn also jede Beobachtung eine Zeile ist und sich jede Variable in einer Spalte befindet, erhalten Sie den Mittelwert jeder Variablen. Wenn Sie festlegen axis = 1, berechnen Sie Ihre Statistik für jede Zeile. In unserem Beispiel erhalten Sie den Mittelwert für jede Beobachtung über alle Ihre Variablen (möglicherweise möchten Sie den Durchschnitt der zugehörigen Kennzahlen).

axis = 0: nach Spalte = spaltenweise = entlang der Zeilen

axis = 1: nach Zeile = zeilenweise = entlang der Spalten

Schauen wir uns die Tabelle aus dem Wiki an. Dies ist eine IWF-Schätzung des BIP von 2010 bis 2019 für die zehn wichtigsten Länder.

1. Achse 1 wirkt für jede Zeile in allen Spalten.
Wenn Sie das durchschnittliche (mittlere) BIP für JEDES Land über das Jahrzehnt (2010-2019) berechnen möchten, müssen Sie Folgendes tun : df.mean(axis=1). Wenn Sie beispielsweise das mittlere BIP der Vereinigten Staaten von 2010 bis 2019 berechnen möchten,df.loc['United States','2010':'2019'].mean(axis=1)

2. Achse 0 wirkt für jede Spalte in allen Zeilen.
Wenn ich das durchschnittliche (mittlere) BIP für JEDES Jahr für alle Länder berechnen möchte, müssen Sie Folgendes tun : df.mean(axis=0). Wenn Sie beispielsweise das mittlere BIP des Jahres 2015 für die USA, China, Japan, Deutschland und Indien berechnen möchten, df.loc['United States':'India','2015'].mean(axis=0)

beachten Sie: Der obige Code funktioniert nur, nachdem Sie die Spalte "Land (oder abhängiges Gebiet)" als Index festgelegt haben set_indexMethode.

Die Achse im Hinblick auf die Programmierung ist die Position im Formtupel. Hier ist ein Beispiel:

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)

Der Mittelwert auf der Achse bewirkt, dass diese Bemaßung entfernt wird.

In Bezug auf die ursprüngliche Frage ist die dff-Form (1,2). Wenn Sie Achse = 1 verwenden, wird die Form in (1,) geändert.

Der Designer von Pandas, Wes McKinney, arbeitete intensiv an Finanzdaten. Stellen Sie sich Spalten als Aktiennamen und Index als Tageskurse vor. Sie können dann das Standardverhalten (dh axis=0) in Bezug auf diese Finanzdaten erraten . axis=1kann einfach als "die andere Richtung" gedacht werden.

Zum Beispiel können die Statistikfunktionen, wie zum Beispiel mean(), sum(), describe(), count()alle standardmäßig spaltenweise , weil es macht mehr Sinn , sie für jede Aktie zu tun. sort_index(by=)Standardmäßig wird auch die Spalte verwendet. fillna(method='ffill')wird entlang der Spalte gefüllt, da es sich um den gleichen Bestand handelt. dropna()Standardmäßig wird gerudert, weil Sie wahrscheinlich nur den Preis an diesem Tag verwerfen möchten, anstatt alle Kurse dieser Aktie wegzuwerfen.

In ähnlicher Weise bezieht sich die Indexierung in eckigen Klammern auf die Spalten, da es üblicher ist, eine Aktie auszuwählen, anstatt einen Tag auszuwählen.

Eine der einfachen Möglichkeiten, sich Achse 1 (Spalten) gegenüber Achse 0 (Zeilen) zu merken, ist die erwartete Ausgabe.

• Wenn Sie für jede Zeile eine Ausgabe erwarten, verwenden Sie axis = 'column'.
• Wenn Sie dagegen für jede Spalte eine Ausgabe wünschen, verwenden Sie axis = 'rows'.

Das Problem bei der axis=ordnungsgemäßen Verwendung besteht in der Verwendung für zwei verschiedene Hauptfälle:

1. Zum Berechnen eines akkumulierten Werts oder zum Neuanordnen (z. B. Sortieren) von Daten.
2. Zum Manipulieren ("Spielen" mit) Entitäten (z . B. Datenrahmen ).

Die Hauptidee hinter dieser Antwort ist, dass wir zur Vermeidung von Verwirrung entweder eine Zahl oder einen Namen zur Angabe der jeweiligen Achse auswählen , je nachdem , was klarer, intuitiver und beschreibender ist.

Pandas basiert auf NumPy, das auf Mathematik basiert, insbesondere auf n-dimensionalen Matrizen. Hier ist ein Bild für die allgemeine Verwendung von Achsnamen in der Mathematik im dreidimensionalen Raum:

Dieses Bild dient nur zum Speichern der Ordnungszahlen der Achsen :

• 0 für die x-Achse
• 1 für die y-Achse und
• 2 für die z-Achse.

Die Z-Achse gilt nur für Panels . Für Datenrahmen beschränken wir unser Interesse auf die grün gefärbte, zweidimensionale Grundebene mit x-Achse ( 0vertikal) und y-Achse ( 1horizontal).

Es ist alles für Zahlen als mögliche Werte von axis=Parametern.

Die Namen der Achsen sind 'index'(Sie können den Alias ​​verwenden 'rows') und 'columns'für diese Erklärung ist die Beziehung zwischen diesen Namen und den Ordnungszahlen (der Achsen) NICHT wichtig , da jeder weiß, was die Wörter "Zeilen" und "Spalten" bedeuten ( und jeder hier - ich nehme an - weiß, was das Wort "Index" in Pandas bedeutet).

Und jetzt meine Empfehlung:

1. Wenn Sie einen akkumulierten Wert berechnen möchten , können Sie ihn aus Werten berechnen, die sich entlang der Achse 0 (oder entlang der Achse 1 ) befinden - verwenden Sie axis=0(oder axis=1).

   Wenn Sie Werte neu anordnen möchten , verwenden Sie die Achsnummer der Achse, entlang derer sich Daten zum Neuanordnen befinden (z . B. zum Sortieren ).

2. Wenn Sie möchten , manipulieren (zB verketten ) Einheiten (zB Datenrahmen ) - Verwendung axis='index'(Synonym: axis='rows') oder axis='columns'die angeben resultierende Änderung - Index ( Zeilen ) oder Spalten sind.
   (Zum Verketten erhalten Sie entweder einen längeren Index (= mehr Zeilen) bzw. mehr Spalten .)

Dies basiert auf der Antwort von @ Safak. Der beste Weg, um die Achsen in pandas / numpy zu verstehen, besteht darin, ein 3D-Array zu erstellen und das Ergebnis der Summenfunktion entlang der 3 verschiedenen Achsen zu überprüfen.

 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)

gibt Ihnen die folgenden Ergebnisse:

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

Ich verstehe so:

Angenommen, Ihre Operation erfordert das Durchlaufen von links nach rechts / von rechts nach links in einem Datenrahmen. Sie führen anscheinend Spalten zusammen, d. H. Sie arbeiten mit verschiedenen Spalten. Dies ist Achse = 1

Beispiel

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

Hier ist zu beachten, dass wir an Spalten arbeiten

Wenn für Ihren Vorgang ein Durchlaufen von oben nach unten / von unten nach oben in einem Datenrahmen erforderlich ist, führen Sie Zeilen zusammen. Dies ist Achse = 0 .

Achse = 0 bedeutet von oben nach unten Achse = 1 bedeutet von links nach rechts

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

Das angegebene Beispiel ist die Summe aller Daten in Spalte == Schlüssel.

Mein Denken: Achse = n, wobei n = 0, 1 usw. bedeutet, dass die Matrix entlang dieser Achse kollabiert (gefaltet) ist. Wenn Sie also in einer 2D-Matrix entlang 0 (Zeilen) kollabieren, arbeiten Sie tatsächlich jeweils an einer Spalte. Ähnliches gilt für Matrizen höherer Ordnung.

Dies ist nicht dasselbe wie der normale Verweis auf eine Dimension in einer Matrix, wobei 0 -> Zeile und 1 -> Spalte. Ähnliches gilt für andere Dimensionen in einem N-Dimensions-Array.

Ich bin ein Neuling bei Pandas. Aber so verstehe ich die Achse bei Pandas:

Achse Constant Unterschiedlich Richtung

0 Spaltenzeile nach unten |

1 Zeile Spalte nach rechts ->

Um den Mittelwert einer Spalte zu berechnen, sollte diese bestimmte Spalte konstant sein, aber die Zeilen darunter können sich ändern (variieren). sodass sie Achse = 0 ist.

Um den Mittelwert einer Zeile zu berechnen, ist diese bestimmte Zeile konstant , kann jedoch verschiedene Spalten durchlaufen (variierend) , Achse = 1.

Ich denke, es gibt einen anderen Weg, es zu verstehen.

Wenn wir für ein np.array Spalten entfernen möchten, verwenden wir axis = 1; Wenn wir Zeilen entfernen möchten, verwenden wir 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,)

axis = 0Steht für pandas object für zeilenweise Operation und axis = 1steht für spaltenweise Operation. Dies unterscheidet sich von numpyder Definition, wir können Definitionen aus numpy.doc und pandas.doc überprüfen

Ich werde ausdrücklich vermeiden, "zeilenweise" oder "entlang der Spalten" zu verwenden, da die Leute sie möglicherweise genau falsch interpretieren.

Analogie zuerst. Intuitiv würden Sie erwarten, dass pandas.DataFrame.drop(axis='column')eine Spalte aus N Spalten entfernt wird und Sie (N - 1) Spalten erhalten. Sie können also vorerst KEINE Aufmerksamkeit auf Zeilen richten (und das Wort "Zeile" aus Ihrem englischen Wörterbuch entfernen). Umgekehrt drop(axis='row')funktioniert dies bei Zeilen.

Arbeitet auf die gleiche Weise sum(axis='column')an mehreren Spalten und gibt Ihnen 1 Spalte. Ähnlich,sum(axis='row') ergibt sich 1 Zeile. Dies steht im Einklang mit der einfachsten Form der Definition, bei der eine Liste von Zahlen auf eine einzige Zahl reduziert wird.

Im Allgemeinen axis=columnsehen Sie mit Spalten, arbeiten an Spalten und rufen Spalten ab. Zeilen vergessen.

Mit axis=row, Perspektive ändern und die Arbeit an Reihen.

0 und 1 sind nur Aliase für 'Zeile' und 'Spalte'. Es ist die Konvention der Matrixindizierung.

Ich habe auch in der letzten Stunde versucht, die Achse herauszufinden. Die Sprache in allen obigen Antworten und auch die Dokumentation sind überhaupt nicht hilfreich.

Um die Frage so zu beantworten, wie ich sie jetzt verstehe, bedeutet in Pandas Achse = 1 oder 0, welche Achsenüberschriften Sie beim Anwenden der Funktion konstant halten möchten.

Hinweis: Wenn ich Überschriften sage, meine ich Indexnamen

Erweitern Sie Ihr Beispiel:

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

Für Achse = 1 = Spalten: Wir halten die Spaltenüberschriften konstant und wenden die Mittelwertfunktion an, indem wir Daten ändern. Zur Demonstration halten wir die Spaltenüberschriften konstant wie folgt:

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

Jetzt füllen wir einen Satz von A- und B-Werten und finden dann den Mittelwert

|            | 0.626386| 1.52325|  

Dann füllen wir den nächsten Satz von A- und B-Werten und finden den Mittelwert

|            | 0.626386| 1.52325|

In ähnlicher Weise halten wir für Achse = Zeilen die Zeilenüberschriften konstant und ändern die Daten ständig: Um dies zu demonstrieren, korrigieren Sie zuerst die Zeilenüberschriften:

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

Füllen Sie nun den ersten Satz von X- und Y-Werten aus und ermitteln Sie den Mittelwert

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

Füllen Sie dann den nächsten Satz von X- und Y-Werten aus und ermitteln Sie den Mittelwert:

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

Zusammenfassend,

Wenn Achse = Spalten, korrigieren Sie die Spaltenüberschriften und ändern Daten, die aus den verschiedenen Zeilen stammen.

Wenn Achse = Zeilen, korrigieren Sie die Zeilenüberschriften und ändern Daten, die aus den verschiedenen Spalten stammen.

Achse = 1, Es wird die Summe zeilenweise angegeben, keepdims = True behält die 2D-Dimension bei. Hoffe es hilft dir.

Viele Antworten hier haben mir sehr geholfen!

Falls Sie durch die unterschiedlichen Verhaltensweisen axisin Python und MARGINR (wie in der applyFunktion) verwirrt sind , finden Sie möglicherweise einen Blog-Beitrag, den ich von Interesse geschrieben habe: https://accio.github.io/programming/2020/05/ 19 / numpy-pandas-axis.html .

Im Wesentlichen:

• Interessanterweise sind ihre Verhaltensweisen mit dreidimensionalen Arrays leichter zu verstehen als mit zweidimensionalen Arrays.
• In Python-Paketen numpyundpandas gibt der Achsenparameter in sum tatsächlich numpy an, um den Mittelwert aller Werte zu berechnen, die in Form eines Arrays [0, 0, ..., i, ..., 0] abgerufen werden können, durch das i iteriert alle möglichen Werte. Der Vorgang wird wiederholt, wobei die Position von i festgelegt ist und die Indizes anderer Dimensionen nacheinander variieren (vom äußersten rechten Element). Das Ergebnis ist ein n-1-dimensionales Array.
• In R lässt der Parameter MARGINS die applyFunktion den Mittelwert aller Werte berechnen, die in Form eines Arrays [, ..., i, ...,] abgerufen werden können, wobei i alle möglichen Werte durchläuft. Der Vorgang wird nicht wiederholt, wenn alle i-Werte iteriert wurden. Daher ist das Ergebnis ein einfacher Vektor.

Arrays werden mit der sogenannten Achse = 0 und vertikal gegenüber der Achse = 1 positionierten Zeilen und horizontal positionierten Spalten entworfen. Die Achse bezieht sich auf die Dimension des Arrays.