F # - Listen
In F # ist eine Liste eine geordnete, unveränderliche Reihe von Elementen desselben Typs. Es entspricht in gewissem Maße einer verknüpften Listendatenstruktur.
Das F # -Modul, Microsoft.FSharp.Collections.List,hat die gemeinsamen Operationen auf Listen. F # importiert dieses Modul jedoch automatisch und macht es für jede F # -Anwendung zugänglich.
Erstellen und Initialisieren einer Liste
Im Folgenden finden Sie die verschiedenen Möglichkeiten zum Erstellen von Listen:
Liste verwenden literals.
Verwenden von cons (::) Operator.
Verwendung der List.init Methode des Listenmoduls.
Mit etwas syntactic constructs namens List Comprehensions.
Literale auflisten
Bei dieser Methode geben Sie einfach eine durch Semikolons getrennte Folge von Werten in eckigen Klammern an. Zum Beispiel -
let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]Die Nachteile (: :) Operator
Mit dieser Methode können Sie einige Werte hinzufügen, indem Sie oder voranstellen cons-inges mit dem Operator :: in eine vorhandene Liste. Zum Beispiel -
let list2 = 1::2::3::4::5::6::7::8::9::10::[];;[] bezeichnet eine leere Liste.
List init Methode
Die List.init-Methode des List-Moduls wird häufig zum Erstellen von Listen verwendet. Diese Methode hat den Typ -
val init : int -> (int -> 'T) -> 'T listDas erste Argument ist die gewünschte Länge der neuen Liste, und das zweite Argument ist eine Initialisierungsfunktion, die Elemente in der Liste generiert.
Zum Beispiel,
let list5 = List.init 5 (fun index -> (index, index * index, index * index * index))Hier generiert die Indexfunktion die Liste.
Listenverständnisse
Listenverständnis sind spezielle syntaktische Konstrukte, die zum Generieren von Listen verwendet werden.
Die Syntax des F # -Listenverständnisses gibt es in zwei Formen - Bereiche und Generatoren.
Bereiche haben die Konstrukte - [Start .. Ende] und [Start .. Schritt .. Ende]
Zum Beispiel,
let list3 = [1 .. 10]Generatoren haben das Konstrukt - [für x in Sammlung do ... Ausbeute Ausdruck]
Zum Beispiel,
let list6 = [ for a in 1 .. 10 do yield (a * a) ]Als die yield Schlüsselwort schiebt einen einzelnen Wert in eine Liste, das Schlüsselwort, yield!, schiebt eine Sammlung von Werten in die Liste.
Die folgende Funktion demonstriert die oben genannten Methoden -
Beispiel
(* 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" list8Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:
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]Eigenschaften des Listendatentyps
Die folgende Tabelle zeigt verschiedene Eigenschaften des Listendatentyps -
| Eigentum | Art | Beschreibung |
|---|---|---|
| Kopf | 'T. | Das erste Element. |
| Leer | 'T Liste | Eine statische Eigenschaft, die eine leere Liste des entsprechenden Typs zurückgibt. |
| Ist leer | Bool | true wenn die Liste keine Elemente enthält. |
| Artikel | 'T. | Das Element am angegebenen Index (nullbasiert). |
| Länge | int | Die Anzahl der Elemente. |
| Schwanz | 'T Liste | Die Liste ohne das erste Element. |
Das folgende Beispiel zeigt die Verwendung dieser Eigenschaften -
Beispiel
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))Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:
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 4Grundlegende Operatoren auf Liste
Die folgende Tabelle zeigt die grundlegenden Operationen für den Listendatentyp -
| Wert | Beschreibung |
|---|---|
| anhängen: 'T-Liste →' T-Liste → 'T-Liste | Gibt eine neue Liste zurück, die die Elemente der ersten Liste gefolgt von den Elementen der zweiten Liste enthält. |
| Durchschnitt: 'T Liste → ^ T. | Gibt den Durchschnitt der Elemente in der Liste zurück. |
| Durchschnitt durch: ('T → ^ U) →' T Liste → ^ U. | Gibt den Durchschnitt der Elemente zurück, die durch Anwenden der Funktion auf jedes Element der Liste generiert wurden. |
| Wählen Sie: (Option 'T →' U) → 'T-Liste →' U-Liste | Wendet die angegebene Funktion auf jedes Element der Liste an. Gibt die Liste mit den Ergebnissen für jedes Element zurück, bei dem die Funktion zurückgegeben wirdSome. |
| sammeln: ('T →' U-Liste) → 'T-Liste →' U-Liste | Wendet für jedes Element der Liste die angegebene Funktion an. Verkettet alle Ergebnisse und gibt die kombinierte Liste zurück. |
| concat: seq <'T-Liste> →' T-Liste | Gibt eine neue Liste zurück, die die Elemente der einzelnen Listen in der angegebenen Reihenfolge enthält. |
| leer: 'T Liste | Gibt eine leere Liste des angegebenen Typs zurück. |
| existiert: ('T → bool) →' T Liste → bool | Testet, ob ein Element der Liste das angegebene Prädikat erfüllt. |
| existiert2: ('T1 →' T2 → Bool) → 'T1-Liste →' T2-Liste → Bool | Testet, ob ein Paar entsprechender Elemente der Listen das angegebene Prädikat erfüllt. |
| Filter: ('T → bool) →' T-Liste → 'T-Liste | Gibt eine neue Sammlung zurück, die nur die Elemente der Sammlung enthält, für die das angegebene Prädikat zurückgegeben wird true. |
| find: ('T → bool) →' T list → 'T. | Gibt das erste Element zurück, für das die angegebene Funktion zurückgegeben wird true. |
| findIndex: ('T → bool) →' T list → int | Gibt den Index des ersten Elements in der Liste zurück, das das angegebene Prädikat erfüllt. |
| Falz: ('Zustand →' T → 'Zustand) →' Zustand → 'T-Liste →' Zustand | Wendet eine Funktion auf jedes Element der Sammlung an und führt ein Akkumulatorargument durch die Berechnung. Diese Funktion nimmt das zweite Argument und wendet die Funktion auf es und das erste Element der Liste an. Dann übergibt es dieses Ergebnis zusammen mit dem zweiten Element an die Funktion und so weiter. Schließlich wird das Endergebnis zurückgegeben. Wenn die Eingabefunktion f ist und die Elemente i0 ... iN sind, berechnet diese Funktion f (... (fs i0) i1 ...) iN. |
| fold2: ('Status →' T1 → 'T2 →' Status) → 'Status →' T1-Liste → 'T2-Liste →' Status | Wendet eine Funktion auf entsprechende Elemente von zwei Sammlungen an und führt ein Akkumulatorargument durch die Berechnung. Die Sammlungen müssen identische Größen haben. Wenn die Eingabefunktion f ist und die Elemente i0 ... iN und j0 ... jN sind, berechnet diese Funktion f (... (fs i0 j0) ...) iN jN. |
| foldBack: ('T →' Status → 'Status) →' T-Liste → 'Status →' Status | Wendet eine Funktion auf jedes Element der Sammlung an und führt ein Akkumulatorargument durch die Berechnung. Wenn die Eingabefunktion isf ist und die Elemente i0 ... iN sind, wird f i0 (... (f iN s)) berechnet. |
| foldBack2: ('T1 →' T2 → 'Status →' Status) → 'T1-Liste →' T2-Liste → 'Status →' Status | Wendet eine Funktion auf entsprechende Elemente von zwei Sammlungen an und führt ein Akkumulatorargument durch die Berechnung. Die Sammlungen müssen identische Größen haben. Wenn die Eingabefunktion f ist und die Elemente i0 ... iN und j0 ... jN sind, berechnet diese Funktion f i0 j0 (... (f iN jN s)). |
| forall: ('T → bool) →' T list → bool | Testet, ob alle Elemente der Sammlung das angegebene Prädikat erfüllen. |
| forall2: ('T1 →' T2 → Bool) → 'T1-Liste →' T2-Liste → Bool | Testet, ob alle entsprechenden Elemente der Sammlung das angegebene Prädikat paarweise erfüllen. |
| Kopf: 'T Liste →' T. | Gibt das erste Element der Liste zurück. |
| init: int → (int → 'T) →' T Liste | Erstellt eine Liste, indem der angegebene Generator für jeden Index aufgerufen wird. |
| isEmpty: 'T list → bool | Kehrt zurück true Wenn die Liste keine Elemente enthält, false Andernfalls. |
| iter: ('T → Einheit) →' T Liste → Einheit | Wendet die angegebene Funktion auf jedes Element der Sammlung an. |
| iter2: ('T1 →' T2 → Einheit) → 'T1-Liste →' T2-Liste → Einheit | Wendet die angegebene Funktion gleichzeitig auf zwei Sammlungen an. Die Sammlungen müssen identisch groß sein. |
| iteri: (int → 'T → Einheit) →' T Liste → Einheit | Wendet die angegebene Funktion auf jedes Element der Sammlung an. Die an die Funktion übergebene Ganzzahl gibt den Index des Elements an. |
| iteri2: (int → 'T1 →' T2 → Einheit) → 'T1-Liste →' T2-Liste → Einheit | Wendet die angegebene Funktion gleichzeitig auf zwei Sammlungen an. Die Sammlungen müssen identisch groß sein. Die an die Funktion übergebene Ganzzahl gibt den Index des Elements an. |
| Länge: 'T Liste → int | Gibt die Länge der Liste zurück. |
| Karte: ('T →' U) → 'T-Liste →' U-Liste | Erstellt eine neue Sammlung, deren Elemente das Ergebnis der Anwendung der angegebenen Funktion auf jedes der Elemente der Sammlung sind. |
| map2: ('T1 →' T2 → 'U) →' T1-Liste → 'T2-Liste →' U-Liste | Erstellt eine neue Sammlung, deren Elemente das Ergebnis der paarweisen Anwendung der angegebenen Funktion auf die entsprechenden Elemente der beiden Sammlungen sind. |
| map3: ('T1 →' T2 → 'T3 →' U) → 'T1-Liste →' T2-Liste → 'T3-Liste →' U-Liste | Erstellt eine neue Sammlung, deren Elemente das Ergebnis der gleichzeitigen Anwendung der angegebenen Funktion auf die entsprechenden Elemente der drei Sammlungen sind. |
| mapi: (int → 'T →' U) → 'T-Liste →' U-Liste | Erstellt eine neue Sammlung, deren Elemente das Ergebnis der Anwendung der angegebenen Funktion auf jedes der Elemente der Sammlung sind. Der an die Funktion übergebene Ganzzahlindex gibt den Index (von 0) des zu transformierenden Elements an. |
| mapi2: (int → 'T1 →' T2 → 'U) →' T1-Liste → 'T2-Liste →' U-Liste | Wie List.mapi, jedoch Zuordnung entsprechender Elemente aus zwei gleich langen Listen. |
| max: 'T Liste →' T. | Gibt das größte aller Elemente der Liste zurück, verglichen mit Operators.max. |
| maxBy: ('T →' U) → 'T-Liste →' T. | Gibt das größte aller Elemente der Liste zurück, verglichen mit Operators.max für das Funktionsergebnis. |
| min: 'T Liste →' T. | Gibt das niedrigste aller Elemente der Liste zurück, verglichen mit Operators.min. |
| minBy: ('T →' U) → 'T-Liste →' T. | Gibt das niedrigste aller Elemente der Liste zurück, verglichen mit Operators.min für das Funktionsergebnis |
| n.: 'T-Liste → int →' T. | Indizes in die Liste. Das erste Element hat den Index 0. |
| ofArray: 'T [] →' T Liste | Erstellt eine Liste aus dem angegebenen Array. |
| ofSeq: seq <'T> →' T Liste | Erstellt eine neue Liste aus dem angegebenen aufzählbaren Objekt. |
| Partition: ('T → bool) →' T-Liste * 'T-Liste | Teilt die Sammlung in zwei Sammlungen auf, die die Elemente enthalten, für die das angegebene Prädikat zurückgegeben wird true und false beziehungsweise. |
| permute: (int → int) → 'T-Liste →' T-Liste | Gibt eine Liste mit allen Elementen zurück, die gemäß der angegebenen Permutation permutiert wurden. |
| Wählen Sie: (Option 'T →' U) → 'T-Liste →' U. | Wendet die angegebene Funktion auf aufeinanderfolgende Elemente an und gibt das erste Ergebnis zurück, bei dem die Funktion zurückgegeben wird Some für einen Wert. |
| reduzieren: ('T →' T → 'T) →' T Liste → 'T. | Wendet eine Funktion auf jedes Element der Sammlung an und führt ein Akkumulatorargument durch die Berechnung. Diese Funktion wendet die angegebene Funktion auf die ersten beiden Elemente der Liste an. Dieses Ergebnis wird dann zusammen mit dem dritten Element an die Funktion übergeben und so weiter. Schließlich wird das Endergebnis zurückgegeben. Wenn die Eingabefunktion f ist und die Elemente i0 ... iN sind, berechnet diese Funktion f (... (f i0 i1) i2 ...) iN. |
| reduBack: ('T →' T → 'T) →' T-Liste → 'T. | Wendet eine Funktion auf jedes Element der Sammlung an und führt ein Akkumulatorargument durch die Berechnung. Wenn die Eingabefunktion isf ist und die Elemente i0 ... iN sind, berechnet diese Funktion f i0 (... (f iN-1 iN)). |
| replizieren: (int → 'T →' T Liste) | Erstellt eine Liste, indem der angegebene Generator für jeden Index aufgerufen wird. |
| rev: 'T-Liste →' T-Liste | Gibt eine neue Liste mit den Elementen in umgekehrter Reihenfolge zurück. |
| Scan: ('Status →' T → 'Status) →' Status → 'T-Liste →' Statusliste | Wendet eine Funktion auf jedes Element der Sammlung an und führt ein Akkumulatorargument durch die Berechnung. Diese Funktion verwendet das zweite Argument und wendet die angegebene Funktion auf sie und das erste Element der Liste an. Dann übergibt es dieses Ergebnis zusammen mit dem zweiten Element an die Funktion und so weiter. Schließlich wird die Liste der Zwischenergebnisse und das Endergebnis zurückgegeben. |
| scanBack: ('T →' Status → 'Status) →' T-Liste → 'Status →' Statusliste | Wie foldBack, gibt jedoch sowohl das Zwischen- als auch das Endergebnis zurück |
| sort: 'T-Liste →' T-Liste | Sortiert die angegebene Liste mit Operators.compare. |
| sortBy: ('T →' Taste) → 'T-Liste →' T-Liste | Sortiert die angegebene Liste mit den Tasten der angegebenen Projektion. Schlüssel werden mit Operators.compare verglichen. |
| sortWith: ('T →' T → int) → 'T-Liste →' T-Liste | Sortiert die angegebene Liste mit der angegebenen Vergleichsfunktion. |
| Summe: ^ T Liste → ^ T. | Gibt die Summe der Elemente in der Liste zurück. |
| sumBy: ('T → ^ U) →' T Liste → ^ U. | Gibt die Summe der Ergebnisse zurück, die durch Anwenden der Funktion auf jedes Element der Liste generiert wurden. |
| Schwanz: 'T-Liste →' T-Liste | Gibt die Eingabeliste ohne das erste Element zurück. |
| toArray: 'T Liste →' T [] | Erstellt ein Array aus der angegebenen Liste. |
| toSeq: 'T list → seq <' T> | Zeigt die angegebene Liste als Sequenz an. |
| tryFind: ('T → bool) →' T-Liste → 'T-Option | Gibt das erste Element zurück, für das die angegebene Funktion zurückgegeben wird true. RückkehrNone wenn kein solches Element vorhanden ist. |
| tryFindIndex: (Option 'T → bool) →' T list → int | Gibt den Index des ersten Elements in der Liste zurück, das das angegebene Prädikat erfüllt. RückkehrNone wenn kein solches Element vorhanden ist. |
| tryPick: (Option 'T →' U) → Option 'T-Liste →' U | Wendet die angegebene Funktion auf aufeinanderfolgende Elemente an und gibt das erste Ergebnis zurück, bei dem die Funktion zurückgegeben wird Somefür einen Wert. Wenn kein solches Element vorhanden ist, kehren Sie zurückNone. |
| entpacken: ('T1 *' T2) Liste → 'T1 Liste *' T2 Liste | Teilt eine Liste von Paaren in zwei Listen auf. |
| unzip3: ('T1 *' T2 * 'T3) Liste →' T1 Liste * 'T2 Liste *' T3 Liste | Teilt eine Liste von Tripeln in drei Listen auf. |
| zip: 'T1 Liste →' T2 Liste → ('T1 *' T2) Liste | Kombiniert die beiden Listen zu einer Liste von Paaren. Die beiden Listen müssen gleich lang sein. |
| zip3: 'T1 Liste →' T2 Liste → 'T3 Liste → (' T1 * 'T2 *' T3) Liste | Kombiniert die drei Listen zu einer Liste von Tripeln. Die Listen müssen gleich lang sein. |
Die folgenden Beispiele veranschaulichen die Verwendung der oben genannten Funktionen -
Beispiel 1
Dieses Programm zeigt das rekursive Umkehren einer Liste -
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)Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:
The original list: [2; 4; 6; 8; 10; 12; 14; 16]
The reversed list: [16; 14; 12; 10; 8; 6; 4; 2]Sie können jedoch die verwenden rev Funktion des Moduls für den gleichen Zweck -
let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]
printfn "The original list: %A" list1
printfn "The reversed list: %A" (List.rev list1)Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:
The original list: [2; 4; 6; 8; 10; 12; 14; 16]
The reversed list: [16; 14; 12; 10; 8; 6; 4; 2]Beispiel 2
Dieses Programm zeigt das Filtern einer Liste mit dem List.filter Methode -
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" list2Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:
The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The Filtered list: [2; 4; 6; 8; 10]Beispiel 3
Das List.map Methode ordnet eine Liste von einem Typ einem anderen zu -
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" list2Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:
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"]Beispiel 4
Das List.append Methode und der @ -Operator hängt eine Liste an eine andere an -
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" lt3Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:
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']Beispiel 5
Das List.sortMethode sortiert eine Liste. DasList.sum Methode gibt die Summe der Elemente in der Liste und die List.average Methode gibt den Durchschnitt der Elemente in der Liste -
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" avgWenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:
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.242857Eine "Falz" -Operation wendet eine Funktion auf jedes Element in einer Liste an, aggregiert das Ergebnis der Funktion in einer Akkumulatorvariablen und gibt den Akkumulator als Ergebnis der Faltoperation zurück.
Beispiel 6
Das List.fold Methode wendet eine Funktion auf jedes Element von links nach rechts an, während List.foldBack wendet eine Funktion von rechts nach links auf jedes Element an.
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 ])Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:
Sum of the elements of list [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] is 55.