NumPy linspace (): Como criar matrizes de números uniformemente espaçados

Este tutorial irá ensiná-lo a usar NumPy linspace() para criar uma matriz de números espaçados uniformemente em Python.

Você aprenderá a sintaxe do NumPy linspace()seguido de exemplos que ajudarão você 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? Reunimos um guia de instalação rápida para você.

Vamos começar!

Instalar e importar NumPy

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

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

• Se você estiver usando Google Colab — um baseado em nuvem Notebook Jupyter ambiente, você pode importar o NumPy e começar a codificar imediatamente. (recomendado para este tutorial ✅)
• Se você deseja 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á tiver o Python instalado em seu computador, ainda poderá instalar a distribuição do 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óximo passo, importe numpy sob o pseudônimo np executando o seguinte comando. Fazer isso ajudará você a referenciar o NumPy como np-sem ter que digitar numpy toda vez que você acessar um item no módulo.

  import numpy as np

No futuro, usaremos a notação de ponto para acessar todas as funções da biblioteca NumPy assim: np.<func-name>.

O caso dos números uniformemente espaçados

Quando você está trabalhando com Matrizes NumPy haverá momentos em que você precisará criar uma matriz de números espaçados uniformemente 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 disso np.arange(start, stop, step) retorna uma matriz de números de start até mas não incluindo stopem passos de step; o tamanho padrão do passo é 1.

No entanto, o valor de Passo pode nem sempre ser óbvio. Vamos ver porque 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 passo 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 igualmente espaçados em (0,1) foi bastante fácil. Você sabe que o tamanho do passo entre os pontos deve ser 0,25.

Suponha que você tenha um exemplo um pouco mais complicado – onde você teve que listar 7 pontos igualmente espaçados entre 1 e 33. Aqui, o tamanho do passo pode não ser muito claro imediatamente. Você pode, no entanto, calcular manualmente o valor de step nesse caso.

No entanto, np.linspace() está aqui para tornar tudo 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 passo. E você receberá de volta o array conforme desejado.

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

Sintaxe do NumPy linspace()

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

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

A princípio, a sintaxe acima pode parecer muito complicada com muitos parâmetros.

No entanto, a maioria deles são opcional 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. Ambos start e stop podem ser escalares ou arrays. Vamos nos limitar aos 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 Falso para excluir o ponto final.
• retstep é outro parâmetro opcional que aceita 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 o start e a stop os valores são os próprios arrays.

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

Ele retorna uma matriz N-dimensional de números uniformemente espaçados. E se o parâmetro retstep está configurado para Trueele também retorna o tamanho do passo.

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 num números uniformemente espaçados 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 um array de 20 números igualmente espaçados no intervalo (1, 5).

Você pode especificar os valores de start, stope 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 na matriz retornada.

#2. No exemplo anterior, você passou os valores para start, stope num Como argumentos de palavras-chave. Se você passar os argumentos na ordem correta, você também pode usá-los como argumentos posicionais 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 para True.

Isso significa que a função agora retornará a matriz e a etapa. E podemos desempacotá-los em duas variáveis arr3: a matriz e step_size: o tamanho do passo 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 endpoint para Falsee verifique 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 duas matrizes, cada uma com 8 e 12 pontos, respectivamente.

Depois que isso estiver concluído, podemos usar a função de plotagem do matplotlib biblioteca 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. Aprenderemos sobre isso na próxima seção.

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

Depois de gerar uma matriz de números igualmente 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 a matriz y usando np.sin() na matriz x. Note que você pode pular o num parâmetro, pois o valor padrão é 50. Ainda o usaremos explicitamente.

Como próximo passo, você pode plotar a função seno no intervalo (0, 2π). Para fazer isso, você pode usar matplotlib , como no exemplo anterior. Especificamente, o plot() função em matplotlib.pytplot é usado 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 gráfico não é muito suave, já que você escolheu apenas 10 pontos no intervalo.

Em geral, quanto maior o número de pontos considerados, 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 num números uniformemente espaçados no intervalo (iniciar, parar).
• Defina o parâmetro opcional ponto final para Falso excluir Pare e defina o intervalo para (iniciar, parar).
• Definir passo de novo para Verdadeiro opcionalmente para obter o tamanho do passo.
• 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 Notebook Jupyter ou outro Alternativas do Jupyter você pode considerar.

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