Numpy Logical_And

Como outras estruturas e idiomas, Numpy também suporta operadores lógicos e suas operações como e, ou etc. Neste guia Numpy, discutiremos a operação Numpy "Logical_and". O operador lógico_ e calcula o valor da verdade de A1 e A2 Elementwise. O np.O método lógico_and () é um método matemático de matriz que é usado para calcular a saída de xi e yi para cada componente xi de matriz1 referente ao elemento yi de array2. Isso nos dá a saída em um formulário de matriz. Para o NP.Função Logical_and () para funcionar, devemos passá -lo para as matrizes de entrada da mesma forma

Sintaxe

Esta é a sintaxe para o nosso método.

Numpy.Logical_and (x1, x2, out = Nenhum, onde = true, dtype = nenhum)

Tem os seguintes parâmetros

x1, x2 são as matrizes de entrada. Esses dois devem ter a mesma forma, que também serão os mesmos que a saída.

fora é o local onde a saída é armazenada. Podemos fornecer a forma manualmente, caso contrário, alocará uma nova matriz.

onde é uma condição que é um parâmetro opcional. Se a condição for verdadeira, a matriz de resultados que é a matriz de saída será definida para a saída não. Caso contrário, a matriz de saída permanecerá em sua forma real mantendo seu valor real.

dtype define o tipo de matriz de saída.

Exemplo # 01:

Agora, levaremos duas matrizes com o mesmo e alguns valores diferentes. O operador e o operador retorna true quando ambos os valores são iguais ou as duas condições são verdadeiras e retorna falsa em todos os outros casos. É assim que o operador funciona. Em nosso exemplo, também verificaremos se o nosso e o operador, usando esse método, funciona da mesma maneira ou não.

Depois de importar com sucesso nossa biblioteca Numpy como NP, atribuímos valores "1", "1", "0" e "0" à nossa primeira matriz e "1", "0", "1" e "0 ”Para nossa segunda matriz. Vamos realizar o operador em nossas matrizes e veremos a saída imprimindo nossa matriz de saída, que inicializamos por nós mesmos como nossa terceira matriz. Vamos executar nosso 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)

A seguir, é o resultado que obteremos do nosso código. Nesta saída, podemos ver que a função retornou a saída como verdadeira e falsa. Ele só retornou verdadeiro onde os valores de ambos os matrizes eram iguais. Portanto, pela saída, podemos concluir que o operador lógico Numpy funciona funcionam da mesma forma que qualquer outro operador e nos dar a saída exata.

Exemplo # 02:

Antes de passar para o próximo exemplo, deixe -nos esclarecer uma coisa: os zeros e os não são apenas os valores usados ​​durante operações lógicas. Em alguns casos, também usamos valores verdadeiros e falsos, onde verdadeiro é igual a "1" e falso é igual a "0". Agora, no exemplo abaixo, passaremos os valores verdadeiros e falsos para nossas matrizes de entrada e realizaremos a operação Logical_and nessas matrizes e armazenaremos o resultado na terceira matriz. Ao imprimir a terceira matriz, veremos se nosso operador trabalha em valores como verdadeiro e falso.

importar numpy como np
ARR_A = [false, false, verdadeiro, verdadeiro]
arr_b = [false, verdadeiro, falso, verdadeiro]
ARR_C = NP.Logical_and (ARR_A, ARR_B)
Imprimir (arr_c)

Vamos primeiro importar nossa biblioteca Numpy, o motivo é que vamos realizar algumas operações que são fornecidas pela Numpy Library. Na próxima linha, declararemos duas matrizes às quais estaremos armazenando os valores da matriz tão verdadeiros e falsos quanto explicamos acima. Depois de declarar as duas matrizes que são "ARR_A" e "ARR_B", declararemos outra matriz que manterá o resultado de nossa e a operação realizada entre as matrizes passadas para nossa lógica e operação. No final, imprimiremos a matriz resultante usando a instrução print ().

Aqui, o método retornou a nós a saída e é a saída exata que estávamos esperando. Apenas verdade é retornado onde ambas as matrizes são verdadeiras. É assim que o operador funciona na realidade também. Portanto, podemos sugerir que não apenas funciona em 0 e 1, mas também funciona em verdadeiro e falso.

Exemplo # 03:

Depois de trabalhar no operador lógico_ e uma pergunta surgirá em sua mente: o que acontece se não passarmos as matrizes da mesma forma para o nosso operador? Para responder à sua pergunta, fizemos este exemplo no qual passamos duas matrizes de formas diferentes para nossa função para ver qual saída nossa função retorna nesse caso. Declaramos duas matrizes, uma com "4" elementos e o outro com "5" elementos para que eles não tenham a mesma forma. Nós armazenamos a saída na terceira matriz e a imprimiremos para verificar a saída. Agora, vamos executar nosso código para verificar o que acontece.

importar numpy como np
pequeno_arr = [0, 0, 1, 1]
grande_arr = [1, 0, 1, 0, 1]
out_arr = np.Logical_and (small_arr, grande_arr)
print (out_arr)

Agora, primeiro importe a biblioteca Numpy e depois define duas matrizes com diferentes tamanhos nomeando -os "small_arr", que contém "4" elementos e "Large_arr", que contém "5" elementos. Em seguida, definiremos outra matriz que conterá a matriz resultante depois de executar a lógica e operação. Por fim, imprimiremos a matriz resultante usando a instrução print ().

Infelizmente, o código nos deu um erro. Mas, com este exemplo, aprendemos que só podemos passar matrizes com a mesma forma para a nossa função; Caso contrário, ele dará um erro. Se lermos a última linha de erro, podemos entender que o sistema está nos dizendo que não podemos transmitir formas 4 e 5 juntas. Os 4 e 5 são o número de elementos que passamos para o nosso Small_arr e Large_arr, respectivamente.

Conclusão

Aprendemos sobre o Numpy NP.Método Logical_and () neste guia. Discutimos com que facilidade podemos executar operações lógicas em nossas matrizes com a ajuda do NP.Logical_and () Função de Numpy. Também mostramos como o sistema se comporta quando passamos as matrizes de diferentes formas. Aplicamos o parâmetro "onde" à nossa função neste guia, o que nos ajuda muito a entender o conceito.