Numpy é uma biblioteca Python popular para computação científica e análise de dados. Ele fornece um poderoso objeto de matriz, juntamente com muitas funções e métodos úteis para manipular e processar dados numéricos. Nesta postagem do blog, compartilharei algumas das operações numpy essenciais que podem ajudá-lo a escrever um código mais rápido e limpo. Seja você um iniciante ou um especialista, espero que encontre algo útil nesta folha de dicas numpy.

Instalação

Se você não possui o numpy, primeiro precisa instalá-lo. Você pode instalá-lo em dois dias:

Usando pip

pip install numpy

Primeiro, ative seu ambiente anaconda e use o seguinte comando:

conda install -c anaconda numpy

Antes de fazer qualquer operação usando numpy, precisamos importá-lo.

import numpy as np

Vamos começar do básico e aprender como criar valores escalares da classe numpy.

# int type

python_int = 2
numpy_int = np.int32(2)
print(type(python_int)) # ---> <class 'int'>
print(type(numpy_int)) # ---> <class 'numpy.int32'>

# float type

python_float = 2.5
numpy_float = np.float32(2.5)
print(type(python_float)) # ---> <class 'float'>
print(type(numpy_float)) # ---> <class 'numpy.float32'>

Agora, é hora de passar para Arrays ou Lists.

Matriz 1-D

Vamos agora criar um array 1-D usando o array()método numpy.

# creating an 1-D array of int type

one_d_array_int = np.array([1,2,3]) 
print(one_d_array_int) # ---> output : [1 2 3]

# creating an 1-D array of float type

one_d_array_float = np.array([1.5,2.5,3.5])
print(one_d_array_float) # ---> output : [1.5 2.5 3.5]

Vamos agora criar um array 2-D usando o array()método numpy.

# 2-D int array

two_d_array_int = np.array([
                [1,2,3],
                [4,5,6],
                [7,8,9]
               ])
print(two_d_array_int) # ---> [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# 2-D float array

two_d_array_float= np.array([
                [1.1,2.1,3.0],
                [4.1,5.1,6.1],
                [7.1,8.1,9.1]
               ])
print(two_d_array_float) # ---> [[1.1, 2.1, 3.0], [4.1, 5.1, 6.1], [7.1, 8.1, 9.1]]

Agora, vamos aprender como você obtém a dimensão de qualquer array.

# If the array is a 1-D array, then it'll return 1
print(one_d_array_int.ndim) # ---> output : 1

# If the array is a 2-D array, then it'l return 2
print(two_d_array_int.ndim) # ---> output : 2

print(one_d_array_int.shape) # ---> output : (3,)


print(two_d_array_int.shape) # ---> output : (3, 3)

Obter o tipo de dados de uma matriz

print(one_d_array_int.dtype) # ---> output : dtype('int32')

Manipulando Elementos de um Array

Vamos criar um novo array e então vamos realizar operações neste novo array.

a = np.array([[1,2,3,4,5,6,7],[8,9,10,11,12,13,14]])
print(a) # ---> output : [[ 1  2  3  4  5  6  7]
#                         [ 8  9 10 11 12 13 14]]

Digamos que queremos acessar o terceiro elemento das primeiras linhas.

# accessing 1st row's 3rd element
print(a[0,2]) # ---> output : 3

Lembre-se, numpy também segue a indexação baseada em 0 e devido a isso, se quisermos obter a primeira linha, precisamos escrever 0 e não 1 e o mesmo vale para o valor da coluna se precisarmos do terceiro elemento, então escreveremos 2 e não 3.

Acesse apenas uma linha ou coluna específica

# accessing only the first row
print(a[0,:]) # ---> output : [1 2 3 4 5 6 7]

# accessing only the second column
print(a[:,1]) # ---> output : [2 9]

# [startindex:endindex:stepsize]
print(a[0, 1:-1:2]) # ---> output : [2 4 6]

Alterando o valor do elemento

a[0,2] = 99
print(a) # ---> output : [[ 1  2 99  4  5  6  7]
#                         [ 8  9 10 11 12 13 14]]

Matrizes especiais em Numpy

matriz zero

# creating a zero matrix of shape(2,3)

print(np.zeros((2,3))) # ---> output : [[0. 0. 0.]
 #                                      [0. 0. 0.]
 #                                      [0. 0. 0.]]

Uma Matriz

# All 1s matrix
print(np.ones((3,2,2))) # ---> output : [[[1. 1.]
#                                        [1. 1.]]
#
#                                        [[1. 1.]
#                                         [1. 1.]]
#                                      
#                                        [[1. 1.]
#                                         [1. 1.]]]

# creating ones matrix int type
print(np.ones((3,2,2)), dtype='int32') # ---> output : [[[1 1]
#                                        [1 1]]
#
#                                        [[1 1]
#                                         [1 1]]
#                                      
#                                        [[1 1]
#                                         [1 1]]]

Matriz Aleatória

Se você deseja ter uma matriz com valores aleatórios de uma forma específica, pode usar np.random.rand()o método.

print(np.random.rand(3,3)) # ---> output : [[0.10671372 0.31133182 0.56572354]
#                                           [0.34792672 0.88867917 0.25310353]
#                                           [0.70052117 0.53243035 0.67948057]]

Se você deseja ter uma matriz com valores int aleatórios de uma forma específica, pode usar np.random.randint()o método.

# np.random.randint(start_value,end_value,size)

print(np.random.randint(-1,5, size=(3,3))) # ---> output : [[0 -1 2]
#                                                           [4 2 1]
#                                                           [4 4 0]]

end_valueé exclusivo é por isso que não há 5 na matriz de saída.

Se você não mencionar o start_value, o valor inicial padrão seria 0. Você deve mencionar o end_value.

Matriz de identidade

Se você deseja criar uma matriz de identidade, pode usar np.identity()o método.

print(np.identity(3)) # ---> output : [[1. 0. 0.]
#                                      [0. 1. 0.]
#                                      [0. 0. 1.]]

matriz de transposição

a = np.random.randint(-1,5, size = (2,3)) # creating a random int array
print(a)                                  # output : [[ 2 -1  1]
                                          #           [ 0  1  1]]

print(a.T)                                # output : [[ 2  0]
                                          #           [-1  1]
                                          #           [ 1  1]]

Se você quiser alterar a forma da matriz, pode usar reshape()o método.

a = np.random.randint(-1,5, size = (2,3)) # creating a random int array
print(a)                                  # output : [[ 2 -1  1]
                                          #           [ 0  1  1]]

print(a.reshape(3,2))                     # output : [[ 2  0]
                                          #           [-1  1]
                                          #           [ 1  1]]

print(a.reshape(1,6))                     # output : [[1 2 3 2 2 2]]

Preencha com qualquer número

Se você deseja que um aray seja preenchido com um valor específico, pode usar np.full()o método.

print(np.full((3,3), 14)) # ---> output : [[14 14 14]
#                                          [14 14 14]
#                                          [14 14 14]]

Se você deseja ter uma matriz com um valor específico e deseja que ela tenha a mesma forma de outra matriz, pode usar o np.full_like()método.

# Any other number (full_like)
print(np.full_like(a, 4)) # ---> output : [[4 4 4 4 4 4 4]
#                                          [4 4 4 4 4 4 4]]

Copiar matriz

a = [1,2,3]             # created an array a
b = [10,20,30]          # created an array b
print(a)                # output : [1 2 3]
a = b                   # I'll explain it below
b[1] = 200              # changed b's 2nd element's value to 200
print(a)                # output : [10 200 30] HOW??????

Aqui, os valores de bnão foram copiados para a, em vez disso a, começam a apontar para bo qual, por sua vez, altera os valores de a, mas o problema é que sempre que você alterar algo no bmesmo, será refletido em a.

Matrizes de Empilhamento

Se você deseja empilhar vários arrays vertical ou horizontalmente, pode usar vstack()método ou hstack()método, respectivamente.

# Vertically stacking vectors
v1 = np.array([1,2,3,4])                # created array v1
v2 = np.array([5,6,7,8])                # create array v2

np.vstack([v1,v2,v1,v2])                # output : [[1 2 3 4]
                                        #           [5 6 7 8]
                                        #           [1 2 3 4]
                                        #           [5 6 7 8]]
print(np.hstack([v1,v2]))               # output : [1 2 3 4 5 6 7 8]

a = np.array([1, 2, 3])
print(a.sum())                               # sum of all values of a
print(a.max())                               # max of all elements of a
print(a.mean())                              # return mean of a
print(np.median(a))                          # return median of a
print(np.std(a))                             # return standard deviation of a

Isso conclui nosso blogpost numpy cheatsheet. Esperamos que você tenha achado útil e aprendido alguns novos truques para trabalhar com arrays e matrizes em Python. Numpy é uma biblioteca poderosa e versátil que pode ajudá-lo a realizar vários cálculos numéricos e tarefas de análise de dados. Se você quiser aprender mais sobre numpy, pode conferir a documentação oficial ou alguns dos tutoriais e cursos online disponíveis. Obrigado por ler e codificação feliz!