Estudiando la función: numpy arange()

NumPy es una librería fundamental de Python para realizar cómputos numéricos. Una de las estructuras de datos mas importantes que tiene esta librería es el tipo matriz que es comúnmente llamado ndarray.

De las rutinas que existen para la creación de matrices, hoy les dejo mis apuntes sobre el método arange()

Nuestro primer paso sera importar la librería NumPy.

import numpy

También podemos usar un alias como un nombre alternativo para referirnos a las librerías que importamos. Si bien se puede usar cualquier valor, el alias que se usa de manera mas popular para NumPy es np.

import numpy as np

Una vez que importemos nuestra librería de esta manera, podremos llamar a la función arange() usando np en vez de numpy

np.arange()

Como mencionamos mas arriba, esta función devuelve una matriz fila conocida como ndarray:

>>> np.arange(2)
Out[]: array([0, 1])
>>> type(np.arange(2))
Out[]: numpy.ndarray

Como se observa en el ejemplo, la función. arange() debe tener al menos un valor numérico de manera obligatoria. Al ingresar un parámetro numérico (n), el valor de start usara su valor predeterminado y la función devolverá una matriz fila de n elementos, empezando por el valor 0.

Parámetros

La sintaxis de la función np.arange es la siguiente

np.arange(start=0, stop, step=1, dtype=None, like=None)

start: Representa el inicio del intervalo. El valor predeterminado es 0. Usando el ejemplo anterior:

>>> np.arange(2)
Out[]: array([0, 1])
>>> np.arange(0,2)
Out[]: array([0, 1])

Obtenemos el mismo resultado agregando el valor por defecto.

stop: Representa el fin del intervalo. No tiene valor predeterminado.

Con los valores de estos argumentos que se mencionan arriba, formaremos nuestro intervalo semi-abierto.

¿Que quiere decir semi-abierto? Que incluirá el valor de inicio (start) y omitirá el valor final (stop). En la documentación oficial esta definición se expresa de la siguiente manera: [start, stop).

Cabe mencionar que el valor final podría ser incluido cuando usamos el argumento step con un numero decimal (float) y el redondeo del mismo afecta la longitud de salida.

>>> np.arange(11, 12, 0.00000001)
Out[]: 
array([11.        , 11.00000001, 11.00000002, ..., 12.00000005,
       12.00000006, 12.00000007])

Una buena practica de programación es hacer referencia a estos argumentos de manera implícita. Esto te permitirá documentar mejor y proveer a terceros de una compresión mas clara sobre la funcionalidad de tu código.

step: Este argumento indica el salto entre valores. El valor por defecto es 1 y si el mismo es indicado en la función, el valor start es obligatorio.

>>> np.arange(10,20,2)
Out[]: array([10, 12, 14, 16, 18])
>>> np.arange(start=10, stop=20, step=2)
Out[]: array([10, 12, 14, 16, 18])

Ejemplo de error cuando no incluimos el valor start:

>>> np.arange(stop=12, step=2)
Traceback (most recent call last):
TypeError: arange() missing required argument 'start' (pos 1)

Tampoco es posible definir un valor step = 0, ya que tendremos una excepción ZeroDivisionError.

np.arange(start=1, stop=12, step=0)
Traceback (most recent call last):
ZeroDivisionError: division by zero

Por ultimo, acorde a la documentación oficial, el uso de decimales en el argumento step puede ser inconsistente de manera frecuente.

Para esos casos recomienda usar numpy.linspace().

dtype: Especifica el tipo de datos que contiene la matriz. El valor predeterminado es None. Si este argumento se omite en la función, intentara inferir el dato tomando como referencia los otros argumentos.

# Buscamos el tipo de datos correspondiente a la posición 1 de la matriz usando [1].
>>> type(np.arange(start=1, stop=10)[1])
Out[]: numpy.int32
# Al realizar la misma operación, cambiando los valores de start y stop por números decimales, el tipo de datos cambia a float.
>>> type(np.arange(start=1.0, stop=10.0)[1])
Out[]: numpy.float64

like: Este argumento es experimental y depende de la aceptación de NEP 35. Básicamente, permite hacer referencia a un tipo de objeto para crear un array que no es un NumPy array.

Uso de valores negativos

En el siguiente ejemplo vemos como se comporta la función cuando definimos sus argumentos con valores negativos. Para el caso de start y stop, la función se comporta de la misma manera:

>>> np.arange(start=-5, stop=-1)
Out[]: array([-5, -4, -3, -2])

En cambio, cuando definimos el parámetro step con valores negativos la función invertirá el orden los valores agregados a la matriz. Hay que tener en cuenta que para obtener valores los parámetros start y top deben cumplir que:

start > stop

o de lo contrario obtendremos una matriz vacía.

# Usando como ejemplo esta función:
np.arange(start=1, stop=10, step=1)
Out[]: array([1, 2, 3, 4, 5, 6, 7, 8, 9])
# Al usar step con un valor negativo y siendo start < stop obtendremos una matriz vacía
np.arange(start=1, stop=10, step=-1)
Out[]: array([], dtype=int32)
# En cambio cuando el valor de start > stop y usamos valores en step < 0, la matriz resultante invierte el orden.
np.arange(start=10, stop=1, step=-1)
Out[]: array([10,  9,  8,  7,  6,  5,  4,  3,  2])

Indistintamente de cualquier valor definido en step, también obtendremos una matriz vacía cuando los argumentos start y stop sean iguales:

>>> np.arange(start=2, stop=2, step=1)
Out[]: array([], dtype=int32)
>>> np.arange(start=2, stop=2, step=-1)
Out[]: array([], dtype=int32)

Tipo de datos

Los tipos de datos son un aspecto importante a tener en cuenta cuando usamos matrices. Las matrices de NumPy tienen las siguientes características:

• Todos los elementos de un NumPy array son del mismo tipo.

Como comentamos mas arriba, cuando el valor dtype es omitido el tipo de datos se intentara deducir de los parámetros anteriores.

>>> np.arange(10).dtype
Out[]: dtype('int32')
>>> np.arange(10.0).dtype
Out[]: dtype('float64')

• Las estructuras de datos (dtypes) de NumPy permiten especificar de manera mas granular los tipos de datos numéricos que vienen incluidos en Python.

NumPy ofrece varios tipos de datos enteros (integer) que difieren en memoria y limites:

• np.int8: 8-bit signed integer (from -128 to 127)
• np.uint8: 8-bit unsigned integer (from 0 to 255)
• np.int16: 16-bit signed integer (from -32768 to 32767)
• np.uint16: 16-bit unsigned integer (from 0 to 65535)
• np.int32: 32-bit signed integer (from -2**31 to 2**31-1)
• np.uint32: 32-bit unsigned integer (from 0 to 2**32-1)
• np.int64: 64-bit signed integer (from -2**63 to 2**63-1)
• np.uint64: 64-bit unsigned integer (from 0 to 2**64-1)

Para usar cualquiera de estos tipos, se deben especificar como np.[dtype]

>>> np.arange(10, dtype=np.uint8)
Out[]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=uint8)

Si excedemos los limites numéricos del tipo de dato definido, la funcion arange() empezara del primer valor.

>>> np.arange(start=250, stop=260, dtype=np.uint8)
Out[111]: array([250, 251, 252, 253, 254, 255,   0,   1,   2,   3], dtype=uint8)

Desde ya, el peso en bytes varia de acuerdo a la estructura de datos que elijamos.

>>> np.arange(0, 10, dtype=np.uint8).itemsize
Out[]: 1
>>> np.arange(0, 10, dtype=np.int32).itemsize
Out[]: 4

Para mas detalles pueden consultar la documentación oficial.

Operadores con np.arange()

Es posible combinar operadores matemáticos con la función arange()

>>> np.arange(1,10)
Out[]: array([1, 2, 3, 4, 5, 6, 7, 8, 9])
# Multiplicación
>>> np.arange(1,10)*2
Out[]: array([ 2,  4,  6,  8, 10, 12, 14, 16, 18])
#Adición
>>> np.arange(1,10)+5
Out[]: array([ 6,  7,  8,  9, 10, 11, 12, 13, 14])
#División
>>> np.arange(1,10)/2
Out[]: array([0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5])

También podemos utilizar la función .reshape() para convertir nuestra matriz fila en una matriz multi-dimensional.

>>> np.arange(0,10)
Out[125]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
#Creamos una matriz de 2 filas y 5 columnas con los diez valores creados por la función arange().
>>> np.arange(0,10).reshape(2,5)
Out[124]: 
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])

Espero que este resumen les resulte útil. Todo comentario es bienvenido!