操作列表

构建列表列表的分组和填充
通过索引操作列表稀疏数组：列表的处理
嵌套列表
构建列表
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[{i1->v1,…},n]]
长度为 n 的列表，元素 ik 为 vk
Apply[List,f[e1,e2,…]]
列表 {e1,e2,…}
用以构建列表的一些明确方式.
给出以2为幂的前5个值的列表：
取得相同结果的另一种方式：
给出相似的列表：
SparseArray 帮助用户在特定位置指定值：
也可以使用模式来指定值：
通常情况下，用户可以提前知道一个列表应该有多长，并且每个元素应该如何生成. 而且，用户可以从一个列表得到另一个列表.
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[ei] 是 True，从 list 的开头给出元素 ei
list[[{i1,i2,…}]]
or
Part[list,{i1,i2,…}]
给出 list 指定部分的列表
从其他列表构建列表.
选出小于5的元素：
选出不小于5的第一个元素：
明确给出编号部分：
选出第二个列表中 1 所对应的元素：
有时候，用户可能想要在程序执行过程中积累结果列表. 这可以使用 Sow 和 Reap 实现.
Sow[val]
对于最接近的 Reap，进行值 val 的 sow 操作
Reap[expr]
计算 expr，并返回 Sow 产生的值的列表
使用 Sow 和 Reap.
该程序对一个数进行迭代求平方：
进行同样的计算，但这里把大于1000的中间结果累积成列表：
另一个效率比较低的方法涉及引入一个临时变量，并以 t={} 开始，然后连续使用 AppendTo[t,elem].
通过索引操作列表
Part[list,spec]
or
list[[spec]]
列表的一个或多个部分
Part[list,spec1,spec2,…]
or
list[[spec1,spec2,…]]
嵌套列表的一个或多个部分
n
开头的第 n 个部分
-n
末尾的第 n 个部分
{i1,i2,…}
由部分组成的列表
m;;n
第 m 部分到第 n 部分
All
所有部分
获取列表的部分.
给出列表的第一部分和第三部分：
一个嵌套列表：
给出第一部分和第三部分的列表：
给出每个部分第一子部的列表：
给出前两个部分的列表：
给出 m 的前两个部分：
给出相应的最后部分：
给出所有子列表的第二部分：
给出所有子列表的最后两个部分：
用户总数通过类似 m[[…]]=value 这样的赋值来重设列表的一个或多个部分.
重设 m 的第一部分和第二部分：
m 的形式：
把第一部分重设为 x，并且把第三部分重设为 y：
把第一部分和第三部分都重设为 p：
重新存储 m 原先的形式：
重设使用 m[[{1,3},{1,2}]] 指定的部分：
可以使用 ;; 来指定给定范围内所有索引：
有时，把一个嵌套列表想象为在空间的展开是有益的，这时，每个元素都是在由其索引所提供的坐标位置上. 对于list[[spec1,spec2,…]]，存在直接的几何解释. 如果一个给定的 speck 是一个单一的整数，那么表示在第 k 维提取单一的分块，而如果是一个列表的话，表示提取平行分块的列表. 那么 list[[spec1,spec2,…]] 的最终结果是在每个连续纬度上分块所得到的元素集合.
一个显示为二维数组的嵌套列表：
选出行1和行3，接着是列1和列2：
Part 被设置使得提取嵌套列表的结构分片更为简单. 然而，有时用户可能想要选出由单一部分组成的任意集合. 也可以使用 Extract 方便地实现.
Part[list,{i1,i2,…}]
列表 {list[[i1]],list[[i2]],…}
Extract[list,{i1,i2,…}]
元素 list[[i1,i2,…]]
Part[list,spec1,spec2,…]
由连续分片指定的部分
Extract[list,{{i1,i2,…},{j1,j2,…},…}]
单一部分{list[[i1,i2,…]],list[[j1,j2,…]],…} 的列表
获取分片与获取单一部分组成的列表的比较.
提取单一部分1，3和1，2：
Extract 的重要特征是其对部分位置的列表采取与函数如 Position 返回的形式相同的形式.
建立一个嵌套列表：
给出 m 中位置的列表：
从这些位置提取元素：
Take[list,spec]
选出列表的指定部分
Drop[list,spec]
丢弃列表的指定部分
Take[list,spec1,spec2,…]
，
Drop[list,spec1,spec2,…]
在嵌套列表的每一层选出或丢弃指定部分
n
前 n 个元素
-n
最后 n 个元素
{n}
仅含元素 n
{m,n}
元素 m 到 n （闭区间）
{m,n,s}
元素 m 到 n，步长为 s
All
所有部分
None
没有部分
在列表中选出和丢弃元素序列.
选出所有从位置2开始的第二个元素：
丢弃所有的第二个元素：
与 Part 很相似，Take 和 Drop 可以视为在嵌套列表的连续层中选出块的序列，用户可以使用 Take 和 Drop 来对数组中的元素块进行操作.
一个3×3数组：
前 2×2 个子数组：
取出前两列的所有元素：
没有保留前两列元素：
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：
再次删除元素：
ReplacePart[list,i->new]
用 new 替换 list 中位置 i 上的元素
ReplacePart[list,{i,j,…}->new]
用 new 替换 list[[i,j,…]]
ReplacePart[list,{i1->new1,i2->new2,…}]
用 newn 替换位置 in 上的部分
ReplacePart[list,{{i1,j1,…}->new1,…}]
用 newn 替换位置 {in,jn,…} 上的部分
ReplacePart[list,{{i1,j1,…},…}->new]
用 new 替换所有部分 list[[ik,jk,…]]
替换列表的部分.
使用 x 取代矩阵的第3个元素：
取代列表的第一和第四部分. 注意在指定多个部分来取代的情况下，需要双列表：
一个3×3单位矩阵：
使用 x 取代矩阵的2,2部分：
理解 ReplacePart 总是创建一个新的列表是重要的. 并不像 m[[…]]=val 那样改变已经赋给一个符号的列表.
把值的列表赋于 alist：
给出列表的拷贝，其中第三个元素由 x 取代：
alist 的值没有被更改：
嵌套列表
{list1,list2,…}
列表的列表
Table[expr,{i,m},{j,n},…]
由 expr 的值构成的 m×n×… 表格
Array[f,{m,n,…}]
由 f[i,j,…] 的值构成的 m×n×… 数组
Normal[SparseArray[{{i1,j1,…}->v1,…},{m,n,…}]]
m×n×… 数组，元素 {is,js,…} 为 vs
Outer[f,list1,list2,…]
对与 f 结合的元素进行的一般外层求积操作
Tuples[list,{m,n,…}]
由 list 得到的元素组成的所有 m×n×… 数组
构建嵌套列表的方式.
产生一个表格，对应于一个2×3嵌套列表：
产生对应于相同嵌套列表的数组：
没有在稀疏数组中明确指定的元素为 0：
最终列表的每个元素包含从每个输入列表的元素：
函数如 Array、SparseArray 和 Outer 总是产生完全数组，其中在特定层的所有子列表都具有相同的长度.
Dimensions[list]
完全数组的维度
ArrayQ[list]
测试在给定层上的所有子列表是否具有相同长度
ArrayDepth[list]
所有子列表具有相同长度
完全数组的函数.
Wolfram 语言可以处理任意嵌套列表. 列表没有必要形成一个完全数组. 使用 Table 可以很容易地形成不规则的数组.
产生一个三角数组：
Flatten[list]
压平 list 的所有层
Flatten[list,n]
压平前 n 层
ArrayFlatten[list,rank]
从由数组构成的数组构建压平的数组
对子列表和子数组进行压平操作.
产生一个2×3数组：
Flatten 根据索引的字典顺序放置元素：
从一个块矩阵生成矩阵：
Transpose[list]
对 list 的前两层进行转置
Transpose[list,{n1,n2,…}]
在第 nk 层放入 list 中的第 k 层
在嵌套列表上对不同层进行转置操作.
产生一个2×2×2数组：
对不同层进行重排，以使得第3层出现在第1层：
恢复原来的数组：
Map[f,list,{n}]
在第 n 层上对所有元素进行 f 映射
Apply[f,list,{n}]
对第 n 层上的所有元素应用 f
MapIndexed[f,list,{n}]
在第 n 层上的部分元素以及索引上映射 f
在嵌套函数上应用函数.
一个嵌套列表：
在第2层对函数 f 进行映射：
在第二层应用函数：
对列表的部分元素和其索引应用 f：
Partition[list,{n1,n2,…}]
分成 n1×n1×… 的块
PadLeft[list,{n1,n2,…}]
在左边填充以生成一个 n1×n1×… 数组
PadRight[list,{n1,n2,…}]
在右边填充以生成一个 n1×n1×… 数组
RotateLeft[list,{n1,n2,…}]
在第 k 层向左轮换 nk 个位置
RotateRight[list,{n1,n2,…}]
在第 k 层向右轮换 nk 个位置
在嵌套列表上的操作.
一个嵌套列表：
在每一层旋转不同的量：
用零进行填充，以生成一个2×3×3数组：
列表的分组和填充
Partition[list,n]
把 list 分为长度为 n 的子列表
Partition[list,n,d]
使用偏移量 d 划分子列表
Split[list]
把 list 分成相同元素的子列表
Split[list,test]
分成相邻元素满足 test 的子列表
对列表中的元素进行分组.
把列表划分为大小为3的块：
以偏移量1把列表分为大小为3的块：
该偏移量可以大于块大小：
分成具有相同元素的子列表：
分成相邻元素不相等的子列表：
Partition 遍历一个列表，并把相邻的元素分成子列表. 默认情况下，没有包含任何令原列表悬空的子列表.
出现任何悬空之前停止操作：
以下例子也同样适用：
用户可以告诉 Partition 包含令原列表末尾悬空的子列表. 默认情况下，通过周期性地处理原来的列表，可以填入其他额外的元素. 也可以根据用户指定的元素进行填充.
包含了另外的子列表，并认为原先的列表是周期性的：
原列表使用元素 x 填充：
使用元素 x 和 y 周期性地填充：
没有引入填充的方法，产生了具有不同长度的子列表：
用户可以认为 Partition 是通过在原列表使用模版并选出元素来提取子列表. 用户可以告诉 Partition 在什么位置开始和停止该过程.
给出所有与原来的列表重叠的子列表：
只允许开头的重叠：
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,{kL,kR}]
指定第一个和最后一个子列表的对齐
Partition[list,n,d,spec]
通过在 list 中周期性地重复元素进行填充
Partition[list,n,d,spec,x]
通过重复元素 x 填充
Partition[list,n,d,spec,{x1,x2,…}]
通过周期性地重复 xi 填充
Partition[list,n,d,spec,{}]
不使用填充
指定对齐和填充.
对齐规格 {kL,kR} 告诉 Partition 给出子列表的序列，其中原列表的第一个元素在第一个子列表的位置 出现，而原列表的最后一个元素在最后一个子列表的位置 出现.
在第一个子列表中，令 a 出现在位置1：
令 a 出现在第一个子列表的位置2：
令 a 首先出现在位置4：
从给定的列表周期性地进行填充：
函数如 ListConvolve 使用与 Partition 相同的对齐和填充规格.
在一些情况下，对列表进行明确的填充插入可能是方便的. 这可以通过使用 PadLeft 和 PadRight 实现.
PadLeft[list,n]
通过在左边插入零进行填充，以达到长度 n
PadLeft[list,n,x]
通过重复元素 x 进行填充
PadLeft[list,n,{x1,x2,…}]
通过周期性地重复 xi 进行填充
PadLeft[list,n,list]
通过周期性地重复 list 进行填充
PadLeft[list,n,padding,m]
在右边留出 m 个元素大小的空白
PadRight[list,n]
在右边插入零进行填充
填充列表.
对列表进行填充，使其长度为6：
以填充方式插入 {x,y}：
在右边留出大小为3的空白：
PadLeft、PadRight 和 Partition 都可以用于嵌套列表.
生成一个3x3数组：
使用偏移量1把数组分成2x2的块：
如果用户给出一个嵌套列表作为填充规格，在每一层周期性地选出其元素.
周期性地填入填充列表的拷贝：
以下是一个仅包含填充的列表：
稀疏数组：列表的处理
在 Wolfram 语言中，列表通过给出元素的明确集合来指定. 但是当处理大型数组时，能够指明特定位置处的元素值，并将其余元素指定为默认值，常常是有用的. 在 Wolfram 语言中可以使用 SparseArray 对象实现.
{e1,e2,…}
，
{{e11,e12,…},…}
，
…
普通列表
SparseArray[{pos1->val1,pos2->val2,…}]
稀疏数组
普通列表和稀疏数组.
指定一个稀疏数组：
普通列表的形式：
指定一个二维稀疏数组：
由列表组成的普通列表：
SparseArray[list]
list 的稀疏数组版本
SparseArray[{pos1->val1,pos2->val2,…}]
在位置 posi 上值为 vali 的稀疏数组
SparseArray[{pos1,pos2,…}->{val1,val2,…}]
同样的稀疏数组
SparseArray[Band[{i,j}]->val]
值为 val 的带状稀疏矩阵
SparseArray[data,{d1,d2,…}]
d1×d2×… 稀疏数组
SparseArray[data,dims,val]
默认值为 val 的稀疏数组
Normal[array]
array 的普通列表版本
ArrayRules[array]
array 的位置值规则
创建和转换稀疏数组.
产生列表的稀疏数组版本：
将其转换为一个普通列表：
生产一个默认值为 x，长度为7的稀疏数组：
相应的普通列表：
显示了稀疏数组中采用的规则：
创建一个带状矩阵：
SparseArray 的重要特征是用户指定的位置可以是模式.
指定一个4×4稀疏数组，与 {i_,i_} 匹配的每个位置为 1：
该结果是一个4×4的单位矩阵：
一个具有额外元素的单位矩阵：
整个第3列为 a：
可以认为 SparseArray[rules] 是采用所有可能位置的规格，然后应用 rules 来确定每个情况下的值. 通常情况下，列表中先给出的规则将被首先尝试.
产生一个随机对角线矩阵：
用户可以具有值取决于索引的规则：
使用 p 对每个偶数位进行填充：
用户可以使用涉及另一种选择的模式：
用户也可以对模式给出条件：
生成一个带状对角矩阵：
以下是另一种方式：
为了许多不同的目的，Wolfram 系统用类似其所对应的普通列表的处理方式处理 SparseArray 对象. 因此，例如，如果用户要求一个稀疏数组对象的部分元素，Wolfram 系统将用类似在对应的普通列表中获取部分元素的方式进行.
产生一个稀疏数组对象：
以下是对应的普通列表：
稀疏数组的部分元素类似于对应的普通列表的部分元素：
该部分元素具有默认值0：
许多操作用类似普通列表的方式处理 SparseArray 对象. 在可能的情况下，他们给出稀疏矩阵作为结果.
给出一个稀疏数组：
以下是对应的普通列表：
Dot 直接对稀疏数组对象进行操作：
用户可以混合稀疏数组和普通列表：
Wolfram 系统用具有头部 SparseArray 的表达式表示稀疏数组. 当计算一个稀疏数组的时候，就自动转换为具有结构 SparseArray[Automatic,dims,val,…] 的优化标准形式.
然而，该结构很少是明显的，由于建立类似 Length 的操作可以对相应的普通列表给出结果，而不是对原始SparseArray 表达式结构给出结果.
产生一个稀疏数组：
以下是内部优化表达式结构：
Length 给出对应的普通列表的长度：
Map 也对单个数值进行操作：