01-Primera experiencia de Numpy: creación de matrices y tipos de datos
En la sección anterior, aprendimos a crear primero un objeto de secuencia y luego a generar una matriz basada en él. Pero esto tiene ciertas limitaciones, porque si la matriz que creamos es relativamente grande, por ejemplo, el tamaño de 100 × 100, será un poco problemático.
De hecho, Numpy tiene muchos métodos integrados para crear matrices. Además de los métodos que explicamos en la sección anterior, Numpy también proporciona métodos para crear rápidamente matrices aritméticas, matrices geométricas y matrices de números aleatorios.
1. Crea una matriz aritmética
- método arange ()
Si nos permite crear una lista de aritmética, del 1 al 100, un total de 100, será muy conveniente, con una range(1,101,1)solución rápida. Numpy también proporciona un método similar arange()y su uso range()es muy similar.
import numpy as np
# 指定 start、stop、以及step。arange和range一样，是左闭右开的区间。
arr_uniform0 = np.arange(1,10,1)
# 也可以只传入一个参数，这种情况下默认start=0，step=1
arr_uniform1 = np.arange(10)
arr_uniform0
Out:
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
arr_uniform1
Out:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
El resultado es básicamente el mismo que imaginamos.
Entonces, ¿cuál es la diferencia entre arange () y range ()?
La respuesta es que los tipos de resultados devueltos por los dos no son los mismos. Uno es numpy.ndarray, el otro es range. Además, es arange()capaz de recibir el flotante, creando una matriz de números de punto flotante, pero range()solo puede recibir enteros para crear una secuencia de conformación. Se puede decir arange()de una gama más amplia de aplicaciones.
arr_uniform2 = np.arange(1.2, 3.8, 0.3)
arr_uniform2
Out:
array([1.2, 1.5, 1.8, 2.1, 2.4, 2.7, 3. , 3.3, 3.6])
Aquí hay una pregunta: ¿Cuáles son las limitaciones de usar el método arange ()?
En problemas prácticos de ingeniería, a menudo encontramos escenarios en los que la longitud del paso es un decimal de cola larga o incluso la longitud del paso no está clara. Si desea aplicar el método arange () en este momento, debe calcular con precisión la longitud del paso antes de generar la secuencia. De hecho, no tiene por qué ser tan problemático, Numpy se encargará de ello por ti.
- método linspace ()
El método linspace () es un poco más complicado y sus parámetros de llamada de función son los siguientes:
np.linspace(start, stop[, num=50[, endpoint=True[, retstep=False[, dtype=None]]]]])
# start、stop参数，和arange()中一致；
# num为待创建的数组中的元素的个数，默认为50
# endpoint=True，则为左闭右闭区间，默认为True；endpoint=False，则为左闭右开区间
# retstep用来控制返回值的形式。默认为False，返回数组；若为True，则返回由数组和步长组成的元祖
Solo mira algunos casos:
# 不设置endpoint，默认为Ture，结果为左闭右闭区间
arr_uniform3 = np.linspace(1,99, 11)
arr_uniform3
Out:
array([ 1. , 10.8, 20.6, 30.4, 40.2, 50. , 59.8, 69.6, 79.4, 89.2, 99. ])
# retstep设置为True，分别返回数组和步长
arr_uniform4 = np.linspace(1,99, 11, retstep=True)
arr_uniform4
Out:
(array([ 1. , 10.8, 20.6, 30.4, 40.2, 50. , 59.8, 69.6, 79.4, 89.2, 99. ]), 9.8)
# 设置endpoint为False，结果为左闭右开区间
arr_uniform5 = np.linspace(1,99, 11, endpoint=False)
arr_uniform5
Out:
array([ 1. , 9.90909091, 18.81818182, 27.72727273, 36.63636364,
45.54545455, 54.45454545, 63.36363636, 72.27272727, 81.18181818,
90.09090909])
La característica más importante del método linspace () es que puede definir directamente la longitud de la matriz, lo que nos brinda la conveniencia de ajustar el tamaño de la matriz. Aquí hay una introducción al método de remodelación:
arr_uniform6 = np.linspace(1,100, 20)
# 这里定义了一个长度为20的等差数组，然后通过reshape方法，调整数组的大小为5×4
arr_uniform6.reshape(5,4)
Out:
array([[ 1. , 6.21052632, 11.42105263, 16.63157895],
[ 21.84210526, 27.05263158, 32.26315789, 37.47368421],
[ 42.68421053, 47.89473684, 53.10526316, 58.31578947],
[ 63.52631579, 68.73684211, 73.94736842, 79.15789474],
[ 84.36842105, 89.57894737, 94.78947368, 100. ]])
El método de remodelación es muy flexible para ajustar el tamaño de la matriz, pero no cambia la longitud de la matriz. Es decir, una matriz de longitud 100, puede ajustarla fácilmente a 1 × 100 o 4 × 25 o 5 × 20. Esto es muy útil cuando se ajusta el volumen horizontal a un vector de columna.
2. Crea una matriz proporcional
Las series geométricas también tienen una amplia gama de aplicaciones en los cálculos, como cuando se calculan las tasas de interés. Aquí presentamos dos métodos para crear datos geométricos.
- método geomspace () para crear series geométricas exponenciales
Por ejemplo, quiero crear una serie geométrica de 2 a 16. No conozco la razón común específica, pero quiero que mi serie tenga una longitud de 4. Entonces puedo hacer esto:
# 起始项为2，结束项为16，数列的长度为4。这里要注意，默认是左闭右闭的数组
arr_geo0 = np.geomspace(2,16,4)
arr_geo0
Out: array([ 2., 4., 8., 16.])
El método geomspace () es muy simple. Sus parámetros se describen a continuación. Lo usarás más adelante. Los amigos pueden personalizar los parámetros de entrada de acuerdo con la situación real:
geomspace（start, stop, num=50, endpoint=True, dtype=None）
# start和stop，分别为区间的起始和终止值，为强制参数；
# num 为待生成等比数列的长度，指定后，程序会自动计算取等比数列的公比；
# endpoint默认为True，结果为左闭右必区间。否则为False，左闭右开区间；
- método logspace () para crear una secuencia geométrica logarítmica
El método logspace () es similar a geomspace (). La única diferencia es que al definir los valores inicial y final del intervalo, se definen en forma de exponentes. El uso de logspace () es el siguiente:
logspace（start, stop, num=50, endpoint=True, base=10.0, dtype=None）
# start：区间起始值为base的start次方
# stop：区间终止值为base的stop次方（是否取得到，需要设定参数endpoint）
# num：为待生成等比数列的长度。按照对数，即start和stop值进行等分。默认值为50
# endpoint：若为True（默认），则可以取到区间终止值，即左闭右闭区间，规则同上
Si producimos la misma secuencia geométrica anterior, ¿cómo escribirla?
# 起始项为2^1，结束项为2^4，数列的长度为4。这里要注意，起始项是以base为底，start值为指数的幂。
# 另外，因为logspace的参数比较多，建议除了start和stop，其他的参数都以键值对的形式进行传参，避免发生错误
arr_geo1 = np.logspace(1, 4, num=4, base=2)
arr_geo1
Out: array([ 2., 4., 8., 16.])
Lo anterior es todo el contenido de la creación de una secuencia geométrica. De un vistazo, conocemos el leopardo completo, después de la encapsulación de Numpy, nos proporciona una gran comodidad. Este es exactamente el encanto de Python para el análisis de datos.
3. Crea una matriz de números aleatorios
Los números aleatorios tienen muchos usos mágicos en el mundo de la programación. Por ejemplo, en el juego de rompecabezas que todos hemos jugado, un bloque de color aleatorio caerá automáticamente en la parte superior de la pantalla después de que se elimine un bloque. el proceso de.
Pero a veces también tenemos ciertos requisitos para los números aleatorios generados. Por ejemplo, en nuestro juego, la probabilidad de que aparezca cada bloque de color es diferente. Especialmente en los niveles difíciles, el programa parece estar deliberadamente mejorado ". Dificultad del juego ". De hecho, los números aleatorios aquí se calculan y diseñan cuidadosamente, así que echemos un vistazo a cómo generar algunos números aleatorios de "orden superior".
- Cree una matriz aleatoria distribuida uniformemente entre [0, 1)
# 函数的输入为若干个整数，表示输出随机数的大小为d0×d1× ...×dn
# 如果没有参数输入，则返回一个float型的随机数
numpy.random.rand(d0, d1, ..., dn)
# 产生一个大小为3×2，符合0-1之间的均匀分布的数组
arr_rand0 = np.random.rand(3, 2)
arr_rand0
Out:
array([[0.07870998, 0.09327187],
[0.49848953, 0.07535019],
[0.64401283, 0.11176563]])
- Cree una matriz aleatoria distribuida uniformemente entre (bajo, alto)
# uniform方法可以指定产生随机数的范围[low, high)，size为数组的形状，输入格式为整形（一维）或者整形元祖
# 如果不指定size的话，则返回一个服从该分布的随机数
numpy.random.uniform(low=0.0, high=1.0, size=None)
# 产生一个大小为3×2，符合0-10之间的均匀分布的数组
arr_rand1 = np.random.uniform(1, 10, (3, 2))
arr_rand1
Out:
array([[6.72617294, 5.32504844],
[7.6895909 , 6.97631457],
[1.3057397 , 3.51288886]])
- Cree una matriz que obedezca a la distribución normal estándar (la media es 0, la varianza es 1)
# 该方法和rand类似，函数的输入为若干个整数，表示输出随机数的大小为d0×d1× ...×dn
# 如果没有参数输入，则返回一个服从标准正态分布的float型随机数
numpy.random.randn(d0, d1, ..., dn)
# 产生一个大小为3×2，符合标准正态分布的数组
arr_rand2 = np.random.randn(3, 2)
arr_rand2
Out:
array([[-0.70354968, -0.85339511],
[ 0.22804958, 0.28517509],
[ 0.736904 , -2.98846222]])
- Cree una matriz que obedezca a la distribución normal de μ = loc, σ = escala
# loc:指定均值 μ; scale:指定标准差 σ
# size:输入格式为整形（一维）或者整形元祖，指定了数组的形状
numpy.random.normal(loc=0.0, scale=1.0, size=None)
# 产生一个大小为3×2，符合均值为5，标准差为10的正态分布的数组
arr_rand3 = np.random.normal(5, 10, (3, 2))
arr_rand3
Out:
array([[ -7.77480714, -2.68529581],
[ 4.40425363, -8.39891281],
[-13.08126657, -9.74238828]])
Hasta ahora, todos estamos generando números aleatorios de punto flotante en un cierto intervalo o conforme a una determinada ley. ¿Podemos generar números enteros aleatoriamente? Evidentemente es posible.
- Matriz de muestras uniformes discretas en el intervalo especificado (bajo, alto)
# 函数返回区间[low, high)内的离散均匀抽样，dtype指定返回抽样数组的数据类型,默认为整形
# size:输入格式为整形（一维）或者整形元祖，指定了数组的形状
numpy.random.randint(low, high=None, size=None, dtype=np.int64)
# 在[1, 5)之间离散均匀抽样，数组形状为3行2列
arr_rand4 = np.random.randint(1, 5, (3, 2))
arr_rand4
Out:
array([[4, 4],
[3, 3],
[4, 2]])
Para np.random.randint(1, 5, (3, 2))la implementación de los resultados se puede interpretar de esta manera: Supongamos las cuatro bolas existentes numeradas 1, 2, y cada vez que hemos vuelto a muestrear, cada muestra seis veces, cada vez que la bola pica Los números se combinan y ajustan a una matriz de tamaño de 3 × 2.
numpy.random.randintEs muy conveniente implementar el muestreo con reemplazo dentro de un cierto intervalo de enteros. Si quiero muestrear objetos específicos, ¿hay una mejor manera? Sigamos mirando.
- Muestreo de muestras específicas con o sin reemplazo
# 从样本a中进行抽样，a可以为数组、列表或者整数，若为整数，表示[0,a)的离散抽样；
# replace为False，表示无放回抽样；replace为True，表示有放回抽样
# size为生成样本的大小
# p为给定数组中元素出现的概率
numpy.random.choice(a, size=None, replace=True, p=None)
Veamos un caso. La probabilidad de que Xiao Ming lance desde la línea de tiros libres es 0,65. Hay 10 tiros en total. Veamos los resultados de la simulación por computadora:
# 因为理想情况下，每次投篮都不影响下一次的结果，所以把这个问题归结为有放回的抽样，一共进行10次
# shoot_lst用来存储投篮的结果
# 从["命中", "未命中"]中有放回抽样，其中命中的概率为0.65，共抽取10次，返回的格式为为numpy.ndarray
shoot_lst = np.random.choice(["命中", "未命中"], size=10, replace=True, p=[0.65, 0.35])
shoot_lst
Out: ['未命中', '命中', '未命中', '命中', '命中', '命中', '命中', '命中', '命中', '未命中']
De los resultados, 10 disparos, 3 aciertos. La tasa de aciertos real es del 70%. Por supuesto, si la computadora continúa simulando, la tasa de aciertos eventualmente se acercará al 65%.
4. Una pequeña prueba: el secreto del muestreo
La estadística es una ciencia metodológica que estudia los fenómenos aleatorios y se caracteriza por la inferencia. La idea de "inferir de la parte al todo" atraviesa la totalidad de la estadística.
Por ejemplo, los departamentos relevantes publican informes sobre la aptitud física de los estudiantes universitarios cada año, y una de las características más básicas es la altura. Entonces, ¿de dónde vienen estas alturas? Obviamente, el costo de obtener la estatura de todos los estudiantes universitarios es muy alto, por lo que para reducir el costo, el truco más simple es muestrear al azar. Así que hoy estudiaremos cómo el muestreo aleatorio puede reflejar la situación general de la muestra.
Al consultar algunos datos, sabemos que la altura de los estudiantes universitarios obedece a una determinada ley de distribución normal. Suponemos que la altura promedio de los estudiantes es de 175 cm, la desviación estándar de la altura es de 10 cm, para entonces podemos Numpygenerar una altura de muestra de 100,000 estudiantes. Nuestra investigación actual se basa en estas 100.000 muestras.A través de un muestreo continuo, observamos cómo cambia el valor promedio a medida que aumenta el número de muestras. Usamos la numpy.random.choicefunción para simular el proceso de muestreo. (El programa utilizará capacidades Numpyinformáticas y matplotlibgráficas simples , y los amigos pueden mirar primero, continuarán presentando más detalles en las secciones posteriores de esta columna).
# 设置matplotlib图片样式在jupyter notebook中显示
%matplotlib inline
# 导包
import numpy as np
import matplotlib.pyplot as plt
# 生成10万大学生的身高样本
arr_height = np.random.normal(175, 10, size=100000)
# 进行第一次采样，采样的样本赋值给sample_height，存储格式为ndarray
sample_height = np.random.choice(arr_height, size=1, replace=True)
# average 用来存储每次采样后计算的平均身高
average = []
# 进行1000轮循环采样，因为每次仅采集1个样本，所以整个过程可以视为有放回抽样
n = 10000
for round in range(n):
sample = np.random.choice(arr_height, size=1, replace=True)
sample_height = np.append(sample_height, sample)
average.append(np.average(sample_height))
# 进行绘图，具体过程在第四章详细说明
plt.figure(figsize=(8,6))
plt.plot(np.arange(n), average, alpha=0.6, color='blue')
plt.plot(np.arange(n), [175 for i in range(n)], alpha=0.6, color='red', linestyle='--')
plt.xlabel("Sample Rounds", fontsize=10)
plt.ylabel("Average Height", fontsize=10)
plt.show()
A partir del efecto de la visualización gráfica, durante el primer muestreo de 2000, el valor medio de las muestras muestreadas cambió drásticamente; sin embargo, a medida que aumentaba el número de muestras, el valor medio de las muestras muestreadas se acercaba cada vez más a 175 cm. Por lo tanto, al establecer métodos de muestreo razonables y científicos, el costo del trabajo estadístico diario de los departamentos pertinentes puede reducirse considerablemente.
5. Resumen
Este capítulo desbloqueó nuevas formas de crear matrices para amigos, incluida la forma de crear de manera flexible varias matrices aritméticas, proporcionales y aleatorias, y a través de una demostración simple, inicialmente demostró la visualización y las estadísticas de datos de Python flexibilidad.
Cabe señalar que Numpy proporciona métodos de números aleatorios más avanzados, que deben distinguirse del método aleatorio que viene con Python.
Por supuesto, lo que hay que recordar es que ya no tenemos que preocuparnos por la falta de datos de entrenamiento. En el futuro proceso de aprendizaje, podemos crear de manera flexible varias matrices grandes para ayudarnos a practicar la gramática.
Hasta ahora, se acabó cómo crear un objeto de matriz. En el próximo capítulo, explicaré la transformación mágica de las matrices. Estén atentos a la siguiente sección: "Indexación y división, setenta y dos cambios en matrices".