Numpy Tutorial - NumPy Array Erstellung

  1. Nullen-Array
  2. Ein Array
  3. Diagonales Array
  4. Triangular Array

Nullen-Array

np.zeros

np.zeros wird benutzt, um das Array zu erstellen, dass alle Elemente 0 sind. Seine Syntax ist,

np.zeros(shape, dtype=float, order='C')

Wo?

Form ist die Größe der Matrix, und sie kann 1-D, 2-D oder mehrere Dimensionen haben.

dtype ist standardmäßig float64, kann aber in NumPy mit jedem Datentyp belegt werden.

Lassen Sie uns ein paar Nullen-Arrays erstellen

>>> import numpy as np
>>> np.zeros(5)		# it creates a 1D array with 5 zeros
array([0., 0., 0., 0., 0.])
>>> np.zeros(5, dtype='int8')	# it creates a 1D array with 5 zeros with the data type of int8
array([0, 0, 0, 0, 0], dtype=int8)
>>> np.zeros((4, 3)) # it creates a 4x3 zeros array
array([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]])

np.empty

In einigen Fällen wollen Sie nur ein Array mit der angegebenen Form initialisieren und u kümmern sich nicht um die Initialisierungsdaten darin. Sie können np.empty verwenden, um eine schnellere Initialisierung zu erreichen, aber denken Sie daran, dass es nicht garantiert, dass der Wert des erzeugten Arrays 0 ist.

Wir könnten %timeit benutzen, um die Ausführungszeit von np.empty() und np.zeros() zu vergleichen,

In [1]: %timeit np.empty((100, 100))
    715 ns ± 11.6 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
In [2]: %timeit np.zeros((100, 100))
    4.03 µs ± 104 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Offensichtlich ist np.empty() viel schneller als np.zeros() bei der Initialisierung. Es dauert nur etwa 17.5% der Zeit, die np.zeros() benötigt, um ein Array mit der Form (100, 100) zu initialisieren.

np.zeros_like

Angenommen, wir haben bereits ein Array und wollen ein Null-Array erstellen, das die gleiche Form hat. Wir könnten den traditionellen Weg benutzen, um dieses neue Array zu erstellen.

test = np.array([[1,2,3],[4,5,6],[7,8,9]])
np.zeros(test.shape)

Oder wir könnten die dedizierte Methode - np.zeros_like() verwenden, um das neue Array effizienter zu erstellen.

x = np.zeros_like(test)
Achtung

Das mit np.zeros_like() erzeugte Array hat nicht nur die gleiche Form mit dem angegebenen Array, sondern auch den gleichen Datentyp wie dieses.

Ein Array

np.ones

Ähnlich wie bei Nullen könnten wir auch das mit Einsen gefüllte Array erstellen. Die Syntax und die Parameter von np.ones() sind identisch mit np.zeros().

>>> import numpy as np
>>> np.ones(5)		# it creates a 1-D array with 5 ones
array([1., 1., 1., 1., 1.])
>>> np.ones(5, dtype='int8')	# it creates a 1-D array with 5 ones, and its data type is int8
array([1, 1, 1, 1, 1], dtype=int8)
>>> np.ones((4, 3)) # it creates an array of (4, 3) shape
array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])

np.ones_like

Ähnlich wie np.zeros_like, könnte np.ones_like verwendet werden, um ein neues Array von Einsen mit der gleichen Form wie das gegebene Array zu erstellen.

>>> test = np.array([[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0]])
>>> np.ones_like(test)
array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])

Diagonales Array

Diagonal-Array ist das 2-D-Array mit Einsen auf der Diagonale und Nullen an anderer Stelle. Es könnte mit der np.eye() Methode erstellt werden, deren Syntax ist,

np.eye(N, M=None, k=0, dtype=<class 'float'>, order='C')

Wo?

Parameter Datentyp Zusammenfassung
N INT Gibt die Anzahl der Zeilen in der generierten Matrix an.
M INT (Optional) Die Voreinstellung ist None. Gibt die Anzahl der zu generierenden Spalten in der Matrix an. Wenn sie None ist, ist sie gleich N.
k INT (Optional) Die Voreinstellung ist 0. 0 ist die Hauptdiagonale. Wenn k positiv ist, erzeugt sie eine obere Diagonale mit der Verschiebung von k; wenn k negativ ist, erzeugt sie eine untere Diagonale mit der Verschiebung von -k.
dTyp Datentyp (Optional) Der Standardwert ist Float. Er gibt den Datentyp des Elements des erzeugten Arrays an.

np.eye() Beispiel

>>> import numpy as np
>>> np.eye(3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
>>> np.eye(4, 3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.],
       [0., 0., 0.]])
>>> np.eye(3, 4)
array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.]])
>>> np.eye(4, k=1)
array([[0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.],
       [0., 0., 0., 0.]])

np.identity()

np.identity könnte als spezielles np.eye behandelt werden, weil es ein quadratisches diagonales Array mit Einsen auf der Hauptdiagonale erzeugt.

numpy.identität(n, dtyp = schweben)
Parameter Datentyp Beschreibung
n INT Gibt die Größe der zu generierenden Matrix an. Es wird ein N×N-Quadrat-Array erzeugt.
dtyp Datentyp (Optional) Die Voreinstellung ist Float. Er gibt den Datentyp des Elements an.

np.identity() Beispiele

>>> import numpy as np
>>> np.identity(3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

Triangular Array

Sie könnten np.tri() verwenden, um ein dreieckiges Array zu erstellen. Seine Syntax ist,

numpy.tri(N, M=None, k=0, dtype=<class 'float'>)

Seine Eingabeparameter sind ähnlich wie bei np.eye().

np.tri() Beispiele

>>> import numpy as np
>>> np.tri(3)
array([[1., 0., 0.],
       [1., 1., 0.],
       [1., 1., 1.]])
>>> np.tri(4, k=1)
array([[1., 1., 0., 0.],
       [1., 1., 1., 0.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])