Pular para o conteúdo
CodeMDD.io | Coding Tutorials

Como usar np.linspace para gerar sequências de números igualmente espaçados

CodeMDD.io

np.linspace(): Criando Arrays Espaçados Uniformemente ou Não Uniformemente

por Stephen Gruppetta (data-science)

Quando você está trabalhando com aplicações numéricas usando o NumPy, muitas vezes você precisa criar um array de números. Em muitos casos, você deseja que os números estejam espaçados uniformemente, mas também há momentos em que você pode precisar de números não uniformemente espaçados. Uma das principais ferramentas que você pode usar em ambas as situações é o np.linspace().

Em sua forma básica, np.linspace() pode parecer relativamente simples de usar. No entanto, é uma parte essencial do kit de ferramentas de programação numérica. É extremamente versátil e poderoso. Neste tutorial, você descobrirá como usar essa função de forma eficaz.

Neste tutorial, você aprenderá como:

  • Criar uma sequência de números espaçados uniformemente ou não uniformemente
  • Decidir quando usar o np.linspace() em vez de outras ferramentas alternativas
  • Usar os parâmetros de entrada necessários e opcionais
  • Criar arrays com duas ou mais dimensões
  • Representar funções matemáticas na forma discreta

Este tutorial parte do pressuposto de que você já está familiarizado com o básico do NumPy e com o tipo de dados ndarray. Você começará aprendendo sobre várias maneiras de criar uma sequência de números em Python. Em seguida, você examinará mais de perto todas as formas de usar o np.linspace() e como usá-lo de forma eficaz em seus programas.

Grátis: Clique aqui para ter acesso a um Guia de Recursos do NumPy gratuito que aponta para os melhores tutoriais, vídeos e livros para melhorar suas habilidades em NumPy.

Criando Sequências de Números com Espaçamento Uniforme

Existem várias maneiras de criar uma sequência de números espaçados uniformemente em Python. O np.linspace() permite que você faça isso e personalize o intervalo para atender às suas necessidades específicas, mas não é a única maneira de criar uma sequência de números. Na próxima seção, você aprenderá como usar o np.linspace() antes de compará-lo com outras maneiras de criar sequências de números espaçados uniformemente.

Usando o np.linspace()

O np.linspace() possui dois parâmetros obrigatórios: start e stop, que você pode usar para definir o início e o fim do intervalo:

Python

import numpy as np
np.linspace(1, 10)

Ao executar este código, você obterá o seguinte array:

array([ 1.        ,  1.18367347,  1.36734694,  1.55102041,  1.73469388,
        1.91836735,  2.10204082,  2.28571429,  2.46938776,  2.65306122,
        2.83673469,  3.02040816,  3.20408163,  3.3877551 ,  3.57142857,
        3.75510204,  3.93877551,  4.12244898,  4.30612245,  4.48979592,
        4.67346939,  4.85714286,  5.04081633,  5.2244898 ,  5.40816327,
        5.59183673,  5.7755102 ,  5.95918367,  6.14285714,  6.32653061,
        6.51020408,  6.69387755,  6.87755102,  7.06122449,  7.24489796,
        7.42857143,  7.6122449 ,  7.79591837,  7.97959184,  8.16326531,
        8.34693878,  8.53061224,  8.71428571,  8.89795918,  9.08163265,
        9.26530612,  9.44897959,  9.63265306,  9.81632653, 10.        ])

Este array contém 50 números espaçados uniformemente entre 1 e 10. O número de elementos no array é controlado pelo parâmetro num, que por padrão é definido como 50.

Você também pode especificar o número de elementos no array:

np.linspace(1, 10, num=20)

Neste caso, você obterá um array com 20 números espaçados uniformemente entre 1 e 10.

Usando range() e List Comprehensions

Uma maneira alternativa de criar uma sequência de números espaçados uniformemente é usar a função range() em conjunto com list comprehensions. Aqui está um exemplo:

Python

[nhttps://codemdd.io/10 for n in range(11)]

Ao executar este código, você obterá o seguinte array:

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]

Este array contém 11 números espaçados uniformemente entre 0 e 1. A vantagem desse método é que ele não requer a importação do NumPy.

Usando np.arange()

Outra maneira de criar uma sequência de números espaçados uniformemente é usar a função np.arange(). Aqui está um exemplo:

Python

np.arange(0, 1.1, 0.1)

Ao executar este código, você obterá o seguinte array:

array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])

Este array contém 11 números espaçados uniformemente entre 0 e 1, com um passo de 0.1. Assim como o np.linspace(), você pode personalizar o intervalo e o passo para atender às suas necessidades.

Personalizando a Saída do np.linspace()

Além dos parâmetros obrigatórios start e stop, o np.linspace() possui vários outros parâmetros opcionais que permitem personalizar a saída.

Os parâmetros start, stop e num

Os parâmetros start, stop e num definem o início, o fim e o número de elementos na sequência, respectivamente. Você já viu exemplos desses parâmetros anteriormente. Aqui está um exemplo completo que mostra todos eles:

Python

np.linspace(start=1, stop=10, num=20)

A saída deste código será um array com 20 números espaçados uniformemente entre 1 e 10.

O parâmetro dtype para a alteração do tipo de saída

O parâmetro dtype permite alterar o tipo de dados dos elementos na saída do np.linspace(). O tipo padrão é float. Aqui está um exemplo em que especificamos o tipo de saída como int:

Python

np.linspace(1, 10, dtype=int)

A saída deste código será um array com 50 números inteiros espaçados uniformemente entre 1 e 10.

Os parâmetros endpoint e retstep

Os parâmetros endpoint e retstep controlam se o ponto final está incluído na sequência e se o passo entre os elementos é retornado como parte da saída, respectivamente. Ambos têm o valor padrão True. Aqui está um exemplo em que desativamos o ponto final e não retornamos o passo:

Python

np.linspace(1, 10, num=10, endpoint=False, retstep=False)

A saída deste código será um array com 10 números espaçados uniformemente entre 1 e 10, excluindo o ponto final.

Valores não escalares para arrays de dimensão superior

Os exemplos apresentados até agora criam arrays unidimensionais. No entanto, o np.linspace() também pode criar arrays de dimensão superior. Você pode especificar os valores start, stop e num como arrays em vez de escalares. Por exemplo:

Python

np.linspace([1, 2], [10, 20], num=5)

A saída deste código será um array bidimensional com 5 linhas e 2 colunas. A primeira coluna conterá valores espaçados uniformemente entre 1 e 10, e a segunda coluna conterá valores espaçados uniformemente entre 2 e 20.

Resumo dos parâmetros de entrada e valores de retorno

Aqui está um resumo dos parâmetros de entrada e dos valores de retorno do np.linspace():

  • start: o valor inicial da sequência.
  • stop: o valor final da sequência, que é inclusivo por padrão.
  • num: o número de elementos na sequência.
  • dtype: o tipo de dados dos elementos na sequência, que é float por padrão.
  • endpoint: um booleano que indica se o ponto final está incluído na sequência, sendo True por padrão.
  • retstep: um booleano que indica se o passo entre os elementos é retornado como parte da saída, sendo False por padrão.

Exemplo: Uma Esteira de Produção de Alimentos

Aqui está um exemplo de uso do np.linspace() em um contexto prático. Suponha que você esteja projetando uma esteira de produção de alimentos e deseje dividir a esteira em 100 partes, com cada parte representando uma posição na esteira:

Python

positions = np.linspace(0, 1, num=100)

A variável positions será um array com 100 números espaçados uniformemente entre 0 e 1. Você pode usar esses valores para controlar o movimento dos produtos na esteira.

Representando Funções Matemáticas

O np.linspace() também pode ser usado para representar funções matemáticas na forma discreta. Tome, por exemplo, uma função senoidal com amplitude 1, frequência 1 e fase 0:

Python

amplitude = 1
frequency = 1
phase = 0
t = np.linspace(0, 2*np.pi, num=100)
y = amplitude * np.sin(frequency * t + phase)

O array t representa o eixo do tempo, com 100 pontos espaçados uniformemente entre 0 e 2π. O array y representa os valores da função senoidal em cada ponto do eixo do tempo.

Você também pode representar funções matemáticas bidimensionais. Por exemplo, aqui está um código que representa a soma de duas ondas senoidais viajando em direções opostas em dois eixos diferentes:

x = np.linspace(-5, 5, num=100)
y = np.linspace(-5, 5, num=100)
X, Y = np.meshgrid(x, y)
Z = np.sin(X) + np.sin(Y)

Os arrays X e Y representam grades 2D de pontos uniformemente espaçados nos eixos x e y. O array Z representa a soma das duas ondas senoidais em cada ponto da grade.

Criando Sequências de Números com Espaçamento Desigual

Até agora, você aprendeu como criar sequências de números espaçados uniformemente. No entanto, há momentos em que você pode precisar criar sequências de números com espaçamento desigual. O NumPy oferece várias maneiras de fazer isso.

Espaçamentos Logarítmicos

Uma maneira de criar sequências de números com espaçamento desigual é usando espaçamentos logarítmicos. O np.logspace() é uma função semelhante ao np.linspace(), mas cria uma sequência de números espaçados igualmente em escala logarítmica. Aqui está um exemplo:

Python

np.logspace(0, 1, num=10)

A saída deste código será um array com 10 números espaçados igualmente na escala logarítmica entre 1 e 10.

Outros Espaçamentos Não Lineares

O NumPy também oferece outras funções para criar sequências de números com espaçamentos desiguais. Algumas delas são:

  • np.geomspace(): cria uma sequência de números espaçados igualmente em escala logarítmica, mas permite especificar uma razão ao invés de um número de elementos.
  • np.linspace() com um array como argumento num: permite criar sequências de números com espaçamentos desiguais especificando os espaçamentos entre os números.

Exemplo: Simulação de um Planeta em Órbita

Aqui está um exemplo de uso do np.linspace() para simular a trajetória de um planeta em órbita. Suponha que você deseje representar a posição do planeta em cada ponto de sua órbita, que terá um formato elíptico:

Python

theta = np.linspace(0, 2*np.pi, num=100)
a = 2.5
b = 1.5
x = a * np.cos(theta)
y = b * np.sin(theta)

Os arrays x e y representam as coordenadas x e y do planeta em cada ponto de sua órbita.

Conclusão

O np.linspace() é uma função poderosa do NumPy que permite criar sequências de números espaçados uniformemente ou não uniformemente. Você aprendeu como usá-la para criar uma sequência de números espaçados igualmente e personalizar a saída de várias maneiras. Além disso, você viu como usar o np.linspace() para representar funções matemáticas discretas e criar sequências de números com espaçamento desigual. Agora você está pronto para usar o np.linspace() em seus próprios programas de Python!