首页 > 其他分享 >无涯教程-F# - 列表(Lists)

无涯教程-F# - 列表(Lists)

时间:2023-11-28 19:31:27浏览次数:53  
标签:教程 list1 元素 list 无涯 Lists 列表 let printfn

在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

相关文章

  • Linux—nvm教程
    简介NVM是node.js的版本管理器,设计为每个用户安装,每个shell调用。可以在任何posix兼容的shell(sh、dash、ksh、zsh、bash)上工作,特别是在这些平台上:unix、macOS和windowsWSL。背景随着项目数量增加,不同项目对node版本有不同要求,基于现有的单node版本无法支持多项目多node进行......
  • 无涯教程-F# - 记录(Records)
    记录(Records)类似于元组,但是它包含命名字段。例如,typewebsite={title:string;url:string}定义记录使用type关键字将记录定义为类型,并将记录的字段定义为以分号分隔的列表。定义记录的语法是-typerecordName={[fieldName:dataType]+}创建......
  • mysql主从同步详细教程
    mysql主从同步详细教程 1、安装好主数据库和从数据库,这个大家肯定都会,如果不是很明白,可以参考我前面的安装教程。例子:假如我需要同步test1、test2数据库  系统:centos7主库主机:192.168.1.252 从库主机:192.168.1.251  端口都是:33062、主数据......
  • 无涯教程-F# - 数据类型
    F#中的数据类型可以分类如下-整数类型浮点类型文本类型其他类型整体数据类型下表提供了F#的整数数据类型,这些基本上是整数数据类型。F#TypeSizeRangeExampleRemarkssbyte1byte-128to12742y-11y8-bitsignedintegerbyte1byte0to25542uy200uy8-......
  • 无涯教程-MySQL String Functions函数
    Sr.No.Name&Description1ASCII()返回最左边字符的数值2BIN()返回参数的字符串表示形式3BIT_LENGTH()返回参数的长度(以位为单位)4CHAR_LENGTH()返回参数中的字符数5CHAR()返回传递的每个整数的字符6CHARACTER_LENGTH()CHAR_LENGTH()的同义词7......
  • 无涯教程-MySQL Numeric Functions函数
    MySQL数值函数主要用于数值运算和/或数学计算。下表详细介绍了MySQL实现中可用的数值函数。Sr.No.Name&Description1ABS()返回数值表达式的绝对值。2ACOS()返回数值表达式的反余弦值。如果该值不在-1到1之间,则返回NULL。3ASIN()返回数字表达式的反正弦值。如......
  • SQL Server2022安装图文教程
      一:下载 本次安装测试系统环境:    1、官网下载链接https://www.microsoft.com/zh-cn/sql-server/sql-server-downloadsSQLServer下载|Microsoft    2、在下载目录中找到下面这个小的安装包SQL2022-SSEI-Dev.exe,运行开始下载SQLserver;   二:安装SqlServer2022......
  • 无涯教程-MySQL AVG Function函数
    MySQLAVG函数用于查找各种记录中某个字段的平均值。要了解AVG函数,请考虑一个employee_tbl表,该表具有以下记录-mysql>SELECT*FROMemployee_tbl;+------+------+------------+--------------------+|id|name|work_date|daily_typing_pages|+------+-......
  • 无涯教程-MySQL MIN Function函数
    MySQLMIN函数用于在记录集中找出最小值的记录。要了解MIN函数,请考虑一个employee_tbl表,该表具有以下记录-mysql>SELECT*FROMemployee_tbl;+------+------+------------+--------------------+|id|name|work_date|daily_typing_pages|+------+-----......
  • 无涯教程-MySQL IN Clause函数
    您可以使用IN子句替换许多OR条件要了解IN子句,请考虑一个employee_tbl表,该表具有以下记录-mysql>SELECT*FROMemployee_tbl;+------+------+------------+--------------------+|id|name|work_date|daily_typing_pages|+------+------+------------......