Numpy Logical_ y

Al igual que otros marcos e idiomas, Numpy también admite operadores lógicos y sus operaciones como y, etc. En esta guía numpy, discutiremos la operación Numpy "Logical_and". LOGICAL_ y el operador calcula el valor de verdad de A1 y A2 Elementwise. El NP.El método Logical_and () es un método de matriz matemática que se utiliza para calcular la salida de Xi y Yi para cada componente XI de Array1 sobre el elemento Yi de Array2. Nos da la salida en forma de matriz. Para el NP.Función lógica_and () para que funcione, debemos pasarlo a las matrices de entrada de la misma forma

Sintaxis

Esta es la sintaxis para nuestro método.

numpy.Logical_and (x1, x2, out = none, where = true, dtype = none)

Tiene los siguientes parámetros

x1, x2 son las matrices de entrada. Estos dos deben ser de la misma forma, que también será lo mismo que la salida.

afuera es la ubicación donde se almacena la salida. Podemos proporcionar la forma manualmente, de lo contrario, asignará una matriz nueva.

dónde es una condición que es un parámetro opcional. Si la condición es verdadera, la matriz de resultados, que es la matriz de salida, se establecerá en la salida noctur. De lo contrario, la matriz de salida permanecerá en su forma real que mantenga su valor real.

dtype Define el tipo de matriz de salida.

Ejemplo # 01:

Ahora, tomaremos dos matrices con los mismos y algunos valores diferentes. Y el operador devuelve verdadero cuando ambos valores son los mismos o ambas condiciones son verdaderas y devuelven falsas en todos los demás casos. Así es como funciona y el operador. En nuestro ejemplo, también verificaremos si nuestro y el operador, utilizando este método, funcionan de la misma manera o no.

Después de importar con éxito nuestra biblioteca Numpy como NP, hemos asignado valores "1", "1", "0" y "0" a nuestra primera matriz, y "1", "0", "1" y "0 "A nuestra segunda matriz. Realizaremos el operador y en nuestras matrices y veremos la salida imprimiendo nuestra matriz de salida que hemos inicializado por nosotros mismos como nuestra tercera matriz. Ejecutaremos nuestro código:

importar numpy como np
arr_x = [1, 1, 0, 0]
arr_y = [1, 0, 1, 0]
arr_z = np.Logical_and (arr_x, arr_y)
Imprimir (ARR_Z)

El siguiente es el resultado que obtendremos de nuestro código. En esta salida, podemos ver que la función ha devuelto la salida como verdadera y falsa. Solo ha devuelto verdadero donde los valores de ambas matrices eran los mismos. Entonces, mediante la salida, podemos concluir que las funciones de operador lógico numpy funcionan de la misma manera que cualquier otro operador y nos dan la salida exacta.

Ejemplo # 02:

Antes de pasar al siguiente ejemplo, dejemos una cosa clara: los ceros y los que no son solo los valores utilizados durante las operaciones lógicas. En algunos casos, también usamos valores verdaderos y falsos donde verdadero es igual a "1" y falso es igual a "0". Ahora en el ejemplo a continuación, pasaremos los valores verdaderos y falsos a nuestras matrices de entrada y realizaremos la operación lógica y en esas matrices y almacenaremos el resultado en la tercera matriz. Al imprimir la tercera matriz, veremos si nuestro operador funciona en valores como Verdadero y Falso o si solo funciona en cero y uno de los valores.

importar numpy como np
arr_a = [falso, falso, verdadero, verdadero]
arr_b = [falso, true, falso, true]
arr_c = np.Logical_and (arr_a, arr_b)
Imprimir (ARR_C)

Primero importemos nuestra biblioteca Numpy, la razón es que vamos a realizar algunas operaciones proporcionadas por la biblioteca Numpy. En la siguiente línea, declararemos dos matrices a las que almacenaremos los valores de la matriz como verdaderos y falsos como explicamos anteriormente. Después de declarar ambas matrices que son "ARR_A" y "ARR_B", declararemos otra matriz que mantendrá el resultado de nuestro y operación realizada entre las matrices pasadas a nuestra operación lógica y. Al final, imprimiremos la matriz resultante usando la instrucción print ().

Aquí, el método nos ha devuelto la salida y es la salida exacta que esperábamos. Solo se devuelve verdadero donde ambas matrices son verdaderas. Así es como el operador y el operador también funciona en realidad. Entonces, podemos implicar que no solo funciona en 0 y 1, sino que también funciona en verdadero y falso.

Ejemplo # 03:

Después de trabajar en el operador Logical_and surgirá una pregunta en su mente: ¿Qué sucede si no pasamos las matrices de la misma forma a nuestro operador?? Para responder a su pregunta, hemos hecho este ejemplo en el que hemos pasado dos matrices de diferentes formas a nuestra función para ver qué salida regresa nuestra función en ese caso. Hemos declarado dos matrices, una con "4" elementos en él y el otro con "5" elementos para que no tengan la misma forma. Hemos almacenado la salida en la tercera matriz y la imprimiremos para verificar la salida. Ahora, ejecutaremos nuestro código para verificar qué sucede.

importar numpy como np
small_arr = [0, 0, 1, 1]
big_arr = [1, 0, 1, 0, 1]
out_arr = np.Logical_and (Small_arr, Boat_arr)
imprimir (out_arr)

Ahora, primero importe la biblioteca Numpy y luego defina dos matrices con diferentes tamaños nombrándolos "Small_arr" que contiene "4" elementos y "grande_arr" que contiene "5" elementos. Luego, definiremos otra matriz que contendrá la matriz resultante después de realizar la lógica y la operación. Por último, imprimiremos la matriz resultante usando la instrucción print ().

Desafortunadamente, el código nos ha dado un error. Pero con este ejemplo, hemos aprendido que solo podemos pasar matrices con la misma forma a nuestra función; De lo contrario, dará un error. Si leemos la última línea de error, podemos entender que el sistema nos dice que no podemos transmitir las formas 4 y 5 juntas. Los 4 y 5 son el número de elementos que hemos pasado a nuestro Small_arr y Large_arr respectivamente.

Conclusión

Hemos aprendido sobre el NP NP.Método Logical_and () en esta guía. Hemos discutido con qué facilidad podemos realizar operaciones lógicas en nuestras matrices con la ayuda del NP.Logical_and () función de numpy. También mostramos cómo se comporta el sistema cuando lo pasamos la matrices de diferentes formas. Hemos aplicado el parámetro "dónde" a nuestra función en esta guía que nos ayuda mucho a comprender el concepto.