操作列表—Wolfram Documentation

操作列表

构建列表	列表的分组和填充
通过索引操作列表	稀疏数组：列表的处理
嵌套列表

构建列表

Wolfram 语言中广泛使用列表，有许多不同的方法可用来构建列表.

Range[n]	列表 {1,2,3,…,n}
Table[expr,{i,n}]	i 从 1 到 n 的 expr 的值
Array[f,n]	列表 {f[1],f[2],…,f[n]}
NestList[f,x,n]	具有 n 个嵌套的{x,f[x],f[f[x]],…}
Normal[SparseArray[{i₁->v₁,…},n]]	长度为 n 的列表，元素 i_k 为 v_k
Apply[List,f[e₁,e₂,…]]	列表 {e₁,e₂,…}

用以构建列表的一些明确方式.

给出以2为幂的前5个值的列表：

Wolfram Language code: Table[2 ^ i, {i, 5}]

取得相同结果的另一种方式：

Wolfram Language code: Array[2 ^ #&, 5]

给出相似的列表：

Wolfram Language code: NestList[2#&, 1, 5]

SparseArray 帮助用户在特定位置指定值：

Wolfram Language code: Normal[SparseArray[{3 -> x, 4 -> y}, 5]]

也可以使用模式来指定值：

Wolfram Language code: Normal[SparseArray[{i_ -> 2 ^ i}, 5]]

通常情况下，用户可以提前知道一个列表应该有多长，并且每个元素应该如何生成. 而且，用户可以从一个列表得到另一个列表.

Table[expr,{i,list}]	当 i 从 list 中取值时， expr 的值
Map[f,list]	对 list 的每个元素应用 f
MapIndexed[f,list]	对于第 i 个元素，给出 f[elem,{i}]
Cases[list,form]	给出与 form 匹配的 list 的元素
Select[list,test]	选出 test[elem] 为 True 的元素
Pick[list,sel,form]	选出 list 的元素，sel 相应的元素与 form 匹配
TakeWhile[list,test]	只要 test[e_i] 是 True，从 list 的开头给出元素 e_i
list[[{i₁,i₂,…}]] or Part[list,{i₁,i₂,…}]
	给出 list 指定部分的列表

从其他列表构建列表.

选出小于5的元素：

Wolfram Language code: Select[{1, 3, 7, 4, 10, 2}, # < 5&]

选出不小于5的第一个元素：

Wolfram Language code: TakeWhile[{1, 3, 7, 4, 10, 2}, # < 5&]

明确给出编号部分：

Wolfram Language code: {a, b, c, d}[[{2, 1, 4}]]

选出第二个列表中 1 所对应的元素：

Wolfram Language code: Pick[{a, b, c, d}, {1, 0, 1, 1}, 1]

有时候，用户可能想要在程序执行过程中积累结果列表. 这可以使用 Sow 和 Reap 实现.

Sow[val]	对于最接近的 Reap，进行值 val 的 sow 操作
Reap[expr]	计算 expr，并返回 Sow 产生的值的列表

使用 Sow 和 Reap.

该程序对一个数进行迭代求平方：

Wolfram Language code: Nest[# ^ 2&, 2, 6]

进行同样的计算，但这里把大于1000的中间结果累积成列表：

Wolfram Language code: Reap[Nest[(If[# > 1000, Sow[#]];# ^ 2)&, 2, 6]]

另一个效率比较低的方法涉及引入一个临时变量，并以 t={} 开始，然后连续使用 AppendTo[t,elem].

通过索引操作列表

Part[list,spec] or list[[spec]]	列表的一个或多个部分
Part[list,spec₁,spec₂,…] or list[[spec₁,spec₂,…]]	嵌套列表的一个或多个部分
n	开头的第 n 个部分
-n	末尾的第 n 个部分
{i₁,i₂,…}	由部分组成的列表
m;;n	第 m 部分到第 n 部分
All	所有部分

获取列表的部分.

给出列表的第一部分和第三部分：

Wolfram Language code: {a, b, c, d}[[{1, 3}]]

一个嵌套列表：

Wolfram Language code: m = {{a, b, c}, {d, e}, {f, g, h}};

给出第一部分和第三部分的列表：

Wolfram Language code: m[[{1, 3}]]

给出每个部分第一子部的列表：

Wolfram Language code: m[[{1, 3}, 1]]

给出前两个部分的列表：

Wolfram Language code: m[[{1, 3}, {1, 2}]]

给出 m 的前两个部分：

Wolfram Language code: m[[1 ;; 2]]

给出相应的最后部分：

Wolfram Language code: m[[1 ;; 2, -1]]

给出所有子列表的第二部分：

Wolfram Language code: m[[All, 2]]

给出所有子列表的最后两个部分：

Wolfram Language code: m[[All, -2 ;; -1]]

用户总数通过类似 m[[…]]=value 这样的赋值来重设列表的一个或多个部分.

重设 m 的第一部分和第二部分：

Wolfram Language code: m[[1, 2]] = x

m 的形式：

Wolfram Language code: m

把第一部分重设为 x，并且把第三部分重设为 y：

Wolfram Language code: m[[{1, 3}]] = {x, y};m

把第一部分和第三部分都重设为 p：

Wolfram Language code: m[[{1, 3}]] = p;m

重新存储 m 原先的形式：

Wolfram Language code: m = {{a, b, c}, {d, e}, {f, g, h}};

重设使用 m[[{1,3},{1,2}]] 指定的部分：

Wolfram Language code: m[[{1, 3}, {1, 2}]] = x;m

可以使用 ;; 来指定给定范围内所有索引：

Wolfram Language code: m[[1 ;; 3, 2]] = y;m

有时，把一个嵌套列表想象为在空间的展开是有益的，这时，每个元素都是在由其索引所提供的坐标位置上. 对于list[[spec₁,spec₂,…]]，存在直接的几何解释. 如果一个给定的 spec_k 是一个单一的整数，那么表示在第 k 维提取单一的分块，而如果是一个列表的话，表示提取平行分块的列表. 那么 list[[spec₁,spec₂,…]] 的最终结果是在每个连续纬度上分块所得到的元素集合.

一个显示为二维数组的嵌套列表：

Wolfram Language code: (m = {{a, b, c}, {d, e, f}, {g, h, i}})//TableForm

选出行1和行3，接着是列1和列2：

Wolfram Language code: m[[{1, 3}, {1, 2}]]//TableForm

Part 被设置使得提取嵌套列表的结构分片更为简单. 然而，有时用户可能想要选出由单一部分组成的任意集合. 也可以使用 Extract 方便地实现.

Part[list,{i₁,i₂,…}]	列表 {list[[i₁]],list[[i₂]],…}
Extract[list,{i₁,i₂,…}]	元素 list[[i₁,i₂,…]]
Part[list,spec₁,spec₂,…]	由连续分片指定的部分
Extract[list,{{i₁,i₂,…},{j₁,j₂,…},…}]	单一部分{list[[i₁,i₂,…]],list[[j₁,j₂,…]],…} 的列表

获取分片与获取单一部分组成的列表的比较.

提取单一部分1，3和1，2：

Wolfram Language code: Extract[m, {{1, 3}, {1, 2}}]

Extract 的重要特征是其对部分位置的列表采取与函数如 Position 返回的形式相同的形式.

建立一个嵌套列表：

Wolfram Language code: m = {{a[1], a[2], b[1]}, {b[2], c[1]}, {{b[3]}}};

给出 m 中位置的列表：

Wolfram Language code: Position[m, b[_]]

从这些位置提取元素：

Wolfram Language code: Extract[m, %]

Take[list,spec]	选出列表的指定部分
Drop[list,spec]	丢弃列表的指定部分
Take[list,spec₁,spec₂,…] ， Drop[list,spec₁,spec₂,…]	在嵌套列表的每一层选出或丢弃指定部分
n	前 n 个元素
-n	最后 n 个元素
{n}	仅含元素 n
{m,n}	元素 m 到 n （闭区间）
{m,n,s}	元素 m 到 n，步长为 s
All	所有部分
None	没有部分

在列表中选出和丢弃元素序列.

选出所有从位置2开始的第二个元素：

Wolfram Language code: Take[{a, b, c, d, e, f, g}, {2, -1, 2}]

丢弃所有的第二个元素：

Wolfram Language code: Drop[{a, b, c, d, e, f, g}, {2, -1, 2}]

与 Part 很相似，Take 和 Drop 可以视为在嵌套列表的连续层中选出块的序列，用户可以使用 Take 和 Drop 来对数组中的元素块进行操作.

一个3×3数组：

Wolfram Language code: (m = {{a, b, c}, {d, e, f}, {g, h, i}})//TableForm

前 2×2 个子数组：

Wolfram Language code: Take[m, 2, 2]//TableForm

取出前两列的所有元素：

Wolfram Language code: Take[m, All, 2]//TableForm

没有保留前两列元素：

Wolfram Language code: Drop[m, None, 2]//TableForm

Prepend[list,elem]	在 list 的开头加入 element
Append[list,elem]	在 list 的末尾加入 element
Insert[list,elem,i]	在位置 i 插入 element
Insert[list,elem,{i,j,…}]	在位置 {i,j,…} 插入
Delete[list,i]	在位置 i 删除元素
Delete[list,{i,j,…}]	在位置 {i,j,…} 删除

在列表中加入和删除元素.

令列表的第2，1位置上的元素为 x：

Wolfram Language code: Insert[{{a, b, c}, {d, e}}, x, {2, 1}]

再次删除元素：

Wolfram Language code: Delete[%, {2, 1}]

ReplacePart[list,i->new]	用 new 替换 list 中位置 i 上的元素
ReplacePart[list,{i,j,…}->new]	用 new 替换 list[[i,j,…]]
ReplacePart[list,{i₁->new₁,i₂->new₂,…}]	用 new_n 替换位置 i_n 上的部分
ReplacePart[list,{{i₁,j₁,…}->new₁,…}]	用 new_n 替换位置 {i_n,j_n,…} 上的部分
ReplacePart[list,{{i₁,j₁,…},…}->new]	用 new 替换所有部分 list[[i_k,j_k,…]]

替换列表的部分.

使用 x 取代矩阵的第3个元素：

Wolfram Language code: ReplacePart[{a, b, c, d}, 3 -> x]

取代列表的第一和第四部分. 注意在指定多个部分来取代的情况下，需要双列表：

Wolfram Language code: ReplacePart[{a, b, c, d}, {{1}, {4}} -> x]

一个3×3单位矩阵：

Wolfram Language code: IdentityMatrix[3]

使用 x 取代矩阵的2,2部分：

Wolfram Language code: ReplacePart[%, {2, 2} -> x]

理解 ReplacePart 总是创建一个新的列表是重要的. 并不像 m[[…]]=val 那样改变已经赋给一个符号的列表.

把值的列表赋于 alist：

Wolfram Language code: alist = {a, b, c, d}

给出列表的拷贝，其中第三个元素由 x 取代：

Wolfram Language code: ReplacePart[alist, 3 -> x]

alist 的值没有被更改：

Wolfram Language code: alist

嵌套列表

{list₁,list₂,…}	列表的列表
Table[expr,{i,m},{j,n},…]	由 expr 的值构成的 m×n×… 表格
Array[f,{m,n,…}]	由 f[i,j,…] 的值构成的 m×n×… 数组
Normal[SparseArray[{{i₁,j₁,…}->v₁,…},{m,n,…}]]
	m×n×… 数组，元素 {i_s,j_s,…} 为 v_s
Outer[f,list₁,list₂,…]	对与 f 结合的元素进行的一般外层求积操作
Tuples[list,{m,n,…}]	由 list 得到的元素组成的所有 m×n×… 数组

构建嵌套列表的方式.

产生一个表格，对应于一个2×3嵌套列表：

Wolfram Language code: Table[x ^ i + j, {i, 2}, {j, 3}]

产生对应于相同嵌套列表的数组：

Wolfram Language code: Array[x ^ #1 + #2&, {2, 3}]

没有在稀疏数组中明确指定的元素为 0：

Wolfram Language code: Normal[SparseArray[{{1, 3} -> 3 + x}, {2, 3}]]

最终列表的每个元素包含从每个输入列表的元素：

Wolfram Language code: Outer[f, {a, b}, {c, d}]

函数如 Array、SparseArray 和 Outer 总是产生完全数组，其中在特定层的所有子列表都具有相同的长度.

Dimensions[list]	完全数组的维度
ArrayQ[list]	测试在给定层上的所有子列表是否具有相同长度
ArrayDepth[list]	所有子列表具有相同长度

完全数组的函数.

Wolfram 语言可以处理任意嵌套列表. 列表没有必要形成一个完全数组. 使用 Table 可以很容易地形成不规则的数组.

产生一个三角数组：

Wolfram Language code: Table[x ^ i + j, {i, 3}, {j, i}]

Flatten[list]	压平 list 的所有层
Flatten[list,n]	压平前 n 层
ArrayFlatten[list,rank]	从由数组构成的数组构建压平的数组

对子列表和子数组进行压平操作.

产生一个2×3数组：

Wolfram Language code: Array[a, {2, 3}]

Flatten 根据索引的字典顺序放置元素：

Wolfram Language code: Flatten[%]

从一个块矩阵生成矩阵：

Wolfram Language code: ArrayFlatten[{{{{1}}, {{2, 3}}}, {{{4}, {7}}, {{5, 6}, {8, 9}}}}]

Transpose[list]	对 list 的前两层进行转置
Transpose[list,{n₁,n₂,…}]	在第 n_k 层放入 list 中的第 k 层

在嵌套列表上对不同层进行转置操作.

产生一个2×2×2数组：

Wolfram Language code: Array[a, {2, 2, 2}]

对不同层进行重排，以使得第3层出现在第1层：

Wolfram Language code: Transpose[%, {3, 1, 2}]

恢复原来的数组：

Wolfram Language code: Transpose[%, {2, 3, 1}]

Map[f,list,{n}]	在第 n 层上对所有元素进行 f 映射
Apply[f,list,{n}]	对第 n 层上的所有元素应用 f
MapIndexed[f,list,{n}]	在第 n 层上的部分元素以及索引上映射 f

在嵌套函数上应用函数.

一个嵌套列表：

Wolfram Language code: m = {{{a, b}, {c, d}}, {{e, f}, {g, h}, {i}}};

在第2层对函数 f 进行映射：

Wolfram Language code: Map[f, m, {2}]

在第二层应用函数：

Wolfram Language code: Apply[f, m, {2}]

对列表的部分元素和其索引应用 f：

Wolfram Language code: MapIndexed[f, m, {2}]

Partition[list,{n₁,n₂,…}]	分成 n₁×n₁×… 的块
PadLeft[list,{n₁,n₂,…}]	在左边填充以生成一个 n₁×n₁×… 数组
PadRight[list,{n₁,n₂,…}]	在右边填充以生成一个 n₁×n₁×… 数组
RotateLeft[list,{n₁,n₂,…}]	在第 k 层向左轮换 n_k 个位置
RotateRight[list,{n₁,n₂,…}]	在第 k 层向右轮换 n_k 个位置

在嵌套列表上的操作.

一个嵌套列表：

Wolfram Language code: m = {{{a, b, c}, {d, e}}, {{f, g}, {h}, {i}}};

在每一层旋转不同的量：

Wolfram Language code: RotateLeft[m, {0, 1, -1}]

用零进行填充，以生成一个2×3×3数组：

Wolfram Language code: PadRight[%, {2, 3, 3}]

列表的分组和填充

Partition[list,n]	把 list 分为长度为 n 的子列表
Partition[list,n,d]	使用偏移量 d 划分子列表
Split[list]	把 list 分成相同元素的子列表
Split[list,test]	分成相邻元素满足 test 的子列表

对列表中的元素进行分组.

把列表划分为大小为3的块：

Wolfram Language code: Partition[{a, b, c, d, e, f}, 3]

以偏移量1把列表分为大小为3的块：

Wolfram Language code: Partition[{a, b, c, d, e, f}, 3, 1]

该偏移量可以大于块大小：

Wolfram Language code: Partition[{a, b, c, d, e, f}, 2, 3]

分成具有相同元素的子列表：

Wolfram Language code: Split[{1, 4, 1, 1, 1, 2, 2, 3, 3}]

分成相邻元素不相等的子列表：

Wolfram Language code: Split[{1, 4, 1, 1, 1, 2, 2, 3, 3}, Unequal]

Partition 遍历一个列表，并把相邻的元素分成子列表. 默认情况下，没有包含任何令原列表悬空的子列表.

出现任何悬空之前停止操作：

Wolfram Language code: Partition[{a, b, c, d, e}, 2]

以下例子也同样适用：

Wolfram Language code: Partition[{a, b, c, d, e}, 3, 1]

用户可以告诉 Partition 包含令原列表末尾悬空的子列表. 默认情况下，通过周期性地处理原来的列表，可以填入其他额外的元素. 也可以根据用户指定的元素进行填充.

包含了另外的子列表，并认为原先的列表是周期性的：

Wolfram Language code: Partition[{a, b, c, d, e}, 3, 1, {1, 1}]

原列表使用元素 x 填充：

Wolfram Language code: Partition[{a, b, c, d, e}, 3, 1, {1, 1}, x]

使用元素 x 和 y 周期性地填充：

Wolfram Language code: Partition[{a, b, c, d, e}, 3, 1, {1, 1}, {x, y}]

没有引入填充的方法，产生了具有不同长度的子列表：

Wolfram Language code: Partition[{a, b, c, d, e}, 3, 1, {1, 1}, {}]

用户可以认为 Partition 是通过在原列表使用模版并选出元素来提取子列表. 用户可以告诉 Partition 在什么位置开始和停止该过程.

给出所有与原来的列表重叠的子列表：

Wolfram Language code: Partition[{a, b, c, d}, 3, 1, {-1, 1}, x]

只允许开头的重叠：

Wolfram Language code: Partition[{a, b, c, d}, 3, 1, {-1, -1}, x]

Partition[list,n,d] or Partition[list,n,d,{1,-1}]	只保留没有悬空的子列表
Partition[list,n,d,{1,1}]	允许在末尾有悬空
Partition[list,n,d,{-1,-1}]	允许在开头有悬空
Partition[list,n,d,{-1,1}]	允许在开头和末尾都有悬空
Partition[list,n,d,{k_L,k_R}]	指定第一个和最后一个子列表的对齐
Partition[list,n,d,spec]	通过在 list 中周期性地重复元素进行填充
Partition[list,n,d,spec,x]	通过重复元素 x 填充
Partition[list,n,d,spec,{x₁,x₂,…}]
	通过周期性地重复 x_i 填充
Partition[list,n,d,spec,{}]	不使用填充

指定对齐和填充.

对齐规格 {k_L,k_R} 告诉 Partition 给出子列表的序列，其中原列表的第一个元素在第一个子列表的位置

出现，而原列表的最后一个元素在最后一个子列表的位置

出现.

在第一个子列表中，令 a 出现在位置1：

Wolfram Language code: Partition[{a, b, c, d}, 3, 1, {1, 1}, x]

令 a 出现在第一个子列表的位置2：

Wolfram Language code: Partition[{a, b, c, d}, 3, 1, {2, 1}, x]

令 a 首先出现在位置4：

Wolfram Language code: Partition[{a, b, c, d}, 3, 1, {4, 1}, x]

从给定的列表周期性地进行填充：

Wolfram Language code: Partition[{a, b, c, d}, 3, 1, {4, 1}, {x, y}]

函数如 ListConvolve 使用与 Partition 相同的对齐和填充规格.

在一些情况下，对列表进行明确的填充插入可能是方便的. 这可以通过使用 PadLeft 和 PadRight 实现.

PadLeft[list,n]	通过在左边插入零进行填充，以达到长度 n
PadLeft[list,n,x]	通过重复元素 x 进行填充
PadLeft[list,n,{x₁,x₂,…}]	通过周期性地重复 x_i 进行填充
PadLeft[list,n,list]	通过周期性地重复 list 进行填充
PadLeft[list,n,padding,m]	在右边留出 m 个元素大小的空白
PadRight[list,n]	在右边插入零进行填充

填充列表.

对列表进行填充，使其长度为6：

Wolfram Language code: PadLeft[{a, b, c}, 6]

以填充方式插入 {x,y}：

Wolfram Language code: PadLeft[{a, b, c}, 6, {x, y}]

在右边留出大小为3的空白：

Wolfram Language code: PadLeft[{a, b, c}, 10, {x, y}, 3]

PadLeft、PadRight 和 Partition 都可以用于嵌套列表.

生成一个3x3数组：

Wolfram Language code: PadLeft[{{a, b}, {e}, {f}}, {3, 3}, x]

使用偏移量1把数组分成2x2的块：

Wolfram Language code: Partition[%, {2, 2}, {1, 1}]

如果用户给出一个嵌套列表作为填充规格，在每一层周期性地选出其元素.

周期性地填入填充列表的拷贝：

Wolfram Language code: PadLeft[{{a, b}, {e}, {f}}, {4, 4}, {{x, y}, {z, w}}]

以下是一个仅包含填充的列表：

Wolfram Language code: PadLeft[{{}}, {4, 4}, {{x, y}, {z, w}}]

稀疏数组：列表的处理

在 Wolfram 语言中，列表通过给出元素的明确集合来指定. 但是当处理大型数组时，能够指明特定位置处的元素值，并将其余元素指定为默认值，常常是有用的. 在 Wolfram 语言中可以使用 SparseArray 对象实现.

{e₁,e₂,…} ， {{e₁₁,e₁₂,…},…} ， …	普通列表
SparseArray[{pos₁->val₁,pos₂->val₂,…}]
	稀疏数组

普通列表和稀疏数组.

指定一个稀疏数组：

Wolfram Language code: SparseArray[{2 -> a, 5 -> b}]

普通列表的形式：

Wolfram Language code: Normal[%]

指定一个二维稀疏数组：

Wolfram Language code: SparseArray[{{1, 2} -> a, {3, 2} -> b, {3, 3} -> c}]

由列表组成的普通列表：

Wolfram Language code: Normal[%]

SparseArray[list]	list 的稀疏数组版本
SparseArray[{pos₁->val₁,pos₂->val₂,…}]
	在位置 pos_i 上值为 val_i 的稀疏数组
SparseArray[{pos₁,pos₂,…}->{val₁,val₂,…}]
	同样的稀疏数组
SparseArray[Band[{i,j}]->val]	值为 val 的带状稀疏矩阵
SparseArray[data,{d₁,d₂,…}]	d₁×d₂×… 稀疏数组
SparseArray[data,dims,val]	默认值为 val 的稀疏数组
Normal[array]	array 的普通列表版本
ArrayRules[array]	array 的位置值规则

创建和转换稀疏数组.

产生列表的稀疏数组版本：

Wolfram Language code: SparseArray[{a, b, c, d}]

将其转换为一个普通列表：

Wolfram Language code: Normal[%]

生产一个默认值为 x，长度为7的稀疏数组：

Wolfram Language code: SparseArray[{3 -> a, 5 -> b}, 7, x]

相应的普通列表：

Wolfram Language code: Normal[%]

显示了稀疏数组中采用的规则：

Wolfram Language code: ArrayRules[%%]

创建一个带状矩阵：

Wolfram Language code: SparseArray[{Band[{1, 1}] -> x, Band[{2, 1}] -> y}, {5, 5}]//MatrixForm

SparseArray 的重要特征是用户指定的位置可以是模式.

指定一个4×4稀疏数组，与 {i_,i_} 匹配的每个位置为 1：

Wolfram Language code: SparseArray[{i_, i_} -> 1, {4, 4}]

该结果是一个4×4的单位矩阵：

Wolfram Language code: Normal[%]

一个具有额外元素的单位矩阵：

Wolfram Language code: Normal[SparseArray[{{1, 3} -> a, {i_, i_} -> 1}, {4, 4}]]

整个第3列为 a：

Wolfram Language code: Normal[SparseArray[{{_, 3} -> a, {i_, i_} -> 1}, {4, 4}]]

可以认为 SparseArray[rules] 是采用所有可能位置的规格，然后应用 rules 来确定每个情况下的值. 通常情况下，列表中先给出的规则将被首先尝试.

产生一个随机对角线矩阵：

Wolfram Language code: Normal[SparseArray[{{i_, i_}： > RandomReal[]}, {3, 3}]]

用户可以具有值取决于索引的规则：

Wolfram Language code: Normal[SparseArray[i_ -> i ^ 2, 10]]

使用 p 对每个偶数位进行填充：

Wolfram Language code: Normal[SparseArray[{_ ? EvenQ -> p, i_ -> i ^ 2}, 10]]

用户可以使用涉及另一种选择的模式：

Wolfram Language code: Normal[SparseArray[{1 | 3, 2 | 4} -> a, {4, 4}]]

用户也可以对模式给出条件：

Wolfram Language code: Normal[SparseArray[i_ /; 3 < i < 7 -> p, 10]]

生成一个带状对角矩阵：

Wolfram Language code: Normal[SparseArray[{{i_, j_} /; Abs[i - j] < 2 -> i + j}, {5, 5}]]

以下是另一种方式：

Wolfram Language code:

Normal[SparseArray[{Band[{1, 1}] -> {2, 4, 6, 8, 10}, Band[{1, 2}] -> {3, 5, 7, 9}, Band[{2, 1}] -> {3, 5, 7, 9}}, {5, 5}]]

为了许多不同的目的，Wolfram 系统用类似其所对应的普通列表的处理方式处理 SparseArray 对象. 因此，例如，如果用户要求一个稀疏数组对象的部分元素，Wolfram 系统将用类似在对应的普通列表中获取部分元素的方式进行.

产生一个稀疏数组对象：

Wolfram Language code: s = SparseArray[{2 -> a, 4 -> b, 5 -> c}, 10]

以下是对应的普通列表：

Wolfram Language code: Normal[s]

稀疏数组的部分元素类似于对应的普通列表的部分元素：

Wolfram Language code: s[[2]]

该部分元素具有默认值0：

Wolfram Language code: s[[3]]

许多操作用类似普通列表的方式处理 SparseArray 对象. 在可能的情况下，他们给出稀疏矩阵作为结果.

给出一个稀疏数组：

Wolfram Language code: 3 s + x

以下是对应的普通列表：

Wolfram Language code: Normal[%]

Dot 直接对稀疏数组对象进行操作：

Wolfram Language code: s.s

用户可以混合稀疏数组和普通列表：

Wolfram Language code: s.Range[10]

Wolfram 系统用具有头部 SparseArray 的表达式表示稀疏数组. 当计算一个稀疏数组的时候，就自动转换为具有结构 SparseArray[Automatic,dims,val,…] 的优化标准形式.

然而，该结构很少是明显的，由于建立类似 Length 的操作可以对相应的普通列表给出结果，而不是对原始SparseArray 表达式结构给出结果.

产生一个稀疏数组：

Wolfram Language code: t = SparseArray[{1 -> a, 5 -> b}, 10]

以下是内部优化表达式结构：

Wolfram Language code: InputForm[%]

Length 给出对应的普通列表的长度：

Wolfram Language code: Length[t]

Map 也对单个数值进行操作：

Wolfram Language code: Normal[Map[f, t]]

Top

更多学习资源

技术支持

数据科学、金融与商业

工程

科学与技术

教育科技

教育举措

开始

提高你的技能

与我们合作

成人教育计划

青少年教育计划

欢迎阅读

操作列表

操作列表

相关指南