Como criar matrizes de números uniformemente espaçados

Este tutorial ensinará como usar NumPy linspace() para criar uma matriz de números uniformemente espaçados em Python.

Você aprenderá a sintaxe do NumPy linspace(), seguido de exemplos que o ajudarão a entender como usá-lo.

Observação: Para acompanhar este tutorial, você precisa ter o Python e o NumPy instalados.

Ainda não tem NumPy? Preparamos um guia de instalação rápida para você.

Vamos começar!

Instalar e importar o NumPy

Antes de iniciar o tutorial, vamos executar rapidamente as etapas para instalar a biblioteca NumPy.

⏩ Se você já tem o NumPy instalado, sinta-se à vontade para pular para a próxima seção.

• Se você estiver usando o Google Colab, um ambiente de notebook Jupyter baseado em nuvem, poderá importar o NumPy e começar a codificar imediatamente. (recomendado para este tutorial ✅)
• Se você quiser configurar um ambiente de trabalho local, recomendo instalar a distribuição Anaconda do Python. O Anaconda vem com vários pacotes úteis pré-instalados. Você pode baixar o instalador para o seu sistema operacional. O processo de configuração leva apenas alguns minutos.⌛
• Se você já tem o Python instalado em seu computador, ainda pode instalar a distribuição Anaconda. Você pode usar conda ou pip para instalar e gerenciar pacotes. Você pode executar um dos seguintes comandos no Prompt de Comando do Anaconda para instalar o NumPy.

# Install NumPy using conda
conda install numpy

# Install NumPy using pip
pip install numpy

Como próxima etapa, importe numpy sob o alias np executando o seguinte comando. Fazer isso irá ajudá-lo a referenciar o NumPy como np—sem ter que digitar numpy toda vez que você ar um item no módulo.

import numpy as np

Daqui para frente, usaremos a notação de ponto para ar todas as funções na biblioteca NumPy como esta: np. .

O caso dos números uniformemente espaçados

Quando você está trabalhando com matrizes NumPy, há momentos em que você precisará criar uma matriz de números uniformemente espaçados em um intervalo.

Antes de prosseguirmos, vamos examinar rapidamente outra função semelhante np.arange().

NumPy linspace() vs. NumPy arange()

Se você já usou NumPy antes, provavelmente teria usado np.arange() para criar uma matriz de números dentro de um intervalo especificado.

Você sabe que np.arange(start, stop, step) retorna uma matriz de números desde o início até a parada, mas não incluindo a parada, em etapas de etapa; o tamanho padrão do o é 1.

No entanto, o valor de degrau pode nem sempre ser óbvio. Vamos ver por que este é o caso.

Por exemplo, se você precisar de 4 números igualmente espaçados entre 0 e 1, você sabe que o tamanho do o deve ser 0,25. Mas se você estiver usando np.arange(), ele não inclui o valor de parada de 1. Portanto, você terá que escolher um intervalo que vá além do valor de parada.

A imagem a seguir ilustra mais alguns exemplos em que você precisa de um número específico de pontos uniformemente espaçados no intervalo [a, b].

Nosso primeiro exemplo de 4 pontos uniformemente espaçados em [0,1] foi bastante fácil. Você sabe que o tamanho do o entre os pontos deve ser 0,25.

Suponha que você tenha um exemplo um pouco mais complicado – onde você teve que listar 7 pontos uniformemente espaçados entre 1 e 33. Aqui, o tamanho do o pode não ficar muito claro imediatamente. Você pode, no entanto, calcular manualmente o valor da etapa neste caso.

No entanto, np.linspace() está aqui para torná-lo ainda mais simples para você! 😄

Ao usar np.linspace(), você só precisa especificar o número de pontos no intervalo—sem se preocupar com o tamanho do o. E você receberá de volta a matriz conforme desejado.

Com essa motivação, vamos aprender a sintaxe do NumPy linspace() na próxima seção.

Sintaxe de NumPy linspace()

A sintaxe para usar o NumPy linspace() é mostrada abaixo:

np.linspace(start, stop, num, endpoint, retstep, dtype, axis)

No início, a sintaxe acima pode parecer muito complicada com muitos parâmetros.

No entanto, a maioria deles são parâmetros, e chegaremos a uma sintaxe muito mais simples em apenas alguns minutos.

Agora vamos começar analisando a sintaxe acima:

• start e stop são os pontos inicial e final do intervalo, respectivamente. Tanto o start quanto o stop podem ser escalares ou arrays. Vamos nos limitar a valores iniciais e finais escalares neste tutorial.
• num é o número de pontos uniformemente espaçados. E é um parâmetro opcional com um valor padrão de 50.
• endpoint também é um parâmetro opcional que pode ser True ou False.
• O valor padrão é True, o que significa que o ponto final será incluído no intervalo por padrão. No entanto, você pode defini-lo como False para excluir o ponto final.
• retstep é mais um parâmetro opcional que recebe os booleanos True ou False. Quando definido como True, o valor da etapa é retornado.
• dtype é o tipo de dados dos números na matriz. O tipo geralmente é inferido como float e não precisa ser fornecido explicitamente.
• axis é outro parâmetro opcional que indica o eixo ao longo do qual os números devem ser armazenados. E isso é relevante apenas quando os valores inicial e final são os próprios arrays.

▶️ Então, o que np.linspace() retorna?

Ele retorna uma matriz N-dimensional de números uniformemente espaçados. E se o parâmetro retstep estiver definido como True, ele também retornará o tamanho do o.

Com base na discussão até agora, aqui está uma sintaxe simplificada para usar np.linspace():

np.linspace(start, stop, num)

A linha de código acima retornará uma matriz de números espaçados uniformemente no intervalo [start, stop].

Agora que você conhece a sintaxe, vamos começar a codificar exemplos.

Como criar matrizes uniformemente espaçadas com NumPy linspace ()

#1. Como nosso primeiro exemplo, vamos criar uma matriz de 20 números uniformemente espaçados no intervalo [1, 5].

Você pode especificar os valores de start, stop e num como argumentos de palavra-chave. Isso é mostrado na célula de código abaixo:

import numpy as np
arr1 = np.linspace(start = 1,stop = 5,num = 20)
print(arr1)

# Output:
[1.         1.21052632 1.42105263 1.63157895 1.84210526 2.05263158
 2.26315789 2.47368421 2.68421053 2.89473684 3.10526316 3.31578947
 3.52631579 3.73684211 3.94736842 4.15789474 4.36842105 4.57894737
 4.78947368 5.        ]

Observe como os números na matriz começam em 1 e terminam em 5 – incluindo os dois pontos finais. Além disso, observe como os números, incluindo os pontos 1 e 5, são representados como float no array retornado.

#2. No exemplo anterior, você ou os valores para start, stop e num como . Se você ar os argumentos na ordem correta, poderá usá-los apenas com os valores, conforme mostrado abaixo.

import numpy as np
arr2 = np.linspace(1,5,20)
print(arr2)

# Output:
[1.         1.21052632 1.42105263 1.63157895 1.84210526 2.05263158
 2.26315789 2.47368421 2.68421053 2.89473684 3.10526316 3.31578947
 3.52631579 3.73684211 3.94736842 4.15789474 4.36842105 4.57894737
 4.78947368 5.        ]

#3. Agora vamos criar outro array onde definimos retstep como True.

Isso significa que a função agora retornará tanto a matriz quanto a etapa. E podemos descompactá-los em duas variáveis ​​arr3: o array e step_size: o tamanho do o retornado.

A célula de código a seguir explica como você pode fazer isso.

import numpy as np
arr3, step_size = np.linspace(1,5,20,retstep = True)
print(arr3)

# Output:
[1.         1.21052632 1.42105263 1.63157895 1.84210526 2.05263158
 2.26315789 2.47368421 2.68421053 2.89473684 3.10526316 3.31578947
 3.52631579 3.73684211 3.94736842 4.15789474 4.36842105 4.57894737
 4.78947368 5.        ]

# Output:
print(step_size)
0.21052631578947367

#4. Como exemplo final, vamos definir o endpoint como False e verificar o que acontece.

import numpy as np
arr4 = np.linspace(1,5,20,endpoint = False)
print(arr4)

# Output:
[1.  1.2 1.4 1.6 1.8 2.  2.2 2.4 2.6 2.8 3.  3.2 3.4 3.6 3.8 
4.  4.2 4.4 4.6 4.8]

Na matriz retornada, você pode ver que 1 está incluído, enquanto 5 não está incluído. E o último valor na matriz é 4,8, mas ainda temos 20 números.

Até agora, geramos apenas matrizes de números uniformemente espaçados. Na próxima seção, vamos visualizar plotando esses números.

Como plotar números uniformemente espaçados em um intervalo

Nesta seção, vamos escolher [10,15] como o intervalo de interesse. E então, use np.linspace() para gerar dois arrays, cada um com 8 e 12 pontos, respectivamente.

Depois que isso estiver concluído, podemos usar a função de plotagem da biblioteca matplotlib para plotá-los.

Para maior clareza, vamos prender as duas matrizes de N1 = 8 e N2 = 12 pontos uniformemente espaçados em diferentes posições ao longo do eixo y.

O trecho de código a seguir demonstra isso.

import numpy as np
import matplotlib.pyplot as plt

N1 = 8
N2 = 12

a = 10
b = 15

y1 = np.zeros(N1)
y2 = np.zeros(N2)

x1 = np.linspace(a, b, N1)
x2 = np.linspace(a, b, N2)

plt.plot(x1, y1-0.5, 'o')
plt.plot(x2, y2 + 0.5, 'o')

plt.ylim([-1, 1])

plt.title(f'Evenly Spaced Numbers in the Interval [{a},{b}]')
plt.xlabel('Interval')

plt.show()

A geração de pontos uniformemente espaçados pode ser útil ao trabalhar com funções matemáticas. Vamos aprender sobre isso na próxima seção.

Como usar NumPy linspace () com funções matemáticas

Depois de gerar um array de números uniformemente espaçados usando np.linspace(), você pode calcular os valores das funções matemáticas no intervalo.

Na célula de código abaixo, você primeiro gera 50 pontos uniformemente espaçados no intervalo de 0 a 2π. E então crie o array y usando np.sin() no array x. Observe que você pode pular o parâmetro num, pois o valor padrão é 50. Ainda o usaremos explicitamente.

Como próximo o, você pode plotar a função seno no intervalo [0, 2π]. Para fazer isso, você pode usar matplotlib, como no exemplo anterior. Especificamente, a função plot() em matplotlib.pytplot é usada para criar um gráfico de linha.

import numpy as np
import matplotlib.pyplot as plt

N = 50

a = 0.0
b = 2*np.pi

x = np.linspace(a, b, N)
y = np.sin(x)

plt.plot(x, y, marker = "o")

plt.ylim([-1, 1])
plt.title(f'y = sin(x)')
plt.xlabel('x ---->')

plt.show()

Agora, execute o código acima definindo N igual a 10. Você obterá o gráfico conforme mostrado na figura abaixo.

E você pode ver que o enredo não é muito suave, pois você só escolheu 10 pontos no intervalo.

Em geral, quanto maior o número de pontos que você considera, mais suave será o gráfico da função.

Conclusão

Aqui está um resumo do que aprendemos.

• np.linspace(iniciar, parar, num) retorna uma matriz de número números uniformemente espaçados no intervalo [start, stop].
• Defina o parâmetro opcional ponto final para Falso excluir Paree defina o intervalo para [começarparar)[startstop).
• Definir refazer para Verdadeiro opcionalmente para obter o tamanho do o.
• Gere arrays uniformemente espaçados usando np.linspace()e, em seguida, use a matriz com funções matemáticas.

Espero que agora você entenda como np.linspace() funciona. Você pode optar por executar os exemplos acima no notebook Jupyter. Confira nosso guia sobre o notebook Jupyter ou outras alternativas do Jupyter que você pode considerar.

Vejo vocês em breve em outro tutorial Python. Até lá, continue codificando!😀