NumPy Arange: Como criar arrays com valores uniformemente espacados

Name

Soren Atelier

Updated on 09/02/2026

Criar arrays de numeros uniformemente espacados e uma das operacoes mais comuns em computacao cientifica, analise de dados e aprendizado de maquina. Seja para gerar uma sequencia de indices para um loop, valores do eixo X para um grafico ou coordenadas de grade para uma simulacao, voce precisa de uma forma rapida e confiavel de gera-los. A funcao integrada range() do Python funciona para inteiros, mas falha no momento em que voce precisa de passos em ponto flutuante ou precisa do resultado como um array NumPy para calculos vetorizados.

E exatamente isso que o numpy.arange() resolve. Ele gera arrays de valores uniformemente espacados com controle total sobre o ponto inicial, ponto final, tamanho do passo e tipo de dados -- tudo em uma unica chamada de funcao. Este guia cobre cada parametro, apresenta exemplos praticos, compara np.arange() com alternativas como range() e np.linspace(), e mostra como evitar os erros mais comuns.

O que np.arange() faz

np.arange() retorna um array NumPy unidimensional contendo valores uniformemente espacados dentro de um intervalo dado. E o equivalente NumPy do range() do Python, mas retorna um ndarray em vez de um objeto range e suporta numeros de ponto flutuante.

Aqui esta a assinatura completa da funcao:

numpy.arange([start, ] stop, [step, ] dtype=None)

Referencia de parametros

A funcao gera valores comecando em start e incrementa por step, parando antes de stop ser alcancado. Este comportamento de "stop exclusivo" corresponde ao range() do Python.

Uso basico: Apenas o valor de Stop

A forma mais simples de usar np.arange() e com um unico argumento. Quando voce passa um valor, ele e tratado como stop, e start assume o padrao 0 com um step de 1.

import numpy as np
 
arr = np.arange(5)
print(arr)
# Output: [0 1 2 3 4]
 
print(type(arr))
# Output: <class 'numpy.ndarray'>

Isso cria um array de inteiros de 0 ate (mas nao incluindo) 5. Note que o resultado e um ndarray do NumPy, nao uma lista Python. Isso significa que voce pode usa-lo imediatamente em operacoes vetorizadas:

import numpy as np
 
arr = np.arange(5)
print(arr * 10)
# Output: [ 0 10 20 30 40]
 
print(arr ** 2)
# Output: [ 0  1  4  9 16]

Usando Start e Stop

Passe dois argumentos para controlar onde a sequencia comeca e termina:

import numpy as np
 
arr = np.arange(2, 10)
print(arr)
# Output: [2 3 4 5 6 7 8 9]

O array comeca em 2 (inclusivo) e para antes de 10 (exclusivo). O passo padrao continua sendo 1.

Voce tambem pode usar valores iniciais negativos:

import numpy as np
 
arr = np.arange(-3, 4)
print(arr)
# Output: [-3 -2 -1  0  1  2  3]

Usando Start, Stop e Step

O terceiro argumento controla o espacamento entre valores. E aqui que np.arange() se torna muito mais poderoso que range(), porque o passo pode ser um numero de ponto flutuante:

import numpy as np
 
arr = np.arange(0, 1, 0.1)
print(arr)
# Output: [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]

Passos inteiros funcionam da mesma forma:

import numpy as np
 
arr = np.arange(0, 20, 3)
print(arr)
# Output: [ 0  3  6  9 12 15 18]

O passo pode ser qualquer numero positivo. A sequencia sempre para antes de alcancar o valor de stop.

Tamanhos de passo em ponto flutuante e problemas de precisao

Usar tamanhos de passo em ponto flutuante e conveniente, mas vem com uma ressalva: a aritmetica de ponto flutuante nao e exata. Pequenos erros de arredondamento podem se acumular e ocasionalmente produzir resultados inesperados.

Considere este exemplo:

import numpy as np
 
arr = np.arange(0, 1, 0.3)
print(arr)
# Output: [0.  0.3 0.6 0.9]
 
print(len(arr))
# Output: 4

Isso parece correto. Mas observe o que acontece com certos tamanhos de passo:

import numpy as np
 
arr = np.arange(0, 1.0, 0.1)
print(len(arr))
# Output: 10
 
arr2 = np.arange(0.0, 1.0 + 1e-10, 0.1)
print(len(arr2))
# Output: 11

Devido a representacao em ponto flutuante, 0.1 * 10 pode nao ser exatamente igual a 1.0 em binario. O numero de elementos no resultado pode variar em um dependendo dos valores especificos.

Melhor pratica: Quando voce precisa de um numero exato de valores em ponto flutuante uniformemente espacados, use np.linspace() em vez disso. Use np.arange() para sequencias em ponto flutuante apenas quando o numero exato de elementos nao importa.

Passos negativos: Contagem regressiva

Defina um step negativo para criar uma sequencia descendente:

import numpy as np
 
arr = np.arange(10, 0, -1)
print(arr)
# Output: [10  9  8  7  6  5  4  3  2  1]

Um passo em ponto flutuante funciona da mesma forma:

import numpy as np
 
arr = np.arange(2.0, 0.0, -0.5)
print(arr)
# Output: [2.  1.5 1.  0.5]

A regra principal: a direcao do passo deve corresponder a direcao de start para stop. Se start < stop, o passo deve ser positivo. Se start > stop, o passo deve ser negativo. Errar isso produz um array vazio (abordado na secao de erros abaixo).

O parametro dtype

Por padrao, np.arange() infere o tipo de dados dos argumentos que voce passa. Se todos os argumentos sao inteiros, voce obtem um array de inteiros. Se algum argumento e um float, voce obtem um array de floats. O parametro dtype permite substituir isso:

import numpy as np
 
# Default: integers in, integers out
arr_int = np.arange(5)
print(arr_int.dtype)
# Output: int64
 
# Default: float step, float output
arr_float = np.arange(0, 5, 0.5)
print(arr_float.dtype)
# Output: float64
 
# Force float output from integer inputs
arr_forced = np.arange(5, dtype=np.float32)
print(arr_forced)
# Output: [0. 1. 2. 3. 4.]
print(arr_forced.dtype)
# Output: float32
 
# Force integer output (values get truncated)
arr_trunc = np.arange(0, 2, 0.5, dtype=int)
print(arr_trunc)
# Output: [0 0 1 1]

Note o ultimo exemplo: quando voce forca um dtype inteiro em uma sequencia de floats, cada valor e truncado (nao arredondado) para um inteiro. Isso pode produzir valores duplicados e resultados inesperados, entao use com cuidado.

np.arange() vs range(): Quando usar cada um

A funcao integrada range() do Python e o np.arange() do NumPy geram sequencias de numeros, mas servem a propositos diferentes.

Quando usar range(): Loops Python puros onde voce precisa de indices e nao esta fazendo calculos na sequencia em si.

Quando usar np.arange(): Sempre que o resultado sera usado em computacao numerica, passado para uma funcao NumPy/SciPy, ou precisa conter valores de ponto flutuante.

import numpy as np
 
# range() for loop iteration
for i in range(5):
    print(i, end=' ')
# Output: 0 1 2 3 4
 
print()
 
# np.arange() for vectorized math
x = np.arange(5)
print(np.sin(x))
# Output: [ 0.          0.84147098  0.90929743  0.14112001 -0.7568025 ]

np.arange() vs np.linspace(): Quando usar cada um

Ambas as funcoes criam arrays de valores uniformemente espacados, mas definem o espacamento de forma diferente.

Aqui esta um exemplo comparativo que mostra a diferenca claramente:

import numpy as np
 
# arange: "give me values from 0 to 1, stepping by 0.2"
a = np.arange(0, 1, 0.2)
print(f"arange: {a}  (length: {len(a)})")
# Output: arange: [0.  0.2 0.4 0.6 0.8]  (length: 5)
 
# linspace: "give me exactly 6 values from 0 to 1"
b = np.linspace(0, 1, 6)
print(f"linspace: {b}  (length: {len(b)})")
# Output: linspace: [0.  0.2 0.4 0.6 0.8 1. ]  (length: 6)

Note que np.linspace() inclui o ponto final (1.0) e garante exatamente 6 valores, enquanto np.arange() para antes de 1.0 e a contagem depende do calculo do passo em ponto flutuante.

Regra geral: Use np.arange() quando o tamanho do passo importa. Use np.linspace() quando o numero de pontos importa.

Casos de uso comuns

Indices de loop e indexacao de arrays

import numpy as np
 
data = np.array([10, 20, 30, 40, 50])
indices = np.arange(len(data))
 
print(indices)
# Output: [0 1 2 3 4]
 
# Use for conditional selection
mask = indices % 2 == 0
print(data[mask])
# Output: [10 30 50]

Valores do eixo X para graficos

import numpy as np
 
x = np.arange(0, 2 * np.pi, 0.01)
y = np.sin(x)
 
print(f"x has {len(x)} points, from {x[0]:.2f} to {x[-1]:.2f}")
# Output: x has 629 points, from 0.00 to 6.28
print(f"y ranges from {y.min():.4f} to {y.max():.4f}")
# Output: y ranges from -1.0000 to 1.0000

Voce pode passar x e y diretamente para plt.plot(x, y) do matplotlib para desenhar uma onda senoidal suave.

Criacao de coordenadas de grade

import numpy as np
 
x = np.arange(0, 3)
y = np.arange(0, 4)
xx, yy = np.meshgrid(x, y)
 
print("xx:")
print(xx)
# Output:
# [[0 1 2]
#  [0 1 2]
#  [0 1 2]
#  [0 1 2]]
 
print("yy:")
print(yy)
# Output:
# [[0 0 0]
#  [1 1 1]
#  [2 2 2]
#  [3 3 3]]

Este padrao e usado extensivamente em processamento de imagens, mapas de calor e graficos de superficie 3D.

Geracao de sequencias baseadas em tempo

import numpy as np
 
# Hours from 0 to 24 in 30-minute intervals
hours = np.arange(0, 24.5, 0.5)
print(f"Time points: {len(hours)}")
# Output: Time points: 49
print(hours[:6])
# Output: [0.  0.5 1.  1.5 2.  2.5]

Erros comuns e como corrigi-los

Array vazio por direcao de passo incorreta

O erro mais frequente com np.arange() e usar um passo que vai na direcao errada:

import numpy as np
 
# Trying to count down with a positive step
arr = np.arange(10, 0, 1)
print(arr)
# Output: []
 
# Trying to count up with a negative step
arr2 = np.arange(0, 10, -1)
print(arr2)
# Output: []

Ambos retornam um array vazio sem erro ou aviso. A correcao e simples -- certifique-se de que a direcao do passo corresponde a direcao de start para stop:

import numpy as np
 
# Correct: counting down with negative step
arr = np.arange(10, 0, -1)
print(arr)
# Output: [10  9  8  7  6  5  4  3  2  1]

Tamanho de passo zero

Um passo de 0 nunca e valido e gera um erro:

import numpy as np
 
try:
    arr = np.arange(0, 10, 0)
except ZeroDivisionError as e:
    print(f"Error: {e}")
# Output: Error: division by zero

Arrays inesperadamente grandes

Como np.arange() cria o array inteiro na memoria de uma vez, um passo muito pequeno em um intervalo grande pode consumir gigabytes de RAM:

import numpy as np
 
# This creates 10 billion elements -- do NOT run this
# arr = np.arange(0, 10, 0.000000001)
 
# Check the size first
count = int((10 - 0) / 0.000000001)
print(f"This would create {count:,} elements")
# Output: This would create 10,000,000,000 elements
print(f"Memory: ~{count * 8 / 1e9:.1f} GB (for float64)")
# Output: Memory: ~80.0 GB (for float64)

Sempre estime o tamanho antes de gerar sequencias grandes.

Experimente com NumPy no RunCell

Se voce quer experimentar estes exemplos de forma interativa e obter assistencia com IA enquanto aprende NumPy, confira o RunCell (opens in a new tab). RunCell e um agente de IA integrado diretamente no Jupyter que ajuda cientistas de dados a escrever, depurar e otimizar codigo.

Em vez de alternar entre abas de documentacao e seu notebook, voce pode pedir ao RunCell para gerar exemplos de np.arange(), explicar o comportamento de precisao de ponto flutuante ou ajuda-lo a escolher entre arange e linspace para seu caso de uso especifico. Ele roda diretamente no seu ambiente Jupyter existente, entao nao ha friccao de configuracao -- basta instalar e comecar a fazer perguntas ao lado de suas celulas de codigo.

Isso e particularmente util quando voce esta explorando funcoes de criacao de arrays do NumPy pela primeira vez, porque voce pode iterar sobre exemplos em tempo real e ver resultados imediatamente.

FAQ

O que numpy arange retorna?

np.arange() retorna um ndarray NumPy unidimensional contendo valores uniformemente espacados. Ao contrario do range() do Python, que retorna um iterador preguicoso, np.arange() gera o array completo em memoria. O array suporta operacoes vetorizadas, broadcasting e todas as funcoes padrao do NumPy.

O numpy arange pode usar valores de passo em ponto flutuante?

Sim. Ao contrario do range() do Python, que aceita apenas inteiros, np.arange() suporta totalmente valores de ponto flutuante para start, stop e step. Por exemplo, np.arange(0, 1, 0.1) gera [0.0, 0.1, 0.2, ..., 0.9]. No entanto, esteja ciente de que o arredondamento de ponto flutuante pode ocasionalmente fazer com que o resultado tenha um elemento a mais ou a menos do que o esperado. Use np.linspace() quando precisar de um numero garantido de elementos.

Qual e a diferenca entre np.arange e np.linspace?

np.arange() recebe um tamanho de passo e gera valores ate alcancar o valor de stop (exclusivo). np.linspace() recebe o numero de pontos desejado e calcula o tamanho do passo automaticamente, incluindo o ponto final por padrao. Use arange quando souber o tamanho do passo. Use linspace quando souber quantos pontos precisa.

Por que np.arange retorna um array vazio?

Um array vazio e retornado quando a direcao do passo nao corresponde a direcao de start para stop. Por exemplo, np.arange(10, 0, 1) retorna um array vazio porque um passo positivo nao pode mover de 10 para baixo ate 0. A correcao e usar um passo negativo: np.arange(10, 0, -1).

np.arange e inclusivo ou exclusivo do valor de stop?

O valor de stop e exclusivo -- nunca e incluido na saida. np.arange(0, 5) retorna [0, 1, 2, 3, 4], nao [0, 1, 2, 3, 4, 5]. Isso corresponde ao comportamento do range() integrado do Python. Se voce precisa que o ponto final seja incluido, use np.linspace() com endpoint=True (o padrao).

Conclusao

np.arange() e uma das funcoes mais usadas do NumPy por um bom motivo: e a forma mais rapida de gerar arrays de numeros uniformemente espacados em Python. Aqui esta um resumo do que lembrar:

• Um argumento (np.arange(n)) cria inteiros de 0 a n-1.
• Dois argumentos (np.arange(start, stop)) definem o intervalo com um passo padrao de 1.
• Tres argumentos (np.arange(start, stop, step)) dao controle total, incluindo passos float e passos negativos para sequencias descendentes.
• dtype substitui a inferencia automatica de tipo quando voce precisa de um tipo de dados especifico.
• Use np.arange() quando o tamanho do passo importa. Use np.linspace() quando o numero de pontos importa.
• Cuidado com a precisao de floats -- np.arange() com passos float pode produzir um numero inesperado de elementos.
• Arrays vazios resultam de uma incompatibilidade entre a direcao do passo e a direcao de start para stop.

Para experimentacao interativa com arrays NumPy, o RunCell (opens in a new tab) fornece codificacao assistida por IA diretamente no Jupyter, permitindo que voce teste variantes de np.arange() e obtenha explicacoes instantaneas sem sair do seu notebook.