NumPy 数组与数据类型

import numpy as np
import time

# 准备测试数据：100 万元素
data = list(range(1_000_000))
arr = np.array(data)

# ====== 方式一：Python 原生循环 ======
start = time.time()
squared = [x ** 2 for x in data]
python_time = time.time() - start
print(f"Python 循环耗时: {python_time:.4f} 秒")

# ====== 方式二：NumPy 向量化 ======
start = time.time()
squared_arr = arr ** 2
numpy_time = time.time() - start
print(f"NumPy 向量化耗时: {numpy_time:.4f} 秒")
print(f"性能提升倍数: {python_time / numpy_time:.0f}x")

Python 循环耗时: 0.0850 秒
NumPy 向量化耗时: 0.0012 秒
性能提升倍数: 71x

import numpy as np

# 二维数组演示轴的含义
matrix = np.array([
    [1, 2, 3],
    [4, 5, 6],
])

print("原始数组:\n", matrix)
print("沿 axis=0 求和（每列求和）:", matrix.sum(axis=0))  # [5 7 9]
print("沿 axis=1 求和（每行求和）:", matrix.sum(axis=1))  # [6 15]

import numpy as np

# 创建一个示例数组：3 行 4 列的矩阵
arr = np.array([
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
])

print("数组内容:\n", arr)
print("shape （形状）:", arr.shape)     # (3, 4) — 3 行 4 列
print("ndim  （维度数）:", arr.ndim)     # 2 — 二维数组
print("size  （元素总数）:", arr.size)   # 12 — 3 × 4 = 12
print("dtype （数据类型）:", arr.dtype)   # int32 或 int64（取决于系统）
print("itemsize（每个元素字节数）:", arr.itemsize)  # 4 或 8
print("nbytes （总字节数）:", arr.nbytes)          # 48 或 96

import numpy as np

# 场景：模型输入要求浮点型，但原始数据是整数
raw_data = np.array([[1, 2, 3], [4, 5, 6]])
print("原始类型:", raw_data.dtype)   # int32 或 int64

# 转换为 float64
float_data = raw_data.astype(np.float64)
print("转换后类型:", float_data.dtype)  # float64

# 原数组未受影响
print("原数组仍为:", raw_data.dtype)    # 不变

# 实际业务场景：图像归一化（uint8 → float32，再归一化到 [0, 1]）
image_uint8 = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8)
image_float = image_uint8.astype(np.float32) / 255.0
print("归一化后范围:", image_float.min(), "~", image_float.max())  # 0.0 ~ 1.0

import numpy as np

# 全整数 → int32 或 int64（取决于平台）
print(np.array([1, 2, 3]).dtype)           # int32 或 int64

# 包含浮点数 → 自动提升为 float64
print(np.array([1, 2.5, 3]).dtype)         # float64

# 混合整数和布尔值 → 整数
print(np.array([True, False, 3]).dtype)    # int32 或 int64

# 显式指定 dtype（推荐）
arr = np.array([1, 2, 3], dtype=np.float32)
print(arr.dtype)                            # float32

import numpy as np

# 定义结构化 dtype：模拟成绩单
grade_dtype = np.dtype([
    ('name', 'U20'),    # 姓名：最长 20 字符的 Unicode 字符串
    ('age', 'i4'),      # 年龄：4 字节有符号整数（int32）
    ('chinese', 'f4'),  # 语文：4 字节浮点（float32）
    ('math', 'f4'),     # 数学：4 字节浮点
    ('english', 'f4'),  # 英语：4 字节浮点
])

# 创建结构化数组
grades = np.array([
    ("张三", 15, 86.0, 90.0, 85.0),
    ("李四", 16, 92.0, 78.0, 88.0),
    ("王五", 15, 75.0, 95.0, 82.0),
], dtype=grade_dtype)

print(grades)
# [('张三', 15, 86., 90., 85.) ('李四', 16, 92., 78., 88.) ('王五', 15, 75., 95., 82.)]

# 按字段名访问（类似 Pandas 的列名）
print("所有姓名:", grades['name'])            # ['张三' '李四' '王五']
print("数学平均分:", grades['math'].mean())   # 87.666...

# 按条件筛选
high_math = grades[grades['math'] >= 85]
print("数学 >= 85 分的同学:\n", high_math)

import numpy as np

# 场景：神经网络中的参数初始化
batch_size, features = 128, 512

# 全零初始化（如梯度累加器）
grad_accumulator = np.zeros((features,))
print("梯度累加器 shape:", grad_accumulator.shape)  # (512,)

# 全一初始化（如偏置项）
bias = np.ones((features,))
print("偏置项 shape:", bias.shape)                  # (512,)

# 预分配内存（稍后填入数据）
buffer = np.empty((batch_size, features), dtype=np.float32)
print("预分配 buffer shape:", buffer.shape)         # (128, 512)

# 单位矩阵（线性变换的初始状态）
identity_matrix = np.eye(3)
print("单位矩阵:\n", identity_matrix)

import numpy as np

# ========== 演示三种方式的差异 ==========
original = np.array([1, 2, 3, 4, 5])

# 方式一：np.array —— 深拷贝
arr_from_array = np.array(original)

# 方式二：np.asarray —— 视图（不复制）
arr_from_asarray = np.asarray(original)

# 方式三：np.copy —— 深拷贝
arr_from_copy = np.copy(original)

# 修改原数组
original[0] = 999

print("修改原数组后:")
print("np.array 结果:  ", arr_from_array)    # [1 2 3 4 5] — 不受影响
print("np.asarray 结果:", arr_from_asarray)   # [999  2  3  4  5] — 被影响了！
print("np.copy 结果:   ", arr_from_copy)      # [1 2 3 4 5] — 不受影响

import numpy as np

# ====== linspace：指定元素个数，包含终点 ======
# 场景：在 [0, 2π] 之间取 100 个点画正弦曲线
x = np.linspace(0, 2 * np.pi, 100)
print("linspace 首尾:", x[0], "...", x[-1])  # 0.0 ... 6.283185307179586（≈2π）

# ====== arange：指定步长，不含终点 ======
# 场景：生成 0 到 99 的整数序列
y = np.arange(0, 100, 5)
print("arange 结果:", y)  # [ 0  5 10 ... 95]（注意：没有 100）

# ====== 经典陷阱演示 ======
# 目标：生成 [0.0, 0.1, 0.2, ..., 1.0]
trap_arange = np.arange(0, 1.1, 0.1)
print("\narange 尝试:", trap_arange)
# 可能输出：[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]
# 但由于浮点精度问题，最后一个值可能不是 1.0！

# 正确做法：用 linspace
correct = np.linspace(0, 1, 11)
print("linspace 正确:", correct)
# [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ] — 精确可控

import numpy as np

# 推荐：使用新版 Generator API（NumPy 1.17+）
rng = np.random.default_rng(seed=42)  # 设置种子保证可复现

# 场景一：模拟班级期末考试成绩（正态分布）
# 假设均分 75 分，标准差 12 分，50 名学生
scores = rng.normal(loc=75, scale=12, size=50)
scores = np.clip(scores, 0, 100)  # 截断到 0-100 分
print(f"成绩统计: 均值={scores.mean():.1f}, 标准差={scores.std():.1f}")
# 成绩统计: 均值=74.x, 标准差=11.x

# 场景二：图像像素噪声（均匀分布）
# 给图像添加 [-10, 10] 范围内的随机噪声
image = np.ones((100, 100), dtype=np.float32) * 128
noise = rng.uniform(-10, 10, image.shape).astype(np.float32)
noisy_image = image + noise
print(f"加噪后范围: [{noisy_image.min():.1f}, {noisy_image.max():.1f}]")

# 场景三：神经网络权重初始化（标准正态分布）
weights = rng.standard_normal((256, 128)) * np.sqrt(2.0 / 256)  # He 初始化
print(f"权重形状: {weights.shape}, 权重均值: {weights.mean():.6f}")

# 场景四：随机打乱数据集索引
indices = rng.permutation(1000)  # 0-999 的随机排列
train_idx, val_idx = indices[:800], indices[800:]
print(f"训练集: {len(train_idx)} 条, 验证集: {len(val_idx)} 条")

import numpy as np

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

# 切片操作返回的是【视图】，不是副本
sub_arr = arr[:2, :2]  # 取前两行前两列

print("子数组:\n", sub_arr)
# [[1 2]
#  [5 6]]

# 修改视图会影响原数组！
sub_arr[0, 0] = 999
print("修改视图后的原数组:\n", arr)
# [[999   2   3   4]
#  [  5   6   7   8]
#  [  9  10  11  12]]

import numpy as np

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

# 切片 → 视图
view = arr[1:4]
print("切片是否拥有自己的数据:", view.base is not None)  # True（是视图）

# fancy indexing → 副本
copy = arr[[0, 2, 4]]
print("花式索引是否拥有自己的数据:", copy.base is None)  # True（是副本）

# 布尔索引 → 副本
mask = arr > 2
bool_copy = arr[mask]
print("布尔索引是否拥有自己的数据:", bool_copy.base is None)  # True（是副本）

# 显式复制
explicit_copy = arr[[1, 2, 3]].copy()
print("显式复制是否拥有自己的数据:", explicit_copy.base is None)  # True

import numpy as np

def normalize(data):
    """❌ 危险：函数内部修改了传入的数组"""
    data = np.asarray(data)       # 如果 data 已经是 ndarray，这里不复制
    data -= data.mean()           # 这一步修改了调用者的原数组！
    data /= data.std()
    return data

# 调用
original = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
result = normalize(original)
print("原数组被破坏了:", original)
# 原数组被破坏了: [-1.26 ...  0.63 ...] — 不再是 [1. 2. 3. 4. 5.]

# ✅ 安全版本
def normalize_safe(data):
    data = np.array(data, dtype=float, copy=True)  # 强制复制
    data -= data.mean()
    data /= data.std()
    return data

import numpy as np

# uint8 范围是 0-255，溢出后回绕
arr = np.array([250, 255], dtype=np.uint8)
result = arr + 10
print(result)  # [4 9] — 不是 [260 265]！

# 安全做法：先提升类型
result_safe = arr.astype(np.uint16) + 10
print(result_safe)  # [260 265] ✓