列表—Wolfram 语言参考资料

link管理

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

相关文章推荐

成熟的春卷 · PHP_追风BOY· 4 月前 ·

没有腹肌的墨镜 · Splane tutorial: ...· 4 月前 ·

大力的拐杖 · getting error on ...· 6 月前 ·

热心的春卷 · 板块的边界在哪里？在天的尽头吗？_学说· 7 月前 ·

没读研的足球 · python三维列表降多个二维 - CSDN文库· 7 月前 ·

检测和搜索列表元素嵌套列表的重排

产生对象列表

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

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

三个数的列表：

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

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

% 的值是整个列表：

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

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

把列表赋给变量 v ：

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

将一些对象放在一起

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

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

一个数的列表：

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

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

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

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

值表的生成

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

给出

从 1 到 6 的

的值表：

一个

从

到

的

的表：

给出近似值：

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

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

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

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

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

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

生成一个

从 1 到 3，

从 1 到 2 的

的表：

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

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

值固定的情况下，

的值.

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

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

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

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

：

产生一个 3 × 2 的表格：

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

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

生成一个三维 2 × 2 × 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 ：

给出表格的第三部分：

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

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

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

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

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

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

t [ [ i ] ]

Part [ t , i ]

给出 t 的 i 个子列表（也作为 t 〚 i 〛输入）

t [ [ i ;; j ] ]

Part [ t , i ;; j ]

给出从 i 到 j 的部分列表

t [ [ { i ₁ , i ₂ , … } ] ]

Part [ t , { i ₁ , i ₂ , … } ]

给出 t 的 i ₁ ， i ₂ ， … 部分构成的列表

t [ [ i , j , … ] ]

Part [ t , i , j , … ]

给出 t 的相应于 t [ [ i ] ] [ [ j ] ] … 的部分元素列表

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

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

和

坐标一样.

处理列表中的元素

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

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

{ a , b , c }

一个列表

Part [ list , i ]

list [ [ i ] ]

列表 list 的第 i 个元素（第一个元素为 list [ [ 1 ] ] ）

Part [ list , { i , j , … } ]

list [ [ { i , j , … } ] ]

列表 list 的第 i ，第 j ， … 个元素组成的列表

Part [ list , i ;; j ]

列表 list 的第 i 到第 j 个元素组成的列表

列表元素的运算.

取出列表的第二个元素：

取出一组元素构成列表：

把列表赋给 v ：

提取 v 的元素：

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

Part [ v , i ]

v [ [ i ] ]

取出列表的第 i 个元素

Part [ v , i ] = value

v [ [ i ] ] = value

重新给列表的第 i 个元素赋值

类似数组的列表运算.

给出一个列表：

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

现在赋给 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 ] ]

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 ] ]

Part [ list , i ]

给出矩阵 list 的第 i 行

list [ [ All , j ] ]

Part [ list , All , j ]

给出矩阵 list 的第 j 列

list [ [ i , j ] ]

Part [ list , i , j ]

给出矩阵 list 的第 i , j 个元素

Dimensions [ list ]

给出矩阵 list 的维数

关于矩阵的函数.

First [ list ]

list 的第一个元素

Last [ list ]

list 的最后一个元素

Part [ list , n ]

list [ [ n ] ]

list 的第 n 个元素

Part [ list , - n ]

list [ [ - n ] ]

倒数第 n 个元素

Part [ list , m ;; n ]

从第 m 到第 n 个元素

Part [ list , { n ₁ , n ₂ , … } ]

list [ [ { n ₁ , n ₂ , … } ] ]

由第 n ₁ , n ₂ , … 个元素组成的列表

取出列表的元素.

使用该列表作为例子：

t 的最后一个元素：

给出第3个元素：

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

给出列表的第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 个元素：

给出后 3 个元素：

给出从 2 到 5 的元素：

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

去掉 t 的第 1 个元素：

去掉 t 的前 3 个元素：

去掉 t 的第 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 在列表中的位置的列表：

Count 计算 a 出现的次数：

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

d 不是其中的元素：

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

表明 0 是 m 的元素：

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

如同 "寻找与模式匹配的表达式" 节讨论，函数 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 添加到列表的开头：

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

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

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

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

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

m [ [ i , j ] ] = new

替换矩阵的第 ( i , j ) 个元素

m [ [ i ] ] = new

替换第 i 行

m [ [ All , i ] ] = new

替换第 i 列

重设矩阵的块.

定义 m 为一个矩阵：

设置矩阵的第一列：

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

列表组合

Join [ list ₁ , list ₂ , … ]

把列表连接在一起

Union [ list ₁ , list ₂ , … ]

列表的并（合并列表，删除重复的元素，并整理结果）

Riffle [ list ₁ , list ₂ ]

交错放置 list ₁ 和 list ₂ 的元素

组合列表函数.

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

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

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

作为集合的列表

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 给出在任一个列表中出现的元素：

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

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

给出该列表的所有子集

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

重排列表

Sort [ list ]

把列表 list 元素整理成标准顺序

Union [ list ]

整理元素，删除重复元素

Reverse [ list ]

对 list 的元素进行反向排序

RotateLeft [ list , n ]

把列表 list 元素向左轮换 n 个位置

RotateRight [ list , n ]

把列表元素向右轮换 n 个位置

重排列表函数.

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

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

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

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

PadLeft [ list , len , x ]

在 list 的左边用 x 进行填充，产生一个长度为 len 的列表

PadRight [ list , len , x ]

在 list 的右边进行填充

填充列表.

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

列表元素的分组和合并

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 时，将列表的参数收集到具有相同值的子列表中

列表元素的分组函数.

一个列表：

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

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

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

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

给出随机整数列表：

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

将整数收集到子列表中：

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

Tuples [ list , n ]

生成所有元素是由 list 得来的 n 元组

Tuples [ { list ₁ , list ₂ , … } ]

生成所有第 i 个元素是由 list _i 得来的元组

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

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

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

列表中的排序

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 中的最大元素

列表中的排序.

一个由数构成的列表：

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

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

与 Sort [ 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 的子列表

嵌套列表重排函数.

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

只压平了子列表的一层：

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