Funciones para Crear Arrays en Numpy
En numpy Existen varias funciones que permiten crear arrays. Entre estas funciones tenemos
np.ones(shape, dtype=None, order=’C’)
— shape : entero, o secuencia de enteros como una tupla
— dtype : tipo de datos. por ejemplo numpy.int8, por defecto es numpy.float64
— order : indica como se va a ordenar el array {‘C’, ‘F’}. ‘C’ (estilo C) es para indicar que es ordenado por filas (row major) o ‘F’ (estilo Fortran) es para indicar que es ordenado por columnas, como en Fortran. Por defecto es ordenado por filas ‘C’.
Hay que recordar que np es un alias de numpy. Si no se utiliza un alias durante la instrucción de importar, debe colocarse el nombre completo numpy antes de la función, separado por el operador punto.
import numpy as np
np_ones=np.ones((2,3))
np_ones
array([[1., 1., 1.],
[1., 1., 1.]])
Otra función es donde se puede crear un array con todos los elementos con valor igual a cero (0).
np.zeros(shape, dtype=None, order=’C’)
— shape : entero, o secuencia de enteros como una tupla
— dtype : tipo de datos. por ejemplo numpy.int8, por defecto es numpy.float64
— order : indica como se va a ordenar el array {‘C’, ‘F’}. ‘C’ (estilo C) es para indicar que es ordenado por filas (row major) o ‘F’ (estilo Fortran) es para indicar que es ordenado por columnas, como en Fortran. Por defecto es ordenado por filas ‘C’.
np_zeros=np.zeros((3,3))
np_zeros
array([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])
Para crear un array vacío (empty) se utiliza la función empty. recordar que np es un alias de numpy. Si no se utiliza el alias debe colocarse antes de la función la palabra numpy.
np.empty(shape, dtype=None, order=’C’)
— shape : entero, o secuencia de enteros como una tupla
— dtype : tipo de datos. por ejemplo numpy.int8, por defecto es numpy.float64
— order : indica como se va a ordenar el array {‘C’, ‘F’}. ‘C’ (estilo C) es para indicar que es ordenado por filas (row major) o ‘F’ (estilo Fortran) es para indicar que es ordenado por columnas, como en Fortran. Por defecto es ordenado por filas ‘C’.
np_vacio=np.empty((3,3))
np_vacio
array([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])
Se puede crear un array que contenga la diagonal llena de unos, el array puede ser cuadrado, es decir igual numero de filas y columnas o puede ser rectangular diferente numero de filas y columnas.
np.eye(N, M=None, k=0, dtype=, order=’C’)
— N : entero, numero de filas que va a tener el array.
— M : entero, numero de columnas que va a tener el arreglo, si no se coloca nada el numero es igual a las filas.
— k : entero, si es 0, se refiere a la diagonal principal, si es un numero positivo se refiere a una diagonal superior, si es un numero negativo se refiere a una diagonal inferior.
— dtype : tipo de datos. por ejemplo numpy.int8, por defecto es numpy.float64
— order : indica como se va a ordenar el array {‘C’, ‘F’}. ‘C’ (estilo C) es para indicar que es ordenado por filas (row major) o ‘F’ (estilo Fortran) es para indicar que es ordenado por columnas, como en Fortran. Por defecto es ordenado por filas ‘C’.
Si solo colocamos un solo numero como argumento se creara un array de igual numero de filas y columnas, con tipo float64 y order=’C’
np_ojo=np.eye((3))
np_ojo
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
np_ojo2=np.eye(4)
np_ojo2
array([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]])
En este ejemplo se crea un array de 4 filas, 3 columnas, y esta desplazado 2 posiciones hacia abajo de la diagonal principal
np_ojo3=np.eye(4, 3,-2)
np_ojo3
array([[0., 0., 0.],
[0., 0., 0.],
[1., 0., 0.],
[0., 1., 0.]])
También se puede crear un array unidimensional utilizando la función np.arange.
numpy.arange([start, ]stop, [step, ]dtype=None)
— start : Valor inicial del rango, es opcional con valor por defecto 0.
— stop : Valor final del rango, el cual no se incluye, excepto en algunos casos donde el valor del step no es un entero y los efectos de redondeo afectan la longitud de la salida.
— step : Valor de espaciamiento entre los valores, por defecto toma valor de 1, si se coloca step como valor posicional, debe proporcionarse un valor de start.
— dtype : tipo de dato del array, si no se coloca nada se tomara en base a los argumentos de los otros parámetros.
Si solo se proporciona un argumento, los demás se consideran por defecto. Esto indica un array con inicio en 0 y con fin en el argumento proporcionado, sin incluirlo.
En el siguiente ejemplo se crea un array con inicio en 1, final en 10 (sin incluirlo) y step de 1.
npr=np.arange(1, 10)
npr
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
Se puede utilizar el método reshape para cambiar la forma del array creado. para que el cambio sea permanente se crea una nueva variable.
npr2=npr.reshape(3,3)
npr2
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
Se observa que el array original npr conserva su forma, y que el array creado npr2 tiene forma (3,3).
npr
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
npr2.shape
(3, 3)
npr.shape
(9,)
Función linspace
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
Esta función permite crear un array de elementos equi espaciados linealmente. soporta no escalar
— start : escalar o array. Inicio de la secuencia.
— stop : escalar o array. Final de la secuencia. Se incluye en el array creado.
— num : escalar, numero de elementos equi espaciados. valor por defecto 50.
— endpoint : Boolean, Indica si el ultimo número (stop) es incluido. Por defecto es True (incluido).
— retstep : Boolean, indica si se va a reportar el espaciamiento entre los números, por defecto es False, no se reporta.
— dtype : El tipo de dato del array de salida. por defecto es float.
— axis : entero, solo es utilizado cuando start y stop son arrays, con valores escalares no tiene ningún significado.
La forma más simple de utilizar esta función es utilizar como argumentos el punto de inicio (start) y el punto final (stop) de la secuencia. los demás parámetros toman valores por defecto. Se generará un array con 50 elementos, que incluyen los valores de inicio (start) y final (stop).
nplist=np.linspace(0,5)
nplist
array([0. , 0.10204082, 0.20408163, 0.30612245, 0.40816327,
0.51020408, 0.6122449 , 0.71428571, 0.81632653, 0.91836735,
1.02040816, 1.12244898, 1.2244898 , 1.32653061, 1.42857143,
1.53061224, 1.63265306, 1.73469388, 1.83673469, 1.93877551,
2.04081633, 2.14285714, 2.24489796, 2.34693878, 2.44897959,
2.55102041, 2.65306122, 2.75510204, 2.85714286, 2.95918367,
3.06122449, 3.16326531, 3.26530612, 3.36734694, 3.46938776,
3.57142857, 3.67346939, 3.7755102 , 3.87755102, 3.97959184,
4.08163265, 4.18367347, 4.28571429, 4.3877551 , 4.48979592,
4.59183673, 4.69387755, 4.79591837, 4.89795918, 5. ])
Si queremos utilizar un numero diferente de elementos, por ejemplo 10, pasamos este valor como argumento de la función.
nplist2=np.linspace(0,2,10)
nplist2
array([0. , 0.22222222, 0.44444444, 0.66666667, 0.88888889,
1.11111111, 1.33333333, 1.55555556, 1.77777778, 2. ])
vstack y hstack
Si se van a unir a lo largo de las columnas, axis=1, se debe utilizar hstack, deben tener igual dimensión en el otro eje, axis=0. Es decir, utilizamos hstack() para añadir columnas, el orden está fijado por la tupla que se pasa como argumento de la función.
g=np.eye(3)
h=np.ones((3,1))
j=np.hstack((g,h))
j
array([[1., 0., 0., 1.],
[0., 1., 0., 1.],
[0., 0., 1., 1.]])
Ahora hagamos una unión de dos arrays pero a lo largo de las filas, en este caso los arrays tienen que tener el mismo número de columnas.
k=np.array([[3,3,3],[4,4,4]])
k
array([[3, 3, 3],
[4, 4, 4]])
k.shape
(2, 3)
vemos que el array g es (3, 3) y el array k (2, 3). tienen igual número de columnas, por lo podemos unirlos con vstack.
vert=np.vstack((g,k))
vert
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.],
[3., 3., 3.],
[4., 4., 4.]])
Luis E Brito Rodríguez 