NumPy - Como criar e inicializar Arrays em Python

 Neste tutorial, vamos te ensinar como usar a biblioteca NumPy para declarar, inicializar e usar Arrays em Python.

Este tutorial faz parte de nosso curso Programação Científica - Computação Numérica e Data Science com Python.

Como importar o módulo NumPy

Para podermos usar a biblioteca NumPy, a primeira coisa que temos que fazer é...'colocar' ela em nosso código. Ou seja, deixar claro para o Python que iremos usar o módulo numpy, e fazemos isso com o comando import: 

• import numpy

Agora, basta usarmos o nome numpy seguido de um ponto, e em seguida o recurso que você deseja acessar/usar, da biblioteca. Por exemplos, para imprimirmos o valor do número pi:

1. import numpy
2. print(numpy.pi)

Teste sempre nossos exemplos de código. Sempre.

Porém, é bem comum darmos algum 'apelido' para essas bibliotecas, geralmente algum nome mais curto e simples, para evitar ficarmos repetindo um comando maior. Por exemplo, vamos dar o apelido de 'np' para a NumPy:

1. import numpy as np
2. print(np.e)

No exemplo acima, pegamos o valor da constante de Euler, muito usada em logaritmos.

Como criar Arrays a partir de Listas e Tuplas

Vamos usar a função numpy.array() para criar e inicializar nossos arrays com valores específicos. No exemplo a seguir, vamos passar a lista [1, 2, 3]:

import numpy as np MeuArray = np.array( [1,2,3] ) print(MeuArray)

Saída: [1 2 3]

Agora, vamos primeiro criar uma variável de nome MinhaTupla, colocar uma Tupla contendo strings nela e passar essa variável direto para a função array():

import numpy as np MinhaTupla = ("Python", "Java", "C++") MeuArray = np.array( MinhaTupla ) print(MeuArray)

Saída: ['Python' 'Java' 'C++']

Para criarmos arrays multidimensionais, basta ir separando as sequências (listas ou tuplas) por vírgulas. Por exemplo, vamos criar uma matriz 3x3 de floats:

import numpy as np MeuArray = np.array([ [1.1, 2.4, 5.4], [5.5, 7.6, 8.9], [9.1, 0.0, 2.1] ]) print(MeuArray)

Saída:
[[1.1 2.4 5.4]
 [5.5 7.6 8.9]
 [9.1 0.  2.1]]

Veja que a as três listas estão dentro de um par de colchetes também.

Inicializando Arrays com Zeros e Um

Muitas vezes, em exatas, vamos precisar inicializar vetores e matrizes com alguns números constantes, como 0 e 1.

Por exemplo, se você vai contar algo, precisa que sua variável parta do 0, logo você tem que inicializar ela com zero. Outras vezes, como em Álgebra Linear, podemos querer inicializar uma matriz com todos seus elementos tendo valores 1.

Para isso, usaremos as funções numpy.zeros() e numpy.ones(), respectivamente.
Para isto, basta passarmos as dimensões do array que você quer inicializar.

Por exemplo, um array de valores nulos, com 5 elementos:

import numpy as np MeuArray = np.zeros(5) print(MeuArray)

Já para criar uma matriz de 4x3 preenchidas de valores unitários, fazemos:

import numpy as np MeuArray = np.ones( (4,3) ) print(MeuArray)

Note que colocamos as dimensões dentro de um par de parêntesis.

E se quisermos um array todo preenchido com o valor de Pi, por exemplo?
Muito simples, basta multiplicar o valor de Pi pela função ones():

import numpy as np MeuArray = np.pi * np.ones( 10 ) print(MeuArray)

Note que para inicializar um arrays com valores diferentes de 0 e 1, usamos dois passos: invocar a função zeros() ou ones() e depois multiplicar. É possível fazer isso chamando apenas uma função, a full(), onde primeiro informamos a dimensão de nosso array e em seguida o valor que queremos inicializar todos os elementos.

Por exemplo, uma matriz 2x2 toda inicializada com o valor 2112:

import numpy as np MeuArray = np.full((2,2),2112) print(MeuArray)

arange(): inicializando um array com uma sequência numérica

Temos no módulo NumPy uma função semelhante a função range() do Python, mas para lidarmos de maneira bem eficiente com arrays, é a arange().

Por exemplo, se quisermos um array com os 100 primeiros números inteiros, fazemos simplesmente:

import numpy as np MeuArray = np.arange(100) print(MeuArray)

Saída:
[ 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 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99]

Importante notar que, na arange(), ao fornecermos um valor n, o NumPy vai inicializar com os valores de 0 até n-1, ou seja, nunca inclui o número n.

A arange() vai mais além (assim como a range() ). Podemos definir o ponto inicial, o final e o step ou pulo, que os valores vão dar. Por exemplo, para inicializar os elementos de um array com todos os números pares, de 0 até 100 (incluindo este), fazemos: 

import numpy as np MeuArray = np.arange(0,101,2) print(MeuArray)

Saída: [  0   2   4   6   8  10  12  14  16  18  20  22  24  26  28  30  32  34 36  38  40  42  44  46  48  50  52  54  56  58  60  62  64  66  68  70 72  74  76  78  80  82  84  86  88  90  92  94  96  98 100]

linspace(): definindo o número de intervalos da sequência

Se usarmos valores do tipo float (decimais), a arange() irá fazer alguns arredondamentos, o que pode acarretar um problema: não sabermos quantos valores o array terá.

Para contornar isso, temos uma função bem parecida, a linspace(), onde vamos deixar bem claro quantos intervalos teremos:

• numpy.linspace(inicio, fim, numero_termos)

Ou seja, não vamos definir o valor do step e sim o número de intervalos que queremos.
Por exemplo, para termos um array com valores de 0 até 10, divididos em 11 espaçamentos, fazemos:

import numpy as np MeuArray = np.linspace(0, 10, 11)

Saída: array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

Note que, na saída anterior, o valor 10 apareceu. Na linspace(), o elemento final aparece, diferente da arange(). Note também que o resultado da linspace() está em formato float (com casas decimais).
Recomendamos usar a arange() com valores inteiros e a linspace() com valores decimais.

Veja bem, o step na arange() é para você incrementar a sequência de step em step.
O step na linspace() é para você definir quantos intervalos você quer quebrar a sequência (inicio,fim)

Em nossa apostila Programação Científica em Python, vamos te mostrar e explicar o código para produzir o gráfico abaixo, usando a linspace(), de uma função seno, variando de 0 até 2pi:

Como criar array de matrizes

O NumPy também oferece uma vasta de opções para trabalharmos diretamente com matrizes.
Por exemplo, para criar uma matriz identidade de dimensão 5 (ou seja, uma matriz com os elementos da diagonal principal com valor 1 e valor 0 para os demais), usamos a função identity():

import numpy as np matriz = np.identity(5)

Saída:

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

Podemos também 'deslocar' essa diagonal de valor, usando a função eye(), que recebe dois argumentos:

1. O primeiro é o da dimensão da matriz
2. O segundo é o argumento k, que é o offset, ou seja, o deslocamento. Se for positivo, subimos essa diagonal de 1's e se for negativo, descemos a diagona de números 1

Por exemplo, uma matriz de dimensão 6 com a diagonal deslocada para a diagonal imediatamente acima:

import numpy as np matriz = np.eye(5,k=1)

Saída:

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

Agora uma matriz de dimensão 7, com um offset de dois:

import numpy as np matriz = np.eye(7,k=-2)

Saída:

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

Também é possível criar uma matriz cuja a diagonal principal recebe uma lista qualquer de valores, para isso bastando usar a função diag(). A dimensão de nossa matriz será a mesma dessa sequência de valores. Por exemplo, uma matriz de dimensão 10 com os números 0, 1, 2, 3, 4, 5, 6, 7, 8 e 9:

import numpy as np matriz = np.diag( np.arange(0,10,1) )

Saída:

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

Essa função também aceita um argumento k de offset.

Exercício: que valor devemos passar para a função eye() para que ela seja igual a identity()? Ou seja, para preencher a diagonal principal.