NumPy Linspace: Como criar arrays uniformemente espaçados em Python

Name

Soren Atelier

Updated on 09/02/2026

Gerar uma sequência de números uniformemente espaçados parece trivial até que você precise de controle exato sobre o início, fim e quantidade. A função embutida range() do Python lida apenas com inteiros, e mesmo numpy.arange() pode produzir surpresas quando tamanhos de passo em ponto flutuante acumulam erros de arredondamento. Se você já plotou uma função e obteve uma curva irregular ou perdeu o último valor de x, você encontrou exatamente esse problema. numpy.linspace() existe para resolvê-lo: você especifica quantos pontos deseja entre dois extremos, e o NumPy calcula o espaçamento exato para você.

Neste guia, você aprenderá a API completa do np.linspace(), verá comparações lado a lado com np.arange(), e percorrerá casos de uso reais, desde plotar curvas suaves até construir grades multidimensionais. Cada exemplo de código está pronto para copiar e colar e mostra sua saída.

O que o np.linspace() faz?

numpy.linspace() retorna um array de números uniformemente espaçados em um intervalo especificado. A ideia chave é que você define o número de amostras em vez do tamanho do passo.

Assinatura completa

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

Exemplo básico

import numpy as np
 
arr = np.linspace(0, 1, 5)
print(arr)
# Output: [0.   0.25 0.5  0.75 1.  ]

O NumPy divide o intervalo [0, 1] em 4 espaços iguais (um a menos que os 5 pontos solicitados) e retorna todos os cinco valores de fronteira, incluindo ambos extremos.

Controlando o número de pontos com num

O parâmetro num determina quantos valores estão no array retornado. O padrão é 50, por isso chamar np.linspace(0, 10) fornece 50 valores mesmo que você não tenha pedido explicitamente.

import numpy as np
 
# 3 pontos entre 0 e 10
print(np.linspace(0, 10, num=3))
# Output: [ 0.  5. 10.]
 
# 6 pontos entre -1 e 1
print(np.linspace(-1, 1, num=6))
# Output: [-1.  -0.6 -0.2  0.2  0.6  1. ]

Um erro comum é definir num=1. Nesse caso, apenas o valor start é retornado.

import numpy as np
 
print(np.linspace(0, 10, num=1))
# Output: [0.]

O parâmetro endpoint: Incluir ou excluir o valor de parada

Por padrão, endpoint=True, o que significa que o valor stop é o último elemento do array. Quando você define endpoint=False, o valor de parada é excluído e o espaçamento muda.

import numpy as np
 
with_endpoint = np.linspace(0, 1, 5, endpoint=True)
print("endpoint=True: ", with_endpoint)
# Output: endpoint=True:  [0.   0.25 0.5  0.75 1.  ]
 
without_endpoint = np.linspace(0, 1, 5, endpoint=False)
print("endpoint=False:", without_endpoint)
# Output: endpoint=False: [0.  0.2 0.4 0.6 0.8]

Quando endpoint=False é útil? Um exemplo clássico é gerar ângulos para uma transformada discreta de Fourier, onde você precisa de N pontos em [0, 2*pi) sem repetir o ângulo inicial.

import numpy as np
 
N = 8
angles = np.linspace(0, 2 * np.pi, N, endpoint=False)
print(np.round(angles, 4))
# Output: [0.     0.7854 1.5708 2.3562 3.1416 3.927  4.7124 5.4978]

Obtendo o tamanho do passo com retstep

Quando retstep=True, np.linspace() retorna uma tupla: o array e o tamanho do passo calculado. Isso é útil quando você precisa do espaçamento para cálculos posteriores sem calculá-lo você mesmo.

import numpy as np
 
values, step = np.linspace(0, 10, num=5, retstep=True)
print("Values:", values)
print("Step:  ", step)
# Output:
# Values: [ 0.   2.5  5.   7.5 10. ]
# Step:   2.5

Você pode usar o tamanho do passo para diferenciação numérica, integração, ou simplesmente para verificar se sua grade tem a resolução esperada.

import numpy as np
 
x, dx = np.linspace(0, np.pi, 1000, retstep=True)
# Approximate integral of sin(x) from 0 to pi using the trapezoidal rule
integral = np.trapz(np.sin(x), dx=dx)
print(f"Integral of sin(x) over [0, pi]: {integral:.6f}")
# Output: Integral of sin(x) over [0, pi]: 2.000000

np.linspace() vs np.arange(): Quando usar qual

Ambas as funções criam sequências de números, mas diferem de forma fundamental: linspace permite especificar a quantidade, enquanto arange permite especificar o tamanho do passo.

Armadilha de ponto flutuante com arange

import numpy as np
 
# arange can produce unexpected element counts with float steps
arr = np.arange(0, 1, 0.1)
print(len(arr), arr)
# Output: 10 [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
 
# Slightly different bounds can cause an extra element
arr2 = np.arange(0, 1.0 + 1e-15, 0.1)
print(len(arr2))
# Output: 11

Com linspace, você sempre obtém exatamente o número de elementos solicitados. Ao trabalhar com intervalos de ponto flutuante, prefira linspace a menos que você genuinamente precise de um tamanho de passo específico e limites amigáveis para inteiros.

Casos de uso práticos

1. Plotando curvas suaves

O uso mais comum de np.linspace() é gerar valores x para plotar funções matemáticas. Mais pontos produzem curvas mais suaves.

import numpy as np
import matplotlib.pyplot as plt
 
x = np.linspace(-2 * np.pi, 2 * np.pi, 300)
y = np.sin(x) / x  # sinc-like function (warning: division by zero at x=0)
 
# Handle division by zero
y = np.where(np.isclose(x, 0), 1.0, np.sin(x) / x)
 
plt.figure(figsize=(8, 4))
plt.plot(x, y, linewidth=1.5)
plt.title("sinc-like function: sin(x)/x")
plt.xlabel("x")
plt.ylabel("y")
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig("sinc_plot.png", dpi=100)
plt.show()

2. Processamento de sinais: Gerando eixos temporais

Ao simular ou analisar sinais, você precisa de um vetor temporal com uma taxa de amostragem conhecida. linspace torna isso simples.

import numpy as np
 
duration = 1.0        # seconds
sample_rate = 44100   # Hz (CD quality)
num_samples = int(duration * sample_rate)
 
t = np.linspace(0, duration, num_samples, endpoint=False)
 
# Generate a 440 Hz sine wave (concert A)
frequency = 440
signal = np.sin(2 * np.pi * frequency * t)
 
print(f"Time array shape: {t.shape}")
print(f"First 5 time values: {t[:5]}")
print(f"First 5 signal values: {np.round(signal[:5], 6)}")
# Output:
# Time array shape: (44100,)
# First 5 time values: [0.00000000e+00 2.26757370e-05 4.53514739e-05 6.80272109e-05 9.07029478e-05]
# First 5 signal values: [0.       0.062648 0.125178 0.187474 0.24942 ]

Note que endpoint=False é usado aqui porque o sinal é periódico: a amostra em t = 1.0 duplicaria a amostra em t = 0.0.

3. Criando gradientes de cor

linspace é útil para interpolar entre valores de cor ao construir mapas de cores personalizados.

import numpy as np
 
# Interpolate between blue (0, 0, 255) and red (255, 0, 0) in 5 steps
steps = 5
r = np.linspace(0, 255, steps).astype(int)
g = np.zeros(steps, dtype=int)
b = np.linspace(255, 0, steps).astype(int)
 
colors = np.column_stack([r, g, b])
for i, c in enumerate(colors):
    print(f"Step {i}: RGB({c[0]:3d}, {c[1]:3d}, {c[2]:3d})")
# Output:
# Step 0: RGB(  0,   0, 255)
# Step 1: RGB( 63,   0, 191)
# Step 2: RGB(127,   0, 127)
# Step 3: RGB(191,   0,  63)
# Step 4: RGB(255,   0,   0)

Grades multidimensionais com linspace e meshgrid

Para cálculos 2D ou 3D (mapas de calor, gráficos de superfície, gráficos de contorno), combine np.linspace() com np.meshgrid().

import numpy as np
 
x = np.linspace(-3, 3, 100)
y = np.linspace(-3, 3, 100)
X, Y = np.meshgrid(x, y)
 
# Compute a 2D Gaussian
Z = np.exp(-(X**2 + Y**2))
 
print(f"X shape: {X.shape}")
print(f"Z min: {Z.min():.6f}, Z max: {Z.max():.6f}")
# Output:
# X shape: (100, 100)
# Z min: 0.000001, Z max: 1.000000

import numpy as np
import matplotlib.pyplot as plt
 
x = np.linspace(-3, 3, 200)
y = np.linspace(-3, 3, 200)
X, Y = np.meshgrid(x, y)
Z = np.exp(-(X**2 + Y**2))
 
plt.figure(figsize=(6, 5))
plt.contourf(X, Y, Z, levels=20, cmap="viridis")
plt.colorbar(label="Amplitude")
plt.title("2D Gaussian via linspace + meshgrid")
plt.xlabel("x")
plt.ylabel("y")
plt.tight_layout()
plt.savefig("gaussian_contour.png", dpi=100)
plt.show()

Este padrão escala para qualquer dimensão. Para grades 3D, adicione uma terceira chamada linspace e use np.meshgrid(x, y, z).

O parâmetro dtype

Por padrão, np.linspace() retorna valores float64. Você pode substituir isso com o parâmetro dtype, mas esteja ciente de que tipos inteiros truncarão os valores calculados.

import numpy as np
 
# Float64 (default)
print(np.linspace(0, 5, 6).dtype)
# Output: float64
 
# Explicit float32 for memory savings
arr32 = np.linspace(0, 1, 5, dtype=np.float32)
print(arr32, arr32.dtype)
# Output: [0.   0.25 0.5  0.75 1.  ] float32
 
# Integer dtype truncates values
arr_int = np.linspace(0, 10, 5, dtype=int)
print(arr_int)
# Output: [ 0  2  5  7 10]

Ao usar dtypes inteiros, as partes fracionárias são simplesmente descartadas (comportamento floor), o que pode produzir resultados com espaçamento desigual. Mantenha os tipos float a menos que tenha uma razão específica para converter.

Padrões comuns: Gerando valores X para plotagem de funções

Aqui está uma referência concisa de padrões que você usará repetidamente.

Padrão 1: Gráfico de função padrão

import numpy as np
import matplotlib.pyplot as plt
 
x = np.linspace(0, 10, 500)
plt.plot(x, np.sin(x), label="sin(x)")
plt.plot(x, np.cos(x), label="cos(x)")
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Padrão 2: Curva paramétrica

import numpy as np
import matplotlib.pyplot as plt
 
t = np.linspace(0, 2 * np.pi, 1000)
x = 16 * np.sin(t)**3
y = 13 * np.cos(t) - 5 * np.cos(2*t) - 2 * np.cos(3*t) - np.cos(4*t)
 
plt.figure(figsize=(5, 5))
plt.plot(x, y, color="red")
plt.title("Heart Curve")
plt.axis("equal")
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Padrão 3: Avaliando um polinômio em um intervalo

import numpy as np
 
coefficients = [1, -3, 2]  # x^2 - 3x + 2
x = np.linspace(-1, 4, 6)
y = np.polyval(coefficients, x)
 
for xi, yi in zip(x, y):
    print(f"x={xi:5.2f}  ->  y={yi:5.2f}")
# Output:
# x=-1.00  ->  y= 6.00
# x= 0.00  ->  y= 2.00
# x= 1.00  ->  y= 0.00
# x= 2.00  ->  y= 0.00
# x= 3.00  ->  y= 2.00
# x= 4.00  ->  y= 6.00

Visualizando dados gerados pelo Linspace com PyGWalker

Ao trabalhar com arrays criados por np.linspace(), muitas vezes você precisa explorar os dados resultantes de forma interativa -- ajustando eixos, filtrando intervalos ou comparando múltiplas séries sem reescrever o código de plotagem a cada vez. PyGWalker (opens in a new tab) é uma biblioteca Python de código aberto que transforma qualquer DataFrame do Pandas em uma interface de visualização interativa semelhante ao Tableau diretamente dentro do Jupyter Notebook.

Veja como combinar dados gerados pelo linspace com PyGWalker para exploração interativa:

import numpy as np
import pandas as pd
import pygwalker as pyg
 
# Generate data using linspace
x = np.linspace(0, 4 * np.pi, 200)
df = pd.DataFrame({
    "x": x,
    "sin": np.sin(x),
    "cos": np.cos(x),
    "damped_sin": np.exp(-0.1 * x) * np.sin(x),
})
 
# Launch interactive visualization in Jupyter
walker = pyg.walk(df)

Com o PyGWalker aberto, você pode arrastar x para o eixo x, soltar sin e damped_sin no eixo y, e comparar formas de onda instantaneamente. Você pode alternar entre gráficos de linhas, gráficos de dispersão e gráficos de barras sem escrever código adicional. Isso é especialmente útil quando você está gerando dados em diferentes faixas de parâmetros com linspace e quer confirmar visualmente o comportamento antes de se comprometer com um gráfico final.

Perguntas frequentes

Qual é a diferença entre np.linspace e np.arange?

np.linspace() recebe um valor de início, valor de parada e o número de pontos desejados. np.arange() recebe um valor de início, valor de parada e um tamanho de passo. Use linspace quando o número de pontos importa (plotagem, interpolação). Use arange quando o passo exato entre os valores importa (sequências inteiras, loops).

O np.linspace inclui o endpoint por padrão?

Sim. Por padrão, endpoint=True, o que significa que o valor stop é incluído como último elemento. Defina endpoint=False para excluí-lo, o que é útil para sinais periódicos ou transformadas de Fourier.

Como obter o tamanho do passo do np.linspace?

Passe retstep=True para obter uma tupla de (array, tamanho_do_passo). Por exemplo: values, step = np.linspace(0, 10, 100, retstep=True).

O np.linspace pode gerar inteiros?

Você pode passar dtype=int, mas os valores serão truncados (não arredondados), o que frequentemente produz espaçamento desigual. Se você precisa de inteiros uniformemente espaçados, np.arange() é geralmente uma escolha melhor.

Quantos pontos devo usar para um gráfico suave?

Para a maioria dos gráficos de funções 2D, 200 a 500 pontos produzem curvas visualmente suaves. Para funções de alta frequência ou figuras com qualidade de publicação, 1000 pontos é uma escolha segura. Mais pontos aumentam o uso de memória e o tempo de renderização, então equilibre suavidade com desempenho.

Conclusão

numpy.linspace() é uma das funções NumPy mais utilizadas por uma boa razão: ela oferece controle preciso sobre quantos valores uniformemente espaçados você gera entre dois extremos. Ao contrário de np.arange(), ela nunca surpreende com um elemento extra ou ausente devido ao arredondamento de ponto flutuante. Os parâmetros endpoint, retstep e dtype oferecem controle detalhado para tudo, desde gráficos rápidos até pipelines de processamento de sinais.

Pontos-chave:

• Use num para definir o número exato de valores de saída.
• Defina endpoint=False para dados periódicos onde o valor de parada duplicaria o início.
• Use retstep=True sempre que precisar do tamanho do passo para cálculos posteriores.
• Prefira linspace em vez de arange para intervalos de ponto flutuante.
• Combine linspace com meshgrid para grades multidimensionais.

Com esses padrões no seu kit de ferramentas, você pode gerar sequências numéricas com confiança para plotagem, simulação, interpolação e computação científica em Python.