NumPy 创建数组

L'array ndarray può essere creato non solo tramite il costruttore di ndarray di basso livello, ma anche attraverso i seguenti metodi:

numpy.empty

Il metodo numpy.empty viene utilizzato per creare un array con una forma specificata (shape), un tipo di dati (dtype) e non inizializzato:

numpy.empty(shape, dtype = float, order = 'C')

Restituisce un nuovo array con la forma e il tipo di dati forniti, senza inizializzare gli elementi.

Parametro

prototype - La forma dell'array di zeri.dtype (opzionale) - Il tipo di dati richiesto per l'array, ad esempio numpy.int8. Il valore predefinito è numpy.float64.order (opzionale, predefinito: 'C') - Ci sono due opzioni "C" e "F", che rappresentano rispettivamente l'ordine delle righe e delle colonne, l'ordine di memorizzazione degli elementi nel computer.

Valore di ritorno: array con la forma dell'array fornito, ma senza inizializzare i dati (valori casuali) per il tipo di dati e l'ordine.

>>>　import　numpy　as　np
>>> np.empty([2, 2])
array([[1., 0.],
　　　　　　　[0., 1.]])
>>> np.empty([2, 2], dtype=int)
array([[4607182418800017408, 0],
　　　　　　　[0, 4607182418800017408]])
>>>

numpy.empty_like

numpy.empty restituisce un nuovo array con la forma e il tipo di dati identici a quelli dell'array fornito.

numpy.empty_like(prototype, dtype=None, order='K', subok=True, shape=None)

Restituisce un nuovo array con la forma e il tipo di dati identici a quelli dell'array fornito

Parametro

prototype - La forma e il tipo di dati dell'array sorgente definiscono queste stesse proprietà dell'array restituito.dtype - Il tipo di dati dei risultati di copertura.order - La disposizione in memoria dei risultati di copertura. Se prototypeFortran è contiguo, "A" rappresenta "F", altrimenti è "C". "K" rappresenta che il prototype si adatta il più possibile alla disposizione.subok - Se impostato su True, l'array creato utilizzerà il sotto tipo di 'a', altrimenti sarà un array di classe base. Predefinito a True.shape - La forma del risultato da coprire. Se order = 'K' e il numero di dimensioni non cambia, viene tentato di mantenere l'ordine; altrimenti, si implica order = 'C'.

Ritorno: Array di dati non inizializzati (qualsiasi) con la stessa forma e tipo dell'原型.

>>>　import　numpy　as　np
>>> a = ([1, 2, 3], [4, 5, 6])  # a è array-like
>>> np.empty_like(a)
array([[6917529027641081856, -6917520256071729910, 98],
　　　　　　　[0, 0, 0],
>>> a = np.array([[1., 2., 3.], [4., 5., 6.]])
>>> np.empty_like(a)
array([[2.68156159e+154, 2.68156159e+154, 3.32479618e+181],
　　　　　　　[2.68156159e+154, 2.68156159e+154, 3.32479618e+181],

numpy.zeros

Crea un array di dimensioni specificate, riempito con 0:

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

Parametro

shape - La forma dell'array di zeri.dtype - Il tipo di dati richiesto per l'array, ad esempio numpy.int8. Il valore predefinito è numpy.float64.order - '{'C', 'F'} opzionale, predefinito: 'C', indica l'ordine di memorizzazione dei dati nell'array in memoria in stile riga (C) o colonna (Fortran).

Ritorno: Array di zeri con la stessa forma, tipo e ordine dell'array fornito.

>>>　import　numpy　as　np
>>> np.zeros(5)
array([0.0, 0.0, 0.0, 0.0, 0.0])
>>> np.zeros((5,), dtype=int)
array([0, 0, 0, 0, 0])
>>> np.zeros((2, 1))
array([[0.0],
　　　　　　　[0.0]
>>> s = (2,2)
>>> np.zeros((2,), dtype=[('x', 'i4'), ('y', '')])  # dtype personalizzato
array([(0, 0), (0, 0)], dtype=[('x', '<i4'), ('y', '')])

numpy.zeros_like

ritorna un array di zeri con la stessa forma e tipo dell'array fornito.

>>>　import　numpy　as　np
>>> x = np.arange(6)
>>> x = x.reshape((2, 3))
>>> print(x)
[[0 1 2]
　[3 4 5]]
>>> np.zeros_like(x)
array([[0, 0, 0],
　　　　　　　[0, 0, 0]])
>>> y = np.arange(3, dtype=float)
>>> y
array([0., 1., 2.])
>>> np.zeros_like(y)
array([0., 0., 0.])

numpy.ones

Crea un array con la forma specificata e riempito con 1:

numpy.ones(shape, dtype=None, order='C')

Parametro

shape - Forma dell'array.dtype - Tipo di dati, opzionaleorder - 'C' per l'array di righe di C, o 'F' per l'array di colonne di FORTRAN

>>>　import　numpy　as　np
>>> np.ones(5)
array([1., 1., 1., 1., 1.])
>>> np.ones((5,), dtype=int)
array([1, 1, 1, 1, 1])
>>> np.ones((2, 1))
array([[1.],
　　　　　　　[1.]])
>>> s = (2,2)
>>> np.ones(s)
array([[1., 1.],
　　　　　　　[1., 1.]])

numpy.ones_like

zeros_like restituisce un array con la stessa forma e tipo dell'array dato.

numpy.ones_like(a, dtype=None, order='K', subok=True, shape=None)

Parametro

a - Proprietà che limita la forma e il tipo di ritorno dell'array.dtype - Tipo di dati richiesto dall'array.order - Copertura della disposizione della memoria del risultato.subok - Se impostato su True, l'array creato utilizzerà il sotto tipo di 'a', altrimenti sarà un array di classe base. Predefinito a True.shape - Copertura della forma del risultato.

Ritorno: un'array di zeri con la stessa forma e tipo.

>>>　import　numpy　as　np
>>> x = np.arange(6)
>>> x = x.reshape((2, 3))
>>> x
array([[0, 1, 2],
　　　　　　　[3, 4, 5]])
>>> np.ones_like(x)
array([[1, 1, 1],
　　　　　　　[1, 1, 1]])
>>> y = np.arange(3, dtype=float)
>>> y
array([0., 1., 2.])
>>> np.ones_like(y)
array([1., 1., 1.])

numpy.arange

numpy.arange([start,] stop, [step,] dtype=None)

Restituisce valori uniformemente spaziati all'interno dell'intervallo fornito.
Genera valori all'interno dell'intervallo aperto (cioè, include start ma non include stop). Per parametri interi, la funzione è equivalente alla funzione integrata di Python range, ma restituisce ndarray invece di lista.

Parametro

start - Inizio dell'intervallo. L'intervallo include questo valore. Il valore predefinito di partenza è 0.stop - Fine dell'intervallo. L'intervallo non include questo valore, a meno che lo step non sia un intero e il round di floating-point influenzi la lunghezza di out.step - Spazio tra i valori. Per qualsiasi output, è la distanza tra due valori adiacenti, la lunghezza predefinita dello step è 1.dtype - Tipo di dati dell'array di output.

Ritorna: un array di valori uniformemente spaziati.

>>>　import　numpy　as　np
>>> np.arange(3)
array([0, 1, 2])
>>> np.arange(3.0)
array([0., 1., 2.])
>>> np.arange(3, 7)
array([3, 4, 5, 6])
>>> np.arange(3, 7, 2)
array([3, 5])

numpy.linspace

La funzione numpy.linspace viene utilizzata per creare un array unidimensionale, l'array è composto da una sequenza aritmetica, con il formato seguente:

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

Parametro

start - Valore di inizio della sequenza.stop - Valore di fine della sequenza. Se endpoint è true, questo valore è incluso nella sequenza.num - Il numero di campioni di passo uguale da generare, il valore predefinito è 50.endpoint - Il valore è true quando la sequenza contiene il valore stop, altrimenti non lo contiene, il valore predefinito è True.retstep - Se impostato su True, l'array generato mostrerà gli spazi, altrimenti non li mostrerà.dtype - Tipo di dati ndarray.

Esempio che utilizza tre parametri, imposta il punto di partenza su 1, il punto di arrivo su 10 e il numero di elementi della sequenza su 10.

>>>　import　numpy　as　np
>>> a = np.linspace(1, 10, 10)
>>> print(a)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a = np.linspace(10, 20, 5, endpoint=False)
>>> print(a)
[10. 12. 14. 16. 18.]
>>> a = np.linspace(1,10,10,retstep= True)
>>> print(a)
(array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]), 1.0)
>>> b = np.linspace(1,10,10).reshape([10,1])
>>> print(b)
[[ 1.]]
　[ 2.]
　[ 3.]
　[ 4.]
　[ 5.]
　[ 6.]
　[ 7.]
　[ 8.]
　[ 9.]
　[10.]]

numpy.asarray

Convertire direttamente i tipi di dati di base di Python (come liste, tuple, ecc.) in ndarray:

>>>　import　numpy　as　np
>>> ls1 = [10, 42, 0, -17, 30]
>>> nd1 = np.array(ls1)
>>> print(nd1)
[ 10 42 0 -17 30]
>>>
>>> print(type(nd1))

numpy.asarraysimile numpy.arrayMa il parametro numpy.asarray ha solo tre, due in meno rispetto a numpy.array.

numpy.asarray(a, dtype = None, order = None)

Parametro

a - Parametro di input di qualsiasi forma, può essere una lista, un tuple di lista, un tuple, un tuple di tuple, una lista di tuple, un array multidimensionale.dtype - Tipo di dati, opzionale.order - Il numero di campioni di passo uguale da generare, il valore predefinito è 50.endpoint - Opzionale, ha due opzioni: "C" e "F", che rappresentano rispettivamente l'ordine per righe e per colonne, l'ordine di memorizzazione degli elementi in memoria del computer.

>>>　import　numpy　as　np
>>> x = [1,2,3]
>>> a = np.asarray(x)
>>> a
array([1, 2, 3])
>>> x = (1,2,3)
>>> a = np.asarray(x)
>>> print(a)
[1 2 3]
>>> x = [(1,2,3),(4,5)]
>>> a = np.asarray(x)
>>> print(a)
[(1, 2, 3) (4, 5)]
>>> x = [1,2,3]
>>> a = np.asarray(x, dtype = float)
>>> print(a)
[1. 2. 3.]

numpy.frombuffer

numpy.frombuffer viene utilizzato per implementare array dinamici.
numpy.frombuffer accetta un parametro buffer, leggendolo come flusso e trasformandolo in un oggetto ndarray.

numpy.frombuffer(buffer, dtype=float, count=-1, offset=0)

Parametro

buffer - Può essere qualsiasi oggetto, letto in forma di flusso.dtype - Restituisce il tipo di dati dell'array, opzionalecount - Numero di dati letti, predefinito a -1, leggere tutti i dati.offset - Posizione di inizio della lettura, predefinita a 0.

>>>　import　numpy　as　np
>>> s = b'Hello w3codebox'
>>> a = np.frombuffer(s, dtype='S1')
>>> print(a)
[b'H' b'e' b'l' b'l' b'o' b' ' b'L' b'i' b'd' b'i' b'h' b'u' b'o']

numpy.fromiter

Il metodo numpy.fromiter costruisce un oggetto ndarray da un oggetto iterable, restituisce un array uno.

numpy.fromiter(iterable, dtype, count=-1)

Parametro

iterable - Oggetto iterabile.dtype - Restituisce il tipo di dati dell'array.count - Numero di dati letti, predefinito a -1, leggere tutti i dati.

>>>　import　numpy　as　np
>>> # Utilizzare la funzione range per creare un oggetto lista
>>> list=range(5)
>>> it=iter(list)
>>> x=np.fromiter(it, dtype=float)
>>> print(x)
[0. 1. 2. 3. 4.]

Generare un array utilizzando il modulo random

Per addestrare efficacemente il modello e migliorare le sue prestazioni, alcune inizializzazioni devono soddisfare determinate condizioni, come la distribuzione normale o uniforme, ecc. Di seguito sono descritte alcune delle modalità comuni del modulo np.random, come indicato nella tabella sottostante.

>>>　import　numpy　as　np
>>>　#　生成全是　0　的　3x3　矩阵
>>>　nd5　=np.zeros([3,　3])
>>>　print("nd5　=\n",　nd5)
nd5　=
　[[0.　0.　0.]
　[0.　0.　0.]
　[0.　0.　0.]]
>>>　#　生成全是　1　的　3x3　矩阵
>>>　nd6　=　np.ones([3,　3])
>>>　print("nd6　=\n",　nd6)
nd6　=
　[[1.　1.　1.]
　[1.　1.　1.]
　[1.　1.　1.]]
>>>
>>>　#　生成　4　阶的单位矩阵
>>>　nd7　=　np.eye(4)
>>>　print("nd7　=\n",　nd7)
nd7　=
　[[1.　0.　0.　0.]
　[0.　1.　0.　0.]
　[0.　0.　1.　0.]
　[0.　0.　0.　1.]]
>>>　#　生成　4　阶对角矩阵
>>>　nd8　=　np.diag([1,　8,　3,　10])
>>>　print("nd8　=\n",　nd8)
nd8　=
　[[　1　0　0　0]
　[　0　8　0　0]
　[　0　0　3　0]
　[　0　0　0　10]]