Verwenden Sie das Achsenargument, um ein NumPy-Array in Python zu manipulieren

Dieser Artikel erklärt, wie man mit NumPy-Achsen-Argumenten arbeitet und sieht, was eine Achse in NumPy ist. Wir werden auch lernen, wie man ein Achsen-Argument als leistungsstarke Operation verwendet, um ein NumPy-Array in Python schnell zu manipulieren.

Verwenden Sie ein Achsen-Argument, um ein NumPy-Array in Python zu manipulieren

Zur Demonstration brauchen wir einige Daten, mit denen wir arbeiten können, aber wir wollen nichts zu Großes und Kompliziertes; Deshalb haben wir etwas getan, was wir sehr häufig tun. Wenn wir etwas über NumPy lernen, wird als erstes Arrays genannt, also haben wir in diesem Fall bereits Arrays zum Testen erstellt.

import numpy as np

Temperature_Array = np.array(
    [
        [[26, 25, 24], [24, 25, 26]],
        [[27, 25, 23], [25, 28, 24]],
        [[27, 24, 26], [24, 27, 25]],
        [[27, 26, 24], [28, 25, 26]],
    ]
)

Timeseries_Temperature = np.array(
    [[23, 24, 25, 24, 23, 25], [25, 26, 27, 29, 25, 23], [20, 23, 21, 22, 25, 29]]
)

Das erste Testarray Temperature_Array soll eine gerasterte Vorhersage darstellen. Nehmen wir an, wir haben unsere gerasterten Beobachtungen und versuchen, Viertaktschritte mit sechs Stationen zu emulieren, die in zwei Reihen und drei Spalten angeordnet sind.

Das folgende Teilarray wäre der erste Zeitschritt und so weiter.

[[26, 25, 24], [24, 25, 26]]

Sie werden feststellen, dass wir für jede dieser Achsen eine unterschiedliche Anzahl von Elementen erstellt haben, und dass es vier Zeitschritte und drei Spalten oder drei Stationen in jeder Reihe und zwei Reihen pro Zeitschritt gibt.

Ein häufiger Fehler, wenn Sie etwas mit NumPy ausprobieren, besteht darin, ein 3x3-Array oder ein 3x3x3-Array zu erstellen, und Sie glauben, Sie wüssten, was vor sich geht, aber wenn Sie es in der realen Welt versuchen, funktioniert es nicht.

Das liegt daran, dass Ihre realen Daten eine unterschiedliche Anzahl von Elementen in diesen verschiedenen Richtungen haben und Sie Ihren Slice oder was auch immer Sie zu tun versuchen, nicht hatten.

Die zweite namens Timeseries_Temperature ist einfacher. Es stellt drei Stationen dar, die stündlich die Temperatur beobachten und sechs Stunden haben.

Unsere Zeilen sind Stationen und Spalten sind Zeit.

Wenn Sie ein fünfdimensionales Array haben, dann haben Sie eine Zeile, eine Spalte und die Tiefe kann Zeit sein, aber diese Dimensionen sind Achsen des Arrays. Die Achse ist nur ein einzelner Teil dieses NumPy-Arrays; es ist eine Richtung, durch die hindurchzugehen ist.

Schauen wir uns unsere Timeseries_Temperature an, um ihre Dimension mit dem Attribut ndim zu erhalten, das die Anzahl der Dimensionen eines Arrays ist.

Timeseries_Temperature.ndim

Ausgang:

2

Nehmen wir an, wir möchten einige Informationen über Mindestwerte erhalten. Dann machen wir so etwas:

Timeseries_Temperature.min()

Und wir bekommen 20 zurück, weil 20 tatsächlich der niedrigste Wert in diesem Array ist, aber das ist wahrscheinlich nicht das, was wir wollen. Wir möchten wissen, an welcher Station in den Daten zu irgendeinem Zeitpunkt die niedrigste Temperatur aufgetreten ist, und vielleicht möchten wir die niedrigste Temperatur kennen, die jede Station erfahren hat.

Oder vielleicht möchten wir die minimale Temperatur zu jeder Zeit wissen und wo es in diesen 6 Stunden zu jeder Zeit am kältesten war. Hier kann das Argument Achse ins Spiel kommen und uns sehr helfen.

Wir müssen kein Looping machen, müssen kein manuelles Slicing machen.

Aber um es zu verstehen, machen wir hier ein paar Scheiben.

Timeseries_Temperature[0, :]

Wir erhalten das 0-te Element in der 0-ten Dimension oder der 0-ten Achse, die uns die erste Zeile liefert.

array([23, 24, 25, 24, 23, 25])

Schauen wir uns an, was passiert, wenn wir sagen, gib uns alles, der Doppelpunkt zeigt entlang der nullten Achse an und gibt uns die nullten Elemente entlang der einen Achse.

Timeseries_Temperature[:, 0]

Dies gibt uns die 0. Spalte und alle Zeilen.

array([23, 25, 20])

Jetzt arbeiten wir wieder mit Timeseries_Temperature und rufen die Funktion min() auf. Wenn wir shift + tab drücken, sehen wir, dass wir ein axis-Argument haben, und standardmäßig ist es None.

Jetzt passieren wir die Achse gleich 0.

Timeseries_Temperature.min(axis=0)

Dies gibt uns den Mindestwert im Array, aber das einzelne Element.

array([20, 23, 21, 22, 23, 23])

Wir hatten in beiden Fällen die gleichen Formen, aber anstatt Scheiben zu verwenden, verwendeten wir ein Achsen-Argument, das die spaltenweise Mindesttemperatur jeder Station zu jeder Stunde darstellt.

Jetzt reduzieren wir Achse 1, die als Spalten dargestellt wird, und erhalten jeweils eine Mindeststunde.

Timeseries_Temperature.min(axis=1)

Ausgang:

array([23, 23, 20])

Schauen wir uns nun den komplizierteren Fall an, also drucken wir unser Temperature_Array noch einmal aus, um Ihnen zu zeigen, wie es aussieht.

Temperature_Array

Ausgang:

array([[[26, 25, 24],
        [24, 25, 26]],

       [[27, 25, 23],
        [25, 28, 24]],

       [[27, 24, 26],
        [24, 27, 25]],

       [[27, 26, 24],
        [28, 25, 26]]])

In Temperature_Array haben wir drei Dimensionen Zeile, Spalte und Tiefe. Wenn wir Temperature_Array[0,:,:] eingeben, erhalten wir den ersten Block, die 0-te Achse, die in diesem Fall die Zeitschritte darstellt, und jede eckige Klammer ist effektiv eine Achse.

array([[26, 25, 24],
       [24, 25, 26]])

Anstatt Minimum zu verwenden, verwenden wir dieses Mal ein Mittel von Temperature_Array mit der Funktion mean().

Temperature_Array.mean()

Ausgang:

25.458333333333332

Jetzt verwenden wir eine Achse gleich 0, was bedeutet, dass wir die 0-te Achse zusammenklappen, die die äußersten eckigen Klammern unseres Zeitschritts waren.

Temperature_Array.mean(axis=0)

Wir haben zweireihige und dreispaltige Arrays erhalten, was der Gesamtdurchschnitt der Zeitschritte von Temperature_Array ist.

array([[26.75, 25.  , 24.25],
       [25.25, 26.25, 25.25]])

Wenn Ihre Daten anders angeordnet sind, müssen wir möglicherweise eine andere Achse verwenden; In unserem Fall verwenden wir axis gleich 1.

Temperature_Array.mean(axis=1)

Hier reduzieren wir die Zeilennummern, weshalb wir den Mittelwert aller Zeitschritte der Spalten erhalten.

array([[25. , 25. , 25. ],
       [26. , 26.5, 23.5],
       [25.5, 25.5, 25.5],
       [27.5, 25.5, 25. ]])

Jetzt übergeben wir 2 an das Argument axis, und mit axis gleich 2 kollabieren wir die innerste Dimension, dargestellt durch Spalten. Es ist ein zeilenweiser Durchschnitt bei jedem Zeitschritt oder ein 4x2-Array.

Temperature_Array.mean(axis=2)

Ausgang:

array([[25.        , 25.        ],
       [25.        , 25.66666667],
       [25.66666667, 25.33333333],
       [25.66666667, 26.33333333]])

Vollständiger Code:

# In[1]:

import numpy as np

Temperature_Array = np.array(
    [
        [[26, 25, 24], [24, 25, 26]],
        [[27, 25, 23], [25, 28, 24]],
        [[27, 24, 26], [24, 27, 25]],
        [[27, 26, 24], [28, 25, 26]],
    ]
)

Timeseries_Temperature = np.array(
    [[23, 24, 25, 24, 23, 25], [25, 26, 27, 29, 25, 23], [20, 23, 21, 22, 25, 29]]
)


# In[2]:

Timeseries_Temperature.ndim

# In[3]:

Timeseries_Temperature.min()

# In[4]:

Timeseries_Temperature[0, :]

# In[5]:

Timeseries_Temperature[:, 0]

# In[6]:

Timeseries_Temperature.min(axis=0)

# In[7]:

Timeseries_Temperature.min(axis=1)

# In[8]:

Temperature_Array

# In[9]:

Temperature_Array.ndim

# In[10]:

Temperature_Array[0, :, :]

# In[11]:

Temperature_Array.mean()

# In[12]:

Temperature_Array.mean(axis=0)

# In[13]:

Temperature_Array.mean(axis=1)

# In[14]:

Temperature_Array.mean(axis=2)