Ravel Python Numpy

Come Numpy è una biblioteca standard Python che funziona con operazioni matematiche di alto livello come array e matrici con calcolo efficiente. Ha una funzione integrata per manipolare gli array. Questo articolo avrà una profonda discussione su una delle funzioni numpy supportate che si chiamano numpy.funzione ravel ().

Restituisce un array di appiattimento contiguo che significa che cambia un array bidimensionale o un array multidimensionale in un array monodimensionale dello stesso tipo di quello dell'array di input. Facciamo un esempio di implementazione di questa funzione Ravel () come si appiattisce in modi diversi.

Tutti gli esempi eseguono nel terminale Spyder. Si noti che dobbiamo importare il modulo numpy per accedere a questa funzione Ravel ().

Sintassi di Numpy.Ravel ()

La sintassi usata in numpy.La funzione Ravel () è così:

# Numpy.Ravel (z, order = "C")

Parametro passato di numpy.Ravel ()

Principalmente, ci sono due parametri passati in questa funzione: "Z" e "Ordine". La "z" è un array di input che cambia in un array di appiattimento contiguo o in un array unidimensionale. Gli elementi dell'array sono nell'ordine specificato dal parametro "ordine" e confezionato in un array unidimensionale.

Questo ordine è un parametro opzionale che prende tre argomenti: C, F e K. Se impostiamo un ordine come C, l'array viene appiattito in riga-major e, per impostazione predefinita, il parametro "C" viene preso. Se impostiamo "F", l'array ottiene un array appiattito in colonna-major. D'altra parte, è impostato nell'ordine "k" che appiattisce l'array nello stesso ordine degli elementi in memoria.

Esempio 1:

In questo esempio, abbiamo un array bidimensionale come array di input con valori diversi con una variabile assegnata con il nome 'arr_1'. Quindi chiameremo l'ARR_1.Ravel () funzione per appiattire un array in un'altra variabile 'arr_2'.

Possiamo avere valori di array di input e appiattire i valori dell'array nella schermata della console tramite istruzioni di stampa.

Importa Numpy come NP
arr_1 = np.Array ([[0, -8, 3], [15, 2, 1]])
arr_2 = arr_1.Ravel ()
print ("Visualizzazione dell'array di input: \ n", arr_1)
print ("Visualizzazione dell'array di output: \ n", arr_2)

Infine, abbiamo l'uscita dell'array 2-D convertita nell'array 1-D sotto.

Esempio 2:

Qui nell'esempio, mostreremo che la funzione Ravel () è uguale alla funzione Reshape (). In primo luogo, abbiamo creato un array 2D dalla funzione dell'array NP.array () quindi assegnato my_arr.ravel () a una variabile 'output_arr' che trasporta l'array appiattito; Successivamente, abbiamo stampato sia array di input che array di output.

Alla fine abbiamo applicato my_arr.Reshape (-1) in una variabile reshape_arr. Abbiamo stampato l'array di reshape e rave () array di funzioni.

Importa Numpy come NP
my_arr = np.array ([[99, 15, 56], [7, 63, -54]])
output_arr = my_arr.Ravel ()
print ("Visualizzazione dell'array di input: \ n", my_arr)
print ("Visualizzazione dell'array di input: \ n", output_arr)
Reshape_arr = my_arr.Reshape (-1)
Stampa ("Visualizzazione dell'array di reshape: \ n", my_arr)

Mentre abbiamo rimodellato l'array e appiattito l'array dalla funzione Ravel (), l'uscita è mostrata nello screenshot seguente.

Esempio 3:

In questo particolare esempio, stiamo applicando il numpy.Ravel () funzione con l'ordine 'f' che imposterà l'array 2D in un array di colonna-Major 1D. Abbiamo un array 2D in una variabile 'f_arr' e f_arr.La funzione ravel () con l'ordine è uguale a 'f' in un'altra variabile rappresentata come f_output che stamperà l'uscita come colonna-major.

Alla fine, abbiamo un'istruzione stampata di F_ARR come array di input e array F_Output come array di output.

Importa Numpy come NP
F_arr = np.Array ([[11, 32, 23], [-4, 58, 88]])
F_output = f_arr.Ravel ('f')
Stampa ("Visualizzazione dell'array di input: \ n", f_arr)
Stampa ("Visualizzazione dell'array di output: \ n", f_output)

Di seguito viene visualizzato l'output dal codice sopra nell'array colonna-major.

Esempio 4:

Questo esempio utilizza "C" come parametro dell'ordine che convertirà l'array 2D in un array 1D che è riga-Major. Abbiamo creato un array 2D che trasporta valori diversi in esso rappresentati come variabile "x_array".

Dopo questo abbiamo l'X_ARRAY.funzione ravel () prendendo il parametro dell'ordine come 'c' che ci darà un array 1D come riga-major.

Importa Numpy come NP
x_array = np.array ([[0, 4, 8], [1, 5, 9]])
y_array = x_array.Ravel ('C')
print ("Questo è un array di input: \ n", x_array)
Stampa ("Questo è un array di output: \ n", y_array)

Come parametro dell'ordine impostata su "C" che ci dà un array di output in un array appiattito.

Esempio 5:

In questo esempio, prendi il parametro dell'ordine e impostalo come 'k' per sapere come funziona questo parametro dell'ordine. Per questo, dobbiamo prendere un array 2D e archiviare il valore dell'array in una variabile "k_array" da una funzione di array.

Quindi chiamando un k_arr.Ravel () funzionare e passare un ordine impostato come 'k' come argomento che restituirà una riga di riga singola da un array 2D. Possiamo vedere l'array di input e derivare da un array con l'ordine impostato come 'k' tramite un'istruzione di stampa. Abbiamo stampato gli array.

Importa Numpy come NP
k_array = np.Array ([[4, 14, 44], [5, 15, 55]])
k_output = k_array.Ravel ('K')
print ("Ecco l'array di input: \ n", k_array)
print ("Ecco l'array di output: \ n", k_output)

Finalmente, abbiamo ottenuto l'array di uscita come un array appiattito. Abbiamo emetto lo screenshot di seguito dal codice sopra.

Esempio 6:

L'ultimo esempio è quello di usare il rimodella con lo scambio di assi. Implementiamo questo esempio questa volta; Abbiamo impostato l'intervallo dell'array su un valore 10 da un NP.Chiamata Arange (). Aiuterà nella funzione Reshape (). Poiché la funzione Reshape () rimodellerà il numero di dimensioni senza avere una modifica dei dati.

Abbiamo anche chiamato funzione swapaxes () che scambierà l'asse da 0 a 1, quindi abbiamo memorizzato NP.funzione ravel () che prende un array di input e lo ordina come "c" in variabile "p". Abbiamo preso diverse variabili per impostare l'ordine c, k, f come p, q e r. Stampa la variabile che fornirà output diverso per set di ordini diversi.

Importa Numpy come NP
my_array = np.Arange (10).Reshape (2,5).swapaxes (0,1)
p = np.Ravel (my_array, order = 'c')
Q = np.Ravel (my_array, order = 'k')
r = np.Ravel (my_array, order = 'f')
print ("array di output: \ n", my_array)
Stampa ("Array di output di C-Ordine: \ n", P)
stampa ("array di output di k-ordine: \ n", q)
print ("array di output di f_order: \ n", r)

Abbiamo un output diverso di seguito sullo schermo.

Conclusione

Abbiamo una discussione profonda su tutti i parametri dell'ordine della funzione Ravel (). Abbiamo visto come questa funzione restituisce un array appiattito dall'array bidimensionale con un esempio diverso. Spero che queste illustrazioni ti aiuteranno a comprendere il concetto più perfettamente.