F# - 序列

序列与列表一样，也表示值的有序集合。但是，会在需要时计算序列或序列表达式中的元素。它们不是立即计算的，因此它们被用来表示无限的数据结构。

定义序列

序列使用以下语法定义 −

seq { expr }

例如，

let seq1 = seq { 1 .. 10 }

创建序列和序列表达式

与列表类似，您可以使用范围和推导式创建序列。

序列表达式是您可以为创建序列而编写的表达式。这些都可以做到 −

通过指定范围。
通过指定递增或递减的范围。
通过使用 yield 关键字生成成为序列一部分的值。
通过使用… 运算符。

以下示例演示了该概念 −

示例 1

(* Sequences *)
let seq1 = seq { 1 .. 10 }

(* ascending order and increment*)
printfn "The Sequence: %A" seq1
let seq2 = seq { 1 .. 5 .. 50 }

(* descending order and decrement*)
printfn "The Sequence: %A" seq2

let seq3 = seq {50 .. -5 .. 0}
printfn "The Sequence: %A" seq3

(* using yield *)
let seq4 = seq { for a in 1 .. 10 do yield a, a*a, a*a*a }
printfn "The Sequence: %A" seq4

当您编译并执行该程序时，它会产生以下输出 −

The Sequence: seq [1; 2; 3; 4; ...]
The Sequence: seq [1; 6; 11; 16; ...]
The Sequence: seq [50; 45; 40; 35; ...]
The Sequence: seq [(1, 1, 1); (2, 4, 8); (3, 9, 27); (4, 16, 64); ...]

示例 2

以下程序打印从 1 到 50 的质数 −

(* Recursive isprime function. *)
let isprime n =
   let rec check i =
      i > n/2 || (n % i <> 0 && check (i + 1))
   check 2

let primeIn50 = seq { for n in 1..50 do if isprime n then yield n }
for x in primeIn50 do
   printfn "%d" x

当您编译并执行该程序时，它会产生以下输出 −

序列的基本操作

下表显示了序列数据类型的基本操作−

值	描述
append : seq<'T> → seq<'T> → seq<'T>	将两个给定的枚举包装为单个串联枚举。
average : seq<^T> → ^T	返回序列中元素的平均值。
averageBy : ('T → ^U) → seq<'T> → ^U	返回将函数应用于序列的每个元素所生成的结果的平均值。
cache : seq<'T> → seq<'T>	返回与输入序列的缓存版本相对应的序列。
cast : IEnumerable → seq<'T>	包装松散类型的系统。作为类型化序列的集合序列。
choose : ('T → 'U option) → seq<'T> → seq<'U>	将给定函数应用于列表的每个元素。返回由函数返回 Some 的每个元素的结果组成的列表。
collect : ('T → 'Collection) → seq<'T> → seq<'U>	将给定函数应用于序列的每个元素并连接所有结果。
compareWith : ('T → 'T → int) → seq<'T> → seq<'T> → int	使用给定的比较函数逐个元素地比较两个序列。
concat : seq<'Collection> → seq<'T>	将给定的枚举组合为单个串联枚举。
countBy : ('T → 'Key) → seq<'T> → seq<'Key * int>	将键生成函数应用于序列的每个元素，并返回一个序列，生成唯一键及其在原始序列中出现的次数。
delay : (unit → seq<'T>) → seq<'T>	返回根据给定的延迟序列规范构建的序列。
distinct : seq<'T> → seq<'T>	根据条目上的通用哈希和相等比较，返回不包含重复条目的序列。如果一个元素在序列中出现多次，则后面出现的元素将被丢弃。
distinctBy : ('T → 'Key) → seq<'T> → seq<'T>	根据给定键生成函数返回的键的通用散列和相等比较，返回不包含重复条目的序列。如果一个元素在序列中出现多次，则后面出现的元素将被丢弃。
empty : seq<'T>	创建一个空序列。
exactlyOne : seq<'T> → 'T	返回序列中唯一的元素。
exists : ('T → bool) → seq<'T> → bool	测试序列中的任何元素是否满足给定谓词。
exists2 : ('T1 → 'T2 → bool) → seq<'T1> → seq<'T2> → bool	测试输入序列的任何一对对应元素是否满足给定的谓词。
filter : ('T → bool) → seq<'T> → seq<'T>	返回一个新集合，仅包含给定谓词返回 true 的集合元素。
find : ('T → bool) → seq<'T> → 'T	返回给定函数返回true的第一个元素。
findIndex : ('T → bool) → seq<'T> → int	返回给定函数返回true的第一个元素的索引。
fold : ('State → 'T → 'State) → 'State → seq<'T> → 'State	将函数应用于集合的每个元素，通过计算线程化累加器参数。如果输入函数为 f 并且元素为 i0...iN，则该函数计算 f (... (f s i0)...) iN。
forall : ('T → bool) → seq<'T> → bool	测试序列的所有元素是否满足给定谓词。
forall2 : ('T1 → 'T2 → bool) → seq<'T1> → seq<'T2> → bool	测试从两个序列中提取的所有元素对满足给定的谓词。如果一个序列比另一个序列短，则忽略较长序列的剩余元素。
groupBy : ('T → 'Key) → seq<'T> → seq<'Key * seq<'T>>	将键生成函数应用于序列的每个元素并生成唯一键的序列。每个唯一的键还包含与该键匹配的所有元素的序列。
head : seq<'T> → 'T	返回序列的第一个元素。
init : int → (int → 'T) → seq<'T>	生成一个新序列，该序列在迭代时通过调用给定函数返回连续元素，直到给定计数。调用该函数的结果不会被保存，即根据需要重新应用该函数以重新生成元素。该函数传递正在生成的项目的索引。
initInfinite : (int → 'T) → seq<'T>	生成一个新序列，迭代时将通过调用给定函数返回连续元素。调用该函数的结果不会被保存，也就是说，该函数将根据需要重新应用以重新生成元素。该函数传递正在生成的项目的索引。
isEmpty : seq<'T> → bool	测试序列是否包含任何元素。
iter : ('T → unit) → seq<'T> → unit
iter2 : ('T1 → 'T2 → unit) → seq<'T1> → seq<'T2> → unit	同时将给定函数应用于两个集合。如果一个序列比另一个序列短，则忽略较长序列的剩余元素。
iteri : (int → 'T → unit) → seq<'T> → unit	将给定函数应用于集合的每个元素。传递给函数的整数表示元素的索引。
last : seq<'T> → 'T	返回序列的最后一个元素。
length : seq<'T> → int	返回序列的长度。
map : ('T → 'U) → seq<'T> → seq<'U>	创建一个新集合，其元素是将给定函数应用于集合中每个元素的结果。当使用 MoveNext 方法从对象检索的枚举器需要元素时，将应用给定的函数。
map2 : ('T1 → 'T2 → 'U) → seq<'T1> → seq<'T2> → seq<'U>	创建一个新集合，其元素是将给定函数应用于两个序列中相应元素对的结果。如果一个输入序列比另一个输入序列短，则忽略较长序列的剩余元素。
mapi : (int → 'T → 'U) → seq<'T> → seq<'U>	创建一个新集合，其元素是将给定函数应用于集合中每个元素的结果。传递给函数的整数索引表示正在转换的元素的索引（从0开始）。
max : seq<'T> → 'T	返回序列中所有元素中最大的元素，并使用 Operators.max 进行比较。
maxBy : ('T → 'U) → seq<'T> → 'T	返回序列中所有元素中最大的元素，并通过对函数结果使用 Operators.max 进行比较。
min : seq<'T> → 'T	使用 Operators.min 进行比较，返回序列中所有元素中的最低元素。
minBy : ('T → 'U) → seq<'T> → 'T	通过对函数结果使用 Operators.min 进行比较，返回序列中所有元素的最低元素。
nth : int → seq<'T> → 'T	计算集合中的第 nth 个元素。
ofArray : 'T array → seq<'T>	将给定数组视为序列。
ofList : 'T list → seq<'T>	将给定列表视为序列。
pairwise : seq<'T> → seq<'T * 'T>	返回输入序列中每个元素及其前任元素的序列，但第一个元素除外，它仅作为第二个元素的前任返回。
pick : ('T → 'U option) → seq<'T> → 'U	将给定函数应用于连续元素，返回函数返回 Some 值的第一个值。
readonly : seq<'T> → seq<'T>	创建一个委托给给定序列对象的新序列对象。这确保了原始序列不能被类型转换重新发现和改变。例如，如果给定一个数组，则返回的序列将返回该数组的元素，但您不能将返回的序列对象强制转换为数组。
reduce : ('T → 'T → 'T) → seq<'T> → 'T	将函数应用于序列的每个元素，通过计算线程化累加器参数。首先将该函数应用于前两个元素。然后将此结果与第三个元素一起输入到函数中，依此类推。返回最终结果。
scan : ('State → 'T → 'State) → 'State → seq<'T> → seq<'State>	与 Seq.fold 类似，但按需计算并返回中间结果和最终结果的序列。
singleton : 'T → seq<'T>	返回仅产生一项的序列。
skip : int → seq<'T> → seq<'T>	返回一个序列，该序列跳过基础序列的指定数量的元素，然后生成序列的剩余元素。
skipWhile : ('T → bool) → seq<'T> → seq<'T>	返回一个序列，该序列在迭代时会跳过基础序列的元素，同时给定谓词返回 true，，然后生成序列的剩余元素。
sort : seq<'T> → seq<'T>	产生按键排序的序列。
sortBy : ('T → 'Key) → seq<'T> → seq<'T>	将键生成函数应用于序列的每个元素，并生成按键排序的序列。使用 Operators.compare 实现的通用比较来比较键。
sum : seq<^T> → ^T	返回序列中元素的总和。
sumBy	返回将函数应用于序列的每个元素所生成的结果的总和。
take : int → seq<'T> → seq<'T>	返回序列的第一个元素，最多达到指定的计数。
takeWhile : ('T → bool) → seq<'T> → seq<'T>	返回一个序列，该序列在迭代时生成基础序列的元素，同时给定谓词返回 true，，然后不再返回任何元素。
toArray : seq<'T> → 'T[]	从给定集合创建一个数组。
toList : seq<'T> → 'T list	从给定集合创建列表。
truncate : int → seq<'T> → seq<'T>	返回一个序列，枚举时返回不超过指定数量的元素。
tryFind : ('T → bool) → seq<'T> → 'T option	返回给定函数返回true的第一个元素，如果不存在这样的元素，则返回None。
tryFindIndex : ('T → bool) → seq<'T> → int option	返回序列中满足给定谓词的第一个元素的索引，如果不存在这样的元素，则返回None。
tryPick : ('T → 'U option) → seq<'T> → 'U option	将给定函数应用于连续元素，返回函数返回 Some 值的第一个值。
unfold : ('State → 'T * 'State option) → 'State → seq<'T>	返回一个序列，其中包含给定计算生成的元素。
where : ('T → bool) → seq<'T> → seq<'T>	返回一个新集合，仅包含给定谓词返回 true 的集合元素。 Seq.filter 的同义词。
windowed : int → seq<'T> → seq<'T []>	返回一个序列，该序列产生包含从输入序列中提取的元素的滑动窗口。每个窗口都作为新数组返回。
zip : seq<'T1> → seq<'T2> → seq<'T1 * 'T2>	将两个序列组合成一个对列表。两个序列不必具有相同的长度 − 当一个序列耗尽时，另一序列中的任何剩余元素都将被忽略。
zip3 : seq<'T1> → seq<'T2> → seq<'T3> → seq<'T1 * 'T2 * 'T3>	将三个序列组合成一个三元组列表。序列不需要具有相等的长度 − 当一个序列耗尽时，其他序列中的任何剩余元素都将被忽略。

以下示例演示了上述某些功能的用法 −

示例 1

该程序创建一个空序列并稍后将其填充 −

(* Creating sequences *)
let emptySeq = Seq.empty
let seq1 = Seq.singleton 20

printfn"The singleton sequence:"
printfn "%A " seq1
printfn"The init sequence:"

let seq2 = Seq.init 5 (fun n -> n * 3)
Seq.iter (fun i -> printf "%d " i) seq2
printfn""

(* converting an array to sequence by using cast *)
printfn"The array sequence 1:"
let seq3 = [| 1 .. 10 |] :> seq<int>
Seq.iter (fun i -> printf "%d " i) seq3
printfn""

(* converting an array to sequence by using Seq.ofArray *)
printfn"The array sequence 2:"
let seq4 = [| 2..2.. 20 |] |> Seq.ofArray
Seq.iter (fun i -> printf "%d " i) seq4
printfn""

当您编译并执行该程序时，它会产生以下输出 −

The singleton sequence:
seq [20]
The init sequence:
0 3 6 9 12
The array sequence 1:
1 2 3 4 5 6 7 8 9 10
The array sequence 2:
2 4 6 8 10 12 14 16 18 20

请注意 −

Seq.empty 方法创建一个空序列。
Seq.singleton 方法创建仅包含一个指定元素的序列。
Seq.init 方法创建一个序列，使用给定函数为其创建元素。
Seq.ofArray 和 Seq.ofList<'T> 方法从数组和列表创建序列。
Seq.iter 方法允许迭代序列。

示例 2

Seq.unfold 方法从计算函数生成一个序列，该函数采用一个状态并将其转换以生成序列中的每个后续元素。

以下函数生成前 20 个自然数 −

let seq1 = Seq.unfold (fun state -> if (state > 20) then None else Some(state, state + 1)) 0
printfn "The sequence seq1 contains numbers from 0 to 20."
for x in seq1 do printf "%d " x
printfn" "

当您编译并执行该程序时，它会产生以下输出 −

The sequence seq1 contains numbers from 0 to 20.
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

示例 3

Seq.truncate 方法从另一个序列创建一个序列，但将该序列限制为指定数量的元素。

Seq.take 方法创建一个新序列，其中包含从序列开头算起的指定数量的元素。

let mySeq = seq { for i in 1 .. 10 -> 3*i }
let truncatedSeq = Seq.truncate 5 mySeq
let takeSeq = Seq.take 5 mySeq

printfn"The original sequence"
Seq.iter (fun i -> printf "%d " i) mySeq
printfn""

printfn"The truncated sequence"
Seq.iter (fun i -> printf "%d " i) truncatedSeq
printfn""

printfn"The take sequence"
Seq.iter (fun i -> printf "%d " i) takeSeq
printfn""

当您编译并执行该程序时，它会产生以下输出 −

The original sequence
3 6 9 12 15 18 21 24 27 30
The truncated sequence
3 6 9 12 15
The take sequence
3 6 9 12 15

F# 基础教程

F# - 序列

定义序列

创建序列和序列表达式

示例 1

示例 2

序列的基本操作

示例 1

示例 2

示例 3

颜色选择器

读后有收获微信请站长喝咖啡

错误报告

您的建议:

感谢您的帮助！