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 de la matriz, 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 una matriz y queremos crear una matriz 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

La matriz creada por np.zeros_like() no sólo tiene la misma forma con la matriz 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 la matriz 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

La matriz diagonal es la matriz 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 la matriz generada.
M INT (Opcional) El valor por defecto es Ninguno. Especifica el número de columnas en la matriz 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 una matriz 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 de la matriz a generar. Crea una matriz 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 una matriz 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.]])
comments powered by Disqus