Introdução ao NumPy

NumPy

O NumPy é um pacote para computação científica e algebra linear para Python.

Usando Numpy

No Python, todos os pacotes externos, assim como no R precisam ser importados. Executando o comando abaixo importamos essa biblioteca.

import numpy as np

Observe que ‘np’ é usado para simplificar e evitar a repetição de ‘numpy’ o tempo todo. Você poderia escolher qualquer outro nome. Numpy tem muitas funções e capacidades integradas. Nós não vamos cobrir todos aqui, mas vamos nos concentrar nas listas e também ver um pouco de geração de números.

Numpy Array ou listas NumPy

A partir de agora irei chamar Numpy Array sempre que me referir a listas Numpy. Os NumPy Array são a principal maneira de usar o Numpy. Numpy Array essencialmente vêm em dois formatos: vetores e matrizes. Vetores são essencialmente de 1-dimensão e matrizes são 2-dimensões (mas você deve notar que um vetor ainda pode ter apenas uma linha ou uma coluna).

Criando NumPy Arrays

A partir de uma Lista

Criaremos um NumPy array diretamente de uma lista

my_list = [10,20,30]  ##lista padrão do python
my_list
[10, 20, 30]
np_list =np.array(my_list)  # Um  NumPy Array simples pode ser definida fornecendo uma única lista de números como um argumento.
print( np_list)
[10 20 30]
type(np_list)   ##classe de Numpy Array é numpy.ndarray
numpy.ndarray
matrix_2d = [[1,2,3],[4,5,6]]
matrix_2d
[[1, 2, 3], [4, 5, 6]]
np_matrix_2d = np.array(matrix_2d)
print( np_matrix_2d)
[[1 2 3]
 [4 5 6]]

Algumas formas de rápidas de gerar NumPy Array

Existem muitas formas incorporadas de gerar NumPy Array

arange

Retorna valores uniformemente espaçados dentro de um determinado intervalo.

np.arange(0,15)  ##gera um NumPy array de 15 elelmentos de 0 a 14
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])
np_arange=np.arange(0,15)  ##armazenar oa lsiat criada
type(np_arange)  ##observe que ele é um NumPy arraY
numpy.ndarray
print(np_arange)
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
np.arange(0, 11, 2) #Range 0 a 10 com step 2 
array([ 0,  2,  4,  6,  8, 10])

O linspace é semelhante ao arange, mas usa um número de amostras em vez do tamanho do passo.

np.linspace(0, 10, 50)  # aqui foi gerado 50 valores entre 0 e 10
array([  0.        ,   0.20408163,   0.40816327,   0.6122449 ,
         0.81632653,   1.02040816,   1.2244898 ,   1.42857143,
         1.63265306,   1.83673469,   2.04081633,   2.24489796,
         2.44897959,   2.65306122,   2.85714286,   3.06122449,
         3.26530612,   3.46938776,   3.67346939,   3.87755102,
         4.08163265,   4.28571429,   4.48979592,   4.69387755,
         4.89795918,   5.10204082,   5.30612245,   5.51020408,
         5.71428571,   5.91836735,   6.12244898,   6.32653061,
         6.53061224,   6.73469388,   6.93877551,   7.14285714,
         7.34693878,   7.55102041,   7.75510204,   7.95918367,
         8.16326531,   8.36734694,   8.57142857,   8.7755102 ,
         8.97959184,   9.18367347,   9.3877551 ,   9.59183673,
         9.79591837,  10.        ])

Função para gerar zeros: np.zeros

np.zeros(3)  # vetor
array([ 0.,  0.,  0.])
np.zeros((5,5))  #matriz 5x5
array([[ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.]])

Função para gerar 1’s:np.one

np.ones(4)   # vetor de 4 elementos
array([ 1.,  1.,  1.,  1.])
np.ones((4,3)) # matriz 4 x 3
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.],
       [ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])

Função para gerr matriz identidade

print('Matriz Identidade = ', np.eye(4)) #Criar matriz identidade
Matriz Identidade =  [[ 1.  0.  0.  0.]
 [ 0.  1.  0.  0.]
 [ 0.  0.  1.  0.]
 [ 0.  0.  0.  1.]]

Alguns atributos

a = np.array([[1, 2, 3], [4, 5, 6],[7,8,9]])  #numpy array usado nos exemplo

# Para saber o formato do NumPy array use 'shape'
print('shape = ', a.shape)

shape =  (3, 3)

# Para saber o numero de dimensoes use 'n.dim:.
print('dimensão = ', a.ndim)


dimensão =  2
# descrever tipo de elementos do array use 'dtype.name'
print('tipo = ', a.dtype.name)
tipo =  int32
# o tamanho em bytes de cada elemento do array.
print('tamanho em bytes = ', a.itemsize)
tamanho em bytes =  4
# o total do numero de elementos do array.
print('numero total de elementos = ', a.size)
numero total de elementos =  9
#Use type para verificar a classe
print('tipo = ', type(a))
tipo =  <class 'numpy.ndarray'>
Números aleatórios

NumPy possui várias formas de criar números aleatórios tendo como base a função random: ##### rand Numpy.random.rand cria um array com uma da forma e a preenche com valores aleatórios de uma distribuição uniforme no intervalo [0, 1).

np.random.rand(1)  # retorna uma amostra com um vetor aleatorio
array([ 0.37968688])
np.random.rand(3)  #retorna amostra com três vetores alatorios
array([ 0.65047196,  0.19279372,  0.81631168])
np.random.rand(5,5) # retorna uma amostra em forma de matriz 5x5
array([[ 0.8472542 ,  0.34438088,  0.45256742,  0.40567087,  0.46506589],
       [ 0.40712275,  0.05849472,  0.32014203,  0.21508325,  0.62038965],
       [ 0.82596773,  0.29950452,  0.29034161,  0.0141033 ,  0.23191333],
       [ 0.01414772,  0.88884345,  0.28485843,  0.86993334,  0.58552488],
       [ 0.43318771,  0.76587123,  0.98934418,  0.00782164,  0.17773894]])
randn

Retornar uma amostra (ou amostras) da distribuição “normal padrão”. Ao contrário do rand, que é uniforme:

np.random.randn(4)
array([-0.91926231,  1.23764068,  0.18680237,  1.91195893])
np.random.randn(4,5)
array([[ 1.59330483, -0.74653643,  0.5311757 , -0.53861642, -0.611056  ],
       [ 0.27707078, -1.29064321,  0.05725259, -0.74814818,  0.35700817],
       [-0.54676309, -1.04873183, -0.76461313, -2.09812475, -0.48114056],
       [ 1.63077661, -0.62706014, -1.31865117,  0.60046109,  0.68462824]])
randint

Retorna números inteiros aleatórios incluindo o número inferior e excluindo o superior.

print('um unico numero inteiro entre 24 e 110 = ', np.random.randint(24, 110))   # por padrão só retorna 1 valor
um unico numero inteiro entre 24 e 110 =  41
print('10 numeros inteiros entre 24 e 110 = ', np.random.randint(24, 110, 10))
10 numeros inteiros entre 24 e 110 =  [ 84  91  70 108  67  27  92  52  53  82]

Mudando a formula de NumPy Array

Remodelar NumPy Array pode ser feito através do método “reshape”

#Definimos um array de shape(forma) (1, 25)
arr = np.arange(0, 25)
print('Array com dimensão (1, 25) = ', arr)
Array com dimensão (1, 25) =  [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]
#Alterando as dimensões de (1, 25) para (25, 1).
mod_array = arr.reshape(25, 1)
print('Array com dimensão (25, 1) = ', mod_array)
Array com dimensão (25, 1) =  [[ 0]
 [ 1]
 [ 2]
 [ 3]
 [ 4]
 [ 5]
 [ 6]
 [ 7]
 [ 8]
 [ 9]
 [10]
 [11]
 [12]
 [13]
 [14]
 [15]
 [16]
 [17]
 [18]
 [19]
 [20]
 [21]
 [22]
 [23]
 [24]]

Operações matemáticas com NumPy

arr = np.arange(0, 10)
arr2 = np.array([2,4,6,7,8,9,11,34,6,78])
print(arr)
[0 1 2 3 4 5 6 7 8 9]
print(arr2)
[ 2  4  6  7  8  9 11 34  6 78]
arr+2   # soma 2 a cada elemento
array([ 2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
arr*3 # multiplica por 3
array([ 0,  3,  6,  9, 12, 15, 18, 21, 24, 27])
arr2-3 # subtrai 3
array([-1,  1,  3,  4,  5,  6,  8, 31,  3, 75])
#soma elementos correspondetes
print('arr + arr2 = ', arr + arr2)
arr + arr2 =  [ 2  5  8 10 12 14 17 41 14 87]
#subtração
print('arr - arr2 = ', arr - arr2)

arr - arr2 =  [ -2  -3  -4  -4  -4  -4  -5 -27   2 -69]
#multiplicação
print('arr x arr2 = ', arr * arr2)
arr x arr2 =  [  0   4  12  21  32  45  66 238  48 702]
#divisão
print('arr / 4 = ', arr / 4)
arr / 4 =  [ 0.    0.25  0.5   0.75  1.    1.25  1.5   1.75  2.    2.25]

Usando funções matematicas no array:

arr = np.arange(0, 10)

#Raiz quadrada arr
print('Raiz quadrada de arr = ', np.sqrt(arr))
Raiz quadrada de arr =  [ 0.          1.          1.41421356  1.73205081  2.          2.23606798
  2.44948974  2.64575131  2.82842712  3.        ]
#Exponencial de arr
print('Exponencial de arr = ', np.exp(arr))

Exponencial de arr =  [  1.00000000e+00   2.71828183e+00   7.38905610e+00   2.00855369e+01
   5.45981500e+01   1.48413159e+02   4.03428793e+02   1.09663316e+03
   2.98095799e+03   8.10308393e+03]
#Sine of arr
print('Sine of arr = ', np.sin(arr))

Sine of arr =  [ 0.          0.84147098  0.90929743  0.14112001 -0.7568025  -0.95892427
 -0.2794155   0.6569866   0.98935825  0.41211849]
#Log of arr
print('Log of arr = ', np.log(arr))  # observe que na primeira entrada ocorreu erro por não existir log de zero

Log of arr =  [       -inf  0.          0.69314718  1.09861229  1.38629436  1.60943791
  1.79175947  1.94591015  2.07944154  2.19722458]


C:\Users\pcnov\Documents\davi\lib\site-packages\ipykernel\__main__.py:2: RuntimeWarning: divide by zero encountered in log
  from ipykernel import kernelapp as app

Acessando elementos (slicing)

import numpy as np
arr = np.arange(0, 25)
print('arr = ', arr)

#Para acessar um elemento usamos o indice = n-1 lembrando que o python começa a contar do zero
print('9º elemento de arr = ', arr[8])
arr =  [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]
9º elemento de arr =  8

Podemos acessar vários elementos ao mesmo tempo

#Acesssar elementos da posição 1 a 6
arr[:5]
array([0, 1, 2, 3, 4])
arr[1:5]
array([1, 2, 3, 4])
arr[-1] # indice negativo começa do ultimo valor
24
arr[::-1]
array([24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,  9,  8,
        7,  6,  5,  4,  3,  2,  1,  0])

Era isso que queria mostrar. Espero que tenha aprendido um pouco sobre essa biblioteca do python. Até a próxima!

Keep calm and analysing data!