Numpy logical_and

Come altri framework e lingue, Numpy supporta anche operatori logici e le loro operazioni come e, o ecc. In questa guida Numpy, discuteremo dell'operazione Numpy "Logical_and". Logical_ e l'operatore calcola il valore di verità di A1 e A2 Elementwise. Il NP.Il metodo logical_and () è un metodo matematico che viene utilizzato per calcolare l'output di xi e yi per ogni componente xi di array1 per quanto riguarda l'elemento yi di array2. Ci dà l'output in un forma di array. Per il np.logical_and () funzione per funzionare, dobbiamo passarlo alle matrici di input della stessa forma

Sintassi

Questa è la sintassi per il nostro metodo.

numpy.logical_and (x1, x2, out = nessuno, dove = true, dtype = nessuno)

Ha i seguenti parametri

x1, x2 sono gli array di input. Questi due devono essere della stessa forma, che sarà anche gli stessi dell'uscita.

fuori è la posizione in cui viene memorizzata l'output. Possiamo fornire la forma manualmente altrimenti sta allocando un nuovo array.

Dove è una condizione che è un parametro opzionale. Se la condizione è vera, l'array di risultati che è l'array di out verrà impostato su un output di nonni. Altrimenti, l'array di output rimarrà nella sua forma effettiva con il suo valore effettivo.

dtype Definisce il tipo di array di output.

Esempio # 01:

Ora prenderemo due array con lo stesso e alcuni valori diversi. L'operatore e l'operatore restituisce vero quando entrambi i valori sono uguali o entrambe le condizioni sono vere e restituiscono false in tutti gli altri casi. Ecco come e l'operatore funziona. Nel nostro esempio, controlleremo anche se il nostro e l'operatore, usando questo metodo, funzionano allo stesso modo o no.

Dopo aver importato correttamente la nostra libreria numpy come NP, abbiamo assegnato valori "1", "1", "0" e "0" al nostro primo array e "1", "0", "1" e "0 "Al nostro secondo array. Eseguiremo l'operatore e gli operatori sui nostri array e vedremo l'output stampando il nostro array di output che abbiamo inizializzato da noi stessi come il nostro terzo array. Eseguiremo il nostro codice:

Importa Numpy come NP
arr_x = [1, 1, 0, 0]
arr_y = [1, 0, 1, 0]
arr_z = np.logical_and (arr_x, arr_y)
stampa (arr_z)

Quello che segue è il risultato che otterremo dal nostro codice. In questo output, possiamo vedere che la funzione ha restituito l'output come vero e falso. È restituito vero solo dove i valori di entrambi gli array erano gli stessi. Quindi, con l'output, possiamo concludere che l'operatore logico numpy funziona come qualsiasi altro operatore e ci danno l'esatto output.

Esempio # 02:

Prima di passare all'esempio successivo, chiamiamo una cosa chiara: gli zeri e quelli non sono solo i valori utilizzati durante le operazioni logiche. In alcuni casi, utilizziamo anche valori vere e false dove il vero è uguale a "1" e false è uguale a "0". Ora nell'esempio seguente, passeremo i valori veri e falsi ai nostri array di input e eseguiremo l'operazione Logical_E e su quegli array e memorizzeremo il risultato nel terzo array. Stampando il terzo array, vedremo se il nostro operatore funziona su valori come true e falso o se funziona solo su zero e uno valori.

Importa Numpy come NP
arr_a = [false, false, vero, vero]
arr_b = [false, vero, falso, vero]
arr_c = np.logical_and (arr_a, arr_b)
stampa (arr_c)

Per prima cosa importa la nostra biblioteca Numpy, il motivo è che eseguiremo alcune operazioni fornite dalla Biblioteca Numpy. Nella riga successiva, dichiareremo due array a cui memorizzeremo i valori dell'array come vero e falso come spieghiamo sopra. Dopo aver dichiarato entrambi gli array che sono "arr_a" e "arr_b", dichiareremo un altro array che manterrà il risultato del nostro e l'operazione eseguita tra le array passate alla nostra logica e operativa. Alla fine, stamperemo l'array risultante utilizzando l'istruzione print ().

Qui, il metodo ci ha restituito l'output ed è l'output esatto che ci aspettavamo. Solo vero viene restituito dove entrambi gli array sono veri. Ecco come funziona anche l'operatore e. Quindi, possiamo implicare che non solo funziona su 0 e 1 ma funziona anche su vero e falso.

Esempio # 03:

Dopo aver lavorato sull'operatore logical_ e si presenterà nella tua mente: cosa succede se non passiamo le matrici della stessa forma al nostro operatore? Per rispondere alla tua domanda, abbiamo fatto questo esempio in cui abbiamo superato due matrici di diverse forme alla nostra funzione per vedere quale output la nostra funzione ritorna in quel caso. Abbiamo dichiarato due array, uno con elementi "4" in esso e l'altro con elementi "5" in esso in modo che non abbiano la stessa forma. Abbiamo archiviato l'output nel terzo array e lo stamperemo per controllare l'output. Ora eseguiremo il nostro codice per controllare cosa succede.

Importa Numpy come NP
Small_arr = [0, 0, 1, 1]
grande_arr = [1, 0, 1, 0, 1]
out_arr = np.logical_and (small_arr, big_arr)
Stampa (out_arr)

Ora, prima importa la libreria numpy e quindi definisci due array con dimensioni diverse che li nominano "Small_arr" che contiene elementi "4" e "Large_arr" che contiene elementi "5". Quindi, definiremo un altro array che conterrà l'array risultante dopo aver eseguito il logico e il funzionamento. Infine, stamperemo l'array risultante utilizzando l'istruzione print ().

Sfortunatamente, il codice ci ha dato un errore. Ma con questo esempio, abbiamo imparato che possiamo passare solo array con la stessa forma alla nostra funzione; Altrimenti, darà un errore. Se leggiamo l'ultima riga di errore, possiamo capire che il sistema ci sta dicendo che non possiamo trasmettere forme 4 e 5 insieme. I 4 e 5 sono il numero di elementi che abbiamo passato rispettivamente al nostro piccolo_arr e larg_arr.

Conclusione

Abbiamo imparato a conoscere il Numpy NP.metodo logical_and () in questa guida. Abbiamo discusso di quanto facilmente possiamo eseguire operazioni logiche sui nostri array con l'aiuto del NP.logical_and () funzione di numpy. Abbiamo anche mostrato come si comporta il sistema quando lo passiamo le matrici di diverse forme. Abbiamo applicato il parametro "dove" alla nostra funzione in questa guida che ci aiuta molto a comprendere il concetto.