prefacio

Registre varios métodos para crear API relacionadas con arreglos. Algunas funciones de parámetros que se usan con menos frecuencia se ignoran de forma selectiva. Por ejemplo np.array(object, dtype=None, *, copy=True, order=‘K’, subok=False, ndmin=0), las dos primeras entradas se usan con frecuencia y las siguientes se ignoran.

1. np.array y np.asarray

Las funciones son básicamente las mismas, y se suelen utilizar para convertir listas, tuplas, numpy.ndarrayetc.
Diferencia: cuando la entrada objecten sí es numpy.ndarray, np.array()la matriz original se copiará de forma predeterminada y el valor de la nueva matriz no cambiará después de que se modifique la matriz original; y np.asarray()la otra matriz cambiará después de cambiar el valor de una matriz.

np.array(object, dtype=None)
np.asarray(object, dtype=None)
----------------------------------------------------------------
a1 = np.random.random((2, 3))
a2 = np.array(a1)
a3 = np.asarray(a1)
a3[0, 0] = 0
print(a1)
print(a2)
print(a3)
'''
[[0.         0.80722796 0.58824907]
 [0.46028017 0.15263737 0.08888952]]
[[0.19299596 0.80722796 0.58824907]
 [0.46028017 0.15263737 0.08888952]]
[[0.         0.80722796 0.58824907]
 [0.46028017 0.15263737 0.08888952]]
'''

2. Valor por defecto

2.1 np.vacío, np.ceros, np.unos

shapePor lo general, list, tuple, int; prototypegeneralmente list, tuple, array, prototypecreate array by shape.

np.empty(shape, dtype=float)
np.zeros(shape, dtype=float)
np.ones(shape, dtype=float)

np.empty_like(prototype, dtype=None)
np.zeros_like(prototype, dtype=None)
np.ones_like(prototype, dtype=None)

2.2 np.completo

np.full()fill_valueHay un gran espacio para la manipulación al configurar :

np.full(shape, fill_value, dtype=None)
np.full_like(prototype, fill_value, dtype=None)
----------------------------------------------------------------
>>> np.full([2, 3], np.inf)
[[inf inf inf]
 [inf inf inf]]
>>> np.full([2, 3], [1, 2, 3])
[[1 2 3]
 [1 2 3]]
>>> np.full([2, 3], [[1], [2]])
[[1 1 1]
 [2 2 2]]

2.3 np.ojo

np.eye(N, M=None, k=0, dtype=float)
----------------------------------------------------------------
>>> np.eye(3)
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
>>> np.eye(3, M=4)
[[1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]]
>>> np.eye(3, k=1)
[[0. 1. 0.]
 [0. 0. 1.]
 [0. 0. 0.]]

3. Intervalo fijo

3.1 np.naranja

np.arange()Similar en range()función a , pero admite números de coma flotante step.

np.arange([start,] stop[, step,], dtype=None)
----------------------------------------------------------------
>>> np.arange(5)
[0, 1, 2, 3, 4]
>>> np.arange(2, 5)
[2, 3, 4]
>>> np.arange(2, 5, 0.5)
[2., 2.5, 3., 3.5, 4., 4.5]

3.2 np.linspace

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
----------------------------------------------------------------
>>> np.linspace(2, 3, 5)
[2., 2.25, 2.5, 2.75, 3.]
>>> np.linspace(2, 3, 5, endpoint=False)
[2., 2.2, 2.4, 2.6, 2.8]
>>> np.linspace(2, 3, 5, retstep=True)
(array([2., 2.25, 2.5, 2.75, 3.]), 0.25)

3.3 np.logspace

np.logspace(start, stop, num=50, endpoint=True, base=10, dtype=None, axis=0)
----------------------------------------------------------------
>>> np.logspace(2, 4, 3)
[100., 1000., 10000.]
>>> np.logspace(2, 4, 3, base=2)
[4., 8., 16.]

3.4 np.rejilla de malla

np.meshgrid(*xi, copy=True, sparse=False, indexing='xy')
----------------------------------------------------------------
x = np.arange(1, 4)
y = np.arange(1, 3)
xv, yv = np.meshgrid(x, y)
'''
xv: [[1 2 3]
 	 [1 2 3]] 
yv: [[1 1 1]
 	 [2 2 2]]
'''
xv, yv = np.meshgrid(x, y, indexing='ij')
'''
xv: [[1 1]
 	 [2 2]
 	 [3 3]]
yv: [[1 2]
 	 [1 2]
 	 [1 2]]
'''

x = np.arange(1, 4)
y = np.arange(1, 4)
z = np.arange(1, 4)
xv, yv, zv = np.meshgrid(x, y, z)
'''
xv: [[[1 1 1]
  	  [2 2 2]
  	  [3 3 3]]
 	 [[1 1 1]
  	  [2 2 2]
  	  [3 3 3]]
 	 [[1 1 1]
  	  [2 2 2]
  	  [3 3 3]]] 
yv: [[[1 1 1]
  	  [1 1 1]
  	  [1 1 1]]
 	 [[2 2 2]
  	  [2 2 2]
  	  [2 2 2]]
 	 [[3 3 3]
  	  [3 3 3]
  	  [3 3 3]]]
zv: [[[1 2 3]
  	  [1 2 3]
  	  [1 2 3]]
 	 [[1 2 3]
  	  [1 2 3]
  	  [1 2 3]]
 	 [[1 2 3]
  	  [1 2 3]
  	  [1 2 3]]]
'''

3.5 Generar índice de imagen o cuadrícula de coordenadas xy

x = np.arange(3)
y = np.arange(2)
xv, yv = np.meshgrid(x, y)
np.stack((yv, xv), axis=2)
'''
[[[0 0] [0 1] [0 2]]
 [[1 0] [1 1] [1 2]]]
'''
np.stack((xv, yv), axis=2)
'''
[[[0 0] [1 0] [2 0]]
 [[0 1] [1 1] [2 1]]]
'''

4. Números aleatorios

4.1 np.aleatorio.rand

Cree una matriz de la forma dada, el valor es $[0, 1)$ números aleatorios de una distribución uniforme.

np.random.rand(d0, d1, ..., dn)
----------------------------------------------------------------
>>> np.random.rand(2, 3)
[[0.42572141 0.81458374 0.73539729]
 [0.8680032  0.38338077 0.97945663]]

4.2 np.aleatorio.aleatorio

El mismo efecto que np.random.rand, la entrada tiene sizela forma de una lista, tupla o int.

np.random.random(size=None)
----------------------------------------------------------------
np.random.random([2, 3])
[[0.42572141 0.81458374 0.73539729]
 [0.8680032  0.38338077 0.97945663]]

4.3 np.aleatorio.randn

Los valores son $[0, 1)$ Números aleatorios de una distribución normal con media 0 y varianza 1.

np.random.randn(d0, d1, ..., dn)
----------------------------------------------------------------
>>> np.random.randn(2, 3)
[[ 1.28560542 -0.30355338  0.61907566]
 [ 0.39599855  0.22340565 -0.05433942]]

4.4 np.random.randint

El valor es $[bajo,__hi g h)$ , sihigh=Noneel rango es $[0, bajo)$ 。 $_$ $_$

np.random.randint(low, high=None, size=None, dtype=int)
----------------------------------------------------------------
>>> np.random.randint(0, 10, size=[2, 3])
[[3 8 8]
 [8 0 5]]

Numpy Notes - Creación de arreglos