在Python矩阵相除操作中,首要问题在于理解NumPy中矩阵(numpy.matrix)与数组(numpy.ndarray)的本质差异。尽管二者在数值层面高度重叠,但其运算行为存在根本性不同。
np.matrix):专为线性代数设计的二维结构,*运算符默认执行矩阵乘法,/运算符执行逐元素除法(等价于np.divide)。np.ndarray):通用N维数组,*为逐元组乘,/为逐元组除,@为矩阵乘法(PEP 465引入)。⚠️ 自NumPy 1.15起,np.matrix被标记为deprecated(不推荐使用),官方明确建议转向ndarray。因此,现代python矩阵相除实践应以ndarray为核心范式。
最常用形式,对应数学中的Hadamard除法。要求两数组形状兼容(broadcastable)。
import numpy as np
A = np.array([[6, 8], [12, 16]])
B = np.array([[2, 4], [3, 4]])
C = A / B # 等价于 np.divide(A, B)
# 输出: [[3. 2.]
# [4. 4.]]
求解线性方程组 AX = B,即 X = A⁻¹B。使用np.linalg.solve(A, B)实现(非显式求逆)。
A = np.array([[3, 1], [1, 2]])
B = np.array([9, 8])
X = np.linalg.solve(A, B)
# 输出: [2. 3.] ← 即 X = [2, 3]
对应方程 XA = B,解为 X = BA⁻¹。可通过转置转换为左除问题:
X = np.linalg.solve(A.T, B.T).T
(2,3) ÷ (1,3))A 为方阵且非奇异(行列式≠0)/ 运算符(逐元素除法)最直观方式,但需警惕整数除法陷阱:
A = np.array([[10, 15], [20, 25]], dtype=int)
B = np.array([[3, 5], [4, 5]], dtype=int)
C = A / B # NumPy 1.x 返回 float64,但旧版可能截断!
✅ 推荐做法:显式转为浮点型
A = A.astype(float)
# 或
C = A / B.astype(float)
np.divide() 函数功能更强大,支持where参数与out参数,适用于复杂条件运算:
A = np.array([10, 20, 30])
B = np.array([2, 0, 5])
C = np.divide(A, B, where=B!=0, out=np.zeros_like(A, dtype=float))
# 输出: [5. 0. 6.] ← 除零位置返回0(由out指定)
np.linalg.pinv() + 矩阵乘法(伪逆解)当矩阵不满秩或非方阵时,使用Moore-Penrose伪逆:
A = np.array([[1, 2], [3, 4], [5, 6]]) # 3×2 非方阵
B = np.array([1, 2, 3])
X = np.linalg.pinv(A) @ B
# 输出最小二乘解: [-0.0556, 0.2222]
此解使 ||AX - B||² 最小化,是欠定/超定方程组的标准解法。
scipy.linalg.solve()(高精度解)SciPy提供更鲁棒的求解器(LU分解优化),适合大型方程组:
from scipy.linalg import solve
A = np.array([[4, 1], [1, 3]])
B = np.array([1, 2])
X = solve(A, B, assume_a='pos') # 假设正定矩阵加速
当两数组形状不同时,NumPy按以下步骤广播:
| 操作 | 形状 | 广播后 |
|---|---|---|
A / b | (3,4) / (4,) | (3,4) |
A / B | (3,4) / (1,4) | (3,4) |
A / b | (2,3,4) / (3,1) | (2,3,4) |
A = np.ones((2,3))
B = np.ones((3,2))
C = A / B # ValueError: operands could not be broadcast together
将矩阵每列减均值、除标准差:
X = np.array([[1,2,3],[4,5,6],[7,8,9]])
mean = X.mean(axis=0) # (3,)
std = X.std(axis=0) # (3,)
X_norm = (X - mean) / std # 广播成功!
广播是零拷贝操作!NumPy仅在逻辑层面扩展形状,不实际复制数据。因此:
A = np.ones((10000, 100))
b = np.ones(100)
C = A / b # 极高效,无额外内存分配
根本原因:形状不兼容广播规则
A.shape与B.shapenp.broadcast_shapes(A.shape, B.shape)预验证当除数数组含零时触发(浮点零除外):
A = np.array([1, 2, 3])
B = np.array([0, 1, 2])
A / B # RuntimeWarning: divide by zero
✅ 解决方案:
np.divide(A, B, where=B!=0)跳过零元ε=1e-10避免除零np.seterr(divide='ignore')抑制警告(需配合np.nan_to_num)解线性方程组时,若系数矩阵奇异(det=0):
A = np.array([[1, 2], [2, 4]]) # 行成比例,奇异
np.linalg.solve(A, np.array([3, 6])) # LinAlgError: Singular matrix
✅ 替代方案:使用伪逆
X = np.linalg.pinv(A) @ np.array([3, 6])
整数数组除法在旧版NumPy中可能截断:
A = np.array([7, 15], dtype=np.int8)
B = np.array([3, 5], dtype=np.int8)
A / B # 可能输出 [2, 3](而非[2.33, 3.0])
✅ 铁律:矩阵运算前显式转为浮点型
A = A.astype(np.float64)
A = np.array([[10, 20], [30, 40]])
B = np.array([[2, 4], [5, 8]])
print(A / B) # [[5. 5.] [6. 5.]]
A = np.array([[1, 2], [3, 4]])
print(1 / A) # [[1. 0.5] [0.333 0.25]]
v = np.array([3, 4])
v_norm = v / np.linalg.norm(v) # 单位向量
2x + y = 5, x - y = 1A = np.array([[2, 1], [1, -1]])
B = np.array([5, 1])
X = np.linalg.solve(A, B) # [2. 1.]
X = np.array([[1,1],[1,2],[1,3]]) # 加上截距项
y = np.array([1,2,3])
theta = np.linalg.pinv(X.T @ X) @ X.T @ y
AX + XAᵀ = -Qfrom scipy.linalg import solve_lyapunov
A = np.array([[1, 2], [0, 1]])
Q = np.eye(2)
X = solve_lyapunov(A, -Q)
img = np.array([[50,100],[150,200]], dtype=np.uint8)
min_val, max_val = 50, 200
img_stretched = (img - min_val) * 255 / (max_val - min_val)
fg = np.array([[[255,0,0,128]]]) # 半透明红色
bg = np.array([[[0,0,255,255]]]) # 蓝色背景
alpha = fg[...,:1] / 255.0
result = fg[...,:3] * alpha + bg[...,:3] * (1 - alpha)
z = np.array([[0, 1], [2, 3]])
sigmoid = 1 / (1 + np.exp(-z))
grad = sigmoid * (1 - sigmoid) # 梯度计算
W = np.array([[1,2],[3,4]])
grad_reg = W / (np.linalg.norm(W, ord='fro') + ε)
def normalized_cross_corr(x, y):
x_norm = (x - np.mean(x)) / np.std(x)
y_norm = (y - np.mean(y)) / np.std(y)
return np.correlate(x_norm, y_norm, 'full')
kernel = np.array([1, 2, 1])
kernel_norm = kernel / kernel.sum() # 求和为1
A = np.random.rand(100, 3, 3) # 100个3×3矩阵
A_inv = np.linalg.inv(A) # NumPy 1.8+ 支持批量操作
from scipy.linalg import solve_banded
# 上、主、下对角线
ab = np.array([[0, -1, -1, -1], [4, 4, 4, 4], [-1, -1, -1, 0]])
b = np.array([1, 0, 0, 1])
x = solve_banded((1,1), ab, b)
A = np.array([[1+2j, 3+4j]])
B = np.array([[1j, 2]])
C = A / B # 自动处理复数除法
❌ 低效写法:
for i in range(n):
for j in range(n):
C[i,j] = A[i,j] / B[i,j]
✅ 高效写法:
C = A / B # 100×以上加速比
使用np.ascontiguousarray()确保数据连续,提升缓存命中率:
A = np.ascontiguousarray(A)
B = np.ascontiguousarray(B)
C = A / B
out参数避免临时分配C = np.empty_like(A, dtype=float)
np.divide(A, B, out=C)
def block_divide(A, B, block_size=1000):
m, n = A.shape
C = np.empty_like(A, dtype=float)
for i in range(0, m, block_size):
for j in range(0, n, block_size):
C[i:i+block_size, j:j+block_size] = \
A[i:i+block_size, j:j+block_size] / \
B[i:i+block_size, j:j+block_size]
return C
import cupy as cp
A_gpu = cp.array(A)
B_gpu = cp.array(B)
C_gpu = A_gpu / B_gpu # 自动在GPU执行