NumPy Array Creation

  1. Zeros Array
  2. Ones Array
  3. Diagonale array
  4. Driehoekige array

Zeros Array

np.zeros

np.zeros wordt gebruikt om de array te maken die alle elementen bevat 0 . De syntaxis is,

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

Waar,

shape is de grootte van de matrix en dit kan 1-D, 2-D of meerdere dimensies zijn.

dtype is float64 standaard, maar kan aan elk gegevenstype worden toegewezen NumPy.

Laten we enkele nullen-arrays maken

>>> 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 sommige gevallen wilt u alleen een array met de opgegeven vorm initialiseren en maakt u zich geen zorgen over de initialisatiegegevens erin. Je kan gebruiken np.empty om een ​​snellere initialisatie te bereiken, maar houd er rekening mee dat het niet garandeert dat de waarde van de gemaakte array 0 is.

We kunnen gebruiken %timeit om de uitvoeringstijd van np.empty() en te vergelijken np.zeros() ,

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)

Het np.empty() is duidelijk dat het veel sneller is dan np.zeros() bij initialisatie. Het kost slechts ongeveer de 17.5% tijd die nodig is np.zeros() om een ​​array met de vorm van te initialiseren (100, 100).

np.zeros_like

Stel dat we al een array hebben en een array met nullen willen maken die dezelfde vorm heeft. We kunnen de traditionele manier gebruiken om deze nieuwe array te maken.

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

Of we kunnen de speciale methode np.zeros_like() gebruiken om de nieuwe array efficiënter te maken.

x = np.zeros_like(test)

Aandacht

De array gemaakt door np.zeros_like() heeft niet alleen dezelfde vorm met de gegeven array maar ook hetzelfde gegevenstype.

Ones Array

np.ones

Net als bij zeros , kunnen we ook de array met degenen maken. De syntaxis en parameters van np.ones() zijn identiek aan 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

Vergelijkbaar met np.zeros_like , np.ones_like kan worden gebruikt om een ​​nieuwe reeks met dezelfde vorm te maken als de gegeven reeks.

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

Diagonale array

Diagonale array is de 2D-array met die op de diagonaal en nullen elders. Het kan worden gemaakt met een np.eye() methode waarvan de syntaxis is,

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

Waar,

parameter type gegevens Overzicht
N INT Specificeert het aantal rijen in de gegenereerde matrix.
M INT (Optioneel) De standaardwaarde is None . Specificeert het aantal kolommen in de te genereren matrix. Wanneer het is None , is het gelijk aan N .
k INT (Optioneel) De standaardwaarde is 0. 0 is de hoofddiagonale positie. Als k positief is, creëert het de bovenste diagonaal met de verplaatsing van k ; als k negatief is, creëert het een lagere diagonaal met de verplaatsing van -k .
dtype type gegevens (Optioneel) De standaardwaarde is float . Het specificeert het gegevenstype van het element van de gecreëerde array.

np.eye() Voorbeeld

>>> 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 kan als speciaal worden behandeld np.eye omdat het een vierkante diagonale reeks creëert met die op de hoofddiagonaal.

numpy.identity(n, dtype = float)
parameter type gegevens Beschrijving
n INT Specificeert de grootte van de te genereren matrix. Het creëert een N × N vierkante array.
dtype type gegevens (Optioneel) De standaardinstelling is zwevend. Het specificeert het gegevenstype van het element.

np.identity() Voorbeelden

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

Driehoekige array

Je kan gebruiken np.tri() om een ​​driehoekige matrix te maken. De syntaxis is,

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

De invoerparameters zijn vergelijkbaar met np.eye().

np.tri() Voorbeelden

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