Como usar a função linspace no Python?

[

np.linspace(): Criar arrays com espaçamento uniforme ou não uniforme

por Stephen Gruppetta

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

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

Neste tutorial, você aprenderá como:

Criar um intervalo de números espaçados uniformemente ou não uniformemente
Decidir quando usar 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 em forma discreta

Este tutorial pressupõe que você já está familiarizado com o básico do NumPy e o tipo de dados ndarray. Você começará aprendendo sobre várias maneiras de criar um intervalo de números em Python. Em seguida, você examinará de perto todas as maneiras de usar o np.linspace() e como usá-lo efetivamente em seus programas.

Criando intervalos de números com espaçamento uniforme

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

Usando 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:

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

Este código retornará um array com valores numéricos espaçados uniformemente entre 1 e 10. O número padrão de elementos no array retornado é 50. Se você quiser especificar o número de elementos, pode usar o parâmetro opcional num:

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

Este código retornará um array com 100 valores numéricos espaçados uniformemente entre 1 e 10.

Você também pode alterar o tipo de dado do array retornado usando o parâmetro opcional dtype:

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

Este código retornará um array com valores inteiros espaçados uniformemente entre 1 e 10.

Além disso, o np.linspace() possui outros parâmetros opcionais, como endpoint e retstep, que você pode usar para personalizar ainda mais o seu array. Você pode obter mais detalhes sobre esses parâmetros em np.linspace() no manual do NumPy.

Usando range() e List Comprehensions

Uma outra maneira de criar um intervalo de números espaçados uniformemente é usar a função range(). Embora a função range() seja mais comumente usada para criar uma sequência de números inteiros, você pode usá-la juntamente com List Comprehensions para criar um intervalo de números com espaçamento uniforme:

[(x + 1) / 10 for x in range(10)]

Este código retornará uma lista de valores numéricos espaçados uniformemente entre 0.1 e 1.0.

Essa abordagem é mais comum em Python puro, mas não oferece a mesma versatilidade e poder que o np.linspace() oferece.

Usando np.arange()

Outra maneira de criar um intervalo de números espaçados uniformemente é usando np.arange(). A diferença entre np.linspace() e np.arange() é que np.linspace() funciona com espaçamentos de números reais, enquanto np.arange() funciona apenas com números inteiros:

np.arange(1, 11)

Este código retornará um array com valores inteiros espaçados uniformemente entre 1 e 10.

A vantagem do np.arange() em relação ao range() é que np.arange() permite que você especifique o espaçamento entre os números. Por exemplo, se você quiser criar um array com números inteiros espaçados de 2 em 2, pode fazer o seguinte:

np.arange(1, 11, step=2)

Este código retornará um array com valores inteiros espaçados uniformemente entre 1 e 10, com um espaçamento de 2 entre os números.

Personalizando a saída do np.linspace()

O np.linspace() oferece vários parâmetros opcionais que você pode usar para personalizar ainda mais a saída do seu array:

Os parâmetros start, stop e num

Os parâmetros start, stop e num são os parâmetros obrigatórios do np.linspace(), que foram mencionados anteriormente. Eles servem para definir o início, o fim e o número de elementos do array retornado.

O parâmetro dtype para alterar o tipo de dado de saída

O parâmetro dtype permite que você especifique o tipo de dado do array retornado. Por padrão, o dtype é float. Se você quiser que seu array retornado contenha valores inteiros, pode usar o parâmetro dtype=int.

Os parâmetros endpoint e retstep

O parâmetro endpoint permite que você controle se o valor stop está incluído ou não no seu intervalo de números. Por padrão, endpoint=True, o que significa que o valor stop está incluído. Se você definir endpoint=False, o valor stop será excluído do intervalo.

O parâmetro retstep permite que você obtenha além do array retornado um segundo valor, que é o espaçamento entre os elementos do array. O valor padrão de retstep=False, o que significa que o espaçamento não será retornado. Se você definir retstep=True, o espaçamento será retornado juntamente com o array.

Valores não escalares para arrays de dimensões superiores

O np.linspace() também pode ser usado para criar arrays com duas ou mais dimensões. Nesse caso, os parâmetros start, stop e num assumirão um formato diferente.

Resumo dos parâmetros de entrada e valores de retorno

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

Exemplo: uma esteira de produção de alimentos

Para demonstrar o uso do np.linspace() em um contexto prático, vamos considerar o exemplo de uma esteira de produção de alimentos em uma fábrica. Suponha que a esteira esteja medindo a quantidade de tempo que um produto específico leva para atravessar cada etapa da linha de produção. Podemos usar o np.linspace() para criar um array que representa o tempo em segundos em cada etapa da linha de produção, assumindo um tempo total de 10 minutos:

import numpy as np
tempo_total = 10 * 60 # 10 minutos convertidos em segundos
np.linspace(0, tempo_total, num=6)

Este código retornará um array com 6 valores numéricos espaçados uniformemente entre 0 e o tempo total, representando o tempo em segundos em cada etapa da linha de produção.

Representando funções matemáticas

Outra aplicação comum para o np.linspace() é a representação de funções matemáticas em forma discreta. Em vez de usar uma função matemática contínua, podemos aproximar a função calculando seu valor em pontos discretos usando o np.linspace(). Isso é útil, por exemplo, quando queremos plotar um gráfico da função.

Funções matemáticas com np.linspace()

Podemos usar o np.linspace() juntamente com funções matemáticas para criar arrays que representam os valores da função em pontos discretos. Aqui está um exemplo usando a função seno da biblioteca matemática do Python (math):

import numpy as np
import math

x = np.linspace(0, 2 * math.pi, num=100)
y = np.sin(x)

Neste exemplo, criamos dois arrays com np.linspace(), um representando os valores de x e outro representando os valores de y, que são os valores da função seno para cada valor de x.

Exemplo: superpondo ondas viajantes

Um exemplo mais complexo é o de superposição de ondas viajantes. Suponha que queiramos visualizar a superposição de duas ondas viajantes usando o np.linspace(). Podemos fazer isso criando arrays para a posição x e o valor da função y correspondente para cada ponto da posição x:

import numpy as np

position = np.linspace(-10, 10, num=1000)
wave1 = np.sin(position)
wave2 = np.sin(2 * position)
superposition = wave1 + wave2

Neste exemplo, usamos o np.linspace() para criar arrays para a posição e em seguida usamos as funções seno para criar arrays para as ondas individuais. Depois, somamos essas duas ondas individuais para obter a superposição.

Funções matemáticas bidimensionais

Além de representar funções matemáticas unidimensionais, o np.linspace() também pode ser usado para criar arrays que representam funções matemáticas bidimensionais. Para isso, basta usar o np.meshgrid() juntamente com o np.linspace(). Aqui está um exemplo para representar uma função de duas variáveis x e y:

import numpy as np

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

Neste exemplo, usamos o np.linspace() para criar arrays para as variáveis x e y. Em seguida, usamos o np.meshgrid() para criar as matrizes X e Y que representam todas as combinações possíveis de valores de x e y. Finalmente, usamos essas matrizes para criar a matriz Z, que representa os valores da função.

Criando intervalos de números com espaçamento não uniforme

Até agora, você viu como criar intervalos de números com espaçamento uniforme usando o np.linspace(). No entanto, também pode ser útil criar intervalos de números com espaçamento não uniforme. Isso pode ser feito usando o np.logspace() para criar intervalos de números logarítmicos ou usando o np.geomspace() para criar intervalos de números geometricamente espaçados.

Espaços logarítmicos

O np.logspace() funciona de maneira semelhante ao np.linspace(), mas em vez de criar um intervalo de números uniformemente espaçados, ele cria um intervalo de números logaritmicamente espaçados:

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

Este código retornará um array com 10 valores numéricos logaritmicamente espaçados entre 1 e 10.

Outros intervalos não lineares

Além dos espaços logarítmicos, o NumPy também oferece outras funções para criar intervalos de números com espaçamento não uniforme, como np.geomspace() para criar intervalos geometricamente espaçados e np.fromfunction() para gerar intervalos de números com base em uma função fornecida.

Exemplo: simulação de um planeta em órbita

Vamos considerar um exemplo prático de usar o np.linspace() para simular a posição de um planeta em órbita. Suponha que queiramos simular a posição radial de um planeta em órbita em relação a uma estrela central em diferentes momentos de tempo. Se assumirmos que a órbita do planeta é elíptica, podemos usar o np.linspace() para gerar um intervalo de tempo espaçado de forma logarítmica e, em seguida, usar essa sequência de tempo para calcular a posição radial correspondente para cada momento de tempo:

import numpy as np

tempo = np.logspace(0, 5, num=100) # intervalo de tempo logarítmico de 1 a 100000
posicao_radial = 10 * np.cos(2 * np.pi * tempo / 1000) + 20

Neste exemplo, usamos o np.logspace() para criar um array de tempo logaritmicamente espaçado de 1 a 100000. Em seguida, usamos essa sequência de tempo para calcular a posição radial correspondente para cada momento de tempo usando uma função matemática.

Conclusão

O np.linspace() é uma ferramenta poderosa para criar arrays com espaçamento uniforme ou não uniforme. Ele oferece flexibilidade e versatilidade para personalizar o intervalo de números de acordo com suas necessidades específicas. Ao dominar o np.linspace(), você terá uma ferramenta valiosa em seu conjunto de ferramentas de programação numérica.

Neste tutorial, você aprendeu como usar o np.linspace() para criar intervalos de números com espaçamento uniforme e não uniforme, personalizar a saída do array e representar funções matemáticas em forma discreta. Esperamos que este tutorial tenha lhe fornecido uma compreensão clara do uso do np.linspace() e como aplicá-lo em suas próprias aplicações numéricas com o Python e o NumPy.