Guía de la función arange() de Numpy

En esta guía, veremos la función np.arange(), cómo funciona, qué argumentos puede pasar y compararla con np.linspace() así como con la función range() integrada.

Introducción

Numpy es la biblioteca Python de computación matemática más popular. Ofrece una gran cantidad de herramientas matemáticas que incluyen, entre otras, matrices y arreglos multidimensionales, funciones matemáticas, generadores de números y mucho más.

Una de las herramientas fundamentales en NumPy es ndarray, una matriz N-dimensional. Hoy, vamos a crear ndarrays, generados en ciertos rangos usando la función NumPy.arange().

Parámetros y devolución

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

Devuelve valores espaciados uniformemente dentro de un intervalo dado donde:

  • inicio es un número (entero o real) a partir del cual comienza la matriz. es opcional
  • stop es un número (entero o real) en el que termina el arreglo y no está incluido en él.
  • paso es un número que establece el espacio entre los valores consecutivos en la matriz. Es opcional y es 1 por defecto.
  • dtype es el tipo de salida para elementos de matriz. Es Ninguno por defecto.

El método devuelve un ndarray de valores espaciados uniformemente. Si la matriz devuelve elementos de coma flotante, la longitud de la matriz será ceil((stop - start)/step).

np.arange() por ejemplo

Importando NumPy

Para comenzar a trabajar con NumPy, debemos importarlo, ya que es una biblioteca externa:

1
import NumPy as np

Si no está instalado, puede instalarlo fácilmente a través de pip:

1
$ pip install numpy

Todos los argumentos np.arange()

Veamos cómo funciona arange() con todos los argumentos de la función. Por ejemplo, supongamos que queremos que una secuencia comience en 0 y se detenga en 10, con un tamaño de paso de 3, mientras produce números enteros.

En un entorno Python, o REEMPLAZAR, generemos una secuencia en un rango:

1
>>> result_array = np.arange(start=0, stop=10, step=2, dtype=int)

El array es un ndarray que contiene los elementos generados:

1
2
>>> result_array
array([0, 2, 4, 6, 8])

Vale la pena señalar que el elemento stop no está incluido, mientras que el elemento start está incluido, por lo que tenemos un 0 pero no un 10 aunque el siguiente elemento en la secuencia debe ser un 10.

{.icon aria-hidden=“true”}

Nota: Como de costumbre, puede proporcionar argumentos posicionales, sin nombrarlos o argumentos con nombre.

Hasta que hayas memorizado sus posiciones de memoria, podría ser útil nombrarlos:

1
2
3
array = np.arange(start=0, stop=10, step=2, dtype=int)
# These two statements are the same
array = np.arange(0, 10, 2, int)

En aras de la brevedad, este último se usa a menudo, y las posiciones de estos argumentos deben seguir la secuencia de start, stop, step y dtype.

np.arange() con stop

Si solo se proporciona un argumento, se tratará como el valor stop. Dará salida a todos los números hasta, pero sin incluir, el número de stop, con un paso predeterminado de 1 y start de 0:

1
2
3
>>> result_array = np.arange(5)
>>> result_array
array([0, 1, 2, 3, 4])

np.arange() con start y stop

Con dos argumentos, por defecto son start y stop, con un step predeterminado de 1, por lo que puede crear fácilmente un rango específico sin pensar en el tamaño del paso:

1
2
3
>>> result_array = np.arange(5, 10)
>>> result_array
array([5, 6, 7, 8, 9])

Al igual que con los ejemplos anteriores, también puede usar números de punto flotante aquí en lugar de números enteros. Por ejemplo, podemos empezar en 5.5:

1
>>> result_array = np.arange(5.5, 11.75)

La matriz resultante será:

1
2
>>> result_array
array([ 5.5,  6.5,  7.5,  8.5,  9.5, 10.5, 11.5])

np.arange() con start, stop y step

El ‘dtype’ predeterminado es ‘Ninguno’ y, en ese caso, se usan ‘int’, por lo que es fácil crear un rango basado en números enteros con un ‘inicio’, ‘parada’ y ‘paso’. Por ejemplo, generemos una secuencia de todos los números pares entre 6 (inclusive) y 22 (exclusivo):

1
>>> result_array = np.arange(6, 22, 2)

El resultado serán todos los números pares entre 6 y 22, pero sin incluirlo:

1
2
>>> result_array
array([ 6,  8, 10, 12, 14, 16, 18, 20])

np.arange() para rangos invertidos

También podemos pasar parámetros negativos a la función np.arange() para obtener una matriz de números invertida.

El ‘inicio’ será el número más grande desde el que queremos empezar a contar, el ‘parada’ será el más bajo y el paso será un número negativo:

1
result_array = np.arange(start=30,stop=14, step=-3)

El resultado será una matriz de números descendentes con un paso negativo de 3:

1
2
>>> result_array
array([30, 27, 24, 21, 18, 15])

Crear NDArrays vacíos con np.arange()

También podemos crear un rango vacío de la siguiente manera:

1
>>> result_array = np.arange(0)

El resultado será una matriz vacía:

1
2
>>> result_array
array([], dtype=int32)

Esto sucede porque 0 es el valor de stop que hemos establecido, y el valor de inicio también es 0 por defecto. Entonces, el conteo se detiene antes de comenzar.

Otro caso en el que el resultado será una matriz vacía es cuando el valor inicial es mayor que el valor final mientras el paso es positivo. Por ejemplo:

1
>>> result_array = np.arange(start=30, stop=10, step=1)

El resultado también será una matriz vacía.

1
2
>>> result_array
array([], dtype=int32)

Esto también puede ocurrir al revés. Podemos comenzar con un número pequeño, detenernos en un número mayor y tener el ‘paso’ como un número negativo. La salida también será una matriz vacía:

1
>>> result_array = np.arange(start=10, stop=30, step=-1)

Esto también da como resultado un ndarray vacío:

1
2
>>> result_array
array([], dtype=int32)

Tipos de datos admitidos para np.arange()

El argumento dtype, que por defecto es int, puede ser cualquier tipo de datos NumPy válido.

Nota: Sin embargo, esto no debe confundirse con los tipos de datos estándar de Python.

Puede usar la versión abreviada para algunos de los tipos de datos más comunes, o el nombre completo, con el prefijo np.:

1
2
3
np.arange(..., dtype=int)
np.arange(..., dtype=np.int32)
np.arange(..., dtype=np.int64)

Para algunos otros tipos de datos, como np.csignle, antepondrá el tipo con np.:

1
2
3
4
5
6
>>> result_array = np.arange(start=10, stop=30, step=1, dtype=np.csingle)
>>> result_array
array([10.+0.j, 11.+0.j, 12.+0.j, 13.+0.j, 14.+0.j, 15.+0.j, 16.+0.j,
       17.+0.j, 18.+0.j, 19.+0.j, 20.+0.j, 21.+0.j, 22.+0.j, 23.+0.j,
       24.+0.j, 25.+0.j, 26.+0.j, 27.+0.j, 28.+0.j, 29.+0.j],
      dtype=complex64)

Un tipo de datos abreviado común es un float:

1
2
3
4
>>> result_array = np.arange(start=10, stop=30, step=1, dtype=float)
>>> result_array
array([10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
       23., 24., 25., 26., 27., 28., 29.])

Para obtener una lista de todos los tipos de datos NumPy admitidos, consulte la documentación oficial.

np.arange() vs np.linspace()

np.linspace() es similar a np.arange() en la devolución de matrices espaciadas uniformemente. Sin embargo, hay un par de diferencias.

Con np.linspace(), especificas el número de muestras en un cierto rango en lugar de especificar el paso. Además, puede incluir puntos finales en la matriz devuelta. Otra diferencia es que np.linspace() puede generar varias matrices en lugar de devolver solo una matriz.

Este es un ejemplo simple de np.linspace() con el punto final incluido y 5 ejemplos:

1
2
3
>>> result_array = np.linspace(0, 20, num=5, endpoint=True)
>>> result_array
array([ 0.,  5., 10., 15., 20.])

Aquí, tanto el número de muestras como el tamaño del paso es 5, pero eso es una coincidencia:

1
2
3
>>> result_array = np.linspace(0, 20, num=2, endpoint=True)
>>> result_array
array([ 0., 20.])

Aquí, hacemos dos puntos entre 0 y 20, por lo que naturalmente están separados por 20 pasos. También puede convertir endpoint en False y np.linspace()se comportará más comonp.arange()` en el sentido de que no incluye el elemento final:

1
2
3
>>> result_array = np.linspace(0, 20, num=5, endpoint=False)
>>> result_array
array([ 0.,  4.,  8., 12., 16.])

np.arange() frente a range() integrado

La función range() integrada de Python y np.arange() comparten muchas similitudes pero tienen ligeras diferencias. En las siguientes secciones, vamos a resaltar algunas de las similitudes y diferencias entre ellos.

Parámetros y devoluciones

Las principales similitudes son que ambos tienen un ‘inicio’, ‘parada’ y ‘paso’. Además, ambos incluyen comienzo y excluyen detener, con un paso predeterminado de 1.

Sin embargo:

  • np.naranja()
  1. Puede manejar múltiples tipos de datos, incluidos números flotantes y complejos
  2. devuelve una matriz
  3. La matriz está completamente creada en la memoria.
  • rango()
  1. Solo puede manejar números enteros
  2. Devuelve un objeto rango
  3. Genera números bajo demanda

Eficiencia y Velocidad

Hay algunas diferencias de velocidad y eficiencia entre np.arange() y la función integrada range(). La función de rango genera los números a pedido y no los crea en la memoria, por adelantado.

Esto ayuda a acelerar el proceso si sabe que romperá en algún lugar de ese rango: Por ejemplo:

1
2
3
for i in range(100000000):
    if i == some_number:
        break

Esto consumirá menos memoria ya que no todos los números se crean de antemano. Esto también hace que ndarrays sea más lento de construir inicialmente.

Sin embargo, si todavía necesita todo el rango de números en la memoria, np.arange() es significativamente más rápido que range() cuando entra en juego el rango completo de números, después han sido construidos.

Por ejemplo, si simplemente iteramos a través de ellos, el tiempo que se tarda en crear las matrices hace que np.arange() funcione más lentamente debido al mayor costo inicial:

1
2
3
4
5
$ python -m timeit "for i in range(100000): pass"
200 loops, best of 5: 1.13 msec per loop

$ python -m timeit "import numpy as np" "for i in np.arange(100000): pass"
100 loops, best of 5: 3.83 msec per loop

Conclusión

Esta guía tiene como objetivo ayudarlo a comprender cómo funciona la función np.arange() y cómo generar secuencias de números.

Aquí hay un resumen rápido de lo que acabamos de cubrir.

  1. np.arange() tiene 4 parámetros:
    • start is a number (integer or real) from which the array starts from. It is optional.
    • stop is a number (integer or real) which the array ends at and is not included in it.
    • step is a number that sets the spacing between the consecutive values in the array. It is optional and is 1 by default.
    • dtype is the type of output for array elements. It is None by default.
  2. Puede usar varios tipos de d con un rango que incluye enteros, flotantes y números complejos.
  3. Puede generar rangos invertidos si tiene el número más grande como inicio, el número más pequeño como parada y el paso como un número negativo.
  4. np.linspace() es similar a np.arange() en la generación de un rango de números, pero se diferencia en incluir la capacidad de incluir el punto final y generar una cantidad de muestras en lugar de **pasos **, que se calculan en función del número de muestras.
  5. np.arange() es más eficiente que range cuando necesita crear toda la matriz. Sin embargo, el rango es mejor si sabe que se romperá en algún lugar al hacer un bucle.