Tutorial Numpy - Creazione di un array NumPy

  1. Array di zeri
  2. Array Uno
  3. Array diagonale
  4. Array triangolare

Array di zeri

np.zeros

np.zeros è usato per creare l’array che tutti gli elementi sono 0. La sua sintassi è,

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

Dove,

shape è la dimensione di un array, e potrebbe essere 1-D, 2-D o dimensioni multiple.

dtype è float64 per impostazione predefinita, ma potrebbe essere assegnato con qualsiasi tipo di dati in numpy.

Creiamo alcuni array di zeri

>>> 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 alcuni casi, si vuole inizializzare solo un array con la forma specificata e non ci si preoccupa dei dati di inizializzazione all’interno. Si può usare np.empty per ottenere un’inizializzazione più veloce, ma si tenga presente che non garantisce che il valore dell’array creato sia 0.

Si potrebbe usare %timeit per confrontare il tempo di esecuzione di np.empty() e 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)

Ovviamente, np.empty() è molto più veloce di np.zeros() nell’inizializzazione. Ci vuole solo circa il 17.5% del tempo necessario per np.zeros() per inizializzare un array con la forma di (100, 100).

np.zeros_like

Supponiamo di avere già un array e di voler creare un array di zeri che abbia la stessa forma. Potremmo usare il modo tradizionale per creare questo nuovo array.

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

Oppure potremmo usare il metodo dedicato - np.zeros_like() per creare il nuovo array in modo più efficiente.

x = np.zeros_like(test)
Attenzione

L’array creato da np.zeros_like() ha non solo la stessa forma con l’array dato, ma anche lo stesso tipo di dati.

Array Uno

np.ones (np.ones)

Simile a zeros, potremmo anche creare l’array riempito con quelli. La sintassi e i parametri di np.ones() sono identici a 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

Simile a np.zeros_like, np.ones_like potrebbe essere usato per creare un nuovo array di quelli con la stessa forma di un dato array.

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

Array diagonale

L’array diagonale è l’array 2-D con uno sulla diagonale e zeri altrove. Potrebbe essere creato con il metodo np.eye() la cui sintassi è la seguente,

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

Dove,

parametro tipo di dati Sommario
N INT Specifica il numero di righe nella matrice generata.
M INT (Opzionale) L’impostazione predefinita è None. Specifica il numero di colonne di un array da generare. Quando è None, è uguale a N.
k INT (Opzionale) Il valore predefinito è 0. 0 è la posizione diagonale principale. Se k è positiva, crea la diagonale superiore con lo spostamento di k; se k è negativa, crea la diagonale inferiore con lo spostamento di -k.
dtype tipo di dati (Opzionale) Il valore predefinito è float. Specifica il tipo di dati dell’elemento dell’array creato.

np.eye() Esempio

>>> 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 potrebbe essere trattato come speciale np.eye perché crea un array diagonale quadrata con quelle sulla diagonale principale.

numpy.identity(n, dtype = float)
parametro tipo di dati Descrizione
n INT Specifica la dimensione di un array da generare. Crea un array quadrata N×N.
dtype tipo di dati (Opzionale) L’impostazione predefinita è float. Specifica il tipo di dati dell’elemento.

np.identity() Esempi

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

Array triangolare

Si potrebbe usare np.tri() per creare un array triangolare. La sua sintassi è,

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

I suoi parametri di ingresso sono simili a np.eye().

np.tri() Esempi

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