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.