NumPy linspace(): Gere Arrays com Números Uniformemente Espaçados em Python

Por

Guia Detalhado para Utilizar NumPy linspace() em Python

Este artigo tem como objetivo ensinar como empregar o método NumPy linspace() para gerar arrays contendo números distribuídos de forma uniforme em Python.

Será apresentada a sintaxe do linspace() do NumPy, juntamente com exemplos práticos que facilitarão a sua compreensão e utilização.

Importante: Para acompanhar este guia, é necessário que você tenha o Python e a biblioteca NumPy instalados.

Caso ainda não possua o NumPy, oferecemos um guia rápido de instalação para auxiliá-lo.

Vamos iniciar!

Instalação e Importação do NumPy

Antes de prosseguirmos com o tutorial, vamos recapitular os passos para a instalação da biblioteca NumPy.

⏩ Caso o NumPy já esteja instalado em seu ambiente, pode avançar para a próxima seção.

  • Se você está usando o Google Colab, um ambiente Jupyter notebook baseado na nuvem, você pode importar o NumPy e iniciar o desenvolvimento imediatamente. (Recomendado para este guia ✅)
  • Se você prefere configurar um ambiente local, sugerimos a instalação da distribuição Anaconda do Python. O Anaconda já inclui diversos pacotes essenciais pré-instalados. Você pode baixar o instalador adequado ao seu sistema operacional. O processo de instalação é rápido e simples. ⌛
  • Mesmo que já tenha o Python instalado no seu computador, você também pode instalar a distribuição Anaconda. É possível utilizar o conda ou o pip para instalar e gerenciar pacotes. Execute um dos seguintes comandos no Prompt de Comando do Anaconda para instalar o NumPy.
    # Instalar NumPy usando conda
    conda install numpy

    # Instalar NumPy usando pip
    pip install numpy

O próximo passo é importar o NumPy usando o alias np, conforme o comando a seguir. Isso simplificará o acesso às funções do NumPy, permitindo referenciá-lo como np, evitando ter que digitar numpy a cada acesso a um item do módulo.

    import numpy as np

A partir de agora, empregaremos a notação de ponto para acessar todas as funcionalidades da biblioteca NumPy, como: np..

A Necessidade de Números Uniformemente Espaçados

Durante o trabalho com arrays NumPy, frequentemente surge a necessidade de criar um array de números com espaçamento uniforme dentro de um intervalo específico.

Antes de prosseguirmos, vamos revisar brevemente outra função relacionada: np.arange().

NumPy linspace() vs. NumPy arange()

Se você já utilizou o NumPy, provavelmente já usou np.arange() para gerar um array de números dentro de um determinado intervalo.

Como você já sabe, np.arange(start, stop, step) retorna um array de números, iniciando em start e terminando antes de stop, com um incremento de step. O valor padrão do incremento é 1.

No entanto, o valor do incremento nem sempre é claro. Vejamos um exemplo para ilustrar essa situação.

Por exemplo, se você necessitar de 4 números igualmente espaçados entre 0 e 1, o incremento deve ser de 0.25. Porém, ao usar np.arange(), o valor final 1 não é incluído. Portanto, será necessário escolher um intervalo que vá além do valor desejado.

A imagem seguinte ilustra mais alguns casos onde se necessita um número específico de pontos uniformemente distribuídos no intervalo [a, b].

Pontos uniformemente espaçados em um intervalo

O primeiro exemplo, com 4 pontos uniformemente distribuídos em [0, 1], foi simples. O incremento entre os pontos era 0.25.

Considere um cenário um pouco mais complexo, como listar 7 pontos uniformemente espaçados entre 1 e 33. Aqui, o incremento não é tão evidente. Embora seja possível calculá-lo manualmente.

Felizmente, np.linspace() simplifica este processo! 😄

Utilize o método linspace do NumPy

Ao empregar np.linspace(), basta definir o número de pontos desejados no intervalo, sem a necessidade de se preocupar com o valor do incremento. O array será gerado conforme o especificado.

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

Sintaxe do NumPy linspace()

A sintaxe para utilizar o linspace() do NumPy é:

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

A princípio, a sintaxe pode parecer complexa devido à quantidade de parâmetros.

Contudo, a maioria dos parâmetros é opcional, e simplificaremos essa sintaxe em breve.

Vamos detalhar a sintaxe:

  • start e stop representam os pontos inicial e final do intervalo, respectivamente. Ambos podem ser valores escalares ou arrays. Neste guia, limitaremos o uso a valores escalares iniciais e finais.
  • num é o número de pontos uniformemente espaçados desejados. Este parâmetro é opcional e possui um valor padrão de 50.
  • endpoint é outro 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. Você pode definir como False para excluí-lo.
  • retstep é um parâmetro opcional que recebe um valor booleano (True ou False). Ao ser definido como True, o valor do incremento é retornado.
  • dtype especifica o tipo de dado dos números no array. O tipo é geralmente inferido como float e não necessita ser fornecido explicitamente.
  • axis é um parâmetro opcional que define o eixo em que os números serão armazenados. É relevante quando os valores inicial e final são arrays.

▶️ O que o np.linspace() retorna?

Ele retorna um array N-dimensional de números uniformemente espaçados. E se o parâmetro retstep for definido como True, o tamanho do passo também será retornado.

Com base no que vimos, apresentamos uma sintaxe simplificada para o uso de np.linspace():

    np.linspace(start, stop, num)

O código acima retornará um array de números uniformemente espaçados no intervalo [start, stop].

Agora que você conhece a sintaxe, vamos começar com exemplos práticos.

Como Criar Arrays Uniformemente Espaçados com NumPy linspace()

#1. Para nosso primeiro exemplo, vamos criar um array com 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. O código a seguir ilustra isso:

    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 que os números no array começam em 1 e terminam em 5, incluindo os pontos inicial e final. Além disso, todos os números, incluindo os pontos 1 e 5, são representados como float no array retornado.

#2. No exemplo anterior, os valores para start, stop e num foram passados como argumentos de palavra-chave. Se você passar os argumentos na ordem correta, poderá usar apenas os valores como argumentos posicionais, 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 um array onde definimos retstep como True.

Isso significa que a função retornará o array e o tamanho do passo. Podemos descompactá-los em duas variáveis: arr3 (o array) e step_size (o tamanho do passo).

O código a seguir ilustra como realizar essa operação.

    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 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]

No array retornado, você pode ver que o valor 1 está incluído, enquanto o valor 5 não está. O último valor no array é 4.8, mas ainda temos 20 números.

Até agora, geramos apenas arrays de números uniformemente espaçados. Na próxima seção, vamos visualizar esses números através de gráficos.

Como Plotar Números Uniformemente Espaçados em um Intervalo

Nesta seção, utilizaremos o intervalo [10, 15]. Em seguida, usaremos np.linspace() para gerar dois arrays, um com 8 pontos e outro com 12 pontos.

Após gerar os arrays, utilizaremos a função de plotagem da biblioteca Matplotlib para visualizar os resultados.

Para facilitar a visualização, vamos posicionar os dois arrays, com N1 = 8 e N2 = 12 pontos, em diferentes alturas no eixo y.

O 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 criação de pontos uniformemente espaçados é útil em diversas tarefas, como no trabalho com funções matemáticas. Vamos explorar isso na próxima seção.

Como Usar NumPy linspace() com Funções Matemáticas

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

No código abaixo, geramos 50 pontos uniformemente espaçados no intervalo de 0 a 2π. Em seguida, criamos o array y utilizando np.sin() no array x. Note que o parâmetro num pode ser omitido, pois o valor padrão é 50. No entanto, vamos utilizá-lo explicitamente.

Em seguida, plotamos a função seno no intervalo [0, 2π]. Para isso, utilizamos a biblioteca matplotlib, como no exemplo anterior. Especificamente, a função plot() em matplotlib.pyplot é utilizada para criar o gráfico.

    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 como 10. Você obterá o gráfico da figura abaixo.

Como se pode observar, o gráfico não é suave, devido ao número limitado de pontos utilizados (10 pontos no intervalo).

De forma 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 foi aprendido:

  • np.linspace(start, stop, num) retorna um array de números uniformemente espaçados no intervalo [start, stop].
  • Defina o parâmetro opcional endpoint como False para excluir o valor de parada, definindo o intervalo como [start, stop).
  • Defina o parâmetro opcional retstep como True para obter o tamanho do passo.
  • Gere arrays uniformemente espaçados com np.linspace() e use o array com funções matemáticas.

Esperamos que você agora compreenda como np.linspace() funciona. Você pode executar os exemplos deste guia em um notebook Jupyter. Consulte nosso guia sobre o Jupyter notebook ou outras alternativas de Jupyter que você pode considerar.

Nos vemos em breve em outro guia sobre Python. Até lá, continue codificando! 😀