F # - Listeler

F # 'da bir liste, aynı türden sıralı, değişmez bir dizi unsurdur. Bir dereceye kadar bağlantılı bir liste veri yapısına eşdeğerdir.

F # modülü, Microsoft.FSharp.Collections.List,listeler üzerinde ortak işlemlere sahiptir. Ancak F #, bu modülü otomatik olarak içe aktarır ve onu her F # uygulaması için erişilebilir hale getirir.

Liste Oluşturma ve Başlatma

Aşağıda liste oluşturmanın çeşitli yolları verilmiştir -

  • Listeyi kullanma literals.

  • Kullanma cons (::) Şebeke.

  • Kullanmak List.init List modülünün yöntemi.

  • Bazılarını kullanarak syntactic constructs aranan List Comprehensions.

Değişmezleri Listele

Bu yöntemde, köşeli parantez içinde noktalı virgülle ayrılmış bir değer dizisi belirtirsiniz. Örneğin -

let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]

Eksileri (: :) Operatör

Bu yöntemle, bazı değerleri önceden ekleyerek veya cons-ing:: operatörünü kullanarak mevcut bir listeye. Örneğin -

let list2 = 1::2::3::4::5::6::7::8::9::10::[];;

[] boş bir listeyi gösterir.

Liste başlatma Yöntemi

List modülünün List.init yöntemi genellikle liste oluşturmak için kullanılır. Bu yöntemin türü vardır -

val init : int -> (int -> 'T) -> 'T list

İlk bağımsız değişken, yeni listenin istenen uzunluğudur ve ikinci bağımsız değişken, listedeki öğeleri oluşturan bir başlatıcı işlevidir.

Örneğin,

let list5 = List.init 5 (fun index -> (index, index * index, index * index * index))

Burada dizin işlevi listeyi oluşturur.

Kavramları Listele

Liste anlamaları, liste oluşturmak için kullanılan özel sözdizimsel yapılardır.

F # liste anlama sözdizimi iki biçimde gelir - aralıklar ve oluşturucular.

Aralıkların yapıları vardır - [start .. end] ve [start .. step .. end]

Örneğin,

let list3 = [1 .. 10]

Oluşturucular yapıya sahiptir - [koleksiyondaki x için do ... verim ifadesi]

Örneğin,

let list6 = [ for a in 1 .. 10 do yield (a * a) ]

Olarak yield anahtar kelime, tek bir değeri bir listeye, anahtar kelimeye, yield!, listeye bir değerler koleksiyonunu iter.

Aşağıdaki işlev, yukarıdaki yöntemleri gösterir -

Misal

(* 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

Programı derleyip çalıştırdığınızda, aşağıdaki çıktıyı verir -

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]

Liste Veri Türünün Özellikleri

Aşağıdaki tablo, liste veri türünün çeşitli özelliklerini göstermektedir -

Emlak Tür Açıklama
Kafa 'T İlk element.
Boş T listesi Uygun türde boş bir liste döndüren statik bir özellik.
Boş bool true Listenin hiç öğesi yoksa.
Öğe 'T Belirtilen dizindeki öğe (sıfır tabanlı).
Uzunluk int Elemanların sayısı.
Kuyruk T listesi İlk öğesi olmayan liste.

Aşağıdaki örnek, bu özelliklerin kullanımını gösterir -

Misal

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))

Programı derleyip çalıştırdığınızda, aşağıdaki çıktıyı verir -

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

Listedeki Temel Operatörler

Aşağıdaki tablo, liste veri türündeki temel işlemleri göstermektedir -

Değer Açıklama
ekle: 'T listesi →' T listesi → 'T listesi İlk listenin öğelerini ve ardından ikinci listenin öğelerini içeren yeni bir liste döndürür.
ortalama: 'T listesi → ^ T Listedeki öğelerin ortalamasını verir.
averageBy: ('T → ^ U) →' T listesi → ^ U İşlevi listenin her bir öğesine uygulayarak oluşturulan öğelerin ortalamasını döndürür.
seçin: ('T →' U seçeneği) → 'T listesi →' U listesi Verilen işlevi listenin her bir öğesine uygular. İşlevin döndürdüğü her öğe için sonuçlardan oluşan listeyi verirSome.
topla: ('T →' U listesi) → 'T listesi →' U listesi Listenin her bir öğesi için verilen işlevi uygular. Tüm sonuçları birleştirir ve birleşik listeyi döndürür.
concat: seq <'T listesi> →' T listesi Sırayla her listenin öğelerini içeren yeni bir liste döndürür.
boş: 'T listesi Verilen türde boş bir liste döndürür.
var: ('T → bool) →' T listesi → bool Listenin herhangi bir öğesinin verilen yüklemi karşılayıp karşılamadığını test eder.
have2: ('T1 →' T2 → bool) → 'T1 listesi →' T2 listesi → bool Listelerin karşılık gelen herhangi bir çiftinin verilen koşulu karşılayıp karşılamadığını test eder.
filtre: ('T → bool) →' T listesi → 'T listesi Yalnızca verilen yüklemin döndürdüğü koleksiyonun öğelerini içeren yeni bir koleksiyon döndürür true.
bul: ('T → bool) →' T listesi → 'T Verilen işlevin döndürdüğü ilk öğeyi verir true.
findIndex: ('T → bool) →' T listesi → int Verilen koşulu karşılayan listedeki ilk öğenin dizinini döndürür.
katlama: ('Durum →' T → 'Eyalet) →' Eyalet → 'T listesi →' Durum Koleksiyonun her öğesine bir işlev uygular, hesaplama aracılığıyla bir akümülatör argümanı iş parçacığı oluşturur. Bu işlev ikinci bağımsız değişkeni alır ve ona ve listenin ilk öğesine uygular. Ardından, bu sonucu ikinci öğeyle birlikte işleve aktarır ve bu böyle devam eder. Son olarak, nihai sonucu döndürür. Giriş fonksiyonu f ise ve elemanlar i0 ... iN ise, bu fonksiyon f (... (fs i0) i1 ...) iN'yi hesaplar.
kat2: ('Durum →' T1 → 'T2 →' Eyalet) → 'Durum →' T1 listesi → 'T2 listesi →' Durum Hesaplama aracılığıyla bir toplayıcı argümanını işleyerek, iki koleksiyonun karşılık gelen öğelerine bir işlev uygular. Koleksiyonların boyutları aynı olmalıdır. Giriş fonksiyonu f ise ve elemanlar i0 ... iN ve j0 ... jN ise, bu fonksiyon f (... (fs i0 j0) ...) iN jN'yi hesaplar.
foldBack: ('T →' Durum → 'Eyalet) →' T listesi → 'Durum →' Durum Koleksiyonun her öğesine bir işlev uygular, hesaplama aracılığıyla bir akümülatör argümanı iş parçacığı oluşturur. Giriş fonksiyonu f ise ve elemanlar i0 ... iN ise f i0 (... (f iN s)) hesaplar.
foldBack2: ('T1 →' T2 → 'Durum →' Durum) → 'T1 listesi →' T2 listesi → 'Durum →' Durum Hesaplama aracılığıyla bir toplayıcı argümanını işleyerek, iki koleksiyonun karşılık gelen öğelerine bir işlev uygular. Koleksiyonların boyutları aynı olmalıdır. Giriş fonksiyonu f ise ve elemanlar i0 ... iN ve j0 ... jN ise, bu fonksiyon f i0 j0 (... (f iN jN s)) hesaplar.
forall: ('T → bool) →' T listesi → bool Koleksiyonun tüm öğelerinin verilen koşulu karşılayıp karşılamadığını test eder.
forall2: ('T1 →' T2 → bool) → 'T1 listesi →' T2 listesi → bool Koleksiyonun tüm karşılık gelen öğelerinin verilen yüklemi ikili olarak karşılayıp karşılamadığını test eder.
head: 'T listesi →' T Listenin ilk öğesini döndürür.
init: int → (int → 'T) →' T listesi Her dizinde verilen oluşturucuyu çağırarak bir liste oluşturur.
isEmpty: 'T listesi → bool İadeler true liste hiçbir öğe içermiyorsa, false aksi takdirde.
iter: ('T → birim) →' T listesi → birim Verilen işlevi koleksiyonun her bir öğesine uygular.
iter2: ('T1 →' T2 → birim) → 'T1 listesi →' T2 listesi → birim Verilen işlevi aynı anda iki koleksiyona uygular. Koleksiyonlar aynı boyutta olmalıdır.
iteri: (int → 'T → birim) →' T listesi → birim Verilen işlevi koleksiyonun her bir öğesine uygular. İşleve aktarılan tamsayı, elemanın indeksini gösterir.
iteri2: (int → 'T1 →' T2 → birim) → 'T1 listesi →' T2 listesi → birim Verilen işlevi aynı anda iki koleksiyona uygular. Koleksiyonlar aynı boyutta olmalıdır. İşleve aktarılan tamsayı, öğenin dizinini gösterir.
uzunluk: 'T listesi → int Listenin uzunluğunu döndürür.
harita: ('T →' U) → 'T listesi →' U listesi Öğeleri, belirli bir işlevi koleksiyonun her bir öğesine uygulamanın sonucu olan yeni bir koleksiyon oluşturur.
map2: ('T1 →' T2 → 'U) →' T1 listesi → 'T2 listesi →' U listesi Verilen işlevi, iki koleksiyonun karşılık gelen öğelerine çiftler halinde uygulamanın sonucu olan yeni bir koleksiyon oluşturur.
map3: ('T1 →' T2 → 'T3 →' U) → 'T1 listesi →' T2 listesi → 'T3 listesi →' U listesi Verilen işlevi üç koleksiyonun karşılık gelen öğelerine eşzamanlı olarak uygulamanın sonucu olan yeni bir koleksiyon oluşturur.
mapi: (int → 'T →' U) → 'T listesi →' U listesi Öğeleri, belirli bir işlevi koleksiyonun her bir öğesine uygulamanın sonucu olan yeni bir koleksiyon oluşturur. İşleve aktarılan tamsayı dizini, dönüştürülen öğenin dizinini (0'dan) gösterir.
mapi2: (int → 'T1 →' T2 → 'U) →' T1 listesi → 'T2 listesi →' U listesi List.mapi gibi, ancak karşılık gelen öğeleri eşit uzunluktaki iki listeden eşleme.
max: 'T listesi →' T Operators.max kullanılarak karşılaştırıldığında listedeki tüm elemanların en büyüğünü döndürür.
maxBy: ('T →' U) → 'T listesi →' T İşlev sonucu üzerinde Operators.max kullanılarak karşılaştırıldığında listedeki tüm elemanların en büyüğünü döndürür.
min: 'T listesi →' T Operators.min kullanılarak karşılaştırıldığında listedeki tüm öğeler arasında en düşük olanı döndürür.
minBy: ('T →' U) → 'T listesi →' T İşlev sonucunda Operators.min kullanarak listedeki tüm öğeler arasında en düşük olanı döndürür
nth: 'T listesi → int →' T Listeye dizinler. İlk elemanın indeksi 0'dır.
ofArray: 'T [] →' T listesi Verilen diziden bir liste oluşturur.
ofSeq: seq <'T> →' T listesi Verilen numaralandırılabilir nesneden yeni bir liste oluşturur.
bölüm: ('T → bool) →' T listesi * 'T listesi Koleksiyonu, verilen yüklemin döndürdüğü öğeleri içeren iki koleksiyona böler true ve false sırasıyla.
permute: (int → int) → 'T listesi →' T listesi Belirtilen permütasyona göre izin verilen tüm öğeleri içeren bir liste döndürür.
seçim: ('T →' U seçeneği) → 'T listesi →' U Verilen işlevi ardışık öğelere uygular, işlevin döndüğü ilk sonucu döndürür Some bir değer için.
azalt: ('T →' T → 'T) →' T listesi → 'T Koleksiyonun her öğesine bir işlev uygular, hesaplama aracılığıyla bir akümülatör argümanı iş parçacığı oluşturur. Bu işlev, belirtilen işlevi listenin ilk iki öğesine uygular. Daha sonra bu sonucu üçüncü öğeyle birlikte işleve aktarır ve bu şekilde devam eder. Son olarak, nihai sonucu döndürür. Giriş fonksiyonu f ise ve elemanlar i0 ... iN ise, bu fonksiyon f (... (f i0 i1) i2 ...) iN'yi hesaplar.
lessBack: ['T →' T → 'T) →' T listesi → 'T Koleksiyonun her öğesine bir işlev uygular, hesaplama aracılığıyla bir akümülatör argümanı iş parçacığı oluşturur. Giriş fonksiyonu f ise ve elemanlar i0 ... iN ise, bu fonksiyon f i0 (... (f iN-1 iN)) hesaplar.
çoğaltma: (int → 'T →' T listesi) Her dizinde verilen oluşturucuyu çağırarak bir liste oluşturur.
rev: 'T listesi →' T listesi Öğeleri ters sırada içeren yeni bir liste döndürür.
tarama: ('Durum →' T → 'Durum) →' Durum → 'T listesi →' Durum listesi Koleksiyonun her öğesine bir işlev uygular, hesaplama aracılığıyla bir akümülatör argümanı iş parçacığı oluşturur. Bu işlev ikinci bağımsız değişkeni alır ve belirtilen işlevi ona ve listenin ilk öğesine uygular. Daha sonra bu sonucu ikinci elemanla birlikte fonksiyona aktarır ve bu böyle devam eder. Son olarak, ara sonuçların listesini ve nihai sonucu döndürür.
scanBack: ('T →' Durum → 'Durum) →' T listesi → 'Durum →' Durum listesi FoldBack gibi, ancak hem ara hem de nihai sonuçları döndürür
sort: 'T listesi →' T listesi Operators.compare'yi kullanarak verilen listeyi sıralar.
sortBy: ('T →' Tuşu) → 'T listesi →' T listesi Verilen listeyi, verilen projeksiyon tarafından verilen tuşları kullanarak sıralar. Anahtarlar Operators.compare kullanılarak karşılaştırılır.
sortWith: ('T →' T → int) → 'T listesi →' T listesi Verilen listeyi verilen karşılaştırma işlevini kullanarak sıralar.
toplam: ^ T listesi → ^ T Listedeki öğelerin toplamını döndürür.
sumBy: ('T → ^ U) →' T listesi → ^ U İşlevi listenin her bir öğesine uygulayarak oluşturulan sonuçların toplamını döndürür.
kuyruk: 'T listesi →' T listesi İlk öğe olmadan girdi listesini döndürür.
toArray: 'T listesi →' T [] Verilen listeden bir dizi oluşturur.
toSeq: 'T listesi → seq <' T> Verilen listeyi bir sıra olarak görüntüler.
tryFind: ('T → bool) →' T listesi → 'T seçeneği Verilen işlevin döndürdüğü ilk öğeyi verir true. DönüşNone böyle bir öğe yoksa.
tryFindIndex: ('T → bool) →' T listesi → int seçeneği Verilen koşulu karşılayan listedeki ilk öğenin dizinini döndürür. DönüşNone böyle bir öğe yoksa.
tryPick: ('T →' U seçeneği) → 'T listesi →' U seçeneği Verilen işlevi ardışık öğelere uygular, işlevin döndüğü ilk sonucu döndürür Somebir değer için. Böyle bir öğe yoksa geri dönünNone.
unzip: ('T1 *' T2) listesi → 'T1 listesi *' T2 listesi Bir çift listesini iki listeye böler.
unzip3: ('T1 *' T2 * 'T3) listesi →' T1 listesi * 'T2 listesi *' T3 listesi Üçlü bir listeyi üç listeye böler.
zip: 'T1 listesi →' T2 listesi → ('T1 *' T2) listesi İki listeyi bir çiftler listesi halinde birleştirir. İki liste eşit uzunluklara sahip olmalıdır.
zip3: 'T1 listesi →' T2 listesi → 'T3 listesi → (' T1 * 'T2 *' T3) listesi Üç listeyi üçlü bir liste halinde birleştirir. Listelerin uzunlukları eşit olmalıdır.

Aşağıdaki örnekler, yukarıdaki işlevlerin kullanımlarını göstermektedir -

örnek 1

Bu program, bir listeyi yinelemeli olarak ters çevirmeyi gösterir -

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)

Programı derleyip çalıştırdığınızda, aşağıdaki çıktıyı verir -

The original list: [2; 4; 6; 8; 10; 12; 14; 16]
The reversed list: [16; 14; 12; 10; 8; 6; 4; 2]

Ancak şunu kullanabilirsiniz: rev modülün aynı amaç için işlevi -

let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]
printfn "The original list: %A" list1
printfn "The reversed list: %A" (List.rev list1)

Programı derleyip çalıştırdığınızda, aşağıdaki çıktıyı verir -

The original list: [2; 4; 6; 8; 10; 12; 14; 16]
The reversed list: [16; 14; 12; 10; 8; 6; 4; 2]

Örnek 2

Bu program, bir listeyi, List.filter yöntem -

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

Programı derleyip çalıştırdığınızda, aşağıdaki çıktıyı verir -

The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The Filtered list: [2; 4; 6; 8; 10]

Örnek 3

List.map yöntem, bir listeyi bir türden diğerine eşler -

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

Programı derleyip çalıştırdığınızda, aşağıdaki çıktıyı verir -

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"]

Örnek 4

List.append yöntem ve @ operatörü bir listeyi diğerine ekler -

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

Programı derleyip çalıştırdığınızda, aşağıdaki çıktıyı verir -

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']

Örnek 5

List.sortyöntem bir listeyi sıralar. List.sum yöntem listedeki öğelerin toplamını verir ve List.average yöntem, listedeki öğelerin ortalamasını verir -

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

Programı derleyip çalıştırdığınızda, aşağıdaki çıktıyı verir -

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

"Katlama" işlemi, bir listedeki her öğeye bir işlev uygular, işlevin sonucunu bir toplayıcı değişkeninde toplar ve katlama işleminin sonucu olarak toplayıcıyı döndürür.

Örnek 6

List.fold yöntem soldan sağa her öğeye bir işlev uygularken List.foldBack sağdan sola her öğeye bir işlev uygular.

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 ])

Programı derleyip çalıştırdığınızda, aşağıdaki çıktıyı verir -

Sum of the elements of list [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] is 55.