Tutorial de Numpy - Creación de matrices de NumPy

  1. Matriz de Ceros
  2. Matriz de los unos
  3. Matriz diagonal
  4. Matriz triangular

Matriz de Ceros

np.zeros

Se utiliza np.zeros para crear el array de que todos los elementos son 0. Su sintaxis es,

np.zeros(shape, dtype=float, order='C')

Dónde,

La shape es el tamaño del array, y puede ser 1-D, 2-D o múltiples dimensiones.

El dtype es float64 por defecto, pero puede ser asignado con cualquier tipo de datos en numpy.

Vamos a crear algunas matrices de ceros

>>> import numpy as np
>>> np.zeros(5)		# it creates a 1D array with 5 zeros
array([0., 0., 0., 0., 0.])
>>> np.zeros(5, dtype='int8')	# it creates a 1D array with 5 zeros with the data type of int8
array([0, 0, 0, 0, 0], dtype=int8)
>>> np.zeros((4, 3)) # it creates a 4x3 zeros array
array([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]])

np.empty

En algunos casos, sólo quieres inicializar un array con la forma especificada y no te importan los datos de inicialización que hay dentro. Puede usar np.empty para conseguir una inicialización más rápida, pero tenga en cuenta que no garantiza que el valor del array creado sea 0.

Podríamos usar %timeit para comparar el tiempo de ejecución de np.empty() y np.zeros(),

In [1]: %timeit np.empty((100, 100))
    715 ns ± 11.6 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
In [2]: %timeit np.zeros((100, 100))
    4.03 µs ± 104 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Obviamente, np.empty() es mucho más rápido que np.zeros() en la inicialización. Sólo se necesita un 17.5% de tiempo para que np.zeros() inicialice un array con la forma de (100, 100).

np.zeros_like

Supongamos que ya tenemos un array y queremos crear un array de ceros que tenga la misma forma. Podríamos usar la forma tradicional para crear esta nueva matriz.

test = np.array([[1,2,3],[4,5,6],[7,8,9]])
np.zeros(test.shape)

O podríamos usar el método dedicado - np.zeros_like() para crear la nueva matriz de forma más eficiente.

x = np.zeros_like(test)
Atención

el array creada por np.zeros_like() no sólo tiene la misma forma con el array dada sino también el mismo tipo de datos que ésta.

Matriz de los unos

np.ones

De forma similar a los zeros, también podríamos crear el array lleno de unos. La sintaxis y los parámetros de np.ones() son idénticos a los de np.zeros().

>>> import numpy as np
>>> np.ones(5)		# it creates a 1-D array with 5 ones
array([1., 1., 1., 1., 1.])
>>> np.ones(5, dtype='int8')	# it creates a 1-D array with 5 ones, and its data type is int8
array([1, 1, 1, 1, 1], dtype=int8)
>>> np.ones((4, 3)) # it creates an array of (4, 3) shape
array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])

np.ones_like

De forma similar al np.zeros_like',np.ones_like’ puede ser usado para crear una nueva matriz de unos con la misma forma que el array dada.

>>> test = np.array([[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0]])
>>> np.ones_like(test)
array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])

Matriz diagonal

el array diagonal es el array 2-D con unos en la diagonal y ceros en otras partes. Se puede crear con el método np.eye() cuya sintaxis es,

np.eye(N, M=None, k=0, dtype=<class 'float'>, order='C')

Dónde,

parámetro tipo de datos Resumen
N INT Especifica el número de líneas en el array generada.
M INT (Opcional) El valor por defecto es None. Especifica el número de columnas en el array que se generará. Cuando es None, es igual a N.
k INT (Opcional) El valor por defecto es 0. 0 es la posición principal de la diagonal. Si k es positiva, crea la diagonal superior con el desplazamiento de k; si k es negativa, crea la diagonal inferior con el desplazamiento de k.
dtype tipo de datos (Opcional) El valor por defecto es flot. Especifica el tipo de datos del elemento del array creado.

np.eye() Ejemplo

>>> import numpy as np
>>> np.eye(3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
>>> np.eye(4, 3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.],
       [0., 0., 0.]])
>>> np.eye(3, 4)
array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.]])
>>> np.eye(4, k=1)
array([[0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.],
       [0., 0., 0., 0.]])

np.identity()

El np.identity puede ser tratado como un np.eye especial porque crea un array diagonal cuadrada con los de la diagonal principal.

numpy.identity(n, dtype = float)
parámetro tipo de datos Descripción
n INT Especifica el tamaño del array a generar. Crea un array cuadrada N×N.
dtype tipo de datos (Opcional) El valor por defecto es flotante. Especifica el tipo de datos del elemento.

np.identity() Ejemplos

>>> import numpy as np
>>> np.identity(3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

Matriz triangular

Podría usar np.tri() para crear un array triangular. Su sintaxis es,

numpy.tri(N, M=None, k=0, dtype=<class 'float'>)

Sus parámetros de entrada son similares a np.eye().

np.tri() Ejemplos

>>> import numpy as np
>>> np.tri(3)
array([[1., 0., 0.],
       [1., 1., 0.],
       [1., 1., 1.]])
>>> np.tri(4, k=1)
array([[1., 1., 0., 0.],
       [1., 1., 1., 0.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])