numpy简要学习

本章小结

本章主要针对科学计算库 NumPy 进行了介绍，包括以下内容：

一、ndarray 数组对象

• ndarray 是 NumPy 的核心数据结构，用于存储同类型数据的多维数组
• 常用属性：shape（形状）、ndim（维度）、size（元素总数）、dtype（数据类型）、T（转置）

二、数组的创建

• np.array()：从列表或元组创建数组
• np.zeros()：创建全零数组
• np.ones()：创建全一数组
• np.arange()：创建等差数组
• np.linspace()：创建等间距数组
• np.random.rand()：创建随机数组

三、数组的运算

• 算术运算：加、减、乘、除都是元素级运算
• 广播机制：不同形状的数组进行运算时，NumPy 会自动扩展较小的数组

四、索引和切片操作

• 基本索引：arr[行, 列] 的形式访问元素
• 切片操作：arr[开始:结束:步长] 的形式获取子数组
• 布尔索引：使用条件表达式筛选元素，如 arr[arr > 5]
• 花式索引：使用整数数组作为索引

五、数组的转置和轴对称

• .T 属性：快速转置
• transpose() 方法：以元组形式传入轴编号进行重排
• swapaxes() 方法：交换两个轴

六、NumPy 通用函数

• 一元通用函数：abs（绝对值）、sqrt（平方根）、square（平方）、exp（指数）、log（对数）、sign（正负号）、ceil（向上取整）、floor（向下取整）、rint（四舍五入）、modf（分离整数小数）、isnan（判断缺失值）、isinf（判断无穷）、三角函数等
• 二元通用函数：add（相加）、subtract（相减）、multiply（相乘）、divide（除法）、maximum（最大值）、minimum（最小值）、mod（取余）、比较运算函数、逻辑运算函数等

七、线性代数模块

• np.linalg.inv()：计算逆矩阵
• np.linalg.det()：计算行列式
• np.linalg.eig()：计算特征值和特征向量
• np.linalg.solve()：求解线性方程组
• 矩阵乘法：使用 @ 运算符或 np.dot()，注意与元素级乘法 * 的区别

八、随机数模块

• np.random.rand()：生成 [0,1) 区间的均匀分布随机数
• np.random.randn()：生成标准正态分布随机数
• np.random.randint()：生成指定区间的随机整数
• np.random.uniform()：生成指定区间的均匀分布随机数
• np.random.normal()：生成正态分布随机数
• np.random.seed()：设置随机种子，保证结果可复现

九、数组数据处理相关操作

• np.where()：条件逻辑转为数组运算，三元表达式的矢量化版本
• 统计运算：sum（求和）、mean（均值）、min（最小值）、max（最大值）、argmin（最小值索引）、argmax（最大值索引）、cumsum（累计和）、cumprod（累计积）、std（标准差）、var（方差）、median（中位数）
• 排序：arr.sort()（原地排序）、np.sort(arr)（返回新数组）
• 集合逻辑：unique（唯一值）、intersect1d（交集）、union1d（并集）、in1d（成员检查）、setdiff1d（差集）、setxor1d（对称差）

 

ndarray 中的数据类型

NumPy 的 ndarray 要求所有元素必须是相同的数据类型（与 Python 列表不同）。

一、整数类型

类型	说明	取值范围
int8	有符号8位整数	-128 ~ 127
int16	有符号16位整数	-32,768 ~ 32,767
int32	有符号32位整数	-2^31 ~ 2^31-1
int64	有符号64位整数	-2^63 ~ 2^63-1
uint8	无符号8位整数	0 ~ 255
uint16	无符号16位整数	0 ~ 65,535
uint32	无符号32位整数	0 ~ 2^32-1
uint64	无符号64位整数	0 ~ 2^64-1

二、浮点数类型

类型	说明	精度
float16	半精度浮点数	5位精度
float32	单精度浮点数	7-8位精度
float64	双精度浮点数（默认）	15-16位精度

三、复数类型

类型	说明
complex64	32位实部 + 32位虚部
complex128	64位实部 + 64位虚部（默认）

四、布尔类型

类型	说明	取值
bool	布尔类型	True / False

五、字符串类型

类型	说明
str 或 U	Unicode 字符串
S	字节字符串（ASCII）

六、日期时间类型

类型	说明
datetime64	日期时间
timedelta64	时间间隔

七、其他类型

类型	说明
object	Python 对象（可存储任意类型，但速度慢）
void	空类型

数据类型优先级

当不同类型混合时，NumPy 会自动进行类型提升：

• int + float → float
• int + bool → int
• float + complex → complex

类型转换

使用 astype() 方法进行类型转换：

arr.astype(np.float32) # 转换为 float32

arr.astype(np.bool_) # 转换为 bool

arr.astype(str) # 转换为字符串

import numpy as np
a=np.array([1,2,3])
print(a)

[1 2 3]

import numpy as np
a=np.array([[1,2],[3,4]])
print(a)

[[1 2]
 [3 4]]

import numpy as np
a=np.array([1,2,3,4,5],ndmin=2)
print(a)

[[1 2 3 4 5]]

import numpy as np
a = np.array([1, 2, 3, 4, 5], dtype=complex)
print(a)

[1.+0.j 2.+0.j 3.+0.j 4.+0.j 5.+0.j]

import numpy as np

x = np.array(5, dtype="float32")
print('x 为 :', x)
print('x 对象的 data 属性: ', x.data)
print('x 对象的 size 属性: ', x.size)
print('x 对象的维数: ', x.ndim)

y = np.array(x, dtype="bool_")
print('转换为 bool 类型的 x 为: ', y)

z = np.array(y, dtype="float16")
print('True 值转换为 float16 类型为: ', z)

x 为 : 5.0
x 对象的 data 属性:  <memory at 0x0000024EAE324D60>
x 对象的 size 属性:  1
x 对象的维数:  0
转换为 bool 类型的 x 为:  True
True 值转换为 float16 类型为:  1.0

arr = np.arange(8)
b=arr[5]
c=arr[3:5]
print(arr,b,c)

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

 

多维数组切片笔记

一、基本概念 多维数组的切片是沿着行或列的方向选取元素，可以：

传入一个切片

传入多个切片

切片与整数索引混合使用

brr=np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
brr.shape
brr[:2,:2]

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

data=np.arange(9)
data.reshape((3,3))

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

 

花式（数组）索引笔记

一、定义 花式索引（Fancy Indexing） 是 NumPy 的术语，指使用整数数组或列表进行索引，然后将数组或列表中的每个元素作为下标进行取值

import numpy as np

# 创建一维数组
arr = np.array([10, 20, 30, 40, 50, 60, 70, 80])

# 使用列表作为索引
result = arr[[0, 2, 4]]
print(result)  # [10 30 50]

# 使用数组作为索引
idx = np.array([1, 3, 5, 7])
result = arr[idx]
print(result)  # [20 40 60 80]

[10 30 50]
[20 40 60 80]

import numpy as np

# 创建二维数组
arr2d = np.array([[1, 2, 3],
                  [4, 5, 6],
                  [7, 8, 9],
                  [10, 11, 12]])

print("原始数组:")
print(arr2d)

原始数组:
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]

# 选择第0行、第2行、第3行
result = arr2d[[0, 2, 3]]
print(result)
# [[ 1  2  3]
#  [ 7  8  9]
#  [10 11 12]]

[[ 1  2  3]
 [ 7  8  9]
 [10 11 12]]

result = arr2d[[0, 2, 3]]
print(result)

[[ 1  2  3]
 [ 7  8  9]
 [10 11 12]]

import numpy as np

# 创建一个 4×4 的二维数组
demo_arr = np.empty((4, 4))

for i in range(4):
    demo_arr[i] = np.arange(i, i + 4)

print("原始数组:")
print(demo_arr)
# 获取索引为 [0, 2] 的行
result = demo_arr[[0, 2]]
result2=demo_arr[1:2]
result1 = demo_arr[:,[1,3]]
print("\n选择索引 0 和 2 的行:")
print(result)
print(result2)

原始数组:
[[0. 1. 2. 3.]
 [1. 2. 3. 4.]
 [2. 3. 4. 5.]
 [3. 4. 5. 6.]]

选择索引 0 和 2 的行:
[[0. 1. 2. 3.]
 [2. 3. 4. 5.]]
[[1. 2. 3. 4.]]

 

花式索引：两个索引数组的用法

根据你的笔记，当使用两个花式索引操作二维数组时：

第1个 → 行索引

第2个 → 列索引

以二维数组索引的方式选取对应位置的元素

import numpy as np

# 创建 4×4 数组
demo_arr = np.array([[0, 1, 2, 3],
                     [4, 5, 6, 7],
                     [8, 9, 10, 11],
                     [12, 13, 14, 15]])

print("原始数组:")
print(demo_arr)

# 获取索引为 (1,1) 和 (3,2) 的元素
result = demo_arr[[1, 3], [1, 2]]
print("\n选取结果:")
print(result)

原始数组:
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]

选取结果:
[ 5 14]

 

数组的转置和轴对称笔记

一、什么是转置？ 转置是指将数组中的每个元素按照一定规则进行位置变换，简单来说就是行变列、列变行。

二、两种实现方式 NumPy 提供了两种实现转置的方法：

方式 语法 说明 T 属性 arr.T 简单快捷，最常用 transpose() 方法 arr.transpose() 功能更强大，可指定轴顺序

import numpy as np
print("=" * 30)
print("转置前后对比")
print("=" * 30)

print("\n原始数组 (3行4列):")
print("┌──-┬─---┬-──┬─---┐")
print("│ 0   │ 1   │ 2   │ 3   │")
print("├──-┼──-┼──-┼-──┤")
print("│ 4   │ 5   │ 6   │ 7   │")
print("├──-┼─-─┼─-─┼-──┤")
print("│ 8   │ 9   │ 10  │ 11  │")
print("└─-─┴──-┴─---┴-──┘")

print("\n↓ 沿主对角线轴对称 (转置) ↓\n")

print("转置后数组 (4行3列):")
print("┌──-┬─-─┬─-─┐")
print("│ 0   │ 4   │ 8   │")
print("├──-┼──-┼──-┤")
print("│ 1   │ 5   │ 9   │")
print("├──-┼──-┼──-┤")
print("│ 2   │ 6   │ 10  │")
print("├─-─┼──-┼─-─┤")
print("│ 3   │ 7   │ 11  │")
print("└──-┴──-┴──-┘")

==============================
转置前后对比
==============================

原始数组 (3行4列):
┌──-┬─---┬-──┬─---┐
│ 0   │ 1   │ 2   │ 3   │
├──-┼──-┼──-┼-──┤
│ 4   │ 5   │ 6   │ 7   │
├──-┼─-─┼─-─┼-──┤
│ 8   │ 9   │ 10  │ 11  │
└─-─┴──-┴─---┴-──┘

↓ 沿主对角线轴对称 (转置) ↓

转置后数组 (4行3列):
┌──-┬─-─┬─-─┐
│ 0   │ 4   │ 8   │
├──-┼──-┼──-┤
│ 1   │ 5   │ 9   │
├──-┼──-┼──-┤
│ 2   │ 6   │ 10  │
├─-─┼──-┼─-─┤
│ 3   │ 7   │ 11  │
└──-┴──-┴──-┘

import numpy as np

# 一维数组
arr_1d = np.array([1, 2, 3, 4])
print("原始:", arr_1d)
print("转置:", arr_1d.shape) 
print("转置:", arr_1d.T)  # 一维数组转置后不变
print("形状:", arr_1d.T.shape)  # (4,)

原始: [1 2 3 4]
转置: (4,)
转置: [1 2 3 4]
形状: (4,)

import numpy as np
# 创建一个 3×4 的二维数组
arr = np.array([[0, 1, 2, 3],
                [4, 5, 6, 7],
                [8, 9, 10, 11]])

print("原始数组:")
print(arr)
print(f"原始数组形状: {arr.shape}")
# 使用 T 属性进行转置（轴对称）
arr_T = arr.T

print("转置后的数组 (arr.T):")
print(arr_T)
print(f"转置后形状: {arr_T.shape}")

原始数组:
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
原始数组形状: (3, 4)
转置后的数组 (arr.T):
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]
转置后形状: (4, 3)

import numpy as np

# 创建 2×3 的二维数组
arr_2d = np.array([[1, 2, 3],
                   [4, 5, 6]])

print("原始数组:")
print(arr_2d)
print("原始形状:", arr_2d.shape)  # (2, 3)

# 方法1：使用 T 属性
result_T = arr_2d.T
print("\n转置后 (T属性):")
print(result_T)
print("转置后形状:", result_T.shape)  # (3, 2)

# 方法2：使用 transpose() 方法
result_transpose = arr_2d.transpose()
print("\n转置后 (transpose方法):")
print(result_transpose)

原始数组:
[[1 2 3]
 [4 5 6]]
原始形状: (2, 3)

转置后 (T属性):
[[1 4]
 [2 5]
 [3 6]]
转置后形状: (3, 2)

转置后 (transpose方法):
[[1 4]
 [2 5]
 [3 6]]

 

arr.transpose((轴0的新位置, 轴1的新位置, 轴2的新位置, ...))

import numpy as np

# 创建 2×3×4 的三维数组
arr_3d = np.arange(24).reshape(2, 3, 4)
print(arr_3d)
print("原始数组形状:", arr_3d.shape)  # (2, 3, 4)
 
# T 属性：反转轴的  顺序
arr_T = arr_3d.T
print(arr_T)
print("T属性转置形状:", arr_T.shape)  # (4, 3, 2)

# transpose() 可以指定轴顺序
arr_transpose = arr_3d.transpose(1, 0, 2)  # 交换前两个轴
print("transpose(1,0,2)形状:", arr_transpose.shape)  # (3, 2, 4)

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

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
原始数组形状: (2, 3, 4)
[[[ 0 12]
  [ 4 16]
  [ 8 20]]

 [[ 1 13]
  [ 5 17]
  [ 9 21]]

 [[ 2 14]
  [ 6 18]
  [10 22]]

 [[ 3 15]
  [ 7 19]
  [11 23]]]
T属性转置形状: (4, 3, 2)
transpose(1,0,2)形状: (3, 2, 4)

import numpy as np

# 1. 创建三维数组
arr = np.array([
    [
        [0, 1, 2, 3],
        [4, 5, 6, 7]
    ],
    [
        [8, 9, 10, 11],
        [12, 13, 14, 15]
    ]
])

print("=" * 50)
print("原始数组")
print("=" * 50)
print(f"数组形状: {arr.shape}")
print(f"维度说明: 第0轴={arr.shape[0]}个块, 第1轴={arr.shape[1]}行, 第2轴={arr.shape[2]}列")
print("数组内容:")
print(arr)
print()

# 3. 使用 transpose() 进行轴交换
arr_transpose = arr.transpose()
print("=" * 50)
print("执行 transpose() 后")
print("数组内容等于.T")
print(f"新数组形状: {arr_transpose.shape}")
print("数组内容:")
print(arr_transpose)


# 3. 使用 transpose(1, 0, 2) 进行轴交换
# 新轴0 = 原轴1, 新轴1 = 原轴0, 新轴2 = 原轴2
arr_transposed = arr.transpose(1, 0, 2)

print("=" * 50)
print("执行 transpose(1, 0, 2) 后")
print("=" * 50)
print(f"新数组形状: {arr_transposed.shape}")
print("数组内容:")
print(arr_transposed)
print()

==================================================
原始数组
==================================================
数组形状: (2, 2, 4)
维度说明: 第0轴=2个块, 第1轴=2行, 第2轴=4列
数组内容:
[[[ 0  1  2  3]
  [ 4  5  6  7]]

 [[ 8  9 10 11]
  [12 13 14 15]]]

==================================================
执行 transpose() 后
数组内容等于.T
新数组形状: (4, 2, 2)
数组内容:
[[[ 0  8]
  [ 4 12]]

 [[ 1  9]
  [ 5 13]]

 [[ 2 10]
  [ 6 14]]

 [[ 3 11]
  [ 7 15]]]
==================================================
执行 transpose(1, 0, 2) 后
==================================================
新数组形状: (2, 2, 4)
数组内容:
[[[ 0  1  2  3]
  [ 8  9 10 11]]

 [[ 4  5  6  7]
  [12 13 14 15]]]

 

1. swapaxes() - 只交换两个轴 当只需要交换两个轴时，使用 swapaxes(a, b) 更简洁。

# 等价于 transpose(1, 0, 2)
arr_swap = arr.swapaxes(1, 0)

print("swapaxes(1,0) 结果形状:", arr_swap.shape)
print(arr_swap)

swapaxes(1,0) 结果形状: (2, 2, 4)
[[[ 0  1  2  3]
  [ 8  9 10 11]]

 [[ 4  5  6  7]
  [12 13 14 15]]]

 

07Numpy通用函数

 

通用函数（ufunc）是一种针对ndarray中的数据执行元素级运算的函数，函数返回的是一个新的数组。

我们将ufunc中接收一个数组参数的函数称为一元通用函数，接受两个数组参数的则称为二元通用函数。

# ==========================================
# 常见的一元通用函数 (一元ufunc)
# ==========================================

import numpy as np

# 创建测试数组
arr = np.array([-4, -1, 0, 1, 4, 9])
arr_float = np.array([-1.7, -0.2, 0.5, 1.3, 2.8])
arr_pos = np.array([1, 2, 4, 9, 100])

print("=" * 50)
print("原始数组:", arr)
print("=" * 50)

# 1. abs, fabs - 绝对值
print("\n1. abs / fabs (绝对值)")
print(f"   np.abs(arr): {np.abs(arr)}")
print(f"   np.fabs(arr): {np.fabs(arr)}")

# 2. sqrt - 平方根
print("\n2. sqrt (平方根)")
print(f"   np.sqrt(arr_pos): {np.sqrt(arr_pos)}")
# 注意：负数的平方根会返回 nan
print(f"   负数平方根: np.sqrt([-4]) = {np.sqrt([-4])}")

# 3. square - 平方
print("\n3. square (平方)")
print(f"   np.square(arr): {np.square(arr)}")

# 4. exp - 指数 e^x
print("\n4. exp (指数 e^x)")
print(f"   np.exp(arr): {np.exp(arr)}")

# 5. log 系列 - 各种对数
print("\n5. log 系列 (对数)")
print(f"   np.log(arr_pos)    (自然对数 ln): {np.log(arr_pos)}")
print(f"   np.log10(arr_pos)  (以10为底): {np.log10(arr_pos)}")
print(f"   np.log2(arr_pos)   (以2为底): {np.log2(arr_pos)}")
print(f"   np.log1p(arr_pos)  (ln(1+x)): {np.log1p(arr_pos)}")

# 6. sign - 正负号
print("\n6. sign (正负号)")
print(f"   np.sign(arr): {np.sign(arr)}")
print("   说明: 1(正数) / 0(零) / -1(负数)")

# 7. ceil - 向上取整
print("\n7. ceil (向上取整)")
print(f"   np.ceil(arr_float): {np.ceil(arr_float)}")
print("   说明: 大于或等于该值的最小整数")

# ==========================================
# 补充：floor (向下取整)
# ==========================================
print("\n8. floor (向下取整) - 补充")
print(f"   np.floor(arr_float): {np.floor(arr_float)}")
print("   说明: 小于或等于该值的最大整数")

# ==========================================
# 快速对照表（打印版）
# ==========================================
print("\n" + "=" * 50)
print("一元通用函数速查表")
print("=" * 50)
print("""
| 函数              | 描述                           |
|-------------------|--------------------------------|
| abs, fabs         | 计算绝对值                     |
| sqrt              | 计算平方根                     |
| square            | 计算平方                       |
| exp               | 计算指数 e^x                   |
| log               | 自然对数 (底数为e)             |
| log10             | 以10为底的对数                 |
| log2              | 以2为底的对数                  |
| log1p             | 计算 log(1+x)                  |
| sign              | 正负号: 1(正), 0(零), -1(负)   |
| ceil              | 向上取整 (大于等于的最小整数)   |
| floor             | 向下取整 (小于等于的最大整数)   |
""")

==================================================
原始数组: [-4 -1  0  1  4  9]
==================================================

1. abs / fabs (绝对值)
   np.abs(arr): [4 1 0 1 4 9]
   np.fabs(arr): [4. 1. 0. 1. 4. 9.]

2. sqrt (平方根)
   np.sqrt(arr_pos): [ 1.          1.41421356  2.          3.         10.        ]
   负数平方根: np.sqrt([-4]) = [nan]

3. square (平方)
   np.square(arr): [16  1  0  1 16 81]

4. exp (指数 e^x)
   np.exp(arr): [1.83156389e-02 3.67879441e-01 1.00000000e+00 2.71828183e+00
 5.45981500e+01 8.10308393e+03]

5. log 系列 (对数)
   np.log(arr_pos)    (自然对数 ln): [0.         0.69314718 1.38629436 2.19722458 4.60517019]
   np.log10(arr_pos)  (以10为底): [0.         0.30103    0.60205999 0.95424251 2.        ]
   np.log2(arr_pos)   (以2为底): [0.         1.         2.         3.169925   6.64385619]
   np.log1p(arr_pos)  (ln(1+x)): [0.69314718 1.09861229 1.60943791 2.30258509 4.61512052]

6. sign (正负号)
   np.sign(arr): [-1 -1  0  1  1  1]
   说明: 1(正数) / 0(零) / -1(负数)

7. ceil (向上取整)
   np.ceil(arr_float): [-1. -0.  1.  2.  3.]
   说明: 大于或等于该值的最小整数

8. floor (向下取整) - 补充
   np.floor(arr_float): [-2. -1.  0.  1.  2.]
   说明: 小于或等于该值的最大整数

==================================================
一元通用函数速查表
==================================================

| 函数              | 描述                           |
|-------------------|--------------------------------|
| abs, fabs         | 计算绝对值                     |
| sqrt              | 计算平方根                     |
| square            | 计算平方                       |
| exp               | 计算指数 e^x                   |
| log               | 自然对数 (底数为e)             |
| log10             | 以10为底的对数                 |
| log2              | 以2为底的对数                  |
| log1p             | 计算 log(1+x)                  |
| sign              | 正负号: 1(正), 0(零), -1(负)   |
| ceil              | 向上取整 (大于等于的最小整数)   |
| floor             | 向下取整 (小于等于的最大整数)   |

C:\Users\HP\AppData\Local\Temp\ipykernel_29208\1173031080.py:25: RuntimeWarning: invalid value encountered in sqrt
  print(f"   负数平方根: np.sqrt([-4]) = {np.sqrt([-4])}")

# ==========================================
# 常见的一元通用函数 (一元ufunc) - 第二组
# ==========================================

import numpy as np

# 创建测试数组
arr = np.array([-1.7, -0.2, 0.5, 1.3, 2.8])
arr_with_nan = np.array([1, 2, np.nan, 4, np.nan, 6])
arr_with_inf = np.array([1, 2, np.inf, 4, -np.inf, 6])
angles = np.array([0, np.pi/6, np.pi/4, np.pi/3, np.pi/2])

print("=" * 50)
print("原始数组:", arr)
print("=" * 50)

# 1. floor - 向下取整
print("\n1. floor (向下取整)")
print(f"   np.floor(arr): {np.floor(arr)}")
print("   说明: 小于或等于该值的最大整数")

# 2. rint - 四舍五入到最接近的整数
print("\n2. rint (四舍五入)")
print(f"   np.rint(arr): {np.rint(arr)}")
print("   说明: 四舍五入到最接近的整数（0.5会取到最近的偶数）")

# 3. modf - 分离小数和整数部分
print("\n3. modf (分离小数和整数)")
fractional, integer = np.modf(arr)
print(f"   小数部分: {fractional}")
print(f"   整数部分: {integer}")
print("   说明: 返回两个数组，分别为小数部分和整数部分")

# 4. isnan - 判断是否为 NaN
print("\n4. isnan (判断是否为NaN)")
print(f"   原始数组: {arr_with_nan}")
print(f"   np.isnan(arr_with_nan): {np.isnan(arr_with_nan)}")
print("   说明: 返回布尔型数组，True表示该位置是NaN")

# 5. isfinite - 判断是否为有穷数
print("\n5. isfinite (判断是否有穷)")
print(f"   原始数组: {arr_with_inf}")
print(f"   np.isfinite(arr_with_inf): {np.isfinite(arr_with_inf)}")
print("   说明: 返回布尔型数组，True表示该位置是有穷数（不是inf或NaN）")

# 6. isinf - 判断是否为无穷
print("\n6. isinf (判断是否为无穷)")
print(f"   原始数组: {arr_with_inf}")
print(f"   np.isinf(arr_with_inf): {np.isinf(arr_with_inf)}")
print("   说明: 返回布尔型数组，True表示该位置是正无穷或负无穷")

# 7. sin, cos, tan - 三角函数
print("\n7. 三角函数")
print(f"   角度(弧度): {angles}")
print(f"   np.sin(angles): {np.sin(angles)}")
print(f"   np.cos(angles): {np.cos(angles)}")
print(f"   np.tan(angles): {np.tan(angles)}")

# 8. sinh, cosh, tanh - 双曲函数
print("\n8. 双曲函数")
x = np.array([-1, 0, 1])
print(f"   x: {x}")
print(f"   np.sinh(x): {np.sinh(x)}")
print(f"   np.cosh(x): {np.cosh(x)}")
print(f"   np.tanh(x): {np.tanh(x)}")

# 9. arcsin, arccos, arctan - 反三角函数
print("\n9. 反三角函数")
values = np.array([-1, -0.5, 0, 0.5, 1])
print(f"   values: {values}")
print(f"   np.arcsin(values): {np.arcsin(values)}")
print(f"   np.arccos(values): {np.arccos(values)}")
print(f"   np.arctan(values): {np.arctan(values)}")

# ==========================================
# 快速对照表（打印版）
# ==========================================
print("\n" + "=" * 50)
print("一元通用函数速查表（第二组）")
print("=" * 50)
print("""
| 函数                    | 描述                                   |
|-------------------------|----------------------------------------|
| floor                   | 向下取整（小于等于该值的最大整数）       |
| rint                    | 四舍五入到最接近的整数                   |
| modf                    | 分离小数和整数部分（返回两个数组）       |
| isnan                   | 判断是否为NaN（返回布尔数组）            |
| isfinite                | 判断是否为有穷数（不是inf/NaN）          |
| isinf                   | 判断是否为无穷（正无穷或负无穷）         |
| sin, cos, tan           | 三角函数（输入为弧度）                   |
| sinh, cosh, tanh        | 双曲三角函数                            |
| arcsin, arccos, arctan  | 反三角函数                              |
""")

# ==========================================
# 综合示例
# ==========================================
print("\n" + "=" * 50)
print("综合示例")
print("=" * 50)

data = np.array([-2.7, -1.5, 0, 1.5, 2.7, np.nan, np.inf])
print(f"原始数据: {data}")
print(f"floor:    {np.floor(data)}")
print(f"rint:     {np.rint(data)}")
print(f"isnan:    {np.isnan(data)}")
print(f"isfinite: {np.isfinite(data)}")
print(f"isinf:    {np.isinf(data)}")

# modf 单独演示
clean_data = np.array([-2.7, -1.5, 0, 1.5, 2.7])
frac, int_part = np.modf(clean_data)
print(f"\nmodf 演示 (clean_data: {clean_data})")
print(f"  小数部分: {frac}")
print(f"  整数部分: {int_part}")

==================================================
原始数组: [-1.7 -0.2  0.5  1.3  2.8]
==================================================

1. floor (向下取整)
   np.floor(arr): [-2. -1.  0.  1.  2.]
   说明: 小于或等于该值的最大整数

2. rint (四舍五入)
   np.rint(arr): [-2. -0.  0.  1.  3.]
   说明: 四舍五入到最接近的整数（0.5会取到最近的偶数）

3. modf (分离小数和整数)
   小数部分: [-0.7 -0.2  0.5  0.3  0.8]
   整数部分: [-1. -0.  0.  1.  2.]
   说明: 返回两个数组，分别为小数部分和整数部分

4. isnan (判断是否为NaN)
   原始数组: [ 1.  2. nan  4. nan  6.]
   np.isnan(arr_with_nan): [False False  True False  True False]
   说明: 返回布尔型数组，True表示该位置是NaN

5. isfinite (判断是否有穷)
   原始数组: [  1.   2.  inf   4. -inf   6.]
   np.isfinite(arr_with_inf): [ True  True False  True False  True]
   说明: 返回布尔型数组，True表示该位置是有穷数（不是inf或NaN）

6. isinf (判断是否为无穷)
   原始数组: [  1.   2.  inf   4. -inf   6.]
   np.isinf(arr_with_inf): [False False  True False  True False]
   说明: 返回布尔型数组，True表示该位置是正无穷或负无穷

7. 三角函数
   角度(弧度): [0.         0.52359878 0.78539816 1.04719755 1.57079633]
   np.sin(angles): [0.         0.5        0.70710678 0.8660254  1.        ]
   np.cos(angles): [1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
 6.12323400e-17]
   np.tan(angles): [0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
 1.63312394e+16]

8. 双曲函数
   x: [-1  0  1]
   np.sinh(x): [-1.17520119  0.          1.17520119]
   np.cosh(x): [1.54308063 1.         1.54308063]
   np.tanh(x): [-0.76159416  0.          0.76159416]

9. 反三角函数
   values: [-1.  -0.5  0.   0.5  1. ]
   np.arcsin(values): [-1.57079633 -0.52359878  0.          0.52359878  1.57079633]
   np.arccos(values): [3.14159265 2.0943951  1.57079633 1.04719755 0.        ]
   np.arctan(values): [-0.78539816 -0.46364761  0.          0.46364761  0.78539816]

==================================================
一元通用函数速查表（第二组）
==================================================

| 函数                    | 描述                                   |
|-------------------------|----------------------------------------|
| floor                   | 向下取整（小于等于该值的最大整数）       |
| rint                    | 四舍五入到最接近的整数                   |
| modf                    | 分离小数和整数部分（返回两个数组）       |
| isnan                   | 判断是否为NaN（返回布尔数组）            |
| isfinite                | 判断是否为有穷数（不是inf/NaN）          |
| isinf                   | 判断是否为无穷（正无穷或负无穷）         |
| sin, cos, tan           | 三角函数（输入为弧度）                   |
| sinh, cosh, tanh        | 双曲三角函数                            |
| arcsin, arccos, arctan  | 反三角函数                              |


==================================================
综合示例
==================================================
原始数据: [-2.7 -1.5  0.   1.5  2.7  nan  inf]
floor:    [-3. -2.  0.  1.  2. nan inf]
rint:     [-3. -2.  0.  2.  3. nan inf]
isnan:    [False False False False False  True False]
isfinite: [ True  True  True  True  True False False]
isinf:    [False False False False False False  True]

modf 演示 (clean_data: [-2.7 -1.5  0.   1.5  2.7])
  小数部分: [-0.7 -0.5  0.   0.5  0.7]
  整数部分: [-2. -1.  0.  1.  2.]

# ==========================================
# 常见的二元通用函数 (二元ufunc)
# ==========================================

import numpy as np

# 创建测试数组
a = np.array([1, 2, 3, 4, 5])
b = np.array([2, 3, 4, 5, 6])
c = np.array([-2, -1, 0, 1, 2])

print("=" * 50)
print("原始数组")
print("=" * 50)
print(f"a = {a}")
print(f"b = {b}")
print(f"c = {c}")

# 1. add - 相加
print("\n1. add (相加)")
print(f"   np.add(a, b): {np.add(a, b)}")
print(f"   等价于 a + b: {a + b}")

# 2. subtract - 相减
print("\n2. subtract (相减)")
print(f"   np.subtract(a, b): {np.subtract(a, b)}")
print(f"   等价于 a - b: {a - b}")

# 3. multiply - 相乘
print("\n3. multiply (相乘)")
print(f"   np.multiply(a, b): {np.multiply(a, b)}")
print(f"   等价于 a * b: {a * b}")

# 4. divide / floor_divide - 除法 / 向下取整除法
print("\n4. divide / floor_divide (除法)")
print(f"   np.divide(a, b): {np.divide(a, b)}")
print(f"   np.floor_divide(a, b): {np.floor_divide(a, b)} (向下取整除法)")
print(f"   等价于 a // b: {a // b}")

# 5. maximum / fmax - 最大值
print("\n5. maximum / fmax (最大值)")
print(f"   np.maximum(a, b): {np.maximum(a, b)}")
print(f"   np.maximum(a, c): {np.maximum(a, c)}")
print("   说明: fmax 会忽略NaN，maximum 不会")

# 6. minimum / fmin - 最小值
print("\n6. minimum / fmin (最小值)")
print(f"   np.minimum(a, b): {np.minimum(a, b)}")
print(f"   np.minimum(a, c): {np.minimum(a, c)}")

# 7. mod - 求模（取余数）
print("\n7. mod (求模/取余数)")
print(f"   np.mod(b, a): {np.mod(b, a)}")
print(f"   等价于 b % a: {b % a}")

# 8. copysign - 复制符号
print("\n8. copysign (复制符号)")
print(f"   np.copysign(a, c): {np.copysign(a, c)}")
print("   说明: 将第二个数组的符号赋给第一个数组的值")

# 9. 比较运算函数
print("\n9. 比较运算函数 (返回布尔数组)")
print(f"   a = {a}, b = {b}")
print(f"   np.greater(a, b)     (a > b):  {np.greater(a, b)}")
print(f"   np.greater_equal(a, b) (a >= b): {np.greater_equal(a, b)}")
print(f"   np.less(a, b)        (a < b):  {np.less(a, b)}")
print(f"   np.less_equal(a, b)  (a <= b): {np.less_equal(a, b)}")
print(f"   np.equal(a, b)       (a == b): {np.equal(a,b)}")
print(f"   np.not_equal(a, b)   (a != b): {np.not_equal(a,b)}")

# 10. 逻辑运算函数
print("\n10. 逻辑运算函数")
x = np.array([True, True, False, False])
y = np.array([True, False, True, False])
print(f"   x = {x}")
print(f"   y = {y}")
print(f"   np.logical_and(x, y): {np.logical_and(x,y)}  (与运算)")
print(f"   np.logical_or(x, y):  {np.logical_or(x,y)}   (或运算)")
print(f"   np.logical_xor(x, y): {np.logical_xor(x,y)}  (异或运算)")

# ==========================================
# 快速对照表（打印版）
# ==========================================
print("\n" + "=" * 50)
print("二元通用函数速查表")
print("=" * 50)
print("""
| 函数                              | 描述                           |
|-----------------------------------|--------------------------------|
| add                               | 将数组中对应的元素相加           |
| subtract                          | 从第一个数组中减去第二个数组     |
| multiply                          | 数组元素相乘                     |
| divide                            | 除法                             |
| floor_divide                      | 向下整除法（舍去余数）           |
| maximum, fmax                     | 元素级的最大值计算               |
| minimum, fmin                     | 元素级的最小值计算               |
| mod                               | 元素级的求模计算（取余数）       |
| copysign                          | 将第二个数组的符号赋给第一个数组 |
| greater, greater_equal            | 执行 >, >= 比较运算              |
| less, less_equal                  | 执行 <, <= 比较运算              |
| equal, not_equal                  | 执行 ==, != 比较运算             |
| logical_and, logical_or, logical_xor | 逻辑与、或、异或运算          |
""")

# ==========================================
# 综合示例
# ==========================================
print("\n" + "=" * 50)
print("综合示例")
print("=" * 50)

arr1 = np.array([10, 20, 30, 40, 50])
arr2 = np.array([3, 5, 7, 9, 11])

print(f"arr1 = {arr1}")
print(f"arr2 = {arr2}")
print()
print(f"相加:   {np.add(arr1,arr2)}")
print(f"相减:   {np.subtract(arr1,arr2)}")
print(f"相乘:   {np.multiply(arr1,arr2)}")
print(f"除法:   {np.divide(arr1,arr2)}")
print(f"整除:   {np.floor_divide(arr1,arr2)}")
print(f"最大值: {np.maximum(arr1,arr2)}")
print(f"最小值: {np.minimum(arr1,arr2)}")
print(f"取余数: {np.mod(arr1,arr2)}")
print(f"arr1 > arr2: {np.greater(arr1,arr2)}")

==================================================
原始数组
==================================================
a = [1 2 3 4 5]
b = [2 3 4 5 6]
c = [-2 -1  0  1  2]

1. add (相加)
   np.add(a, b): [ 3  5  7  9 11]
   等价于 a + b: [ 3  5  7  9 11]

2. subtract (相减)
   np.subtract(a, b): [-1 -1 -1 -1 -1]
   等价于 a - b: [-1 -1 -1 -1 -1]

3. multiply (相乘)
   np.multiply(a, b): [ 2  6 12 20 30]
   等价于 a * b: [ 2  6 12 20 30]

4. divide / floor_divide (除法)
   np.divide(a, b): [0.5        0.66666667 0.75       0.8        0.83333333]
   np.floor_divide(a, b): [0 0 0 0 0] (向下取整除法)
   等价于 a // b: [0 0 0 0 0]

5. maximum / fmax (最大值)
   np.maximum(a, b): [2 3 4 5 6]
   np.maximum(a, c): [1 2 3 4 5]
   说明: fmax 会忽略NaN，maximum 不会

6. minimum / fmin (最小值)
   np.minimum(a, b): [1 2 3 4 5]
   np.minimum(a, c): [-2 -1  0  1  2]

7. mod (求模/取余数)
   np.mod(b, a): [0 1 1 1 1]
   等价于 b % a: [0 1 1 1 1]

8. copysign (复制符号)
   np.copysign(a, c): [-1. -2.  3.  4.  5.]
   说明: 将第二个数组的符号赋给第一个数组的值

9. 比较运算函数 (返回布尔数组)
   a = [1 2 3 4 5], b = [2 3 4 5 6]
   np.greater(a, b)     (a > b):  [False False False False False]
   np.greater_equal(a, b) (a >= b): [False False False False False]
   np.less(a, b)        (a < b):  [ True  True  True  True  True]
   np.less_equal(a, b)  (a <= b): [ True  True  True  True  True]
   np.equal(a, b)       (a == b): [False False False False False]
   np.not_equal(a, b)   (a != b): [ True  True  True  True  True]

10. 逻辑运算函数
   x = [ True  True False False]
   y = [ True False  True False]
   np.logical_and(x, y): [ True False False False]  (与运算)
   np.logical_or(x, y):  [ True  True  True False]   (或运算)
   np.logical_xor(x, y): [False  True  True False]  (异或运算)

==================================================
二元通用函数速查表
==================================================

| 函数                              | 描述                           |
|-----------------------------------|--------------------------------|
| add                               | 将数组中对应的元素相加           |
| subtract                          | 从第一个数组中减去第二个数组     |
| multiply                          | 数组元素相乘                     |
| divide                            | 除法                             |
| floor_divide                      | 向下整除法（舍去余数）           |
| maximum, fmax                     | 元素级的最大值计算               |
| minimum, fmin                     | 元素级的最小值计算               |
| mod                               | 元素级的求模计算（取余数）       |
| copysign                          | 将第二个数组的符号赋给第一个数组 |
| greater, greater_equal            | 执行 >, >= 比较运算              |
| less, less_equal                  | 执行 <, <= 比较运算              |
| equal, not_equal                  | 执行 ==, != 比较运算             |
| logical_and, logical_or, logical_xor | 逻辑与、或、异或运算          |


==================================================
综合示例
==================================================
arr1 = [10 20 30 40 50]
arr2 = [ 3  5  7  9 11]

相加:   [13 25 37 49 61]
相减:   [ 7 15 23 31 39]
相乘:   [ 30 100 210 360 550]
除法:   [3.33333333 4.         4.28571429 4.44444444 4.54545455]
整除:   [3 4 4 4 4]
最大值: [10 20 30 40 50]
最小值: [ 3  5  7  9 11]
取余数: [1 0 2 4 6]
arr1 > arr2: [ True  True  True  True  True]

import numpy as np

# 包含 NaN 的数组
a = np.array([1, 2, np.nan, 4, 5])
b = np.array([10, 20, 30, 40, np.nan])

print("=" * 50)
print("maximum vs fmax 对比")
print("=" * 50)
print(f"a = {a}")
print(f"b = {b}")
print()

print("np.maximum(a, b):")
print(f"   {np.maximum(a, b)}")
print("   说明: 只要有一个是 NaN，结果就是 NaN")
print()

print("np.fmax(a, b):")
print(f"   {np.fmax(a, b)}")
print("   说明: 忽略 NaN，返回另一个非 NaN 的值")

==================================================
maximum vs fmax 对比
==================================================
a = [ 1.  2. nan  4.  5.]
b = [10. 20. 30. 40. nan]

np.maximum(a, b):
   [10. 20. nan 40. nan]
   说明: 只要有一个是 NaN，结果就是 NaN

np.fmax(a, b):
   [10. 20. 30. 40.  5.]
   说明: 忽略 NaN，返回另一个非 NaN 的值

 

08利用numpy数组进行数据处理

 

np.where() - 将条件逻辑转为数组运算

np.where() 是三元表达式 x if condition else y 的矢量化版本。

语法

```python np.where(condition, x, y) condition：条件数组（布尔型）

x：条件为 True 时取值的数组或标量

y：条件为 False 时取值的数组或标量

import numpy as np

# 示例1：基本用法
arr_x = np.array([1, 5, 7])
arr_y = np.array([2, 6, 8])
arr_con = np.array([True, False, True])

result = np.where(arr_con, arr_x, arr_y)
print(result)  # [1 6 7]

print("""
索引0：True → 取 arr_x[0] = 1

索引1：False → 取 arr_y[1] = 6

索引2：True → 取 arr_x[2] = 7""")

re2=np.where(arr_x>3,1,0)
print(re2)

[1 6 7]

索引0：True → 取 arr_x[0] = 1

索引1：False → 取 arr_y[1] = 6

索引2：True → 取 arr_x[2] = 7
[0 1 1]

 

数组统计运算

通过 NumPy 库中的相关方法，可以很方便地进行数组的统计汇总。

常用统计方法速查表

方法	描述
sum	对数组中全部或某个轴向上的元素求和
mean	算术平均值
min	计算数组中的最小值
max	计算数组中的最大值
argmin	返回最小值的索引
argmax	返回最大值的索引
cumsum	所有元素的累计和
cumprod	所有元素的累计积

重要参数：axis

大多数统计方法都支持 axis 参数：

• axis=0：沿着行方向（垂直），对各列进行统计
• axis=1：沿着列方向（水平），对各⾏进行统计
• 不指定 axis：对所有元素进行统计

## 代码单元格（可直接运行）

# ==========================================
# 数组统计运算
# ==========================================

import numpy as np

# 创建测试数组
arr = np.array([[1, 2, 3],
                [4, 5, 6],
                [7, 8, 9]])

print("=" * 50)
print("原始数组")
print("=" * 50)
print(arr)
print(f"形状: {arr.shape}")

# 1. sum - 求和
print("\n1. sum (求和)")
print(f"   全部元素求和: {np.sum(arr)}")
print(f"   按列求和 (axis=0): {np.sum(arr, axis=0)}")
print(f"   按行求和 (axis=1): {np.sum(arr, axis=1)}")

# 2. mean - 平均值
print("\n2. mean (平均值)")
print(f"   全部元素平均值: {np.mean(arr)}")
print(f"   按列求平均 (axis=0): {np.mean(arr, axis=0)}")
print(f"   按行求平均 (axis=1): {np.mean(arr, axis=1)}")

# 3. min / max - 最小值和最大值
print("\n3. min / max (最小/最大值)")
print(f"   全局最小值: {np.min(arr)}")
print(f"   全局最大值: {np.max(arr)}")
print(f"   每列最小值: {np.min(arr, axis=0)}")
print(f"   每行最大值: {np.max(arr, axis=1)}")

# 4. argmin / argmax - 最值索引
print("\n4. argmin / argmax (最值索引)")
print(f"   全局最小值索引 (扁平化后): {np.argmin(arr)}")
print(f"   全局最大值索引 (扁平化后): {np.argmax(arr)}")
print(f"   每列最小值索引: {np.argmin(arr, axis=0)}")
print(f"   每行最大值索引: {np.argmax(arr, axis=1)}")

# 5. cumsum - 累计和
print("\n5. cumsum (累计和)")
print(f"   全部元素累计和: {np.cumsum(arr)}")
print(f"   按列累计和 (axis=0):\n{np.cumsum(arr, axis=0)}")
print(f"   按行累计和 (axis=1):\n{np.cumsum(arr, axis=1)}")

# 6. cumprod - 累计积
print("\n6. cumprod (累计积)")
print(f"   全部元素累计积: {np.cumprod(arr)}")
print(f"   按列累计积 (axis=0):\n{np.cumprod(arr, axis=0)}")
print(f"   按行累计积 (axis=1):\n{np.cumprod(arr, axis=1)}")

# 7. 补充：标准差、方差、中位数
print("\n" + "=" * 50)
print("补充统计方法")
print("=" * 50)
arr_flat = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
print(f"数组: {arr_flat}")
print(f"标准差: {np.std(arr_flat):.2f}")
print(f"方差: {np.var(arr_flat):.2f}")
print(f"中位数: {np.median(arr_flat)}")
print(f"第50百分位数: {np.percentile(arr_flat,50)}")

# 8. 综合示例
print("\n" + "=" * 50)
print("综合示例")
print("=" * 50)
data = np.array([[10, 20, 30],
                 [40, 50, 60],
                 [70, 80, 90]])

print(f"数据:\n{data}")
print(f"\n统计摘要:")
print(f"  总和: {np.sum(data)}")
print(f"  均值: {np.mean(data)}")
print(f"  最小值: {np.min(data)} (索引: {np.argmin(data)})")
print(f"  最大值: {np.max(data)} (索引: {np.argmax(data)})")
print(f"  累计和: {np.cumsum(data)}")
print(f"  累计积: {np.cumprod(data)}")

==================================================
原始数组
==================================================
[[1 2 3]
 [4 5 6]
 [7 8 9]]
形状: (3, 3)

1. sum (求和)
   全部元素求和: 45
   按列求和 (axis=0): [12 15 18]
   按行求和 (axis=1): [ 6 15 24]

2. mean (平均值)
   全部元素平均值: 5.0
   按列求平均 (axis=0): [4. 5. 6.]
   按行求平均 (axis=1): [2. 5. 8.]

3. min / max (最小/最大值)
   全局最小值: 1
   全局最大值: 9
   每列最小值: [1 2 3]
   每行最大值: [3 6 9]

4. argmin / argmax (最值索引)
   全局最小值索引 (扁平化后): 0
   全局最大值索引 (扁平化后): 8
   每列最小值索引: [0 0 0]
   每行最大值索引: [2 2 2]

5. cumsum (累计和)
   全部元素累计和: [ 1  3  6 10 15 21 28 36 45]
   按列累计和 (axis=0):
[[ 1  2  3]
 [ 5  7  9]
 [12 15 18]]
   按行累计和 (axis=1):
[[ 1  3  6]
 [ 4  9 15]
 [ 7 15 24]]

6. cumprod (累计积)
   全部元素累计积: [     1      2      6     24    120    720   5040  40320 362880]
   按列累计积 (axis=0):
[[  1   2   3]
 [  4  10  18]
 [ 28  80 162]]
   按行累计积 (axis=1):
[[  1   2   6]
 [  4  20 120]
 [  7  56 504]]

==================================================
补充统计方法
==================================================
数组: [1 2 3 4 5 6 7 8 9]
标准差: 2.58
方差: 6.67
中位数: 5.0
第50百分位数: 5.0

==================================================
综合示例
==================================================
数据:
[[10 20 30]
 [40 50 60]
 [70 80 90]]

统计摘要:
  总和: 450
  均值: 50.0
  最小值: 10 (索引: 0)
  最大值: 90 (索引: 8)
  累计和: [ 10  30  60 100 150 210 280 360 450]
  累计积: [         10         200        6000      240000    12000000   720000000
 -1139607552  -974290944 -1786839040]

 

对numpy进行排序 ：sort() 方法总结 默认根据-1轴进行排序

方法 是否修改原数组 返回值 arr.sort() ✅ 是（原地排序） None np.sort(arr) ❌ 否 返回排序后的新数组

# ==========================================
# 数组排序 - sort()
# ==========================================

import numpy as np

print("=" * 50)
print("数组排序示例")
print("=" * 50)

# 创建数组
arr = np.array([[6, 2, 7], [3, 6, 2], [4, 3, 2]])

print("原数组:")
print(arr)
print()

# 原地排序（直接修改原数组）
arr.sort()

print("调用 arr.sort() 后:")
print(arr)
print()
print("说明: sort() 会直接修改原数组（原地排序）")
print("      每行独立排序，不跨行排序")

==================================================
数组排序示例
==================================================
原数组:
[[6 2 7]
 [3 6 2]
 [4 3 2]]

调用 arr.sort() 后:
[[2 6 7]
 [2 3 6]
 [2 3 4]]

说明: sort() 会直接修改原数组（原地排序）
      每行独立排序，不跨行排序

# ==========================================
# sort() 方法总结 - 对比示例
# ==========================================

import numpy as np

print("=" * 50)
print("arr.sort() vs np.sort(arr) 对比")
print("=" * 50)

# 创建相同的测试数组
arr1 = np.array([[6, 2, 7], [3, 6, 2], [4, 3, 2]])
arr2 = np.array([[6, 2, 7], [3, 6, 2], [4, 3, 2]])

print("原始数组（两份相同数据）:")
print(arr1)
print()

# ==========================================
# 方法1：arr.sort() - 原地排序
# ==========================================
print("1. arr.sort() - 原地排序")
print("-" * 30)
print(f"排序前 arr1: \n{arr1}")
print(f"arr1 的内存地址: {id(arr1)}")

arr1.sort()  # 直接修改原数组

print(f"\n排序后 arr1: \n{arr1}")
print(f"arr1 的内存地址: {id(arr1)} (地址相同，说明是同一个对象)")
print("✅ 原数组被直接修改，不返回新数组")

# ==========================================
# 方法2：np.sort(arr) - 返回新数组
# ==========================================
print("\n" + "=" * 50)
print("2. np.sort(arr) - 返回新数组")
print("-" * 30)
print(f"排序前 arr2: \n{arr2}")
print(f"arr2 的内存地址: {id(arr2)}")

arr2_sorted = np.sort(arr2)  # 返回新数组，原数组不变

print(f"\n排序后 arr2 (原数组): \n{arr2}")
print(f"arr2 的内存地址: {id(arr2)} (地址不变，原数组未修改)")
print(f"\n排序后返回的新数组 arr2_sorted: \n{arr2_sorted}")
print(f"arr2_sorted 的内存地址: {id(arr2_sorted)} (新地址，是新对象)")
print("✅ 原数组保持不变，返回排序后的新数组")

# ==========================================
# 实际应用示例
# ==========================================
print("\n" + "=" * 50)
print("实际应用场景")
print("=" * 50)

# 场景1：不需要保留原数据时，用 arr.sort()（节省内存）
data = np.array([5, 2, 8, 1, 9])
print("场景1 - 不需要保留原数据:")
print(f"  排序前: {data}")
data.sort()
print(f"  排序后: {data} (原数据被覆盖)")
print()

# 场景2：需要保留原数据时，用 np.sort()
original = np.array([5, 2, 8, 1, 9])
sorted_data = np.sort(original)
print("场景2 - 需要保留原数据:")
print(f"  原数组: {original}")
print(f"  排序后新数组: {sorted_data}")
print(f"  原数组保持不变: {original}")

# ==========================================
# 一维数组示例
# ==========================================
print("\n" + "=" * 50)
print("一维数组示例")
print("=" * 50)

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

# 原地排序
arr_1d_copy = arr_1d.copy()
arr_1d_copy.sort()
print(f"arr.sort(): {arr_1d_copy}")

# 返回新数组
arr_1d_original = np.array([3, 1, 4, 1, 5, 9, 2])
result = np.sort(arr_1d_original)
print(f"np.sort(): {result}")
print(f"原数组未变: {arr_1d_original}")

==================================================
arr.sort() vs np.sort(arr) 对比
==================================================
原始数组（两份相同数据）:
[[6 2 7]
 [3 6 2]
 [4 3 2]]

1. arr.sort() - 原地排序
------------------------------
排序前 arr1: 
[[6 2 7]
 [3 6 2]
 [4 3 2]]
arr1 的内存地址: 2420193396848

排序后 arr1: 
[[2 6 7]
 [2 3 6]
 [2 3 4]]
arr1 的内存地址: 2420193396848 (地址相同，说明是同一个对象)
✅ 原数组被直接修改，不返回新数组

==================================================
2. np.sort(arr) - 返回新数组
------------------------------
排序前 arr2: 
[[6 2 7]
 [3 6 2]
 [4 3 2]]
arr2 的内存地址: 2420193534768

排序后 arr2 (原数组): 
[[6 2 7]
 [3 6 2]
 [4 3 2]]
arr2 的内存地址: 2420193534768 (地址不变，原数组未修改)

排序后返回的新数组 arr2_sorted: 
[[2 6 7]
 [2 3 6]
 [2 3 4]]
arr2_sorted 的内存地址: 2420193397904 (新地址，是新对象)
✅ 原数组保持不变，返回排序后的新数组

==================================================
实际应用场景
==================================================
场景1 - 不需要保留原数据:
  排序前: [5 2 8 1 9]
  排序后: [1 2 5 8 9] (原数据被覆盖)

场景2 - 需要保留原数据:
  原数组: [5 2 8 1 9]
  排序后新数组: [1 2 5 8 9]
  原数组保持不变: [5 2 8 1 9]

==================================================
一维数组示例
==================================================
arr.sort(): [1 1 2 3 4 5 9]
np.sort(): [1 1 2 3 4 5 9]
原数组未变: [3 1 4 1 5 9 2]

import numpy as np

arr = np.array([[6, 3, 4], [7, 5, 2]])
print("原数组:")
print(arr)
print()

arr.sort(axis=-2)
print("arr.sort(axis=-2) 后:")
print(arr)

print("""
原理解释
axis=-2 在二维数组中的含义
对于二维数组：
axis=-1 表示最后一个轴（水平方向/行内axis=1）→ 按行排序
axis=-2 表示倒数第二个轴（垂直方向/列间axis=0）→ 按列排序""")

原数组:
[[6 3 4]
 [7 5 2]]

arr.sort(axis=-2) 后:
[[6 3 2]
 [7 5 4]]

原理解释
axis=-2 在二维数组中的含义
对于二维数组：
axis=-1 表示最后一个轴（水平方向/行内axis=1）→ 按行排序
axis=-2 表示倒数第二个轴（垂直方向/列间axis=0）→ 按列排序

 

检索数组元素 - all() 和 any()

all() 和 any() 是 NumPy 中用于条件检索的两个重要函数。

函数说明

函数	作用	返回值
all()	判断所有元素是否都满足条件	True / False
any()	判断是否存在元素满足条件	True / False

速查表 条件 all() any() 所有 > 0 np.all(arr > 0) - 存在 > 0 - np.any(arr > 0) 所有 == 0 np.all(arr == 0) - 存在 == 0 - np.any(arr == 0) 所有都是 NaN np.all(np.isnan(arr)) - 存在 NaN - np.any(np.isnan(arr))

## 代码单元格（可直接运行）
# ==========================================
# 检索数组元素 - all() 和 any()
# ==========================================

import numpy as np

# 创建测试数组
arr = np.array([[1, -2, -7],
                [-3, 6, 2],
                [-4, 3, 2]])

print("=" * 50)
print("原始数组")
print("=" * 50)
print(arr)

# 1. all() - 所有元素都满足条件
print("\n1. all() - 所有元素都满足条件")
print("-" * 30)
print(f"np.all(arr > 0): {np.all(arr > 0)}")
print(f"np.all(arr > -10): {np.all(arr > -10)}")

# 2. any() - 存在元素满足条件
print("\n2. any() - 存在元素满足条件")
print("-" * 30)
print(f"np.any(arr > 0): {np.any(arr > 0)}")
print(f"np.any(arr > 10): {np.any(arr > 10)}")

# 3. 指定轴方向
print("\n3. 指定轴方向 (axis 参数)")
print("-" * 30)
print(f"axis=0 (按列) - all: {np.all(arr > 0, axis=0)}")
print(f"axis=0 (按列) - any: {np.any(arr > 0, axis=0)}")
print(f"axis=1 (按行) - all: {np.all(arr > 0, axis=1)}")
print(f"axis=1 (按行) - any: {np.any(arr > 0, axis=1)}")

# 4. 实际应用场景
print("\n4. 实际应用场景")
print("-" * 30)

# 场景1：检查数据是否全为正数
data = np.array([1, 2, 3, 4, 5])
print(f"数据全为正数? {np.all(data > 0)}")

# 场景2：检查数据是否存在缺失值
data_with_nan = np.array([1, 2, np.nan, 4, 5])
data_with_nan2=np.array([1,2,np.nan,4,5])
a=np.isnan(data_with_nan2)
print(a)
print(f"数据存在 NaN? {np.any(np.isnan(data_with_nan))}")

# 场景3：检查数组是否全为零
zeros = np.zeros((3, 3))
print(f"数组全为零? {np.all(zeros == 0)}")

# 场景4：检查数组是否有任何非零元素
non_zeros = np.array([[0, 0, 0], [0, 1, 0]])
print(f"数组有任何非零元素? {np.any(non_zeros != 0)}")

print("\n" + "=" * 50)
print("总结")
print("=" * 50)
print("""
- all(): 所有元素都满足条件 → True（类似"与"运算）
- any(): 至少一个元素满足条件 → True（类似"或"运算）
- axis参数: 指定统计方向
  - axis=0: 沿着行方向（按列）
  - axis=1: 沿着列方向（按行）
""")

==================================================
原始数组
==================================================
[[ 1 -2 -7]
 [-3  6  2]
 [-4  3  2]]

1. all() - 所有元素都满足条件
------------------------------
np.all(arr > 0): False
np.all(arr > -10): True

2. any() - 存在元素满足条件
------------------------------
np.any(arr > 0): True
np.any(arr > 10): False

3. 指定轴方向 (axis 参数)
------------------------------
axis=0 (按列) - all: [False False False]
axis=0 (按列) - any: [ True  True  True]
axis=1 (按行) - all: [False False False]
axis=1 (按行) - any: [ True  True  True]

4. 实际应用场景
------------------------------
数据全为正数? True
[False False  True False False]
数据存在 NaN? True
数组全为零? True
数组有任何非零元素? True

==================================================
总结
==================================================

- all(): 所有元素都满足条件 → True（类似"与"运算）
- any(): 至少一个元素满足条件 → True（类似"或"运算）
- axis参数: 指定统计方向
  - axis=0: 沿着行方向（按列）
  - axis=1: 沿着列方向（按行）

 

唯一化及其他集合逻辑

针对一维数组，NumPy 提供了 unique() 函数来找出数组中的唯一值，并返回排序后的结果。

1. unique() - 唯一值

import numpy as np

arr = np.array([12, 11, 34, 23, 12, 8, 11]) result = np.unique(arr) print(result) # [ 8 11 12 23 34]

unique() 函数参数说明

参数	说明	返回值
return_index	返回唯一值在原数组中首次出现的索引	(unique, indices)
return_inverse	返回原数组在唯一值数组中的索引（用于重构）	(unique, inverse)
return_counts	返回唯一值出现的次数	(unique, counts)

1. 其他集合逻辑函数

函数	说明	示例
intersect1d()	计算两个数组的交集	np.intersect1d(arr1, arr2)
union1d()	计算两个数组的并集	np.union1d(arr1, arr2)
setdiff1d()	计算差集（在 arr1 中但不在 arr2 中）	np.setdiff1d(arr1, arr2)
setxor1d()	计算对称差（并集减交集）	np.setxor1d(arr1, arr2)
in1d()	检查 arr1 的元素是否在 arr2 中	np.in1d(arr1, arr2)

1. 速查表 a = [1, 2, 3] b = [2, 3, 4]

操作	函数	结果示例
唯一值	np.unique(arr)	[1, 2, 3]
唯一值 + 索引	np.unique(arr, return_index=True)	(values, indices)
唯一值 + 次数	np.unique(arr, return_counts=True)	(values, counts)
交集	np.intersect1d(a, b)	[2, 3]
并集	np.union1d(a, b)	[1, 2, 3, 4]
差集	np.setdiff1d(a, b)	[1]
对称差	np.setxor1d(a, b)	[1, 4]
成员检查	np.in1d(a, b)	[False, True, True]

## 代码单元格（可直接运行）
# ==========================================
# 唯一化及其他集合逻辑
# ==========================================

import numpy as np

print("=" * 50)
print("1. unique() - 唯一值")
print("=" * 50)

arr = np.array([12, 11, 34, 23, 12, 8, 11])
print(f"原数组: {arr}")
print(f"np.unique(arr): {np.unique(arr)}")

print("\n" + "=" * 50)
print("2. unique() 参数详解")
print("=" * 50)

# return_index
unique, indices = np.unique(arr, return_index=True)
print(f"return_index=True:")
print(f"  唯一值: {unique}")
print(f"  首次出现索引: {indices}")

# return_counts
unique, counts = np.unique(arr, return_counts=True)
print(f"\nreturn_counts=True:")
print(f"  唯一值: {unique}")
print(f"  出现次数: {counts}")

# return_inverse
unique, inverse = np.unique(arr, return_inverse=True)
print(f"\nreturn_inverse=True:")
print(f"  唯一值: {unique}")
print(f"  重构索引: {inverse}")
print(f"  用索引重构: {unique[inverse]}")

print("\n" + "=" * 50)
print("3. 集合逻辑函数")
print("=" * 50)

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

print(f"arr1: {arr1}")
print(f"arr2: {arr2}")
print(f"交集 (intersect1d): {np.intersect1d(arr1, arr2)}")
print(f"并集 (union1d): {np.union1d(arr1, arr2)}")
print(f"差集 (setdiff1d arr1 - arr2): {np.setdiff1d(arr1, arr2)}")
print(f"对称差 (setxor1d): {np.setxor1d(arr1, arr2)}")
print(f"成员检查 (in1d): {np.in1d(arr1, arr2)}")

print("\n" + "=" * 50)
print("4. 实际应用场景")
print("=" * 50)

# 统计出现频率
data = np.array([1, 2, 2, 3, 3, 3, 4, 4, 4, 4])
values, counts = np.unique(data, return_counts=True)
print("统计频率:")
for v, c in zip(values, counts):
    print(f"  {v} 出现 {c} 次")

# 去重
data = np.array([5, 3, 5, 1, 3, 2, 5, 1])
print(f"\n原数组: {data}")
print(f"去重后: {np.unique(data)}")

# 找出缺失的元素
expected = np.array([1, 2, 3, 4, 5])
actual = np.array([1, 2, 4, 5])
missing = np.setdiff1d(expected, actual)
print(f"\n期望值: {expected}")
print(f"实际值: {actual}")
print(f"缺失值: {missing}")

==================================================
1. unique() - 唯一值
==================================================
原数组: [12 11 34 23 12  8 11]
np.unique(arr): [ 8 11 12 23 34]

==================================================
2. unique() 参数详解
==================================================
return_index=True:
  唯一值: [ 8 11 12 23 34]
  首次出现索引: [5 1 0 3 2]

return_counts=True:
  唯一值: [ 8 11 12 23 34]
  出现次数: [1 2 2 1 1]

return_inverse=True:
  唯一值: [ 8 11 12 23 34]
  重构索引: [2 1 4 3 2 0 1]
  用索引重构: [12 11 34 23 12  8 11]

==================================================
3. 集合逻辑函数
==================================================
arr1: [1 2 3 4 5]
arr2: [4 5 6 7 8]
交集 (intersect1d): [4 5]
并集 (union1d): [1 2 3 4 5 6 7 8]
差集 (setdiff1d arr1 - arr2): [1 2 3]
对称差 (setxor1d): [1 2 3 6 7 8]
成员检查 (in1d): [False False False  True  True]

==================================================
4. 实际应用场景
==================================================
统计频率:
  1 出现 1 次
  2 出现 2 次
  3 出现 3 次
  4 出现 4 次

原数组: [5 3 5 1 3 2 5 1]
去重后: [1 2 3 5]

期望值: [1 2 3 4 5]
实际值: [1 2 4 5]
缺失值: [3]

 

唯一化及其他集合逻辑 - in1d()

in1d() 函数用于判断数组中的元素是否在另一个数组中存在，返回一个布尔型数组。

语法

np.in1d(a, b)

import numpy as np

arr = np.array([12, 11, 34, 23, 12, 8, 11])
result = np.in1d(arr, [11, 12])

print(result)

[ True  True False False  True False  True]

 

唯一化及其他集合逻辑

NumPy 提供的集合函数，用于对一维数组进行集合运算。

NumPy 集合函数速查表

==========================================

函数 描述 示例 unique(x) 唯一值（有序） [1,2,3] intersect1d(x,y) 交集 [2,3] union1d(x,y) 并集 [1,2,3,4] in1d(x,y) 成员检查（布尔数组） [True,False] setdiff1d(x,y) 差集（x-y） [1] setxor1d(x,y) 对称差 [1,4]

import numpy as np

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

print("x =", x)
print("y =", y)
print()
print("unique(x):          ", np.unique(x))
print("intersect1d(x, y):  ", np.intersect1d(x, y))
print("union1d(x, y):      ", np.union1d(x, y))
print("in1d(x, y):         ", np.in1d(x, y))
print("setdiff1d(x, y):    ", np.setdiff1d(x, y))
print("setxor1d(x, y):     ", np.setxor1d(x, y))

x = [1 2 3]
y = [2 3 4]

unique(x):           [1 2 3]
intersect1d(x, y):   [2 3]
union1d(x, y):       [1 2 3 4]
in1d(x, y):          [False  True  True]
setdiff1d(x, y):     [1]
setxor1d(x, y):      [1 4]

import numpy as np

arr = np.array([[6, 3, 4], [7, 5, 2]])
print("原数组:")
print(arr)
print()

arr.sort(axis=-2)
print("arr.sort(axis=-2) 后:")
print(arr)

print("""
原理解释
axis=-2 在二维数组中的含义
对于二维数组：
axis=-1 表示最后一个轴（水平方向/行内axis=1）→ 按行排序
axis=-2 表示倒数第二个轴（垂直方向/列间axis=0）→ 按列排序""")

原数组:
[[6 3 4]
 [7 5 2]]

arr.sort(axis=-2) 后:
[[6 3 2]
 [7 5 4]]

原理解释
axis=-2 在二维数组中的含义
对于二维数组：
axis=-1 表示最后一个轴（水平方向/行内）→ 按行排序
axis=-2 表示倒数第二个轴（垂直方向/列间）→ 按列排序

 

 

==================================================
原始数组
==================================================
[[1 2 3]
 [4 5 6]
 [7 8 9]]
形状: (3, 3)

1. sum (求和)
   全部元素求和: 45
   按列求和 (axis=0): [12 15 18]
   按行求和 (axis=1): [ 6 15 24]

2. mean (平均值)
   全部元素平均值: 5.0
   按列求平均 (axis=0): [4. 5. 6.]
   按行求平均 (axis=1): [2. 5. 8.]

3. min / max (最小/最大值)
   全局最小值: 1
   全局最大值: 9
   每列最小值: [1 2 3]
   每行最大值: [3 6 9]

4. argmin / argmax (最值索引)
   全局最小值索引 (扁平化后): 0
   全局最大值索引 (扁平化后): 8
   每列最小值索引: [0 0 0]
   每行最大值索引: [2 2 2]

5. cumsum (累计和)
   全部元素累计和: [ 1  3  6 10 15 21 28 36 45]
   按列累计和 (axis=0):
[[ 1  2  3]
 [ 5  7  9]
 [12 15 18]]
   按行累计和 (axis=1):
[[ 1  3  6]
 [ 4  9 15]
 [ 7 15 24]]

6. cumprod (累计积)
   全部元素累计积: [     1      2      6     24    120    720   5040  40320 362880]
   按列累计积 (axis=0):
[[  1   2   3]
 [  4  10  18]
 [ 28  80 162]]
   按行累计积 (axis=1):
[[  1   2   6]
 [  4  20 120]
 [  7  56 504]]

==================================================
补充统计方法
==================================================
数组: [1 2 3 4 5 6 7 8 9]
标准差: 2.58
方差: 6.67
中位数: 5.0
第50百分位数: 5.0

==================================================
综合示例
==================================================
数据:
[[10 20 30]
 [40 50 60]
 [70 80 90]]

统计摘要:
  总和: 450
  均值: 50.0
  最小值: 10 (索引: 0)
  最大值: 90 (索引: 8)
  累计和: [ 10  30  60 100 150 210 280 360 450]
  累计积: [         10         200        6000      240000    12000000   720000000
 -1139607552  -974290944 -1786839040]

 

09 线性代数模块

 

线性代数模块 - numpy.linalg

numpy.linalg 模块包含了一组标准的矩阵分解运算，以及逆矩阵、行列式等线性代数运算。

重要区别：* vs @ / dot()

运算	符号/函数	说明
元素级乘法	a * b	对应位置元素相乘（Hadamard积）
矩阵点积	a @ b 或 np.dot(a, b)	标准的矩阵乘法

import numpy as np

# 创建两个矩阵
A = np.array([[1, 2],
              [3, 4]])

B = np.array([[5, 6],
              [7, 8]])

print("=" * 50)
print("矩阵 A:")
print(A)
print("\n矩阵 B:")
print(B)

print("\n" + "=" * 50)
print("元素级乘法 (A * B)")
print("=" * 50)
result = A * B
print(result)
print("说明: 对应位置元素相乘")


print("\n" + "=" * 50)
print("矩阵点积 (A @ B)")
print("=" * 50)
result = A @ B
print(result)
print("说明: 标准的矩阵乘法")

# 等价写法
print("\n等价写法:")
print("A @ B     =", A @ B)
print("np.dot(A, B) =", np.dot(A, B))

==================================================
矩阵 A:
[[1 2]
 [3 4]]

矩阵 B:
[[5 6]
 [7 8]]

==================================================
元素级乘法 (A * B)
==================================================
[[ 5 12]
 [21 32]]
说明: 对应位置元素相乘

==================================================
矩阵点积 (A @ B)
==================================================
[[19 22]
 [43 50]]
说明: 标准的矩阵乘法

等价写法:
A @ B     = [[19 22]
 [43 50]]
np.dot(A, B) = [[19 22]
 [43 50]]

 

函数 描述 np.linalg.inv(A) 计算矩阵 A 的逆矩阵 np.linalg.det(A) 计算矩阵 A 的行列式 np.linalg.matrix_power(A, n) 计算矩阵 A 的 n 次幂 np.linalg.eig(A) 计算矩阵 A 的特征值和特征向量 np.linalg.solve(A, b) 求解线性方程组 Ax = b np.linalg.qr(A) 计算矩阵 A 的 QR 分解 np.linalg.svd(A) 计算矩阵 A 的奇异值分解 np.trace(A) 计算矩阵 A 的迹（对角线元素之和） np.linalg.norm(A) 计算矩阵或向量的范数

a=np.array([[80,86],
           [82,80],
           [85,78],
           [90,90],
           [86,82],
           [78,80],
           [92,94]])
b=np.array([[0.8],
            [0.2]])
re=a.T
print(re)
res=re * b
print(res)
resul=np.sum(res,axis=0)
print(resul)

[[80 82 85 90 86 78 92]
 [86 80 78 90 82 80 94]]
[[64.  65.6 68.  72.  68.8 62.4 73.6]
 [17.2 16.  15.6 18.  16.4 16.  18.8]]
[81.2 81.6 83.6 90.  85.2 78.4 92.4]

a=np.array([[80,86],
           [82,80],
           [85,78],
           [90,90],
           [86,82],
           [78,80],
           [92,94]])
b=np.array([[0.8,0.2]])
re=b@a.T
print(re)

[[81.2 81.6 83.6 90.  85.2 78.4 92.4]]

 

随机数模块 - numpy.random

与 Python 内置的 random 模块相比，NumPy 的 random 模块功能更强大，可以高效生成多种概率分布的样本值。

常用随机函数速查表

函数	描述	示例
rand(d0, d1, ..., dn)	生成 [0, 1) 区间内均匀分布的随机浮点数	np.random.rand(3, 3)
randn(d0, d1, ..., dn)	生成标准正态分布（均值为0，方差为1）的随机数	np.random.randn(2, 3)
randint(low, high, size)	生成指定区间内的随机整数	np.random.randint(0, 10, size=(2, 3))
random(size)	生成 [0, 1) 区间内均匀分布的随机浮点数	np.random.random((2, 3))
uniform(low, high, size)	生成指定区间内的均匀分布随机数	np.random.uniform(0, 1, size=(2, 3))
normal(loc, scale, size)	生成正态分布随机数	np.random.normal(0, 1, size=(2, 3))
seed(n)	设置随机种子，保证结果可复现	np.random.seed(42)

## 代码单元格（可直接运行）
# ==========================================
# 随机数模块 - numpy.random
# ==========================================

import numpy as np

print("=" * 50)
print("numpy.random 常用函数")
print("=" * 50)

# 1. rand() - 均匀分布 [0, 1)
print("\n1. rand() - [0, 1) 均匀分布")
print("-" * 30)
print(f"np.random.rand(): {np.random.rand()}")
print(f"np.random.rand(3): {np.random.rand(3)}")
print("np.random.rand(3, 3):")
print(np.random.rand(3, 3))

# 2. randn() - 标准正态分布
print("\n2. randn() - 标准正态分布 (均值=0, 标准差=1)")
print("-" * 30)
print(f"np.random.randn(3): {np.random.randn(3)}")
print("np.random.randn(2, 3):")
print(np.random.randn(2, 3))

# 3. randint() - 随机整数
print("\n3. randint() - 随机整数")
print("-" * 30)
print(f"np.random.randint(0, 10): {np.random.randint(0, 10)}")
print(f"np.random.randint(0, 10, size=5): {np.random.randint(0, 10, size=5)}")
print("np.random.randint(0, 10, size=(2, 3)):")
print(np.random.randint(0, 10, size=(2, 3)))

# 4. random() - 均匀分布
print("\n4. random() - [0, 1) 均匀分布")
print("-" * 30)
print("np.random.random((2, 3)):")
print(np.random.random((2, 3)))

# 5. uniform() - 指定区间均匀分布
print("\n5. uniform() - 指定区间均匀分布")
print("-" * 30)
print("np.random.uniform(5, 10, size=(2, 3)):")
print(np.random.uniform(5, 10, size=(2, 3)))

# 6. normal() - 正态分布
print("\n6. normal() - 正态分布")
print("-" * 30)
print("np.random.normal(10, 2, size=(2, 3)):")
print(np.random.normal(10, 2, size=(2, 3)))

# 7. seed() - 设置随机种子
print("\n7. seed() - 设置随机种子")
print("-" * 30)
np.random.seed(42)
print(f"种子=42 第一次: {np.random.rand(3)}")
np.random.seed(42)
print(f"种子=42 第二次: {np.random.rand(3)}")
print("说明: 相同种子生成的随机数相同")

# 8. 综合示例
print("\n" + "=" * 50)
print("综合示例 - 学生成绩")
print("=" * 50)

np.random.seed(42)
scores = np.random.randint(80, 101, size=(5, 3))
print("随机生成的学生成绩 (5人 × 3门):")
print(scores)

print(f"\n各科平均分: {np.mean(scores, axis=0)}")
print(f"每个学生总分: {np.sum(scores, axis=1)}")

weights = np.random.rand(3)
weights = weights / np.sum(weights)
print(f"\n随机权重: {weights}")
print(f"加权总分: {scores@weights}")

==================================================
numpy.random 常用函数
==================================================

1. rand() - [0, 1) 均匀分布
------------------------------
np.random.rand(): 0.0848437845732567
np.random.rand(3): [0.30349665 0.59328843 0.16593953]
np.random.rand(3, 3):
[[0.70644697 0.74654654 0.82385073]
 [0.86677578 0.98360124 0.5646154 ]
 [0.84301567 0.52588447 0.11765028]]

2. randn() - 标准正态分布 (均值=0, 标准差=1)
------------------------------
np.random.randn(3): [-1.03259682 -1.94910672  0.74464989]
np.random.randn(2, 3):
[[-1.01379753  0.65957459 -1.05746843]
 [-1.86759789 -1.97478611 -0.15910931]]

3. randint() - 随机整数
------------------------------
np.random.randint(0, 10): 4
np.random.randint(0, 10, size=5): [3 6 9 6 0]
np.random.randint(0, 10, size=(2, 3)):
[[0 7 4]
 [5 4 9]]

4. random() - [0, 1) 均匀分布
------------------------------
np.random.random((2, 3)):
[[0.1551867  0.92877921 0.88739953]
 [0.99446099 0.32403818 0.66935413]]

5. uniform() - 指定区间均匀分布
------------------------------
np.random.uniform(5, 10, size=(2, 3)):
[[6.09108317 8.5506106  8.84241698]
 [5.06235081 7.96912816 6.38921877]]

6. normal() - 正态分布
------------------------------
np.random.normal(10, 2, size=(2, 3)):
[[ 9.86004221 12.29280699  8.10890262]
 [12.35407446 10.6906425  14.05464067]]

7. seed() - 设置随机种子
------------------------------
种子=42 第一次: [0.37454012 0.95071431 0.73199394]
种子=42 第二次: [0.37454012 0.95071431 0.73199394]
说明: 相同种子生成的随机数相同

==================================================
综合示例 - 学生成绩
==================================================
随机生成的学生成绩 (5人 × 3门):
[[ 86  99  94]
 [ 90  87 100]
 [ 86  98  90]
 [ 90 100  83]
 [ 87  82 100]]

各科平均分: [87.8 93.2 93.4]
每个学生总分: [279 277 274 273 269]

随机权重: [0.48141852 0.41318614 0.10539534]
加权总分: [92.21458252 89.81439501 91.37981501 93.39409397 86.30420876]

 

案例：酒鬼漫步

import numpy as np
step=2000
draws=np.random.randint(0,2,size=step)

draws

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

#当元素为1：向前移动
#当元素为0：向后移动
direction_steps=np.where(draws>0,1,-1)
direction_steps

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

#数组累计求和
distance=direction_steps.cumsum()

#使用max函数计算向前走得最远的距离
distance.max()

45

#使用max函数计算向前走得最远的距离
distance.min()

-2

#步长为0.5米 
steps=7/0.5
distance_ads=np.abs(distance)

(distance_ads>=steps).argmax()

109