[数学] 智机+视觉+机器学习必要的工程数学（应用数学）知识练习与总结 -- 线性代数+概率+统计

[数学] 智机+视觉+机器学习必要的工程数学（应用数学）知识练习与总结 – 线性代数+概率+统计

链接: 智机+视觉+机器学习必要的工程数学（应用数学）知识练习与总结 – 微积分+高等数学.

注：.ipynb 笔记总结 转换成 .md 文件，图片上传麻烦，可以根据目录运行验证过的代码。

---

---

---

1. numpy 入门

1. numpy 概念

numpy：number python，一个重要的python语言数学运算库，在数据分析，机器学习，科学运算，
图像处理等方面有重要的作用。

NumPy 是支持 Python 语言的数值计算扩充库，numpy让向量和矩阵的运算变得非常简单。
除此之外，NumPy 还内建了大量的函数，方便你快速构建数学模型。

2. 创建 numpy 数组

创建数组 1， 2， 3

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jkbRDMfA-1605604842860)(attachment:image.png)]

import numpy as np

print(np.array([1, 2, 3]))

[1 2 3]

创建数组 [1, 1, 1]; [0, 0, 0]; [随机，随机，随机]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ucPS4FmN-1605604842863)(attachment:image.png)]

# 1. 数组[1, 1, 1]
print(np.ones(3))

# 2. 数组[0, 0, 0]
print(np.zeros(3))

# 1. 数组[..., ..., ...]
print(np.random.random(3))

[1. 1. 1.]
[0. 0. 0.]
[0.72325184 0.33075919 0.97509469]

创建 1-6 数组；-2到1间隔0.5数组，前开后闭

# 1. 1-6 数组
a = np.arange(6)
print(a)

# 2. -2-1 间隔 0.5 数组
a = np.arange(-2, 1, 0.5)
print(a)

[0 1 2 3 4 5]
[-2.  -1.5 -1.  -0.5  0.   0.5]

创建数组 0-2，并且被分为5份，包含5；0-10，被分为10分，不包含10

# 0-2，5份，包含2
a = np.linspace(0, 2, 5)
print(a)

# 0-10，10份，不包含10
a = np.linspace(0, 10, 10, endpoint=False)
print(a)

[0.  0.5 1.  1.5 2. ]
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]

创建二维0数组和二维1数组；

# 1. 2x3 0数组
a = np.zeros([2, 3])
print(a)

print()

# 2. 2x3 1数组
a = np.ones([2, 3])
print(a)

[[0. 0. 0.]
 [0. 0. 0.]]

[[1. 1. 1.]
 [1. 1. 1.]]

创建 numpy 对角单位矩阵；斜对角矩阵

# 1. 对角单位矩阵 2x2
a = np.eye(2)
print(a)

print()
# 2. 斜对角矩阵
# 创建 [1, 2, 3] 1d 矩阵
a = np.array([1, 2, 3])
print(a)
print()
# 2d 斜对角矩阵
d = np.diag(a)  
print(d)

[[1. 0.]
 [0. 1.]]

[1 2 3]

[[1 0 0]
 [0 2 0]
 [0 0 3]]

3. numpy 数组属性

a = np.arange(12).reshape(3, 4)
print(a)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

数组维度

a.ndim

2

数组形状

a.shape

(3, 4)

数组元素个数

a.size

12

数组数据类型

a.dtype

dtype('int32')

指定数组数据类型

# 指定数组数据类型为 float64
a = np.array([1.1, 2.2, 3.3], dtype=np.float64)
print(a)
print(a.dtype)

[1.1 2.2 3.3]
float64

数组数据类型转换

# 数组数据类型 float64 - int
a_int = a.astype(int)
a_int.dtype

dtype('int32')

---

2. numpy 进阶

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mlz6tErK-1605604842868)(attachment:image.png)]

1. numpy 数组运算

data = np.array([1, 2])
print("data: {0}".format(data))

ones = np.ones(2)
print("ones: {0}".format(ones))

data: [1 2]
ones: [1. 1.]

加

data + ones

array([2., 3.])

减

data - ones

array([0., 1.])

乘

data * ones

array([1., 2.])

除

data / ones

array([1., 2.])

数组乘以常量

data * 1.6

array([1.6, 3.2])

平方

data ** 2

array([1, 4], dtype=int32)

三角函数

np.sin(data)

array([0.84147098, 0.90929743])

指数函数

# exponent
np.exp(data)

array([2.71828183, 7.3890561 ])

开平方

np.sqrt(data)

array([1.        , 1.41421356])

布尔过滤

a = np.array([20, 30, 40, 50])
a <= 35

array([ True,  True, False, False])

2. numpy 数组和 list 比较 (todo)

3. numpy 数组的索引

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SYRUS8ra-1605604842873)(attachment:image.png)]

data = np.array([1, 2, 3])
print(data, "")
print(data[0], "")
print(data[1], "")
print(data[0: 2], "")  # 不包含 index=2
print(data[1: ], "")

[1 2 3] 
1 
2 
[1 2] 
[2 3] 

4. numpy 数组的元素操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FY8cendQ-1605604842876)(attachment:image.png)]

data = np.array([1, 2, 3])
print("最大：", data.max(), "")
print("最小：", data.min(), "")
print("总和：", data.sum(), "")
print("均值：", data.mean(), "")

最大： 3 
最小： 1 
总和： 6 
均值： 2.0 

5. numpy 二维数组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-biCE99Mv-1605604842879)(attachment:image.png)]

a_2d = np.array([
    [1, 2],
    [3, 4],
])
a_2d

array([[1, 2],
       [3, 4]])

6. numpy 2D数组运算

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nGIEyixa-1605604842880)(attachment:image.png)]

data = np.array([
    [1, 2],
    [3, 4],
])

data

array([[1, 2],
       [3, 4]])

ones = np.ones((2, 2))
ones

array([[1., 1.],
       [1., 1.]])

# 2d 数组相加
data + ones

array([[2., 3.],
       [4., 5.]])

# 2d 数组广播相加
ones_row = np.ones((1, 2))
ones_row

array([[1., 1.]])

data + ones_row

array([[2., 3.],
       [4., 5.]])

7. numpy 数组切片和索引 ([start: stop], half interval)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-upa8JZ0M-1605604842883)(attachment:image.png)]

data = np.arange(1, 7, 1).reshape(3, 2)
data

array([[1, 2],
       [3, 4],
       [5, 6]])

print("result:", data[0, 1])  # 0行1列
print("result:", data[1: 3])  # 1-2行，所有列
print("result:", data[0: 2, 0])  # 0-1行，0列

result: 2
result: [[3 4]
 [5 6]]
result: [1 3]

8. numpy 数据转置 (.T)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ne8pibvO-1605604842885)(attachment:image.png)]

print(data, "\n")
print(data.T)  # 二维数组转置 transposiation

[[1 2]
 [3 4]
 [5 6]] 

[[1 3 5]
 [2 4 6]]

9. numpy 数据变形 (.reshape(row, col))

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fYgYbmyx-1605604842887)(attachment:image.png)]

# 1. 创建一维数组
a = np.array([1, 2, 3, 4, 5, 6])  # 或 a = np.arange(1, 7, 1); start, stop, step, [)
print(a, "\n")
print(a.reshape(2, 3), "\n")
print(a.reshape(3, 2), "\n")
print(a.reshape(3, -1), "\n")  # row=3, col=随意（-1）
print(a.ravel(), "\n")  # 降为一维

[1 2 3 4 5 6] 

[[1 2 3]
 [4 5 6]] 

[[1 2]
 [3 4]
 [5 6]] 

[[1 2]
 [3 4]
 [5 6]] 

[1 2 3 4 5 6] 

​

10. numpy 高维数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4vdZ39uO-1605604842889)(attachment:image.png)]

# 1. 创建三维数组，方法1
a_3d = np.array([
    [
        [1, 2],
        [3, 4],
    ],
    [
        [5, 6],
        [7, 8],
    ],
])
a_3d

array([[[1, 2],
        [3, 4]],

       [[5, 6],
        [7, 8]]])

# 1. 创建三维数组，方法2
a_3d = np.arange(1, 9, 1).reshape(2, 2, 2)  # row, col, stack
a_3d

array([[[1, 2],
        [3, 4]],

       [[5, 6],
        [7, 8]]])

# 2. 维度
a_3d.ndim

3

# 3.形状
a_3d.shape

(2, 2, 2)

11. numpy 数据维度应用场景 (略)

---

3. numpy 统计分析

$\left[\begin{array}{cc}0,& 1\\ 2,& 3\end{array}\right]$

1. 求和

a_statistic = np.arange(0, 4, 1).reshape(2, 2)
a_statistic

array([[0, 1],
       [2, 3]])

a_statistic.sum()  # python builtins

6

np.sum(a_statistic)

6

2. 按列操作求和（axis=0）

np.sum(a_statistic, axis=0)  # 求每一列所有元素的和

array([2, 4])

3. 按行操作求和（axis=1）

np.sum(a_statistic, axis=1) # 求每一行所有元素的和

array([1, 5])

4. 求最大值

np.max(a_statistic)

3

5. 求最小值

np.min(a_statistic)

0

6. 求平均值

np.mean(a_statistic)

1.5

7. 求中位数

(wiki)
中位数（又称中值，英语：Median），统计学中的专业名词，代表一个样本、种群或概率分布中的一个数值，其可将数值集合划分为数量相等的上下两部分。

一个数集中最多有一半的数值小于中位数，也最多有一半的数值大于中位数。如果大于和小于中位数的数值个数均少于一半，那么数集中必有若干值等同于中位数。

np.median(a_statistic)

1.5

8. 求方差（方程反应稳定程度）

(wiki)
方差（英语：Variance），应用数学里的专有名词。在概率论和统计学中，一个随机变量的方差描述的是它的离散程度，也就是该变量离其期望值的距离。

方差（应用数学），期望（概率与统计学）

方差的正平方根称为该随机变量的标准差（此为相对各个数据点间）

方差、标准差、均方差、均方误差（MSE）区别总结)

# 方差越大，数据的波动越大；方差越小，数据的波动就越小 
# 方差是指一组数据中的各个数减这组数据的平均数的平方和的平均数，
# 如（1，2，3,4,5）这组数 据的方差，就先求出这组数据的平均数（1+2+3+4+5）÷5＝3，
# 然后再求各个数与平均数的差的平 方和，
# 用（1-3）²+（2-3）²+（3-3）²+（4-3）²+（5-3）²＝10，再求平均数10÷5＝2，即这 组数据的方差为2
np.var(a_statistic)

1.25

9. 求标准差，均方差

(wiki)
标准差（又称标准偏差、均方差，英语：Standard Deviation，缩写SD），数学符号σ（sigma），在概率统计中最常使用作为测量一组数值的离散程度之用。标准差定义：为方差开算术平方根，反映组内个体间的离散程度；标准差与期望值之比为标准离差率。

基本定义

$SD=\sqrt{\frac{1}{N}\sum _{i=1}^N(x_i-\mu {)}^2}$

$\mu$ 为平均值（ $\overline{x}\overline{x}$）

np.std(a_statistic)

1.118033988749895

---

4. 偏差和方差

偏差：枪的镜头准不准会产生偏差，偏差是固定的
方差：枪手的手抖不抖会产生方差，方差是波动的

偏差可以很容易加偏移量 bias修正。
方差反映了选手的能力，需要经过艰苦卓绝的训练才能降低方差。

---

5. numpy 线性代数入门

1. 初等数学和高等数学

线性代数3大核心概念

• 向量
• 矩阵
• 维度

向量： 一串数字
标量： 一个数字
维度：数字如何组合

2. numpy 矩阵的乘法

点积、点乘、数量级、标量积、内积

(wiki)
在数学中，点积（英语：Dot Product）又称数量积或标量积（英语：Scalar Product），是一种接受两个等长的数字序列（通常是坐标向量）、返回单个数字的代数运算。

在欧几里得几何中，两个笛卡尔坐标向量的点积常称为内积（英语：Inner Product），见内积空间。

从代数角度看，先对两个数字序列中的每组对应元素求积，再对所有积求和，结果即为点积。

从几何角度看，点积则是两个向量的长度与它们夹角余弦的积。这两种定义在笛卡尔坐标系中等价。

点积的名称源自表示点乘运算的点号（ $a\cdot b$），读作 $ {\displaystyle a\ dot\ b}$，标量积的叫法则是在强调其运算结果为标量而非向量。

向量的另一种乘法是叉乘（$ {\displaystyle a\times b}$），其结果为向量，称为叉积或向量积。

• 小明今天要做饭，消耗2斤肉，1斤蔬菜。肉每斤20元，蔬菜每斤5元，则一共需多少花费？

  $\left[\begin{array}{cc}20& 5\end{array}\right]\times \left[\begin{array}{c}2\\ 1\end{array}\right]=45$

# 1. 定义采购清单数组
a_item = np.array([20, 5])
# 2. 定义价格数组
a_price = np.array([2, 1])
# 3. 求解总价，使用点乘（数量级）
np.dot(a_item, a_price)

# 矩阵运算就是定义了一组数据排放的格式， 不同位置的数据代表不同的含义。

45

3. numpy 求解鸡兔同笼问题

大约在1500年前，《孙子算经》中就记载了这个有趣的问题。书中是这样叙述的：
今有鸡兔同笼，上有三十五头，下有九十四足，问鸡兔各几何？

翻译： 有若干只鸡兔同在一个笼子里，从上面数，有35个头，从下面数，有94只脚。问笼中各有多少
只鸡和兔？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mmi917SJ-1605604842891)(attachment:image.png)]

使用高等数学矩阵 AX=B 求解

# 鸡 x1 只，兔 x2 只
# 鸡头+兔头=35；1 * x1 + 1 * x2 = 35
# 鸡脚+兔脚=94；2 * x1 + 4 * x2 = 94
# 1，1   x1   35
# 2，4   x2   94
# A      X    B

# 1. 定义头数数组
a_head = np.array([1, 1])
# 2. 定义脚数数组
a_leg = np.array([2, 4])

# 3. 定义 A 数组
A = np.array([
    a_head,
    a_leg,
])
# 4. 定义 B 数组
B = np.array([35, 94])

# 5. solve求解，solve a linear matrix equation/system of linear scalar equations
numpy.linalg.solve(A, B)  # linalg: linear algorithm

对 AX=B 使用逆矩阵求解

$X=A^{-1}B$

np.dot(np.linalg.inv(A), B)

array([23., 12.])

使用方程组求解

# 1. 导入 sympy 库
from sympy import *

# 2. 声明代数符号
x1, x2 = symbols("x1, x2")

# 3. 创建计算头总数等式
eq_head = Eq(1 * x1 + 1 * x2, 35)
# 4. 创建计算脚总数等式
eq_leg = Eq(2 * x1 + 4 * x2, 94)

# 5. 使用 sympy.solve 求解方程组
solve([eq_head, eq_leg])

{x1: 23, x2: 12}

4. numpy 倒数和逆矩阵

倒数（dào shù）（reciprocal / multiplicative inverse）

一个数x与其相乘的积为1的数

0没有倒数

逆矩阵（inverse matrix）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tlqOzAfw-1605604842892)(attachment:image.png)]

# 1. 定义一个二维数组 a_random
np.random.seed(seed=3)
# a_random_2d = np.random.randn(3, 3)
# a_random_2d = np.arange(1, 17).reshape(4, 4)
a_random_2d = np.array([
    [1, 2],
    [3, 4],
])

a_random_2d

array([[1, 2],
       [3, 4]])

# 2. 求a_random_2d 的逆矩阵 inv_a_random_2d
inv_a_random_2d = np.linalg.inv(a_random_2d)
inv_a_random_2d

array([[-2. ,  1. ],
       [ 1.5, -0.5]])

# 3. 验证
np.dot(a_random_2d, inv_a_random_2d)

array([[1.00000000e+00, 1.11022302e-16],
       [0.00000000e+00, 1.00000000e+00]])

# 4. 验证
np.dot(a_random_2d, np.linalg.inv(a_random_2d))

array([[1.00000000e+00, 1.11022302e-16],
       [0.00000000e+00, 1.00000000e+00]])

---

6. numpy 随机数

1. numpy 随机数

主要由 numpy.random 模块完成

主要由以下一些方法完成：numpy.random.rand(d0, d1, ..., dn)

并使用 [0, 1) 区间随机数据填充，这些数据均匀分布：np.random.rand(2, 5)

numpy.random.randn(d0, d1, ..., dn) 与 numpy.random.rand(d0, d1, ..., dn) 的区别在于，前者是从标准正态分布中返回一个或多个样本值。

randint(low, high, size, dtype) 方法将会生成 [low, high) 的随机整数。注意这是一个半开半闭区间：np.random.randint(2, 5, 10)

random_sample(size) 方法将会在 [0, 1) 区间内生成指定 size 的随机浮点数：np.random.random_sample([10])

2. numpy 随机数 api

返回一个shape为 2行5列的随机数数组, 值在0到1之间 [0,1)

# 返回一个shape为 2行5列的随机数数组,  值在0到1之间 [0,1)
np.random.rand(2,5)

array([[0.5507979 , 0.70814782, 0.29090474, 0.51082761, 0.89294695],
       [0.89629309, 0.12558531, 0.20724288, 0.0514672 , 0.44080984]])

生成1行10列的正态分布的随机数

# 生成1行10列的正态分布的随机数
np.random.randn(1,10)

array([[-0.04381817, -0.47721803, -1.31386475,  0.88462238,  0.88131804,
         1.70957306,  0.05003364, -0.40467741, -0.54535995, -1.54647732]])

生成1行10列的正态分布的随机数

# randint (随机整数)
np.random.randint(2,5,10)
#最小值2,最大值5
#[2,5) 
# 10个随机数

array([3, 4, 2, 4, 2, 3, 2, 3, 2, 4])

在0到1之间生成指定大小的随机浮点数

# 在0到1之间生成指定大小的随机浮点数
np.random.random_sample([10])

array([0.89306511, 0.71842202, 0.0206145 , 0.14271733, 0.32530618,
       0.8089292 , 0.39899095, 0.42470161, 0.41371868, 0.7871385 ])

---

7. 概率基础入门

标准正态分布又称为u分布，是以0为均数、以1为标准差的正态分布，记为N（0，1）。

测量的误差 都是在标准数值上下浮动。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Lk7yKyjs-1605604842894)(attachment:image.png)]

μ是期望值（平均数）， σ是标准差（均方差）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IyEDeHhR-1605604842896)(attachment:image.png)]

Normal distribution

In probability theory, a normal (or Gaussian or Gauss or Laplace–Gauss) distribution is a type of continuous probability distribution for a real-valued random variable. The general form of its probability density function is：

$f(x)=\frac{1}{\sigma \sqrt{2\pi }}{e}^{-\frac{1}{2}{\left(\frac{x-\mu }{\sigma }\right)}^2}$

The parameter $ \mu$ is the mean or expectation of the distribution (and also its median and mode), (期望、均值)

while the parameter $ \sigma$ is its standard deviation.（标准差）

The variance of the distribution is $ \sigma ^{2}$.（方差）

创建正态分布，期望u=85，详细波动10，4x4矩阵

samples = np.random.normal(85, 10, size=(4,4))  # mean, standard deviation, size
samples

array([[ 91.26523492,  66.61128338,  91.31922526,  99.30496539],
       [ 90.84076867,  73.72207261,  93.39998367,  88.68274037],
       [ 80.26720463,  96.70187995,  85.6006215 ,  84.02085567],
       [ 79.82487567, 103.42720402,  87.63072704,  62.49902783]])

创建正态分布，期望u=0，4x4矩阵

samples = np.random.randn(4,4)
samples

array([[ 1.36374261, -0.18869992,  0.88017359, -0.47035361],
       [ 3.04817148, -0.81361969,  0.08619699,  1.30118569],
       [-0.43540545, -0.78697804, -0.59039268,  1.00420471],
       [-0.01514394, -0.41303679,  0.00543419, -0.46208081]])

创建10000x10000正态分布

samples = np.random.randn(10000, 10000)
samples

array([[-0.18511682,  0.35392212,  1.07164202, ..., -0.42904947,
        -0.60128889,  1.67353845],
       [-0.61340182, -0.32909342, -0.62117178, ...,  2.07574234,
         0.71181868, -0.37584731],
       [-0.28285024, -1.65056979,  1.76895029, ..., -0.48947015,
         2.19572155,  1.03972482],
       ...,
       [ 0.15979727, -0.44450146,  0.81457076, ..., -0.74083951,
         0.14889562, -1.22268499],
       [-1.12035684, -0.992758  , -0.31651157, ...,  0.38051484,
        -0.65671628, -1.24961783],
       [-0.26519644, -0.56649243,  1.06494977, ..., -1.84670641,
        -0.06656356, -1.19089753]])

# 求平均值
samples.mean()

4.5275772663803533e-05

# 求标准差，均方差
samples.std()

1.0000741966190665

1. numpy 数据打散

a = np.array(range(5)) 
a

array([0, 1, 2, 3, 4])

# Randomly permute a sequence, or return a permuted range.
# #不修改原始的数据
np.random.permutation(a) #打乱，不修改原数据 
a

array([0, 1, 4, 2, 3])

# Modify a sequence in-place by shuffling its contents.
# 修改原始数据
np.random.shuffle(a)
a

array([3, 0, 4, 2, 1])

2. numpy 随机数种子

指定种子的一条随机代码的值不会改变

# 指定随机种子
np.random.seed(seed=3)

# 创建随机矩阵，执行多次值不变
np.random.randn(2, 2)

array([[ 1.78862847,  0.43650985],
       [ 0.09649747, -1.8634927 ]])

# 创建随机矩阵，执行多次值改变
np.random.randn(2, 2)

array([[-0.92379202, -1.02387576],
       [ 1.12397796, -0.13191423]])

# 创建随机矩阵，执行多次值改变
np.random.randn(2, 2)

array([[-0.59664964, -0.58859438],
       [-0.8738823 ,  0.02971382]])

3. numpy 逻辑操作

a = np.array([True, True, False])
a

array([ True,  True, False])

判断a是不是都真

np.all(a)

False

判断a是不是有真

np.any(a)

True

过滤 >3

a = np.array([1, 2, 3, 4, 5, 6, 7])
a > 3

array([False, False, False,  True,  True,  True,  True])

过滤 <5

a < 5

array([ True,  True,  True,  True, False, False, False])

转换普通 numpy 数组到真值数组

a = np.zeros((3, 3))
a

array([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]])

a == 0

array([[ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True]])

a != 0

array([[False, False, False],
       [False, False, False],
       [False, False, False]])

---

8. numpy 排序操作

# 创建一个服从正态分布的随机数组
a = np.random.randn(10)
a

array([-2.24825777, -0.26776186,  1.01318344,  0.85279784,  1.1081875 ,
        1.11939066,  1.48754313, -1.11830068,  0.84583341, -1.86088953])

直接排序

a.sort()
a

array([-2.24825777, -1.86088953, -1.11830068, -0.26776186,  0.84583341,
        0.85279784,  1.01318344,  1.1081875 ,  1.11939066,  1.48754313])

排序索引

a.argsort()  # 上一段代码已经排序好了

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int64)

按行排序，从小到大 (左到右)

# 1. 创建一个符合正态分布的二维数组 3x3
b = np.random.randn(3, 3)
b 

array([[-0.6028851 , -1.91447204,  1.04814751],
       [ 1.33373782, -0.19741468,  1.77464503],
       [-0.67472751,  0.15061687,  0.1529457 ]])

# 每一行左（最小），右（最大）
b.sort(axis=1)
b

array([[-1.91447204, -0.6028851 ,  1.04814751],
       [-0.19741468,  1.33373782,  1.77464503],
       [-0.67472751,  0.15061687,  0.1529457 ]])

按列排序，从小到大

# 1. 创建一个符合正态分布的二维数组 3x3
b = np.random.randn(3, 3)
b 

array([[ 0.64316328,  0.24908671, -1.3957635 ],
       [ 1.39166291, -1.37066901,  0.23856319],
       [ 0.61407709, -0.83791227,  0.14506321]])

# 每一列上（最小），下（最大）
b.sort(axis=0)
b

array([[-1.06419527,  0.43794661, -0.15450685],
       [-1.02493087,  0.48378835,  0.6762164 ],
       [ 1.7696273 ,  0.89933845,  1.93897846]])

按行排序索引，从小到大

b = np.random.randn(3,3) 
b

array([[ 0.56448552,  1.23347104,  0.14898639],
       [-0.53058214, -0.73052664,  0.64506198],
       [ 0.31306037, -0.51664792, -0.18907167]])

b.argsort(axis = 1)

array([[2, 0, 1],
       [1, 0, 2],
       [1, 2, 0]], dtype=int64)

按列排序索引，从小到大

b = np.random.randn(3,3) 
b

array([[-0.41619802,  0.72465766, -0.68996068],
       [ 0.48641448,  0.85151895,  0.48624933],
       [-0.83423985,  1.34499246, -0.67821268]])

b.argsort(axis = 1)

array([[2, 0, 1],
       [2, 0, 1],
       [0, 2, 1]], dtype=int64)

---

9. 行向量和列向量

numpy中一维数组 行向量和列向量没有任何区别

a = np.array([1,2,3]) 
print("{0}\n{1}\n".format(a, a.T)) 
print(a.transpose())

[1 2 3]
[1 2 3]

[1 2 3]

二维数组 行向量列向量变化

b = np.array([[1],[2],[3]]) 
print(b, "\n")
print(b.T , "\n")
print(b.transpose(), "\n")

[[1]
 [2]
 [3]] 

[[1 2 3]] 

[[1 2 3]] 

​

一维数组变二维

 np.array([1,2,3]).reshape(3,1)

array([[1],
       [2],
       [3]])

其他创建行向量或者列向量方式

a = np.r_[-2, -1, 3,2,3,4,1:4] 
print(a, "\n")
print(np.c_[np.array([1,2,3,4,5])], '\n')

[-2 -1  3  2  3  4  1  2  3] 

[[1]
 [2]
 [3]
 [4]
 [5]] 

​

---

10.【案例】计算PI

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VlobX7A5-1605604842899)(attachment:image.png)]

绿圆横坐标平方+纵坐标平方的值小于1

# 1. 生成随机点，二维矩阵（x, y），第一列表示x轴坐标，第二列表示y轴坐标
num = 99999999
b = np.random.rand(num, 2)  # num X 2 尺寸的随机矩阵 （xn, yn）, 范围 0-1，属于第一象限

# 2. 对坐标矩阵每一列的坐标进行平方 (xn^2, yn^2)
sqr_b = b ** 2

# 3. 对平方后的x,y 坐标进行求和，行操作
sum_sqr_b = np.sum(sqr_b, axis = 1)

# 4. 统计平方和点矩阵中所有小于等于1的点的个数
circle_count = np.sum(sum_sqr_b <= 1)

# 5. 在圆内点 比 正方形点 = PI
# 因为 rand 生成的数 在 0-1 之间，即在第一象限，所以要乘以4
my_pi = 4 * circle_count / num
my_pi

3.1416092714160926

---

11. numpy 1D 数组

1. numpy 1D 数组切片和索引

创建数组

# 使用 arange 创建 0-9 的一维数组的平方
a = np.arange(10) ** 2
a

array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81], dtype=int32)

索引元素

a[2]

4

索引2-5元素,前闭后开（2，3，4，）

a[2:6]

array([ 4,  9, 16, 25], dtype=int32)

索引步长

a[::2]

array([ 0,  4, 16, 36, 64], dtype=int32)

倒序索引

a[::-1]

array([81, 64, 49, 36, 25, 16,  9,  4,  1,  0], dtype=int32)

---

12. numpy 2D 数组

1. numpy 2D 数组索引

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w6AKLOVP-1605604842903)(attachment:image.png)]

# 1. 创建数组 2d
a = np.arange(6).reshape(2, 3)
a

array([[0, 1, 2],
       [3, 4, 5]])

# 2. 取一行
a[1]

array([3, 4, 5])

# 3. 取一列
a[:, 1]

array([1, 4])

# 4. 取二维数组的一个元素
a[1][1]

4

# 4. 同上
a[1, 1]

4

2. numpy 2D 数组和普通 python 数组区别 (略)

3. numpy 2D 数组切片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2ce9gQmr-1605604842904)(attachment:image.png)]

切割红色数据

a = np.arange(0, 25, 1).reshape(5, 5)
a

array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24]])

a[1,2:4]

array([7, 8])

切割绿色数据

 a[3:,3:]

array([[18, 19],
       [23, 24]])

切割紫色数据

a[:,1]

array([ 1,  6, 11, 16, 21])

切割黄色数据

 a[::2,2::2]

array([[ 2,  4],
       [12, 14],
       [22, 24]])

---

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W9gqsO8c-1605604842906)(attachment:image.png)]

切割红色区域

a[[0,2,4],[0,2,4]] #推荐这种写法

array([ 0, 12, 24])

切割绿色区域

a[[1,3,4],3:]

array([[ 8,  9],
       [18, 19],
       [23, 24]])

切割紫色区域

mask = np.array([False, True, True, True, False])
a[1, mask]

array([6, 7, 8])

---

13. numpy 数组操作

1. numpy 数组拆分

# 1. 创建数组
a = np.arange(9).reshape(3,3)
a

array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

按行拆分

np.vsplit(a, 3)  # 拆成3行

[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]

按列拆分

np.hsplit(a, 3)  # 拆成3列

[array([[0],
        [3],
        [6]]),
 array([[1],
        [4],
        [7]]),
 array([[2],
        [5],
        [8]])]

2. numpy 数组合并

# 1. 创建数组 a, b
a = np.array([
    [0, 1],
    [2, 3],
])

b = np.array([
    [0, -1],
    [-2, -3],
])

print(a, "\n", b, "\n")

[[0 1]
 [2 3]] 
 [[ 0 -1]
 [-2 -3]] 

​

上下合并

np.vstack((a, b))

array([[ 0,  1],
       [ 2,  3],
       [ 0, -1],
       [-2, -3]])

水平合并

np.hstack((a, b))

array([[ 0,  1,  0, -1],
       [ 2,  3, -2, -3]])

3. numpy 数组高级操作

创建数组a

a = np.arange(5) ** 2
a

array([ 0,  1,  4,  9, 16], dtype=int32)

创建数组i

i = np.array([3, 1, 3, 0])
i

array([3, 1, 3, 0])

用i数组索引a数组的元素

a[i]

array([9, 1, 9, 0], dtype=int32)

---

14. numpy 广播入门

不同形状和维度的数组在某些情况下, numpy可以执行加减乘除的运算,这种机制就叫做广播机制

示例1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qWbN8oLC-1605604842907)(attachment:image.png)]

import numpy as np 
a = np.arange(3) 
b = 1 
a + b

array([1, 2, 3])

示例2

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SUlwauTv-1605604842908)(attachment:image.png)]

a = np.arange(6).reshape(2, 3) 
b = np.array([0, 1, 2]) 
a + b 

array([[0, 2, 4],
       [3, 5, 7]])

示例3

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VfonOct9-1605604842909)(attachment:image.png)]

a = np.arange(6).reshape(2, 3) 
b = np.array([0, 1]).reshape(2, 1) 
a + b

array([[0, 1, 2],
       [4, 5, 6]])

示例4

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q6qkpgV8-1605604842910)(attachment:image.png)]

a = np.arange(6).reshape(2, 3) 
b = 2 
a + b

array([[2, 3, 4],
       [5, 6, 7]])

示例5

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eTSMIfvy-1605604842912)(attachment:image.png)]

a = np.array([0, 3]).reshape(2, 1) 
b = np.array([0, 1, 2]) 
a + b

array([[0, 1, 2],
       [3, 4, 5]])

示例6

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ggo0158F-1605604842912)(attachment:image.png)]

我们可以通过下面这些方法对数组中元素进行搜索和计数。列举如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E6h5rd9X-1605604842915)(attachment:image.png)]

---

15.【案例】地铁梯度票价表 （略）

深圳地铁票价规则:
起步价前4公里2元;以后4公里至12公里部分,每1元可乘坐4公里;12公里至24公里部分,每1元可乘坐6公 里;超过24公里,每1元可乘坐8公里

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QCur5jgM-1605604842918)(attachment:image.png)]

---

16.【作业题】线性代数+概率

1. 导入依赖

2. 创建 10 个 0 的一维数组

3. 创建 10个 1 的一维数组

4. 创建 10个 5 的 一维数组

5. 创建 10-50 的一维数组

6. 创建 10-50 偶数的一维数组

7. 创建 3x3 的二维数组，包含0-8

8. 创建 3x3 的二维单位矩阵

9. 创建 0-1 之间的随机数

10. 创建 25 个正态分布的随机数

11. 创建 10x10 的矩阵从 0.01 到 1

12. 创建 0 到 1，中间 20 个相同的线段

13. 创建 5x5 的二维数组，其中边界值为 1，其余值为 0

14. 找出两个一维数组里面相同的元素

15. 创建一个长度为 5 的一维数组，并将其中最大值替换为 0

---

17.【作业题】数组操作及计算

1. 切割数组

2. 求 mat 所有元素的和

3. 求 mat 所有元素的标准差

4. 换行求 mat 所有元素的和

---