एफ # 10: सूची

किसी भी भाषा में किसी भी गंभीर प्रोग्रामिंग में हमेशा सूचियाँ शामिल होंगी। इस प्रकार, आपको यह जानकर प्रसन्नता होगी कि F # बहुत, बहुत अच्छी तरह से इसके सूची मॉड्यूल का उपयोग करके सूचियों का समर्थन करता है। F # में एक सूची उसी प्रकार के तत्वों की एक क्रमबद्ध, अपरिवर्तनीय श्रृंखला है।

एक सूची बनाएं

F # में कई तरीके हैं जिनसे आप एक सूची बना सकते हैं।

• एक खाली सूची बनाएँ
• 1 से 10 तक आइटम के साथ एक सरल सूची बनाएं
• 1 से 10 तक की सीमा में विषम संख्याओं के साथ एक सूची बनाएं
• सूची बनाने के लिए लूप का उपयोग करें।

let prettyPrint desc list = printfn desc printfn "%A" list //empty list let listEmpty = [] //simple list let list1 = [1 .. 10 ] //simple list, with step value let list2 = [1 ..2..10 ] //using for loops to create lists let list3 = [for i in 1 .. 10 -> i*2 ] prettyPrint "let listEmpty = []" listEmpty prettyPrint "let list1 = [ 1 .. 10 ]" list1 prettyPrint "let list2 = [ 1 .. 2..10 ]" list2 prettyPrint "[ for i in 1 .. 10 -> i*2 ]" list3 

ऊपर दिखाए गए अंतिम उदाहरण से पता चलता है कि सूची बनाने के लिए लूप का उपयोग कैसे किया जाता है, जो बहुत ही शांत है, लेकिन एफ # टूलबॉक्स में कुछ और भी अधिक शांत और शक्तिशाली है, अर्थात् सूची समझ।

सूची समझ एक शक्तिशाली विधि है जो आपको मानक F # का उपयोग करके सूचियां बनाने की अनुमति देती है, जिसमें फ़ंक्शन / लूप / शर्तें आदि शामिल हैं।

आइए एक उदाहरण देखते रहें कि हम सूची कैसे बना सकते हैं।

 let is2 x = match x with | 2 -> "YES" | _ -> "NO" //yield directly let list1 = [ yield 1; yield 2; yield 3; ] //yield numbers between 1 and 20 where we use the //Math.Pow function to return a new number let list2 = [for i in 1.0 .. 20.0 do yield Math.Pow(i,2.0) ] //yield only numbers between 1 and 20 that //can be divided by 5 let list3 = [ for i in 1 .. 20 do if i % 5 = 0 then yield i ] //yields YES/NO strings depending on //whether source int = 2 or not let list4 = [for i in 1 .. 5 -> is2 i ] 

कुछ उपयोगी सूची ऑपरेटर

कंस ऑपरेटर

हम मौजूदा सूची में मान जोड़ने के लिए "ऑपरेटर" का उपयोग कर सकते हैं, इसलिए मान लें कि हमारे पास यह सूची थी:

 let list1 = [1;2;3;4] let list2 = 42 :: list1 

सांत्वना देनेवाला संचालक

एक और बहुत उपयोगी ऑपरेटर "@" ऑपरेटर है, जो आपको उसी प्रकार की सूचियों को संयोजित करने की अनुमति देता है। इसलिए, उदाहरण के लिए, अगर हमारे पास यह था:

 let list1 = [1;2;3;4] let list2 = [5;6;7;8] let list3 = list1 @ list2 

सूची मॉड्यूल

मुझे नहीं लगता कि मैं इसे अति करता हूं जब मैं कहता हूं कि सूची मॉड्यूल एफ # में एक महत्वपूर्ण मॉड्यूल है। वास्तव में, इसके लिए MSDN प्रलेखन F # में दूसरों की तुलना में बहुत अच्छा है। इसलिए, मुझे नहीं लगता कि मैं MSDN पर पाए गए उदाहरणों में बहुत अधिक उपयोगिता जोड़ सकता हूं, लेकिन मैं आपकी सुविधा के लिए यहां कुछ दे दूंगा, लेकिन आपको अधिक जानकारी के लिए MSDN का अध्ययन करना चाहिए ।

गुण

Head
'T
पहला तत्व
Empty
'T list
निर्दिष्ट प्रकार की एक खाली सूची देता है
IsEmpty
bool
सच - अगर सूची में कोई तत्व नहीं हैं
मद
'टी
एक आइटम जो एक विशिष्ट सूचकांक पर है
लंबाई
पूर्णांक
मदों की संख्या
पूंछ
'टी सूची
पहली आइटम के बिना सूची:

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

फ़िल्टर (फ़िल्टर)

एक नया संग्रह लौटाता है जिसमें केवल संग्रह के तत्व होते हैं जिसके लिए दिए गए विधेय सही होते हैं। यहां एक तुच्छ उदाहरण है जो एक सूची से केवल एक नई सूची बनाने के लिए संख्या का चयन करता है

 let evenOnlyList = List.filter (fun x -> x % 2 = 0) [1; 2; 3; 4; 5; 6] 

खोजें (खोजें)

पहला तत्व लौटाता है जिसके लिए यह फ़ंक्शन सही है। इस उदाहरण में, चूंकि 1 से 100 तक की सूची में 5 है, 5 में 1 नंबर है, जो 5 से विभाजित है, इसलिए यह रिटर्न है:

सभी के लिए (forall)

जाँच करता है कि क्या संग्रह के सभी तत्व दिए गए विधेय को संतुष्ट करते हैं। इस उदाहरण में, सही वापसी मान प्राप्त करने के लिए पूरी सूची में 0 होना चाहिए।

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

सभी पर लागू करें (Iteri)

इस फ़ंक्शन को संग्रह में प्रत्येक आइटम पर लागू करता है। फ़ंक्शन के लिए दिया गया पूर्णांक तत्व के सूचकांक को इंगित करता है।

 let data = ["Cats";"Dogs";"Mice";"Elephants"] data |> List.iteri (fun ix -> printfn "item %d: %s" ix) 

द्वारा क्रमबद्ध करें (SortWith)

इस तुलनात्मक फ़ंक्शन का उपयोग करके निर्दिष्ट सूची को सॉर्ट करता है।

 let list1 = [ ""; "&"; "&&"; "&&&"; ""; "|"; "||"; "|||" ] printfn "Before sorting: " list1 |> printfn "%A" //custom sorting function let sortFunction (string1:string) (string2:string) = if (string1.Length > string2.Length) then 1 else if (string1.Length printfn "After sorting:\n%A" 

सूची मॉड्यूल में कई उपयोगी कार्य हैं, यह सिर्फ एक छोटा सा हिस्सा है जिसे आप पा सकते हैं।

सूचियों पर पुनरावृत्ति पर एक छोटा सा नज़र

पुनरावर्तन के बारे में बात किए बिना सूचियों की कोई चर्चा पूरी नहीं होगी। पुनरावृत्ति वह है जो पूरी पोस्ट के लिए समर्पित होगी, लेकिन अब, आइए एक नज़र डालते हैं कि एक पुनरावर्ती फ़ंक्शन को लिखने में क्या लगता है जो एफ # में एक सूची पर काम करता है।

 let printIt desc x = printfn "%A %A" desc x let rec printList list = match list with | h :: t -> printIt "head=" h printIt "tail=" t printList t | [] -> () printList [1;2;3;4;5] 

रिक कीवर्ड के उपयोग पर ध्यान दें, जो एफ # संकलक को बताता है कि यह फ़ंक्शन पुनरावर्ती होगा। इस कीवर्ड के बिना, एक पुनरावर्ती फ़ंक्शन कॉल - आपको एक संकलन त्रुटि संदेश प्राप्त होगा, हालांकि बहुत स्पष्ट त्रुटि पाठ के साथ नहीं।



तो, आइए देखें कि निम्न सूची [1] के साथ दिखाए गए उदाहरण के परिणाम थोड़े अधिक हैं; 2; 3; 4; 5]



आप देख सकते हैं कि सब कुछ ठीक काम करता है, और यह तब काम करना बंद कर देता है जब मूल्य एक खाली सूची से मेल खाता है, जैसा कि अपेक्षित था।