Teilen über

Slices

In diesem Artikel wird erläutert, wie Sie Segmente aus vorhandenen F#-Typen und wie Sie Eigene Segmente definieren.

In F# ist ein Segment eine Teilmenge eines beliebigen Datentyps. Segmente ähneln Indexern, aber anstatt einen einzelnen Wert aus der zugrunde liegenden Datenstruktur zu liefern, ergeben sie mehrere. Segmente verwenden die .. Operatorsyntax, um den Bereich der angegebenen Indizes in einem Datentyp auszuwählen. Weitere Informationen finden Sie im Referenzartikel zum Schleifenausdruck.

F# unterstützt derzeit systeminterne Zeichenfolgen, Listen, Arrays und mehrdimensionale Arrays (2D, 3D, 4D). Slicing wird am häufigsten mit F#-Arrays und -Listen verwendet. Sie können Ihren benutzerdefinierten Datentypen mithilfe der GetSlice Methode in Der Typdefinition oder in einer Erweiterung des Typs " In-Scope" Slicing hinzufügen.

F#-Listen und -Arrays slicing

Die am häufigsten verwendeten Datentypen sind F#-Listen und Arrays. Das folgende Beispiel veranschaulicht das Segmentieren von Listen:

// Generate a list of 100 integers
let fullList = [ 1 .. 100 ]

// Create a slice from indices 1-5 (inclusive)
let smallSlice = fullList[1..5]
printfn $"Small slice: {smallSlice}"

// Create a slice from the beginning to index 5 (inclusive)
let unboundedBeginning = fullList[..5]
printfn $"Unbounded beginning slice: {unboundedBeginning}"

// Create a slice from an index to the end of the list
let unboundedEnd = fullList[94..]
printfn $"Unbounded end slice: {unboundedEnd}"

Slicing arrays is just like slicing lists:

// Generate an array of 100 integers
let fullArray = [| 1 .. 100 |]

// Create a slice from indices 1-5 (inclusive)
let smallSlice = fullArray[1..5]
printfn $"Small slice: {smallSlice}"

// Create a slice from the beginning to index 5 (inclusive)
let unboundedBeginning = fullArray[..5]
printfn $"Unbounded beginning slice: {unboundedBeginning}"

// Create a slice from an index to the end of the list
let unboundedEnd = fullArray[94..]
printfn $"Unbounded end slice: {unboundedEnd}"

Vor F# 6 verwendet slicing die Syntax expr.[start..finish] mit der zusätzlichen .. Wenn Sie dies auswählen, können Sie diese Syntax weiterhin verwenden. Weitere Informationen finden Sie unter RFC FS-1110.

Slicing multidimensional arrays

F# unterstützt mehrdimensionale Arrays in der F#-Kernbibliothek. Wie bei eindimensionalen Arrays können Auch Segmente multidimensionaler Arrays nützlich sein. Die Einführung zusätzlicher Dimensionen mandatiert jedoch eine etwas andere Syntax, sodass Sie Segmente bestimmter Zeilen und Spalten verwenden können.

Die folgenden Beispiele veranschaulichen das Segment eines 2D-Arrays:

// Generate a 3x3 2D matrix
let A = array2D [[1;2;3];[4;5;6];[7;8;9]]
printfn $"Full matrix:\n {A}"

// Take the first row
let row0 = A[0,*]
printfn $"{row0}"

// Take the first column
let col0 = A[*,0]
printfn $"{col0}"

// Take all rows but only two columns
let subA = A[*,0..1]
printfn $"{subA}"

// Take two rows and all columns
let subA' = A[0..1,*]
printfn $"{subA}"

// Slice a 2x2 matrix out of the full 3x3 matrix
let twoByTwo = A[0..1,0..1]
printfn $"{twoByTwo}"

Definieren von Datensegmenten für andere Datenstrukturen

Die F#-Kernbibliothek definiert Segmente für einen begrenzten Satz von Typen. Wenn Sie Segmente für weitere Datentypen definieren möchten, können Sie dies entweder in der Typdefinition selbst oder in einer Typerweiterung tun.

Hier erfahren Sie beispielsweise, wie Sie Segmente für die ArraySegment<T> Klasse definieren können, um eine bequeme Datenbearbeitung zu ermöglichen:

open System

type ArraySegment<'TItem> with
    member segment.GetSlice(start, finish) =
        let start = defaultArg start 0
        let finish = defaultArg finish segment.Count
        ArraySegment(segment.Array, segment.Offset + start, finish - start)

let arr = ArraySegment [| 1 .. 10 |]
let slice = arr[2..5] //[ 3; 4; 5]

Ein weiteres Beispiel mit den Span<T> folgenden Typen ReadOnlySpan<T> :

open System

type ReadOnlySpan<'T> with
    member sp.GetSlice(startIdx, endIdx) =
        let s = defaultArg startIdx 0
        let e = defaultArg endIdx sp.Length
        sp.Slice(s, e - s)

type Span<'T> with
    member sp.GetSlice(startIdx, endIdx) =
        let s = defaultArg startIdx 0
        let e = defaultArg endIdx sp.Length
        sp.Slice(s, e - s)

let printSpan (sp: Span<int>) =
    let arr = sp.ToArray()
    printfn $"{arr}"

let sp = [| 1; 2; 3; 4; 5 |].AsSpan()
printSpan sp[0..] // [|1; 2; 3; 4; 5|]
printSpan sp[..5] // [|1; 2; 3; 4; 5|]
printSpan sp[0..3] // [|1; 2; 3|]
printSpan sp[1..3] // |2; 3|]

Integrierte F#-Segmente sind end-inclusive

Alle systeminternen Segmente in F# sind end-inclusive; d. h. die obere Grenze ist im Segment enthalten. Für ein bestimmtes Segment mit dem Anfangsindex und dem Endindex xyenthält das resultierende Segment den Yth-Wert .

// Define a new list
let xs = [1 .. 10]

printfn $"{xs[2..5]}" // Includes the 5th index

Integrierte F#-Leere Segmente

F#-Listen, Arrays, Sequenzen, Zeichenfolgen, multidimensionale Arrays (2D, 3D, 4D) erzeugen alle ein leeres Segment, wenn die Syntax ein Segment erzeugen könnte, das nicht vorhanden ist.

Betrachten Sie das folgenden Beispiel:

let l = [ 1..10 ]
let a = [| 1..10 |]
let s = "hello!"

let emptyList = l[-2..(-1)]
let emptyArray = a[-2..(-1)]
let emptyString = s[-2..(-1)]

Von Bedeutung

C#-Entwickler erwarten möglicherweise, dass diese eine Ausnahme auslösen, anstatt ein leeres Segment zu erzeugen. Dies ist eine Entwurfsentscheidung, die in der Tatsache verwurzelt ist, dass leere Sammlungen in F# verfassen. Eine leere F#-Liste kann mit einer anderen F#-Liste verfasst werden, eine leere Zeichenfolge kann einer vorhandenen Zeichenfolge hinzugefügt werden usw. Es kann üblich sein, Segmente basierend auf werten zu übernehmen, die als Parameter übergeben werden, und die Toleranz von außerhalb der Grenzen > , indem eine leere Auflistung erstellt wird, die mit der Zusammensetzung des F#-Codes übereinstimmt.

Segmente mit fester Indexierung für 3D- und 4D-Arrays

Für F# 3D- und 4D-Arrays können Sie einen bestimmten Index "korrigieren" und andere Dimensionen mit diesem Index fest segmentieren.

Um dies zu veranschaulichen, berücksichtigen Sie das folgende 3D-Array:

z = 0

x\y 0 1
0 0 1
1 2 3

z = 1

x\y 0 1
0 4 5
1 6 7

Wenn Sie das Segment [| 4; 5 |] aus dem Array extrahieren möchten, verwenden Sie ein Segment mit festem Index.

let dim = 2
let m = Array3D.zeroCreate<int> dim dim dim

let mutable count = 0

for z in 0..dim-1 do
    for y in 0..dim-1 do
        for x in 0..dim-1 do
            m[x,y,z] <- count
            count <- count + 1

// Now let's get the [4;5] slice!
m[*, 0, 1]

Die letzte Zeile behebt die y und z die Indizes des 3D-Arrays und übernimmt die restlichen x Werte, die der Matrix entsprechen.

Siehe auch

  • Last updated on