14 章: 进阶 NumPy

arr_2d = np.ones((10, 5))  # 创建一个 10x5 的全 1 数组
arr_2d.shape  # 查看数组的形状

arr_3d = np.ones((3, 4, 5), dtype=np.float64)  # 创建一个 3x4x5 的 float64 类型全 1 数组
arr_3d.strides  # 查看数组的跨度

ints = np.ones(10, dtype=np.uint16)  # 创建一个 uint16 类型的全 1 数组
floats = np.ones(10, dtype=np.float32)  # 创建一个 float32 类型的全 1 数组
print(np.issubdtype(ints.dtype, np.integer))  # 检查 ints.dtype 是否是 np.integer 的子类型
print(np.issubdtype(floats.dtype, np.floating))  # 检查 floats.dtype 是否是 np.floating 的子类型

np.float64.mro()  # 查看 np.float64 的方法解析顺序（继承关系）

arr = np.arange(8)  # 创建一个包含 0 到 7 的一维数组
arr.reshape((4, 2))  # 将数组重塑为 4x2 的二维数组

arr.reshape((4, 2)).reshape((2, 4))  # 将数组先重塑为 4x2，再重塑为 2x4

arr = np.arange(15)  # 创建一个包含 0 到 14 的一维数组
arr.reshape((5, -1))  # 将数组重塑为 5 行，列数自动推断（这里是 3）

other_arr = np.ones((3, 5))  # 创建一个 3x5 的全 1 数组
arr.reshape(other_arr.shape)  # 使用 other_arr 的形状重塑 arr

arr = np.arange(15).reshape((5, 3))  # 创建一个 5x3 的数组
arr.ravel()  # 将数组展开为一维数组

arr.flatten()  # 将数组展开为一维数组（返回副本）

arr = np.arange(12).reshape((3, 4))  # 创建一个 3x4 的数组
print(arr.ravel())      # 默认：'C' 顺序
print(arr.ravel('F'))  # FORTRAN 顺序

arr1 = np.array([[1, 2, 3], [4, 5, 6]])  # 创建一个 2x3 的数组
arr2 = np.array([[7, 8, 9], [10, 11, 12]])  # 创建一个 2x3 的数组
print(np.concatenate([arr1, arr2], axis=0))  # 沿行（axis=0）堆叠（垂直堆叠）
print(np.concatenate([arr1, arr2], axis=1))  # 沿列（axis=1）堆叠（水平堆叠）

print(np.vstack((arr1, arr2)))  # 垂直堆叠
print(np.hstack((arr1, arr2)))  # 水平堆叠

arr = rng.standard_normal((5, 2))  # 创建一个 5x2 的标准正态分布数组
first, second, third = np.split(arr, [1, 3])  # 将数组在索引 1 和 3 处拆分
print(f"{first=}")  # 打印第一个拆分结果
print(f"{second=}")  # 打印第二个拆分结果
print(f"{third=}")  # 打印第三个拆分结果

arr = np.arange(6)  # 创建一个包含 0 到 5 的一维数组
arr1 = arr.reshape((3, 2))  # 将数组重塑为 3x2
arr2 = rng.standard_normal((3, 2))  # 创建一个 3x2 的标准正态分布数组
print(np.r_[arr1, arr2])  # 类似于 row_stack
print(np.c_[np.r_[arr1, arr2], arr])  # 将 arr 作为新列连接

arr = np.arange(3)  # 创建一个包含 0 到 2 的一维数组
print(arr.repeat(3))  # 每个元素重复 3 次
print(arr.repeat([2, 3, 4]))  # 每个元素分别重复 2、3、4 次

arr = rng.standard_normal((2, 2))  # 创建一个 2x2 的标准正态分布数组
arr.repeat(2, axis=0) # 沿着行重复

arr = rng.standard_normal((2, 2))  # 创建一个 2x2 的标准正态分布数组
print(np.tile(arr, 2))  # 沿行重复数组两次
print(np.tile(arr, (2, 1)))  # 沿行重复 2 次，沿列重复 1 次
print(np.tile(arr, (3, 2)))  # 沿行重复 3 次，沿列重复 2 次

arr = np.arange(10) * 100  # 创建一个 [0, 100, 200, ..., 900] 的数组
inds = [7, 1, 2, 6]  # 定义索引列表
arr.take(inds)  # 类似于 arr[inds]

arr.put(inds, 42)  # 将索引位置的值设置为 42
print(arr)  # 打印修改后的数组
arr.put(inds, [40, 41, 42, 43])  # 将索引位置的值分别设置为 40、41、42、43
print(arr)  # 打印修改后的数组

arr = np.arange(5)  # 创建一个包含 0 到 4 的一维数组
arr * 4  # 4 被“广播”到所有元素

arr = rng.standard_normal((4, 3))   # 创建一个4x3的标准正态分布的数组
demeaned = arr - arr.mean(0)  #  arr.mean(0)是计算每列的均值
demeaned

arr = rng.standard_normal((4, 3))  # 创建一个 4x3 的标准正态分布数组
row_means = arr.mean(1)  # 计算每行的均值
print(row_means.shape)  # 打印行均值的形状

# 将 row_means 重塑为 (4, 1) 以进行广播
demeaned = arr - row_means.reshape((4, 1))  # 减去行均值
print(demeaned.mean(1))  # 验证每行的均值现在为 0（或接近 0）

arr = np.zeros((4, 4))  # 创建一个 4x4 的全 0 数组
arr_3d = arr[:, np.newaxis, :]  # 在中间添加一个新轴
print(arr_3d.shape)  # 打印新数组的形状

arr_1d = rng.standard_normal(3)  # 创建一个长度为 3 的标准正态分布数组
print(arr_1d[:, np.newaxis])  # 转换为列向量
print(arr_1d[np.newaxis, :])  # 转换为行向量

arr = np.zeros((4, 3))  # 创建一个 4x3 的全 0 数组
arr[:] = 5  # 将所有元素设置为 5
print(arr)  # 打印修改后的数组

col = np.array([1.28, -0.42, 0.44, 1.6])  # 创建一个包含 4 个元素的一维数组
arr[:] = col[:, np.newaxis]  # 将 col 广播到 arr 的每一行
print(arr)  # 打印修改后的数组

arr = np.arange(10)  # 创建一个包含 0 到 9 的一维数组
np.add.reduce(arr)  # 类似于 arr.sum()，对数组元素求和

arr = np.arange(15).reshape((3, 5))  # 创建一个 3x5 的数组
np.add.accumulate(arr, axis=1)  # 沿行计算累积和

arr = np.arange(3).repeat([1, 2, 2])  # 创建一个 [0, 1, 1, 2, 2] 的数组
np.multiply.outer(arr, np.arange(5))  # 计算 arr 和 [0, 1, 2, 3, 4] 的外积

arr = np.arange(10)  # 创建一个包含 0 到 9 的一维数组
np.add.reduceat(arr, [0, 5, 8])  # 归约 [0:5]、[5:8]、[8:]

arr = np.multiply.outer(np.arange(4), np.arange(5))  # 计算外积
np.add.reduceat(arr, [0, 2, 4], axis=1) # 沿列归约

import numpy as np  # 导入 NumPy 库

def mean_distance(x, y):  # 定义一个计算平均距离的函数
    nx = len(x)  # 获取 x 的长度
    result = 0.0  # 初始化结果
    count = 0  # 初始化计数器
    for i in range(nx):  # 遍历 x
        result += x[i] - y[i]  # 累加差值
        count += 1  # 计数器加 1
    return result / count  # 返回平均值

import numba as nb  # 导入 Numba 库

numba_mean_distance = nb.jit(mean_distance)  # 使用 jit 装饰器编译 mean_distance 函数

# 或者，使用装饰器：
@nb.jit  # 使用 jit 装饰器
def numba_mean_distance(x, y):  # 定义一个计算平均距离的函数
    nx = len(x)  # 获取 x 的长度
    result = 0.0  # 初始化结果
    count = 0  # 初始化计数器
    for i in range(nx):  # 遍历 x
        result += x[i] - y[i]  # 累加差值
        count += 1  # 计数器加 1
    return result / count  # 返回平均值

from numba import vectorize  # 从 Numba 导入 vectorize 装饰器

@vectorize  # 使用 vectorize 装饰器
def nb_add(x, y):  # 定义一个加法函数
    return x + y  # 返回 x + y

dtype = [('x', np.float64), ('y', np.int32)]  # 字段名称和类型
sarr = np.array([(1.5, 6), (np.pi, -2)], dtype=dtype)  # 创建结构化数组
print(sarr)  # 打印数组
print(sarr[0])  # 打印第一个元素
print(sarr[0]['y'])  # 访问第一个元素的 'y' 字段

dtype = [('x', np.int64, 3), ('y', np.int32)]  # 'x' 是一个包含 3 个 int64 的数组
arr = np.zeros(4, dtype=dtype)  # 创建一个结构化数组
print(arr)  # 打印数组
print(arr[0]['x'])  # 访问第一个元素的 'x' 字段

arr = rng.standard_normal(6)  # 创建一个包含 6 个标准正态分布元素的数组
arr.sort()  # 升序排序
print(arr)  # 打印排序后的数组

arr = rng.standard_normal(5)  # 创建一个包含 5 个标准正态分布元素的数组
print(np.sort(arr))  # 排序副本

arr = rng.standard_normal((3, 5))   # 创建一个3x5的标准正态分布的数组
arr.sort(axis=1)  # 对每一行进行排序
print(arr)  # 打印排序后的数组

values = np.array([5, 0, 1, 3, 2])  # 创建一个一维数组
indexer = values.argsort()  # 获取排序后的索引
print(indexer)  # 打印索引
print(values[indexer])  # 使用索引对数组进行排序

first_name = np.array(['Bob', 'Jane', 'Steve', 'Bill', 'Barbara'])  # 创建一个包含名字的数组
last_name = np.array(['Jones', 'Arnold', 'Arnold', 'Jones', 'Walters'])  # 创建一个包含姓氏的数组
sorter = np.lexsort((first_name, last_name))  # 先按姓氏排序，再按名字排序
print(list(zip(last_name[sorter], first_name[sorter])))  # 打印排序后的姓名

values = np.array(['2:first', '2:second', '1:first', '1:second', '1:third'])  # 创建一个字符串数组
key = np.array([2, 2, 1, 1, 1])  # 创建一个键数组
indexer = key.argsort(kind='mergesort')  # 使用稳定的 mergesort 进行排序
print(values.take(indexer))  # 使用索引对值数组进行排序

rng = np.random.default_rng(12345)  # 创建一个随机数生成器
arr = rng.standard_normal(20)  # 创建一个包含 20 个标准正态分布元素的数组
np.partition(arr, 3)  # 前 3 个是最小的（未排序）

indices = np.argpartition(arr, 3)  # 获取部分排序的索引
arr.take(indices)  # 部分排序

arr = np.array([0, 1, 7, 12, 15])  # 创建一个排序数组
print(arr.searchsorted(9))   # 在哪里插入 9？
print(arr.searchsorted([0, 8, 11, 16]))  # 查找多个值的插入位置

data = np.floor(rng.uniform(0, 10000, size=50))  # 生成 50 个 0 到 10000 之间的随机整数
bins = np.array([0, 100, 1000, 5000, 10000])  # 定义分箱边界
labels = bins.searchsorted(data)  # 对每个数据点进行分箱
print(labels)  # 打印每个数据点所属的箱子标签

mmap = np.memmap('mymmap', dtype='float64', mode='w+',
                 shape=(10000, 10000))  # 创建一个内存映射文件
print(mmap)  # 打印内存映射对象

section = mmap[:5]  # 前 5 行

section[:] = rng.standard_normal((5, 10000))  # 将数据写入切片
mmap.flush()  # 将更改刷新到磁盘

mmap = np.memmap('mymmap', dtype='float64', shape=(10000, 10000))  # 打开现有的内存映射文件
print(mmap)  # 打印内存映射对象

arr_c = np.ones((100, 10000), order='C')  # 创建一个 C 连续数组
arr_f = np.ones((100, 10000), order='F')  # 创建一个 Fortran 连续数组
print(arr_c.flags)  # C_CONTIGUOUS: True, F_CONTIGUOUS: False
print(arr_f.flags)  # C_CONTIGUOUS: False, F_CONTIGUOUS: True

arr_f.copy('C').flags  # 将 Fortran 连续数组复制为 C 连续数组