Numpy学习笔记（二）

基本运算

（一）矢量和矩阵运算

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

1、加法

  print(array+2)
  
   # [[3 4]
   #  [5 6]
   #  [7 8]]

2、减法

 print(array-2)
 
 # [[-1  0]
 #  [ 1  2]
 #  [ 3  4]]

3、 乘法

 print(array*2)
 
 # [[ 2  4]
 #  [ 6  8]
 #  [10 12]]

4、 除法

print(array/2)

# [[0.5 1. ]
#  [1.5 2. ]
#  [2.5 3. ]]

5、幂运算

print(array ** 2)

# [[ 1  4]
#  [ 9 16]
#  [25 36]]

（二）统计运算

1、求和

np.sum(arr, axis=None, keepdims=np._NoValue, initial=np._NoValue)

计算数组中所有元素的和

• arr: 输入数组，可以是任何维度的数组。
• axis: 指定沿哪个轴进行求和。对于二维数组，axis=0 表示按列求和（即沿着行的方向），axis=1 表示按行求和（即沿着列的方向）。如果 axis 是 None 或未指定，则计算整个数组所有元素的和。
• keepdims: 布尔值或 np._NoValue（默认值）。如果为 True，则输出的维度将与输入数组 a 相同，但在 axis 指定的维度上大小为 1。如果为 False 或未指定，则输出数组将是一个降维的数组。
• initial: 用于求和计算的初始值。这通常不用于普通情况，但在某些特殊情况下可能很有用。
• np._NoValue 是一个特殊的 NumPy 值，用于表示函数参数的默认值。

import numpy as np

# 一维数组相加
print(np.sum([1, 2, 3, 4]))  # 10

# 二维数组相加
print(np.sum([[1, 2], [3, 4]]))  # 10

# 初始值相加
print(np.sum([1, 2, 3, 4], initial=5))  # 15

# 沿行相加
print(np.sum([[1, 2], [3, 4]], axis=1))  # [3 7]

# 沿列相加
print(np.sum([[1, 2], [3, 4]], axis=0))  # [4 6]

# 沿行相加，结果不降维
print(np.sum([[1, 2], [3, 4]], axis=1, keepdims=True))
# [[3]
#  [7]]

# 沿列相加，结果不降维
print(np.sum([[1, 2], [3, 4]], axis=0, keepdims=True))
# [[4 6]]

 

2、求平均值

np.mean(arr, axis=None,keepdims=False)

返回沿给定轴的平均值，axis没有指定时，默认为None，表示返回所有元素的平均值

• axis = 0
  表示沿着行的方向（即垂直方向）进行操作，因此它会计算每一列的平均值。
• axis = 1
  表示沿着列的方向（即水平方向）进行操作，因此它会计算每一行的平均值。
• keepdims: 布尔值或 np._NoValue（默认值）。如果为 True，则输出的维度将与输入数组 a 相同，但在 axis 指定的维度上大小为 1。如果为 False 或未指定，则输出数组将是一个降维的数组。

import numpy as np

lis = [[0, 1, 7, 3], [4, 9, 6, 2], [8, 5, 11, 10]]
arr = np.array(lis)

# 打印数组
print(arr)
#[[ 0  1  7  3]
# [ 4  9  6  2]
# [ 8  5 11 10]]

# 计算所有均值
print(np.mean(arr)) # 5.5

# 计算每列的均值
print(np.mean(arr, axis=0)) # [4. 5. 8. 5.]

# 计算每行的均值
print(np.mean(arr, axis=1)) # [2.75 5.25 8.5 ]

 

3、求方差

np.var(arr, axis=None, ddof=0, keepdims=False)

返回沿给定轴的方差，axis没有指定时，默认为None，表示返回所有元素的方差。
方差是每个数据与平均值之差的平方的平均值，用于衡量数据的离散程度

• arr: 输入数组，其中包含要计算标准差的数值。
• axis=0表示沿着行的方向（即垂直方向）进行操作，因此它会计算每一列的方差。
• axis=1表示沿着列的方向（即水平方向）进行操作，因此它会计算每一行的方差。
• ddof: Delta Degrees of Freedom。在计算方差时，通常使用 n-1 作为分母，其中 n 是样本大小。ddof 表示自由度的调整，ddof=1 将使用 n 作为分母，这通常用于样本方差的计算。
• keepdims: 布尔值，如果为 True，则在结果中保持减少的维度。

import numpy as np

lis = [[0, 1, 7, 3], [4, 9, 6, 2], [8, 5, 11, 10]]
arr = np.array(lis)

# 打印数组
print(arr)

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

# 计算数组全部数据的方差
print(np.var(arr))  # 11.916666666666666

# 计算数组的列方差
print(np.var(arr, axis=0))  # [10.66666667 10.66666667  4.66666667 12.66666667]

# 计算数组的行方差
print(np.var(arr, axis=1))  # [7.1875 6.6875 5.25  ]

 

4、求标准差

np.std(arr, axis=None, ddof=0,keepdims=False)

返回沿给定轴的标准差，axis没有指定时，默认为None，表示返回所有元素的标准差
标准差是方差的平方根，用于衡量数据的离散程度

• arr: 输入数组，其中包含要计算标准差的数值。
• axis=0表示沿着行的方向（即垂直方向）进行操作，因此它会计算每一列的标准差。
• axis=1表示沿着列的方向（即水平方向）进行操作，因此它会计算每一行的标准差。
• ddof: Delta Degrees of Freedom。表示自由度的调整。ddof=1 将使用样本标准差（n-1）的计算方法，而 ddof=0 将使用总体标准差（n）的计算方法。
• keepdims: 布尔值，如果为 True，则在结果中保持减少的维度。

import numpy as np

lis = [[0, 1, 7, 3], [4, 9, 6, 2], [8, 5, 11, 10]]
arr = np.array(lis)

# 打印数组
print(arr)

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


# 计算所有数据标准差
print(np.std(arr))  # 3.452052529534663

# 计算每一列的标准差
print(np.std(arr, axis=0))  # [3.26598632 3.26598632 2.1602469  3.55902608]

# 计算每一行的标准差
print(np.std(arr, axis=1))  # [2.68095132 2.58602011 2.29128785]

 

5、求最大值

np.max(arr, axis=None,keepdims=False)

返回沿给定轴的最大值，axis没有指定时，默认为None，表示返回所有元素的最大值

• arr: 输入数组，其中包含要计算标准差的数值。
• axis=0表示沿着行的方向（即垂直方向）进行操作，因此它会返回每一列的最大值。
• axis=1表示沿着列的方向（即水平方向）进行操作，因此它会返回每一行的最大值。
• keepdims: 布尔值，如果为 True，则在结果中保持减少的维度。

import numpy as np

lis = [[0, 1, 7, 3], [4, 9, 6, 2], [8, 5, 11, 10]]
arr = np.array(lis)

# 打印数组
print(arr)

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


# 获取所有数据最大值
print(np.max(arr))  # 11

# 获取每列的最大值
print(np.max(arr, axis=0))  # [ 8  9 11 10]

# 获取每行的最大值
print(np.max(arr, axis=1))  # [ 7  9 11]

 

6、求最小值

np.min(arr, axis=None,keepdims=False)

返回沿给定轴的最小值，axis没有指定时，默认为None，表示返回所有元素的最小值

• arr: 输入数组，其中包含要计算标准差的数值。
• axis=0表示沿着行的方向（即垂直方向）进行操作，因此它会返回每一列的最小值。
• axis=1表示沿着列的方向（即水平方向）进行操作，因此它会返回每一行的最小值。
• keepdims: 布尔值，如果为 True，则在结果中保持减少的维度。

import numpy as np

lis = [[0, 1, 7, 3], [4, 9, 6, 2], [8, 5, 11, 10]]
arr = np.array(lis)

# 打印数组
print(arr)

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


# 获取所有数据最小值
print(np.min(arr))  # 0

# 获取每列的最小值
print(np.min(arr, axis=0))  # [0 1 6 2]

# 获取每行的最小值
print(np.min(arr, axis=1))  # [0 2 5]

 

（三）逻辑运算

1、逻辑非

np.logical_not(arr)

用于对布尔型数组 arr 进行逻辑非（NOT）操作。这个函数会逐个元素地反转数组中的数据，即将 True 变为 False，将 False 变为 True。

• arr: 输入数组，可以是布尔类型或者可以转换为布尔类型的数组。

import numpy as np

# 创建一个布尔数组
bool_arr = np.array([True, False, True, False])

not_arr = np.logical_not(bool_arr)

print(not_arr)  
# [False  True False  True]

逻辑非操作通常用于条件筛选或在布尔逻辑中实现取反的功能。

注意事项：

• 输入数组 arr 中的非布尔值会被隐式地转换为布尔值。例如，数值 0 会被转换为 False，而任何非零数值会被转换为 True。
• 结果数组 not_arr 的数据类型将与输入数组 arr 的数据类型一致。

 

2、逻辑与

np.logical_and(arr1, arr2) 或 arr1 & arr2

用于计算两个数组的按元素逻辑与（AND）操作。对于输入数组中的每个对应位置的元素，如果两个元素都是 True（或者在布尔上下文中相当于非零或非空），那么结果数组中相应位置的元素为 True，否则为 False。

• arr1 和 arr2: 输入数组。可以是相同形状的数组，或者是能够广播到相同形状的数组。

广播机制：

   如果输入数组的形状不完全相同，NumPy 会根据广播规则将它们广播到相同的形状，然后进行逻辑与操作。广播规则允许较小的数组根据需要扩展以匹配较大数组的形状。

import numpy as np

# 创建两个布尔数组
bool_arr1 = np.array([True, False, True, True])
bool_arr2 = np.array([True, True, False, False])

# 使用 logical_and 函数
result = np.logical_and(bool_arr1, bool_arr2)
print(result)
# [ True False  True False]

result 数组中的每个元素都是根据 bool_arr1 和 bool_arr2 中相应位置的元素进行逻辑与操作得到的。

注意事项：

• 如果输入数组包含非布尔值，NumPy 会将它们转换为布尔值（0 转换为 False，非 0 转换为 True）。
• 结果数组的数据类型是布尔型。

 

3、逻辑或

numpy.logical_or(arr1, arr2) 或 arr1 | arr2

用于对两个数组进行按元素的逻辑或（OR）操作。对于两个输入数组 arr1 和 arr2 中的每个对应位置的元素，如果至少有一个元素是 True（或者在布尔上下文中相当于非零或非空），那么结果数组中相应位置的元素将为 True；如果两个元素都是 False，则结果为 False。

• arr1 和 arr2: 输入数组。它们可以是相同形状的数组，或者是能够广播到相同形状的数组。

广播机制：

   如果输入数组的形状不完全相同，NumPy 会根据广播规则将它们广播到相同的形状，然后进行逻辑或操作。广播规则允许较小的数组根据需要扩展以匹配较大数组的形状。

import numpy as np

# 创建两个布尔数组
bool_arr1 = np.array([True, False, True, False])
bool_arr2 = np.array([False, True, False, True])

# 使用 logical_or 函数
result = np.logical_or(bool_arr1, bool_arr2)
print(result)
# [ True  True  True  True]

在这个例子中，result 数组中的每个元素都是根据 bool_arr1 和 bool_arr2 中相应位置的元素进行逻辑或操作得到的。

注意事项：

• 如果输入数组包含非布尔值，NumPy 会将它们转换为布尔值（0 转换为 False，非 0 转换为 True）。
• 结果数组的数据类型是布尔型。

 

4、逻辑异或

np.logical_xor(arr1, arr2,)

执行按元素的逻辑异或（XOR）操作。对于两个输入数组 arr1 和 arr2 中的每个对应位置的元素，如果两个元素的逻辑值不同，结果数组中相应位置的元素将为 True；如果两个元素的逻辑值相同，则结果为 False。

• arr1 和 arr2: 输入数组。它们可以是相同形状的数组，或者是能够广播到相同形状的数组。

import numpy as np

# 创建两个布尔数组
bool_arr1 = np.array([True, False, True, False])
bool_arr2 = np.array([False, True, False, True])

# 使用 logical_xor 函数
result = np.logical_xor(bool_arr1, bool_arr2)
print(result)

# [ True  True False  True]

在这个例子中，result 数组中的每个元素都是根据 bool_arr1 和 bool_arr2 中相应位置的元素进行逻辑异或操作得到的。

注意事项：

• 如果输入数组包含非布尔值，NumPy 会将它们转换为布尔值（0 转换为 False，非 0 转换为 True）。
• 结果数组的数据类型是布尔型。
   

（四）比较运算

1、等于

np.equal(arr1, arr2) 或 arr1 == arr2

按元素判断 arr1 == arr2 的结果

• arr1 ，arr2 的形状必须相同，或者可以广播

import numpy as np

print(np.equal([4, 2], [2, 2]))  # [False  True]

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

print(np.equal(a, b))

# [[False  True]
#  [False False]]


print(a == b)

# [[False  True]
#  [False False]]

 

2、不等于

np.not_equal(arr1, arr2) 或 arr1 != arr2

按元素判断 arr1 ！= arr2 的结果

• arr1 ，arr2 的形状必须相同，或者可以广播

import numpy as np

print(np.not_equal([4, 2], [2, 2]))  # [ True False]

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

print(np.not_equal(a, b))

# [[True False]
#  [True  True]]

print(a != b)

# [[True False]
#  [True  True]]

 

3、 大于

np.greater(arr1, arr2) 或 arr1 > arr2

按元素判断 arr1 > arr2 的结果

• arr1 ，arr2 的形状必须相同，或者可以广播

import numpy as np

print(np.greater([4, 2], [2, 1]))  # [ True  True]

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

print(np.greater(a, b))

# [[True False]
#  [True False]]

print(a > b)

# [[True False]
#  [True False]]

 

4、 小于

np.less(arr1, arr2) 或 arr1 < arr2

按元素判断 arr1 < arr2 的结果

• arr1 ，arr2 的形状必须相同，或者可以广播

import numpy as np

print(np.less([4, 2], [2, 2]))  # [False False]

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

print(np.less(a, b))

# [[False False]
#  [False  True]]

print(a < b)

# [[False False]
#  [False  True]]

 

5、大于等于

np.greater_equal(arr1, arr2) 或 arr1 >= arr2

按元素判断 arr1 >= arr2 的结果

• arr1 ，arr2 的形状必须相同，或者可以广播

print(np.greater_equal([4, 2], [2, 2]))  # [ True  True]

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

print(np.greater_equal(a, b))

# [[True  True]
#  [True False]]

print(a >= b)

# [[True  True]
#  [True False]]

 

6、 小于等于

np.less_equal(arr1, arr2) 或 arr1 <= arr2

按元素判断 arr1 <= arr2 的结果

• arr1 ，arr2 的形状必须相同，或者可以广播

import numpy as np

print(np.less_equal([4, 2], [2, 2]))  # [False  True]

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

print(np.less_equal(a, b))

# [[False  True]
#  [False  True]]

print(a <= b)

# [[False  True]
#  [False  True]]

 

（五）指数和对数运算

1、指数

np.exp(x)

计算 e 的 x 幂次方

# e的0次方、e的1次方、e的2次方
print(np.exp([0, 1, 2]))

# [1.         2.71828183 7.3890561 ]

 

2、自然对数

np.log(x)

计算 x 的自然对数(以e为底)

print(np.log([1, np.e, np.e ** 2]))

# [0. 1. 2.]

 

3、 以10为底的对数

np.log10(x)

计算 x 的以 10 为底的对数

import numpy as np

print(np.log10([1e-15, 1000]))
# [-15.   3.]

 

4、 以2为底的对数

np.log2(x)

计算 x 的以 2 为底的对数

import numpy as np

x = np.array([1, 2, 2 ** 4])
print(np.log2(x))

# [0. 1. 4.]

 

（六）线性代数运算

1、矩阵乘法

np.dot(a, b)

两个数组的点积
$a\cdot b=a[0]\ast b[0]+a[1]\ast b[1]+...+a[n]\ast b[n]$

import numpy as np

# 一维数组相乘
a = [1, 2, 3]
b = [1, 0, 2]
print(np.dot(a, b))  # 7

# 二维数组相乘
a = [[1, 0], [0, 1]]
b = [[4, 1], [2, 2]]
print(np.dot(a, b))

# [[4 1]
#  [2 2]]

# 标量相乘
print(np.dot(3, 4))  # 12

# 标量与数组相乘
a = 2
b = [[4, 1], [2, 2]]
print(np.dot(a, b))

# [[8 2]
#  [4 4]]

 

2、矩阵乘积

np.matmul(a, b)

两个数组的矩阵乘积 @操作符也可表示

  a = np.array([[1, 0],
                [0, 1]])
                
  b = np.array([[4, 1],[2, 2]])
  print(np.matmul(a, b))
  
  # [[4 1]
  #  [2 2]]
  
 print(a @ b)
  # [[4 1]
  #  [2 2]]
      
 a = np.array([[1, 0],
               [0, 1]])
               
 b = np.array([1, 2])
 
 print(np.matmul(a, b))
 print(a @ b)
    
 # [1 2]

3、迹(主对角线)

np.trace(arr, offset=0, axis1=0, axis2=1, dtype=None, out=None)

用于计算一个方阵（或二维数组）的迹（trace），也就是矩阵主对角线上元素的总和。主对角线是指从左上角到右下角的对角线。

• 输入的二维数组。
• 偏移量，用于指定主对角线的位置。默认为0，即主对角线
• axis1 和 axis2：这两个参数定义了矩阵的行和列，通常默认为axis1=0和axis2=1。
• dtype：输出数据类型。如果设置为None，则根据输入数据类型自动推断。

import numpy as np

A = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])

trace_A = np.trace(A)
print(trace_A)  # 输出结果为 1+5+9=15

注意，numpy.trace函数只适用于二维数组，如果输入的是一个多维数组，你需要指定axis1和axis2参数来确定计算迹的二维矩阵。
 

4、 行列式

np.linalg.det(arr)

用于计算一个方阵（即行数和列数相等的二维数组）的行列式。
行列式是一个标量值，它在数学中有许多重要的性质和应用，例如在求解线性方程组、计算矩阵的逆、以及在几何和物理学中描述体积变化等场合。

• arr：输入的方阵，必须是一个二维数组。

import numpy as np

# 定义一个2x2的方阵
A = np.array([[1, 2],
              [3, 4]])

# 计算方阵A的行列式
det_A = np.linalg.det(A)
print(det_A)  # 输出结果为 -2.0

在这个例子中，方阵A的行列式计算如下：
$det(A)=1\ast 4-2\ast 3=-2$

注意，如果输入的矩阵不是方阵，numpy.linalg.det函数将会抛出错误。此外，如果矩阵是奇异的（即其行列式为0），那么矩阵将没有逆矩阵。
 

5、逆矩阵

np.linalg.inv(arr)

用于计算一个方阵的逆矩阵。
逆矩阵是一个重要的矩阵概念，它在数学和工程学中有广泛的应用，比如在求解线性方程组、最小二乘问题以及在控制系统分析中。

• arr：输入的方阵，必须是一个二维数组。
• 函数返回输入方阵的逆矩阵。

import numpy as np

# 定义一个2x2的方阵
A = np.array([[1, 2],
              [3, 4]])

# 计算方阵A的逆矩阵
A_inv = np.linalg.inv(A)

print(A_inv)  # 输出方阵A的逆矩阵

# [[-2.   1. ]
#  [ 1.5 -0.5]]

注意，一个矩阵存在逆矩阵的前提是它是非奇异的，即其行列式值非零。如果矩阵是奇异的（行列式为0），那么这个矩阵没有逆矩阵，numpy.linalg.inv函数会抛出一个错误。

此外，矩阵求逆在数值计算中可能会有稳定性问题，特别是对于病态矩阵（ill-conditioned matrices）。
在实际应用中，如果需要解决线性方程组，通常推荐使用numpy.linalg.solve或者numpy.linalg.lstsq等方法，因为它们更加稳定。

下面是如何使用numpy.linalg.solve来解决线性方程组的例子：

import numpy as np

# 定义线性方程组的系数矩阵A和常数项b
A = np.array([[1, 2], [3, 4]])
b = np.array([1, 2])

# 使用numpy.linalg.solve求解线性方程组Ax = b
x = np.linalg.solve(A, b)

print(x)  # 输出线性方程组的解

# [0.  0.5]

在上述代码中，numpy.linalg.solve函数会给出线性方程组Ax = b的解向量x，而不直接计算矩阵的逆。

 

5、特征值

np.linalg.eigvals(arr)

用于计算一个方阵的特征值。
对于一个给定的方阵，其特征值是与特征向量相对应的标量，它们在许多数学和物理问题中扮演着重要角色，比如在稳定性分析、振动问题、量子力学等领域。

• arr：输入的方阵，必须是一个二维数组。
• 函数返回一个数组，包含了输入方阵的所有特征值。

import numpy as np

# 定义一个2x2的方阵
A = np.array([[2, -1], [1, 0]])

# 计算方阵A的特征值
eigvals = np.linalg.eigvals(A)

print(eigvals)  # 输出方阵A的特征值

# [1.+6.68896751e-09j 1.-6.68896751e-09j]

在这个例子中，方阵A的特征值是满足方程det(A - λI) = 0的λ值，其中I是单位矩阵。对于上述矩阵，特征值计算如下：
$det(A-\lambda I)=det\left(\begin{array}{ccc}2-\lambda & & -1\\ 1& & 0-\lambda \end{array}\right)=(2-\lambda )(-\lambda )-(-1)(1)={\lambda }^2-2\lambda +1$
这是一个关于λ的二次方程，其解为特征值。

注意，特征值的计算涉及到求解多项式方程，因此对于高维矩阵，特征值的计算可能会非常复杂。此外，由于数值稳定性的原因，对于病态矩阵或不精确的数据，特征值的计算可能会有误差
 

6、奇异值分解:

numpy.linalg.svd(arr,full_matrices=True, compute_uv=True, hermitian=False)

用于计算一个矩阵的奇异值分解（Singular Value Decomposition，简称SVD）。
奇异值分解是一种将任意矩阵分解为一系列特定矩阵乘积的方法，它在信号处理、统计学、计算机视觉等领域有着广泛的应用。

• arr：输入的矩阵，可以是二维数组。
• full_matrices：布尔值，如果为True，则返回全尺寸的U和V矩阵。如果为False，则返回经济尺寸的矩阵。
• compute_uv：布尔值，如果为True，则同时计算U和V矩阵。如果为False，则只计算奇异值。
• hermitian：布尔值，如果为True，则计算适用于共轭转置对称（Hermitian）矩阵的SVD。

返回值：

• 如果compute_uv=True，则函数返回三个数组(u, s, vh)：
  u：一个矩阵，包含了左侧奇异向量。
  s：一个数组，包含了奇异值，按照从大到小的顺序排列。
  vh：一个矩阵，包含了右侧奇异向量（实际上是v的共轭转置）。
• 如果compute_uv=False，则只返回s数组。

import numpy as np

# 定义一个矩阵
A = np.array([[1, 2, 3],
              [4, 5, 6]])

# 计算矩阵A的奇异值分解
u, s, vh = np.linalg.svd(A, full_matrices=False, compute_uv=True)

print("U matrix:", u)

# U matrix:
# [[-0.3863177   0.92236578]
#  [-0.92236578 -0.3863177 ]]

print("Sigma matrix (singular values):", s)

# Sigma matrix (singular values):
# [9.508032   0.77286964]

print("V^H matrix (right singular vectors):", vh)

# V^H matrix (right singular vectors):
# [[-0.42866713 -0.56630692 -0.7039467 ]
#  [-0.80596391 -0.11238241  0.58119908]]

奇异值分解的结果可以表示为：
$A=U\sum V^H$

其中：

• U是一个m x m或m x r的矩阵（取决于full_matrices的设置），其列向量是A的左奇异向量。
• Σ是一个r x r的对角矩阵，对角线上的元素是非负的奇异值，且按从大到小的顺序排列。r是矩阵A的秩。
• V^H是一个n x n或n x r的矩阵（取决于full_matrices的设置），其行向量是A的右奇异向量。

奇异值分解的一个重要性质是，它可以提供矩阵的低秩近似，这在数据压缩和降维中非常有用。此外，矩阵的奇异值可以提供关于矩阵性质的重要信息，比如矩阵的范数和条件数。
 

（七）舍入和类型转换

1、 四舍五入

np.around(arr,decimals=0)

函数用于将数组中的元素舍入到最接近的整数，或者指定的小数位数。

• arr：输入的数组，可以是任何NumPy支持的数据类型。
• decimals：舍入到的小数位数，默认为0，即舍入到最接近的整数。
• 返回一个数组，其中包含arr中每个元素按照指定的小数位数舍入后的值。

import numpy as np

# 定义一个数组
arr = np.array([3.14, 2.71, 1.62, 2.99])

# 将数组中的每个元素四舍五入到最接近的整数
rounded_arr = np.around(arr)

print(rounded_arr)  # 输出: [3. 2. 2. 3.]

# 将数组中的每个元素四舍五入到最接近的十分位
rounded_arr_dec = np.around(arr, decimals=1)

print(rounded_arr_dec)  # 输出: [3.1 2.7 1.6 3.0]

numpy.around函数的舍入策略是向距离相等的两个整数中，舍入到较小的那个整数。这与标准的四舍五入策略（即向更接近的整数舍入）不同。
如果你需要标准的四舍五入行为，可以使用numpy.round函数，它的舍入策略是看小数部分的第一位，如果大于等于0.5则向上舍入，否则向下舍入。
 

2、类型转换

arr.astype(newtype)

用于将arr数组中的数据转换为指定数据类型的表达式。

• 输入的NumPy数组，包含了需要转换数据类型的数据。
• newtype：一个数据类型对象，表示转换后的数据类型。
• 返回一个新的NumPy数组，其中的数据类型已经被转换为newtype指定的类型。

import numpy as np

# 定义一个数组，初始数据类型为float64
arr = np.array([1, 2, 3, 4], dtype=np.float64)

# 将数组的数据类型转换为int32
arr_int32 = arr.astype(np.int32)

print(arr_int32)  # 输出: [1 2 3 4]
print(arr_int32.dtype)  # 输出数据类型: int32

   astype方法非常有用，尤其是在需要确保数组数据类型满足特定算法或数据处理步骤要求时。例如，某些机器学习算法可能需要输入数据为整数类型或浮点数类型，使用astype可以方便地进行转换。

   此外，astype方法在内存使用和性能优化中也很重要，因为不同的数据类型占用的内存空间不同，计算效率也有差异。通过选择合适的数据类型，可以减少内存使用，提高计算速度。
 

3、浮点数转整数

numpy.floor(arr), numpy.ceil(arr)

numpy.floor和numpy.ceil函数分别用于对数组中的每个元素进行向下舍入（floor）和向上舍入（ceil）操作。

numpy.floor(arr)

numpy.floor函数将数组中的每个元素舍入到小于或等于该元素的最小整数。

• arr：输入的数组，可以是任何NumPy支持的数据类型。
• 返回一个数组，其中包含arr中每个元素向下舍入到最接近的整数的结果。

numpy.ceil(arr)

numpy.ceil函数将数组中的每个元素舍入到大于或等于该元素的最小整数。

• arr：输入的数组，可以是任何NumPy支持的数据类型。
• 返回一个数组，其中包含arr中每个元素向上舍入到最接近的整数的结果。

import numpy as np

# 定义一个数组
arr = np.array([3.14, 2.71, 1.62, 2.99])

# 使用numpy.floor向下舍入
floored_arr = np.floor(arr)

print("Floored array:", floored_arr)  # 输出: [3. 2. 1. 2.]

# 使用numpy.ceil向上舍入
ceiled_arr = np.ceil(arr)

print("Ceiled array:", ceiled_arr)  # 输出: [4. 3. 2. 3.]

在上述示例中，numpy.floor将每个元素舍入到小于或等于它们自身的最小整数，而numpy.ceil则将每个元素舍入到大于或等于它们自身的最小整数。
 

（八）布尔数组的操作

1、 布尔数组的任何值

numpy.any(arr, axis=None, out=None, keepdims=False)

用于检查输入数组中是否有任何元素是非零的（对于布尔类型数组，检查是否有任何元素是True）

• arr：输入的数组。
• axis：指定沿着哪个轴检查元素。如果为None，默认操作是在数组的整个范围内进行。
• out：如果提供了输出数组，结果将被存储在这个数组中。
• keepdims：布尔值，如果为True，则在结果数组中保留减少的维度。

返回值：

• 返回一个布尔值，如果arr中至少有一个元素是非零的（或对于布尔数组，至少有一个元素是True），则返回True；否则返回False。

import numpy as np

# 定义一个数组
arr = np.array([[True, False], [False, True]])

# 使用numpy.any检查数组中是否有任何True值
any_true = np.any(arr)

print(any_true)  # 输出: True

# 定义一个没有True值的数组
arr_no_true = np.array([[False, False], [False, False]])

# 使用numpy.any检查数组中是否有任何True值
any_true_no = np.any(arr_no_true)

print(any_true_no)  # 输出: False

numpy.any函数可以用于多种情况，包括：

• 检查一个布尔数组是否包含任何True值。

• 检查一个非布尔数组是否包含任何非零元素。

• 用于条件语句，以决定是否基于数组中的某些元素的值执行特定的操作。

   

2、布尔数组的所有值

numpy.all(arr, axis=None, out=None, keepdims=False)

用于检查输入数组中的所有元素是否都满足某个条件。对于布尔类型数组，它会检查所有元素是否都为True。对于非布尔数组，通常检查所有元素是否都非零。

• arr：输入的数组。
• axis：指定沿着哪个轴检查元素。如果为None，默认操作是在数组的整个范围内进行。
• out：如果提供了输出数组，结果将被存储在这个数组中。
• keepdims：布尔值，如果为True，则在结果数组中保留减少的维度。

返回值：

• 返回一个布尔值，如果arr中的所有元素都满足条件（对于布尔数组，所有元素都是True；对于非布尔数组，所有元素都非零），则返回True；否则返回False。

import numpy as np

# 定义一个布尔数组
bool_arr = np.array([True, True, True])

# 使用numpy.all检查数组中的所有元素是否都是True
all_true = np.all(bool_arr)

print(all_true)  # 输出: True

# 定义一个包含False的布尔数组
bool_arr_with_false = np.array([True, False, True])

# 使用numpy.all检查数组中的所有元素是否都是True
not_all_true = np.all(bool_arr_with_false)

print(not_all_true)  # 输出: False

# 定义一个数值数组
num_arr = np.array([1, 2, 3])

# 使用numpy.all检查数组中的所有元素是否都非零
all_nonzero = np.all(num_arr)

print(all_nonzero)  # 输出: True

# 定义一个包含零的数值数组
num_arr_with_zero = np.array([1, 0, 3])

# 使用numpy.all检查数组中的所有元素是否都非零
not_all_nonzero = np.all(num_arr_with_zero)

print(not_all_nonzero)  # 输出: False

numpy.all函数可以用于多种情况，包括：

• 检查一个布尔数组是否所有元素都是True。
• 检查一个数值数组是否所有元素都非零。
• 用于条件语句，以决定是否基于数组中的所有元素的值执行特定的操作。
   

（九）随机数生成

1、 随机样本

import numpy as np

rng = np.random.default_rng()  # 创建一个随机数生成器实例
sample = rng.random()
print(sample)
# 0.07625147013457467

samples = rng.random(size=5)
print(samples)
# [0.88773144 0.12345188 0.64482947 0.10995531 0.88079215]

 

2、随机整数

np.random.randint(low, high, size=None)

用于生成一个或多个随机整数，这些整数从 low（包含）到 high（不包含）之间均匀分布。如果 high 没有指定，则默认为 low 的值加一。

• low (int): 随机数的下限（包含）。
• high (int, 可选): 随机数的上限（不包含）。如果没有指定，则默认为 low + 1。
• size (int 或 tuple of ints, 可选): 输出数组的尺寸。如果未指定，则默认为一个单一的整数。

1.生成一个随机整数：

import numpy as np

random_int = np.random.randint(1, 10)
print(random_int)
# 5 

2、生成指定数量的随机整数：

import numpy as np

# 随机生成5个1-10的整数
random_integers = np.random.randint(1, 10, size=5)
print(random_integers)

# [7 1 6 8 6]

3、生成指定形状的随机整数数组：

import numpy as np

# 生成随机整数,每一行数据在[1,10),3行4列
random_integers = np.random.randint(1, 10, size=(3, 4))
print(random_integers)

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

4、生成从0开始的随机整数（不指定 high）：

import numpy as np

# 没有指定 high，所以随机整数的范围是从0到10（不包含10）。
random_integers = np.random.randint(10, size=5)
print(random_integers)

# [2 7 1 7 2]

 

3、正态分布随机数:

np.random.randn(d0, d1, …, dn）

用于生成标准正态分布（均值为0，标准差为1）的随机样本。
1、生成一个标准正态分布的随机样本：

import numpy as np

sample = np.random.randn()
print(sample)
# 0.8171323496331089

2、生成多个标准正态分布的随机样本，指定 size 参数：

import numpy as np

samples = np.random.randn(5)
print(samples)
# [-0.15842107 -0.35061045  0.20003743 -1.08743635  0.22300377]

     size=5 意味着生成一个包含5个随机样本的数组，每个样本都是从标准正态分布中抽取的。

3、生成具有特定均值和标准差的正态分布样本：

import numpy as np

mean = 0  # 均值
std_dev = 2  # 标准差
samples = mean + std_dev * np.random.randn(5)
print(samples)

# [ 2.73899853 -1.33176561 -1.97492163 -0.69672498  0.07173888]

这里，我们首先定义了均值 mean 和标准差 std_dev，然后通过 mean + std_dev * np.random.randn(size) 来生成具有特定均值和标准差的正态分布样本。这里，我们首先定义了均值 mean 和标准差 std_dev，然后通过 mean + std_dev * np.random.randn(size) 来生成具有特定均值和标准差的正态分布样本。

注意：
① numpy.random.randn 函数生成的是浮点数，如果需要生成整数，可以使用 np.random.randint 或其他相关函数。
② 此外，np.random.randn 函数生成的是连续的正态分布样本，而不是离散的整数
 

4、均匀分布随机数:

np.random.uniform(low, high, size=None)

用于生成在指定范围内均匀分布的随机样本。这个函数的参数 low 和 high 指定了随机数的最小值和最大值，而 size 参数则用来指定输出数组的形状。

• low (float 或 array-like): 随机数的下限（包含）。
• high (float 或 array-like): 随机数的上限（不包含）。如果 high 小于 low，它们的位置会被交换。
• size (int 或 tuple of ints, 可选): 输出数组的尺寸。如果未指定，则默认为一个单一的随机数。

1、生成一个在 [0, 1) 范围内均匀分布的随机数：

import numpy as np

random_number = np.random.uniform(low=0.0, high=1.0)
print(random_number)

# 0.7499954845659931

2、生成多个随机数，指定 size 参数：

import numpy as np

random_numbers = np.random.uniform(low=0.0, high=1.0, size=5)
print(random_numbers)

# [0.57950386 0.2547959  0.89262127 0.64685615 0.89779286]

3、生成具有特定形状的随机数数组：

import numpy as np

random_numbers = np.random.uniform(low=0.0, high=1.0, size=(3, 4))
print(random_numbers)

这里 size=(3, 4) 表示生成一个3行4列的数组，数组中的每个元素都是从 [0, 1) 范围内均匀分布的随机数。

4、生成在不同范围内的随机数：

import numpy as np

random_numbers = np.random.uniform(low=-5.0, high=5.0, size=(2, 2))
print(random_numbers)

# [[0.21063845 0.16785233]
#  [0.07805075 3.98533615]]

在这个例子中，随机数的范围是 [-5, 5)。

np.random.uniform 函数在需要生成特定范围内均匀分布的随机数时非常有用，例如在模拟实验、随机抽样、游戏开发等场景中。

5、生成一个随机排列

np.random.permutation(x)

• x：int or array_like x 可以是一个整数或者是一个数组。
  如果 x 是整数，返回随机排列的 np.arange(x)
  如果 x 是数组，只对数组的第一个维度随机排列，返回新的数组

 print(np.random.permutation(6))  # [5 1 2 0 4 3]
        
 arr1 = np.array([0, 1, 2, 3, 4, 5])
 print(np.random.permutation(arr1))  # [4 0 3 1 5 2]
        
 arr2 = np.arange(10).reshape(5, 2)
 print(np.random.permutation(arr2))  
        
 # [[2 3]
 #  [6 7]
 #  [4 5]
 #  [0 1]
 #  [8 9]]

 

6、随机数种子

np.random.seed(x)

    当你设置了一个种子值后，NumPy 的随机数生成器将会产生一个可预测的、确定的随机数序列。这意味着，每次你使用相同的种子值初始化随机数生成器时，你都会得到相同的随机数序列。
    这在需要结果可复现性的情况下非常有用，比如在科学研究、机器学习和调试过程中。

种子（seed）是一个初始值，它用于启动随机数生成器的算法。如果不设置种子，NumPy 的随机数生成器会默认使用一个系统提供的随机或伪随机种子，这通常会导致每次运行程序时生成不同的随机数序列。

np.random.seed(3)
print(np.random.uniform(1, 2, size=4))  # [1.5507979  1.70814782 1.29090474 1.51082761]
        
np.random.seed(5)
print(np.random.uniform(1, 2, size=4)) # [1.22199317 1.87073231 1.20671916 1.91861091]
        
np.random.seed(3)
print(np.random.uniform(1, 2, size=4)) # [1.5507979  1.70814782 1.29090474 1.51082761]

 

7、返回从正态分布中抽取的随机样本

np.random.normal(loc=0.0, scale=1.0, size=None)

• loc：均值（中心）
• scale：标准差
• size：输出的形状

import numpy as np

print(np.random.normal(3, 2.5, size=(2, 4)))

# [[-0.99076962  2.01174106  0.23579857  4.14366161]
#  [ 1.87438832  8.13918791  1.62049807  9.3790898 ]]