Numpy — Conceitos para iniciantes

No início de 2005, o desenvolvedor do NumPy, Travis Oliphant, queria unificar a comunidade em torno de um único pacote de matriz e portou os recursos da Numarray para a Numeric, liberando o resultado como NumPy 1.0 em 2006.

Este novo projeto fazia parte do SciPy. Para evitar a instalação do grande pacote SciPy apenas para obter um objeto de matriz, esse novo pacote foi separado e chamado NumPy. — Wikipédia

O NumPy está centralizado em torno de um objeto de matriz N-dimensional e também contém suporte para álgebra linear, transformação de Fourier e funções de números aleatórios.

• Nota

1. No NumPy, cada dimensão é chamada de axis.
2. O número de eixos é chamado de rank. *
   Por exemplo, uma matriz 3x4 é uma matriz com rank 2 (bidimensional).
3. O lenght de um axis é chamado de shape.
   Por exemplo, o shape da matriz acima é (3, 4).
   O rank igual ao length do shape.

In [1]:

import numpy as np

np.zeros

A função zeros cria uma matriz preenchida de zeros.

In [2]:

np.zeros(10)

Out[2]:

array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])

//Matriz 2D, com valroes zerados

In [3]:

np.zeros((5,5))

Out[3]:

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.]])

In [4]:

zero = np.zeros((5,5))
print("shape: ", zero.shape)
print("ndim:", zero.ndim," - // len(zero.shape)")
print("size:", zero.size)
shape:  (5, 5)
ndim: 2  - // len(zero.shape)
size: 25

N-dimensionais

Aqui está uma matriz 3D (rank = 3), com shape (2,3,4):

In [5]:

np.zeros((2,3,4))

Out[5]:

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.]]])

np.ones

In [6]:

np.ones((5,2))

Out[6]:

array([[1., 1.],
       [1., 1.],
       [1., 1.],
       [1., 1.],
       [1., 1.]])

np.full

Cria uma matriz inicializada com o valor préviamente especificados.

In [7]:

np.full((2,5), np.log(8))

Out[7]:

array([[2.07944154, 2.07944154, 2.07944154, 2.07944154, 2.07944154],
       [2.07944154, 2.07944154, 2.07944154, 2.07944154, 2.07944154]])

np.array

In [8]:

np.array([[2,4,6,8], [8,6,4,2]])

Out[8]:

array([[2, 4, 6, 8],
       [8, 6, 4, 2]])

np.arange

Você pode criar um ndarray usando a função range do NumPy, que é semelhante à função range interna do python.**

In [9]:

np.arange(10, 25)

Out[9]:

array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24])

np.linspace

A função linspace retorna uma matriz que contém um número específico de pontos distribuídos igualmente entre dois valores.

In [10]:

np.linspace(6, 4/4, 5)

Out[10]:

array([6.  , 4.75, 3.5 , 2.25, 1.  ])

np.random.randn & np.random.rand

In [11]:

np.random.rand(2,2), np.random.randn(2,2)

Out[11]:

(array([[0.07442464, 0.15097294],
        [0.52665941, 0.75451712]]),
 array([[ 0.45457224, -0.3164228 ],
        [ 0.09081072, -0.1629611 ]]))

Para dar uma idéia de como são essas distribuições, vamos usar o matplotlib (consulte o tutorial do matplotlib para obter mais detalhes).

In [12]:

%matplotlib inline
import matplotlib.pyplot as plt
plt.hist(np.random.rand(500), density=True, bins=10, histtype="step", color="green", label="rand")
plt.hist(np.random.randn(500), density=True, bins=10, histtype="step", color="purple", label="randn")
plt.axis([-2.5, 2.5, 0, 1.1])
plt.legend(loc = "upper left")
plt.title("Distribuições Aleatórias")
plt.xlabel("Valores")
plt.ylabel("Density")
plt.show()

data buffer

Os dados são armazenados na memória como um buffer de bytes simples (unidimensional). Está disponível através do atributo de dados.

In [13]:

arr = np.array([[2,2],[20, 10]], dtype=np.int16)
arr.data

reshape

O reshape retorna um novo objeto ndarray apontando para os mesmos dados. Isso significa que a modificação de uma matriz também modificará a outra.

In [14]:

matriz = np.arange(25)
print(matriz)
print("Rank:",matriz.ndim)
print("Shape:",matriz.shape)
print()
print()
matriz = matriz.reshape(5,5)
print(matriz)
print("Rank:",matriz.ndim)
print("Shape:",matriz.shape)
print()
[ 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]
Rank: 1
Shape: (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]]
Rank: 2
Shape: (5, 5)

ravel

Retorna um novo ndarray unidimensional que também aponta para os mesmos dados

In [15]:

matriz.ravel()

Out[15]:

array([ 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])

Em geral, quando o NumPy espera matrizes de mesmo shape, mas descobre que esse não é o caso, aplica as chamadas regras de transmissão

Se as matrizes não tiverem o mesmo rank, um 1 será anexado às matrizes com rank menores até que seus ranks correspondam.

Operadores condicionais

In [16]:

valores = np.array([1, 2, 30, 6])
print(valores > [2, 4, 5, 6])
print()
print("equivalente valores < [5, 5, 5, 5]", valores < 5)
[False False  True False]
equivalente valores < [5, 5, 5, 5] [ True  True False False]

Funções Matemáticas/Estatísticas

In [17]:

v = np.array([[4, 9, 6], [7, 5, 6]])
print(v)
print()
for func in (v.min, v.max, v.sum, v.prod, v.std, v.var,v.mean):
    print(func.__name__, "=", func())
    print()
[[4 9 6]
 [7 5 6]]
min = 4
max = 9
sum = 37
prod = 45360
std = 1.5723301886761007
var = 2.4722222222222228
mean = 6.166666666666667

Funções Universais

O Numpy, também possui algumas funcões conhecidas como funções universais.

In [18]:

values = np.array([[2.5, 3.413, 56], [9, 1.1, 7.2]])
print(values)
print()
for func in (np.abs, np.sqrt, np.exp, np.log, np.sign, np.ceil, np.modf, np.isnan, np.cos):
    print("\n", func.__name__)
    print(func(values))
[[ 2.5    3.413 56.   ]
 [ 9.     1.1    7.2  ]]

 absolute
[[ 2.5    3.413 56.   ]
 [ 9.     1.1    7.2  ]]
 sqrt
[[1.58113883 1.84743065 7.48331477]
 [3.         1.04880885 2.68328157]]
 exp
[[1.21824940e+01 3.03561763e+01 2.09165950e+24]
 [8.10308393e+03 3.00416602e+00 1.33943076e+03]]
 log
[[0.91629073 1.22759167 4.02535169]
 [2.19722458 0.09531018 1.97408103]]
 sign
[[1. 1. 1.]
 [1. 1. 1.]]
 ceil
[[ 3.  4. 56.]
 [ 9.  2.  8.]]
 modf
(array([[0.5  , 0.413, 0.   ],
       [0.   , 0.1  , 0.2  ]]), array([[ 2.,  3., 56.],
       [ 9.,  1.,  7.]]))
 isnan
[[False False False]
 [False False False]]
 cos
[[-0.80114362 -0.96339456  0.85322011]
 [-0.91113026  0.45359612  0.60835131]]

In [19]:

a = np.array([1, -2, 3, 4])
b = np.array([2, 8, -1, 7])
print("a = ",a)
print("b = ",b)
print()
for func in (np.add,np.subtract,np.minimum, np.greater, np.maximum, np.copysign):
    print("\n", func.__name__)
    print(func(a,b))
a =  [ 1 -2  3  4]
b =  [ 2  8 -1  7]

 add
[ 3  6  2 11]
 subtract
[ -1 -10   4  -3]
 minimum
[ 1 -2 -1  4]
 greater
[False False  True False]
 maximum
[2 8 3 7]
 copysign
[ 1.  2. -3.  4.]

Acessando Matrizes

In [20]:

a = np.array([1, 3, 5, 7, 9, 11, 13])
print("a[5]= ",a[5])
print("a[3:5]= ",a[3:5])
print("a[4:-1]= ",a[4:-1])
print("a[:3]= ",a[:3])
print("a[2::2]= ",a[2::2])
print("a[::-1]= ",a[::-1])
print()
a[5]=  11
a[3:5]=  [7 9]
a[4:-1]=  [ 9 11]
a[:3]=  [1 3 5]
a[2::2]=  [ 5  9 13]
a[::-1]=  [13 11  9  7  5  3  1]

In [21]:

b = np.arange(48).reshape(6,8)
print(b)
print()
print("b[1, 2]=",b[1, 2])
print("b[2, :]=",b[2, :])
print("b[:, 3]=",b[:, 3])
print("b[0, :]=",b[0, :])
print("b[1:2, :]=",b[1:2, :])
[[ 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 25 26 27 28 29 30 31]
 [32 33 34 35 36 37 38 39]
 [40 41 42 43 44 45 46 47]]
b[1, 2]= 10
b[2, :]= [16 17 18 19 20 21 22 23]
b[:, 3]= [ 3 11 19 27 35 43]
b[0, :]= [0 1 2 3 4 5 6 7]
b[1:2, :]= [[ 8  9 10 11 12 13 14 15]]

continua…

fontes:

• Aurélien Geron
• https://numpy.org/doc/
• https://en.wikipedia.org/wiki/NumPy
• https://docs.scipy.org/doc/numpy/user/whatisnumpy.html

Notebook