Numpy

Last updated: May 15th, 20202020-05-15Project preview

NumPy

Lembrar de instalar o numpy caso não esteja instalado rodando o comando pip install numpy

Comparação com lista

In [1]:
a = [1, 2, 3]
b = [4, 5, 6]

Fazer uma soma elemento a elemento com lista em pyhton

In [2]:
a + b
Out[2]:
[1, 2, 3, 4, 5, 6]

Não é o que queremos... 😔

Para somar elemento a elemento, precisamos fazer um loop:

In [3]:
i = 0
arr = []

while i < len(a):
    arr.append(a[i] + b[i])
    i += 1

arr
Out[3]:
[5, 7, 9]

Básico

Importando numppy com um alias np

In [4]:
import numpy as np

1-D arrays (matriz de 1 dimensão ou vetor...)

In [5]:
a = np.array([1, 2, 3]) # array unidimensional
a
Out[5]:
array([1, 2, 3])
In [6]:
# checando o tipo da variável a...
type(a)
Out[6]:
numpy.ndarray

o nd significa n-dimensional

Checando o tipo de dados do array (se é int32, int64, float32, float64, etc...)

In [7]:
a.dtype
Out[7]:
dtype('int64')

A consistência do dado é forte...

In [8]:
# se eu trocar o elemento na posição 0 para o valor 10, dá certo
a[0] = 10
a
Out[8]:
array([10,  2,  3])
In [9]:
# se eu trocar para ponto flutuante, ele "trunca" e eu perco a parte decimal
a[0] = 1.2
a
Out[9]:
array([1, 2, 3])

2-D arrays - 2 dimensões (matrizes)

In [10]:
# atenção pro duplo colchete!
b = np.array([[9.0, 8.0, 7.0],
              [6.0, 5.0, 4.0]])
b
Out[10]:
array([[9., 8., 7.],
       [6., 5., 4.]])

Dimensão e formato

In [11]:
a.ndim
Out[11]:
1
In [12]:
b.ndim
Out[12]:
2
In [13]:
a.shape
Out[13]:
(3,)
In [14]:
b.shape
Out[14]:
(2, 3)

Tipo de dado e tamanho

In [15]:
a.dtype
Out[15]:
dtype('int64')
In [16]:
b.dtype
Out[16]:
dtype('float64')
In [17]:
a2 = np.array([1, 2, 3], dtype=np.int16)
a2
Out[17]:
array([1, 2, 3], dtype=int16)
In [18]:
a.itemsize # 8 bytes (64/8 = 8)
Out[18]:
8
In [19]:
a2.itemsize # 2 bytes (16/8)
Out[19]:
2
In [20]:
# quantidade de elementos total
a.size
Out[20]:
3
In [21]:
# quantidade de elementos vezes o tamanho de cada elemento
a.size * a.itemsize
Out[21]:
24
In [22]:
# que é o mesmo que nbytes ou número de bytes
a.nbytes
Out[22]:
24

Obs: Eu geralmente não me preocuparia em reduzir o número de bits a não ser que eu tenha certeza que um tamanho reduzido vai atender minha necessidade e eu quero ser extremamente eficiente.

Acessando/Modificando elementos específicos, linhas, colunas, etc

In [23]:
a = np.array([[1, 2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13, 14]])
print(a)
[[ 1  2  3  4  5  6  7]
 [ 8  9 10 11 12 13 14]]
In [24]:
# Retire um elemento [linha, coluna]
a[1, 5]
Out[24]:
13
In [25]:
# poser ser assim também...
a[1][5]
Out[25]:
13
In [26]:
# negativo funciona de trás pra frente
a[1, -2]
Out[26]:
13
In [27]:
# Pegar uma linha específica
a[0, :]
Out[27]:
array([1, 2, 3, 4, 5, 6, 7])
In [28]:
# que é o mesmo que...
a[0]
Out[28]:
array([1, 2, 3, 4, 5, 6, 7])
In [29]:
# Pegar uma coluna específica
a[:, 2]
Out[29]:
array([ 3, 10])
In [30]:
# Pegando dando passos [startindex:endindex:stepsize]
a[0, 1:6:2]
Out[30]:
array([2, 4, 6])
In [31]:
a[0, 1:-1:2]
Out[31]:
array([2, 4, 6])
In [32]:
#  Mudar um elemento específico
a[1,5] = 20
print(a)
[[ 1  2  3  4  5  6  7]
 [ 8  9 10 11 12 20 14]]
In [33]:
# Mudando uma coluna inteira para ser 5
a[:, 2] = 5
print(a)
[[ 1  2  5  4  5  6  7]
 [ 8  9  5 11 12 20 14]]
In [34]:
# acessando o formato de um slicing
a[:, 2].shape
Out[34]:
(2,)
In [35]:
a[:, 2] = [5, 10]
print(a)
[[ 1  2  5  4  5  6  7]
 [ 8  9 10 11 12 20 14]]
In [36]:
# Exemplo 3-D
b = np.array([[[1, 2], [3,4]], [[5, 6], [7, 8]]])
In [37]:
b
Out[37]:
array([[[1, 2],
        [3, 4]],

       [[5, 6],
        [7, 8]]])
In [38]:
b.ndim
Out[38]:
3
In [39]:
# Retire um elemento específico -> 4
b[0, 1, 1]
Out[39]:
4
In [40]:
b[:, 1, :]
Out[40]:
array([[3, 4],
       [7, 8]])
In [41]:
b[:, 1, :] = [[9, 9], [8, 8]]

Inicializando arrays usando métodos internos

O NumPy possui muitos métodos built-in para gerar arrays dos mais diversos tipos

In [42]:
# matriz apenas com zeros
np.zeros(5)
Out[42]:
array([0., 0., 0., 0., 0.])
In [43]:
np.zeros((2, 3))
Out[43]:
array([[0., 0., 0.],
       [0., 0., 0.]])
In [44]:
np.zeros((2, 2, 3))
Out[44]:
array([[[0., 0., 0.],
        [0., 0., 0.]],

       [[0., 0., 0.],
        [0., 0., 0.]]])
In [45]:
# matriz apenas com 1
np.ones((4, 2, 2), dtype='int32')
Out[45]:
array([[[1, 1],
        [1, 1]],

       [[1, 1],
        [1, 1]],

       [[1, 1],
        [1, 1]],

       [[1, 1],
        [1, 1]]], dtype=int32)
In [46]:
# qualquer outro número
np.full((2, 2), 99)
Out[46]:
array([[99, 99],
       [99, 99]])
In [47]:
np.full((2, 2), 99.)
Out[47]:
array([[99., 99.],
       [99., 99.]])
In [48]:
# Qualquer outro número copiando o formato de uma matriz
np.full_like(a, 4)
Out[48]:
array([[4, 4, 4, 4, 4, 4, 4],
       [4, 4, 4, 4, 4, 4, 4]])
In [49]:
# Números decimais aleatórios
np.random.random_sample((4, 2))
Out[49]:
array([[0.59701743, 0.40627135],
       [0.23940108, 0.58528558],
       [0.04228252, 0.68467361],
       [0.68907347, 0.85636431]])
In [50]:
# função igual ao do matlab (observe que não é uma tupla)
np.random.rand(4, 2)
Out[50]:
array([[0.13322589, 0.76493887],
       [0.06716679, 0.61834428],
       [0.54098045, 0.09752974],
       [0.6656696 , 0.79337782]])
In [51]:
# números inteiros
np.random.randint(7, size=(3, 3))
Out[51]:
array([[6, 5, 6],
       [0, 6, 2],
       [4, 6, 5]])
In [52]:
np.random.randint(0, high=100, size=100)
Out[52]:
array([66, 91, 70, 95, 73, 73, 70, 98, 10, 70, 47, 11, 67, 69, 60, 30, 23,
       51, 58, 18, 79, 46,  8, 12, 84, 45, 44, 90, 13, 86, 92, 20,  9, 93,
       41,  7, 56, 39, 11, 58, 36, 94, 80, 65, 94,  9, 20, 47, 74,  5, 90,
       28,  3, 86, 29, 51, 83, 44, 58, 33, 55, 69,  9, 15, 54, 87, 87, 68,
       35,  6, 91, 98, 99, 81, 73, 37, 86, 79, 91, 65, 44, 22, 68,  5, 85,
       28, 49, 70, 64, 23, 23, 73, 94, 56, 76, 11, 12, 21, 14, 48])
In [53]:
# é exclusivo, então, se quiser incluir 100, você deve fazer:
np.random.randint(-100, high=101, size=10)
Out[53]:
array([ 30,  43, -63, -79,  26, -52, -56,  52,  88, -48])
In [54]:
# Matriz identidade (diagonal com 1, matriz quadrada)
np.identity(3)
Out[54]:
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

repeat

In [55]:
arr = np.array([1, 2, 3])
r1 = np.repeat(arr, 3)
print(r1)
[1 1 1 2 2 2 3 3 3]
In [56]:
arr = np.array([[1, 2, 3]])
r1 = np.repeat(arr, 3, axis=0)
print(r1)
[[1 2 3]
 [1 2 3]
 [1 2 3]]
In [57]:
arr = np.array([[1, 2, 3]])
r1 = np.repeat(arr, 3, axis=1)
print(r1)
[[1 1 1 2 2 2 3 3 3]]

arange

Retorne elementos igualmente espaçados num step (por padrão, 1) dentro de um certo intervalo.

In [58]:
np.arange(0, 10)
Out[58]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [59]:
np.arange(0, 11, 0.1)
Out[59]:
array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9,  1. ,
        1.1,  1.2,  1.3,  1.4,  1.5,  1.6,  1.7,  1.8,  1.9,  2. ,  2.1,
        2.2,  2.3,  2.4,  2.5,  2.6,  2.7,  2.8,  2.9,  3. ,  3.1,  3.2,
        3.3,  3.4,  3.5,  3.6,  3.7,  3.8,  3.9,  4. ,  4.1,  4.2,  4.3,
        4.4,  4.5,  4.6,  4.7,  4.8,  4.9,  5. ,  5.1,  5.2,  5.3,  5.4,
        5.5,  5.6,  5.7,  5.8,  5.9,  6. ,  6.1,  6.2,  6.3,  6.4,  6.5,
        6.6,  6.7,  6.8,  6.9,  7. ,  7.1,  7.2,  7.3,  7.4,  7.5,  7.6,
        7.7,  7.8,  7.9,  8. ,  8.1,  8.2,  8.3,  8.4,  8.5,  8.6,  8.7,
        8.8,  8.9,  9. ,  9.1,  9.2,  9.3,  9.4,  9.5,  9.6,  9.7,  9.8,
        9.9, 10. , 10.1, 10.2, 10.3, 10.4, 10.5, 10.6, 10.7, 10.8, 10.9])

linspace

Parecido com o arange, mas você diz quantos pontos você quer e o intervalo e ele define o espaçamento linear

In [60]:
np.linspace(0, 100, num=10)
Out[60]:
array([  0.        ,  11.11111111,  22.22222222,  33.33333333,
        44.44444444,  55.55555556,  66.66666667,  77.77777778,
        88.88888889, 100.        ])

Exercício 1

Construir a matriz

1 1 1 1 1
1 0 0 0 1
1 0 9 0 1
1 0 0 0 1
1 1 1 1 1

Usando o mínimo e linhas e o que vimos acima!

Solução

In [61]:
matrix = np.ones((5, 5))
matrix[1:-1, 1:4] = np.zeros((3, 3))
matrix[2, 2] = 9
matrix
Out[61]:
array([[1., 1., 1., 1., 1.],
       [1., 0., 0., 0., 1.],
       [1., 0., 9., 0., 1.],
       [1., 0., 0., 0., 1.],
       [1., 1., 1., 1., 1.]])

Tenha cuidado ao copiar arrays!

Jeito errado

In [62]:
a = np.array([1, 2, 3])
b = a
b
Out[62]:
array([1, 2, 3])
In [63]:
b[0] = 100
b
Out[63]:
array([100,   2,   3])
In [64]:
a
Out[64]:
array([100,   2,   3])

Jeito certo

In [65]:
a = np.array([1, 2, 3])
b = a.copy()
b
Out[65]:
array([1, 2, 3])
In [66]:
b[0] = 100
b
Out[66]:
array([100,   2,   3])
In [67]:
a
Out[67]:
array([1, 2, 3])

Matemática

In [68]:
a = np.array([1, 2, 3, 4])
a
Out[68]:
array([1, 2, 3, 4])
In [69]:
a + 2
Out[69]:
array([3, 4, 5, 6])
In [70]:
a - 2
Out[70]:
array([-1,  0,  1,  2])
In [71]:
a * 2
Out[71]:
array([2, 4, 6, 8])
In [72]:
a / 2
Out[72]:
array([0.5, 1. , 1.5, 2. ])
In [73]:
a += 2
a
Out[73]:
array([3, 4, 5, 6])
In [74]:
a = np.array([1, 2, 3, 4])
b = np.array([1, 0, 1, 0])
a + b
Out[74]:
array([2, 2, 4, 4])
In [75]:
a ** 2
Out[75]:
array([ 1,  4,  9, 16])
In [76]:
# Take the sin
np.sin(a)
Out[76]:
array([ 0.84147098,  0.90929743,  0.14112001, -0.7568025 ])
In [77]:
np.cos(a)
Out[77]:
array([ 0.54030231, -0.41614684, -0.9899925 , -0.65364362])

Álgebra Linear

In [78]:
a = np.ones((2, 3))
print(a)

b = np.full((3, 2), 2)
print(b)
[[1. 1. 1.]
 [1. 1. 1.]]
[[2 2]
 [2 2]
 [2 2]]

Transpor

In [79]:
# Tranpose
np.transpose(a)
Out[79]:
array([[1., 1.],
       [1., 1.],
       [1., 1.]])
In [80]:
a.T
Out[80]:
array([[1., 1.],
       [1., 1.],
       [1., 1.]])

Multiplicação matriz

In [81]:
np.matmul(a, b)
Out[81]:
array([[6., 6.],
       [6., 6.]])
In [82]:
a @ b
Out[82]:
array([[6., 6.],
       [6., 6.]])

Encontrar o determinante

In [83]:
c = np.identity(3)
print(c)
np.linalg.det(c)
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
Out[83]:
1.0

Outras funcções de Álgebra Linear: https://docs.scipy.org/doc/numpy/reference/routines.linalg.html

  • Determinante
  • Trace
  • Decomposição de vetores
  • Autovalor/autovetor
  • Norma da Matriz
  • Inversa
  • Etc...

Estatística

In [84]:
stats = np.array([[1, 2, 3], [4, 5, 6]])
stats
Out[84]:
array([[1, 2, 3],
       [4, 5, 6]])
In [85]:
np.min(stats)
Out[85]:
1
In [86]:
np.max(stats)
Out[86]:
6
In [87]:
np.min(stats, axis=1) # min per row
Out[87]:
array([1, 4])
In [88]:
np.max(stats, axis=0) # max per col
Out[88]:
array([4, 5, 6])
In [89]:
np.sum(stats, axis=0)
Out[89]:
array([5, 7, 9])
In [90]:
np.average(stats)
Out[90]:
3.5

Reorganizar Array

Reshape

In [91]:
before = np.array([[1,2,3,4],[5,6,7,8]])
print(before.shape)
(2, 4)
In [92]:
after = before.reshape((8, 1)) # tem que ter a mesma quantidade!
after
Out[92]:
array([[1],
       [2],
       [3],
       [4],
       [5],
       [6],
       [7],
       [8]])
In [93]:
before.reshape(2, 2, 2)
Out[93]:
array([[[1, 2],
        [3, 4]],

       [[5, 6],
        [7, 8]]])

Apendar verticalmente os vetores

In [94]:
v1 = np.array([1,2,3,4])
v2 = np.array([5,6,7,8])
In [95]:
np.vstack([v1, v2])
Out[95]:
array([[1, 2, 3, 4],
       [5, 6, 7, 8]])
In [96]:
np.vstack([v1, v2, v2, v2])
Out[96]:
array([[1, 2, 3, 4],
       [5, 6, 7, 8],
       [5, 6, 7, 8],
       [5, 6, 7, 8]])

Apendar verticalmente os vetores

In [97]:
h1 = np.ones((2, 4))
h2 = np.zeros((2, 2))

np.hstack((h1, h2))
Out[97]:
array([[1., 1., 1., 1., 0., 0.],
       [1., 1., 1., 1., 0., 0.]])

Funcionalidades extras

Carregar dados de um arquivo

In [98]:
%%writefile data.txt
1,13,21,11,196,75,4,3,34,6,7,8,0,1,2,3,4,5
3,42,12,33,766,75,4,55,6,4,3,4,5,6,7,0,11,12
1,22,33,11,999,11,2,1,78,0,1,2,9,8,7,1,76,88
Overwriting data.txt
In [99]:
filedata = np.genfromtxt('data.txt', delimiter=',')
filedata
Out[99]:
array([[  1.,  13.,  21.,  11., 196.,  75.,   4.,   3.,  34.,   6.,   7.,
          8.,   0.,   1.,   2.,   3.,   4.,   5.],
       [  3.,  42.,  12.,  33., 766.,  75.,   4.,  55.,   6.,   4.,   3.,
          4.,   5.,   6.,   7.,   0.,  11.,  12.],
       [  1.,  22.,  33.,  11., 999.,  11.,   2.,   1.,  78.,   0.,   1.,
          2.,   9.,   8.,   7.,   1.,  76.,  88.]])
In [100]:
filedata.astype('int32')
Out[100]:
array([[  1,  13,  21,  11, 196,  75,   4,   3,  34,   6,   7,   8,   0,
          1,   2,   3,   4,   5],
       [  3,  42,  12,  33, 766,  75,   4,  55,   6,   4,   3,   4,   5,
          6,   7,   0,  11,  12],
       [  1,  22,  33,  11, 999,  11,   2,   1,  78,   0,   1,   2,   9,
          8,   7,   1,  76,  88]], dtype=int32)
In [101]:
np.save('data', filedata.astype('int32'))
In [102]:
np.savez_compressed('dataz', filedata)
In [103]:
np.load('data.npy')
Out[103]:
array([[  1,  13,  21,  11, 196,  75,   4,   3,  34,   6,   7,   8,   0,
          1,   2,   3,   4,   5],
       [  3,  42,  12,  33, 766,  75,   4,  55,   6,   4,   3,   4,   5,
          6,   7,   0,  11,  12],
       [  1,  22,  33,  11, 999,  11,   2,   1,  78,   0,   1,   2,   9,
          8,   7,   1,  76,  88]], dtype=int32)

Máscara Boleana e Seleção Avançada

In [104]:
filedata > 50
Out[104]:
array([[False, False, False, False,  True,  True, False, False, False,
        False, False, False, False, False, False, False, False, False],
       [False, False, False, False,  True,  True, False,  True, False,
        False, False, False, False, False, False, False, False, False],
       [False, False, False, False,  True, False, False, False,  True,
        False, False, False, False, False, False, False,  True,  True]])
In [105]:
filedata[filedata > 50]
Out[105]:
array([196.,  75., 766.,  75.,  55., 999.,  78.,  76.,  88.])
In [106]:
a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
a[[1, 2, 8]] # passando uma lista para seleção
Out[106]:
array([2, 3, 9])
In [107]:
np.any(filedata > 50, axis=0)
Out[107]:
array([False, False, False, False,  True,  True, False,  True,  True,
       False, False, False, False, False, False, False,  True,  True])

Quais colunas tem pelo menos 1 valor maior que 50

In [108]:
np.any(filedata > 50, axis=0)
Out[108]:
array([False, False, False, False,  True,  True, False,  True,  True,
       False, False, False, False, False, False, False,  True,  True])

Quais colunas tem todos os valores da coluna maior que 50

In [109]:
np.all(filedata > 50, axis=0)
Out[109]:
array([False, False, False, False,  True, False, False, False, False,
       False, False, False, False, False, False, False, False, False])

Operador AND

In [110]:
((filedata > 50) & (filedata < 100))
Out[110]:
array([[False, False, False, False, False,  True, False, False, False,
        False, False, False, False, False, False, False, False, False],
       [False, False, False, False, False,  True, False,  True, False,
        False, False, False, False, False, False, False, False, False],
       [False, False, False, False, False, False, False, False,  True,
        False, False, False, False, False, False, False,  True,  True]])
In [111]:
filedata[((filedata > 50) & (filedata < 100))]
Out[111]:
array([75., 75., 55., 78., 76., 88.])

Operador NOT

In [112]:
~((filedata > 50) & (filedata < 100))
Out[112]:
array([[ True,  True,  True,  True,  True, False,  True,  True,  True,
         True,  True,  True,  True,  True,  True,  True,  True,  True],
       [ True,  True,  True,  True,  True, False,  True, False,  True,
         True,  True,  True,  True,  True,  True,  True,  True,  True],
       [ True,  True,  True,  True,  True,  True,  True,  True, False,
         True,  True,  True,  True,  True,  True,  True, False, False]])

Mais exercícios

1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
26 27 28 29 30

Exercício 2

Como você selecionaria o bloco abaixo?

1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
26 27 28 29 30
In [113]:
m = np.arange(1, 31).reshape(6, 5)
m
Out[113]:
array([[ 1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10],
       [11, 12, 13, 14, 15],
       [16, 17, 18, 19, 20],
       [21, 22, 23, 24, 25],
       [26, 27, 28, 29, 30]])
In [114]:
m[2:4, 0:2]
Out[114]:
array([[11, 12],
       [16, 17]])

Exercício 3

Como você seleciona o bloco abaixo?

1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
26 27 28 29 30

Solução

In [115]:
m[[0, 1, 2, 3],[1, 2, 3, 4]]
Out[115]:
array([ 2,  8, 14, 20])

Exercício 4

Como você seleciona o bloco abaixo?

1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
26 27 28 29 30

Solução

In [116]:
m[[0, 4, 5], 3:]
Out[116]:
array([[ 4,  5],
       [24, 25],
       [29, 30]])
Notebooks AI
Notebooks AI Profile20060