NumPy: 副本与视图

Q: 怎么判断一个操作返回的是视图还是副本？

记住三条核心规则：① 基本切片 → 视图；② 花式索引/布尔索引 → 副本；③ 不确定就用 arr.base is not None 或 np.shares_memory() 检测。

Q: np.shares_memory 和 np.may_share_memory 有什么区别？

shares_memory 精确判断但较慢； may_share_memory 极快但保守——可能误报（说共享但实际不重叠），但不会漏报。用于快速排除：如果 may_share_memory 返回 False，则一定不共享。

Q: 赋值 b = a 是视图还是副本？

都不是。 b = a 让 b 和 a 指向同一个 Python 对象， b is a 为 True。视图是 b is not a 但共享内存。区别： b = a 后 b is a 为 True； b = a[:] 后 b is a 为 False 但共享内存（视图）。

Q: ravel 和 flatten 的区别是什么？

ravel() 在内存连续时返回视图（修改会影响原数组），不连续时返回副本； flatten() 总是返回副本。需要安全副本时用 flatten() ，需要零拷贝时用 ravel() 。

Charlie 修改了子数组，发现原数组也跟着变了，调试了 2 个小时。Alice 说："查 .base 属性——如果 base is 原数组，就是视图。不确定就 .copy()。"

这个故事揭示了一个关键问题：NumPy 中并非所有操作都返回独立的数组。理解视图与副本的区别，是避免隐式数据修改 bug 的基础。

1. 视图机制

(1) 什么是视图

视图（view）是原数组的另一个"窗口"——它共享同一块内存，修改视图会直接修改原数组。

PYTHON

import numpy as np

a = np.array([1, 2, 3, 4, 5])
b = a[1:4]          # 切片返回视图
b[0] = 999
print(a)            # [  1 999   3   4   5]  原数组被修改！
print(b)            # [999   3   4]

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

视图的优势是零拷贝——不占用额外内存，速度极快。

(2) 视图与原数组的内存关系

PYTHON

a = np.array([10, 20, 30])
b = a[:]            # 视图
print(a.__array_interface__['data'][0])  # 原数组数据地址
print(b.__array_interface__['data'][0])  # 视图数据地址（相同！）

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

两者指向同一块内存起始地址，只是元数据（shape、stride 等）不同。

▶ 示例

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

：切片视图验证（难度⭐）

PYTHON

import numpy as np

a = np.arange(6).reshape(2, 3)
b = a[0, :]         # 切片 → 视图

b[:] = [10, 20, 30]
print("a =", a)
# a = [[10 20 30]
#      [ 3  4  5]]

# 修改 b 影响了 a，因为 b 是 a 的视图

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

2. 副本机制

(1) 什么是副本

副本（copy）是原数组的完整独立拷贝——它拥有自己的内存，修改副本不影响原数组。

PYTHON

a = np.array([1, 2, 3])
b = a.copy()        # 显式创建副本
b[0] = 999
print(a)            # [1 2 3]  原数组不受影响
print(b)            # [999   2   3]

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

(2) 副本的内存代价

副本需要分配新内存并复制数据，时间和空间开销与数组大小成正比。

PYTHON

a = np.zeros(1_000_000)
b = a.copy()
print(a.nbytes)     # 8000000 bytes  (8 MB)
print(b.nbytes)     # 8000000 bytes  (8 MB)  额外 8 MB

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

▶ 示例

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

：花式索引副本验证（难度⭐）

PYTHON

import numpy as np

a = np.array([10, 20, 30, 40, 50])
b = a[[0, 2, 4]]    # 花式索引 → 副本

b[0] = 999
print("a =", a)     # [10 20 30 40 50]  原数组不变
print("b =", b)     # [999  30  50]

# 花式索引返回副本，修改 b 不影响 a

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

3. 操作分类：哪些返回视图，哪些返回副本

这是最容易踩坑的地方——不同操作返回不同类型，需要牢记分类。

操作类型	返回类型	示例
基本切片	视图	`a[1:4]`
花式索引（整数数组）	副本	`a[[0,2,4]]`
布尔索引	副本	`a[a > 3]`
标量索引	标量（非视图非副本）	`a[0]`
`.reshape()`	视图（可能）	`a.reshape(2,3)`
`.transpose()` / `.T`	视图	`a.T`
`.ravel()`	视图（可能）	`a.ravel()`
`.flatten()`	副本	`a.flatten()`
`.copy()`	副本	`a.copy()`
`np.squeeze()`	视图	`np.squeeze(a)`
赋值 `b = a`	都不是（同一对象）	`b = a`
算术运算 `a + 1`	副本	`a + 1`

⚠️ 注意： "可能"表示在数据内存连续时返回视图，不连续时返回副本。

(1) 视图 vs 副本操作分类

类别	视图	副本
索引	基本切片	花式索引、布尔索引
形状	reshape、transpose、squeeze、ravel	flatten
显式	—	.copy()
运算	—	算术、比较等产生新数组
赋值	`b = a` 是同一对象引用，既非视图也非副本	—

(2) reshape 的"可能视图"规则

PYTHON

a = np.arange(12)
b = a.reshape(3, 4)    # 连续内存 → 视图

c = a.reshape(3, 4).copy()  # 保证副本
c[0, 0] = 999
print(a[0])             # 0  不受影响

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

非连续数组的 reshape 可能返回副本：

PYTHON

a = np.arange(12).reshape(3, 4)
b = a.T                 # 转置 → 视图（但内存不连续）
c = b.reshape(-1)       # 非连续 reshape → 副本！
c[0] = 999
print(b[0, 0])          # 0  不受影响

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

▶ 示例

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

：操作返回类型检测（难度⭐⭐）

PYTHON

import numpy as np

a = np.arange(8)

# 切片 → 视图
s = a[2:6]
s[0] = 99
print("slice → view, a =", a)  # a 被修改

a[:] = np.arange(8)  # 重置

# 花式索引 → 副本
f = a[[1, 3, 5]]
f[0] = 99
print("fancy → copy, a =", a)  # a 不变

# 布尔索引 → 副本
m = a[a > 3]
m[0] = 99
print("bool → copy, a =", a)   # a 不变

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

4. .base 属性

(1) base 的含义

每个 NumPy 数组都有 .base 属性：

如果数组是视图，.base 指向原始数组
如果数组拥有自己的内存，.base 为 None

PYTHON

a = np.array([1, 2, 3, 4])
b = a[1:3]           # 视图

print(b.base is a)   # True  b 的 base 就是 a
print(a.base)        # None  a 拥有自己的内存

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

(2) base 链追踪

视图的视图仍然可以追溯源头：

PYTHON

a = np.arange(10)
b = a[2:8]           # b 是 a 的视图
c = b[1:4]           # c 是 b 的视图

print(c.base is b)   # True（通常）
print(b.base is a)   # True
# c → b → a 链式追溯

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

▶ 示例

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

：base 追踪（难度⭐⭐）

PYTHON

import numpy as np

a = np.arange(12).reshape(3, 4)
b = a[0, :]           # 切片视图
c = a[[0, 2], :]      # 花式索引副本
d = a.copy()          # 显式副本

print("b.base is a:", b.base is a)    # True
print("c.base is a:", c.base is a)    # False  c.base is None
print("d.base:", d.base)              # None
print("a.base:", a.base)              # None（reshape 可能返回视图，base 追溯到原始数组）

# 安全判断函数
def is_view(arr):
    return arr.base is not None

print("b is view:", is_view(b))  # True
print("c is view:", is_view(c))  # False

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

5. 共享内存检测

(1) np.shares_memory

np.shares_memory(a, b) 精确判断两个数组是否共享内存：

PYTHON

a = np.arange(6)
b = a[1:4]
c = a.copy()

print(np.shares_memory(a, b))   # True
print(np.shares_memory(a, c))   # False

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

(2) np.may_share_memory

np.may_share_memory(a, b) 是保守检查——可能误报（说共享但实际不共享），但不会漏报：

PYTHON

a = np.arange(10)
b = a[::2]             # 视图：取偶数位
c = a[1::2]            # 视图：取奇数位

print(np.shares_memory(a, b))       # True
print(np.shares_memory(b, c))       # False（b 和 c 内存不重叠）
print(np.may_share_memory(b, c))    # True  误报！因为它们共享同一底层缓冲区

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

方法	速度	精确度	用途
`np.shares_memory`	较慢	精确	需要确定答案时
`np.may_share_memory`	极快	保守（可能误报）	快速排除不共享的情况

▶ 示例

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

：shares_memory（难度⭐⭐）

PYTHON

import numpy as np

a = np.arange(20).reshape(4, 5)
b = a[1:3, :]           # 行切片 → 视图
c = a[:, 2:4]           # 列切片 → 视图
d = a[[0, 3]]           # 花式索引 → 副本

print("a & b:", np.shares_memory(a, b))   # True
print("a & c:", np.shares_memory(a, c))   # True
print("b & c:", np.shares_memory(b, c))   # True（b 和 c 有重叠区域）
print("a & d:", np.shares_memory(a, d))   # False

# 检查不重叠的视图
e = a[0:1, :]           # 第 0 行
f = a[3:4, :]           # 第 3 行
print("e & f:", np.shares_memory(e, f))   # False（不重叠）

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

6. .flags 属性

(1) flags 中的关键信息

arr.flags 包含数组的内存布局信息，其中最关键的是 OWNDATA：

PYTHON

a = np.arange(6)
b = a[1:4]
c = a.copy()

print(a.flags['OWNDATA'])   # True   a 拥有数据
print(b.flags['OWNDATA'])   # False  b 是视图，不拥有数据
print(c.flags['OWNDATA'])   # True   c 拥有自己的数据副本

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

(2) 其他 flags 字段

Flag	含义
`OWNDATA`	数组是否拥有自己的内存
`C_CONTIGUOUS`	C 顺序（行优先）内存连续
`F_CONTIGUOUS`	Fortran 顺序（列优先）内存连续
`WRITEABLE`	数组是否可写
`ALIGNED`	数据是否对齐

▶ 示例

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

：flags（难度⭐⭐）

PYTHON

import numpy as np

a = np.arange(12).reshape(3, 4)
b = a.T                # 转置视图
c = a.copy()

print("=== a.flags ===")
print(a.flags)

print("\n=== b.flags ===")
print(b.flags)

print("\n=== c.flags ===")
print(c.flags)

# 关键区别
print("\nowns data?  a:", a.flags['OWNDATA'], " b:", b.flags['OWNDATA'], " c:", c.flags['OWNDATA'])
# owns data?  a: True   b: False   c: True

# 转置视图的 C_CONTIGUOUS 为 False
print("C contiguous?  a:", a.flags['C_CONTIGUOUS'], " b:", b.flags['C_CONTIGUOUS'])
# C contiguous?  a: True   b: False

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

7. 操作分类决策树

graph TB
    Start[操作类型?] --> Index{索引方式?}
    Index -->|基本切片| View1[返回视图]
    Index -->|花式索引<br/>整数数组| Copy1[返回副本]
    Index -->|布尔索引| Copy2[返回副本]
    Index -->|标量索引| Scalar[返回标量]

    Start --> Shape{形状操作?}
    Shape -->|reshape<br/>连续内存| View2[返回视图]
    Shape -->|reshape<br/>非连续内存| Copy3[返回副本]
    Shape -->|transpose / .T| View3[返回视图]
    Shape -->|ravel<br/>连续内存| View4[返回视图]
    Shape -->|flatten| Copy4[返回副本]
    Shape -->|squeeze| View5[返回视图]

    Start --> Explicit{显式操作?}
    Explicit -->|.copy| Copy5[返回副本]
    Explicit -->|赋值 b = a| Ref[同一对象引用]

    Start --> Calc{算术运算?}
    Calc -->|a + 1<br/>a * 2 等| Copy6[返回副本<br/>新数组]

    View1 --> Check[用 .base 或<br/>np.shares_memory 验证]
    Copy1 --> Safe[修改安全<br/>不影响原数组]
    Check --> Confirm{确认是否视图?}
    Confirm -->|是视图| Warn[修改会影响原数组!]
    Confirm -->|是副本| Safe2[修改安全]

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

8. 综合示例：操作链逐步检查

▶ 示例

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

：操作链 base 与 shares_memory 追踪（难度⭐⭐⭐）

PYTHON

import numpy as np

print("=== 操作链：逐步检查 base 和 shares_memory ===\n")

# Step 1: 创建原始数组
a = np.arange(24)
print(f"Step 1 - a = arange(24)")
print(f"  a.base: {a.base}")
print(f"  a.flags.OWNDATA: {a.flags['OWNDATA']}\n")

# Step 2: reshape（连续内存 → 视图）
b = a.reshape(4, 6)
print(f"Step 2 - b = a.reshape(4, 6)")
print(f"  b.base is a: {b.base is a}")
print(f"  shares_memory(a, b): {np.shares_memory(a, b)}")
print(f"  b.flags.OWNDATA: {b.flags['OWNDATA']}\n")

# Step 3: 切片（→ 视图）
c = b[1:3, 2:5]
print(f"Step 3 - c = b[1:3, 2:5]")
print(f"  c.base is b: {c.base is b}")
print(f"  shares_memory(a, c): {np.shares_memory(a, c)}")
print(f"  shares_memory(b, c): {np.shares_memory(b, c)}")
print(f"  c.flags.OWNDATA: {c.flags['OWNDATA']}\n")

# Step 4: 花式索引（→ 副本）
d = c[[0, 1], :]
print(f"Step 4 - d = c[[0, 1], :]")
print(f"  d.base: {d.base}")
print(f"  d.base is c: {d.base is c}")
print(f"  shares_memory(c, d): {np.shares_memory(c, d)}")
print(f"  d.flags.OWNDATA: {d.flags['OWNDATA']}\n")

# Step 5: copy（→ 独立副本）
e = d.copy()
print(f"Step 5 - e = d.copy()")
print(f"  e.base: {e.base}")
print(f"  shares_memory(d, e): {np.shares_memory(d, e)}")
print(f"  e.flags.OWNDATA: {e.flags['OWNDATA']}\n")

# Summary: 修改链验证
print("=== 修改验证 ===")
c[0, 0] = 999
print(f"After c[0,0]=999:")
print(f"  a affected? {999 in a}")    # True（c 是 a 的视图）
print(f"  b affected? {999 in b}")    # True
print(f"  d affected? {999 in d}")    # False（d 是副本）

d[0, 0] = 777
print(f"After d[0,0]=777:")
print(f"  c affected? {777 in c}")    # False
print(f"  e affected? {777 in e}")    # False

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

9. COW 概念

(1) Copy-On-Write 简介

COW（Copy-On-Write，写时复制）是一种延迟复制的优化策略：只有在数据被修改时才真正复制内存。NumPy 本身没有完整的 COW 机制，但理解这个概念有助于理解为什么视图操作是安全的（只要不写）。

PYTHON

a = np.arange(1_000_000)
b = a[:]              # 视图——零拷贝

# 此时 a 和 b 共享内存，没有任何复制开销
# 只有在修改 b 时，才会产生数据分歧

b[0] = 999            # 修改 b，a 也会被修改（因为是视图，非 COW）
print(a[0])           # 999

# 如果要 COW 效果，必须显式 copy
c = a.copy()          # 此时就复制，而非写时复制
c[0] = 888
print(a[0])           # 999  不受影响

TEXT 📖 仅展示

> **输出：** 在本地 Python 环境运行 NumPy 2.x，输出 ndarray 数组内容。Piston 服务器未预装 NumPy，请在本机安装（`pip install numpy`）后实操对照。实际数值可能因 NumPy 版本、随机种子略有差异。

⚠️ 注意： NumPy 的视图不是 COW！修改视图会直接修改原数组。如果需要隔离修改，必须显式调用 .copy()。

❓ 常见问题

Q 怎么判断一个操作返回的是视图还是副本？

A 记住三条核心规则：① 基本切片 → 视图；② 花式索引/布尔索引 → 副本；③ 不确定就用 arr.base is not None 或 np.shares_memory() 检测。

Q transpose / .T 返回视图吗？

A 是的，转置返回视图。修改转置后的数组会影响原数组。但转置后内存不再 C 连续，对它做 reshape 可能返回副本。

Q 什么时候应该主动调用 .copy()？

A 当需要将子数组传递给可能修改数据的函数时；当需要保留原数组快照时；当不确定操作链中是否有视图时。安全做法：函数输入先 copy，避免副作用。

Q np.shares_memory 和 np.may_share_memory 有什么区别？

A shares_memory 精确判断但较慢；may_share_memory 极快但保守——可能误报（说共享但实际不重叠），但不会漏报。用于快速排除：如果 may_share_memory 返回 False，则一定不共享。

Q 赋值 b = a 是视图还是副本？

A 都不是。b = a 让 b 和 a 指向同一个 Python 对象，b is a 为 True。视图是 b is not a 但共享内存。区别：b = a 后 b is a 为 True；b = a[:] 后 b is a 为 False 但共享内存（视图）。

Q ravel 和 flatten 的区别是什么？

A ravel() 在内存连续时返回视图（修改会影响原数组），不连续时返回副本；flatten() 总是返回副本。需要安全副本时用 flatten()，需要零拷贝时用 ravel()。

📖 小节

视图共享内存，修改视图直接影响原数组；副本独立，修改不影响原数组
基本切片 → 视图；花式索引/布尔索引 → 副本
reshape、ravel 在内存连续时返回视图，否则返回副本
flatten、.copy() 总是返回副本
transpose/.T 返回视图，但转置后内存不再 C 连续
.base 属性追溯内存来源：视图的 base 指向原数组，副本的 base 为 None
np.shares_memory() 精确检测内存共享；np.may_share_memory() 快速保守检测
.flags['OWNDATA'] 判断数组是否拥有自己的内存
赋值 b = a 是同一对象引用，既非视图也非副本
不确定时调用 .copy() 是最安全的做法

📝 作业

基础题（难度⭐）：对以下 10 种操作，逐一判断返回视图还是副本，并用 .base 和 np.shares_memory() 验证：① a[1:5] ② a[[0,2,4]] ③ a[a > 3] ④ a.reshape(2,3) ⑤ a.T ⑥ a.flatten() ⑦ a.ravel() ⑧ a.copy() ⑨ a.squeeze() ⑩ a + 1。编写完整代码并输出每个操作的结果。
基础题（难度⭐）：创建两个数组 a 和 b，使用 np.shares_memory() 和 np.may_share_memory() 分别检测以下三组关系：① a 与 a[::2] ② a[::2] 与 a[1::2] ③ a 与 a.copy()。打印结果并解释 may_share_memory 在哪种情况下会误报。
进阶题（难度⭐⭐）：构造一个"视图 bug"场景——创建一个函数 process(data)，它内部修改了传入的子数组切片，导致外部原数组被意外修改。然后通过在函数入口加 .copy() 修复此 bug。写出修改前后的代码和运行结果对比。

Web-Tutorial 技术团队

由多位开发者共同维护的编程教程平台。每篇教程由对应领域的开发者编写和审核，确保内容准确可靠。如发现任何问题，欢迎向我们反馈。

关于我们

NumPy: 副本与视图

1. 视图机制

(1) 什么是视图

(2) 视图与原数组的内存关系

▶ 示例

2. 副本机制

(1) 什么是副本

(2) 副本的内存代价

▶ 示例

3. 操作分类：哪些返回视图，哪些返回副本

(1) 视图 vs 副本操作分类

(2) reshape 的"可能视图"规则

▶ 示例

4. .base 属性

(1) base 的含义

(2) base 链追踪

▶ 示例

5. 共享内存检测

(1) np.shares_memory

(2) np.may_share_memory

▶ 示例

6. .flags 属性

(1) flags 中的关键信息

(2) 其他 flags 字段

▶ 示例

7. 操作分类决策树

8. 综合示例：操作链逐步检查

▶ 示例

9. COW 概念

(1) Copy-On-Write 简介

❓ 常见问题

📖 小节

📝 作业

🙏 帮我们做得更好