在F#中,列表(Lists)是相同类型的元素的有序、不可变的组合,它在某种程度上等效于链表数据结构。
F#模块 Microsoft.FSharp.Collections.List 具有列表上的常用操作,但是,F#会自动导入此模块,并使每个F#应用程序都可以访问它。
List初始化
以下是创建列表的各种方法-
使用List 字面量。
使用 cons (::)运算符。
使用 List.init 方法。
使用语法结构 。
List字面量
在此方法中,您只需在方括号中指定以分号分隔的值序列。如-
let list1=[1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
Cons(::)运算符
使用此方法,您可以使用::运算符将其添加到现有列表的前面或 cons-ing 来添加一些值。如-
let list2=1::2::3::4::5::6::7::8::9::10::[];;
[]表示一个空列表。
List.init谅
列表模块的List.init方法通常用于创建列表。此方法的类型为-
val init : int -> (int -> 'T) -> 'T list
第一个参数是新列表的所需长度,第二个参数是初始化函数,该函数在列表中生成项目。
let list5=List.init 5 (fun index -> (index, index * index, index * index * index))
在这里,索引函数生成列表。
List语法结构
列表理解是用于生成列表的特殊语法构造,范围具有结构-[start..end]和[start..step..end]
let list3=[1 .. 10]
生成器具有以下结构-[对于x in collection do ... yield expr]
let list6=[ for a in 1 .. 10 do yield (a * a) ]
当 yield 关键字将单个值推入列表时,关键字 yield!将值的集合推入列表。
以下功能演示了上述方法-
(* using list literals *) let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] printfn "The list: %A" list1 (*using cons operator *) let list2 = 1::2::3::[] printfn "The list: %A" list2 (* using range constructs*) let list3 = [1 .. 10] printfn "The list: %A" list3 (* using range constructs *) let list4 = ['a' .. 'm'] printfn "The list: %A" list4 (* using init method *) let list5 = List.init 5 (fun index -> (index, index * index, index * index * index)) printfn "The list: %A" list5 (* using yield operator *) let list6 = [ for a in 1 .. 10 do yield (a * a) ] printfn "The list: %A" list6 (* using yield operator *) let list7 = [ for a in 1 .. 100 do if a % 3 = 0 && a % 5 = 0 then yield a] printfn "The list: %A" list7 (* using yield! operator *) let list8 = [for a in 1 .. 3 do yield! [ a .. a + 3 ] ] printfn "The list: %A" list8
编译并执行程序时,将产生以下输出-
The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] The list: [1; 2; 3] The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] The list: ['a'; 'b'; 'c'; 'd'; 'e'; 'f'; 'g'; 'h'; 'i'; 'j'; 'k'; 'l'; 'm'] The list: [(0, 0, 0); (1, 1, 1); (2, 4, 8); (3, 9, 27); (4, 16, 64)] The list: [1; 4; 9; 16; 25; 36; 49; 64; 81; 100] The list: [15; 30; 45; 60; 75; 90] The list: [1; 2; 3; 4; 2; 3; 4; 5; 3; 4; 5; 6]
列表属性
属性 | 类型 | 说明 |
---|---|---|
Head | 'T | 第一个元素。 |
Empty | 'T list | 一个静态属性,它返回适当类型的空列表。 |
IsEmpty | bool | true (如果列表中没有元素)。 |
Item | 'T | 位于指定索引处的元素(从零开始)。 |
Length | int | 元素数。 |
Tail | 'T list | 不包含第一个元素的列表。 |
以下示例显示了这些属性的用法-
let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ] //Use of Properties printfn "list1.IsEmpty is %b" (list1.IsEmpty) printfn "list1.Length is %d" (list1.Length) printfn "list1.Head is %d" (list1.Head) printfn "list1.Tail.Head is %d" (list1.Tail.Head) printfn "list1.Tail.Tail.Head is %d" (list1.Tail.Tail.Head) printfn "list1.Item(1) is %d" (list1.Item(1))
编译并执行程序时,将产生以下输出-
list1.IsEmpty is false list1.Length is 8 list1.Head is 2 list1.Tail.Head is 4 list1.Tail.Tail.Head is 6 list1.Item(1) is 4
基本操作
下表显示了列表数据类型的基本操作-
Value | 描述 |
---|---|
append : 'T list → 'T list → 'T list | 返回一个新列表,其中包含第一个列表的元素,然后是第二个列表的元素。 |
average : 'T list → ^T | 返回列表中元素的平均值。 |
averageBy : ('T → ^U) → 'T list → ^U | 返回通过将函数应用于列表的每个元素而生成的元素的平均值。 |
choose : ('T → 'U option) → 'T list → 'U list | 将给定函数应用于列表的每个元素。返回由函数返回Some的每个元素的结果组成的列表。 |
collect : ('T → 'U list) → 'T list → 'U list | 对于列表的每个元素,应用给定的功能。连接所有结果并返回合并的列表。 |
concat : seq<'T list> → 'T list | 返回一个新列表,该列表按顺序包含每个列表的元素。 |
empty : 'T list | 返回给定类型的空列表。 |
exists : ('T → bool) → 'T list → bool | 测试列表中的任何元素是否满足给定谓词。 |
exists2 : ('T1 → 'T2 → bool) → 'T1 list → 'T2 list → bool | 测试列表中的任何一对对应元素是否满足给定谓词。 |
filter : ('T → bool) → 'T list → 'T list | 返回一个仅包含给定谓词返回true的集合元素的新集合。 |
find : ('T → bool) → 'T list → 'T | 返回给定函数为其返回true的第一个元素。 |
findIndex : ('T → bool) → 'T list → int | 返回满足给定谓词的列表中第一个元素的索引。 |
fold : ('State → 'T → 'State) → 'State → 'T list → 'State | 将函数应用于集合的每个元素,从而在计算过程中穿插累加器参数。此函数采用第二个参数,并将该函数应用于它和列表的第一个元素。然后,它将结果与第二个元素一起传递给函数,依此类推。最后,它返回最终结果。如果输入函数为f并且元素为i0 ... iN,则此函数将计算f(...(f s i0)i1 ...)iN。 |
fold2 : ('State → 'T1 → 'T2 → 'State) → 'State → 'T1 list → 'T2 list → 'State | 将一个函数应用于两个集合的相应元素,从而通过计算对累加器参数进行线程化。集合必须具有相同的大小。如果输入函数为f并且元素为i0 ... iN和j0 ... jN,则此函数计算f(...(f s i0 j0)...)iN jN。 |
foldBack : ('T → 'State → 'State) → 'T list → 'State → 'State | 将函数应用于集合的每个元素,从而在计算过程中穿插累加器参数。如果输入函数isf且元素为i0 ... iN,则计算f i0(...(f iN s))。 |
foldBack2 : ('T1 → 'T2 → 'State → 'State) → 'T1 list → 'T2 list → 'State → 'State | 将一个函数应用于两个集合的相应元素,从而通过计算对累加器参数进行线程化。集合必须具有相同的大小。如果输入函数为f并且元素为i0 ... iN和j0 ... jN,则此函数将计算f i0 j0(...(f iN jN s))。 |
forall : ('T → bool) → 'T list → bool | 测试集合的所有元素是否满足给定谓词。 |
forall2 : ('T1 → 'T2 → bool) → 'T1 list → 'T2 list → bool | 测试集合中所有对应的元素是否成对地满足给定谓词。 |
head : 'T list → 'T | 返回列表的第一个元素。 |
init : int → (int → 'T) → 'T list | 通过在每个索引上调用给定的生成器来创建列表。 |
isEmpty : 'T list → bool | 如果列表不包含任何元素,则返回true,否则返回false。 |
iter : ('T → unit) → 'T list → unit | 将给定函数应用于集合的每个元素。 |
iter2 : ('T1 → 'T2 → unit) → 'T1 list → 'T2 list → unit | 将给定函数同时应用于两个集合。集合必须具有相同的大小。 |
iteri : (int → 'T → unit) → 'T list → unit | 将给定函数应用于集合的每个元素。传递给函数的整数表示元素的索引。 |
iteri2 : (int → 'T1 → 'T2 → unit) → 'T1 list → 'T2 list → unit | 将给定函数同时应用于两个集合。集合必须具有相同的大小。传递给函数的整数表示元素的索引。 |
length : 'T list → int | 返回列表的长度。 |
map : ('T → 'U) → 'T list → 'U list | 创建一个新集合,其元素是将给定功能应用于集合的每个元素的结果。 |
map2 : ('T1 → 'T2 → 'U) → 'T1 list → 'T2 list → 'U list | 创建一个新集合,其元素是成对地将给定函数应用于两个集合的相应元素的结果。 |
map3 : ('T1 → 'T2 → 'T3 → 'U) → 'T1 list → 'T2 list → 'T3 list → 'U list | 创建一个新集合,其元素是同时将给定功能应用于三个集合的相应元素的结果。 |
mapi : (int → 'T → 'U) → 'T list → 'U list | 创建一个新集合,其元素是将给定功能应用于集合的每个元素的结果。传递给函数的整数索引指示要转换的元素的索引(从0开始)。 |
mapi2 : (int → 'T1 → 'T2 → 'U) → 'T1 list → 'T2 list → 'U list | 类似于List.mapi,但是映射两个相等长度的列表中的对应元素。 |
max : 'T list → 'T | 通过使用Operators.max,返回列表中所有元素中最大的一个。 |
maxBy : ('T → 'U) → 'T list → 'T | 返回列表中所有元素中最大的一个,通过对函数结果使用Operators.max进行比较。 |
min : 'T list → 'T | 通过使用Operators.min进行比较,返回列表中所有元素中的最低元素。 |
minBy : ('T → 'U) → 'T list → 'T | 返回列表中所有元素的最低值,通过对函数结果使用Operators.min进行比较 |
nth : 'T list → int → 'T | 索引到列表。第一个元素的索引为0。 |
ofArray : 'T [] → 'T list | 从给定数组创建一个列表。 |
ofSeq : seq<'T> → 'T list | 从给定的可枚举对象创建一个新列表。 |
partition : ('T → bool) → 'T list * 'T list | 将集合分为两个集合,其中包含给定谓词分别返回true和false的元素。 |
permute : (int → int) → 'T list → 'T list | 返回一个列表,其中所有元素均根据指定的排列进行排列。 |
pick : ('T → 'U option) → 'T list → 'U | 将给定的函数应用于连续的元素,返回第一个结果,其中函数针对某个值返回Some。 |
reduce : ('T → 'T → 'T) → 'T list → 'T | 将函数应用于集合的每个元素,从而在计算过程中穿插累加器参数。此函数将指定的函数应用于列表的前两个元素。然后将结果与第三个元素一起传递给函数,依此类推。最后,它返回最终结果。如果输入函数为f并且元素为i0 ... iN,则此函数将计算f(...(f i0 i1)i2 ...)iN。 |
reduceBack : ('T → 'T → 'T) → 'T list → 'T | 将函数应用于集合的每个元素,从而在计算过程中穿插累加器参数。如果输入函数isf且元素为i0 ... iN,则此函数将计算f i0(...(f iN-1 iN))。 |
replicate : (int → 'T → 'T list) | 通过在每个索引上调用给定的生成器来创建列表。 |
rev : 'T list → 'T list | 返回具有相反顺序元素的新列表。 |
scan : ('State → 'T → 'State) → 'State → 'T list → 'State list | 将函数应用于集合的每个元素,从而在计算过程中穿插累加器参数。此函数采用第二个参数,并将指定的函数应用于该参数和列表的第一个元素。然后,它将结果与第二个元素一起传递给函数,依此类推。最后,它返回中间结果和最终结果的列表。 |
scanBack : ('T → 'State → 'State) → 'T list → 'State → 'State list | 与foldBack类似,但同时返回中间结果和最终结果 |
sort : 'T list → 'T list | 使用Operators.compare对给定列表进行排序。 |
sortBy : ('T → 'Key) → 'T list → 'T list | 使用给定投影给定的键对给定列表进行排序。使用Operators.compare比较密钥。 |
sortWith : ('T → 'T → int) → 'T list → 'T list | 使用给定的比较函数对给定的列表进行排序。 |
sum : ^T list → ^T | 返回列表中元素的总和。 |
sumBy : ('T → ^U) → 'T list → ^U | 返回通过将该函数应用于列表的每个元素而生成的结果的总和。 |
tail : 'T list → 'T list | 返回不包含第一个元素的输入列表。 |
toArray : 'T list → 'T [] | 从给定列表创建一个数组。 |
toSeq : 'T list → seq<'T> | 以序列查看给定列表。 |
tryFind : ('T → bool) → 'T list → 'T option | 返回给定函数为其返回true的第一个元素。如果不存在这样的元素,则返回None。 |
tryFindIndex : ('T → bool) → 'T list → int option | 返回满足给定谓词的列表中第一个元素的索引。如果不存在这样的元素,则返回None。 |
tryPick : ('T → 'U option) → 'T list → 'U option | 将给定的函数应用于连续的元素,返回第一个结果,其中函数针对某个值返回Some。如果不存在这样的元素,则返回None。 |
unzip : ('T1 * 'T2) list → 'T1 list * 'T2 list | 将成对列表分成两个列表。 |
unzip3 : ('T1 * 'T2 * 'T3) list → 'T1 list * 'T2 list * 'T3 list | 将三元组列表分成三个列表。 |
zip : 'T1 list → 'T2 list → ('T1 * 'T2) list | 将两个列表合并成对列表。这两个列表的长度必须相等。 |
zip3 : 'T1 list → 'T2 list → 'T3 list → ('T1 * 'T2 * 'T3) list | 将三个列表合并为一个三元组列表。列表的长度必须相等。 |
以下示例演示了上述功能的用法-
递归示例
该程序显示递归地反转列表-
let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ] printfn "The original list: %A" list1 let reverse lt = let rec loop acc = function | [] -> acc | hd::tl -> loop (hd::acc) tl loop [] lt printfn "The reversed list: %A" (reverse list1)
编译并执行程序时,将产生以下输出-
The original list: [2; 4; 6; 8; 10; 12; 14; 16] The reversed list: [16; 14; 12; 10; 8; 6; 4; 2]
但是,您可以将模块的 rev 功能用于相同的目的-
let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ] printfn "The original list: %A" list1 printfn "The reversed list: %A" (List.rev list1)
编译并执行程序时,将产生以下输出-
The original list: [2; 4; 6; 8; 10; 12; 14; 16] The reversed list: [16; 14; 12; 10; 8; 6; 4; 2]
List.filter示例
该程序显示使用 List.filter 方法过滤列表-
let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] printfn "The list: %A" list1 let list2 = list1 |> List.filter (fun x -> x % 2 = 0);; printfn "The Filtered list: %A" list2
编译并执行程序时,将产生以下输出-
The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] The Filtered list: [2; 4; 6; 8; 10]
List.map示例
List.map 方法将列表从一种类型映射到另一种类型-
let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] printfn "The list: %A" list1 let list2 = list1 |> List.map (fun x -> (x * x).ToString());; printfn "The Mapped list: %A" list2
编译并执行程序时,将产生以下输出-
The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] The Mapped list: ["1"; "4"; "9"; "16"; "25"; "36"; "49"; "64"; "81"; "100"]
List.append示例
List.append 方法和@运算符将一个列表追加到另一个-
let list1 = [1; 2; 3; 4; 5 ] let list2 = [6; 7; 8; 9; 10] let list3 = List.append list1 list2 printfn "The first list: %A" list1 printfn "The second list: %A" list2 printfn "The appened list: %A" list3 let lt1 = ['a'; 'b';'c' ] let lt2 = ['e'; 'f';'g' ] let lt3 = lt1 @lt2 printfn "The first list: %A" lt1 printfn "The second list: %A" lt2 printfn "The appened list: %A" lt3
编译并执行程序时,将产生以下输出-
The first list: [1; 2; 3; 4; 5] The second list: [6; 7; 8; 9; 10] The appened list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] The first list: ['a'; 'b'; 'c'] The second list: ['e'; 'f'; 'g'] The appened list: ['a'; 'b'; 'c'; 'e'; 'f'; 'g']
List.sort 示例
List.sort 方法对列表进行排序, List.sum 方法给出列表中元素的总和,而 List.average 方法给出列表中元素的平均值-
let list1 = [9.0; 0.0; 2.0; -4.5; 11.2; 8.0; -10.0] printfn "The list: %A" list1 let list2 = List.sort list1 printfn "The sorted list: %A" list2 let s = List.sum list1 let avg = List.average list1 printfn "The sum: %f" s printfn "The average: %f" avg
编译并执行程序时,将产生以下输出-
The list: [9.0; 0.0; 2.0; -4.5; 11.2; 8.0; -10.0] The sorted list: [-10.0; -4.5; 0.0; 2.0; 8.0; 9.0; 11.2] The sum: 15.700000 The average: 2.242857
"折叠"操作将函数应用于列表中的每个元素,将该函数的输出汇总到累加器变量中,并作为折叠操作的输出返回累加器。
List.fold示例
List.fold 方法从左到右对每个元素应用一个函数,而 List.foldBack 从右到左对每个元素应用一个函数。
let sumList list = List.fold (fun acc elem -> acc + elem) 0 list printfn "Sum of the elements of list %A is %d." [ 1 .. 10 ] (sumList [ 1 .. 10 ])
编译并执行程序时,将产生以下输出-
Sum of the elements of list [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] is 55.
参考链接
https://www.learnfk.com/fsharp/fsharp-lists.html
标签:教程,list1,元素,list,无涯,Lists,列表,let,printfn From: https://blog.51cto.com/u_14033984/8604470