Introdução ao NumPy | Envato Tuts+

() translation by (you can also view the original English article)

Numeric é um pacote que foi originalmente desenvolvido por Jim Hugunin. Considerado o ancestral do NumPy, é uma biblioteca Python e um projeto open-source criado por Travis Oliphant que significa Numerical Python. Travis criou o NumPy incorporando recursos do pacote Numarray no pacote Numeric.

A ideia fundamental do NumPy é o suporte à matrizes multidimensionais. Portanto, o NumPy pode ser considerado como a base para a computação numérica no Python e foi criado para permitir que o Python seja usado na resolução de problemas matemáticos e científicos. O módulo NumPy fornece-nos centenas de funções matemáticas úteis além de constantes como a base dos logaritmos naturais (e) e pi (π).

Este tutorial mostra como podemos usar o NumPy para trabalhar com matrizes multidimensionais e uma descrição do objeto ndarray, um objeto fundamental da biblioteca.

Instalando o NumPy

Como o NumPy não vem junto o Python, o primeiro passo para usar esta biblioteca é instalá-la. Isso pode ser feito simplesmente executando o comando a seguir no seu prompt de comando:

1	pip install numpy

Para certificar-se de que o NumPy foi instalado com êxito, execute os seguintes comandos na Python IDLE:

Se ao menos a instrução import foi executada com êxito, então estamos prontos!

O objeto ndarry

O ndarray é um objeto fundamental do NumPy. Este objeto é uma matriz N-dimensional, isso significa que ele contém uma coleção de elementos do mesmo tipo indexados usando N números inteiros (dimensão da matriz).

Os principais atributos do ndarray são os tipos de dados (dtype), shape, size, itemsize, data e ndim. Vamos aprender o que significa cada atributo através de um exemplo.

Neste exemplo, vamos usar o NumPy para criar uma matriz. Eu não vou dar as dimensões da matriz e outras informações, já que vamos usar os atributos acima.

Observe que usamos a função array para criar uma matriz. A saída do script acima é a seguinte:

Vamos agora voltar aos nossos atributos.

dtype

O atributo dtype pode ser executado, como mostrado na seguinte instrução:

1	data_type = my_array.dtype

A declaração acima retornará int32 como tipo de dado. Isso significa que os elementos da matriz são do tipo int32. Estou recebendo 32 pois estou usando uma versão 32-bit do Python. Se você estiver usando um Python 64-bit, você receberá int64, mas estamos lidando com números inteiros ainda.

Como o NumPy é usado em computação científica, tem muitos tipos de dados, conforme mostrado na documentação. Observe que a maioria dos tipos de dados NumPy termina com um número que indica o número de bits associados com esse tipo (isto foi mencionado brevemente no parágrafo acima).

Os exemplos a seguir mostram como podemos converter de um tipo para outro:

bool(35)
bool(0)
bool(-1)
float(True)
int(67.7)
float(87)

As instruções acima retornam o seguinte:

True
False
True
1.0
67
87.0

Embora seja possível converter um tipo para outro, é importante notar que nós não podemos converter um número complexo em um número inteiro ou float.

shape

O atributo shape retorna um tuple de dimensões da matriz. Então a seguinte instrução:

1	array_shape = my_array.shape

irá retornar (4,4), significa que nossa matriz é composta por 4 linhas e 4 colunas.

size

O atributo size retorna o número de elementos na matriz. Assim, se nós digitarmos:

1	array_size = my_array.size

Teremos 16 como resultado, o que significa que temos 16 elementos em nossa matriz.

itemsize

O atributo itemsize retorna o tamanho de um elemento da matriz em bytes. A instrução a seguir:

1	array_item_size = my_array.itemsize

retornará 4. Isto significa que cada elemento da matriz tem o tamanho de 4-bytes.

data

O atributo data é um objeto de buffer do Python que aponta para o início dos dados da matriz. Se digitarmos o seguinte:

1	array_location = my_array.data

Teremos isso: <memory at 0x0000021E7E8D7EA0>.

ndim

O atributo ndim retornará o número de dimensões da matriz. Então, digitando a seguinte instrução:

1	array_dimension = my_array.ndim

retornará 2, significa que esta matriz consiste de duas dimensões.

Após entender o que os diferentes atributos de ndarray significam, vamos dar uma olhada em alguns exemplos usando ndarray.

Exemplo 1

Digamos que nós queremos criar uma nova matriz com uma linha e cinco colunas. Faríamos isso da seguinte forma:

1	my_array = np.array( (1, 2, 3, 4, 5) )

A saída da instrução acima é: [1 2 3 4 5].

Exemplo 2

Neste exemplo, vou reescrever o primeiro exemplo deste tutorial, mas usando [ ] em vez de ( ), conforme a seguir:

Exemplo 3

Este exemplo mostra como usar tipos de dados estruturados, onde declaramos o nome do campo e os correspondentes tipos de dados:

1	import numpy as np
2
3	height_type = np.dtype([('height', np.float)])

Se nós escrevermos print(data_type), teremos o seguinte:

1	[('height', '<f8')]

Podemos aplicar o height_type para um objeto ndarray, da seguinte forma:

import numpy as np

height_type = np.dtype([('height', np.float)])
my_array = np.array([(1.78,),(1.69,),(1.88,)], dtype = height_type) 

# access content of height column
print(my_array['height'])

Selecionando itens

Nesta seção, eu vou te mostrar como selecionar itens específicos na matriz. Usando a matriz da seção "objeto ndarry", digamos que queremos selecionar o item localizado na terceira linha e na quarta coluna. Vamos fazer isso da seguinte forma:

1	my_array[2,3]

Lembre-se que essa indexação aqui começa em 0, e é por isso que nós escrevemos [2,3] em vez de [3,4].

Mais sobre matrizes com NumPy

Nesta seção, Vamos aprofundar em matrizes com NumPy.

Matrizes vazias (não inicializadas)

Podemos criar uma matriz vazia usando numpy.empty com a seguinte sintaxe:

1	numpy.empty(shape, dtype, order)

O significado dos parâmetros no construtor acima é:

Shape: a forma (dimensões) da matriz vazia.
dtype: o tipo de saída desejada, que é opcional.
Ordem: se você quer uma matriz no estilo C (linha é a principal), digite C; se você quer uma matriz no estilo FORTRAN (coluna é a principal), digite F.

Então vamos criar uma matriz vazia [2,2] do tipo int. Podemos fazer isso da seguinte forma:

1	import numpy as np
2
3	empty_array = np.empty([2,2], dtype = int)
4	print(empty_array)

O script acima retornará os seguintes valores aleatórios, ja que a matriz não foi inicializada:

1	[[1852795252 111218]
2	[ 7500288 53018624]]

Matriz preenchida com zeros

Para criar uma matriz onde os elementos são todos zeros, usamos numpy.zeros. O construtor aqui tem a mesma sintaxe e parâmetros como em numpy.empty. Então, se queremos criar uma matriz de zeros [2,2] do tipo int, podemos fazer isso da seguinte forma:

1	import numpy as np
2
3	zeros_array = np.zeros([2,2], dtype = int)
4	print(zeros_array)

O script acima irá retornar o seguinte:

1	[[0 0]
2	[0 0]]

Uma matriz com todos os elementos com valor 1 pode ser simplesmente criada da mesma forma que antes, mas com numpy.ones.

Matrizes com valores uniformemente distribuídos dentro de um determinado intervalo

Nós podemos usar numpy.arange para criar uma matriz com valores uniformemente distribuídos dentro de um intervalo especificado. O construtor tem o seguinte formato:

1	numpy.arange(start, stop, step, dtype)

Abaixo o significado de cada parâmetro:

Start: é aqui que começa o intervalo. O valor padrão é 0.
Stop: o fim do intervalo, este número não será incluído na matriz.
Step: o espaçamento entre os valores. O valor padrão é 1.
dtype: o tipo de saída dos dados. Se não for especificado, o tipo de dados será o mesmo que o da entrada.

Vamos dar um exemplo de numpy.arange.

1	import numpy as np
2
3	my_array = np.arange(1,10)
4	print(my_array)

O resultado do script acima é:

1	[1 2 3 4 5 6 7 8 9]

Remodelando uma matriz

Para remodelar uma matriz, usamos a função numpy.reshape. Esta função dá uma nova forma à matriz sem alterar seus dados. Conforme a documentação, a função tem os seguintes atributos: numpy.reshape (a, newshape, order = 'C'), onde a é a matriz que nós gostaríamos de remodelar, newshape é a nova forma desejada, desde que a nova forma seja compatível com a forma original, e order é um argumento opcional que refere-se à ordem do índice que gostaríamos de usar tanto para ler a matriz a quanto para colocar os elementos na matriz reformulada.

C significa ler/escrever os elementos usando uma ordem de índice no estilo C; F significa ler/escrever os elementos usando uma ordem de índice como no Fortran, e A significa ler/escrever os elementos com uma ordem de índice Fortran se a for Fortran com memória contígua, caso contrário será como C.

Eu se que o parágrafo acima parece complexo, mas o conceito é muito simples. Vamos tomar a matriz my_array e tentar remodelá-la. Lembre-se que a nova matriz (reformulada) tem de ser compatível com a matriz original. Por exemplo, my_array tem a forma (4,4); são 16 elementos na matriz, então a nova matriz tem que ter esse número de elementos.

Nós podemos remodelar my_array definindo-a com oito linhas e duas colunas, da seguinte forma:

1	import numpy as np
2	my_array = np.array(((6, 12, 93, 2),
3	(5, 26, 78, 90),
4	(3, 12, 16, 22),
5	(5, 3, 1, 16)))
6
7	my_array_reshaped = np.reshape(my_array, (8,2))

Nesse caso, teríamos a seguinte saída, onde também temos 16 elementos.

1	[[ 6 12]
2	[93 2]
3	[ 5 26]
4	[78 90]
5	[ 3 12]
6	[16 22]
7	[ 5 3]
8	[ 1 16]]

E se escrevemos a instrução de remodelagem da seguinte forma?

1	my_array_reshaped = np.reshape(my_array, (8,3))

Neste caso, será apresentado o seguinte erro:

1	ValueError: cannot reshape array of size 16 into shape (8,3)

Concatenação de matrizes

Se nós quisermos juntar duas ou mais matrizes com o mesmo formato ao longo de um eixo específico, nós podemos usar a função numpy.concatenate. A sintaxe desta função é: numnumpy.concatenate ((a1, a2,...), axis=0)y.concatenate. a1 e a2 são matrizes com a mesma forma, e axis é o eixo ao longo do qual se juntarão as matrizes, o valor padrão é 0.

Novamente, vamos dar um exemplo para simplificar o conceito. Neste exemplo, nós vamos juntar (concatenar) três matrizes.

import numpy as np
array_1 = np.array(((1, 2),
                   (3, 4)))

array_2 = np.array(((5, 6),
	               (7, 8))) 

array_3 = np.array(((9, 10),
	               (11, 12))) 

contacted_array = np.concatenate((array_1, array_2, array_3))

print('First Array: ')
print(array_1)
print('Second Array: ')
print(array_2)
print('Third Array: ')
print(array_3)
print('Concatenated Array: ')
print(contacted_array)

A saída do código acima é a seguinte:

1	First Array:
2	[[1 2]
3	[3 4]]
4	Second Array:
5	[[5 6]
6	[7 8]]
7	Third Array:
8	[[ 9 10]
9	[11 12]]
10	Concatenated Array:
11	[[ 1 2]
12	[ 3 4]
13	[ 5 6]
14	[ 7 8]
15	[ 9 10]
16	[11 12]]

Divisão de matrizes

Ao contrário do fizemos com as matrizes na seção acima, vamos ver como podemos dividir uma matriz em várias sub matrizes. Isso pode ser feito usando a seguinte função:

1	numpy.split(ary, indices_or_sections, axis=0)

ary é a matriz a ser dividida em sub matrizes. Quanto ao indices_or_sections, se é um número inteiro N, a matriz será dividida em N matrizes iguais ao longo do eixo. Se é uma matriz 1D de inteiros ordenados, as entradas indicam onde ao longo do eixo a matriz será dividida. axis é o eixo ao longo do qual será dividido.

O exemplo a seguir irá inverter o que fizemos no exemplo anterior, que deve retornar a matriz concatenada e seus componentes em três matrizes:

import numpy as np

concatenated_array = np.array(((1, 2),
    			       (3, 4),
				       (5, 6),
				       (7, 8),
				       (9, 10),
				       (11, 12)))

split_array = np.split(concatenated_array, 3)

print('Original Array:')
print(concatenated_array)
print('Split Sub-arrays:')
print('First Sub-array')
print(split_array[0])
print('Second Sub-array')
print(split_array[1])
print('Third Sub-array')
print(split_array[2])

A saída do script acima é:

1	Original Array:
2	[[ 1 2]
3	[ 3 4]
4	[ 5 6]
5	[ 7 8]
6	[ 9 10]
7	[11 12]]
8	Split Sub-arrays:
9	First Sub-array
10	[[1 2]
11	[3 4]]
12	Second Sub-array
13	[[5 6]
14	[7 8]]
15	Third Sub-array
16	[[ 9 10]
17	[11 12]]

Conclusão

Como vimos neste tutorial, o NumPy torna muito flexível trabalhar com matrizes. O tutorial foi apenas um arranhão na superfície desta interessante biblioteca Python. NumPy ainda tem muito mais recursos para se estudar e tirar o máximo proveito desta biblioteca. Um livro abrangente sobre o tema feito pelo próprio criador do NumPy é guia Guide to NumPy.

Além disso, veja o que temos disponível para venda e para estudo no marketplace e não hesite em fazer perguntas e fornecer seu feedback valioso usando o feed abaixo.