1 前期导入-线性代数
1.1 标量
概念：只有大小没有方向的量叫做标量。
1.2 向量
概念：既有大小也有方向的量，向量的起点称为原点，终点称为向量的端点，向量的长度（或模）是起点和终点之间的距离
1.3 向量的表示
在几何中：向量可以用有向线段来表示，有向线段的长度表示向量的大小，有向线段的方向表示向量的方向。
在空间坐标系中：在二维或三维空间中，向量可以用坐标来表示。
二维向量v=(v1,v2) 三维向量v=(v1,v2,v3)
在数学中：向量通常表示为有序数组，可以是列向量或行向量。v = (v1,v2,v3,v4,v5)
1.4 向量的运算
1.4.1 向量的大小
向量的大小也就是向量的长度(或称模)。向量a的模记作|a|
向量的模是非负实数。例如：向量 
，则
1.4.2 向量的加减法
当两个向量进行加减操作时，两个向量必须是同维向量。运算规则为对应位置的元素相加减。
例如：A=（1,2,3,4,5） B=（6,7,8,9,8） → A+B=（7,9,11,13,13）
1.4.3 向量的乘法
向量的数乘:
数乘就是使用一个标量乘以向量，其核心本质就是对向量的大小和方向进行改变。
向量的点积:
两个向量相乘的结果是一个标量，这就叫向量的内积或点积，使用 · 作为运算符
如：a=(2, 3) ，b=(3, 4)，则a·b=2*3+3*4=18
1.5 矩阵
矩阵（Matrix） 是一个由数字排列成的矩形阵列，是一个二维数组，通常用大写字母表示，如 A。矩阵的元素可以是标量，矩阵的行数和列数分别称为矩阵的维度，一个 m×n 的矩阵有 m 行和 n 列，可以表示为:
1.5.1 特殊矩阵
行矩阵：只有一行的矩阵称为行矩阵或行向量。
列矩阵：只有一列的矩阵称为列矩阵或列向量。
零矩阵：元素都为0的矩阵称为零矩阵。
方阵：矩阵的行数与列数相等，即m=n的矩阵，称为n阶方阵。
单位矩阵：主对角线元素为1，其余元素为0的方阵。
同型矩阵：两个矩阵A和B的行数与列数对应相等的矩阵称为同型矩阵。
1.6 矩阵的运算
1.6.1 矩阵的加减法
运算的两个矩阵必须同维（例如，都是m×n 矩阵），其计算结果就是将两个矩阵的对应元素进行相加减得到一个新的同型矩阵。
1.6.2 矩阵的乘法：矩阵和标量相乘
矩阵和标量相乘又称为矩阵的数乘。数乘是指一个矩阵的所有元素都乘以一个常数k，相当于将这个矩阵内的所有元素缩放了k倍大小。
1.6.3 矩阵的乘法：矩阵和向量相乘
矩阵和向量也可以进行相乘运算，前提条件是矩阵的列数=向量的行数时才可乘，结果是向量。
1.6.4 矩阵的乘法：矩阵和矩阵相乘
其进行相乘的前提条件是第一个矩阵的列数必须等于第二个矩阵的行数，结果是一个新的矩阵，其行数等于第一个矩阵的行数，列数等于第二个矩阵的列数。
1.7 张量
张量（Tensor）是标量、向量和矩阵的高维推广，是现代数学、物理学（如广义相对论）和计算机科学（如深度学习）中的核心概念。
阶（Rank）：表示张量的维度数量
-
0阶张量：标量（Scalar），如
3.14 -
1阶张量：向量（Vector），如
[1, 2, 3] -
2阶张量：矩阵（Matrix），如
[[1,2],[3,4]] -
3阶张量：立方体结构，如RGB图像（高度×宽度×颜色通道）
-
n阶张量：更高维数组
2 numpy库的功能
NumPy(Numerical Python)是一个开源的Python科学计算库，它提供了多维数组对象（ndarray）以及大量的数学函数库
-
支持多维数组操作：NumPy提供了强大的n维数组对象ndarray，可进行高效的数据处理
-
丰富的函数：NumPy内置了大量数学、统计和线性代数函数。
-
高性能：NumPy底层采用C语言编写，相比于python来说运算速度快，性能优越
-
具有广播功能：可以允许不同形状的数组进行算术运算
练习：实现两个列表的元素相加运算
a = [1, 2, 3, 4] b = [3, 4, 5, 6]
a = [1, 2, 3, 4]
b = [3, 4, 5, 6]
c = [] # 创建一个空列表 'c'，用于存储计算结果
for i in range(len(a)): # 启动循环。
# 'len(a)'获取列表'a'的长度（值为4），
# 'range(4)'生成索引序列 [0, 1, 2, 3]，循环将执行4次
c.append(a[i] + b[i])
print(c)
3 ndarray数组
NumPy数组在内存中连续存储，并且每个元素的大小、类型相同。其在访问和修改元素时具有极高的效率。
NumPy数组可以是多维的，具有明确的形状（shape）。
NumPy提供了丰富的数学、统计、线性代数等函数库，可以进行相应的运算。
NumPy数组的内部实现是基于C语言的
NumPy的广播机制允许不同形状的数组在进行运算时自动扩展它们的形状，从而能够进行元素级的运算
3.1 数组创建
创建命令式：
import numpy as np
# object 类型：array_like （列表、元组、其他数组等），这是必选参数。
np.array([1, 2, 3]) # 一维数组 [1 2 3]
np.array([[1, 2], [3, 4]]) # 二维数组
# [[1 2]
# [3 4]]
# dtyp 类型：data-type（如 np.int32, np.float64）作用：指定数组元素的数据类型，
# 若为 None，NumPy 自动推断合适类型
np.array([1, 2, 3], dtype=np.float32) # 输出：array([1., 2., 3.], dtype=float32)
np.array([1.5, 2.7], dtype=np.int32) # 输出：array([1, 2]) → 截断小数部分
# copy 类型：bool 作用：是否复制输入数据
# True（默认）：始终创建新副本 # True相当于深拷贝，不复制空间
# False：尽可能避免复制 # False相当于浅拷贝，复制空间
tp = (1.2, 2, 3.5, 6)
arr = np.array(tp)
print(arr)
# [1.2 2. 3.5 6. ]
brr = np.array(arr, copy=False) # False相当于浅拷贝，复制空间
brr[1] = 5.5
print(arr)
# [1.2 5.5 3.5 6. ]
print(brr)
# [1.2 5.5 3.5 6. ]
crr = np.array(arr, copy=True) # True相当于深拷贝，不复制空间
crr[1] = 9.9
print(arr)
# [1.2 5.5 3.5 6. ]
print(crr)
# [1.2 9.9 3.5 6. ]
# order 类型：{'K', 'A', 'C', 'F'}
作用：控制数组的内存布局
'C'：行优先（C 风格，默认行为）
'F'：列优先（Fortran 风格）
'A'：保留输入数据的原始顺序
'K'：尽可能保持输入数据的存储顺序
arr = np.array([[1, 2], [3, 4]], order='F')
print(arr)
# subok:默认返回一个与基类类型一致的数组
# ndmin 类型：int 作用：指定输出数组的最小维度 若输入维度不足，通过添加新轴（长度为 1）扩展
np.array([1, 2, 3], ndmin=2) # 输出：[[1, 2, 3]]
np.array([1, 2, 3], ndmin=3) # 输出：[[[1, 2, 3]]]
3.2 数值的访问
一维数组的访问：
数组可以通过索引和切片进行访问：
索引从 0 开始，可以使用负数索引从数组末尾开始访问元素。
import numpy as np
# 访问
arr = np.array([1, 2, 3, 4, 5, 6])
print(arr)
print(arr[0])
print(arr[-1])
print(arr[1:3:2])
#[1 2 3 4 5 6]
#1
#6
#[2]
切片访问与Python列表的切片方式类似，使用冒号:进行切片，格式为start:stop:step，其中start、stop值为数组的索引，遵循左闭右开原则，三个值可根据情况省略
import numpy as np
# 切片访问
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
"""
行\列 | 0列 | 1列 | 2列
—————|—————|—————|————
0行 | 1 | 2 | 3
1行 | 4 | 5 | 6
2行 | 7 | 8 | 9
"""
print(arr) # 全部打印
print(arr[0]) # 获取第0行（第一行）的所有元素
# 输出：[1, 2, 3]
print(arr[1][2])
print(arr[1, 2])
# 先取下标为1的一行（第二行）：[4, 5, 6]再从这行取下标为2的元素
# 输出6
# 输出6
print(arr[0:2]) # 取行切片：从第0行到第1行（不含第2行）
# 输出：[[1 2 3]
# [4 5 6]]
print(arr[0:2, 1:2]) # 行：取0-1行（前两行）列：取下标为1的列（第二列）
# 输出：[[2]
# [5]]
print(arr[:, 1:2]) # 行：: 表示所有行 列：取1的列（第二列）
# 输出：[[2]
# [5]
# [8]]
print(arr[:, [0, 2]]) # 行：: 表示所有行 列：取下标为0列和下标为2列（第一列和第三列）
# 输出：[[1 3]
# [4 6]
# [7 9]]
print(arr[[1, 2]]) # 直接指定要的行：第1行和第2行（第二行和第三行）
# 输出：[[4 5 6]
# [7 8 9]]
# 特殊的
print(arr[[1, 2], [0, 2]])
# 取特定坐标点：
# 第1行第0列（坐标(1,0) → 4）
# 第2行第2列（坐标(2,2) → 9）
# 相当于取左下角(4)和右下角(9)两个点
# 输出：[4 9]
3.3 创建特殊数组
3.3.1 empty
创建一个指定形状（shape）、数据类型（dtype）且初值为随机值的数组。
numpy.empty(shape, dtype = float, order = 'C')
参数：
shape：数组的形状，用[]或()表示
dtype：数组元素的类型
order：数据在计算机内存中的存储元素的顺序，C或F
import numpy as np
arr = np.empty([2, 3], dtype=int)
print(arr)
#[[506110512 32767 506115024]
# [ 32767 211264592 32767]]
# 填充值
arr.fill(4)
print(arr)
#[[4 4 4]
# [4 4 4]]
3.3.2 zeros
numpy.zeros(shape, dtype = float, order = 'C')
功能：创建指定大小的数组
numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None)
参数：a：可以是列表、元组、numpy数组
功能：创建一个和给定的数组具有相同形状的数组
# 创建 0 数组
import numpy as np
arr = np.zeros([3, 3])
print(arr)
arr = np.zeros_like([[1, 2, 3], [4, 5, 6]])
print(arr)
3.3.3 ones
numpy.ones(shape, dtype = None, order = 'C')
功能：创建指定形状的数组
numpy.ones_like(a, dtype=None, order='K', subok=True, shape=None)
功能：创建一个和给定的数组具有相同形状的数组
# 创建 1 数组
import numpy as np
arr = np.ones([3, 3])
print(arr)
3.3.4 full
numpy.full(shape, fill_value, dtype=None, order='C')
功能：创建一个指定形状，并设置指定值的数组
参数：shape：形状
fill_value：填充的值
# full 创建指定形状的数组，且赋初值
import numpy as np
arr = np.full([2, 4], 5)# 全部为5
print(arr)
print(type(arr)) # 打印的是整体举行的类型
3.4 numpy的数据类型
3.4.1 基本数据类型
整数类型：
'b': 有符号字符（相当于 int8）
'u': 无符号字符（相当于 uint8）
'i1', 'i2', 'i4', 'i8': 分别表示有符号的8位、16位、32位、64位整数
'u1', 'u2', 'u4', 'u8': 分别表示无符号的8位、16位、32位、64位整数
浮点类型：
'f2', 'f4', 'f8': 分别表示16位、32位、64位浮点数（相当于 float16, float32, float64）
字节类型：
'S<n>': 固定长度的字节字符串，<n> 表示长度。例如，'S10' 表示长度为10的字节字符串。
unicode类型：
'U<n>': 固定长度的Unicode字符串，<n> 表示长度（以字符为单位）。例如，'U10' 表示长度为10的Unicode字符串（Unicode编码标准来表示的字符串）。
补充：S10和U10区别：
S：是采用ASCII编码的字符串，ASCII 是一种基于英文字符的编码标准
U：是采用Unicode编码的字符串，Unicode 是一种国际标准的字符编码
两者编码方式不一样
3.4.2 结构化数据类型
结构化数组的每个元素都是一个记录，而每个记录则包含多个命名的字段。字段名可以是任何有效的字符串，而字段的数据类型则可以是NumPy支持的任何数据类型，包括基本数据类型和其他结构化类型。
[('键名1'， '类型1')， （'键名2'， '类型2'）...]
import numpy as np
type = [('x', 'i4'), ('y', 'f4')]
"""
这定义了一个类似表格的结构
表格有两列：
列名 'x'：存储整数（i4 表示32位整数）
列名 'y'：存储浮点数（f4 表示32位浮点数）
类似定义了一个包含两个字段的记录
"""
a = [(1, 3.4), (2, 3.2), (3, 4.5)]
"""
这是三行数据
每行是一个元组：(x值, y值)
相当于：
第1行：x=1, y=3.4
第2行：x=2, y=3.2
第3行：x=3, y=4.5
"""
# 创建结构化数组
arr = np.array(a, dtype=type)
"""
将Python列表转换为NumPy结构化数组
使用之前定义的type作为数据结构
结果是一个包含3行记录的数组，每行有x和y两个字段
"""
print(arr)
print(arr[0]) # 获取第一行数据（索引0）,返回一个包含该行所有字段值的元组
print(arr['x'][1])
"""
分两步 操作：
arr['x']：获取所有行的'x'字段值 → 返回 [1, 2, 3]
[1]：从这些值中取第二个（索引1） → 返回 2
"""
# 练习：定义一个结构化数据类型，每个元素包含3个字段，分别是name、age、height
import numpy as np
ty = [('name', 'U10'), ('age', 'i1'), ('height', 'f4')]
a = [("张三", 32, 175.1), ("lisi", 45, 180.1), ("wangwu", 16, 165.1)]
arr = np.array(a, dtype=ty) # dtype=ty ty自定义类型
print(arr)
print(arr[0])
print(arr['name'][1])
3.5 ndarray属性
|
ndarray.ndim |
秩(zhi)，即轴的数量或维度的数量 |
|
ndarray.shape |
数组的维度，对于矩阵，n 行 m 列 |
|
ndarray.size |
数组元素的总个数，相当于 .shape 中 n*m 的值 |
|
ndarray.dtype |
ndarray 对象的元素类型 |
import numpy as np
a = np.array([[1, 2, 3], [3, 4, 5], [7, 8, 9]])
print(a.ndim) # 数组的维度
print(a.shape) # 数组的形状
print(a.size) # 数组的大小
print(a.dtype) # 数组的元素类型
print(type(a)) # 数组的类型
修改属性
3.5.1 astype
功能：修改数组的类型，它返回一个新的数组，原数组数据不会改变
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr.dtype)
b = arr.astype(np.float32)
print(b)
print(b.dtype)
3.5.2 reshape
# 修改数组的形状 reshape
# 前提是修改的新数组元素个数与原始数组元素个数要一致，否则会抛出异常
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
brr = arr.reshape([6, 1])
print(brr)
crr = arr.reshape([-1, 2]) # 当值为-1时，会根据元素总个数除以固定的值，自动计算出来
print(crr)
# 输出：[[1 2]
# [3 4]
# [5 6]]
3.5.3 resize
resize 方法用于改变数组的大小，它会直接修改调用它的原始数组。如果新形状大于原始形状，则会在数组的末尾添加新的元素，这些元素的值未定义；如果新形状小于原始形状，则会截断数组。
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
# arr.resize([2, 4])
# print(arr)
# # 输出：[[1 2 3 4]
# # [5 6 0 0]]
# 如果新形状大于原始形状，则会在数组的末尾添加新的元素，这些元素的值未定义；
arr.resize([2, 2])
print(arr)
# 输出：[[1 2]
# [3 4]]
# 如果新形状小于原始形状，则会截断数组。
"""resize的复制"""
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
brr = np.resize(arr, [4, 3])
print(brr)
# [[1 2 3]
# [4 5 6]
# [1 2 3]
# [4 5 6]]
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.resize(arr, [4, 4])
print(b)
# [[1 2 3 4]
# [5 6 1 2]
# [3 4 5 6]
# [1 2 3 4]]
# resize函数可直接修改，如进行生成新数组，当生成的新数组形状大于原始数组：
1.行数相同时：会从第一行复制原始数据补全新数组
2.行数不同时，把原始数组循环从第一个元素开始重新添加
3.5.4 flatten
flatten方法返回一个一维数组，它是原始数组的拷贝，修改新数组不会影响原数组，它默认按行顺序展平数组，但可以通过参数 `order` 来指定展平顺序。
# flatten 将数组平铺
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
brr = arr.flatten(order='F') # F按列
# order：指定的顺序，‘C’ 表示按行，‘F’ 表示按列，‘A’ 或 ‘K’ 表示与原数组相同的顺序
print(brr)
# 输出：[1 4 2 5 3 6]
3.5.5 T
Ndarray 对象的 T 属性是一个特殊的属性，它返回转置后的数组（transpose）。
转置是一个操作，它将数组的维度进行交换。对于二维数组，这意味着行变为列，列变为行。对于更高维度的数组，转置操作涉及到交换数组的轴。
# T 数组的转置
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
brr = arr.T
print(brr)
# 输出：[[1 4]
# [2 5]
# [3 6]]
4 创建数组的其他函数
4.1 arange
numpy 使用 arange 函数创建数值范围并返回 ndarray 对象
numpy.arange(start, stop, step, dtype)
参数：
start：起始值，默认为0
stop：终止值（不包含）
step：步长，默认为1
dtype：返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。
import numpy as np
arr = np.arange(1, 10, 2)
print(arr)
arr = np.arange(10)
print(arr)
4.2 linspace
用于创建一个一维数组，数组是一个等差数列构成的
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
参数：
start：序列的起始值
stop：序列的终止值
num：要生成的等步长的样本数量，默认为`50`
endpoint：该值为 True时，数列中包含`stop`值，反之不包含，默认是True。
retstep：如果为 True 时，生成的数组中会显示间距，反之不显示。
dtype：`ndarray` 的数据类型
# linspace 用于创建一个一维数组，数组是一个等差数列构成的
import numpy as np
# endpoint：设置是否包含终止值 retstep：显示差值
# endpoint：该值为 True时，数列中包含`stop`值，反之不包含，默认是True。
arr = np.linspace(10, 20, 5, endpoint=False, retstep=True, dtype=int)
print(arr)
# (array([10, 12, 14, 16, 18]), 2.0)
4.3 random
Ndarray数组还可以创建具有随机元素的数组。随机元素的值可以根据是否设置随机数种子每次产生相同或不同的随机值。
随机数种子：是一个用于初始化随机数生成器的值，随机数种子的值可以是任意的，如果不显式设置种子，通常会使用当前时间作为种子，这样每次程序运行时都会产生不同的随机数序列。如果设置相同的随机数种子，每次程序运行时生成的随机数序列都是相同的。
np.random.seed(num)
功能：设置随机数种子，种子值可以是任何整数，通常是正整数
4.3.1 rand
numpy.random.rand(d0, d1, ..., dn)
功能：返回一个或一组[0.0, 1.0) 区间均匀分布的随机浮点类型样本
参数：d0, d1, ..., dn：这些参数定义了输出数组的形状
# random
import numpy as np
a = np.random.rand(3, 4)
print(a)
# random加随机种子
# 当设置随机数种子为固定值时，每次运行的随机值都想同，
# 当不设置种子值时会以当前时间作为种子值，每次运行随机值都不同
import numpy as np
np.random.seed(10)
b = np.random.rand(3, 4)
print(b)
4.3.2 random
numpy.random.random(size)
功能：返回一个或一组[0.0, 1.0) 区间均匀分布的随机浮点类型样本
参数：size：通过列表或元组的方式指定形状
import numpy as np
# 参数：size：通过列表或元组的方式指定形状
arr = np.random.random([2, 3])
print(arr)
4.3.3 randint
umpy.random.randint(low, high=None, size=None, dtype=int)
功能：用于生成随机整数，这些数在指定的范围内均匀分布(每个数的概率相同)
参数：low：生成随机数的起始点（包含）
high（可选）：生成随机数的结束点（不包含）
size：定义输出数组形状的整数或元组，省略时会生成一个随机数
dtype：指定返回数组的数据类型
# 根据指定的起始位置和终止位置生成整数
import numpy as np
brr = np.random.randint(1, 20, [2, 3])
print(brr)
4.3.4 randn
numpy.random.randn(d0, d1, ..., dn)
功能：用于生成服从标准正态分布（均值为0，标准差为1）的随机数
参数：生成的数组的形状
# 生成符合标准正态分布的数组
import numpy as np
arr = np.random.randn(2, 3)
print(arr)
4.3.5 normal
numpy.random.normal(loc=0.0, scale=1.0, size=None)
功能：用于生成正态分布（高斯分布）随机数的函数
参数： loc：浮点数，表示正态分布的均值（μ），默认值为 0.0。
scale：浮点数，表示正态分布的标准差（σ西格玛），默认值为 1.0。
注意，这里的 scale 实际上是标准差，而不是方差。
size：整数或整数元组，指定输出数组的形状。如果省略或为 None,则返回一个单一的浮点数。
import numpy as np
arr = np.random.normal(3, 4, [2, 3])
print(arr)
4.3.6 uniform
numpy.random.uniform(low=0.0, high=1.0, size=None)
功能：用于在指定范围内随机抽取浮点数
参数：low：浮点数或类似浮点数的数组，样本抽取区间的下限，默认值为 0。
high：浮点数或类似浮点数的数组，表示样本抽取区间的上限，默认值为 1。
size：整数或元组，可选参数，表示输出的形状。如果未提供，则返回单个浮点数。如果提供了一个整数，则返回一个一维数组；如果提供了一个元组，则返回一个多维数组。
import numpy as np
arr = np.random.uniform(1.3, 9.6, [3, 2])
print(arr)
4.3.7 shuffle
numpy.random.shuffle(x)
功能：用来随机打乱数组元素的顺序的
参数：x：要打乱的数组
# shuffle
# 打乱数组顺序，二维数组只打乱行
import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6]) # 一维数组元素会被打乱
np.random.shuffle(arr)
print(arr)
#---[4 2 6 5 3 1]
brr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) # 二维数组打乱行
np.random.shuffle(brr)
print(brr)
#---[[4 5 6]
#--- [1 2 3]
#--- [7 8 9]]
练习：猜数字游戏。1-100之间，输入整数猜测是否是预定的数值，打印提示且当猜对时输出猜测次数。
import numpy as np
arr = np.random.randint(1, 101)
q = 1
while q < 10:
print(f"第{q}次猜字")
a = int(input("请输入在1-100之间的一个整数"))
if 0 <= a <= 100:
if a > arr:
print("猜大了")
elif a < arr:
print("猜小了")
else:
print("恭喜您，猜对了")
break
q += 1
else:
print("输入错误")
print(f"生成的整数位{arr}")
扫一扫
1493
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
