NumPy Arange: Cómo crear arrays con valores equiespaciados

Name

Soren Atelier

Updated on 9/2/2026

Crear arrays de números equiespaciados es una de las operaciones más comunes en computación científica, análisis de datos y aprendizaje automático. Ya sea que necesites una secuencia de índices para un bucle, valores del eje X para un gráfico o coordenadas de cuadrícula para una simulación, necesitas una forma rápida y confiable de generarlos. La función incorporada range() de Python funciona para enteros, pero falla en el momento en que necesitas pasos de punto flotante o necesitas el resultado como un array NumPy para matemáticas vectorizadas.

Esto es exactamente lo que resuelve numpy.arange(). Genera arrays de valores equiespaciados con control total sobre el punto de inicio, punto final, tamaño de paso y tipo de datos, todo en una sola llamada a función. Esta guía cubre cada parámetro, presenta ejemplos prácticos, compara np.arange() con alternativas como range() y np.linspace(), y te muestra cómo evitar los errores más comunes.

Qué hace np.arange()

np.arange() devuelve un array NumPy unidimensional que contiene valores equiespaciados dentro de un intervalo dado. Es el equivalente en NumPy de range() de Python, pero devuelve un ndarray en lugar de un objeto range y admite números de punto flotante.

Aquí está la firma completa de la función:

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

Referencia de parámetros

La función genera valores comenzando en start e incrementando en step, deteniéndose antes de alcanzar stop. Este comportamiento de "stop exclusivo" coincide con el range() de Python.

Uso básico: Solo el valor de Stop

La forma más simple de usar np.arange() es con un solo argumento. Cuando pasas un valor, se trata como stop, y start tiene por defecto 0 con un 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'>

Esto crea un array de enteros del 0 hasta (pero sin incluir) 5. Observa que el resultado es un ndarray de NumPy, no una lista de Python. Eso significa que puedes usarlo inmediatamente en operaciones vectorizadas:

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 y Stop

Pasa dos argumentos para controlar dónde comienza y termina la secuencia:

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

El array comienza en 2 (inclusivo) y se detiene antes de 10 (exclusivo). El paso predeterminado sigue siendo 1.

También puedes usar valores de inicio negativos:

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

Usando Start, Stop y Step

El tercer argumento controla el espaciado entre valores. Aquí es donde np.arange() se vuelve mucho más potente que range(), porque el paso puede ser un número de punto flotante:

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]

Los pasos enteros funcionan de la misma manera:

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

El paso puede ser cualquier número positivo. La secuencia siempre se detiene antes de alcanzar el valor de stop.

Tamaños de paso con punto flotante y problemas de precisión

Usar tamaños de paso con punto flotante es conveniente, pero tiene una advertencia: la aritmética de punto flotante no es exacta. Pequeños errores de redondeo pueden acumularse y ocasionalmente producir resultados inesperados.

Considera este ejemplo:

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

Esto parece correcto. Pero observa qué sucede con ciertos tamaños de paso:

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

Debido a la representación de punto flotante, 0.1 * 10 podría no ser exactamente igual a 1.0 en binario. El número de elementos en el resultado puede variar en uno dependiendo de los valores específicos.

Mejor práctica: Cuando necesites un número exacto de valores de punto flotante equiespaciados, usa np.linspace() en su lugar. Usa np.arange() para secuencias de punto flotante solo cuando el número exacto de elementos no importe.

Pasos negativos: Contar hacia atrás

Establece un step negativo para crear una secuencia descendente:

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

Un paso con punto flotante funciona de la misma manera:

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

La regla clave: la dirección del paso debe coincidir con la dirección de start a stop. Si start < stop, el paso debe ser positivo. Si start > stop, el paso debe ser negativo. Hacerlo incorrectamente produce un array vacío (cubierto en la sección de errores más abajo).

El parámetro dtype

Por defecto, np.arange() infiere el tipo de datos a partir de los argumentos que pasas. Si todos los argumentos son enteros, obtienes un array de enteros. Si algún argumento es un flotante, obtienes un array de flotantes. El parámetro dtype te permite anular esto:

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]

Observa el último ejemplo: cuando fuerzas un dtype entero en una secuencia de flotantes, cada valor se trunca (no se redondea) a un entero. Esto puede producir valores duplicados y resultados inesperados, así que úsalo con cuidado.

np.arange() vs range(): Cuándo usar cada uno

La función incorporada range() de Python y np.arange() de NumPy generan secuencias de números, pero sirven para propósitos diferentes.

Cuándo usar range(): Bucles puros de Python donde necesitas índices y no estás haciendo cálculos con la secuencia misma.

Cuándo usar np.arange(): Cualquier vez que el resultado se usará en cálculos numéricos, se pasará a una función NumPy/SciPy o necesite contener valores de punto flotante.

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(): Cuándo usar cada uno

Ambas funciones crean arrays de valores equiespaciados, pero definen el espaciado de manera diferente.

Aquí hay un ejemplo comparativo que muestra la diferencia 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)

Observa que np.linspace() incluye el punto final (1.0) y garantiza exactamente 6 valores, mientras que np.arange() se detiene antes de 1.0 y el conteo depende del cálculo del paso con punto flotante.

Regla general: Usa np.arange() cuando te importe el tamaño del paso. Usa np.linspace() cuando te importe el número de puntos.

Casos de uso comunes

Índices de bucle e indexación 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 del eje X para gráficos

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

Puedes pasar x e y directamente a plt.plot(x, y) de matplotlib para dibujar una onda sinusoidal suave.

Creación de coordenadas de cuadrícula

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 patrón se usa extensivamente en procesamiento de imágenes, mapas de calor y gráficos de superficie 3D.

Generación de secuencias basadas en tiempo

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]

Errores comunes y cómo solucionarlos

Array vacío por dirección de paso incorrecta

El error más frecuente con np.arange() es usar un paso que va en la dirección incorrecta:

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 devuelven un array vacío sin error ni advertencia. La solución es sencilla: asegúrate de que la dirección del paso coincida con la dirección de start a 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]

Tamaño de paso cero

Un paso de 0 nunca es válido y genera un error:

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

Dado que np.arange() crea el array completo en memoria de una vez, un paso muy pequeño sobre un rango grande puede 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)

Siempre estima el tamaño antes de generar secuencias grandes.

Experimenta con NumPy en RunCell

Si quieres probar estos ejemplos de forma interactiva y obtener asistencia impulsada por IA mientras aprendes NumPy, echa un vistazo a RunCell (opens in a new tab). RunCell es un agente de IA integrado directamente en Jupyter que ayuda a los científicos de datos a escribir, depurar y optimizar código.

En lugar de alternar entre pestañas de documentación y tu notebook, puedes pedirle a RunCell que genere ejemplos de np.arange(), explique el comportamiento de precisión de punto flotante o te ayude a elegir entre arange y linspace para tu caso de uso específico. Se ejecuta directamente en tu entorno Jupyter existente, así que no hay fricción de configuración -- simplemente instala y comienza a hacer preguntas junto a tus celdas de código.

Esto es particularmente útil cuando estás explorando funciones de creación de arrays de NumPy por primera vez, porque puedes iterar sobre ejemplos en tiempo real y ver resultados inmediatamente.

FAQ

¿Qué devuelve numpy arange?

np.arange() devuelve un ndarray unidimensional de NumPy que contiene valores equiespaciados. A diferencia del range() de Python, que devuelve un iterador perezoso, np.arange() genera el array completo en memoria. El array admite operaciones vectorizadas, broadcasting y todas las funciones estándar de NumPy.

¿Puede numpy arange usar valores de paso flotantes?

Sí. A diferencia del range() de Python, que solo acepta enteros, np.arange() admite completamente valores de punto flotante para start, stop y step. Por ejemplo, np.arange(0, 1, 0.1) genera [0.0, 0.1, 0.2, ..., 0.9]. Sin embargo, ten en cuenta que el redondeo de punto flotante puede ocasionalmente hacer que el resultado tenga un elemento más o menos de lo esperado. Usa np.linspace() cuando necesites un número garantizado de elementos.

¿Cuál es la diferencia entre np.arange y np.linspace?

np.arange() toma un tamaño de paso y genera valores hasta alcanzar el valor de stop (exclusivo). np.linspace() toma el número de puntos que deseas y calcula el tamaño de paso automáticamente, incluyendo el punto final por defecto. Usa arange cuando conozcas el tamaño del paso. Usa linspace cuando sepas cuántos puntos necesitas.

¿Por qué np.arange devuelve un array vacío?

Se devuelve un array vacío cuando la dirección del paso no coincide con la dirección de start a stop. Por ejemplo, np.arange(10, 0, 1) devuelve un array vacío porque un paso positivo no puede moverse de 10 hacia abajo a 0. La solución es usar un paso negativo: np.arange(10, 0, -1).

¿Es np.arange inclusivo o exclusivo del valor de stop?

El valor de stop es exclusivo -- nunca se incluye en la salida. np.arange(0, 5) devuelve [0, 1, 2, 3, 4], no [0, 1, 2, 3, 4, 5]. Esto coincide con el comportamiento del range() incorporado de Python. Si necesitas que se incluya el punto final, usa np.linspace() con endpoint=True (el valor predeterminado).

Conclusión

np.arange() es una de las funciones más usadas de NumPy por una buena razón: es la forma más rápida de generar arrays de números equiespaciados en Python. Aquí hay un resumen de lo que debes recordar:

• Un argumento (np.arange(n)) crea enteros de 0 a n-1.
• Dos argumentos (np.arange(start, stop)) definen el rango con un paso predeterminado de 1.
• Tres argumentos (np.arange(start, stop, step)) dan control total, incluyendo pasos flotantes y pasos negativos para secuencias descendentes.
• dtype anula la inferencia automática de tipo cuando necesitas un tipo de datos específico.
• Usa np.arange() cuando te importe el tamaño del paso. Usa np.linspace() cuando te importe el número de puntos.
• Cuidado con la precisión flotante -- np.arange() con pasos flotantes puede producir un número inesperado de elementos.
• Los arrays vacíos resultan de una discrepancia entre la dirección del paso y la dirección de start a stop.

Para experimentación interactiva con arrays NumPy, RunCell (opens in a new tab) proporciona codificación asistida por IA directamente en Jupyter, permitiéndote probar variantes de np.arange() y obtener explicaciones instantáneas sin salir de tu notebook.