Módulo 1: Introdução à Lib Numpy

Tutorial

Imports para a Aula



In [ ]:

    
import numpy as np

Tipos Numéricos Auxiliares

Not A Number

Definição



In [ ]:

    
np.nan



In [ ]:

    
-np.nan

Propriedades



In [ ]:

    
np.nan == 0



In [ ]:

    
np.nan > 0



In [ ]:

    
np.nan < 0



In [ ]:

    
np.nan == np.nan

Infinito

Definição



In [ ]:

    
np.inf



In [ ]:

    
-np.inf



In [ ]:

    
np.float32(1.) / np.float32(0)

Propriedades



In [ ]:

    
np.inf == np.inf



In [ ]:

    
-np.inf == np.inf



In [ ]:

    
np.inf/np.inf



In [ ]:

    
np.inf/(-np.inf)



In [ ]:

    
biggest_uint = np.iinfo(np.uint64).max
print(biggest_uint)
np.inf > biggest_uint



In [ ]:

    
-np.inf < -biggest_uint



In [ ]:

    
np.inf > -np.inf

Arrays e Matrizes

1D Array



In [ ]:

    
""" inicializando com uma list """   
x = [1, 2, 3, 4, 5, 6, 7, 8, 9]
np.array(x)



In [ ]:

    
""" inicializando com uma tupla """   
x = (1, 2, 3, 4, 5, 6, 7, 8, 9)
np.array(x)



In [ ]:

    
""" inicializando diretamente """   
np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])

Matriz = 2D Array



In [ ]:

    
""" list de lists """   
x = [
    [1, 2, 3, 4, 5, 6, 7, 8, 9],
    [1, 2, 3, 4, 5, 6, 7, 8, 9],
    [1, 2, 3, 4, 5, 6, 7, 8, 9],
    [1, 2, 3, 4, 5, 6, 7, 8, 9],
    [1, 2, 3, 4, 5, 6, 7, 8, 9]
]
np.array(x)



In [ ]:

    
""" lista de arrays """   
x = [
    np.array([1, 2, 3, 4, 5, 6, 7, 8, 9]),
    np.array([1, 2, 3, 4, 5, 6, 7, 8, 9]),
    np.array([1, 2, 3, 4, 5, 6, 7, 8, 9]),
    np.array([1, 2, 3, 4, 5, 6, 7, 8, 9]),
    np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
]
np.array(x)

Acessando valores em um array

Definição das Variáveis



In [ ]:

    
x_1d = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
x_1d



In [ ]:

    
x_2d = np.array([
    x_1d, 
    x_1d + 1, 
    x_1d + 2, 
    x_1d + 3, 
    x_1d + 4
])
x_2d

Slicing

1D (índices)



In [ ]:

    
x_1d[3]



In [ ]:

    
x_1d[[3, 2]]

1D (intervalos)



In [ ]:

    
x_1d[2:7:2]



In [ ]:

    
x_1d[:8:3]



In [ ]:

    
x_1d[7:9]



In [ ]:

    
x_1d[:4]



In [ ]:

    
x_1d[::3]



In [ ]:

    
x_1d[::-1]



In [ ]:

    
x_1d[:]

2D (índices)



In [ ]:

    
x_2d[3]



In [ ]:

    
x_2d[3][5]



In [ ]:

    
x_2d[3, 5]



In [ ]:

    
x_2d[[3, 2]]



In [ ]:

    
x_2d[[3, 2], 2]

2D (intervalos)



In [ ]:

    
x_2d[[2, 4], 4:6]



In [ ]:

    
x_2d[2:4, [2, 4, 5]]



In [ ]:

    
x_2d[2:4, :5]

Masks

Conceito



In [ ]:

    
""" mask = array(bool) """
x_2d[:, :6] >  4

Aplicação



In [ ]:

    
""" Nota sobre o método `copy`:  
    
    Caso não seja utilizado, modificar um valor no slice 
    é a mesma coisa que modificar na variável original.
    
"""
tmp = x_2d[:, :8].copy()
tmp



In [ ]:

    
tmp[tmp >  6] = 13
tmp[tmp <  2] = -13
tmp



In [ ]:

    
tmp[(tmp == -13) | (tmp == 13)] = 0
tmp



In [ ]:

    
tmp[(tmp > 0) & (tmp < 6)] = -3
tmp

Operações Vetoriais

Definição das Variáveis:



In [ ]:

    
A = np.array([
    [1, 2, 0, -4],
    [0, 2, 3, -1],
    [1, 0, 3,  0],
])



In [ ]:

    
B = np.array([
    [-1,  0,  2],
    [ 0, -1, -2],
])



In [ ]:

    
C = np.array([
    [ 1,  0,  2],
    [ 1,  3,  0],
])



In [ ]:

    
D = np.array([ 3,  5,  2])

Concatenação



In [ ]:

    
np.hstack((B, C))



In [ ]:

    
np.vstack((B, C))

Transposição:



In [ ]:

    
np.transpose(A)



In [ ]:

    
B.T

Operações Escalares Simples:



In [ ]:

    
A + 1



In [ ]:

    
B * 10



In [ ]:

    
C ** 3



In [ ]:

    
B - C



In [ ]:

    
B * C



In [ ]:

    
(B + 10) / ((C ** 2) + 10)

Operações Escalares Propagadas:



In [ ]:

    
B / D



In [ ]:

    
A.T * D



In [ ]:

    
C + D

Operações Vetoriais:



In [ ]:

    
B.dot(D)



In [ ]:

    
np.dot(A.T, B.T)



In [ ]:

    
X = np.dot(A.T, B.T).dot(B.dot(D))
X



In [ ]:

    
Y = np.array([X])
Y



In [ ]:

    
Y.T.dot(Y)



In [ ]:

    
Y.dot(Y.T)

Propagação de Operações:

* Numéricos



In [ ]:

    
B.sum()



In [ ]:

    
B.sum(axis=0)



In [ ]:

    
B.sum(axis=1)



In [ ]:

    
B.mean(axis=1)



In [ ]:

    
B.std(axis=1)

* Lógicos



In [ ]:

    
(B > 0).all(axis=1)



In [ ]:

    
(B > 0).any(axis=1)

Geradores

Repetidores

zeros



In [ ]:

    
np.zeros((3,7))

ones



In [ ]:

    
np.ones((3,7))

tile



In [ ]:

    
A = np.array([[1, 2, 3, 4, 5]])
A



In [ ]:

    
np.tile(A, (3, 1))



In [ ]:

    
np.tile(A.T, (1,4))



In [ ]:

    
np.tile(A.T, (2, 4))

eye (Matriz Identidade)



In [ ]:

    
np.eye(4)

Transformadores:

Variável Auxiliar



In [ ]:

    
A = np.tile(np.array([[1, 2, 3, 4]]), (4, 1))
A

TRIL



In [ ]:

    
np.tril(A)



In [ ]:

    
np.tril(A, 1)



In [ ]:

    
np.tril(A, -1)

TRIU



In [ ]:

    
np.triu(A)



In [ ]:

    
np.triu(A, 1)



In [ ]:

    
np.triu(A, -1)

Desafio

Objetivo:

Construir a saída esperada usando as ferramentas dadas em cada item.

[ Exemplo ]

Saída Esperada:



In [ ]:

    
np.array([
    [ 1., 0., -1.],
    [ 0., 0.,  0.],
    [-1., 0.,  1.]
])

Ferramentas:



In [ ]:

    
np.eye?

Solução:



In [ ]:

    
np.eye(3) - np.eye(3)[::-1]

[ Item A ]

Saída Esperada:



In [ ]:

    
np.array([[-1.,  0.,  0., 0.],
          [-1., -1.,  0., 0.],
          [-1., -1., -1., 0.]])

Ferramentas:



In [ ]:

    
np.ones?



In [ ]:

    
np.tril?

Solução:



In [ ]:

    
""" Escreva a a Solução Aqui """

[ Item B ]

Saída Esperada:



In [ ]:

    
np.array([[ 1.,  0.,  0.,  0.,  0.],
          [ 0.,  2.,  0.,  0.,  0.],
          [ 0.,  0.,  3.,  0.,  0.],
          [ 0.,  0.,  0.,  4.,  0.],
          [ 0.,  0.,  0.,  0.,  5.]])

Ferramentas:



In [ ]:

    
np.eye?



In [ ]:

    
""" Operador *"""
np.multiply?

Solução:



In [ ]:

    
""" Escreva a a Solução Aqui """

[ Item C ]

Saída Esperada:



In [ ]:

    
np.array([[ 0.,  1.,  2.,  3.,  4.],
          [-1.,  0.,  1.,  2.,  3.],
          [-2., -1.,  0.,  1.,  2.],
          [-3., -2., -1.,  0.,  1.],
          [-4., -3., -2., -1.,  0.]])

Ferramentas:



In [ ]:

    
np.ones?



In [ ]:

    
""" Operador * """
np.multiply?



In [ ]:

    
""" Operador + """
np.add?

Solução:



In [ ]:

    
""" Escreva a a Solução Aqui """

[ Item D ]

Saída Esperada:



In [ ]:

    
np.array([[ 1,  2,  3,  4,  5,  6,  7,  8,  9],
          [ 2,  4,  6,  8, 10, 12, 14, 16, 18],
          [ 3,  6,  9, 12, 15, 18, 21, 24, 27],
          [ 4,  8, 12, 16, 20, 24, 28, 32, 36],
          [ 5, 10, 15, 20, 25, 30, 35, 40, 45],
          [ 6, 12, 18, 24, 30, 36, 42, 48, 54],
          [ 7, 14, 21, 28, 35, 42, 49, 56, 63],
          [ 8, 16, 24, 32, 40, 48, 56, 64, 72],
          [ 9, 18, 27, 36, 45, 54, 63, 72, 81]])

Ferramentas:



In [ ]:

    
A = np.array([[1, 2, 3, 4, 5, 6, 7, 8, 9]])



In [ ]:

    
np.dot?



In [ ]:

    
np.transpose?

Solução:



In [ ]:

    
""" Escreva a a Solução Aqui """

[ Item E ]

Saída Esperada:



In [ ]:

    
np.array([[-18,   0,  18]])

Ferramentas:



In [ ]:

    
A = np.array([[1, 2, 3, 4, 5, 6, 7, 8, 9]])
B = np.array([[-1, 0, 1]])
C = np.array([[0, 0, 1, 0, 0, 1, 0, 0, 1]])



In [ ]:

    
np.dot?



In [ ]:

    
np.transpose?

Solução:



In [ ]:

    
""" Escreva a a Solução Aqui """