Tweet

Como preencher arrays com NumPy (ndarrays)

Na lição anterior vimos como criar arrays de até três dimensões em Python usando a biblioteca NumPy. Vimos também como atribuir valores a um array no momento de sua criação.

É possível preencher um array de outras formas, por exemplo com valores específicos ou repetidos, o que pode ser útil em determinadas circunstâncias ou em cálculos especiais, por exemplo, em álgebra linear.

O método mais usual de preenchimento de um array em NumPy consiste em passar valores a partir de uma lista ao criar o array, como vimos na aula anterior. Porém, podemos preencher arrays específicos de outras formas também.

Algumas das formas especiais de preenchimento de arrays incluem:

• Preenchimento com zeros
• Preenchimento com uns
• Preenchimento com outro valor numérico repetido
• Preenchimento a partir de uma faixa de valores
• Preenchimento com números gerados aleatoriamente

Vamos estudar cada uma dessas técnicas a partir de agora.

Preencher array com valores específicos

Com os métodos zeros, ones e full podemos criar arrays preenchidos automaticamente com zeros, uns ou com um valor numérico específico, respectivamente.

Os métodos zeros e ones produzem valores do tipo float64 por padrão, mas podemos alterar o tipo de dado se for necessário.

Vejamos alguns exemplos desses métodos.

# Criar array com 10 elementos iguais a 0
print(np.zeros(10))

[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]

# Criar array com 15 elementos iguais a 1
print(np.ones(15))

[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

# Criar array com 8 elementos iguais a 12 (int).
# O primeiro argumento corresponde ao número de elementos desejados.
print(np.full(8,12)) 

[12 12 12 12 12 12 12 12]

# Criar array com 10 elementos iguais a 0, do tipo inteiro
print(np.zeros(10, dtype=int))

# Criar array com 15 elementos iguais a 1, do tipo inteiro
print(np.ones(15, dtype=int))

# Criar array com 8 elementos iguais a 12, do tipo ponto flutuante
print(np.full(8,12, dtype=float)) # primeiro argumento: núm. de elementos.

[0 0 0 0 0 0 0 0 0 0]
[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]
[12. 12. 12. 12. 12. 12. 12. 12.]

# Criar um array bidimensional 2x5 preenchido com zeros, do tipo inteiro:
print(np.zeros((2, 5),dtype=int))

[[0 0 0 0 0]
 [0 0 0 0 0]]

Criar array a partir de faixas de valores: método arange

Também é possível criar um array  a partir de uma faixa de valores especificada, tanto de números inteiros quanto de números de ponto flutuante.

Para isso usamos os métodos arange e linspace.

Criar array com método arange

# Array de 10 elementos, números de 0 a 9
print(np.arange(10))

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

# Array de 10 elementos float, números de 0 a 9
print(np.arange(10.))

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

Basta usar um ponto . na definição da quantidade de elementos do array e automaticamente a função irá criar números de ponto flutuante em vez de números inteiros.

# Array com valores no intervalo de 5 a 15 (usamos 16, pois o último número é sempre limite superior - 1)
print(np.arange(5,16))

[ 5  6  7  8  9 10 11 12 13 14 15]

# Array com os números pares de 50 até 1
# O terceiro argumento, -2, indica o intervalo de contagem dos valores ("passo").
print(np.arange(50, 1, -2))

[50 48 46 44 42 40 38 36 34 32 30 28 26 24 22 20 18 16 14 12 10  8  6  4  2]

Criar array com método linspace

# Criar array com valores de ponto flutuante com o método linspace. 
print(np.linspace(0.0,2.0,num=5))

[0.  0.5 1.  1.5 2. ]

Os argumentos passados para o método linspace são:

• primeiro argumento: valor inicial
• segundo argumento: valor final
• terceiro argumento (num): quantidade de itens a gerar

Preencher array com valores aleatórios (randômicos)

Podemos criar arrays e preenchê-los com números aleatórios, inteiros ou de ponto flutuante, usando os métodos rand e randint da biblioteca NumPy.

# Criar e preencher array com valores aleatórios

import numpy as np

# Array de 10 elementos entre 0 e 1
a = np.random.rand(10)
print(a)

[0.07418479 0.95672716 0.19361192 0.32394591 0.29980946 0.20812523
 0.92100292 0.49129843 0.78413243 0.07830975]

# Gerar um número aleatório inteiro entre 0 e 8 com random.randint
print('Número aleatório:', np.random.randint(9))

Número aleatório: 3

# Array unidimensional com 10 números aleatórios inteiros entre 1o e 20
b = np.random.randint(10,21,size=10)
print(b)

[13 17 16 16 16 12 18 15 14 12]

# Array bidimensional 3x3
c = np.random.rand(3,3)
print(c)

[[0.56700019 0.56581178 0.47336097]
 [0.5626577  0.75670315 0.8608974 ]
 [0.71296439 0.09674716 0.95800157]]

# Array bidimensional 10x10 com números aleatórios inteiros entre 1 e 100
d = np.random.randint(1,101,size=(10,10))
print(d)

[[ 50  55  74  93  77  42  71  69  44  50]
 [ 13  13  79  50  82  75  91  11  79  26]
 [ 76  47  59  79  20  58  30  20  22  36]
 [ 13  81   9  77  34  21   3  91  21  29]
 [ 88  38  76 100   9  18  20  11  39  94]
 [ 45  23  81  13  59   1  13  44  36  33]
 [ 48  93  82  99  97  39  94  23  41  86]
 [ 17  21  65  52  85  87  15  75  50  75]
 [ 61  35  17  52  71  32  29  61  21  62]
 [ 66  19  78  47  92  23  52  58  81  68]]

É isso aí! Nesta lição aprendemos como preencher um ndarray em NumPy usando métodos variados, que permitem atribuir valores específicos, listas de valores ou valores gerados de forma aleatória ao array.

Aproveite e assista a uma aula em vídeo sobre o preenchimento de arrays em NumPy:

Até a próxima!