列表—Wolfram Documentation

列表

产生对象列表	添加、删除和修改列表元素
将一些对象放在一起	列表组合
值表的生成	作为集合的列表
处理列表中的元素	重排列表
向量和矩阵	列表元素的分组和合并
获得列表的部分元素	列表中的排序
检测和搜索列表元素	嵌套列表的重排

产生对象列表

在做计算时，将一些对象放在一起作为单个实体处理是很方便的. 而列表（Lists）是 Wolfram 语言产生对象集合的一种方法. 后面将看到列表是 Wolfram 语言的非常重要和普遍的结构.

例如列表 {3,5,1} 是三个对象的集合，但在许多情况下，可以作为单一对象处理. 例如，可以一次对整个列表进行运算，或把整个列表赋为某个变量的值.

三个数的列表：

Wolfram Language code: {3, 5, 1}

列表中每个数的平方再加 1 ：

Wolfram Language code: {3, 5, 1} ^ 2 + 1

两个列表相应元素之差，此时两列表长度必须相同：

Wolfram Language code: {6, 7, 8} - {3.5, 4, 2.5}

% 的值是整个列表：

Wolfram Language code: %

"一些数学函数 " 中的数学函数都可以使用到列表：

Wolfram Language code: Exp[%]//N

如同把数赋给变量一样也可以把列表赋给某变量.

把列表赋给变量 v ：

Wolfram Language code: v = {2, 4, 3.1}

无论 v 出现在何处，都用这个列表代替：

Wolfram Language code: v / (v - 1)

将一些对象放在一起

在 "产生对象的列表 " 节中我们已经讨论过列表，在那里是作为一种把多个数放在一起的方式. 在这一节中，将看到使用列表的许多不同方式. 用户将发现列表是 Wolfram 语言中最灵活和最强有力的对象之一. 将看到 Wolfram 语言列表是数学和计算机科学中的一些标准概念的一般化.

一般地，Wolfram 语言列表本质上是提供一种把任何类型的表达式收集在一起的方法.

一个数的列表：

Wolfram Language code: {2, 3, 4}

给出一个符号表达式的列表：

Wolfram Language code: x ^ % - 1

可以对这些表达式求导数：

Wolfram Language code: D[%, x]

然后可以求出用 3 替换 x 所得的值：

Wolfram Language code: % /. x -> 3

Wolfram 语言内部的数学函数大多被设置成 “可列表的”，使其能分别作用于列表的每一个元素. 然而，并不一定 Wolfram 语言的所有函数都能做到这一点. 除非用户专门设置. 用户引入新函数 f 把列表作为单个对象进行处理. "函数作用于表达式的部分项 " 和 "结构的操作 " 将介绍如何用 Map 和 Thread 使一个函数分别地作用于列表的每个元素.

值表的生成

可以使用列表作为值的表. 用户可以生成这些表. 例如，通过对不同参数值的序列计算一个表达式来生成表.

给出

从 1 到 6 的

的值表：

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

一个

从

到

的

的表：

Wolfram Language code: Table[Sin[n / 5], {n, 0, 4}]

给出近似值：

Wolfram Language code: N[%]

也可以生成一个公式列表：

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

表 Table 使用像函数 Sum 和 Product 一样的循环表示法. 该表示法在 "求和与求积 " 中讨论过：

Wolfram Language code: Product[x ^ i + 2i, {i, 5}]

一个 x 从 0 到 1，步长为 0.25 所产生的表：

Wolfram Language code: Table[Sqrt[x], {x, 0, 1, 0.25}]

可以在从 Table 中得到的列表上进行其他运算：

Wolfram Language code: % ^ 2 + 3

TableForm 把列表显示为“表格”的形式. 注意，TableForm 中有两个大写字母：

Wolfram Language code: %//TableForm

到现在为止所有表的例子都是通过变化单个参数而得到的. 用户也可以使用多个参数产生表. 在 "求和与求积 " 节讨论使用标准的 Wolfram 语言循环表示法确定的多维表.

生成一个

从 1 到 3，

从 1 到 2 的

的表：

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

这个例子是一个列表的列表. 其中外层列表的元素相应于

的值. 内层列表的元素相应于

值固定的情况下，

的值.

有时用户可能想通过计算一个特定表达式多次来生成一个表，其中没有任何变量的增加.

生成一个包含符号 x 的 4 个拷贝的列表：

Wolfram Language code: Table[x, {4}]

从 {1,2,3,4} 给出 4 个伪随机数的表. Table 对列表中的每个元素重复计算RandomSample[{1,2,3,4},2] 4次，得到了不同的伪随机数：

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

对列表 {1,4,9,16} 中的每个 i 值计算

：

Wolfram Language code: Table[Sqrt[i], {i, {1, 4, 9, 16}}]

产生一个 3×2 的表格：

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

在这个表格中，行的长度取决于较慢变化的迭代变量 i：

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

可以使用 Table 生成具有任意维度的数组.

生成一个三维 2×2×2 数组. 这是一个列表的列表的列表：

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

Table[f,{i_max}]	给出 f 的 i_max 个值的列表
Table[f,{i,i_max}]	给出 f 的 i 从 1 到 i_max 的列表
Table[f,{i,i_min,i_max}]	给出 i 从 i_min 到 i_max 的列表
Table[f,{i,i_min,i_max,di}]	使用 di 为步长
Table[f,{i,i_min,i_max},{j,j_min,j_max},…]	生成多维表
Table[f,{i,{i₁,i₂,…}]	给出当 i 连续取值 i₁, i₂, … 时 f 的值的列表
TableForm[list]	把列表显示为表格形式

生成表的函数.

可以使用 "处理列表元素 " 节讨论的方法提取表的元素.

生成一个 2×2 的表，起名为 sq：

Wolfram Language code: sq = Table[j ^ 2, {j, 7}]

给出表格的第三部分：

Wolfram Language code: sq[[3]]

给出第三到第五部分的列表：

Wolfram Language code: sq[[3 ;; 5]]

生成一个 2×2 的表，起名为 m：

Wolfram Language code: m = Table[i - j, {i, 2}, {j, 2}]

从列表的列表中提取第一个子列表来产生一个表：

Wolfram Language code: m[[1]]

提取该子列表的第二个元素：

Wolfram Language code: %[[2]]

把前面两个运算合在一起进行：

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

把 m 显示成“表格”形式：

Wolfram Language code: TableForm[m]

t[[i]] or Part[t,i]	给出 t 的 i 个子列表（也作为 t〚i〛输入）
t[[i;;j]] or Part[t,i;;j]	给出从 i 到 j 的部分列表
t[[{i₁,i₂,…}]] or Part[t,{i₁,i₂,…}]	给出 t 的 i₁，i₂，… 部分构成的列表
t[[i,j,…]] or Part[t,i,j,…]	给出 t 的相应于 t[[i]][[j]]… 的部分元素列表

提取列表的部分元素的方法.

如 "处理列表元素 " 节中提到的那样，用户可以把 Wolfram 语言列表看作 “数组”，那么列表的列表则可看作二维数组. 当把列表显示为表格形式时，每个元素的两个指标如同

和

坐标一样.

处理列表中的元素

在 Wolfram 语言中，列表运算大多是将列表作为单个对象进行处理，然而，有时也需要取出或设置列表中的某个元素.

通过给出 Wolfram 语言列表元素的 “索引” 来涉及某个元素. 列表元素被以 1 开始顺序标号.

{a,b,c}	一个列表
Part[list,i] or list[[i]]	列表 list 的第 i 个元素（第一个元素为 list[[1]]）
Part[list,{i,j,…}] or list[[{i,j,…}]]	列表 list 的第 i，第 j，… 个元素组成的列表
Part[list,i;;j]	列表 list 的第 i 到第 j 个元素组成的列表

列表元素的运算.

取出列表的第二个元素：

Wolfram Language code: {5, 8, 6, 9}[[2]]

取出一组元素构成列表：

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

把列表赋给 v：

Wolfram Language code: v = {2, 4, 7}

提取 v 的元素：

Wolfram Language code: v[[2]]

通过把列表赋给变量，可以像其他计算机语言中的 “数组” 一样使用 Wolfram 语言列表. 因此. 例如，通过给 v[[i]] 赋值来重新设置元素列表.

Part[v,i] or v[[i]]	取出列表的第 i 个元素
Part[v,i]=value or v[[i]]=value	重新给列表的第 i 个元素赋值

类似数组的列表运算.

给出一个列表：

Wolfram Language code: v = {4, -1, 8, 7}

对列表的第三个元素重新赋值：

Wolfram Language code: v[[3]] = 0

现在赋给 v 的列表被修改了：

Wolfram Language code: v

向量和矩阵

在 Wolfram 语言中，向量和矩阵简单地分别用列表和列表的列表来表示.

{a,b,c}	向量
{{a,b},{c,d}}	矩阵

用列表表示向量和矩阵.

2×2 矩阵：

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

矩阵的第一行：

Wolfram Language code: m[[1]]

矩阵中的元素

：

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

一个二元向量：

Wolfram Language code: v = {x, y}

对象 p 和 q 被作为标量处理：

Wolfram Language code: p v + q

向量的加法是对应的分量加法：

Wolfram Language code: v + {xp, yp} + {xpp, ypp}

两个向量的点（数量）积：

Wolfram Language code: {x, y}.{xp, yp}

矩阵乘以向量：

Wolfram Language code: m.v

矩阵乘以矩阵：

Wolfram Language code: m.m

向量乘以矩阵：

Wolfram Language code: v.m

组合结果是一个数：

Wolfram Language code: v.m.v

由于 Wolfram 语言使用列表表示向量和矩阵，使用户完全不必区分“行”和“列”向量.

Table[f,{i,n}]	通过计算 i=1,2,…,n 时 f 的值，构造一个 n 维向量
Array[a,n]	构造形如 {a[1],a[2],…} 的 n 维向量
Range[n]	建立列表 {1,2,3,…,n}
Range[n₁,n₂]	建立列表 {n₁,n₁+1,…,n₂}
Range[n₁,n₂,dn]	建立列表 {n₁,n₁+dn,…,n₂}
list[[i]] or Part[list,i]	取出向量 list 的第 i 个元素
Length[list]	给出 list 的元素个数
c v	数乘向量
a.b	向量的点积
Cross[a,b]	向量的叉积（也输入为 a×b）
Norm[v]	向量的欧式范数（norm）

关于向量的函数.

Table[f,{i,m},{j,n}]	通过计算 i 从 1 到 m，j 从 1 到 n 的 f 的值，构造一个 m×n 矩阵
Array[a,{m,n}]	构造一个 m×n 矩阵，其第 i,j 个元素为 a[i,j]
IdentityMatrix[n]	生成一个 n×n 单位矩阵
DiagonalMatrix[list]	生成一个对角线上的元素为 list 的对角阵
list[[i]] or Part[list,i]	给出矩阵 list 的第 i 行
list[[All,j]] or Part[list,All,j]	给出矩阵 list 的第 j 列
list[[i,j]] or Part[list,i,j]	给出矩阵 list 的第 i,j 个元素
Dimensions[list]	给出矩阵 list 的维数

关于矩阵的函数.

Column[list]	在一个列中显示 list 的元素
MatrixForm[list]	用矩阵形式显示 list

向量和矩阵的格式构造.

构造一个 3×3 矩阵

，其元素为

：

Wolfram Language code: s = Table[i + j, {i, 3}, {j, 3}]

标准的二维矩阵形式显示 s：

Wolfram Language code: MatrixForm[s]

给出具有符号元素的一个向量. 可以用其推导对任何向量组成部分有效的一般公式：

Wolfram Language code: Array[a, 4]

给出具有符号元素的 3×2 矩阵. “由函数产生列表” 节将讨论如何用 Array 生成具有其他种类元素的矩阵：

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

上一个矩阵的维数：

Wolfram Language code: Dimensions[%]

生成一个 3×3 对角阵：

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

c m	用数乘以矩阵
a.b	两个矩阵的点积
Inverse[m]	矩阵的逆
MatrixPower[m,n]	矩阵的 n 次幂
Det[m]	矩阵的行列式
Tr[m]	矩阵的迹
Transpose[m]	矩阵的转置
Eigenvalues[m]	矩阵的特征值
Eigenvectors[m]	矩阵的特征向量

矩阵的一些运算.

前面定义的 2×2 符号变量矩阵：

Wolfram Language code: m

求出其行列式：

Wolfram Language code: Det[m]

m 的转置阵：

Wolfram Language code: Transpose[m]

给出符号形式的 m 的逆矩阵：

Wolfram Language code: Inverse[m]

3×3 有理矩阵：

Wolfram Language code: h = Table[1 / (i + j - 1), {i, 3}, {j, 3}]

逆矩阵：

Wolfram Language code: Inverse[h]

逆矩阵与原矩阵进行点积给出单位矩阵：

Wolfram Language code: %.h

3×3 矩阵：

Wolfram Language code: r = Table[i + j + 1, {i, 3}, {j, 3}]

Eigenvalues 给出矩阵的特征值：

Wolfram Language code: Eigenvalues[r]

给出矩阵的数值近似值：

Wolfram Language code: rn = N[r]

特征值的近似值：

Wolfram Language code: Eigenvalues[rn]

"Wolfram 语言中的线性代数 " 讨论 Wolfram 语言内部其他许多矩阵操作.

获得列表的部分元素

First[list]	list的第一个元素
Last[list]	list 的最后一个元素
Part[list,n] or list[[n]]	list 的第 n 个元素
Part[list,-n] or list[[-n]]	倒数第 n 个元素
Part[list,m;;n]	从第 m 到第 n 个元素
Part[list,{n₁,n₂,…}] or list[[{n₁,n₂,…}]]
	由第 n₁, n₂, … 个元素组成的列表

取出列表的元素.

使用该列表作为例子：

Wolfram Language code: t = {a, b, c, d, e, f, g}

t 的最后一个元素：

Wolfram Language code: Last[t]

给出第3个元素：

Wolfram Language code: t[[3]]

给出列表的第 3 到第 6 个元素：

Wolfram Language code: t[[3 ;; 6]]

给出列表的第1个和第4个元素：

Wolfram Language code: t[[{1, 4}]]

Take[list,n]	list 的前 n 个元素
Take[list,-n]	list 的后 n 个元素
Take[list,{m,n}]	list 中从 m 到 n 的元素
Rest[list]	去掉 list 的第一个元素
Drop[list,n]	去掉 list 的前 n 个元素
Most[list]	去掉 list 的最后一个元素
Drop[list,-n]	去掉 list 的后 n 个元素
Drop[list,{m,n}]	去掉 list 的从第 m 到第 n 个间的元素

取出列表元素的一些序列.

给出前面定义的列表 t 的前 3 个元素：

Wolfram Language code: Take[t, 3]

给出后 3 个元素：

Wolfram Language code: Take[t, -3]

给出从 2 到 5 的元素：

Wolfram Language code: Take[t, {2, 5}]

给出从 3 到 7，步长为 2 的元素：

Wolfram Language code: Take[t, {3, 7, 2}]

去掉 t 的第 1 个元素：

Wolfram Language code: Rest[t]

去掉 t 的前 3 个元素：

Wolfram Language code: Drop[t, 3]

去掉 t 的第 3 个元素：

Wolfram Language code: Drop[t, {3, 3}]

"同类列表的操作" 节将介绍如何将本节的所有函数推广到不仅用于列表，而且用于各种 Wolfram 语言表达式.

本节的函数允许用户提取列表中特定位置上的元素. "寻找与模式匹配的表达式" 节将介绍如何使用像 Select 和 Cases 这样的函数提取列表元素. 他们不是根据元素的位置，而是根据元素的特征进行提取.

检测和搜索列表元素

Position[list,form]	form 在 list 中的位置
Count[list,form]	form 作为 list 的元素所给出的次数
MemberQ[list,form]	检测 form 是否为 list 的元素
FreeQ[list,form]	检测 form 是否不在 list 中

检测和搜索列表的元素.

"获得列表的部分元素" 讨论如何根据元素的位置或标号提取列表的元素. Wolfram 系统也有根据元素的值搜索和检测列表元素的函数.

给出元素 a 在列表中的位置的列表：

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

Count 计算 a 出现的次数：

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

表明 a 是 {a,b,c} 的一个元素：

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

d 不是其中的元素：

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

定义 m 为一个 3×3 单位矩阵：

Wolfram Language code: m = IdentityMatrix[3]

表明 0 是 m 的元素：

Wolfram Language code: FreeQ[m, 0]

给出 0 出现在 m 中的位置的列表：

Wolfram Language code: Position[m, 0]

如同 "寻找与模式匹配的表达式" 节讨论，函数 Count 和 Position，以及 MemberQ 和 FreeQ，不仅能用于搜索“特定”的列表元素，而且能搜索与特定“模式”相匹配的元素类.

添加、删除和修改列表元素

Prepend[list,element]	在 list 的开头添加元素 element
Append[list,element]	在 list 的末尾添加元素 element
Insert[list,element,i]	在 list 的第 i 个位置上插入 element
Insert[list,element,-i]	在 list 的倒数第 i 个位置上插入 element
Riffle[list,element]	在 list 的位置上交错放置 element
Delete[list,i]	去掉 list 的第 i 个位置上的元素
ReplacePart[list,i->new]	用 new 替换 list 的第 i 个位置上的元素
ReplacePart[list,{i,j}->new]	用 new 替换 list[[i,j]]

在清晰的列表中的元素操作函数.

将 x 添加到列表的开头：

Wolfram Language code: Prepend[{a, b, c}, x]

将 x 插入到第 2 个位置上：

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

在列表的位置上交错放置 x：

Wolfram Language code: Riffle[{a, b, c}, x]

用 x 替换列表的第 3 个元素：

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

替换 2×2 矩阵中的第 1 个和第 2 个元素：

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

函数如 ReplacePart 用明确的列表产生新的列表. 然而，用户有时可能想要在合适的位置修改一个列表，而不明确产生一个新的列表.

v={e₁,e₂,…}	将一个列表赋给变量
v[[i]]=new	对第 i 个元素赋以新值

重设列表元素.

定义 v 为一个列表：

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

设置第 3 个元素为 x：

Wolfram Language code: v[[3]] = x

v 被修改了：

Wolfram Language code: v

m[[i,j]]=new	替换矩阵的第 (i,j) 个元素
m[[i]]=new	替换第 i 行
m[[All,i]]=new	替换第 i 列

重设矩阵的块.

定义 m 为一个矩阵：

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

设置矩阵的第一列：

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

对第一列的每个元素赋以值 0：

Wolfram Language code: m[[All, 1]] = 0;m

列表组合

Join[list₁,list₂,…]	把列表连接在一起
Union[list₁,list₂,…]	列表的并（合并列表，删除重复的元素，并整理结果）
Riffle[list₁,list₂]	交错放置 list₁ 和 list₂ 的元素

组合列表函数.

Join 可以连接任意多个列表：

Wolfram Language code: Join[{a, b, c}, {x, y}, {t, u}]

Union 合并列表，且保持列表中只有不同元素：

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

Riffle 通过交错放置列表的元素合并列表：

Wolfram Language code: Riffle[{a, b, c}, {x, y, z}]

作为集合的列表

Wolfram 语言通常按用户最初输入的元素顺序，保持列表元素. 但是，如果用户希望像数学集合一样处理 Wolfram 语言列表，可能希望不考虑元素在集合中的顺序.

Union[list₁,list₂,…]	给出 list_i 中不同元素的列表
Intersection[list₁,list₂,…]	给出 list_i 中共有的元素的列表
Complement[universal,list₁,…]	给出在 universal 中，但不在 list_i 中的元素的列表
Subsets[list]	给出 list 中元素的所有子集的列表
DeleteDuplicates[list]	从 list 中删除所有重复元素

集合论的函数.

Union 给出在任一个列表中出现的元素：

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

Intersection 给出在所有集合中都出现的元素：

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

Complement 给出在第 1 个集合出现，而不在其他集合中出现的元素：

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

给出该列表的所有子集

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

DeleteDuplicates 从列表中删除所有重复元素：

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

重排列表

Sort[list]	把列表 list 元素整理成标准顺序
Union[list]	整理元素，删除重复元素
Reverse[list]	对 list 的元素进行反向排序
RotateLeft[list,n]	把列表 list 元素向左轮换 n 个位置
RotateRight[list,n]	把列表元素向右轮换 n 个位置

重排列表函数.

把列表元素整理成标准顺序，此处，顺序是字母或数字：

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

整理元素，删除重复的元素：

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

把列表中的元素向左轮换（“移动”）两个位置：

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

可以通过给出负位移或使用 RotateRight 进行向右轮换：

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

PadLeft[list,len,x]	在 list 的左边用 x 进行填充，产生一个长度为 len 的列表
PadRight[list,len,x]	在 list 的右边进行填充

填充列表.

用 x 在列表的左边填充生成一个长度为 10 的列表：

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

列表元素的分组和合并

Partition[list,n]	把 list 分成 n 个元素一组
Partition[list,n,d]	使用偏移 d 进行逐次分组
Split[list]	把 list 按邻接的相同元素进行分组
SplitBy[list,f]	当应用 f 时，将 list 分为具有相同值得参数运行
Gather[list]	将 list 的参数收集到相同参数的子列表中
GatherBy[list,f]	当应用 f 时，将列表的参数收集到具有相同值的子列表中

列表元素的分组函数.

一个列表：

Wolfram Language code: t = {a, b, c, d, e, f, g}

把列表元素按对分组，此时，去掉末尾余下的单个元素：

Wolfram Language code: Partition[t, 2]

将元素分为 3 个一组，不同组之间没有重叠：

Wolfram Language code: Partition[t, 3]

分成 3 个元素一组，相邻的三元素组之间仅差一个元素：

Wolfram Language code: Partition[t, 3, 1]

把列表按邻接的相同元素进行分组：

Wolfram Language code: Split[{a, a, b, b, b, a, a, a, b}]

给出随机整数列表：

Wolfram Language code: t = RandomInteger[10, 20]

将列表分为偶数和奇数行：

Wolfram Language code: SplitBy[t, EvenQ]

将整数收集到子列表中：

Wolfram Language code: Gather[t]

根据等价模块3将整数收集到子列表中：

Wolfram Language code: GatherBy[t, Mod[#, 3]&]

Tuples[list,n]	生成所有元素是由 list 得来的 n 元组
Tuples[{list₁,list₂,…}]	生成所有第 i 个元素是由 list_i 得来的元组

寻找列表中元素的可能元组.

给出从列表中提取两个元素的所有可能性：

Wolfram Language code: Tuples[{a, b}, 2]

给出从每个列表中提取一个元素的所有可能性：

Wolfram Language code: Tuples[{{a, b}, {1, 2, 3}}]

列表中的排序

Sort[list]	把 list 中的元素按顺序排列
Ordering[list]	Sort[list] 中 list 元素的位置
Ordering[list,n]	Ordering[list] 的前 n 个元素
Ordering[list,-n]	Ordering[list] 的最后 n 个元素
Permutations[list]	list 的所有可能排序
Min[list]	list 中的最小元素
Max[list]	list 中的最大元素

列表中的排序.

一个由数构成的列表：

Wolfram Language code: t = {17, 21, 14, 9, 18}

按排好的顺序给出 t 的元素：

Wolfram Language code: Sort[t]

给出 t 的元素位置，从最小到最大的位置：

Wolfram Language code: Ordering[t]

与 Sort[t] 产生相同的结果：

Wolfram Language code: t[[%]]

给出列表中的最小元素：

Wolfram Language code: Min[t]

嵌套列表的重排

如果使用矩阵或生成多维数组的表，将会碰到嵌套列表. Wolfram 语言提供了许多函数来处理这样的列表.

Flatten[list]	压平 list 的所有层
Flatten[list,n]	压平 list 的前 n 层
Partition[list,{n₁,n₂,…}]	分成大小为 n₁×n₂×… 的块
Transpose[list]	交换列表的前两层
RotateLeft[list,{n₁,n₂,…}]	将层逐次轮换 n_i 个位置
PadLeft[list,{n₁,n₂,…}]	把第 i 层填充为长为 n_i 的子列表

嵌套列表重排函数.

“压平”子列表. 用户可以把他看作是去掉了内层集合的括号：

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

只压平了子列表的一层：

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

对嵌套列表还有许多其他运算. 在 "操作列表" 中将讨论更多操作.

Top

更多学习资源

技术支持

Wolfram 解决方案

Wolfram 的教育解决方案

开始

提高你的技能

与我们合作

成人教育计划

青少年教育计划

欢迎阅读

列表

列表

相关指南