[PYTHON] [Übersetzung] NumPy Official Tutorial "NumPy: die absoluten Grundlagen für Anfänger"

Eingeführt vom Übersetzer

Dieser Artikel ist eine Übersetzung von "NumPy: Die absoluten Grundlagen für Anfänger" in der offiziellen NumPy v.1.19-Dokumentation. Dieses Dokument wurde veröffentlicht, nachdem die Entwicklungsversion auf diese Version geändert wurde.

Python ist in den letzten Jahren sehr beliebt geblieben. Einer der Gründe ist der KI-Boom und der Reichtum der Python-Bibliothek für maschinelles Lernen. Es scheint, dass Pythons reichlich vorhandene Bibliotheken auf dem Gebiet der Berechnung von Wissenschaft und Technologie wie maschinelles Lernen eine weitere Erweiterung der Bibliothek und Unterstützung ermöglichen, die nicht auf Anfänger beschränkt ist.

NumPy ist das zugrunde liegende System dieser Bibliotheksbibliotheken für Wissenschaft und Technologie. Der Grund, warum NumPy übernommen wird, ist das Geschwindigkeitsproblem von Python. Aufgrund der Art der Sprache ist Python für einige Operationen als sehr langsam bekannt. Daher verwenden viele Bibliotheken NumPy, das in der Sprache C implementiert ist, um zu vermeiden, dass Python zu einem Verarbeitungsengpass wird, und um die Geschwindigkeit zu realisieren, die einer großen Menge an Datenverarbeitung standhält. ist.

NumPy hat den Reiz, sehr bequem und schnell zu sein, aber es kann etwas weniger klebrig sein als Python selbst. In diesem Artikel erkläre ich die Grundlagen von NumPy anhand von Bildern. Der Umfang der Erklärung umfasst mehr als die Hälfte des "Schnellstart-Tutorials". Lesen Sie daher dieses trockene Tutorial. Sie sollten zumindest in der Lage sein, einige Dinge zu tun.

Es kann auch hilfreich sein, [Für Anfänger] Illustrated NumPy and Data Representation zu lesen. Der Autor ist der Schöpfer der Bilder in diesem Artikel. Es wäre sehr dankbar, wenn Sie auf Fehlübersetzungen hinweisen könnten.

** Übersetzt unten **

Willkommen im Leitfaden für NumPy-Anfänger! Wenn Sie Kommentare oder Vorschläge haben, können Sie uns gerne kontaktieren!

Welcome to NumPy!

NumPy (Numerical Python) ist eine Open-Source-Python-Bibliothek, die in nahezu allen Bereichen der Wissenschaft und Technik verwendet wird. Numpy ist der globale Standard für die Arbeit mit numerischen Daten und der Kern von Scientific Python und der Pydata-Familie [Pydata-Ökosysteme: Produktlinie des Numpy-Entwicklers Pydata]. Die Benutzer von NUmpy reichen von neuen Programmierern bis zu erfahrenen Forschern, die sich mit modernster wissenschaftlicher und technischer Forschung und Entwicklung befassen. Die Numpy-API wird häufig in Pandas, SciPy, Matplotlib, Scikit-Learn, Scikit-Image und den meisten anderen Data Science- und wissenschaftlichen Python-Paketen verwendet. Die Numpy-Bibliothek verfügt über mehrdimensionale Array- und Matrixdatenstrukturen (mehr dazu in einem späteren Abschnitt). Numpy bietet ndarray, ein n-dimensionales Array-Objekt desselben Typs [gleichen Datentyps], sowie Methoden zur effizienten Verarbeitung von Arrays. Numpy kann verwendet werden, um eine Vielzahl von mathematischen Operationen an Arrays auszuführen. Numpy fügt Python leistungsstarke Datenstrukturen hinzu, die eine effiziente Berechnung von Arrays und Matrizen gewährleisten, und bietet eine riesige Bibliothek mit erweiterten mathematischen Funktionen, die mit diesen Arrays und Matrizen funktionieren. Learn more about NumPy here!

Installieren Sie NumPy

Wir empfehlen dringend, eine wissenschaftliche Python-Distribution zu verwenden, um NumPy zu installieren. wenn Wenn Sie eine vollständige Anleitung zur Installation von NumPy auf Ihrem Betriebssystem benötigen, finden Sie hier alle Details (https://www.scipy.org/install.html).

Wenn Sie Python bereits verwenden, können Sie NumPy mit dem folgenden Code installieren.

conda install numpy

Oder

pip install numpy

Wenn Sie Python noch nicht haben, sollten Sie Anaconda verwenden. Anaconda ist der einfachste Weg, um mit Python zu beginnen. Der Vorteil dieser Distribution besteht darin, dass Sie sich nicht zu sehr um die Installation von NumPy kümmern müssen, den Hauptpaketen, die für die Datenanalyse, Pandas, Scikit-Learn usw. einzeln verwendet werden.

You can find all of the installation details in the InstallationsectionatSciPy.

So importieren Sie NumPy

Wann immer Sie ein Paket oder eine Bibliothek verwenden möchten, müssen Sie das erste zugänglich machen. Um mit NumPy und all seinen Funktionen zu beginnen, müssen Sie NumPy importieren. Dies kann einfach mit der folgenden import-Anweisung [Anweisung] durchgeführt werden.

import numpy as np

(Wir kürzen NumPy als np ab, um Zeit zu sparen und den Code zu standardisieren, damit jeder, der damit arbeitet, ihn leicht verstehen und ausführen kann. .)

So lesen Sie das Codebeispiel

Wenn Ihr Code nicht daran gewöhnt ist, viele Tutorials zu lesen, wissen Sie möglicherweise nicht, wie Sie einen Codeblock wie diesen verstehen:

>>> a = np.arange(6)
>>> a2 = a[np.newaxis, :]
>>> a2.shape
(1, 6)

Auch wenn Sie mit dieser Methode nicht vertraut sind, ist diese Notation sehr einfach zu verstehen. Wenn es >>> gibt, zeigt es auf ** Eingabe **, dh den Code, den Sie eingeben werden. Alles ohne >>> vor dem Code ist ** Ausgabe **, das Ergebnis der Ausführung des Codes. Dies ist der Stil, wenn Python in der Befehlszeile ausgeführt wird. Bei Verwendung von IPython werden jedoch möglicherweise andere Stile angezeigt.

Was ist der Unterschied zwischen Python-Liste und NumPy-Array?

NumPy bietet zahlreiche schnelle und effiziente Möglichkeiten, Arrays zu erstellen und numerische Daten zu bearbeiten. Pyhon-Listen können in einer Liste unterschiedliche Datentypen haben, aber in einem NumPy-Array müssen alle Elemente im Array vom gleichen Typ sein. Wenn das Array mit anderen Datentypen gemischt wird, sind die mathematischen Operationen, die auf dem Array ausgeführt werden sollen, äußerst ineffizient.

Warum wird NumPy verwendet?

NumPy-Arrays sind schneller und prägnanter als Python-Listen. Das [Python] -Array benötigt weniger Speicher und ist bequem zu verwenden. Im Vergleich dazu benötigt NumPy viel weniger Speicher zum Speichern von Daten und verfügt über einen Mechanismus zum Identifizieren von Datentypen. Dies ermöglicht eine weitere Optimierung des Codes.

Was ist ein Array?

Ein Array ist eine der Hauptdatenstrukturen in der NumPy-Bibliothek. Ein Array ist ein Wertegitter, das Informationen zu den Rohdaten, Informationen zum Anordnen der Elemente und Informationen zum Interpretieren der Elemente enthält. Das aus verschiedenen Elementen von NumPy bestehende Raster kann mit [verschiedenen Methoden] indiziert werden (https://numpy.org/doc/stable/user/quickstart.html#quickstart-indexing-slicing-and-iterating). Ich werde. Die Elemente sind alle homogen und werden im Array als "dtype" dargestellt.

Ein Array kann durch ein Tupel positiver Ganzzahlen, Boolescher Werte, eines anderen Arrays oder einer Ganzzahl indiziert werden. Der "Rang" des Arrays ist die Anzahl der Dimensionen. Die "Form" eines Arrays ist ein ganzzahliges Tupel, das die Größe des Arrays entlang jeder Dimension darstellt. Eine Möglichkeit, ein NumPy-Array zu initialisieren, besteht darin, es aus einer Python-Liste zu initialisieren. Verwenden Sie eine verschachtelte Liste für Daten mit mehr als zwei Dimensionen.

Beispiel:

>>> a = np.array([1, 2, 3, 4, 5, 6])

Oder

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Verwenden Sie Schlüsselklammern, um auf die Elemente des Arrays zuzugreifen. Denken Sie daran, dass der NumPy-Index beim Zugriff auf die Elemente des Arrays bei 0 beginnt. Dies bedeutet, dass Sie auf das Array "0" zugreifen, wenn Sie auf das erste Element des Arrays zugreifen möchten.

>>> print(a[0])
[1 2 3 4]

Erfahren Sie mehr über Arrays

• Dieser Abschnitt befasst sich mit "1D-Array", "2D-Array", "ndarray", "Vektor", "Matrix" *

Möglicherweise haben Sie gelegentlich ein Array mit der Bezeichnung "ndarray" gesehen. Dies ist eine Abkürzung für "N-dimensionales Array". Ein N-dimensionales Array ist einfach ein Array mit einer beliebigen Anzahl von Dimensionen. Möglicherweise haben Sie auch "** 1-D " oder eindimensionale Arrays, " 2-D **" oder zweidimensionale Arrays usw. gesehen. Die ndarray-Klasse von NumPy wird verwendet, um sowohl Matrizen als auch Vektoren darzustellen. ** Vektor ** ist ein eindimensionales Array (es gibt keinen Unterschied zwischen Zeilen- und Spaltenvektoren), und ** Matrix ** bezieht sich auf ein zweidimensionales Array. Für Arrays von ** 3D ** und höher wird üblicherweise auch der Begriff ** Tensor ** verwendet.

** Was sind Array-Attribute? ** ** **

Ein Array ist normalerweise ein Container mit fester Größe von Elementen des gleichen Typs und der gleichen Größe. Die Anzahl der Dimensionen und Elemente eines Arrays wird durch die Form des Arrays definiert. Die Form des Arrays ist ein natürlicher Zahlentapel, der die Größe jeder Dimension definiert. In NumPy werden Dimensionen als ** Achsen ** bezeichnet. Das heißt, wenn Sie die folgende Sequenz haben

[[0., 0., 0.],
 [1., 1., 1.]]

Dieses Array hat zwei Achsen. Die Länge der ersten Achse beträgt 2 und die Länge der zweiten Achse beträgt 3. Wie bei jedem Python-Container können Sie durch Indizieren und Schneiden auf den Inhalt des Arrays zugreifen und diesen ändern. Im Gegensatz zu typischen Containerobjekten können dieselben Daten jedoch in verschiedenen Arrays gemeinsam genutzt werden, sodass in einem Array vorgenommene Änderungen möglicherweise in einem anderen Array angezeigt werden.

Die ** Attribute ** eines Arrays spiegeln Array-spezifische Informationen wider. Wenn Sie die Eigenschaften eines Arrays abrufen oder festlegen müssen, ohne ein neues zu erstellen, greifen Sie häufig über die Attribute des Arrays auf das Array zu.

Read more about array attributes hereandlearnaboutarrayobjectshere.

So erstellen Sie ein einfaches Array

_ In diesem Abschnitt "np.array ()", "np.zeros ()", "np.ones ()", "np.empty ()", "np.arange ()", "np.linspace ()" , dtype wird behandelt_

Verwenden Sie zum Erstellen eines NumPy-Arrays die Funktion np.array (). Alles, was Sie tun müssen, um ein einfaches Array zu erstellen, ist eine Liste zu übergeben. Bei Bedarf können Sie auch den Listendatentyp angeben. Weitere Informationen zu Datentypen finden Sie hier.

>>> import numpy as np
>>> a = np.array([1, 2, 3])

Sie können das Array wie folgt visualisieren: Beachten Sie, dass diese Visualisierungen das Konzept verständlicher machen und ein grundlegendes Verständnis der Funktionsweise der Ideen und Mechanismen von NumPy vermitteln sollen. Arrays und Array-Operationen sind viel komplexer als die hier dargestellten. Zusätzlich zu dem aus einer Reihe von Elementen erstellten Array können Sie problemlos ein mit "0" gefülltes Array erstellen.

>>> np.zeros(2)
array([0., 0.])

Sie können auch ein mit "1" gefülltes Array erstellen.

>>> np.ones(2)
array([1., 1.])

Oder sogar ein leeres Array! Die Funktion "leer" erstellt ein Array, dessen Anfangsinhalt zufällig ist und vom Speicherstatus abhängt. Der Grund für die Verwendung der Funktion "leer" gegenüber der Funktion "null" (oder ähnlichem) ist die Geschwindigkeit. Vergessen Sie nicht, alle Elemente später auszufüllen!

>>> # Create an empty array with 2 elements
>>> np.empty(2)
array([ 3.14, 42.  ])  # may vary

Sie können ein Array zusammenhängender Elemente erstellen:

>>> np.arange(4)
array([0, 1, 2, 3])

Sie können auch ein Array mit gleichmäßig verteilten Spalten erstellen. Geben Sie dazu ** erste Nummer **, ** letzte Nummer ** und Anzahl der Schritte an.

>>> np.arange(2, 9, 2)
array([2, 4, 6, 8])

Sie können np.linspace () verwenden, um ein Array mit linear beabstandeten Werten in bestimmten Intervallen zu erstellen.

>>> np.linspace(0, 10, num=5)
array([ 0. ,  2.5,  5. ,  7.5, 10. ])

** Datentyp angeben **

Der Standarddatentyp ist Gleitkomma (np.float64). Sie können jedoch explizit den Datentyp angeben, den Sie mit dem Schlüsselwort dtype verwenden möchten.

>>> x = np.ones(2, dtype=np.int64)
>>> x
array([1, 1])

Learn more about creating arrays here

Elemente hinzufügen / entfernen / sortieren

• Dieser Abschnitt befasst sich mit np.sort (), np.concatenate () *

Beim Sortieren von Elementen ist es einfach, np.sort () zu verwenden. Wenn Sie diese Funktion aufrufen, können Sie die Achse, den Typ und die Reihenfolge angeben.

Nehmen Sie dieses Array als Beispiel

>>> arr = np.array([2, 1, 5, 3, 7, 4, 6, 8])

Auf diese Weise können Sie schnell in aufsteigender Reihenfolge sortieren.

>>> np.sort(arr)
array([1, 2, 3, 4, 5, 6, 7, 8])

sort gibt eine sortierte Kopie in ein Array zurück, aber Sie können auch Folgendes verwenden:

• Argsort: Indirekte Sortierung nach der angegebenen Achse · Lexsort: Indirekte stabile Sortierung bei mehreren Schlüssel] · Searchsorted: Ermitteln Sie Elemente aus einem sortierten Array
• Partition: Partielle Sortierung

Nehmen Sie diese Sequenzen als Beispiel:

>>> a = np.array([1, 2, 3, 4])
>>> b = np.array([5, 6, 7, 8])

Sie können diese Arrays mit np.concatenate () verketten.

>>> np.concatenate((a, b))
array([1, 2, 3, 4, 5, 6, 7, 8])

Nehmen Sie dieses Array als Beispiel:

>>> x = np.array([[1, 2], [3, 4]])
>>> y = np.array([[5, 6]])

Auf diese Weise können Sie verketten:

>>> np.concatenate((x, y), axis=0)
array([[1, 2],
       [3, 4],
       [5, 6]])

Um ein Element aus dem Array zu entfernen, können Sie einfach den Index verwenden, um das Element auszuwählen, das Sie behalten möchten. Wenn Sie mehr über die Verkettung erfahren möchten, lesen Sie rechts: verketten.

Wie erkennt man die Form und Größe eines Arrays?

• Dieser Abschnitt befasst sich mit ndarray.ndim, ndarray.size, ndarray.shape *

ndarray.ndim gibt die Anzahl der Achsen im Array an, dh die Anzahl der Dimensionen.

ndarray.size gibt die Gesamtzahl der Elemente im Array an. Dies ist das Produkt der Größe des Arrays.

ndarray.shape zeigt ein ganzzahliges Tupel an, das die Anzahl der in jeder Dimension des Arrays gespeicherten Elemente angibt. Wenn Sie beispielsweise ein 2-mal-3-zweidimensionales Array haben, ist die Form des Arrays (2,3).

Angenommen, Sie erstellen das folgende Array:

>>> array_example = np.array([[[0, 1, 2, 3],
...                           [4, 5, 6, 7]],
...                          [[0, 1, 2, 3],
...                           [4, 5, 6, 7]],
...                          [[0 ,1 ,2, 3],
...                           [4, 5, 6, 7]]])

So ermitteln Sie die Anzahl der Dimensionen in einem Array:

>>> array_example.ndim
3

So ermitteln Sie die Gesamtzahl der Elemente in einem Array:

>>> array_example.size
24

Gehen Sie wie folgt vor, um die Form des Arrays herauszufinden:

>>> array_example.shape
(3, 2, 4)

Kann ich das Array transformieren?

• Dieser Abschnitt befasst sich mit arr.reshape () *

natürlich! Sie können arr.reshape () verwenden, um einem Array eine neue Form zu geben, ohne die Daten zu ändern. Beachten Sie bei der Verwendung dieser Transformationsmethode, dass das Array, das Sie erstellen möchten, dieselbe Anzahl von Elementen wie das ursprüngliche Array haben muss. Wenn Sie ein Array mit 12 Elementen transformieren, müssen Sie sicherstellen, dass das neue Array auch insgesamt 12 Elemente enthält. Wenn Sie dieses Array verwenden:

>>> a = np.arange(6)
>>> print(a)
[0 1 2 3 4 5]

Sie können "reshape ()" verwenden, um das Array zu transformieren. Sie können dieses Array beispielsweise in ein 3-mal-2-Array umwandeln:

>>> b = a.reshape(3, 2)
>>> print(b)
[[0 1]
 [2 3]
 [4 5]]

Es ist möglich, einige Parameter mit np.shape () anzugeben. :: ::

>>> numpy.reshape(a, newshape=(1, 6), order='C')]
array([[0, 1, 2, 3, 4, 5]])

a ist ein Array, das seine Form ändert. newshape ist die Form des neuen Arrays. Sie können eine Ganzzahl oder eine Ganzzahl angeben. Wenn Sie eine Ganzzahl angeben, wird ein Array mit dieser Ganzzahllänge erstellt. Die Form muss mit der ursprünglichen Form kompatibel sein. order: C steht für Lesen und Schreiben in einer C-ähnlichen Indexreihenfolge und F steht für Lesen und Schreiben in einer Fortran-ähnlichen Indexreihenfolge. Ein Mittel verwendet eine Fortran-ähnliche Indexreihenfolge, wenn das Element im Speicher an Fortran angrenzt, andernfalls einen C-ähnlichen Index (dies ist ein optionaler Parameter und muss angegeben werden. Kein Notwendigkeit für). If you want to learn more about C and Fortran order, you can read more about the internal organization of NumPy arrays here. Essentially, C and Fortran orders have to do with how indices correspond to the order the array is stored in memory. In Fortran, when moving through the elements of a two-dimensional array as it is stored in memory, the first index is the most rapidly varying index. As the first index moves to the next row as it changes, the matrix is stored one column at a time. This is why Fortran is thought of as a Column-major language. In C on the other hand, the last index changes the most rapidly. The matrix is stored by rows, making it a Row-major language. What you do for C or Fortran depends on whether it’s more important to preserve the indexing convention or not reorder the data. Learn more about shape manipulation here.

So konvertieren Sie ein 1D-Array in ein 2D-Array (wie Sie dem Array eine neue Achse hinzufügen)

• Dieser Abschnitt befasst sich mit np.newaxis, np.expand_dims *

Sie können np.newaxis und np.expand_dims verwenden, um die Abmessungen eines vorhandenen Arrays zu erhöhen.

Die Verwendung von "np.newaxis" erhöht die Dimension des Arrays um eine Dimension, wenn es nur einmal verwendet wird. Das heißt, ein 1D-Array wird zu einem 2D-Array, ein 2D-Array wird zu einem 3D-Array und so weiter.

Zum Beispiel in der folgenden Reihenfolge

>>> a = np.array([1, 2, 3, 4, 5, 6])
>>> a.shape
(6,)

Sie können eine neue Achse mit np.newaxis hinzufügen. :: ::

>>> a2 = a[np.newaxis, :]
>>> a2.shape
(1, 6)

Sie können ein 1D-Array explizit aus einem Zeilenvektor oder einem Spaltenvektor transformieren, indem Sie "np.newaxis" verwenden. Sie können beispielsweise ein 1D-Array in einen Zeilenvektor konvertieren, indem Sie eine Achse in die erste Dimension einfügen.

>>> row_vector = a[np.newaxis, :]
>>> row_vector.shape
(1, 6)

Sie können auch eine Achse in der zweiten Dimension in den Spaltenvektor einfügen:

>>> col_vector = a[:, np.newaxis]
>>> col_vector.shape
(6, 1)

Sie können das Array auch erweitern, indem Sie die in np.expand_dims angegebenen Achsen einfügen. Zum Beispiel in diesem Array:

>>> a = np.array([1, 2, 3, 4, 5, 6])
>>> a.shape
(6,)

Mit np.expand_dims können Sie eine Achse an der Indexposition 1 hinzufügen. :: ::

>>> b = np.expand_dims(a, axis=1)
>>> b.shape
(6, 1)

So fügen Sie eine Achse an der Indexposition 0 hinzu: :: ::

>>> c = np.expand_dims(a, axis=0)
>>> c.shape
(1, 6)

Indizieren und Schneiden

Der tiefgestellte Zugriff und das Slicing von Numpy-Arrays können auf die gleiche Weise erfolgen wie das Slicing von Python-Listen.

>>> data = np.array([1, 2, 3])

>>> data[1]
2
>>> data[0:2]
array([1, 2])
>>> data[1:]
array([2, 3])
>>> data[-2:]
array([2, 3])

Dies kann wie folgt dargestellt werden:

Möglicherweise müssen Sie Teile des Arrays oder bestimmte Elemente des Arrays zur weiteren Analyse oder Bearbeitung extrahieren. Dazu müssen Sie die Sequenz unterteilen, in Scheiben schneiden und / oder indizieren.

Wenn Sie Werte aus einem Array extrahieren möchten, die bestimmte Bedingungen erfüllen, ist NumPy einfach.

Nehmen Sie zum Beispiel das folgende Array als Beispiel.

>>> a = np.array([[1 , 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Sie können problemlos Zahlen unter 5 im Array anzeigen.

>>> print(a[a < 5])
[1 2 3 4]

Sie können beispielsweise auch eine Zahl von 5 oder höher auswählen und diese Bedingung zum Indizieren des Arrays verwenden.

>>> five_up = (a >= 5)
>>> print(a[five_up])
[ 5  6  7  8  9 10 11 12]

Sie können auch Elemente extrahieren, die durch 2 teilbar sind. :: ::

>>> divisible_by_2 = a[a%2==0]
>>> print(divisible_by_2)
[ 2  4  6  8 10 12]

Sie können auch die Operatoren "&" und "|" verwenden, um Elemente abzurufen, die zwei Bedingungen erfüllen:

>>> c = a[(a > 2) & (a < 11)]
>>> print(c)
[ 3  4  5  6  7  8  9 10]

Sie können auch die logischen Operatoren ** & ** und ** | ** verwenden, um einen booleschen Wert zurückzugeben, der angibt, ob der Wert des Arrays bestimmte Bedingungen erfüllt. Dies ist nützlich für Arrays mit Namen oder Werten in verschiedenen Kategorien.

>>> five_up = (a > 5) | (a == 5)
>>> print(five_up)
[[False False False False]
 [ True  True  True  True]
 [ True  True  True True]]

Sie können auch np.nonzero () verwenden, um ein Element oder einen Index aus einem Array auszuwählen. Beginnen wir mit dem folgenden Array:

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Sie können np.nonzero () verwenden, um den Index eines Elements anzuzeigen, in diesem Fall weniger als 5:

>>> b = np.nonzero(a < 5)
>>> print(b)
(array([0, 0, 0, 0]), array([0, 1, 2, 3]))

In diesem Beispiel wird ein Tapple des Arrays zurückgegeben. Für jede Dimension wird nur ein Taple zurückgegeben. Das erste Array zeigt die Zeilenindizes mit Werten, die die Bedingungen erfüllen, und das zweite Array zeigt die Spaltenindizes mit den Werten, die die Bedingungen erfüllen.

Wenn Sie eine Liste von Koordinaten mit einem Element generieren möchten, können Sie dieses Array komprimieren und die Liste der Koordinaten durchlaufen, um es anzuzeigen. Zum Beispiel:

>>> list_of_coordinates= list(zip(b[0], b[1]))

>>> for coord in list_of_coordinates:
...    print(coord)
(0, 0)
(0, 1)
(0, 2)
(0, 3)

Sie können auch np.nonzero () verwenden, um weniger als 5 Elemente in einem Array anzuzeigen:

>>> print(a[b])
[1 2 3 4]
```shell

 Wenn das gesuchte Element nicht im Array vorhanden ist, ist das Rückgabeindex-Array leer. Zum Beispiel:

​```shell
>>> not_there = np.nonzero(a == 42)
>>> print(not_there)
(array([], dtype=int64), array([], dtype=int64))

So erstellen Sie ein Array aus vorhandenen Daten

• Dieser Abschnitt befasst sich mit "Schneiden und Indizieren", "np.vstack ()", "np.hstack ()", "np.hsplit ()", ".view ()", "copy ()" *

Sie können ein Array einfach aus einem Teil eines vorhandenen Arrays erstellen. Angenommen, Sie haben die folgende Reihenfolge:

>>> a = np.array([1,  2,  3,  4,  5,  6,  7,  8,  9, 10])

Sie können jederzeit ein neues Array aus dem Teil des Arrays erstellen, indem Sie den Teil des Arrays angeben, den Sie in Scheiben schneiden möchten.

>>> arr1 = a[3:8]
>>> arr1
array([4, 5, 6, 7, 8])

Hier wird der Bereich von Indexposition 3 bis Indexposition 8 angegeben.

Sie können zwei vorhandene Arrays entweder vertikal oder horizontal verketten. Angenommen, Sie haben die folgenden zwei Arrays: "a1" und "a2".

>>> a1 = np.array([[1, 1],
...               [2, 2]])

>>> a2 = np.array([[3, 3],
...               [4, 4]])

Sie können diese vertikal mit vstack stapeln.

>>> np.vstack((a1, a2))
array([[1, 1],
       [2, 2],
       [3, 3],
       [4, 4]])

Und Sie können sie neben "hstack" stapeln.

>>> np.hstack((a1, a2))
array([[1, 1, 3, 3],
       [2, 2, 4, 4]])

Sie können das Array mit hsplit in mehrere kleinere Arrays aufteilen. Sie können angeben, in wie viele isomorphe Arrays das Array unterteilt werden soll und wie viele Spalten nach der Teilung vorhanden sind.

Angenommen, Sie haben dieses Array:

>>> x = np.arange(1, 25).reshape(2, 12)
>>> x
array([[ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12],
       [13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]])

Wenn Sie dieses Array in drei identisch geformte Arrays aufteilen möchten, führen Sie den folgenden Code aus.

>>> np.hsplit(x, 3)
[array([[1,  2,  3,  4],
        [13, 14, 15, 16]]), array([[ 5,  6,  7,  8],
        [17, 18, 19, 20]]), array([[ 9, 10, 11, 12],
        [21, 22, 23, 24]])]

Wenn Sie das Array nach der 3. und 4. Spalte aufteilen möchten, führen Sie den folgenden Code aus.

>>> np.hsplit(x, (3, 4))
[array([[1, 2, 3],
        [13, 14, 15]]), array([[ 4],
        [16]]), array([[ 5, 6, 7, 8, 9, 10, 11, 12],
        [17, 18, 19, 20, 21, 22, 23, 24]])]

Learn more about stacking and splitting arrays here.

Mit der Methode "Ansicht" können Sie ein neues Array erstellen, das auf dieselben Daten wie das ursprüngliche Array verweist (flache Kopie).

Ansichten sind eines der Schlüsselkonzepte von NumPy. NumPy-Funktionen geben nach Möglichkeit Ansichten zurück, ähnlich wie Vorgänge wie Indexzugriff und Slicing. Dies spart Speicher und ist schnell (es ist keine Kopie der Daten erforderlich). Beachten Sie jedoch Folgendes: Wenn Sie die Daten in der Ansicht ändern, wird auch das ursprüngliche Array geändert.

Angenommen, Sie erstellen ein Array wie folgt:

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Schneiden Sie nun "a" in "b1" und ändern Sie das erste Element von "b1". Diese Operation ändert auch das entsprechende Element von "a".

>>> b1 = a[0, :]
>>> b1
array([1, 2, 3, 4])
>>> b1[0] = 99
>>> b1
array([99,  2,  3,  4])
>>> a
array([[99,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])

Verwenden Sie die Methode "copy", um eine vollständige Kopie des Arrays und seiner Daten zu erstellen (Deep Copy). Führen Sie den folgenden Code aus, um dies für ein Array zu verwenden.

>>> b2 = a.copy()

Grundlegende Bedienung eines Arrays

• Dieser Abschnitt befasst sich mit Addition, Subtraktion, Multiplikation, Division usw. *

Sobald Sie ein Array erstellt haben, können Sie damit arbeiten. Angenommen, Sie haben zwei Arrays mit den Namen "Daten" und "Einsen" erstellt.

Sie können Arrays mit dem Pluszeichen hinzufügen.

>>> data = np.array([1, 2])
>>> ones = np.ones(2, dtype=int)
>>> data + ones
array([2, 3])

Natürlich können Sie mehr als nur hinzufügen!

>>> data - ones
array([0, 1])
>>> data * data
array([1, 4])
>>> data / data
array([1., 1.])

Die Grundbedienung ist mit NumPy einfach. Wenn Sie die Summe der Sequenzen wissen möchten, verwenden Sie sum (). Es funktioniert in 1D-, 2D- und höheren Arrays.

>>> a = np.array([1, 2, 3, 4])

>>> a.sum()
10

Wenn Sie Spalten oder Zeilen in einem zweidimensionalen Array hinzufügen möchten (Um die Zeilen oder Spalten in einem 2D-Array hinzuzufügen), geben Sie die Achsen an. Wenn Sie mit diesem Array beginnen:

>>> b = np.array([[1, 1], [2, 2]])

Die Zeilen können wie folgt summiert werden:

>>> b.sum(axis=0)
array([3, 3])

Die Spalten können wie folgt summiert werden: :: ::

>>> b.sum(axis=1)
array([2, 4])

Broadcasting

Es gibt Zeiten, in denen Sie eine Operation zwischen einem Array und einer einzelnen Zahl oder zwischen Arrays unterschiedlicher Größe ausführen möchten (erstere wird auch als Operation zwischen einem Vektor und einem Skalar bezeichnet). Angenommen, ein Array ("Daten" genannt) enthält Informationen darüber, wie viele Meilen entfernt sind, und Sie möchten es in Kilometer umrechnen. Sie können dies wie folgt tun:

>>> data = np.array([1.0, 2.0])
>>> data * 1.6
array([1.6, 3.2])

NumPy versteht, dass die Multiplikation in jeder einzelnen Zelle erfolgen muss. Dieses Konzept heißt ** Broadcast **. Broadcastet ist ein Mechanismus, mit dem NumPy Operationen an Arrays unterschiedlicher Form ausführen kann. Die Abmessungen des Arrays müssen kompatibel sein. Zum Beispiel, wenn beide Arrays dieselbe Dimension haben oder eines eine Dimension hat. Wenn nicht, erhalten Sie einen "ValueError".

Bequemere Array-Operationen

This section covers maximum, minimum, sum, mean, product, standard deviation, and more

NumPy führt auch Aggregatfunktionen aus. Zusätzlich zu "min", "max", "sum", "mean", um den Durchschnitt zu erhalten, "prod", um das Ergebnis der Multiplikation der Elemente zu erhalten, "std", um die Standardabweichung zu erhalten usw. sind einfach. Kann ausgeführt werden.

>>> data.max()
2.0
>>> data.min()
1.0
>>> data.sum()
3.0

Beginnen wir mit diesem Array, "a"

>>> a = np.array([[0.45053314, 0.17296777, 0.34376245, 0.5510652],
...              [0.54627315, 0.05093587, 0.40067661, 0.55645993],
...              [0.12697628, 0.82485143, 0.26590556, 0.56917101]])

Es ist sehr häufig, dass Sie entlang von Zeilen und Spalten aggregieren möchten. Standardmäßig geben alle NumPy-Aggregatfunktionen die Summe des gesamten Arrays zurück. Wenn Sie die Summe oder den Mindestwert der Elemente eines Arrays wissen möchten, verwenden Sie den folgenden Code.

>>> a.sum()
4.8595784

Oder:

>>> a.min()
0.05093587

Sie können angeben, auf welcher Achse die Aggregatfunktion arbeiten soll. Sie können beispielsweise den Mindestwert in jeder Spalte ermitteln, indem Sie axis = 0 setzen.

>>> a.min(axis=0)
array([0.12697628, 0.05093587, 0.26590556, 0.5510652 ])

Die obigen vier Zahlen stimmen mit den Zahlen in den Zeilen des ursprünglichen Arrays überein. Mit einem vierzeiligen Array können Sie als Ergebnis vier Werte erhalten.

Machen Sie eine Warteschlange

Sie können eine Python-Liste übergeben und mit NumPy ein 2D-Array (oder eine "Matrix") erstellen, das dieses Array darstellt.

>>> data = np.array([[1, 2], [3, 4]])
>>> data
array([[1, 2],
       [3, 4]])

Indexzugriff und Slicing-Operationen sind nützlich, wenn Sie mit Matrizen arbeiten.

>>> data[0, 1]
2
>>> data[1:3]
array([[3, 4]])
>>> data[0:2, 0]
array([1, 3])

Sie können die Matrix genauso bearbeiten wie den Vektor.

>>> data.max()
4
>>> data.min()
1
>>> data.sum()
10

Sie können alle Werte in einer Matrix aggregieren oder Achsenparameter verwenden, um über Spalten oder Zeilen hinweg zu aggregieren.

>>> data.max(axis=0)
array([3, 4])
>>> data.max(axis=1)
array([2, 4])

Wenn Sie nach dem Erstellen einer Matrix zwei Matrizen gleicher Größe haben, können Sie arithmetische Operatoren zum Addieren oder Multiplizieren verwenden.

>>> data = np.array([[1, 2], [3, 4]])
>>> ones = np.array([[1, 1], [1, 1]])
>>> data + ones
array([[2, 3],
       [4, 5]])

Sie können diese arithmetischen Operationen für Matrizen unterschiedlicher Größe ausführen, jedoch nur, wenn eine Matrix nur eine Zeile oder eine Spalte enthält. In diesem Fall verwendet NumPy Broadcast-Regeln für den Vorgang.

>>> data = np.array([[1, 2], [3, 4], [5, 6]])
>>> ones_row = np.array([[1, 1]])
>>> data + ones_row
array([[2, 3],
       [4, 5],
       [6, 7]])

Beachten Sie, dass, wenn NumPy ein N-dimensionales Array anzeigt, die letzte Achse die meisten Schleifen aufweist, während die erste Achse sanft [12 Mal für die Spalte, die im folgenden Beispiel die letzte Achse ist, eine Schleife durchläuft. Es gibt 4 Schleifen auf der ersten Achse]. Zum Beispiel

>>> np.ones((4, 3, 2))
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.]]])

Oft möchten Sie ein Array mit NumPy initialisieren. NumPy bietet Funktionen wie "Einsen ()" und "Nullen ()" und die Klasse "random.Generator" für die Zufallszahlengenerierung. Für die Initialisierung müssen Sie lediglich die Anzahl der Elemente übergeben, die Sie generieren möchten.

>>>np.ones(3)
array([1., 1., 1.])
>>> np.zeros(3)
array([0., 0., 0.])
# the simplest way to generate random numbers
>>> rng = np.random.default_rng(0)
>>> rng.random(3)
array([0.63696169, 0.26978671, 0.04097352])

この関数やメソッドに二次元の行列を表すタプルを与えれば、ones()、zeros()とrandom() を使って二次元配列も生成可能です。

>>> np.ones((3, 2))
array([[1., 1.],
       [1., 1.],
       [1., 1.]])
>>> np.zeros((3, 2))
array([[0., 0.],
       [0., 0.],
       [0., 0.]])
>>> rng.random((3, 2))
array([[0.01652764, 0.81327024],
       [0.91275558, 0.60663578],
       [0.72949656, 0.54362499]])  # may vary

Zufallszahlen generieren

Die Verwendung der Zufallszahlengenerierung ist ein wichtiger Bestandteil der Platzierung und Bewertung vieler mathematischer oder maschineller Lernalgorithmen. Zufällige Initialisierung des Gewichts des künstlichen neuronalen Netzwerks, Aufteilung in zufällige Mengen oder zufälliges Mischen von Datensätzen, in jedem Fall mangelnde Fähigkeit, Zufallszahlen zu generieren (tatsächlich die Anzahl reproduzierbarer Pseudozufallszahlen). Ich kann nicht Sie können "Generator.integers" verwenden, um zufällige Ganzzahlen von Minimum bis Maximum auszugeben (beachten Sie, dass Numpy Minimum und nicht Maximum enthält). Sie können "endpoint = True" setzen, um eine Zufallszahl mit dem höchsten Wert zu generieren.

Sie können eine 2x4-Matrix generieren, die aus zufälligen Ganzzahlen von 0 bis 4 besteht:

>>> rng.integers(5, size=(2, 4))
array([[2, 1, 1, 0],
       [0, 0, 0, 4]])  # may vary

So rufen Sie nicht überlappende Elemente ab und zählen sie

• Dieser Abschnitt befasst sich mit np.unique () *

Sie können die Elemente eines Arrays einzeln mit "Np.unique" ohne Duplizierung abrufen. Nehmen Sie dieses Array als Beispiel.

>>> a = np.array([11, 11, 12, 13, 14, 15, 16, 17, 12, 13, 11, 14, 18, 19, 20])

Sie können Np.unique verwenden, um die eindeutigen Werte im Array herauszufinden.

>>>
>>> unique_values = np.unique(a)
>>> print(unique_values)
[11 12 13 14 15 16 17 18 19 20]

Übergeben Sie das Argument "return_index" mit dem Array an "np.unique ()", um den Index der eindeutigen Werte des Numpy-Arrays (den ersten Index jedes eindeutigen Werts des Arrays) abzurufen.

>>> unique_values, indices_list = np.unique(a, return_index=True)
>>> print(indices_list)
[ 0  2  3  4  5  6  7 12 13 14]

Sie können das Argument "return_counts" zusammen mit dem Array an "np.unique ()" übergeben, um zu sehen, wie viele eindeutige Werte jedes Numpy-Array hat.

>>> unique_values, occurrence_count = np.unique(a, return_counts=True)
>>> print(occurrence_count)
[3 2 2 2 1 1 1 1 1 1]

Dies funktioniert auch für zweidimensionale Arrays! Mit diesem Array

>>> a_2d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [1, 2, 3, 4]])

Auf diese Weise können Sie eindeutige Werte finden.

>>> unique_values = np.unique(a_2d)
>>> print(unique_values)
[ 1  2  3  4  5  6  7  8  9 10 11 12]

Wenn kein Achsenargument übergeben wird, wird das zweidimensionale Array auf eine Dimension reduziert. Wenn Sie eine eindeutige Zeile oder Spalte kennen möchten, müssen Sie das Achsenargument übergeben. Geben Sie "Achse = 0" für eindeutige Zeilen und "Achse = 1" für Spalten an.

>>> unique_rows = np.unique(a_2d, axis=0)
>>> print(unique_rows)
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]

So erhalten Sie eine eindeutige Spalte, Indexposition und Anzahl der Vorkommen:

>>> unique_rows, indices, occurrence_count = np.unique(
...     a_2d, axis=0, return_counts=True, return_index=True)
>>> print(unique_rows)
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
>>> print(indices)
[0 1 2]
>>> print(occurrence_count)
[2 1 1]

Matrixtranslokation und -transformation

• Dieser Abschnitt befasst sich mit "arr.reshape ()", "arr.transpose ()", "arr.T ()" * Oft ist es notwendig, die Matrix zu transponieren. Das Numpy-Array hat die Eigenschaft "T", um die Matrix zu transponieren.

Möglicherweise müssen Sie auch die Abmessungen des Arrays austauschen. Dies ist beispielsweise der Fall, wenn Sie ein Modell haben, das ein Array von Eingaben voraussetzt, das sich vom Dataset unterscheidet. Die Umformmethode ist in solchen Fällen nützlich. Sie müssen lediglich die neuen Dimensionen [Dimensionen] übergeben, die Sie für die Matrix benötigen.

>>> data.reshape(2, 3)
array([[1, 2, 3],
       [4, 5, 6]])
>>> data.reshape(3, 2)
array([[1, 2],
       [3, 4],
       [5, 6]])

Nehmen Sie dieses Array als Beispiel:

>>> arr = np.arange(6).reshape((2, 3))
>>> arr
array([[0, 1, 2],
       [3, 4, 5]])

Sie können ein Array mit arr.transpose () transponieren.

>>> arr.transpose()
array([[0, 3],
       [1, 4],
       [2, 5]])

So invertieren Sie ein Array

• Dieser Abschnitt befasst sich mit np.flip *

NumPys np.flip () kann die Achse eines Arrays relativ zur Achse spiegeln. Geben Sie bei Verwendung von "np.flip ()" das Array und die Achse an, die Sie spiegeln möchten. Wenn keine Achse angegeben ist, invertiert NumPy das angegebene Array für alle Achsen.

1D-Array invertieren

Nehmen Sie als Beispiel das folgende eindimensionale Array:

>>> arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])

Sie können das Array folgendermaßen invertieren:

>>> reversed_arr = np.flip(arr)

Wenn Sie das invertierte Array sehen möchten, führen Sie diesen Code aus:

>>> print('Reversed Array: ', reversed_arr)
Reversed Array:  [8 7 6 5 4 3 2 1]

2D-Array invertieren

2D-Arrays werden auf die gleiche Weise gespiegelt.

Nehmen Sie dieses Array als Beispiel:

>>> arr_2d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Sie können den Inhalt aller Spalten und Zeilen invertieren.

>>> reversed_arr = np.flip(arr_2d)
>>> print(reversed_arr)
[[12 11 10  9]
 [ 8  7  6  5]
 [ 4  3  2  1]]

Dies ist die einzige Möglichkeit, nur Zeilen zu invertieren:

>>> reversed_arr_rows = np.flip(arr_2d, axis=0)
>>> print(reversed_arr_rows)
[[ 9 10 11 12]
 [ 5  6  7  8]
 [ 1  2  3  4]]

Um nur die Spalten umzudrehen:

>>> reversed_arr_columns = np.flip(arr_2d, axis=1)
>>> print(reversed_arr_columns)
[[ 4  3  2  1]
 [ 8  7  6  5]
 [12 11 10  9]]

Sie können auch nur eine Zeile oder Spalte invertieren. Sie können beispielsweise die Zeile mit Index 1 (zweite Zeile) invertieren:

>>> arr_2d[1] = np.flip(arr_2d[1])
>>> print(arr_2d)
[[ 1  2  3  4]
 [ 8  7  6  5]
 [ 9 10 11 12]]

Sie können die Spalte auch mit Index 1 (zweite Spalte) invertieren:

>>> arr_2d[:,1] = np.flip(arr_2d[:,1])
>>> print(arr_2d)
[[ 1 10  3  4]
 [ 8  7  6  5]
 [ 9  2 11 12]]

So formen und reduzieren Sie ein mehrdimensionales Array

• Dieser Abschnitt befasst sich mit .flatten (), ravel () *

Es gibt zwei gängige Methoden, um ein Array zu reduzieren. .flatten () und .ravel (). Der Hauptunterschied zwischen den beiden besteht darin, dass die mit .ravel () erstellte Sequenz tatsächlich eine Referenz (oder "Ansicht") auf die übergeordnete Sequenz ist. Wenn Sie also etwas im neuen Array ändern, ändert sich auch das übergeordnete Array. ravel erstellt keine Kopie, ist also speichereffizient.

>>> x = np.array([[1 , 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Sie können "Abflachen" verwenden, um ein Array in ein 1D-Array umzuwandeln.

>>> x.flatten()
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])

Mit "Abflachen" werden Änderungen am Array nicht auf das übergeordnete Array angewendet.

Zum Beispiel:

>>> a1 = x.flatten()
>>> a1[0] = 99
>>> print(x)  # Original array
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
>>> print(a1)  # New array
[99  2  3  4  5  6  7  8  9 10 11 12]

Bei ravel werden Änderungen am Array jedoch nicht auf das übergeordnete Array angewendet.

>>> a2 = x.ravel()
>>> a2[0] = 98
>>> print(x)  # Original array
[[98  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
>>> print(a2)  # New array
[98  2  3  4  5  6  7  8  9 10 11 12]

Besuchen Sie den Docstring, um mehr zu erfahren

Dieser Abschnitt befasst sich mit help (), ?, ??.

Wenn es um das Data Science-Ökosystem geht, sind Python und NumPy auf den Benutzer zugeschnitten. Ein gutes Beispiel hierfür ist der Zugriff auf die Dokumentation. Jedes Objekt hat einen Verweis auf eine Zeichenfolge, die als Dokumentzeichenfolge bezeichnet wird. In den meisten Fällen enthält diese Dokumentzeichenfolge eine kurze und präzise Übersicht über das Objekt und dessen Verwendung. Python verfügt über eine integrierte Hilfefunktion, mit der Sie auf die Dokumentzeichenfolge zugreifen können. Dies bedeutet, dass Sie, wenn Sie weitere Informationen benötigen, normalerweise help () verwenden können, um die benötigten Informationen schnell zu finden.

Zum Beispiel

>>> help(max)
Help on built-in function max in module builtins:
 
max(...)
    max(iterable, *[, default=obj, key=func]) -> value
    max(arg1, arg2, *args, *[, key=func]) -> value
 
    With a single iterable argument, return its biggest item. The
    default keyword-only argument specifies an object to return if
    the provided iterable is empty.
    With two or more arguments, return the largest argument.

Der Zugriff auf weitere Informationen kann sehr hilfreich sein. Was ist also mit IPython? Wird als Abkürzung für den Zugriff auf andere Informationen im Zusammenhang mit der Dokumentation verwendet. IPython ist eine Befehlsshell für interaktive Berechnungen, die in mehreren Sprachen verwendet werden können. Weitere Informationen zu IPython.

Zum Beispiel

In [0]: max?
max(iterable, *[, default=obj, key=func]) -> value
max(arg1, arg2, *args, *[, key=func]) -> value
 
With a single iterable argument, return its biggest item. The
default keyword-only argument specifies an object to return if
the provided iterable is empty.
With two or more arguments, return the largest argument.
Type:      builtin_function_or_method

Diese Notation kann sogar für Objektmethoden und sogar für die Objekte selbst verwendet werden.

Angenommen, Sie haben die folgende Sequenz erstellt:

>>> a = np.array([1, 2, 3, 4, 5, 6])

Auf diese Weise erhalten Sie viele nützliche Informationen (zuerst die Details des Objekts selbst, gefolgt von der Dokumentzeichenfolge des ndarray, in dem a eine Instanz ist).

In [1]: a?
Type:            ndarray
String form:     [1 2 3 4 5 6]
Length:          6
File:            ~/anaconda3/lib/python3.7/site-packages/numpy/__init__.py
Docstring:       <no docstring>
Class docstring:
ndarray(shape, dtype=float, buffer=None, offset=0,
        strides=None, order=None)
 
An array object represents a multidimensional, homogeneous array
of fixed-size items.  An associated data-type object describes the
format of each element in the array (its byte-order, how many bytes it
occupies in memory, whether it is an integer, a floating point number,
or something else, etc.)
 
Arrays should be constructed using `array`, `zeros` or `empty` (refer
to the See Also section below).  The parameters given here refer to
a low-level method (`ndarray(...)`) for instantiating an array.
 
For more information, refer to the `numpy` module and examine the
methods and attributes of an array.
 
Parameters
----------
(for the __new__ method; see Notes below)
 
shape : tuple of ints
        Shape of created array.
...

Dies funktioniert auch für Funktionen und andere Objekte, die Sie erstellen. Jedoch. Vergessen Sie nicht, die Dokumentzeichenfolge mit dem Zeichenliteral in die Funktion einzufügen (fügen Sie das Dokument in "" "" "" "oder" "" "" "" ein).

Zum Beispiel, wenn Sie die folgende Funktion erstellen

>>> def double(a):
...  '''Return a * 2'''
...  return a * 2

So erhalten Sie Informationen zu dieser Funktion:

 In [2]: double?
Signature: double(a)
Docstring: Return a * 2
File:      ~/Desktop/<ipython-input-23-b5adf20be596>
Type:      function

Sie können eine andere Informationsebene erhalten, indem Sie den Quellcode des Objekts lesen, an dem Sie interessiert sind. Sie können auf den Quellcode zugreifen, indem Sie das doppelte Fragezeichen (??) verwenden.

Zum Beispiel

In [3]: double??
Signature: double(a)
Source:
def double(a):
    '''Return a * 2'''
    return a * 2
File:      ~/Desktop/<ipython-input-23-b5adf20be596>
Type:      function

Wenn das Objekt in einer anderen Sprache als Python kompiliert wurde, gibt die Verwendung von ?? dieselben Informationen wie? Zurück. Dies ist in vielen integrierten Objekten und Typen zu sehen. Zum Beispiel

In [4]: len?
Signature: len(obj, /)
Docstring: Return the number of items in a container.
Type:      builtin_function_or_method

Und:

In [5]: len??
Signature: len(obj, /)
Docstring: Return the number of items in a container.
Type:      builtin_function_or_method

Sie haben dieselbe Ausgabe, da sie in einer anderen Sprache als Python kompiliert sind.

Behandeln Sie mathematische Formeln

Einer der Gründe, warum NumPy in der wissenschaftlichen Python-Community so häufig verwendet wird, ist, dass es einfach ist, Formeln zu implementieren, die auf Arrays funktionieren.

Dies ist beispielsweise der mittlere quadratische Fehler (die zentrale Formel, die in überwachten Modellen für maschinelles Lernen verwendet wird, die sich mit Regression befassen).

Die Implementierung dieses Ausdrucks ist in NumPy einfach und entspricht dem Ausdruck:

error  = (1/n) * np.sum(np.square(predictions - labels))

Dies funktioniert sehr gut, da es entweder einen oder 1000 vorhergesagte Werte und Beschriftungen enthalten kann. Alles, was Sie brauchen, ist, dass der vorhergesagte Wert und das Etikett dieselbe Größe haben.

Dies kann wie folgt visualisiert werden:

In diesem Beispiel sind Vorhersage und Bezeichnung Bertholds mit drei Werten, daher nimmt n den Wert drei an. Nach der Subtraktion wird der Wert des Vektors quadriert. NumPy summiert dann die Werte und das Ergebnis ist eine Bewertung des vorhergesagten Fehlers und der Modellqualität.

So speichern und laden Sie NumPy

• Dieser Abschnitt befasst sich mit "np.save", "np.savez", "np.savetxt", "np.load", "np.loadtxt" *

Möglicherweise möchten Sie das Array irgendwann auf der Festplatte speichern und laden, ohne den Code erneut ausführen zu müssen. Glücklicherweise bietet NumPy verschiedene Möglichkeiten zum Speichern und Laden von Objekten. Das ndarray-Objekt kann reguläre Textdateien mit den Funktionen loadtxt und savetxt laden und speichern sowie NumPy-Binärdateien mit der Erweiterung .npz mit den Funktionen load und save verarbeiten. Und Sie können mit Numpy-Dateien mit der Erweiterung .npz mit der Funktion savez arbeiten.

Die Dateien **. Npy ** und **. Npz ** speichern Daten, Formen, dtypes und andere Informationen, die zum Neuerstellen des ndarray erforderlich sind, damit die Dateien auf verschiedenen Architekturen korrekt wiederhergestellt werden können. Ich bin.

Wenn Sie ein ndarray-Objekt speichern möchten, verwenden Sie np.save, um es als .npy-Datei zu speichern. Wenn Sie mehrere ndarrays in einem Array speichern möchten, verwenden Sie np.savez und speichern Sie es als .npz. Sie können auch mehrere Arrays in einer Datei speichern, indem Sie sie im npz-Format speichern, das mit savez_compressed komprimiert wurde.

Mit np.save () ist das Speichern und Laden und Array einfach. Mit np.save () ist das Speichern und Laden und Array einfach. Vergessen Sie nicht, das Array und den Dateinamen anzugeben, die Sie speichern möchten. Zum Beispiel, wenn Sie dieses Array erstellen

>>> a = np.array([1, 2, 3, 4, 5, 6])

Sie können es als "filename.npy" speichern.

>>> np.save('filename', a)

Sie können das Array mit np.load () wiederherstellen.

>>> b = np.load('filename.npy')

Wenn Sie die Sequenz sehen möchten, können Sie diesen Code ausführen.

>>> print(b)
[1 2 3 4 5 6]

Sie können np.savetxt verwenden, um NumPy-Dateien als einfachen Text wie CSV- und TXT-Dateien zu speichern.

Zum Beispiel, wenn Sie die folgende Sequenz erstellen

>>> csv_arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
​```shell
 
You can easily save it as a .csv file with the name “new_file.csv” like this:

​```shell
>>> np.savetxt('new_file.csv', csv_arr)

Sie können eine gespeicherte Textdatei einfach mit loadtxt () laden.

>>> np.loadtxt('new_file.csv')
array([1., 2., 3., 4., 5., 6., 7., 8.])

Die Funktionen savetxt () und loadtxt () akzeptieren zusätzliche Parameter wie Kopf-, Fuß- und Trennzeichen. Textdateien sind praktisch für die Freigabe, während .npy- und .npz-Dateien klein und schnell zu lesen und zu schreiben sind. Wenn Sie eine komplexere Handhabung von Textdateien benötigen (z. B. beim Umgang mit einer Matrix [Zeilen] mit fehlenden Werten), genfromtxt Sie müssen die Funktion .genfromtxt.html # numpy.genfromtxt) verwenden.

Bei Verwendung von savetxt können Sie Kopf- und Fußzeilen, Kommentare usw. angeben.

Learn more about input and output routines here.

So importieren / exportieren Sie CSV

Es ist einfach, eine CSV-Datei zu lesen, die vorhandene Informationen enthält. Am einfachsten ist es, Pandas zu verwenden.

>>> import pandas as pd
 
>>> # If all of your columns are the same type:
>>> x = pd.read_csv('music.csv', header=0).values
>>> print(x)
[['Billie Holiday' 'Jazz' 1300000 27000000]
 ['Jimmie Hendrix' 'Rock' 2700000 70000000]
 ['Miles Davis' 'Jazz' 1500000 48000000]
 ['SIA' 'Pop' 2000000 74000000]]
 
>>> # You can also simply select the columns you need:
>>> x = pd.read_csv('music.csv', usecols=['Artist', 'Plays']).values
>>> print(x)
[['Billie Holiday' 27000000]
 ['Jimmie Hendrix' 70000000]
 ['Miles Davis' 48000000]
 ['SIA' 74000000]]

Das Exportieren eines Arrays ist mit Pandas ebenfalls einfach. Wenn Sie NumPy noch nicht kennen, empfiehlt es sich, einen Pandas-Datenrahmen aus Array-Werten zu erstellen und diesen Datenrahmen mit Pandas in eine CSV-Datei zu exportieren.

Angenommen, Sie haben das Array "a" erstellt.

>>> a = np.array([[-2.58289208,  0.43014843, -1.24082018, 1.59572603],
...              [ 0.99027828, 1.17150989,  0.94125714, -0.14692469],
...              [ 0.76989341,  0.81299683, -0.95068423, 0.11769564],
...              [ 0.20484034,  0.34784527,  1.96979195, 0.51992837]])

Sie können einen Pandas-Datenrahmen wie folgt erstellen:

>>> df = pd.DataFrame(a)
>>> print(df)
          0         1         2         3
0 -2.582892  0.430148 -1.240820  1.595726
1  0.990278  1.171510  0.941257 -0.146925
2  0.769893  0.812997 -0.950684  0.117696
3  0.204840  0.347845  1.969792  0.519928

Sie können den Datenrahmen wie folgt speichern:

>>> df.to_csv('pd.csv')

CSV ist so

>>> data = pd.read_csv('pd.csv')

NumPyのsavetxtメソッドを使って保存することもできます。

>>> np.savetxt('np.csv', a, fmt='%.2f', delimiter=',', header='1,  2,  3,  4')

Wenn Sie die Befehlszeile verwenden, können Sie jederzeit eine mit einem Befehl wie diesem gespeicherte CSV laden:

$ cat np.csv
#  1,  2,  3,  4
-2.58,0.43,-1.24,1.60
0.99,1.17,0.94,-0.15
0.77,0.81,-0.95,0.12
0.20,0.35,1.97,0.52

Alternativ können Sie es jederzeit in einem Texteditor öffnen.

Weitere Informationen zu Pandas finden Sie in der offiziellen Pandas-Dokumentation. Informationen zur Installation von Pandas finden Sie unter offizielle Informationen zur Pandas-Installation.

Zeichnen Sie das Array mit Matplotlib

Wenn Sie ein Diagramm mit Werten erstellen müssen, ist Matplotlib sehr einfach zu verwenden.

Beispielsweise könnten Sie ein Array wie das folgende haben:

>>> a = np.array([2, 1, 5, 7, 4, 6, 8, 14, 10, 9, 18, 20, 22])

Wenn Sie Matplotlib bereits installiert haben, können Sie es folgendermaßen importieren:

>>> import matplotlib.pyplot as plt
 
# If you're using Jupyter Notebook, you may also want to run the following
# line of code to display your code in the notebook:
 
%matplotlib inline

Es ist keine mühsame Arbeit erforderlich, um die Werte zu zeichnen.

>>> plt.plot(a)
 
# If you are running from a command line, you may need to do this:
# >>> plt.show()

Beispielsweise können Sie ein 1D-Array wie folgt zeichnen:

‘>>> x = np.linspace(0, 5, 20)
>>> y = np.linspace(0, 10, 20)
>>> plt.plot(x, y, 'purple') # line
>>> plt.plot(x, y, 'o')      # dots

Matplotlib bietet eine Vielzahl von Visualisierungsoptionen.

>>> from mpl_toolkits.mplot3d import Axes3D
>>> fig = plt.figure()
>>> ax = Axes3D(fig)
>>> X = np.arange(-5, 5, 0.15)
>>> Y = np.arange(-5, 5, 0.15)
>>> X, Y = np.meshgrid(X, Y)
>>> R = np.sqrt(X**2 + Y**2)
>>> Z = np.sin(R)
 
>>> ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='viridis')

To read more about Matplotlib and what it can do, take a look at the official documentation.FordirectionsregardinginstallingMatplotlib,seetheofficialinstallationsection.

mage credits: Jay Alammar http://jalammar.github.io/