Listeler
F # ' daki bir liste, aynı türde olan sıralı, sabit bir öğe serisidir. Listelerde temel işlemleri gerçekleştirmek için, liste modülündekiişlevleri kullanın.
Liste oluşturma ve başlatma
Aşağıdaki kod satırında gösterildiği gibi, noktalı virgülle ayırarak ve köşeli parantez içine alınmış öğeleri açıkça listeleyerek bir liste tanımlayabilirsiniz.
let list123 = [ 1; 2; 3 ]
Ayrıca, öğelerin arasına satır sonları koyabilirsiniz, bu durumda noktalı virgül isteğe bağlıdır. İkinci sözdizimi, öğe başlatma ifadeleri daha uzun olduğunda veya her öğe için bir açıklama eklemek istediğinizde daha okunabilir kod oluşmasına neden olabilir.
let list123 = [
1
2
3 ]
Normalde, tüm liste öğeleri aynı türde olmalıdır. Bir özel durum, öğelerin temel tür olarak belirtildiği bir listenin türetilmiş tür öğelerine sahip olması olabilir. Bu nedenle, her ikisi Button ve CheckBox öğesinden türetiğinden aşağıdakiler kabul edilebilir Control .
let myControlList : Control list = [ new Button(); new CheckBox() ]
Ayrıca .. , aşağıdaki kodda gösterildiği gibi, Aralık işleci () ile ayrılmış tamsayılar tarafından belirtilen bir aralığı kullanarak liste öğelerini tanımlayabilirsiniz.
let list1 = [ 1 .. 10 ]
Boş bir liste, aralarında hiçbir şey olmadan köşeli ayraç çifti ile belirtilir.
// An empty list.
let listEmpty = []
Bir liste oluşturmak için bir dizi ifadesi de kullanabilirsiniz. Daha fazla bilgi için bkz. dizi ifadeleri . Örneğin, aşağıdaki kod, 1 ile 10 arasındaki sayıların karelerinin bir listesini oluşturur.
let listOfSquares = [ for i in 1 .. 10 -> i*i ]
Listelerle çalışma için işleçler
(Cons) işlecini kullanarak bir listeye öğe ekleyebilirsiniz :: . list1İse [2; 3; 4] , aşağıdaki kod list2 olarak oluşturulur [100; 2; 3; 4] .
let list2 = 100 :: list1
Aşağıdaki kodda olduğu gibi işlecini kullanarak uyumlu türleri olan listeleri birleştirebilirsiniz @ . , list1 Ve ise, [2; 3; 4] list2 [100; 2; 3; 4] Bu kod olarak oluşturulur list3 [2; 3; 4; 100; 2; 3; 4] .
let list3 = list1 @ list2
Listelerde işlem gerçekleştirmeye yönelik işlevler, liste modülündemevcuttur.
F # içindeki listeler sabit olduğundan, tüm değiştirme işlemleri var olan listeleri değiştirmek yerine yeni listeler oluşturur.
F # içindeki listeler, listedir bağlantılı listeler olarak uygulanır. Bu, yalnızca listenin baş başlarına erişen işlemlerin O (1) ve öğe erişiminin ise O (n) olduğu anlamına gelir.
Özellikler
Liste türü aşağıdaki özellikleri destekler:
| Özellik | Tür | Description |
|---|---|---|
| Head | 'T |
İlk öğesi. |
| Olmamalıdır | 'T list |
Uygun türdeki boş bir liste döndüren statik özellik. |
| IsEmpty | bool |
true listede öğe yoksa. |
| Öğe | 'T |
Belirtilen dizindeki öğe (sıfır tabanlı). |
| Uzunluk | int |
Öğe sayısı. |
| Kuyruk | 'T list |
İlk öğesi olmayan liste. |
Aşağıda bu özellikleri kullanmaya ilişkin bazı örnekler verilmiştir.
let list1 = [ 1; 2; 3 ]
// 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))
Listeleri kullanma
Listelerle programlama, az miktarda kodla karmaşık işlemler gerçekleştirmenize olanak sağlar. Bu bölümde, işlevsel programlama için önemli olan listelerle ilgili genel işlemler açıklanmaktadır.
Listelerle özyineleme
Listeler özyinelemeli programlama tekniklerine benzersiz bir şekilde uygundur. Listenin her öğesinde gerçekleştirilmesi gereken bir işlem düşünün. Bu işlemi, listenin başından yararlanarak ve sonra listenin kuyruğunu geçirerek, ilk öğe olmayan orijinal listeden oluşan daha küçük bir liste olan bir sonraki özyineleme düzeyine geri dönerek yapabilirsiniz.
Bu tür bir özyinelemeli işlevi yazmak için, :: bir listenin başını bir kuyruklu ayırmanızı sağlayan, model eşleme içinde Cons işlecini () kullanın.
Aşağıdaki kod örneği, bir liste üzerinde işlemler gerçekleştiren özyinelemeli bir işlevi uygulamak için nasıl model eşleştirmesinin kullanılacağını göstermektedir.
let rec sum list =
match list with
| head :: tail -> head + sum tail
| [] -> 0
Önceki kod küçük listeler için iyi sonuç verir, ancak daha büyük listeler için yığın taşar. Aşağıdaki kod, özyinelemeli işlevlerle çalışmaya yönelik standart bir yöntem olan bir biriktirici bağımsız değişkeni kullanarak bu kodda gelişir. Biriktiricidir bağımsız değişkeninin kullanılması, yığın alanı kaydeden işlev kuyruklu özyinelemeli olur.
let sum list =
let rec loop list acc =
match list with
| head :: tail -> loop tail (acc + head)
| [] -> acc
loop list 0
İşlevi, RemoveAllMultiples iki liste alan özyinelemeli bir işlevdir. İlk liste, katları kaldırılacak olan sayıları ve ikinci liste ise sayıların kaldırılacağı liste olduğunu içerir. Aşağıdaki örnekteki kod, bu özyinelemeli işlevi bir listeden tüm asal olmayan sayıları ortadan kaldırmak için kullanır ve sonuç olarak asal sayıların bir listesini bırakır.
let IsPrimeMultipleTest n x =
x = n || x % n <> 0
let rec RemoveAllMultiples listn listx =
match listn with
| head :: tail -> RemoveAllMultiples tail (List.filter (IsPrimeMultipleTest head) listx)
| [] -> listx
let GetPrimesUpTo n =
let max = int (sqrt (float n))
RemoveAllMultiples [ 2 .. max ] [ 1 .. n ]
printfn "Primes Up To %d:\n %A" 100 (GetPrimesUpTo 100)
Çıktı aşağıdaki şekilde olacaktır:
Primes Up To 100:
[2; 3; 5; 7; 11; 13; 17; 19; 23; 29; 31; 37; 41; 43; 47; 53; 59; 61; 67; 71; 73; 79; 83; 89; 97]
Modül Işlevleri
Liste modülü , bir listenin öğelerine erişen işlevler sağlar. Baş öğe, erişimin en hızlı ve en kolay yoludur. Özellik kafasını veya List. Headmodül işlevini kullanın. Tail özelliğini veya List. tail işlevini kullanarak bir listenin kuyruğunu erişebilirsiniz. Dizine göre bir öğe bulmak için List. nth işlevini kullanın. List.nth listede yer geçer. Bu nedenle, O (n). Kodunuz List.nth sıklıkla kullanılıyorsa, bir liste yerine bir dizi kullanmayı düşünmek isteyebilirsiniz. Dizilerde öğe erişimi O (1).
Listelerde Boole Işlemleri
List. IsEmpty işlevi bir listenin herhangi bir öğeye sahip olup olmadığını belirler.
List. Exists işlevi bir listenin öğelerine Boole testi uygular ve true herhangi bir öğe, testi karşılıyorsa döndürür. List. exists2 benzerdir ancak iki listede ardışık öğe çiftlerinde çalışır.
Aşağıdaki kod öğesinin kullanımını gösterir List.exists .
// Use List.exists to determine whether there is an element of a list satisfies a given Boolean expression.
// containsNumber returns true if any of the elements of the supplied list match
// the supplied number.
let containsNumber number list = List.exists (fun elem -> elem = number) list
let list0to3 = [0 .. 3]
printfn "For list %A, contains zero is %b" list0to3 (containsNumber 0 list0to3)
Çıktı aşağıdaki şekilde olacaktır:
For list [0; 1; 2; 3], contains zero is true
Aşağıdaki örnek öğesinin kullanımını gösterir List.exists2 .
// Use List.exists2 to compare elements in two lists.
// isEqualElement returns true if any elements at the same position in two supplied
// lists match.
let isEqualElement list1 list2 = List.exists2 (fun elem1 elem2 -> elem1 = elem2) list1 list2
let list1to5 = [ 1 .. 5 ]
let list5to1 = [ 5 .. -1 .. 1 ]
if (isEqualElement list1to5 list5to1) then
printfn "Lists %A and %A have at least one equal element at the same position." list1to5 list5to1
else
printfn "Lists %A and %A do not have an equal element at the same position." list1to5 list5to1
Çıktı aşağıdaki şekilde olacaktır:
Lists [1; 2; 3; 4; 5] and [5; 4; 3; 2; 1] have at least one equal element at the same position.
List . forall ' i kullanarak bir listedeki tüm öğelerin bir koşula uyup uymadığını test etmek istiyorsanız.
let isAllZeroes list = List.forall (fun elem -> elem = 0.0) list
printfn "%b" (isAllZeroes [0.0; 0.0])
printfn "%b" (isAllZeroes [0.0; 1.0])
Çıktı aşağıdaki şekilde olacaktır:
true
false
Benzer şekilde, List. forall2 , iki liste içindeki karşılık gelen konumlarda bulunan tüm öğelerin her bir öğe çiftini Içeren bir Boolean ifade karşılayıp karşılamadığını belirler.
let listEqual list1 list2 = List.forall2 (fun elem1 elem2 -> elem1 = elem2) list1 list2
printfn "%b" (listEqual [0; 1; 2] [0; 1; 2])
printfn "%b" (listEqual [0; 0; 0] [0; 1; 0])
Çıktı aşağıdaki şekilde olacaktır:
true
false
Listelerde sıralama Işlemleri
List. Sort, List. sortByve List. sortWith işlevleri sıralama listeleri. Sıralama işlevi, bu üç işlevden hangisini kullanacağınızı belirler. List.sort Varsayılan genel karşılaştırmayı kullanır. Genel karşılaştırma, değerleri karşılaştırmak için genel karşılaştırma işlevini temel alan genel işleçleri kullanır. Basit sayısal türler, tanımlama grupları, kayıtlar, ayırt edici birleşimler, listeler, diziler ve uygulayan herhangi bir tür gibi çok sayıda öğe türü ile verimli bir şekilde çalışmaktadır System.IComparable . Uygulayan türler için System.IComparable , genel karşılaştırma System.IComparable.CompareTo() işlevini kullanır. Genel karşılaştırma dizelerle de birlikte çalışarak, ancak kültüre bağımsız bir sıralama düzeni kullanır. Genel karşılaştırma, işlev türleri gibi desteklenmeyen türlerde kullanılmamalıdır. Ayrıca, varsayılan genel karşılaştırmanın performansı, küçük yapılandırılmış türler için en iyisidir; sıklıkla karşılaştırılması ve sıralanması gereken daha büyük yapılandırılmış türler için, System.IComparable yöntemini uygulamayı ve verimli bir uygulama sağlamayı düşünün System.IComparable.CompareTo() .
List.sortBy sıralama ölçütü olarak kullanılan bir değer döndüren bir işlev alır ve bir List.sortWith karşılaştırma işlevini bağımsız değişken olarak alır. Bu ikinci iki işlev, karşılaştırmayı desteklemeyen türlerle çalışırken ya da karşılaştırma, kültüre duyarlı dizeler söz konusu olduğunda olduğu gibi daha karmaşık karşılaştırma semantiği gerektirdiğinde yararlıdır.
Aşağıdaki örnek öğesinin kullanımını gösterir List.sort .
let sortedList1 = List.sort [1; 4; 8; -2; 5]
printfn "%A" sortedList1
Çıktı aşağıdaki şekilde olacaktır:
[-2; 1; 4; 5; 8]
Aşağıdaki örnek öğesinin kullanımını gösterir List.sortBy .
let sortedList2 = List.sortBy (fun elem -> abs elem) [1; 4; 8; -2; 5]
printfn "%A" sortedList2
Çıktı aşağıdaki şekilde olacaktır:
[1; -2; 4; 5; 8]
Sonraki örnek öğesinin kullanımını gösterir List.sortWith . Bu örnekte, özel karşılaştırma işlevi öncelikle bir compareWidgets özel türün bir alanını ve ardından ilk alanın değerleri eşitse başka bir değeri karşılaştırmak için kullanılır.
type Widget = { ID: int; Rev: int }
let compareWidgets widget1 widget2 =
if widget1.ID < widget2.ID then -1 else
if widget1.ID > widget2.ID then 1 else
if widget1.Rev < widget2.Rev then -1 else
if widget1.Rev > widget2.Rev then 1 else
0
let listToCompare = [
{ ID = 92; Rev = 1 }
{ ID = 110; Rev = 1 }
{ ID = 100; Rev = 5 }
{ ID = 100; Rev = 2 }
{ ID = 92; Rev = 1 }
]
let sortedWidgetList = List.sortWith compareWidgets listToCompare
printfn "%A" sortedWidgetList
Çıktı aşağıdaki şekilde olacaktır:
[{ID = 92;
Rev = 1;}; {ID = 92;
Rev = 1;}; {ID = 100;
Rev = 2;}; {ID = 100;
Rev = 5;}; {ID = 110;
Rev = 1;}]
Listelerde arama Işlemleri
Listeler için çok sayıda arama işlemi desteklenir. En basit, List. Find, belirli bir koşulla eşleşen ilk öğeyi bulmanızı sağlar.
Aşağıdaki kod örneği, List.find bir listede 5 ' e bölünebilen ilk sayıyı bulmak için kullanımını gösterir.
let isDivisibleBy number elem = elem % number = 0
let result = List.find (isDivisibleBy 5) [ 1 .. 100 ]
printfn "%d " result
Sonuç 5 ' tir.
Öğelerin önce dönüştürülmesi gerekiyorsa, bir seçenek döndüren bir işlevi alan List. Pickçağırın ve olan ilk seçenek değerini arar Some(x) . Öğesini döndürmek yerine List.pick sonucunu döndürür x . Eşleşen bir öğe bulunamazsa, List.pick oluşturur System.Collections.Generic.KeyNotFoundException . Aşağıdaki kod öğesinin kullanımını gösterir List.pick .
let valuesList = [ ("a", 1); ("b", 2); ("c", 3) ]
let resultPick = List.pick (fun elem ->
match elem with
| (value, 2) -> Some value
| _ -> None) valuesList
printfn "%A" resultPick
Çıktı aşağıdaki şekilde olacaktır:
"b"
Başka bir arama işlemleri grubu olan List. tryFind ve related işlevleri, bir seçenek değeri döndürür. İşlevi, böyle bir öğe varsa bir List.tryFind koşulu karşılayan bir listenin ilk öğesini döndürür, ancak değilse seçenek değeri None . Çeşitleme listesi. tryFindIndex , öğenin kendisi yerine, varsa, öğesinin dizinini döndürür. Bu işlevler aşağıdaki kodda gösterilmiştir.
let list1d = [1; 3; 7; 9; 11; 13; 15; 19; 22; 29; 36]
let isEven x = x % 2 = 0
match List.tryFind isEven list1d with
| Some value -> printfn "The first even value is %d." value
| None -> printfn "There is no even value in the list."
match List.tryFindIndex isEven list1d with
| Some value -> printfn "The first even value is at position %d." value
| None -> printfn "There is no even value in the list."
Çıktı aşağıdaki şekilde olacaktır:
The first even value is 22.
The first even value is at position 8.
Listelerde aritmetik Işlemler
Toplam ve ortalama gibi yaygın aritmetik işlemler liste modülüneyerleştirilmiştir. List. Sumile çalışmak için liste öğesi türü + işleci desteklemelidir ve sıfır değerine sahip olmalıdır. Tüm yerleşik aritmetik türler bu koşulları karşılar. List. Averageile çalışmak için, öğe türü, bir geri kalanı olmadan bir bölüm desteklemelidir, bu da integral türlerini dışlar, ancak kayan nokta türlerine izin verir. List. sumBy ve List. averageBy işlevleri bir işlevi parametre olarak alır ve bu işlevin sonuçları Sum veya Average değerlerini hesaplamak için kullanılır.
Aşağıdaki kod,, ve kullanımını gösterir List.sum List.sumBy List.average .
// Compute the sum of the first 10 integers by using List.sum.
let sum1 = List.sum [1 .. 10]
// Compute the sum of the squares of the elements of a list by using List.sumBy.
let sum2 = List.sumBy (fun elem -> elem*elem) [1 .. 10]
// Compute the average of the elements of a list by using List.average.
let avg1 = List.average [0.0; 1.0; 1.0; 2.0]
printfn "%f" avg1
Çıktı 1.000000 olur.
Aşağıdaki kod öğesinin kullanımını gösterir List.averageBy .
let avg2 = List.averageBy (fun elem -> float elem) [1 .. 10]
printfn "%f" avg2
Çıktı 5.5 olur.
Listeler ve tanımlama grupları
Tanımlama gruplarını içeren listeler, zip ve unzip işlevleri tarafından değiştirilebilir. Bu işlevler, tek değerlerden oluşan iki listeyi tek bir tanımlama grubu içinde birleştirir veya bir tanımlama grubu listesini tek değerlerden oluşan iki listeye ayırır. En basit List.zip işlevi, tek öğelerin iki listesini alır ve dizi kümesi çiftlerinin tek bir listesini oluşturur. Başka bir sürüm olan List. zip3, tek öğelerin üç listesini alır ve üç öğesi içeren başlıkların tek bir listesini oluşturur. Aşağıdaki kod örneği öğesinin kullanımını gösterir List.zip .
let list1 = [ 1; 2; 3 ]
let list2 = [ -1; -2; -3 ]
let listZip = List.zip list1 list2
printfn "%A" listZip
Çıktı aşağıdaki şekilde olacaktır:
[(1, -1); (2, -2); (3; -3)]
Aşağıdaki kod örneği öğesinin kullanımını gösterir List.zip3 .
let list3 = [ 0; 0; 0]
let listZip3 = List.zip3 list1 list2 list3
printfn "%A" listZip3
Çıktı aşağıdaki şekilde olacaktır:
[(1, -1, 0); (2, -2, 0); (3, -3, 0)]
Karşılık gelen unzip sürümleri, List. unzip ve List. unzip3, tanımlama grubu ve dönüş listelerinin listesini alır, burada ilk liste her bir tanımlama grubunda ilk olan tüm öğeleri içerir ve ikinci liste her bir tanımlama grubunun ikinci öğesini içerir ve bu şekilde devam eder.
Aşağıdaki kod örneği List. unzipöğesinin kullanımını gösterir.
let lists = List.unzip [(1,2); (3,4)]
printfn "%A" lists
printfn "%A %A" (fst lists) (snd lists)
Çıktı aşağıdaki şekilde olacaktır:
([1; 3], [2; 4])
[1; 3] [2; 4]
Aşağıdaki kod örneği List. unzip3kullanımını gösterir.
let listsUnzip3 = List.unzip3 [(1,2,3); (4,5,6)]
printfn "%A" listsUnzip3
Çıktı aşağıdaki şekilde olacaktır:
([1; 4], [2; 5], [3; 6])
Liste öğelerinde çalışma
F #, liste öğelerinde çeşitli işlemleri destekler. Listenin her öğesinde bir işlevi çağırmanızı sağlayan en basit List. iter. Her bir öğenin dizininin her öğe için çağrılan işleve bir bağımsız değişken olarak geçirilmesi ve ve işlevlerinin bir birleşimi olan List. iteri2 ' yi, bu iki listenin öğelerinde bir işlem gerçekleştirmenize olanak sağlayan varyasyonlar Include List. iter2 List.iter List.iter2 List.iteri . Aşağıdaki kod örneği bu işlevleri gösterir.
let list1 = [1; 2; 3]
let list2 = [4; 5; 6]
List.iter (fun x -> printfn "List.iter: element is %d" x) list1
List.iteri(fun i x -> printfn "List.iteri: element %d is %d" i x) list1
List.iter2 (fun x y -> printfn "List.iter2: elements are %d %d" x y) list1 list2
List.iteri2 (fun i x y ->
printfn "List.iteri2: element %d of list1 is %d element %d of list2 is %d"
i x i y)
list1 list2
Çıktı aşağıdaki şekilde olacaktır:
List.iter: element is 1
List.iter: element is 2
List.iter: element is 3
List.iteri: element 0 is 1
List.iteri: element 1 is 2
List.iteri: element 2 is 3
List.iter2: elements are 1 4
List.iter2: elements are 2 5
List.iter2: elements are 3 6
List.iteri2: element 0 of list1 is 1; element 0 of list2 is 4
List.iteri2: element 1 of list1 is 2; element 1 of list2 is 5
List.iteri2: element 2 of list1 is 3; element 2 of list2 is 6
Liste öğelerini dönüştüren başka bir sık kullanılan işlev List . Mapolur ve bu, bir listedeki her öğeye bir işlev uygulamanıza ve tüm sonuçların yeni bir listeye yerleştirmenize olanak sağlar. List. map2 ve List. map3 birden çok liste alan değişimlerdir. List. mapi ve List. mapi2öğesini de kullanabilirsiniz. Buna ek olarak, işlevine her öğenin dizinini geçirilmesi gerekir. Ve arasındaki tek fark List.mapi2 , List.mapi List.mapi2 iki liste ile birlikte çalışmadır. Aşağıdaki örnekte List. Mapgösterilmektedir.
let list1 = [1; 2; 3]
let newList = List.map (fun x -> x + 1) list1
printfn "%A" newList
Çıktı aşağıdaki şekilde olacaktır:
[2; 3; 4]
Aşağıdaki örnek öğesinin kullanımını gösterir List.map2 .
let list1 = [1; 2; 3]
let list2 = [4; 5; 6]
let sumList = List.map2 (fun x y -> x + y) list1 list2
printfn "%A" sumList
Çıktı aşağıdaki şekilde olacaktır:
[5; 7; 9]
Aşağıdaki örnek öğesinin kullanımını gösterir List.map3 .
let newList2 = List.map3 (fun x y z -> x + y + z) list1 list2 [2; 3; 4]
printfn "%A" newList2
Çıktı aşağıdaki şekilde olacaktır:
[7; 10; 13]
Aşağıdaki örnek öğesinin kullanımını gösterir List.mapi .
let newListAddIndex = List.mapi (fun i x -> x + i) list1
printfn "%A" newListAddIndex
Çıktı aşağıdaki şekilde olacaktır:
[1; 3; 5]
Aşağıdaki örnek öğesinin kullanımını gösterir List.mapi2 .
let listAddTimesIndex = List.mapi2 (fun i x y -> (x + y) * i) list1 list2
printfn "%A" listAddTimesIndex
Çıktı aşağıdaki şekilde olacaktır:
[0; 7; 18]
List. Collect , List.map her öğe bir liste ürettiğinden ve tüm bu listelerin son bir liste ile bitiştirildiği durumlar haricinde gibidir. Aşağıdaki kodda, listenin her bir öğesi üç sayı üretir. Bunların hepsi tek bir listede toplanır.
let collectList = List.collect (fun x -> [for i in 1..3 -> x * i]) list1
printfn "%A" collectList
Çıktı aşağıdaki şekilde olacaktır:
[1; 2; 3; 2; 4; 6; 3; 6; 9]
Ayrıca, Boolean koşulunu alan ve yalnızca verilen koşulu karşılayan öğelerden oluşan yeni bir liste üreten List. Filteröğesini de kullanabilirsiniz.
let evenOnlyList = List.filter (fun x -> x % 2 = 0) [1; 2; 3; 4; 5; 6]
Elde edilen liste [2; 4; 6] .
Map ve Filter, List. Select birleşimi, öğeleri aynı anda dönüştürmenizi ve seçmenizi sağlar. List.choose bir listedeki her öğeye bir seçenek döndüren bir işlev uygular ve işlev seçenek değerini döndürdüğünde öğelerin sonuçlarının yeni bir listesini döndürür Some .
Aşağıdaki kod, List.choose bir sözcük listesinden büyük harfli sözcükler seçmek için kullanımını gösterir.
let listWords = [ "and"; "Rome"; "Bob"; "apple"; "zebra" ]
let isCapitalized (string1:string) = System.Char.IsUpper string1[0]
let results = List.choose (fun elem ->
match elem with
| elem when isCapitalized elem -> Some(elem + "'s")
| _ -> None) listWords
printfn "%A" results
Çıktı aşağıdaki şekilde olacaktır:
["Rome's"; "Bob's"]
Birden çok liste üzerinde çalışma
Listeler birlikte birleştirilebilir. İki listeyi tek tek birleştirmek için List. Appendkullanın. İkiden fazla listeyi birleştirmek için List. Concatkullanın.
let list1to10 = List.append [1; 2; 3] [4; 5; 6; 7; 8; 9; 10]
let listResult = List.concat [ [1; 2; 3]; [4; 5; 6]; [7; 8; 9] ]
List.iter (fun elem -> printf "%d " elem) list1to10
printfn ""
List.iter (fun elem -> printf "%d " elem) listResult
Katlama ve tarama Işlemleri
Bazı liste işlemleri liste öğeleri arasında bağımlılıkları kapsar. Katlama ve tarama işlemleri, List.iter List.map her öğe üzerinde bir işlevi çağırmanıza benzer ancak bu işlemler, hesaplama aracılığıyla bilgi taşıyan bir ek parametre sağlar.
List.foldBir liste üzerinde hesaplama gerçekleştirmek için kullanın.
Aşağıdaki kod örneği, çeşitli işlemleri gerçekleştirmek için List. Fold öğesinin kullanımını gösterir.
Listeye çapraz ve Biriktirici, acc Hesaplama ilerledikçe geçen bir değerdir. İlk bağımsız değişken, biriktiriciden ve List öğesini alır ve bu liste öğesi için hesaplamanın ara sonucunu döndürür. İkinci bağımsız değişken, biriktiricinin ilk değeridir.
let sumList list = List.fold (fun acc elem -> acc + elem) 0 list
printfn "Sum of the elements of list %A is %d." [ 1 .. 3 ] (sumList [ 1 .. 3 ])
// The following example computes the average of a list.
let averageList list = (List.fold (fun acc elem -> acc + float elem) 0.0 list / float list.Length)
// The following example computes the standard deviation of a list.
// The standard deviation is computed by taking the square root of the
// sum of the variances, which are the differences between each value
// and the average.
let stdDevList list =
let avg = averageList list
sqrt (List.fold (fun acc elem -> acc + (float elem - avg) ** 2.0 ) 0.0 list / float list.Length)
let testList listTest =
printfn "List %A average: %f stddev: %f" listTest (averageList listTest) (stdDevList listTest)
testList [1; 1; 1]
testList [1; 2; 1]
testList [1; 2; 3]
// List.fold is the same as to List.iter when the accumulator is not used.
let printList list = List.fold (fun acc elem -> printfn "%A" elem) () list
printList [0.0; 1.0; 2.5; 5.1 ]
// The following example uses List.fold to reverse a list.
// The accumulator starts out as the empty list, and the function uses the cons operator
// to add each successive element to the head of the accumulator list, resulting in a
// reversed form of the list.
let reverseList list = List.fold (fun acc elem -> elem::acc) [] list
printfn "%A" (reverseList [1 .. 10])
İşlev adında basamak olan bu işlevlerin sürümleri birden fazla listede çalışır. Örneğin, List. fold2 iki listede hesaplamalar gerçekleştirir.
Aşağıdaki örnek öğesinin kullanımını gösterir List.fold2 .
// Use List.fold2 to perform computations over two lists (of equal size) at the same time.
// Example: Sum the greater element at each list position.
let sumGreatest list1 list2 = List.fold2 (fun acc elem1 elem2 ->
acc + max elem1 elem2) 0 list1 list2
let sum = sumGreatest [1; 2; 3] [3; 2; 1]
printfn "The sum of the greater of each pair of elements in the two lists is %d." sum
List.fold ve List. Scan , List.fold ek parametrenin son değerini döndüren ' de farklılık gösterir, ancak List.scan ek parametrenin ara değerlerinin (son değeri ile birlikte) listesini döndürür.
Bu işlevlerin her biri, listenin geri alındığı sırada ve bağımsız değişkenlerin sırası farklı olan List. foldBackgibi bir ters çeşitleme içerir. Ayrıca, List.fold ve aynı List.foldBack uzunlukta iki liste alan Çeşitlemeler, List. fold2 ve List. foldBack2' i de vardır. Her öğe üzerinde yürütülen işlev, bazı eylemler gerçekleştirmek için her iki listedeki ilgili öğeleri kullanabilir. Aşağıdaki örnekte olduğu gibi, iki listenin öğe türleri farklı olabilir. Bu, bir liste bir banka hesabı için işlem tutarlarını içerir ve diğer liste işlemin türünü içerir: depozito veya çekme al.
// Discriminated union type that encodes the transaction type.
type Transaction =
| Deposit
| Withdrawal
let transactionTypes = [Deposit; Deposit; Withdrawal]
let transactionAmounts = [100.00; 1000.00; 95.00 ]
let initialBalance = 200.00
// Use fold2 to perform a calculation on the list to update the account balance.
let endingBalance = List.fold2 (fun acc elem1 elem2 ->
match elem1 with
| Deposit -> acc + elem2
| Withdrawal -> acc - elem2)
initialBalance
transactionTypes
transactionAmounts
printfn "%f" endingBalance
Toplama gibi bir hesaplama için, List.fold List.foldBack sonuç çapraz geçiş sırasına bağlı olmadığından aynı etkiye sahiptir. Aşağıdaki örnekte, List.foldBack bir listedeki öğeleri eklemek için kullanılır.
let sumListBack list = List.foldBack (fun elem acc -> acc + elem) list 0
printfn "%d" (sumListBack [1; 2; 3])
// For a calculation in which the order of traversal is important, fold and foldBack have different
// results. For example, replacing fold with foldBack in the listReverse function
// produces a function that copies the list, rather than reversing it.
let copyList list = List.foldBack (fun elem acc -> elem::acc) list []
printfn "%A" (copyList [1 .. 10])
Aşağıdaki örnek, banka hesabı örneğine geri döner. Yeni bir işlem türü eklendiğinde bu kez bir vade farkının hesaplanması. Bitiş bakiyesi artık işlem sırasına bağlıdır.
type Transaction2 =
| Deposit
| Withdrawal
| Interest
let transactionTypes2 = [Deposit; Deposit; Withdrawal; Interest]
let transactionAmounts2 = [100.00; 1000.00; 95.00; 0.05 / 12.0 ]
let initialBalance2 = 200.00
// Because fold2 processes the lists by starting at the head element,
// the interest is calculated last, on the balance of 1205.00.
let endingBalance2 = List.fold2 (fun acc elem1 elem2 ->
match elem1 with
| Deposit -> acc + elem2
| Withdrawal -> acc - elem2
| Interest -> acc * (1.0 + elem2))
initialBalance2
transactionTypes2
transactionAmounts2
printfn "%f" endingBalance2
// Because foldBack2 processes the lists by starting at end of the list,
// the interest is calculated first, on the balance of only 200.00.
let endingBalance3 = List.foldBack2 (fun elem1 elem2 acc ->
match elem1 with
| Deposit -> acc + elem2
| Withdrawal -> acc - elem2
| Interest -> acc * (1.0 + elem2))
transactionTypes2
transactionAmounts2
initialBalance2
printfn "%f" endingBalance3
İşlev listesi. küçültme biraz benzer ve aynı şekilde, List.fold List.scan ayrı bir Biriktiricinin etrafında geçiş yerine List.reduce iki bağımsız değişken alan bir işlev alır, ancak bu bağımsız değişkenlerden biri yalnızca bir değil, bu bağımsız değişkenlerden biri de, hesaplamanın ara sonucunu depoladığı anlamına gelir. List.reduce ilk iki liste öğesinde çalışmaya başlar ve sonra işlemin sonucunu Next öğesiyle birlikte kullanır. Kendi türüne sahip ayrı bir biriktiricidir çünkü, List.reduce List.fold yalnızca biriktiricidir ve öğe türü aynı türde olduğunda ' nin yerine kullanılabilir. Aşağıdaki kod öğesinin kullanımını gösterir List.reduce . List.reduce Belirtilen listede öğe yoksa bir özel durum oluşturur.
Aşağıdaki kodda, lambda ifadesine yapılan ilk çağrıya 2 ve 4 bağımsız değişkenleri verilir ve 6, sonraki çağrıya ise 6 ve 10 bağımsız değişkenleri verilir, dolayısıyla sonuç 16 ' dır.
let sumAList list =
try
List.reduce (fun acc elem -> acc + elem) list
with
| :? System.ArgumentException as exc -> 0
let resultSum = sumAList [2; 4; 10]
printfn "%d " resultSum
Listeler ve Diğer Koleksiyon Türleri Arasında Dönüştürme
Modül, List hem dizilere hem de dizilere ve dizilere dönüştürme işlevleri sağlar. Bir diziye veya diziden dönüştürmek için List.toSeq veya List.ofSeq kullanın. Bir diziye veya diziden dönüştürmek için List.toArray veya List.ofArray kullanın.
Ek İşlemler
Listelerde yapılan ek işlemler hakkında daha fazla bilgi için Kitaplık başvuru konusu Liste Modülü'ne bakın.