NumPy Tutorial: Datenanalyse mit Python

Verpassen Sie nicht unseren KOSTENLOSEN NumPy-Spickzettel am Ende dieses Beitrags

NumPy ist ein häufig verwendetes Python-Paket zur Datenanalyse. Durch die Verwendung von NumPy können Sie Ihre Arbeitsabläufe beschleunigen und Schnittstellen zu anderen Paketen im Python-Ökosystem, wie scikit-learn, nutzen, die NumPy unter der Haube verwenden. NumPy wurde ursprünglich Mitte der 2000er Jahre entwickelt und ist aus einem noch älteren Paket namens Numeric hervorgegangen. Diese Langlebigkeit bedeutet, dass fast jedes Datenanalyse- oder Machine-Learning-Paket für Python NumPy in irgendeiner Weise nutzt.

In diesem Tutorial werden wir die Verwendung von NumPy zur Analyse von Daten zur Weinqualität erläutern. Die Daten enthalten Informationen über verschiedene Attribute von Weinen, wie pH und fixed acidity, zusammen mit einer Qualitätsbewertung zwischen 0 und 10 für jeden Wein. Die Qualitätsbewertung ist der Durchschnitt von mindestens 3 menschlichen Verkostungstestern. Während wir lernen, wie man mit NumPy arbeitet, werden wir versuchen, mehr über die wahrgenommene Qualität von Wein herauszufinden.

Die Weine, die wir analysieren werden, stammen aus der Region Minho in Portugal.

Die Daten wurden vom UCI Machine Learning Repository heruntergeladen und sind hier verfügbar. Hier sind die ersten Zeilen der winequality-red.csv-Datei, die wir in diesem Tutorium verwenden werden:

"fixed acidity";"volatile acidity";"citric acid";"residual sugar";"chlorides";"free sulfur dioxide";"total sulfur dioxide";"density";"pH";"sulphates";"alcohol";"quality"7.4;0.7;0;1.9;0.076;11;34;0.9978;3.51;0.56;9.4;57.8;0.88;0;2.6;0.098;25;67;0.9968;3.2;0.68;9.8;5

Die Daten liegen im so genannten ssv-Format (semicolon separated values) vor – jeder Datensatz wird durch ein Semikolon (;) getrennt, und die Zeilen werden durch eine neue Zeile getrennt. Es gibt 1600 Zeilen in der Datei, einschließlich einer Kopfzeile, und 12 Spalten.

Bevor wir anfangen, ein kurzer Hinweis zur Version – wir werden Python 3.5 verwenden. Unsere Code-Beispiele werden mit Jupyter notebook durchgeführt.

Listen von Listen für CSV-Daten

Bevor wir NumPy verwenden, werden wir zunächst versuchen, mit den Daten mit Python und dem csv-Paket zu arbeiten. Wir können die Datei mit dem csv.reader-Objekt einlesen, das es uns ermöglicht, den gesamten Inhalt der ssv-Datei einzulesen und aufzuteilen.

Im folgenden Code:

• Importieren Sie die csv-Bibliothek.
• Öffnen Sie die winequality-red.csv-Datei.
  • Erstellen Sie bei geöffneter Datei ein neues csv.reader-Objekt.
    • Geben Sie das Schlüsselwortargument delimiter=";" ein, um sicherzustellen, dass die Datensätze am Semikolon-Zeichen anstelle des Standard-Komma-Zeichens aufgeteilt werden.
  • Rufen Sie den Listentyp auf, um alle Zeilen aus der Datei zu erhalten.
  • Zuweisung des Ergebnisses an wines.

import csvwith open('winequality-red.csv', 'r') as f: wines = list(csv.reader(f, delimiter=';'))

Nachdem wir die Daten eingelesen haben, können wir die ersten 3 Zeilen ausgeben:

print(wines)

, , ]

Die Daten wurden in eine Liste von Listen eingelesen. Jede innere Liste ist eine Zeile aus der ssv-Datei. Wie Sie vielleicht bemerkt haben, wird jedes Element in der gesamten Liste von Listen als Zeichenkette dargestellt, was es schwieriger macht, Berechnungen durchzuführen.

Wir werden die Daten in eine Tabelle formatieren, damit sie leichter zu sehen sind:

Wie Sie aus der obigen Tabelle ersehen können, haben wir drei Zeilen eingelesen, von denen die erste die Spaltenüberschriften enthält. Jede Zeile nach der Kopfzeile stellt einen Wein dar. Das erste Element jeder Zeile ist der fixed acidity, das zweite der volatile acidity und so weiter. Wir können den Durchschnitt quality der Weine ermitteln. Der folgende Code wird:

• Das letzte Element aus jeder Zeile nach der Kopfzeile extrahieren.
• Jedes extrahierte Element in einen Float umwandeln.
• Alle extrahierten Elemente der Liste qualities zuordnen.
• Dividieren Sie die Summe aller Elemente in qualities durch die Gesamtzahl der Elemente in qualities, um den Mittelwert zu erhalten.

qualities =) for item in wines]sum(qualities) / len(qualities)

5.6360225140712945

Obwohl wir die gewünschte Berechnung durchführen konnten, ist der Code ziemlich komplex, und es macht keinen Spaß, jedes Mal etwas Ähnliches tun zu müssen, wenn wir eine Menge berechnen wollen. Zum Glück können wir NumPy verwenden, um die Arbeit mit unseren Daten zu erleichtern.

Numpy 2-dimensionale Arrays

Mit NumPy arbeiten wir mit mehrdimensionalen Arrays. Wir werden später auf alle möglichen Arten von mehrdimensionalen Arrays eingehen, aber für den Moment konzentrieren wir uns auf 2-dimensionale Arrays. Ein 2-dimensionales Array ist auch als Matrix bekannt und sollte Ihnen vertraut sein. Im Grunde ist es nur eine andere Art, sich eine Liste von Listen vorzustellen. Eine Matrix hat Zeilen und Spalten. Durch Angabe einer Zeilennummer und einer Spaltennummer können wir ein Element aus einer Matrix extrahieren.

In der folgenden Matrix ist die erste Zeile die Kopfzeile und die erste Spalte ist die Spalte fixed acidity:

Wenn wir das Element in der ersten Zeile und der zweiten Spalte wählen würden, bekämen wir volatile acidity. Wenn wir das Element in der dritten Zeile und der zweiten Spalte auswählen würden, bekämen wir 0.88.

In einem NumPy-Array wird die Anzahl der Dimensionen als Rang bezeichnet, und jede Dimension wird als Achse bezeichnet. Die Zeilen sind also die erste Achse, und die Spalten sind die zweite Achse.

Nachdem Sie nun die Grundlagen von Matrizen verstanden haben, wollen wir sehen, wie wir von unserer Liste von Listen zu einem NumPy-Array kommen.

Erstellen eines NumPy-Arrays

Wir können ein NumPy-Array mit der Funktion numpy.array erstellen. Wenn wir eine Liste von Listen übergeben, wird automatisch ein NumPy-Array mit der gleichen Anzahl von Zeilen und Spalten erstellt. Da wir wollen, dass alle Elemente im Array zur einfachen Berechnung Fließkommaelemente sind, lassen wir die Kopfzeile weg, die Strings enthält. Eine der Einschränkungen von NumPy besteht darin, dass alle Elemente in einem Array vom gleichen Typ sein müssen. Wenn wir also die Kopfzeile einschließen, werden alle Elemente im Array als Strings eingelesen. Da wir in der Lage sein wollen, Berechnungen durchzuführen, wie z.B. den Durchschnitt quality der Weine zu finden, müssen die Elemente alle Fließkommazahlen sein.

Im folgenden Code:

• Importieren Sie das numpy Paket.
• Übergeben Sie die Liste der Listen wines an die Funktion array, die sie in ein NumPy-Array umwandelt.
  • Schließen Sie die Kopfzeile mit List Slicing aus.
  • Spezifizieren Sie das Schlüsselwortargument dtype, um sicherzustellen, dass jedes Element in eine Fließkommazahl umgewandelt wird. Wir werden später noch genauer darauf eingehen, was dtype ist.

import csvwith open("winequality-red.csv", 'r') as f: wines = list(csv.reader(f, delimiter=";"))import numpy as npwines = np.array(wines, dtype=np.float)

Versuchen Sie, den obigen Code auszuführen und zu sehen, was passiert!

Wenn wir wines anzeigen, erhalten wir jetzt ein NumPy-Array:

wines

array(,,,...,,,])

Wir können die Anzahl der Zeilen und Spalten in unseren Daten mithilfe der Shape-Eigenschaft von NumPy-Arrays überprüfen:

wines.shape

(1599, 12)

Alternative Methoden zur Erstellung von NumPy-Arrays

Es gibt eine Reihe von Methoden, die Sie zum Erstellen von NumPy-Arrays verwenden können. Zunächst können Sie ein Array erstellen, bei dem jedes Element Null ist. Der folgende Code erstellt ein Array mit 3 Zeilen und 4 Spalten, bei dem jedes Element 0 ist, mit numpy.zeros:

import numpy as np

empty_array = np.zeros((3,4)) empty_array

Es ist nützlich, ein Array mit allen Nullelementen zu erstellen, wenn Sie ein Array mit fester Größe benötigen, aber noch keine Werte dafür haben.

Sie können auch ein Array erstellen, bei dem jedes Element eine Zufallszahl ist, mit numpy.random.rand. Hier ist ein Beispiel:

np.random.rand(3,4)

array(,,])

Das Erstellen von Arrays voller Zufallszahlen kann nützlich sein, wenn Sie Ihren Code schnell mit Beispiel-Arrays testen wollen.

NumPy zum Einlesen von Dateien verwenden

Es ist möglich, NumPy zu verwenden, um csv- oder andere Dateien direkt in Arrays einzulesen. Das geht mit der Funktion numpy.genfromtxt. Wir können sie verwenden, um unsere ersten Daten über Rotweine einzulesen.

Im folgenden Code:

• Verwenden Sie die Funktion genfromtxt, um die Datei winequality-red.csv einzulesen.
• Spezifizieren Sie das Schlüsselwortargument delimiter=";", damit die Felder richtig geparst werden.
• Spezifizieren Sie das Schlüsselwortargument skip_header=1, damit die Kopfzeile übersprungen wird.

wines = np.genfromtxt("winequality-red.csv", delimiter=";", skip_header=1)

wines wird am Ende genauso aussehen, als ob wir sie in eine Liste einlesen und dann in ein Array von Floats konvertieren würden. NumPy wählt automatisch einen Datentyp für die Elemente in einem Array, basierend auf ihrem Format.

Indizierung von NumPy-Arrays

Wir wissen jetzt, wie man Arrays erstellt, aber solange wir keine Ergebnisse aus ihnen abrufen können, gibt es nicht viel, was wir mit NumPy tun können. Wir können Array-Indizierung verwenden, um einzelne Elemente, Gruppen von Elementen oder ganze Zeilen und Spalten auszuwählen. Dabei ist zu beachten, dass NumPy genau wie Python-Listen einen Null-Index hat, d. h. der Index der ersten Zeile ist 0 und der Index der ersten Spalte ist 0. Wenn wir mit der vierten Zeile arbeiten wollen, verwenden wir den Index 3, wenn wir mit der zweiten Zeile arbeiten wollen, verwenden wir den Index 1, und so weiter. Wir arbeiten wieder mit dem Array wines:

Lassen Sie uns das Element in Zeile 3 und Spalte 4 auswählen. Im folgenden Code geben wir den Index 2 als Zeilenindex und den Index 3 als Spaltenindex ein. Dies ruft den Wert aus der vierten Spalte der dritten Zeile ab:

wines

2.2999999999999998

Da wir in NumPy mit einem 2-dimensionalen Array arbeiten, geben wir zwei Indizes an, um ein Element abzurufen. Der erste Index ist der Zeilen- oder Achsenindex 1, und der zweite Index ist der Spalten- oder Achsenindex 2. Jedes Element in wines kann mit den 2-Indizes abgerufen werden.

Slicing NumPy Arrays

Wenn wir stattdessen die ersten drei Elemente aus der vierten Spalte auswählen wollen, können wir dies mit einem Doppelpunkt (:) tun. Ein Doppelpunkt zeigt an, dass wir alle Elemente vom Startindex bis zum Endindex, aber nicht darunter, auswählen wollen. Dies wird auch als Slice bezeichnet:

wines

array()

Genauso wie bei der Listenaufteilung kann man das 0 weglassen, um alle Elemente vom Anfang bis zum Element 3 abzurufen:

wines

array()

Wir können eine ganze Spalte auswählen, indem wir angeben, dass wir alle Elemente vom ersten bis zum letzten wollen. Dies geschieht durch einen Doppelpunkt (:) ohne Anfangs- oder Endindizes. Der folgende Code wählt die gesamte vierte Spalte aus:

wines

array()

Wir haben oben eine ganze Spalte ausgewählt, aber wir können auch eine ganze Zeile extrahieren:

wines

array()

Wenn wir unsere Indizierung auf die Spitze treiben, können wir das gesamte Array mit zwei Doppelpunkten auswählen, um alle Zeilen und Spalten in wines auszuwählen. Das ist ein toller Partytrick, hat aber nicht viele gute Anwendungen:

wines

array(,,<br />,<br />...,,,<br />])

Werte an NumPy-Arrays zuweisen

Wir können die Indizierung auch verwenden, um bestimmten Elementen in Arrays Werte zuzuweisen. Wir können dies tun, indem wir direkt dem indizierten Wert zuweisen:

wines = 10

Dasselbe können wir für Slices tun. Um eine ganze Spalte zu überschreiben, können wir Folgendes tun:

wines = 50

Der obige Code überschreibt alle Werte in der elften Spalte mit 50.

1-Dimensionale NumPy-Arrays

Bis jetzt haben wir mit 2-dimensionalen Arrays gearbeitet, wie wines. NumPy ist jedoch ein Paket für die Arbeit mit mehrdimensionalen Arrays. Einer der häufigsten Typen von mehrdimensionalen Arrays ist das 1-dimensionale Array oder der Vektor. Wie Sie oben vielleicht bemerkt haben, haben wir beim Slicen von wines ein 1-dimensionales Array abgerufen. Ein 1-dimensionales Array benötigt nur einen einzigen Index, um ein Element abzurufen. Jede Zeile und Spalte in einem 2-dimensionalen Array ist ein 1-dimensionales Array. So wie eine Liste von Listen einem 2-dimensionalen Array entspricht, entspricht eine einzelne Liste einem 1-dimensionalen Array. Wenn wir Weine zerschneiden und nur die dritte Zeile abrufen, erhalten wir ein 1-dimensionales Array:

third_wine = wines

So sieht third_wine aus:

11.2000.2800.5601.9000.07517.00060.0000.9983.1600.5809.8006.000

Wir können einzelne Elemente aus third_wine mit einem einzigen Index abrufen. Der folgende Code zeigt das zweite Element in third_wine an:

third_wine

0.28000000000000003

Die meisten NumPy-Funktionen, mit denen wir gearbeitet haben, wie numpy.random.rand, können mit mehrdimensionalen Arrays verwendet werden. So würden wir numpy.random.rand verwenden, um einen Zufallsvektor zu erzeugen:

np.random.rand(3)

array()

Beim vorherigen Aufruf von np.random.rand haben wir eine Form für ein 2-dimensionales Array übergeben, so dass das Ergebnis ein 2-dimensionales Array war. Dieses Mal haben wir eine Form für ein eindimensionales Array übergeben. Der Shape gibt die Anzahl der Dimensionen und die Größe des Arrays in jeder Dimension an. Ein Shape von (10,10) ist ein 2-dimensionales Array mit 10 Zeilen und 10 Spalten. Ein Shape von (10,) ist ein 1-dimensionales Array mit 10 Elementen.

Wo NumPy komplexer wird, ist, wenn wir anfangen, mit Arrays zu arbeiten, die mehr als 2 Dimensionen haben.

N-Dimensionale NumPy-Arrays

Das kommt nicht sehr oft vor, aber es gibt Fälle, in denen man mit Arrays umgehen möchte, die mehr als 3 Dimensionen haben. Man kann sich das als eine Liste von Listen von Listen vorstellen. Nehmen wir an, wir wollen die monatlichen Einnahmen eines Geschäfts speichern, aber wir wollen die Ergebnisse für ein Quartal und für ein Jahr schnell nachschlagen können. Die Einnahmen für ein Jahr könnten wie folgt aussehen:

Das Geschäft hat im Januar 0 verdient, im Februar 5, und so weiter. Wir können diese Einnahmen nach Quartal in eine Liste von Listen aufteilen:

year_one = , , , ]

Wir können die Einnahmen von Januar abrufen, indem wir year_one aufrufen. Wenn wir die Ergebnisse für ein ganzes Quartal wollen, können wir year_one oder year_one aufrufen. Wir haben jetzt ein 2-dimensionales Array oder eine Matrix. Was aber, wenn wir nun die Ergebnisse eines anderen Jahres hinzufügen wollen? Wir müssen eine dritte Dimension hinzufügen:

earnings = , , , ], , , , ]]

Wir können die Ergebnisse vom Januar des ersten Jahres abrufen, indem wir earnings aufrufen. Wir brauchen jetzt drei Indizes, um ein einziges Element abzurufen. Mit einem dreidimensionalen Array in NumPy verhält es sich ähnlich. Tatsächlich können wir earnings in ein Array umwandeln und dann den Verdienst für den Januar des ersten Jahres abrufen:

earnings = np.array(earnings)earnings

500

Wir können auch die Form des Arrays ermitteln:

earnings.shape

(2, 4, 3)

Indizierung und Slicing funktionieren bei einem dreidimensionalen Array genau gleich, aber jetzt müssen wir eine zusätzliche Achse übergeben. Wenn wir die Erträge für den Januar aller Jahre abrufen wollten, könnten wir Folgendes tun:

earnings

array()

Wenn wir die Erträge des ersten Quartals aus beiden Jahren abrufen wollten, könnten wir Folgendes tun:

earnings

array(,])

Das Hinzufügen weiterer Dimensionen kann die Abfrage Ihrer Daten erheblich erleichtern, wenn sie auf eine bestimmte Weise organisiert sind. Wenn wir von 3-dimensionalen Arrays zu 4-dimensionalen und größeren Arrays übergehen, gelten dieselben Eigenschaften, und sie können auf dieselbe Weise indiziert und aufgeteilt werden.

NumPy-Datentypen

Wie bereits erwähnt, kann jedes NumPy-Array Elemente eines einzigen Datentyps speichern. Zum Beispiel enthält wines nur Float-Werte. NumPy speichert Werte unter Verwendung seiner eigenen Datentypen, die sich von Python-Typen wie float und str unterscheiden. Das liegt daran, dass der Kern von NumPy in einer Programmiersprache namens C geschrieben ist, die Daten anders speichert als die Python-Datentypen. Die NumPy-Datentypen lassen sich zwischen Python und C abbilden, so dass wir NumPy-Arrays ohne Konvertierungsprobleme verwenden können.

Den Datentyp eines NumPy-Arrays finden Sie, indem Sie auf die dtype-Eigenschaft zugreifen:

wines.dtype

dtype('float64')

NumPy verfügt über verschiedene Datentypen, die meist auf Python-Datentypen wie float und str abgebildet werden. Eine vollständige Auflistung der NumPy-Datentypen finden Sie hier, aber hier sind ein paar wichtige:

• float – numerische Fließkommadaten.
• int – Integer-Daten.
• string – Zeichendaten.
• object – Python-Objekte.

Datentypen enden zusätzlich mit einem Suffix, das angibt, wie viele Bits Speicher sie belegen. So ist int32 ein 32-Bit-Integer-Datentyp und float64 ein 64-Bit-Float-Datentyp.

Datentypen konvertieren

Mit der Methode numpy.ndarray.astype kann man ein Array in einen anderen Typ konvertieren. Die Methode kopiert das Array und gibt ein neues Array mit dem angegebenen Datentyp zurück. Wir können zum Beispiel wines in den Datentyp int konvertieren:

wines.astype(int)

array(,,,...,,,])

Wie Sie oben sehen können, sind alle Elemente im resultierenden Array Ganzzahlen. Beachten Sie, dass wir bei der Konvertierung von wines den Python-Datentyp int und nicht einen NumPy-Datentyp verwendet haben. Das liegt daran, dass mehrere Python-Datentypen, einschließlich float, int und string, mit NumPy verwendet werden können und automatisch in NumPy-Datentypen konvertiert werden.

Wir können die Eigenschaft name des dtype des resultierenden Arrays überprüfen, um zu sehen, welchem Datentyp NumPy das resultierende Array zugeordnet hat:

int_wines = wines.astype(int)int_wines.dtype.name

'int64'

Das Array wurde in einen 64-Bit-Integer-Datentyp konvertiert. Dies ermöglicht sehr lange Integer-Werte, benötigt aber mehr Platz im Speicher als die Speicherung der Werte als 32-Bit-Integer.

Wenn Sie mehr Kontrolle darüber haben wollen, wie das Array im Speicher gespeichert wird, können Sie direkt NumPy dtype-Objekte wie numpy erstellen.int32:

np.int32

numpy.int32

Sie können diese direkt verwenden, um zwischen den Typen zu konvertieren:

wines.astype(np.int32)

array(,,,...,,,], dtype=int32)

NumPy Array Operations

NumPy macht es einfach, mathematische Operationen auf Arrays durchzuführen. Dies ist einer der Hauptvorteile von NumPy und macht es recht einfach, Berechnungen durchzuführen.

Einzelne Array-Mathematik

Wenn man eine der grundlegenden mathematischen Operationen (/, *, -, +, ^) mit einem Array und einem Wert durchführt, wird die Operation auf jedes der Elemente im Array angewendet.

Sagen wir, wir wollen 10 Punkte zu jeder Qualitätsbewertung hinzufügen, weil wir betrunken sind und uns großzügig fühlen. So würden wir das tun:

wines + 10

array()

Beachten Sie, dass die obige Operation das Array wines nicht verändert – es wird ein neues 1-dimensionales Array zurückgegeben, in dem 10 zu jedem Element in der Qualitätsspalte der Weine hinzugefügt wurde.

Wenn wir stattdessen += machen würden, würden wir das Array stattdessen verändern:

wines += 10wines

array()

Alle anderen Operationen funktionieren auf die gleiche Weise. Wenn wir z.B. jeden der Qualitätswerte mit 2 multiplizieren wollen, könnten wir das so machen:

wines * 2

array()

Multiple Array Math

Es ist auch möglich, mathematische Operationen zwischen Arrays durchzuführen. Dabei wird die Operation auf Paare von Elementen angewendet. Wenn wir zum Beispiel die Spalte quality zu sich selbst addieren, erhalten wir folgendes Ergebnis:

wines + wines

array()

Beachten Sie, dass dies äquivalent zu wines * 2 ist – das liegt daran, dass NumPy jedes Paar von Elementen addiert. Das erste Element im ersten Array wird zum ersten Element im zweiten Array addiert, das zweite zum zweiten, und so weiter.

Wir können dies auch zum Multiplizieren von Arrays verwenden. Nehmen wir an, wir wollen einen Wein auswählen, der den höchsten Alkoholgehalt und die beste Qualität hat (wir wollen uns betrinken, aber wir sind stilvoll). Wir würden alcohol mit quality multiplizieren und den Wein mit der höchsten Punktzahl auswählen:

wines * wines

array()

Alle gängigen Operationen (/, *, -, +, ^) funktionieren zwischen Arrays.

Broadcasting

Sofern die Arrays, auf denen man operiert, nicht exakt gleich groß sind, ist es nicht möglich, elementweise Operationen durchzuführen. In solchen Fällen führt NumPy ein Broadcasting durch, um zu versuchen, die Elemente aneinander anzupassen. Im Wesentlichen umfasst das Broadcasting ein paar Schritte:

• Die letzte Dimension jedes Arrays wird verglichen.
  • Wenn die Längen der Dimensionen gleich sind oder eine der Dimensionen die Länge 1 hat, dann machen wir weiter.
  • Wenn die Längen der Dimensionen nicht gleich sind und keine der Dimensionen die Länge 1 hat, dann gibt es einen Fehler.
• Weiter mit der Überprüfung der Dimensionen, bis das kürzeste Array keine Dimensionen mehr hat.

Zum Beispiel sind die folgenden zwei Formen kompatibel:

A: (50,3)B (3,)

Das liegt daran, dass die Länge der letzten Dimension von Array A 3 ist und die Länge der letzten Dimension von Array B 3 ist. Sie sind gleich lang, also ist diese Dimension in Ordnung. Array B hat dann keine Elemente mehr, also ist alles in Ordnung, und die Arrays sind für mathematische Operationen kompatibel.

Die folgenden beiden Formen sind ebenfalls kompatibel:

A: (1,2)B (50,2)

Die letzte Dimension stimmt überein, und A hat in der ersten Dimension die Länge 1.

Diese beiden Matrizen passen nicht zusammen:

A: (50,50)B: (49,49)

Die Längen der Dimensionen sind nicht gleich, und keine der beiden Matrizen hat die Länge 1.

Eine ausführliche Erklärung der Übertragung gibt es hier, aber wir werden einige Beispiele durchgehen, um das Prinzip zu veranschaulichen:

wines * np.array()

------------------------------------------------------------------------ValueError Traceback (most recent call last)<ipython -input-40-821086ccaf65> in <module>()----> 1 wines * np.array()ValueError: operands could not be broadcast together with shapes (1599,12) (2,)</module></ipython>

Das obige Beispiel hat nicht funktioniert, weil die beiden Matrizen keine übereinstimmende hintere Dimension haben. Hier ist ein Beispiel, bei dem die letzte Dimension übereinstimmt:

array_one = np.array( , ])array_two = np.array()array_one + array_two

array(,])

Wie Sie sehen können, wurde array_two über jede Zeile von array_one übertragen. Hier ein Beispiel mit unseren wines-Daten:

rand_array = np.random.rand(12)wines + rand_array

array(,,,...,,,])

Elemente von rand_array werden über jede Zeile von wines verteilt, so dass der ersten Spalte von wines der erste Wert in rand_array hinzugefügt wird, und so weiter.

NumPy Array-Methoden

Zusätzlich zu den üblichen mathematischen Operationen hat NumPy auch mehrere Methoden, die Sie für komplexere Berechnungen auf Arrays verwenden können. Ein Beispiel dafür ist die Methode numpy.ndarray.sum. Diese ermittelt standardmäßig die Summe aller Elemente in einem Array:

wines.sum()

9012.0

Die Summe aller unserer Qualitätsbewertungen ist 154.1788. Wir können das Schlüsselwortargument axis an die Methode sum übergeben, um Summen über eine Achse zu finden. Wenn wir sum über die wines-Matrix aufrufen und axis=0 übergeben, finden wir die Summen über die erste Achse des Arrays. So erhalten wir die Summe aller Werte in jeder Spalte. Es mag verkehrt erscheinen, dass die Summen über die erste Achse die Summe jeder Spalte ergeben, aber eine Möglichkeit, dies zu verstehen, ist, dass die angegebene Achse diejenige ist, die „weggeht“. Wenn wir also axis=0 angeben, wollen wir, dass die Zeilen verschwinden, und wir wollen die Summen für jede der verbleibenden Achsen über jede Zeile finden:

wines.sum(axis=0)

array()

Wir können überprüfen, ob wir die Summe richtig gebildet haben, indem wir die Form überprüfen. Die Form sollte 12 sein, was der Anzahl der Spalten entspricht:

wines.sum(axis=0).shape

(12,)

Wenn wir axis=1 eingeben, finden wir die Summen über die zweite Achse des Arrays. Dies gibt uns die Summe jeder Zeile:

wines.sum(axis=1)

array()

Es gibt mehrere andere Methoden, die sich wie die sum-Methode verhalten, einschließlich:

• numpy.ndarray.mean – findet den Mittelwert eines Arrays.
• numpy.ndarray.std – findet die Standardabweichung eines Arrays.
• numpy.ndarray.min – findet den Mindestwert in einem Array.
• numpy.ndarray.max – findet den Maximalwert in einem Array.

Eine vollständige Liste der Array-Methoden finden Sie hier.

NumPy Array-Vergleiche

NumPy macht es möglich, mit mathematischen Vergleichsoperationen wie <, >, >=, <= und == zu testen, ob Zeilen mit bestimmten Werten übereinstimmen. Wenn wir zum Beispiel sehen wollen, welche Weine eine höhere Qualitätsbewertung als 5 haben, können wir Folgendes tun:

wines > 5

array(, dtype=bool)

Wir erhalten ein boolesches Array, das uns sagt, welche der Weine eine höhere Qualitätsbewertung als 5 haben. Wir können etwas Ähnliches mit den anderen Operatoren machen. Zum Beispiel können wir sehen, ob es Weine mit einer Qualitätsbewertung gleich 10:

wines == 10

array(, dtype=bool)

Subsetting

Eine der mächtigen Dinge, die wir mit einem booleschen Array und einem NumPy-Array tun können, ist die Auswahl nur bestimmter Zeilen oder Spalten im NumPy-Array. Der folgende Code wählt zum Beispiel nur die Zeilen in wines aus, deren Qualität über 7 liegt:

high_quality = wines > 7wines

array(,,])

Wir wählen nur die Zeilen aus, in denen high_quality einen True-Wert enthält, und alle Spalten. Diese Unterteilung macht es einfach, Arrays nach bestimmten Kriterien zu filtern. Wir können zum Beispiel nach Weinen mit hohem Alkoholgehalt und hoher Qualität suchen. Um mehrere Bedingungen anzugeben, müssen wir jede Bedingung in Klammern setzen und mit einem kaufmännischen Und-Zeichen (&) trennen:

high_quality_and_alcohol = (wines > 10) & (wines > 7)wines

array(,,,,,,,,,,,,,,,])

Wir können Subsetting und Zuweisung kombinieren, um bestimmte Werte in einem Array zu überschreiben:

high_quality_and_alcohol = (wines > 10) & (wines > 7)wines = 20

Reshaping NumPy Arrays

Wir können die Form von Arrays ändern und dabei alle ihre Elemente beibehalten. Das kann den Zugriff auf Array-Elemente oft erleichtern. Die einfachste Umformung besteht darin, die Achsen zu spiegeln, so dass Zeilen zu Spalten werden und andersherum. Wir können dies mit der Funktion numpy.transpose erreichen:

np.transpose(wines).shape

(12, 1599)

Wir können die Funktion numpy.ravel verwenden, um ein Array in eine eindimensionale Darstellung zu verwandeln. Sie macht aus einem Array eine lange Folge von Werten:

wines.ravel()

array()

Hier ist ein Beispiel, in dem die Reihenfolge von numpy.ravel zu sehen ist:

array_one = np.array( , ])array_one.ravel()

array()

Schließlich können wir die Funktion numpy.reshape verwenden, um ein Array in eine bestimmte, von uns festgelegte Form umzuformen. Der folgende Code verwandelt die zweite Zeile von wines in ein 2-dimensionales Array mit 2 Zeilen und 6 Spalten:

wines.reshape((2,6))

array(,])

Kombinieren von NumPy-Arrays

Mit NumPy ist es sehr üblich, mehrere Arrays zu einem einzigen, einheitlichen Array zu kombinieren. Wir können numpy.vstack verwenden, um mehrere Arrays vertikal zu stapeln. Stellen Sie sich das so vor, dass die Elemente des zweiten Arrays als neue Zeilen zum ersten Array hinzugefügt werden. Wir können den Datensatz winequality-white.csv einlesen, der Informationen über die Qualität von Weißweinen enthält, und ihn dann mit unserem vorhandenen Datensatz wines kombinieren, der Informationen über Rotweine enthält.

Im folgenden Code lesen wir:

• Lesen Sie winequality-white.csv.
• Zeigen Sie die Form von white_wines.

white_wines = np.genfromtxt("winequality-white.csv", delimiter=";", skip_header=1)white_wines.shape

(4898, 12)

Wie Sie sehen können, haben wir Attribute für 4898Weine. Da wir nun die Daten für die Weißweine haben, können wir alle Weindaten kombinieren.

Im folgenden Code:

• Verwenden Sie die Funktion vstack, um wines und white_wines zu kombinieren.
• Zeigen Sie die Form des Ergebnisses an.

all_wines = np.vstack((wines, white_wines))all_wines.shape

(6497, 12)

Wie Sie sehen, hat das Ergebnis 6497 Zeilen, was der Summe der Anzahl der Zeilen in wines und der Anzahl der Zeilen in red_wines entspricht.

Wenn wir Arrays horizontal kombinieren wollen, bei denen die Anzahl der Zeilen konstant bleibt, aber die Spalten verbunden werden, dann können wir die Funktion numpy.hstack verwenden. Die Arrays, die wir kombinieren, müssen die gleiche Anzahl von Zeilen haben, damit dies funktioniert.

Schließlich können wir numpy.concatenate als eine Allzweckversion von hstack und vstack verwenden. Wenn wir zwei Arrays konkatenieren wollen, übergeben wir sie an concatenate und geben dann das axis-Schlüsselwortargument an, entlang dessen wir konkatenieren wollen. Die Verkettung entlang der ersten Achse ähnelt vstack, und die Verkettung entlang der zweiten Achse ähnelt hstack:

np.concatenate((wines, white_wines), axis=0)

array(,,,...,,,])

Free NumPy Cheat Sheet

Wenn Sie mehr über NumPy erfahren möchten, besuchen Sie unseren interaktiven Kurs über NumPy und Pandas. Sie können sich registrieren und die ersten Missionen kostenlos absolvieren.

Sie können Ihre NumPy-Kenntnisse auch mit unserem kostenlosen NumPy-Spickzettel vertiefen!

Weitere Lektüre

Sie sollten jetzt ein gutes Verständnis von NumPy haben und wissen, wie man es auf einen Datensatz anwendet.

Wenn Sie tiefer eintauchen wollen, sind hier einige Ressourcen, die hilfreich sein können:

• NumPy Quickstart – hat gute Codebeispiele und deckt die meisten grundlegenden NumPy-Funktionen ab.
• Python NumPy Tutorial – ein großartiges Tutorial zu NumPy und anderen Python-Bibliotheken.
• Visual NumPy Introduction – ein Leitfaden, der das Spiel des Lebens nutzt, um NumPy-Konzepte zu veranschaulichen.

In unserem nächsten Tutorial tauchen wir tiefer in Pandas ein, eine Bibliothek, die auf NumPy aufbaut und die Datenanalyse noch einfacher macht. Sie löst zwei der größten Probleme:

• Sie können nicht mehrere Datentypen in einem Array mischen.
• Sie müssen sich merken, welche Art von Daten jede Spalte enthält.