线性代数（四）向量空间¶
章节概述¶
向量空间是线性代数的核心概念之一，是研究线性变换和线性方程组的理论基础。本章将介绍向量空间的概念、基和维数、线性变换以及应用。
学习目标¶
- 理解向量空间的定义和性质
- 掌握向量的线性相关性和线性无关性
- 学会求向量空间的基和维数
- 理解线性变换的概念和表示
- 了解向量空间的应用
（一）向量空间的定义¶
向量空间的定义¶
设 V 是一个非空集合，F 是一个数域（通常是实数域 ℝ 或复数域 ℂ）。如果 V 中的元素（称为向量）满足以下条件，则称 V 为 F 上的向量空间：
加法运算：对于任意 u, v ∈ V，有 u + v ∈ V 数乘运算：对于任意 k ∈ F 和 v ∈ V，有 k·v ∈ V
并且满足以下公理：
- 加法交换律：u + v = v + u
- 加法结合律：(u + v) + w = u + (v + w)
- 零向量存在：存在 0 ∈ V，使得 v + 0 = v
- 负向量存在：对于每个 v ∈ V，存在 -v ∈ V，使得 v + (-v) = 0
- 数乘单位律：1·v = v
- 数乘结合律：(kl)·v = k·(l·v)
- 数乘分配律：k·(u + v) = k·u + k·v
- 加法分配律：(k + l)·v = k·v + l·v
常见向量空间¶
1. ℝⁿ 空间：所有 n 维实数向量组成的集合
2. 矩阵空间：所有 m×n 矩阵组成的集合
3. 多项式空间：所有次数不超过 n 的多项式组成的集合
4. 零空间：所有零向量组成的集合 {0}
Python 实现¶
class Vector:
"""向量类"""
def __init__(self, components):
"""
初始化向量
参数:
components: 向量的分量列表
示例:
>>> v = Vector([1, 2, 3])
"""
self.components = components
self.dimension = len(components)
def __add__(self, other):
"""向量加法"""
if self.dimension != other.dimension:
raise ValueError("向量维数不匹配")
return Vector([a + b for a, b in zip(self.components, other.components)])
def __sub__(self, other):
"""向量减法"""
if self.dimension != other.dimension:
raise ValueError("向量维数不匹配")
return Vector([a - b for a, b in zip(self.components, other.components)])
def __mul__(self, scalar):
"""数乘"""
return Vector([scalar * a for a in self.components])
def __rmul__(self, scalar):
"""右数乘"""
return self.__mul__(scalar)
def __repr__(self):
"""字符串表示"""
return f"Vector({self.components})"
def dot(self, other):
"""
点积
参数:
other: 另一个向量
返回:
float: 点积
"""
if self.dimension != other.dimension:
raise ValueError("向量维数不匹配")
return sum(a * b for a, b in zip(self.components, other.components))
def norm(self):
"""
向量的范数（长度）
返回:
float: 向量的范数
"""
return self.dot(self) ** 0.5
def normalize(self):
"""
单位化向量
返回:
Vector: 单位向量
"""
norm = self.norm()
if norm == 0:
raise ValueError("零向量不能单位化")
return self * (1 / norm)
def is_zero(self, tolerance=1e-10):
"""
判断是否为零向量
参数:
tolerance: 容差
返回:
bool: 如果是零向量返回 True
"""
return all(abs(c) < tolerance for c in self.components)
实例分析¶
实例1：创建向量
实例2：向量运算
v1 = Vector([1, 2, 3])
v2 = Vector([4, 5, 6])
# 向量加法
v3 = v1 + v2
print(f"v1 + v2 = {v3}")
# 数乘
v4 = 2 * v1
print(f"2 * v1 = {v4}")
# 点积
dot_product = v1.dot(v2)
print(f"v1 · v2 = {dot_product}")
# 范数
norm_v1 = v1.norm()
print(f"||v1|| = {norm_v1}")
# 单位化
v1_unit = v1.normalize()
print(f"v1 的单位向量 = {v1_unit}")
（二）线性相关性和线性无关性¶
线性组合¶
给定向量组 v₁, v₂, ..., vₙ 和数 k₁, k₂, ..., kₙ，向量
称为 v₁, v₂, ..., vₙ 的线性组合。线性相关性¶
向量组 v₁, v₂, ..., vₙ 称为线性相关，如果存在不全为零的数 k₁, k₂, ..., kₙ，使得
线性无关性¶
向量组 v₁, v₂, ..., vₙ 称为线性无关，如果只有当 k₁ = k₂ = ... = kₙ = 0 时，才有
Python 实现¶
def is_linearly_independent(vectors, tolerance=1e-10):
"""
判断向量组是否线性无关
参数:
vectors: 向量列表
tolerance: 容差
返回:
bool: 如果线性无关返回 True
示例:
>>> v1 = Vector([1, 0, 0])
>>> v2 = Vector([0, 1, 0])
>>> v3 = Vector([0, 0, 1])
>>> is_linearly_independent([v1, v2, v3])
True
"""
import numpy as np
# 构建矩阵
matrix = np.array([v.components for v in vectors], dtype=float).T
# 计算秩
rank = np.linalg.matrix_rank(matrix, tol=tolerance)
return rank == len(vectors)
def linear_combination(vectors, coefficients):
"""
计算向量的线性组合
参数:
vectors: 向量列表
coefficients: 系数列表
返回:
Vector: 线性组合结果
示例:
>>> v1 = Vector([1, 2])
>>> v2 = Vector([3, 4])
>>> linear_combination([v1, v2], [2, 3])
Vector([11, 16])
"""
if len(vectors) != len(coefficients):
raise ValueError("向量和系数数量不匹配")
result = Vector([0] * vectors[0].dimension)
for v, coeff in zip(vectors, coefficients):
result = result + coeff * v
return result
def find_linear_combination(target, vectors, tolerance=1e-10):
"""
找到表示目标向量的线性组合系数
参数:
target: 目标向量
vectors: 向量列表
tolerance: 容差
返回:
list: 系数列表，如果无法表示则返回 None
"""
import numpy as np
# 构建矩阵
matrix = np.array([v.components for v in vectors], dtype=float).T
target_vec = np.array(target.components, dtype=float)
# 解线性方程组
try:
coefficients = np.linalg.solve(matrix, target_vec)
return coefficients.tolist()
except np.linalg.LinAlgError:
return None
实例分析¶
实例1：判断线性无关性
v1 = Vector([1, 0, 0])
v2 = Vector([0, 1, 0])
v3 = Vector([0, 0, 1])
print(f"v1, v2, v3 是否线性无关: {is_linearly_independent([v1, v2, v3])}") # True
v4 = Vector([1, 1, 0])
v5 = Vector([2, 2, 0])
print(f"v4, v5 是否线性无关: {is_linearly_independent([v4, v5])}") # False
实例2：线性组合
v1 = Vector([1, 2])
v2 = Vector([3, 4])
# 计算 2*v1 + 3*v2
result = linear_combination([v1, v2], [2, 3])
print(f"2*v1 + 3*v2 = {result}") # Vector([11, 16])
实例3：找线性组合
target = Vector([7, 10])
v1 = Vector([1, 2])
v2 = Vector([3, 4])
coefficients = find_linear_combination(target, [v1, v2])
print(f"系数: {coefficients}") # [1.0, 2.0]
print(f"验证: {linear_combination([v1, v2], coefficients)}") # Vector([7, 10])
（三）基和维数¶
基的定义¶
向量空间 V 中的向量组 B = {v₁, v₂, ..., vₙ} 称为 V 的基，如果满足：
- 线性无关：v₁, v₂, ..., vₙ 线性无关
- 生成空间：V 中的每个向量都可以表示为 v₁, v₂, ..., vₙ 的线性组合
维数的定义¶
向量空间 V 的维数记作 dim(V)，是 V 的基中向量的个数。
常见向量空间的基和维数¶
1. ℝⁿ 空间： - 基：e₁ = (1, 0, ..., 0), e₂ = (0, 1, ..., 0), ..., eₙ = (0, 0, ..., 1) - 维数：n
2. 矩阵空间 M(m,n)： - 基：Eᵢⱼ（第 i 行第 j 列为 1，其余为 0） - 维数：m×n
3. 多项式空间 Pₙ： - 基：1, x, x², ..., xⁿ - 维数：n+1
Python 实现¶
def find_basis(vectors, tolerance=1e-10):
"""
找到向量组的基
参数:
vectors: 向量列表
tolerance: 容差
返回:
list: 基向量列表
示例:
>>> v1 = Vector([1, 0, 0])
>>> v2 = Vector([0, 1, 0])
>>> v3 = Vector([1, 1, 0])
>>> find_basis([v1, v2, v3])
[Vector([1, 0, 0]), Vector([0, 1, 0])]
"""
import numpy as np
if not vectors:
return []
# 构建矩阵
matrix = np.array([v.components for v in vectors], dtype=float).T
# 使用高斯消元找线性无关的向量
basis_indices = []
for i in range(len(vectors)):
# 检查当前向量是否可以被基表示
test_matrix = np.array([vectors[j].components for j in basis_indices + [i]], dtype=float).T
rank = np.linalg.matrix_rank(test_matrix, tol=tolerance)
if rank > len(basis_indices):
basis_indices.append(i)
return [vectors[i] for i in basis_indices]
def dimension_of_span(vectors, tolerance=1e-10):
"""
计算向量组生成的子空间的维数
参数:
vectors: 向量列表
tolerance: 容差
返回:
int: 维数
"""
basis = find_basis(vectors, tolerance)
return len(basis)
def coordinates_in_basis(vector, basis, tolerance=1e-10):
"""
计算向量在给定基下的坐标
参数:
vector: 向量
basis: 基向量列表
tolerance: 容差
返回:
list: 坐标列表，如果无法表示则返回 None
"""
coefficients = find_linear_combination(vector, basis, tolerance)
return coefficients
实例分析¶
实例1：找基
v1 = Vector([1, 0, 0])
v2 = Vector([0, 1, 0])
v3 = Vector([1, 1, 0])
v4 = Vector([0, 0, 1])
basis = find_basis([v1, v2, v3, v4])
print(f"基: {basis}") # [Vector([1, 0, 0]), Vector([0, 1, 0]), Vector([0, 0, 1])]
print(f"维数: {len(basis)}") # 3
实例2：计算维数
v1 = Vector([1, 2, 3])
v2 = Vector([2, 4, 6])
v3 = Vector([1, 0, 1])
dim = dimension_of_span([v1, v2, v3])
print(f"生成的子空间的维数: {dim}") # 2
实例3：计算坐标
# 标准基
e1 = Vector([1, 0, 0])
e2 = Vector([0, 1, 0])
e3 = Vector([0, 0, 1])
# 向量
v = Vector([3, 4, 5])
# 计算坐标
coords = coordinates_in_basis(v, [e1, e2, e3])
print(f"在标准基下的坐标: {coords}") # [3.0, 4.0, 5.0]
（四）线性变换¶
线性变换的定义¶
从向量空间 V 到向量空间 W 的映射 T 称为线性变换，如果满足：
- 加法性：T(u + v) = T(u) + T(v)
- 齐次性：T(k·v) = k·T(v)
线性变换的矩阵表示¶
如果 T: ℝⁿ → ℝᵐ 是线性变换，则存在 m×n 矩阵 A，使得
常见线性变换¶
1. 旋转变换：
2. 缩放变换：
3. 投影变换：
Python 实现¶
class LinearTransformation:
"""线性变换类"""
def __init__(self, matrix):
"""
初始化线性变换
参数:
matrix: 变换矩阵
示例:
>>> T = LinearTransformation([[1, 0], [0, 1]])
"""
self.matrix = matrix
def apply(self, vector):
"""
应用线性变换
参数:
vector: 输入向量
返回:
Vector: 变换后的向量
"""
if vector.dimension != len(self.matrix[0]):
raise ValueError("向量维数与变换矩阵不匹配")
result = []
for row in self.matrix:
result.append(sum(row[i] * vector.components[i] for i in range(len(row))))
return Vector(result)
def compose(self, other):
"""
复合线性变换
参数:
other: 另一个线性变换
返回:
LinearTransformation: 复合变换
"""
import numpy as np
A = np.array(self.matrix, dtype=float)
B = np.array(other.matrix, dtype=float)
C = np.dot(A, B)
return LinearTransformation(C.tolist())
def inverse(self, tolerance=1e-10):
"""
求逆变换
参数:
tolerance: 容差
返回:
LinearTransformation: 逆变换
抛出:
ValueError: 如果变换不可逆
"""
import numpy as np
A = np.array(self.matrix, dtype=float)
if abs(np.linalg.det(A)) < tolerance:
raise ValueError("变换不可逆")
A_inv = np.linalg.inv(A)
return LinearTransformation(A_inv.tolist())
def rotation_transformation(theta):
"""
创建 2D 旋转变换
参数:
theta: 旋转角度（弧度）
返回:
LinearTransformation: 旋转变换
示例:
>>> T = rotation_transformation(math.pi/2)
"""
import math
matrix = [[math.cos(theta), -math.sin(theta)],
[math.sin(theta), math.cos(theta)]]
return LinearTransformation(matrix)
def scaling_transformation(scale_x, scale_y):
"""
创建缩放变换
参数:
scale_x: x 方向缩放因子
scale_y: y 方向缩放因子
返回:
LinearTransformation: 缩放变换
"""
matrix = [[scale_x, 0],
[0, scale_y]]
return LinearTransformation(matrix)
def reflection_transformation():
"""
创建关于 x 轴的反射变换
返回:
LinearTransformation: 反射变换
"""
matrix = [[1, 0],
[0, -1]]
return LinearTransformation(matrix)
实例分析¶
实例1：旋转变换
import math
# 创建旋转变换（旋转 90 度）
T = rotation_transformation(math.pi / 2)
# 应用变换
v = Vector([1, 0])
v_rotated = T.apply(v)
print(f"原向量: {v}")
print(f"旋转后: {v_rotated}") # Vector([0, 1])
实例2：缩放变换
# 创建缩放变换
S = scaling_transformation(2, 3)
# 应用变换
v = Vector([1, 1])
v_scaled = S.apply(v)
print(f"原向量: {v}")
print(f"缩放后: {v_scaled}") # Vector([2, 3])
实例3：复合变换
# 旋转和缩放的复合
T = rotation_transformation(math.pi / 4)
S = scaling_transformation(2, 2)
# 先旋转再缩放
v = Vector([1, 0])
v1 = S.apply(T.apply(v))
print(f"先旋转再缩放: {v1}")
# 先缩放再旋转
v2 = T.apply(S.apply(v))
print(f"先缩放再旋转: {v2}")
# 复合变换
TS = T.compose(S)
v3 = TS.apply(v)
print(f"复合变换: {v3}")
（五）向量空间的应用¶
1. 计算机图形学¶
线性变换在计算机图形学中用于旋转、缩放、平移等操作。
def transform_polygon(vertices, transformation):
"""
对多边形应用线性变换
参数:
vertices: 顶点列表 [Vector, ...]
transformation: 线性变换
返回:
list: 变换后的顶点列表
"""
return [transformation.apply(v) for v in vertices]
# 示例：旋转三角形
triangle = [Vector([1, 0]), Vector([0, 1]), Vector([-1, 0])]
T = rotation_transformation(math.pi / 3)
rotated_triangle = transform_polygon(triangle, T)
print("旋转后的三角形:")
for vertex in rotated_triangle:
print(vertex)
2. 信号处理¶
信号可以表示为函数空间中的向量，线性变换用于滤波、卷积等操作。
3. 量子力学¶
量子态可以表示为希尔伯特空间中的向量，算子表示线性变换。
实战练习¶
练习1：判断线性无关性¶
判断下列向量组是否线性无关：
v1 = Vector([1, 2, 3])
v2 = Vector([4, 5, 6])
v3 = Vector([7, 8, 9])
print(f"是否线性无关: {is_linearly_independent([v1, v2, v3])}") # False
练习2：找基¶
找到下列向量组的基：
v1 = Vector([1, 0, 0])
v2 = Vector([0, 1, 0])
v3 = Vector([1, 1, 0])
v4 = Vector([0, 0, 1])
basis = find_basis([v1, v2, v3, v4])
print(f"基: {basis}")
print(f"维数: {len(basis)}")
练习3：线性变换¶
创建一个先旋转 45 度再缩放 2 倍的复合变换，并应用到向量 (1, 0)。
import math
T = rotation_transformation(math.pi / 4)
S = scaling_transformation(2, 2)
TS = T.compose(S)
v = Vector([1, 0])
result = TS.apply(v)
print(f"变换结果: {result}")
章节小结¶
本章介绍了向量空间：
- 向量空间的定义：理解向量空间的公理和常见例子
- 线性相关性：掌握线性相关性和线性无关性的概念
- 基和维数：学会求向量空间的基和维数
- 线性变换：理解线性变换的概念和矩阵表示
- 向量空间的应用：了解在图形学、信号处理等领域的应用
向量空间是线性代数的核心概念，是理解高级数学和工程应用的基础。
下一步¶
继续学习第五章：特征值与特征向量，学习特征值、特征向量、对角化等内容。
重点提醒： - 向量空间必须满足 8 条公理 - 线性无关性是基的核心概念 - 维数是向量空间的固有性质 - 线性变换可以用矩阵表示 - 复合变换对应矩阵乘法