Operações de matriz Numpy

Hoje, aprendemos quais operações executamos em matrizes Numpy e como executar essas operações. Este tutorial será útil se você já estiver familiarizado com o básico do Python e quiser começar a usar Numpy.

Numpy é a Biblioteca Avançada de Programação Python. A principal característica do Numpy é que ela se oferece para trabalhar com matrizes multidimensionais e uma velocidade excelente, bem como capacidades para interagir com essas matrizes.

Numpy é usado para executar as operações lógicas e matemáticas. Podemos executar várias operações em matrizes que são:

• Operaçoes aritimeticas
• Operações lógicas
• Operações de comparação

Operaçoes aritimeticas

Podemos executar várias operações em matrizes Numpy, onde podemos adicionar, subtrair, multiplicar e dividir as duas matrizes; Essas operações são chamadas de operações aritméticas. Pelo menos duas matrizes são necessárias para as operações aritméticas e devem ter o mesmo tamanho ou seguir as regras para transmissão de matrizes.

Sintaxe:

Vamos ver a sintaxe da operação aritmética da biblioteca Python, Numpy. Aqui, primeiro escrevemos o nome da biblioteca que usamos que é "Numpy". Em seguida, chamamos a função da operação aritmética que queremos executar como add (), sub (), mul () e div (). E então, passamos os parâmetros para essa função.

Exemplo:

Vamos passar para o exemplo de operações aritméticas que estão adicionando, subtraindo, multiplicando e dividindo. Vamos ver como implementar essas operações em matrizes Numpy. Abra seu compilador Python para a implementação do Programa Aitmético.

O primeiro e básico passo é importar a biblioteca do Python, que é Numpy. Primeiro, escrevemos a palavra -chave "importar" que mostra que vamos importar a biblioteca. Então, escrevemos o nome da biblioteca que é "Numpy". E então, escrevemos o pseudônimo de Numpy, "np". Na terceira linha de código, usamos a instrução print () para que possamos exibir a mensagem de que vamos implementar as operações aritméticas. Então, na próxima linha, chamamos a função Numpy Arange () para a criação de Array1 e passamos os argumentos.

O primeiro argumento é o elemento inicial da matriz1. O segundo argumento é o elemento de parada, mas lembre -se de que não podemos incluir o elemento de parada no Array1. E o terceiro argumento é quanta diferença devemos ter para obter o próximo elemento da matriz1; dtype significa que tipo de dados queremos (como int, flutuação, etc.) para a matriz1.

Nesta linha, usamos outra função aplicando a concatenação que é a função Reshape (). Esta função é usada para moldar a matriz1. Aqui, temos 2 linhas e 4 colunas da matriz. Em seguida, criamos outra matriz que é o Array2 usando a mesma função que usamos para o Array1, mas não usamos a função Reshape () na Array 2 porque não queremos moldar a matriz. Após a criação de ambas as matrizes, imprimimos o Array1 e o Array2 usando a instrução print () e passamos as matrizes.

importar numpy como np
Print ("Implementação de operações Arthimatic: \ n")
Array1 = np.Arange (40, 96, 7, dtype = int).remodelar (2,4)
print ("A primeira matriz é", Array1.ndim, "Dimensional: \ n", Array1)
Array2 = np.Arange (5, 20, 4, Dtype = int)
print ("\ nA segunda matriz é", Array2.ndim, "Dimensional: \ n", Array2)
add = np.Add (Array1, Array2)
print ("\ nadding as duas matrizes: \ n", add)
sub = np.subtraia (Array1, Array2)
print ("\ nsubtracting as duas matrizes: \ n", sub)
Mul = np.Multiply (Array1, Array2)
print ("\ nmultiplying the Two Award: \ n", Mul)
div = np.Divide (Array1, Array2)
print ("\ ndiviving as duas matrizes: \ n", div)

Depois de criar ambos os matrizes, chamamos as funções aritméticas uma a uma por uma. Primeiro, chamamos a função add () para a adição de Ambos Array1 e Array2. Em seguida, chamamos a função sub () para que possamos subtrair o Array2 da Array1. Em seguida, chamamos a função MUL () para a multiplicação de ambas as matrizes. Por fim, temos a função div () que divide as duas matrizes e temos o quociente. Em seguida, imprimimos todas as funções usando a instrução print () e passamos os parâmetros.

Aqui está a saída deste exemplo explicado em que obtemos o resultado de operações aritméticas:

Operações lógicas

Agora, vamos para a segunda operação da biblioteca Numpy, que é a operação lógica. Usamos a operação lógica para obter o verdadeiro valor das matrizes numpy, como os valores da verdade booleana. Implementamos as operações lógicas por meio de funções Numpy que são funções lógicas_and (), lógico_or () e lógico_not ().

Sintaxe:

Vejamos o estilo de escrita da operação lógica da Biblioteca Python, Numpy. Primeiro, escrevemos o nome da biblioteca que usamos neste programa que é Numpy. Em seguida, escrevemos o nome da função do operador lógico que usamos e depois passamos os argumentos.

Exemplo:

Vamos começar a implementar o exemplo das operações lógicas do Python-Numpy, que são LOGICAL_AND (), LOGICAL_OR e LOGICAL_NOT.

Nós importamos a biblioteca de Python que usamos neste programa que é Numpy. Em seguida, criamos a matriz aleatória unidimensional usando a função Numpy Randn () e passamos dois parâmetros. O primeiro parâmetro mostra o número de linhas da matriz. O segundo parâmetro mostra o número de colunas da matriz. Na sexta linha de código, chamamos a instrução print () e passamos a função logical_and (). Então, na próxima linha, passamos a função logical_or () e depois as funções LOGICAL_NOT ().

importar numpy como np
arr = np.aleatório.Randn (2, 2)
print ("A matriz aleatória é: \ n", arr)
print ('\ n o resultado de e é: \ n', np.Logical_and (arr> 0, arr, < 0.5))
print ('\ n o resultado de ou é: \ n', np.Logical_or (arr < 0, arr > 0.5))
print ('\ n O resultado de não é: \ n', np.Logical_not (arr> 0))

Aqui está a saída do trecho de código mencionado anteriormente. Como você pode ver, obtemos a matriz aleatória usando a função Randn () e aplicamos as múltiplas operações lógicas:

Operações de comparação

Agora, temos a terceira operação de matrizes Numpy, que é a operação de comparação. Nesta operação, comparamos a matriz com qualquer número e verificamos se é verdadeiro ou falso. Realizamos as operações de comparação múltipla em matrizes numpy que são>, = = =, <=, =, != etc.

Sintaxe:

Aqui está a sintaxe das operações de comparação em matrizes Numpy:

Exemplo:

Agora, vamos para o exemplo de operações de comparação. Primeiro, importamos a biblioteca Python, que é Numpy. Em seguida, criamos uma matriz Numpy aleatória usando a função Randint () para criar a matriz aleatória inteira de 1 a 20. O tamanho da matriz é de 1 linha e 3 colunas. Em seguida, chamamos a instrução print () e passamos as operações de comparação nela. As funções que desempenhamos neste exemplo são maiores (), Grande_equal (), menos (), Less_equal (), igual () e não_equal ().

importar numpy como np
arr = np.aleatório.Randint (1, 8, tamanho = (1, 3))
print ("A matriz de entrada é: \ n", arr)
print ("\ nGreater do que é: \ n", np.maior (arr, 5))
print ("\ nGreater ou igual a 5: \ n", np.maior_equal (arr, 5))
print ("\ nless que 5: \ n", np.menos (arr, 5))
print ("\ nless que ou igual a 5: \ n", np.LESS_EQUAL (ARR, 5))
print ("\ nequal a 5: \ n", np.igual (arr, 5))
print ("\ não igual a 5: \ n", np.não_equal (arr, 5))

Aqui está a saída das operações de comparação:

Conclusão

Neste artigo, aprendemos quais operações podemos executar em matrizes Numpy, como implementar essas operações em matrizes numpy e quais funções usamos para implementar essas operações de Numpy. Implementamos exemplos de todas as operações de matrizes Numpy e usamos as diferentes funções para criar a matriz nesses exemplos.