NumPy

import numpy as np

arr = np.array([1, 2, 3, 4, 5])
arr.ndim, arr.shape, arr.size, arr.dtype   # 输出: (1, (5,), 5, dtype('int32'))
arr + 10, arr * 2, arr ** 2                # 输出: [11 12 13 14 15] [ 2  4  6  8 10] [ 1  4  9 16 25]
arr.sum(), arr.mean(), arr.max(), arr.std()# 输出: 15  3.0  5  1.414...
arr[arr > 3]                               # 输出: [4 5]（布尔索引）
m = np.array([[1, 2, 3], [4, 5, 6]])
m[1, 2], m.shape, m.T.shape                # 输出: 6  (2, 3)  (3, 2)
m.sum(axis=0), m.sum(axis=1)               # 输出: [5 7 9]  [ 6 15]

import numpy as np
import time

n = 2_000_000
py_list = list(range(n))
arr = np.arange(n)

t0 = time.perf_counter(); _ = [x * 2 + 1 for x in py_list]; t_list = time.perf_counter() - t0
t0 = time.perf_counter(); res = arr * 2 + 1;              t_np   = time.perf_counter() - t0

np.__version__                       # 输出: '2.x.x'
arr.dtype, arr.nbytes                # 输出: (dtype('int64'), 16000000)；Windows 常为 int32 → 8000000
np.array([1, 2, 3]).dtype            # 输出: dtype('int64')（跨平台代码请显式写 dtype）
round(t_list / t_np, 1)              # 输出: 约 10（本机实测；随机器浮动，但 t_np 恒更小）
res[:5]                              # 输出: [1 3 5 7 9]

import numpy as np

names = np.array(['赵一', '钱二', '孙三', '李四', '周五',
                  '吴六', '郑七', '王八', '冯九', '陈十'])
scores = np.array([72, 88, 55, 91, 64, 79, 83, 47, 95, 68])

scores.mean(), np.median(scores), round(scores.std(), 2)   # 输出: 74.2  75.5  15.04
(scores >= 60).mean() * 100                                # 输出: 80.0（及格率，布尔当 0/1 求均值）
(scores >= 90).sum(), (scores < 60).sum()                  # 输出: 2  2（优秀 / 不及格人数）
np.percentile(scores, [25, 75])                            # 输出: [65.   86.75]（四分位）

order = scores.argsort()[::-1]                             # 输出: [8 3 1 6 5 0 9 4 2 7]（降序下标）
names[order[:3]], scores[order[:3]]                        # 输出: (['冯九' '李四' '钱二'], [95 91 88])
names[scores < 60]                                         # 输出: ['孙三' '王八']（不及格名单）
scores[scores > scores.mean()]                             # 输出: [88 91 79 83 95]（高于均分的成绩）

import numpy as np

a = np.array([10, 20, 30, 40, 50])
a[0], a[-1]                       # 输出: 10  50
a[1:4], a[::2], a[::-1]           # 输出: [20 30 40]  [10 30 50]  [50 40 30 20 10]
a[1:3] = [200, 300]               # 切片赋值就地生效

m = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
m[1, 3]                           # 输出: 8（推荐写法，等价于 m[1][3] 但更快）
m[0], m[0, :]                     # 输出: [1 2 3 4]（整行）
m[:, 0]                           # 输出: [1 5 9]（整列）
m[:2, 1:3]                        # 输出: [[2 3] [6 7]]（子矩阵）
m[:, 0] = [1, 2, 3]               # 整列赋值

t = np.arange(24).reshape(2, 3, 4)
t[1, 2, 3]                        # 输出: 23
t[0]                              # 输出: shape (3, 4) 的整块
t[:, 0, 0]                        # 输出: [ 0 12]（所有块的同一位置）

import numpy as np

m = np.array([[1, 2, 3],
              [4, 5, 6]])         # shape (2, 3)
m.sum()                           # 输出: 21（不指定 axis = 全展平）
m.sum(axis=0)                     # 输出: [5 7 9]  shape (3,)  折叠"行" → 每列一个值
m.sum(axis=1)                     # 输出: [ 6 15]  shape (2,)  折叠"列" → 每行一个值

t = np.arange(24).reshape(2, 3, 4)
t.sum(axis=0).shape               # 输出: (3, 4)
t.sum(axis=1).shape               # 输出: (2, 4)
t.sum(axis=2).shape               # 输出: (2, 3)
t.sum(axis=-1).shape              # 输出: (2, 3)（-1 = 最后一维）
t.mean(axis=(0, 1)).shape         # 输出: (4,)（多轴同时折叠）

import numpy as np

np.array([1, 2, 3], dtype=np.float32).dtype        # 输出: float32
np.array([1.9, 2.5, 3.1]).astype(np.int32)         # 输出: [1 2 3]（截断，非四舍五入！）
np.array(['1', '2', '3']).astype(np.int32)         # 输出: [1 2 3]
np.array([True, False]).astype(np.int32)           # 输出: [1 0]
a8 = np.array([100], dtype=np.int8)
a8 + a8                                  # 输出: [-56] ← 数组间运算静默环绕，无警告
np.array([200], dtype=np.int16) + 100     # 输出: [300]
# np.array([200], dtype=np.int8)         # NumPy 2 起抛 OverflowError：200 装不进 int8

import numpy as np

a = np.array([1, 2, 3, 4, 5]); b = np.array([10, 20, 30, 40, 50])
a + b, a * b, b / a, a ** 2, a % 2    # 逐元素；输出: [11 22 33 44 55] [10 40 90 160 250] ...
np.sqrt(a), np.exp(a), np.log(a)      # 通用函数 ufunc，逐元素
a @ a                                 # 输出: 55（内积；二维数组 @ 才是矩阵乘法）
(a > 3), (a == 3), (a > 2) & (a < 5)  # 输出布尔数组；务必用 & | ~，不用 and/or/not

m = np.array([[1, 2, 3], [4, 5, 6]])
m + np.array([10, 20, 30])            # 输出: [[11 22 33] [14 25 36]]（行向量广播到每行）
m + np.array([[10], [20]])            # 输出: [[11 12 13] [24 25 26]]（列向量广播到每列）

import numpy as np

a = np.array([1, 2, 3])
# a.append(4)                          # AttributeError：ndarray 没有 append
np.append(a, 4)                        # 输出: [1 2 3 4]，但返回新数组（整块复制，很慢）
np.concatenate([a, np.array([5, 6])])  # 输出: [1 2 3 5 6]；批量追加才用它

v = a[1:3]; v[0] = 99                  # 切片是视图！a 变成 [1 99 3]
c = a[1:3].copy(); c[0] = 7            # 原数组不变
np.array_equal(a, b)                   # 判等；if (a == b) 会抛 "ambiguous"
(a == b).all()                         # 等价写法

import numpy as np

img = np.array([[[255, 0, 0], [0, 255, 0], [0, 0, 255], [255, 255, 255]],
                [[0, 0, 0], [128, 128, 128], [200, 100, 50], [30, 60, 90]],
                [[255, 255, 0], [0, 255, 255], [255, 0, 255], [10, 20, 30]],
                [[100, 100, 100], [150, 50, 200], [80, 160, 40], [220, 220, 20]]],
               dtype=np.uint8)

img.shape, img.dtype, img[0, 0]          # 输出: (4, 4, 3)  uint8  [255   0   0]（一个像素的 RGB）
img[:, :, 0]                             # 输出: R 通道，shape (4, 4)
gray = img.mean(axis=2)                  # 输出: shape (4, 4) 的 float64：[[ 85. 85. 85. 255.] ...]
gray_u8 = gray.round().astype(np.uint8)  # 输出: [[85 85 85 255] [0 128 117 60] [170 170 170 20] [100 133 93 153]]
binary = np.where(gray > 127, 255, 0).astype(np.uint8)   # 输出: 4×4 的 0/255 二值图
(binary > 0).mean()                      # 输出: 0.4375（前景像素占比）
255 - gray_u8                            # 输出: 反色图，uint8 内不会溢出；先 astype 再算更安全

import numpy as np

sales = np.array([[100, 120, 80, 90],     # 周一
                  [110, 130, 85, 95],     # 周二
                  [120, 125, 90, 100],    # 周三
                  [130, 140, 95, 105],    # 周四
                  [125, 135, 92, 102],    # 周五
                  [140, 150, 100, 110],   # 周六
                  [150, 160, 105, 115]])  # 周日   shape (7, 4)

sales.sum(axis=1)                          # 输出: [390 420 435 470 454 500 530]（每天总销量）
sales.sum(axis=0)                          # 输出: [875 960 647 717]（每个产品周销量）
sales.mean(axis=0).round(1)                # 输出: [125.  137.1  92.4 102.4]（产品日均）
sales.argmax(axis=0) + 1                   # 输出: [7 7 7 7]（各产品销量最高的天）
sales.max(axis=0) - sales.min(axis=0)      # 输出: [50 40 25 25]（各产品周内波动幅度）
(sales > 100).all(axis=1)                  # 输出: [F F F F F F T]（当天所有产品都 >100）
np.where((sales > 100).all(axis=1))[0] + 1 # 输出: [7]（满足条件的天号）

import numpy as np

points = np.array([[0, 0], [1, 1], [3, 4], [5, 2]])   # 4 个已知点，shape (4, 2)
query = np.array([[0, 1], [4, 4]])                    # 2 个查询点，shape (2, 2)

diff = query[:, None, :] - points[None, :, :]   # 广播：shape (2, 4, 2)，每个查询点对每个已知点的坐标差
dist = np.sqrt((diff ** 2).sum(axis=-1))        # 输出: shape (2, 4)：[[1. 1. 4.243 5.099] [5.657 4.243 1. 2.236]]
np.linalg.norm(diff, axis=-1)                   # 等价写法，省掉手动 sqrt
dist.argmin(axis=1)                             # 输出: [0 2]（每个查询点的最近邻下标）
dist.min(axis=1)                                # 输出: [1. 1.]（最近距离）
points[dist.argmin(axis=1)]                     # 输出: [[0 0] [3 4]]（最近邻坐标）

import numpy as np

np.array([1, 2, 3])                     # 输出: [1 2 3]
# np.array([[1, 2], [3, 4, 5]])          # ✗ NumPy ≥1.24 抛 ValueError（子列表长度不齐）
np.array([[1, 2], [3, 4, 5]], dtype=object)  # 显式 object 才能建：向量化失效，尽量别用
np.array([[1, 2, 0], [3, 4, 5]])        # 正确：补齐长度
np.array([1.5, 2.7], dtype=int)         # 输出: [1 2]（截断）
np.array(range(10))                     # 输出: [0 1 ... 9]（range 也可直接喂）
np.asarray(existing_arr)                # 已是 ndarray 时不复制，性能更好

import numpy as np

np.zeros((3, 4))                        # 默认 float64；np.zeros(5, dtype=int) → 整型
np.ones((2, 3), dtype=np.int8)
np.empty((2, 3))                        # 未初始化，内容是内存垃圾
np.full((3, 4), 3.14)
np.zeros_like(a)                        # 同 shape/dtype
np.zeros_like(a, dtype=float)           # 同 shape，改 dtype（整型模板做归一化时必用）
np.full_like(a, 99)

import numpy as np

np.arange(10)                           # 输出: [0 1 ... 9]
np.arange(5, 10)                        # 输出: [5 6 7 8 9]
np.arange(0, 10, 2)                     # 输出: [0 2 4 6 8]
np.arange(10, 0, -1)                    # 输出: [10 9 ... 1]（递减）
np.arange(0, 1, 0.3)                    # 输出: [0.  0.3 0.6 0.9]  浮点步长有精度误差
np.linspace(0, 10, 5)                   # 输出: [ 0.   2.5  5.   7.5 10. ]  含终点
np.linspace(0, 10, 5, endpoint=False)   # 输出: [0. 2. 4. 6. 8.]
np.linspace(0, 1, 5, retstep=True)      # 输出: (array([0., .25, .5, .75, 1.]), 0.25)
np.logspace(0, 3, 4)                    # 输出: [   1.   10.  100. 1000.]
np.logspace(-3, 0, 4, base=2)           # 输出: 2^-3 → 2^0 等比
np.geomspace(1, 1000, 4)                # 输出: [   1.   10.  100. 1000.]

import numpy as np

np.eye(3)                               # 3×3 单位阵
np.eye(3, 4)                            # 非方阵，对角线为 1
np.eye(4, k=1)                          # 对角线上移一位（k=-1 下移）
np.identity(3)                          # 仅方阵，等价于 np.eye(3)
np.diag([1, 2, 3])                      # 一维 → 对角阵
np.diag(np.array([[1,2,3],[4,5,6],[7,8,9]]))   # 输出: [1 5 9]  二维 → 提取对角线
np.diag([1, 2, 3], k=1)                 # 上对角（4×4）

import numpy as np

rng = np.random.default_rng(seed=42)    # 显式生成器，替代全局 np.random.seed
rng.random((3, 4))                      # [0,1) 均匀分布
rng.uniform(-1, 1, size=5)              # 指定区间均匀分布
rng.integers(0, 10, size=(3, 4))        # 随机整数，[low, high) 左闭右开
rng.normal(loc=0, scale=1, size=5)      # 正态；rng.standard_normal(5) 即标准正态
rng.standard_normal((2, 3))             # 标准正态（替代旧的 randn）
rng.choice([1, 2, 3], size=10, p=[0.5, 0.3, 0.2])   # 按概率抽样
rng.choice(10, size=3, replace=False)   # 无放回抽样
rng.shuffle(arr)                        # 原地打乱（只打乱第 0 维），无返回值
rng.permutation(10)                     # 返回新排列，不改原数组
rng.binomial(n=10, p=0.5, size=5)       # 二项
rng.poisson(lam=5, size=5)              # 泊松（计数事件）
rng.exponential(scale=2.0, size=5)      # 指数（等待时间）
rng.beta(a=2, b=5, size=5); rng.gamma(2.0, 2.0, 5); rng.chisquare(df=5, size=5)

import numpy as np
rng = np.random.default_rng(42)

# 同步打乱 X 与 y
idx = rng.permutation(len(X)); X, y = X[idx], y[idx]

# 按权重初始化（He / Xavier）
he = rng.standard_normal((n_in, n_out)) * np.sqrt(2.0 / n_in)
xavier = rng.standard_normal((n_in, n_out)) * np.sqrt(2.0 / (n_in + n_out))

# 加噪声 + 裁剪
noisy = np.clip(signal + rng.normal(0, 0.1, signal.shape), 0, 1)

import numpy as np

np.loadtxt('d.csv', delimiter=',', skiprows=1, usecols=(1, 2), dtype=float)
np.genfromtxt('d.csv', delimiter=',', filling_values=0)      # 缺值填 0；默认填 nan
np.savetxt('out.csv', arr, delimiter=',', fmt='%.3f', header='a,b', comments='')
np.save('a.npy', arr); np.load('a.npy')                      # 单数组二进制，最快
np.savez('m.npz', w=W, b=b)                                  # 多数组（未压缩）
np.savez_compressed('m.npz', w=W, b=b)                       # 多数组（压缩）
d = np.load('m.npz'); d['w']; list(d.keys())                 # 惰性加载，用完 d.close()

import numpy as np

a = np.arange(6)
b = a                    # 赋值：同一对象（b is a → True）
v = a[1:4]               # 视图：切片、reshape、ravel、transpose、T 都可能返回视图
c = a.copy()             # 副本：独立内存

v[0] = 99                # a 被改 → [0 99 2 3 4 5]
c[0] = 99                # a 不变
v.base is a              # 输出: True
c.base is None           # 输出: True
np.shares_memory(a, v)   # 输出: True（最可靠的判定方式）

import numpy as np

x = np.linspace(-5, 5, 10); y = np.linspace(-5, 5, 10)
X, Y = np.meshgrid(x, y)                # 输出: 均为 (10, 10)，X 按行铺、Y 按列铺
Z = X**2 + Y**2                         # 二维函数直接算
oy, ox = np.ogrid[0:100, 0:100]         # 稀疏网格，形状 (100,1) 与 (1,100)，省内存
np.indices((3, 3))                      # 输出: shape (2,3,3)，[0] 行索引、[1] 列索引
np.fromfunction(lambda i, j: (i+1)*(j+1), (9, 9), dtype=int)   # 九九乘法表
np.outer(np.arange(1, 10), np.arange(1, 10))                   # 同上，更快

np.tile([1, 2, 3], 3)                   # 输出: [1 2 3 1 2 3 1 2 3]（整体平铺）
np.repeat([1, 2, 3], 3)                 # 输出: [1 1 1 2 2 2 3 3 3]（逐元素重复）
np.repeat([1, 2, 3], [2, 3, 4])         # 输出: [1 1 2 2 2 3 3 3 3]

np.concatenate([a, b], axis=0)          # 沿已有轴拼接（要求其余维度一致）
np.vstack([a, b]) / np.hstack([a, b])   # 纵向 / 横向（更直观）
np.stack([a, b], axis=0)                # 新建维度堆叠，shape 多一维
np.column_stack([x, y])                 # 一维 → (n, 2) 的列矩阵

import numpy as np

rng = np.random.default_rng(42)

for n in (10**3, 10**5, 10**6):
    pts = rng.random((n, 2)) * 2 - 1              # shape (n, 2)，两列分别是 x、y
    inside = (pts ** 2).sum(axis=1) <= 1          # 布尔数组：是否在单位圆内
    round(inside.mean() * 4, 4)                   # 输出: 3.116 → 3.1362 → 3.1446（n 越大越接近 3.1416）

pts = rng.random((2_000_000, 2)) * 2 - 1
pi_est = ((pts ** 2).sum(axis=1) <= 1).mean() * 4
round(pi_est, 4), round(abs(pi_est - np.pi), 5)   # 输出: 3.1406  0.00103（每次运行都在该量级浮动）

import numpy as np

rng = np.random.default_rng(2024)
ret = rng.normal(0.0005, 0.02, size=250)              # 250 个交易日收益率，shape (250,)
price = np.concatenate([[100.0], 100.0 * np.cumprod(1 + ret)])   # 输出: shape (251,)，首日为 100

price[:5].round(2)                                    # 输出: [100.   102.11 105.51 107.98 105.94]
round(price[-1], 2), round(price.max(), 2), round(price.min(), 2)   # 输出: 103.0  121.29  84.01
round(ret.std() * np.sqrt(250), 4)                    # 输出: 0.3098（年化波动率）

peak = np.maximum.accumulate(price)                   # 截至每天的历史最高价，shape (251,)
drawdown = (price - peak) / peak                      # 当前回撤，≤ 0
round(drawdown.min(), 4), drawdown.argmin()           # 输出: -0.3074  213（最大回撤 30.74%，第 213 天）
(price > 100).mean().round(3)                         # 输出: 0.721（收盘价高于起点的天数占比）

import numpy as np

rng = np.random.default_rng(0)
n, d = 200, 4
X = rng.normal(size=(n, d))                       # 输出: shape (200, 4)
w_true = np.array([2.0, -1.0, 0.5, 0.0])
y = X @ w_true + 3.0 + rng.normal(0, 0.3, size=n)  # 输出: shape (200,)，@ 是矩阵乘（不是逐元素）

Xb = np.column_stack([np.ones(n), X])             # 加一列 1 当截距项，shape (200, 5)
idx = rng.permutation(n)                          # 输出: 0~199 的随机排列
train_idx, test_idx = idx[:160], idx[160:]
X_train, y_train = Xb[train_idx], y[train_idx]    # 输出: shape (160, 5) / (160,)
X_test, y_test = Xb[test_idx], y[test_idx]        # 输出: shape (40, 5) / (40,)
np.corrcoef(X[:, 0], y)[0, 1].round(3)            # 输出: 0.871（第一列特征与标签的相关性）

import numpy as np

arr_int = np.array([1, 2, 3, 4, 5])
arr_int.astype(np.float64)               # 输出: [1. 2. 3. 4. 5.]
np.array([1.7, 2.3, 3.9]).astype(np.int32)   # 输出: [1 2 3]（向零截断）
np.array([0, 1, 2]).astype(np.bool_)     # 输出: [False  True  True]
np.array(['1', '2']).astype(np.int32)    # 输出: [1 2]；非数字字符串抛 ValueError
arr_int.astype('float64')                # 字符串写法等价

import numpy as np

a = np.array([3, 1, 4, 1, 5, 9, 2, 6])
a.max(), a.min(), a.argmax(), a.argmin()      # 输出: 9  1  5  1
a.sum(), a.mean(), a.var(), round(a.std(), 3) # 输出: 31  3.875  6.609  2.571
a.cumsum()                                    # 输出: [ 3  4  8  9 14 23 25 31]
np.median(a), np.percentile(a, 25)            # 输出: 3.5  1.75

m = np.array([[1, 2, 3], [4, 5, 6]])
m.sum(), m.sum(axis=0), m.sum(axis=1)         # 输出: 21  [5 7 9]  [ 6 15]
m.argmax()                                    # 输出: 5（展平索引）
np.unravel_index(m.argmax(), m.shape)         # 输出: (1, 2)  ← 还原多维下标，必记
m.argmax(axis=0)                              # 输出: [1 1 1]（每列最大值所在行）

import numpy as np

a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
mask = a > 5                          # 输出: [F F F F F T T T T]
a[mask]                               # 输出: [6 7 8 9]
a[(a > 3) & (a < 7)]                  # 输出: [4 5 6]（与）
a[(a < 3) | (a > 7)]                  # 输出: [1 2 8 9]（或）
a[~(a > 5)]                           # 输出: [1 2 3 4 5]（非）
(a > 5).sum()                         # 输出: 4（True 计数，最常用）
(a > 5).any(), (a > 0).all()          # 输出: True  True

m2 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
m2[m2 > 5]                            # 输出: [6 7 8 9]（二维布尔索引 → 一维）
m2[m2[:, 0] > 3]                      # 输出: [[4 5 6] [7 8 9]]（按行筛选）

a2 = a.copy(); a2[a2 % 2 == 0] = 0    # 输出: [1 0 3 0 5 0 7 0 9]（就地改满足条件的）

import numpy as np

a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
np.where(a > 5)                       # 输出: (array([5, 6, 7, 8]),)  ← 元组，取 [0] 得索引
np.where(a > 5, a, 0)                 # 输出: [0 0 0 0 0 6 7 8 9]   ← 三元：真取 a，假取 0
np.where(a < 4, '小', np.where(a > 6, '大', '中'))   # 输出: 多分类，嵌套

# 异常值替换为正常均值
data = np.array([10, 999, 20, 30, 999, 40])
ok = data < 100
np.where(ok, data, data[ok].mean())   # 输出: [10 25 20 30 25 40]

import numpy as np

a = np.array([3, 1, 4, 1, 5, 9, 2, 6])
a.sort()                              # 原地排序，返回 None
np.sort(a)                            # 返回新数组，原数组不变
np.sort(a)[::-1]                      # 降序（先升后反转）
a.argsort()                           # 输出: 排序后的原始索引 [1 3 6 0 2 4 7 5]
a[a.argsort()]                        # 排序结果
a.argsort()[::-1]                     # 降序排名索引；配合名字数组做排行榜

m = np.array([[3, 1, 4], [1, 5, 9], [2, 6, 5]])
m.sort(axis=1)                        # 每行内排序（原地）；np.sort(m, axis=0) 每列排序

np.unique(np.array([1, 2, 2, 3, 3, 3]))                     # 输出: [1 2 3]
vals, cnts = np.unique(np.array([1,2,2,3]), return_counts=True)   # 输出: [1 2 3]  [1 2 1]
np.unique(x, return_index=True)       # 首次出现下标
np.unique(x, return_inverse=True)     # 逆索引，可用 vals[inv] 重建原数组

np.array([1, 2, 3, 4, 5, 6, 7, 8, 9]).clip(3, 7)   # 输出: [3 3 3 4 5 6 7 7 7]
np.round(np.array([1.234, 2.567]), 2)               # 输出: [1.23 2.57]
np.round(np.array([123, 456]), -2)                  # 输出: [100 500]（负数位 = 整数位）
np.floor([1.7]), np.ceil([1.2]), np.trunc([1.9])    # 输出: [1.] [2.] [1.]

import numpy as np

a = np.arange(6)
a.reshape(2, 3)                       # 返回视图（元素连续时），原数组不变
a.reshape(2, -1)                      # -1 表示自动推断，只能有一个 -1
a.resize(2, 3)                        # 原地改形状，无返回值（用得少）
m = np.arange(6).reshape(2, 3)
m.flatten()                           # 一维副本（改它不影响 m）
m.ravel()                             # 一维，能视图就视图（改它可能影响 m！）
m.T                                   # 转置视图
m.transpose(1, 0)                     # 显式轴重排；3D 用 transpose(2, 0, 1) 做 HWC→CHW

import numpy as np

np.set_printoptions(precision=3, suppress=True)   # 3 位小数 + 禁用科学计数法
np.set_printoptions(threshold=20)                 # 超过 20 个元素就省略中间
np.set_printoptions(edgeitems=3, linewidth=120)   # 省略时保留的首尾个数 / 行宽
np.set_printoptions()                             # 恢复默认
np.info(np.ndarray.reshape)                       # 查看签名的简要文档

import numpy as np

heights = np.array([1.75, 1.80, 1.65, 1.70, 1.78, 1.68, 1.82])
weights = np.array([70, 85, 55, 90, 75, 60, 95])

bmi = weights / heights ** 2                       # 输出: [22.9 26.2 20.2 31.1 23.7 21.3 28.7]
category = np.where(bmi < 18.5, '偏瘦',
                    np.where(bmi < 24, '正常',
                             np.where(bmi < 28, '偏胖', '肥胖')))
category                                           # 输出: ['正常' '偏胖' '正常' '肥胖' '正常' '正常' '肥胖']
np.unique(category, return_counts=True)            # 输出: (['偏胖' '正常' '肥胖'], [1 4 2])
np.where((bmi < 18.5) | (bmi >= 28))[0] + 1        # 输出: [4 7]（需要关注的人员编号）
heights[category == '肥胖'].round(2), bmi[category == '肥胖'].round(1)   # 输出: [1.7  1.82]  [31.1 28.7]
round(bmi.mean(), 2)                               # 输出: 24.86（整体均值）

import numpy as np

scores = np.array([85, 92, 78, 91, 68, 74, 88, 55, 95, 82, 79, 90])

rank = (-scores).argsort().argsort() + 1   # 输出: [ 6  2  9  3 11 10  5 12  1  7  8  4]（1 = 最高分）
top3 = scores.argsort()[::-1][:3]          # 输出: [8 1 3]（前三名的下标）
scores[top3]                               # 输出: [95 92 91]
np.sort(scores)[::-1][:3]                  # 输出: [95 92 91]（只要分数、不要下标时的简写）
np.percentile(scores, [25, 50, 75])        # 输出: [77.   83.5  90.25]
np.histogram(scores, bins=[0, 60, 70, 80, 90, 101])[0]   # 输出: [1 1 3 3 4]（<60 / 60-69 / 70-79 / 80-89 / 90+）
(scores >= scores.mean()).sum()            # 输出: 7（达到均分的人数）

import numpy as np

data = np.array([23.5, 25.1, 24.8, 26.2, 23.9, 25.5, 24.1, 60.0, 22.8, 25.9])
z = (data - data.mean()) / data.std()
z.round(2)                                     # 输出: [-0.44 -0.29 -0.32 -0.19 -0.4 -0.25 -0.38 2.99 -0.5 -0.21]

outlier = np.abs(z) > 2                        # 输出: 只有下标 7（值 60.0）为 True
np.where(outlier)[0], data[outlier]            # 输出: [7]  [60.]
clean = np.where(outlier, data[~outlier].mean(), data)   # 用正常值均值 24.64 替换
zc = (clean - clean.mean()) / clean.std()
zc.round(2)                                    # 输出: [-1.12  0.44  0.15  1.52 -0.73  0.83 -0.53  0.  -1.8   1.22]
np.abs(zc).max().round(2)                      # 输出: 1.8（清洗后没有超过 2σ 的点）
np.clip(data, *np.percentile(data, [5, 95]))   # 缩尾替代方案：把超界值压到 5%/95% 分位，60.0 → 44.79

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

arr[2]        # 2
arr[-1]       # 9，负索引从 -1 开始
arr[2:5]      # [2 3 4]，左闭右开
arr[:3]       # [0 1 2]
arr[5:]       # [5 6 7 8 9]
arr[::2]      # [0 2 4 6 8]
arr[1::2]     # [1 3 5 7 9]
arr[::-1]     # [9 8 7 6 5 4 3 2 1 0]，反转
arr[-5:-2]    # [5 6 7]
arr[2:-2]     # [2 3 4 5 6 7]
arr[10:15]    # []，切片越界不报错，返回空
arr[10]       # IndexError

a = np.arange(1, 13).reshape(3, 4)

a[1, 2]      # 7，推荐 [行, 列]；a[1][2] 等价但更慢
a[-1, -1]    # 12
a[0]         # [1 2 3 4]，整行，等价于 a[0, :]
a[:, 0]      # [1 5 9]，整列
a[1:3, 1:3]  # [[6 7], [10 11]]
a[::2, ::2]  # 隔行隔列
a[:, ::-1]   # 列反转
a[0:1, 0:1]  # [[1]]，切片保维度；a[0, 0] 得到标量

a = np.arange(1, 11)
np.where(a > 5, 99, a)          # [1 2 3 4 5 99 99 99 99 99]
np.where(a > 5, 'big', 'small') # 字符串数组
np.where(a > 5)[0]              # [5 6 7 8 9]，单参数形式 = 满足条件的索引
np.where(a > 5, a, -a)          # 等价于把 <=5 的取负

# 多分支嵌套（分段映射）
scores = np.array([85, 92, 78, 65])
np.where(scores >= 90, 'A',
         np.where(scores >= 80, 'B',
                  np.where(scores >= 70, 'C', 'D')))  # ['B' 'A' 'C' 'D']

a = np.array([10, 20, 30, 40, 50, 60])
a[[0, 2, 4]]      # [10 30 50]
a[[0, 0, 2]]      # [10 10 30]，可重复
a[[-1, -2]]       # [60 50]，支持负索引

m = np.arange(1, 17).reshape(4, 4)
m[[0, 2]]                 # 取 0、2 行
m[:, [1, 3]]              # 取 1、3 列
m[[0, 1, 2], [0, 1, 2]]   # [1 6 11]，元素对：等价于 [m[0,0], m[1,1], m[2,2]]
m[[0, 2], :][:, [1, 3]]   # 链式取子矩阵（两次复制）

m = np.arange(1, 17).reshape(4, 4)

m[np.ix_([0, 2], [1, 3])]   # [[2 4], [10 12]]，笛卡尔积取子矩阵
np.ix_([0, 2], [1, 3])      # (array([[0],[2]]), array([[1, 3]]))

np.take(m, [0, 2], axis=0)        # 等价于 m[[0, 2]]，axis 可省（按展平取）
np.take(m, [1, 3], axis=1)        # 取 1、3 列
np.take_along_axis(m, np.array([[0], [1], [2], [3]]), axis=1)  # (4,1) 逐行取指定列

a = np.arange(6)
np.put(a, [0, 2], [99, 88])  # 原地写入，无返回值 → [99 1 88 3 4 5]
a.put([0, 2], [7, 8])        # 方法形式等价

a = np.array([1, 2, 3, 4, 5])
v = a[1:4]; v[0] = 99      # a → [1 99 3 4 5]，视图联动
c = a[[1, 2]].copy(); c[0] = 0   # a 不变

v.base is a       # True，视图的 base 指向源
c.base is None    # True
v.flags.owndata   # False，视图不拥有数据

a = np.arange(12)
i = np.argsort(a)          # 排序索引
a[np.random.permutation(len(a))]        # 打乱
a[np.random.choice(len(a), 5, replace=False)]  # 无放回抽样

m = np.random.randint(0, 256, (10, 10))
np.argwhere(m == 0)        # 满足条件的坐标数组，形状 (n, ndim)
np.unravel_index(np.argmax(m), m.shape)   # 扁平索引 → 多维坐标
np.ravel_multi_index((2, 3), m.shape)     # 多维坐标 → 扁平索引
m[[0, 1, 2], [0, 1, 2]]                   # 主对角线（np.diag 更快）
m[[0, 1], [1, 0]]                         # 副对角线

import numpy as np

rng = np.random.default_rng(0)
img = rng.integers(0, 256, size=(8, 8), dtype=np.uint8)
img[0]                       # 输出: [ 95 130 194 217 207 235  15 163]

# 1. 取区域：切片是视图，改子图会改原图
center = img[2:-2, 2:-2]     # 输出: shape (4, 4)，去掉 2 像素边缘
corner = img[:3, :3]         # 左上角 3×3

# 2. 取边框：四条边拼一维，用 1:-1 避免角点重复计数
border = np.concatenate([img[0, :], img[-1, :], img[1:-1, 0], img[1:-1, -1]])
border.size                  # 输出: 28，等于 8*4-4

# 3. 几何变换全是切片/转置，零拷贝
flip_v = img[::-1, :]        # 上下翻转
flip_h = img[:, ::-1]        # 左右翻转
rot90 = img.T[::-1, :]       # 逆时针 90°：转置后上下翻

# 4. 提亮：uint8 直接加会环绕溢出，必须先升位再 clip
(img[0, :6] + np.uint8(60))                            # 输出: [155 190 254  21  11  39]  ← 溢出
np.clip(img[0, :6].astype(np.int16) + 60, 0, 255)      # 输出: [155 190 254 255 255 255]

# 5. 掩码批量改：过曝像素压成纯白
mask = img > 200
mask.sum()                   # 输出: 14，满足条件的像素数
img[mask] = 255              # 布尔索引赋值是原地写入

# 6. 打码：右下角 3×3 涂黑
img[-3:, -3:] = 0

import numpy as np

rng = np.random.default_rng(42)
temp = rng.uniform(15, 30, size=(7, 24)).round(1)   # (7, 24)

# 1. 按维度切：行=天，列=小时
noon = temp[:, 12]           # 输出: [24.7 16.9 25.  15.3 16.4 23.7 19.2]，每天正午
night = temp[:, :6]          # 输出: shape (7, 6)，每天 0-5 点
workday = temp[:5]           # 前 5 天
temp[::2, ::6]               # 输出: shape (4, 4)，隔天、每 6 小时抽样

# 2. 按行聚合定位极值
daily = temp.mean(axis=1).round(2)
daily                        # 输出: [24.04 22.18 21.79 21.46 22.93 21.79 22.21]
daily.argmax()               # 输出: 0，第 1 天最热
temp[daily.argmax()].max()   # 那天的峰值温度

# 3. 条件定位：布尔数组既能计数也能给坐标
hot = temp > 28
hot.sum()                    # 输出: 14，高温小时数
np.argwhere(hot)[:3]         # 输出: [[ 0  5] [ 0 11] [ 0 22]]，(第几天, 第几小时)
hot.any(axis=1)              # 输出: [ True  True False False  True  True  True]，哪天出现过高温
hot.sum(axis=1)              # 每天的高温小时数

# 4. 数据清洗：低温截断，原地生效
(temp < 18).sum()            # 输出: 35
temp[temp < 18] = 18.0
temp.min()                   # 输出: 18.0

import numpy as np

scores = np.array([[85, 90, 78],    # 学生 0
                   [92, 88, 95],
                   [78, 85, 80],
                   [88, 92, 90],
                   [95, 87, 92]])   # 列：数学 / 英语 / 科学

avg = scores.mean(axis=1).round(2)
avg                            # 输出: [84.33 91.67 81.   90.   91.33]

# 1. 行掩码：一维掩码长度 = 行数，筛出整行
scores[avg >= 90]              # 输出: [[92 88 95] [88 92 90] [95 87 92]]
np.where(avg >= 90)[0]         # 输出: [1 3 4]，对应学号

# 2. 元素级条件 → 坐标，定位"谁的哪门课"不及格
np.argwhere(scores < 80)       # 输出: [[0 2] [2 0]]，(学号, 课程号)
(scores >= 80).all(axis=1)     # 输出: [False  True False  True  True]，全科过线

# 3. 排名：argsort 取负实现降序，再用花式索引重排
total = scores.sum(axis=1)
total                          # 输出: [253 275 243 270 274]
rank = np.argsort(-total)
rank                           # 输出: [1 4 3 0 2]，按总分从高到低的学号
scores[rank][:2]               # 输出: [[92 88 95] [95 87 92]]，前两名整行

# 4. 每人最强科：argmax 给列号，take_along_axis 按列号取值
best = scores.argmax(axis=1)
best                           # 输出: [1 2 1 1 0]
np.take_along_axis(scores, best[:, None], axis=1).ravel()   # 输出: [90 95 85 92 95]

# 5. 补课模拟：先 copy 再改，别动原表
fixed = scores.copy()
fixed[fixed < 80] += 10
fixed[0]                       # 输出: [85 90 88]
scores.mean(axis=0).round(2)   # 输出: [87.6 88.4 87. ]，各科平均分

a = np.arange(12)
a.reshape(3, 4)      # 3×4
a.reshape(2, 2, 3)   # 三维
a.reshape(-1, 4)     # (3, 4)，-1 = 自动推断，只能写一个
a.reshape(3, -1)     # (3, 4)
a.reshape(-1)        # (12,)，常用展平写法
a.reshape(5, -1)     # ValueError：12 不能被 5 整除
a.reshape(-1, -1)    # ValueError：只能有一个 -1

a = np.arange(6).reshape(2, 3)
a.T              # (3, 2)，二维等价于 a.transpose()
a.T.strides      # 只换 stride，不搬数据，所以是视图

b = np.arange(24).reshape(2, 3, 4)
b.transpose()        # (4, 3, 2)，默认反转所有轴
b.transpose(2, 0, 1) # (4, 2, 3)，指定新轴顺序
b.swapaxes(0, 1)     # (3, 2, 4)
b.swapaxes(1, 2)     # (2, 4, 3)

img = np.random.rand(100, 200, 3)
img.transpose(2, 0, 1)              # HWC → CHW，(3, 100, 200)
imgs = np.random.rand(32, 224, 224, 3)
imgs.transpose(0, 3, 1, 2)          # NHWC → NCHW
imgs.swapaxes(1, 3).swapaxes(2, 3)  # 同上，分步交换

a = np.array([1, 2, 3])
np.expand_dims(a, axis=0)   # (1, 3)
np.expand_dims(a, axis=1)   # (3, 1)
np.expand_dims(a, axis=-1)  # (3, 1)
a[np.newaxis, :]            # (1, 3)，索引写法
a[:, None]                  # (3, 1)，None 与 newaxis 等价

c = np.array([[[1, 2, 3]]])   # (1, 1, 3)
np.squeeze(c)                 # (3,)
np.squeeze(c, axis=0)         # (1, 3)
np.squeeze(c, axis=(0, 1))    # (3,)
np.squeeze(np.zeros((2, 2)))  # (2, 2)，无长度为 1 的轴则原样返回

m = np.arange(1_000_000).reshape(1000, 1000)
blocks = m.reshape(10, 100, 10, 100).swapaxes(1, 2)   # (10, 10, 100, 100)
blocks[3, 5].shape       # (100, 100)，与 m[300:400, 500:600] 等价
blocks.sum(axis=(2, 3))  # (10, 10) 每块求和

ts = np.arange(1000); w = 10
idx = np.arange(w) + np.arange(len(ts) - w + 1)[:, None]   # (991, 10)
ts[idx]                  # 滑动窗口矩阵，比循环快得多

x = np.arange(10)
y = x[2:5]
y.base is x        # True
y.flags.owndata    # False

def is_view(src, obj):        # 兼容链式视图
    cur = obj
    while cur.base is not None:
        if cur.base is src:
            return True
        cur = cur.base
    return False

import numpy as np

rng = np.random.default_rng(1)
img = rng.random((32, 32, 3))     # 单张 RGB 图 (H, W, C)

variants = [
    img,                          # 原图
    img[:, ::-1, :],              # 水平翻转（沿宽度反向）
    img[::-1, :, :],              # 垂直翻转（沿高度反向）
    img.transpose(1, 0, 2),       # 对角翻转：只换 H/W，通道不动
    img[:, :, ::-1],              # 通道翻转 RGB → BGR
]
aug = np.stack(variants)                  # 输出: shape (5, 32, 32, 3)，stack 新建轴
aug.transpose(0, 3, 1, 2).shape           # 输出: (5, 3, 32, 32)，NHWC → NCHW
aug.reshape(len(aug), -1).shape           # 输出: (5, 3072)，保批次维展平送全连接层

np.shares_memory(aug, img)                # 输出: False，stack 一定复制
np.allclose(aug[1].mean(), img.mean())    # 输出: True，翻转不改变统计量

# 追加一张到已有批次：concatenate 沿已有轴接，需要先补出批次维
np.concatenate([img[None], aug]).shape    # 输出: (6, 32, 32, 3)

import numpy as np
from numpy.lib.stride_tricks import sliding_window_view

ts = np.arange(1000, dtype=float)     # 1000 个时间步
w = 24                                # 窗口长度

win = sliding_window_view(ts, w)
win.shape                             # 输出: (977, 24)，等于 1000-24+1
np.shares_memory(win, ts)             # 输出: True，视图不占额外内存
win.flags.writeable                   # 输出: False，只读；要改先 .copy()

# 对齐标签：win[i] = ts[i:i+24]，预测目标是 ts[i+24]
X, y = win[:-1], ts[w:]
X.shape, y.shape                      # 输出: ((976, 24), (976,))
X[..., None].shape                    # 输出: (976, 24, 1)，补特征维给 LSTM

# 按 batch 分组：先截成整数倍再 reshape
bs = 32
n = len(X) // bs                      # 输出: 30
X[:n * bs][..., None].reshape(n, bs, w, 1).shape   # 输出: (30, 32, 24, 1)

win.mean(axis=1)[:3]                  # 输出: [11.5 12.5 13.5]，每个窗口均值
win[-1][-1]                           # 输出: 999.0，最后一个窗口覆盖到序列末尾

import numpy as np

gray = np.arange(16, dtype=float).reshape(4, 4)     # 单通道图 (H, W)

# 1. 升维成三通道：先补通道轴，再沿该轴复制
rgb = np.repeat(gray[:, :, None], 3, axis=2)
rgb.shape                                    # 输出: (4, 4, 3)
np.array_equal(rgb, np.stack([gray] * 3, axis=-1))    # 输出: True，两种写法等价

# 2. 三通道转回灰度：末维与权重 (3,) 对齐，矩阵乘直接降维
back = rgb @ np.array([0.299, 0.587, 0.114])
back.shape, np.allclose(back, gray)          # 输出: ((4, 4), True)，权重和为 1

# 3. 补 batch 与 channel 轴喂模型
x = gray[None, ..., None]
x.shape                                      # 输出: (1, 4, 4, 1)
pred = x * 2                                 # 占位：模型前向

# 4. 降维三种写法，注意差别
pred[0, ..., 0].shape                        # 输出: (4, 4)，显式索引最安全
np.squeeze(pred).shape                       # 输出: (4, 4)，batch 和 channel 一起被挤掉
np.squeeze(pred, axis=-1).shape              # 输出: (1, 4, 4)，只去通道，保住批次

a = np.array([1, 2, 3, 4])
b = np.array([10, 20, 30, 40])

a + b        # [11 22 33 44]
a * b        # [10 40 90 160]，元素级
a ** 2       # [1 4 9 16]
a / 2        # [0.5 1. 1.5 2.]，结果转 float
a // 2       # [0 1 1 2]
a + 10       # [11 12 13 14]，标量广播

a > 2                 # [False False  True  True]
(a > 1) & (a < 4)     # [False  True  True False]
np.all(a > 0), np.any(a > 3)   # (True, True)

a += 10               # 原地；a = a + 10 会新建数组

v = np.array([1, 2, 3])
v.shape             # (3,)
v[np.newaxis, :]    # (1, 3) 行向量
v[:, None]          # (3, 1) 列向量
v[None, :, None]    # (1, 3, 1)

v + v[:, None]      # (3, 3) 外积式加法
v.reshape(-1, 1) * v.reshape(1, -1)   # (3, 3) 外积

data = np.arange(12).reshape(4, 3).astype(float)

# 每列中心化：mean 形状 (3,)，天然按行广播
data - data.mean(axis=0)
# 每行中心化：用 keepdims 或 [:, None]
data - data.mean(axis=1, keepdims=True)

# 标准化
(data - data.mean(0)) / data.std(0)

# 距离矩阵（成对欧氏距离）
P = np.array([[0, 0], [1, 1], [2, 2]])
d = np.sqrt(((P[:, None, :] - P[None, :, :]) ** 2).sum(-1))   # (3, 3)

# RGB 通道增益
img = np.random.rand(5, 5, 3)
img * np.array([1.2, 0.8, 1.0])      # (5,5,3)，最后一维对齐

# 加权总分
scores = np.array([[80, 90, 85], [75, 85, 90]])
scores * np.array([0.3, 0.4, 0.3])   # 按列权重