Tutorial de Numpy - Creación de matrices de NumPy

Jinku Hu 18 julio 2021 18 enero 2020
  1. Matriz de Ceros
  2. Matriz de los unos
  3. Matriz diagonal
  4. Matriz triangular
Tutorial de Numpy - Creación de matrices de NumPy

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.]])
Author: Jinku Hu
Jinku Hu avatar Jinku Hu avatar

Founder of DelftStack.com. Jinku has worked in the robotics and automotive industries for over 8 years. He sharpened his coding skills when he needed to do the automatic testing, data collection from remote servers and report creation from the endurance test. He is from an electrical/electronics engineering background but has expanded his interest to embedded electronics, embedded programming and front-/back-end programming.

LinkedIn