जूलिया। तालिकाओं के साथ काम करें

जूलिया सबसे कम उम्र की गणितीय प्रोग्रामिंग भाषाओं में से एक है, इस क्षेत्र में मुख्य प्रोग्रामिंग भाषा होने का दावा करती है। दुर्भाग्य से, फिलहाल रूसी में पर्याप्त साहित्य नहीं है, और अंग्रेजी में उपलब्ध सामग्रियों में जानकारी है, जो जूलिया के गतिशील विकास के कारण हमेशा वर्तमान संस्करण के अनुरूप नहीं होती है, लेकिन शुरुआती जूलिया-प्रोग्रामर्स के लिए यह स्पष्ट नहीं है। हम अंतराल में भरने की कोशिश करेंगे और जूलिया के विचारों को सरल उदाहरणों के रूप में पाठकों तक पहुंचाएंगे।

इस लेख का उद्देश्य जूलिया प्रोग्रामिंग भाषा में तालिकाओं के साथ काम करने के बुनियादी तरीकों का एक विचार है ताकि वास्तविक डेटा को संसाधित करने के लिए इस प्रोग्रामिंग भाषा का उपयोग शुरू करने के लिए उन्हें प्रोत्साहित किया जा सके। हम मानते हैं कि पाठक पहले से ही अन्य प्रोग्रामिंग भाषाओं से परिचित है, इसलिए हम केवल इस बारे में न्यूनतम जानकारी देंगे कि यह कैसे किया जाता है, लेकिन हम डेटा प्रोसेसिंग विधियों के विवरण में नहीं जाएंगे।

बेशक, एक प्रोग्राम के काम में सबसे महत्वपूर्ण चरणों में से एक जो डेटा विश्लेषण करता है, वह उनका आयात और निर्यात है। इसके अलावा, सबसे आम डेटा प्रस्तुति प्रारूप एक तालिका है। जूलिया के लिए पुस्तकालय हैं जो रिलेशनल डीबीएमएस तक पहुंच प्रदान करते हैं, एचडीएफ 5, मैटलैब, जेएलडी जैसे एक्सचेंज स्वरूपों का उपयोग करते हैं। लेकिन इस मामले में, हमें केवल तालिकाओं की प्रस्तुति के पाठ प्रारूप में रुचि होगी, जैसे कि सीएसवी।

तालिकाओं को देखने से पहले, आपको इस डेटा संरचना की प्रस्तुति के लिए एक छोटा सा परिचय देने की आवश्यकता है। जूलिया के लिए, एक तालिका को दो-आयामी सरणी के रूप में या डेटाफ़्रेम के रूप में दर्शाया जा सकता है।

सरणियों

चलो जूलिया में सरणियों के साथ शुरू करते हैं। तत्वों की संख्या एक से शुरू होती है। यह गणितज्ञों के लिए काफी स्वाभाविक है, और इसके अलावा, इसी योजना का उपयोग फोरट्रान, पास्कल, मतलाब में किया जाता है। प्रोग्रामर जिन्होंने कभी इन भाषाओं का उपयोग नहीं किया है, उनके लिए यह अंकन असहज हो सकता है और सीमा की स्थिति लिखते समय त्रुटियों का कारण बन सकता है, लेकिन, वास्तव में, यह सिर्फ आदत की बात है। जूलिया का उपयोग करने के कुछ हफ्तों के बाद, भाषा मॉडल के बीच स्विच करने का सवाल ही नहीं उठता।

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

हम कमांड लाइन (REPL) पर बनाई गई एक सरणी के साथ इसका वर्णन करते हैं

julia> a = [1, 2, 3] 3-element Array{Int64,1}: 1 2 3 

सरणी के प्रकार पर ध्यान दें - ऐरे {Int64,1}। सरणी एक आयामी है, Int64 टाइप करें। इसके अलावा, यदि हम इस सरणी को किसी अन्य सरणी के साथ जोड़ना चाहते हैं, तो, चूंकि हम एक स्तंभ के साथ काम कर रहे हैं, इसलिए हमें vcat फ़ंक्शन (अर्थात ऊर्ध्वाधर समवर्ती) का उपयोग करना चाहिए। परिणाम एक नया स्तंभ है।

 julia> b = vcat(a, [5, 6, 7]) 7-element Array{Int64,1}: 1 2 3 5 6 7 

यदि हम एक स्ट्रिंग को एक स्ट्रिंग के रूप में बनाते हैं, तो एक शाब्दिक लिखते समय, हम कॉमा के बजाय रिक्त स्थान का उपयोग करते हैं और प्रकार का एक दो आयामी सरणी प्राप्त करते हैं Array {Int64,2}। प्रकार की घोषणा में दूसरा तर्क का अर्थ है बहुआयामी सरणी के निर्देशांक की संख्या।

 julia> c = [1 2 3] 1×3 Array{Int64,2}: 1 2 3 

यही है, हमें एक पंक्ति और तीन कॉलम के साथ एक मैट्रिक्स मिला है।

पंक्तियों और स्तंभों की यह प्रस्तुति भी फोरट्रान और मतलाब की विशेषता है, लेकिन, यह केवल याद किया जाना चाहिए कि जूलिया एक भाषा है जो विशेष रूप से उनके क्षेत्र के लिए उन्मुख है।

जूलिया के लिए मैट्रिक्स एक द्वि-आयामी सरणी है, जहां सभी कोशिकाएं एक ही प्रकार की होती हैं। आइए इस तथ्य पर ध्यान दें कि प्रकार सार हो सकता है कोई भी या काफी विशिष्ट, जैसे कि Int64, Float64 या, यहां तक ​​कि, स्ट्रिंग।

हम एक शाब्दिक के रूप में एक मैट्रिक्स बना सकते हैं:

 julia> a = [1 2; 3 4] 2×2 Array{Int64,2}: 1 2 3 4 

निर्माणकर्ता का उपयोग करके बनाएँ और आरंभीकरण के बिना मेमोरी आवंटित करें (अपरिभाषित):

 julia> a = Array{Int64,2}(undef, 2, 3) 2×3 Array{Int64,2}: 4783881648 4783881712 4782818640 4783881680 4783881744 4782818576 

या आरंभ के साथ यदि कोई विशिष्ट मान अपरिभाषित के बजाय निर्दिष्ट किया गया है।

अलग कॉलम से गोंद:

 julia> a = [1, 2, 3] 3-element Array{Int64,1}: 1 2 3 julia> b = hcat(a, a, a, a) 3×4 Array{Int64,2}: 1 1 1 1 2 2 2 2 3 3 3 3 

बेतरतीब ढंग से शुरू करें:

 julia> x = rand(1:10, 2, 3) 2×3 Array{Int64,2}: 1 10 2 9 7 7 

तर्क रैंड - 1 से 10 तक और आयाम 2 x 3।

या समावेश का उपयोग करें (समझ)

 julia> x = [min(i, j) for i = 0:2, j = 0:2 ] 3×3 Array{Int64,2}: 0 0 0 0 1 1 0 1 2 

इस तथ्य पर ध्यान दें कि जूलिया के लिए कॉलम मेमोरी का एक रैखिक ब्लॉक है, इस तथ्य की ओर जाता है कि कॉलम द्वारा तत्वों पर पुनरावृति पंक्तियों के माध्यम से छंटाई की तुलना में काफी तेज होगी। विशेष रूप से, निम्न उदाहरण 1_000_000 पंक्तियों और 100 स्तंभों के मैट्रिक्स का उपयोग करता है।

 #!/usr/bin/env julia using BenchmarkTools x = rand(1:1000, 1_000_000, 100) #x = rand(1_000_000, 100) function sumbycolumns(x) sum = 0 rows, cols = size(x) for j = 1:cols, i = 1:rows sum += x[i, j] end return sum end @show @btime sumbycolumns(x) function sumbyrows(x) sum = 0 rows, cols = size(x) for i = 1:rows, j = 1:cols sum += x[i, j] end return sum end @show @btime sumbyrows(x) 

परिणाम:

  74.378 ms (1 allocation: 16 bytes) =# @btime(sumbycolumns(x)) = 50053093495 206.346 ms (1 allocation: 16 bytes) =# @btime(sumbyrows(x)) = 50053093495 

@btime उदाहरण में निष्पादित करने के लिए औसत समय की गणना करने के लिए एक फ़ंक्शन का एक बहु रन है। यह मैक्रो बेंचमार्कटूलजीएल लाइब्रेरी द्वारा प्रदान किया गया है। जूलिया बेस किट में एक टाइम मैक्रो है, लेकिन यह एक एकल अंतराल को मापता है, जो इस मामले में, गलत होगा। शो मैक्रो केवल कंसोल में एक्सप्रेशन और उसके परिकलित मान को प्रदर्शित करता है।

तालिका के साथ सांख्यिकीय संचालन करने के लिए स्तंभ संग्रहण अनुकूलन सुविधाजनक है। चूंकि परंपरागत रूप से, तालिका स्तंभों की संख्या द्वारा सीमित होती है, और पंक्तियों की संख्या कोई भी हो सकती है, अधिकांश ऑपरेशन, जैसे कि औसत, न्यूनतम, अधिकतम मानों की गणना, विशेष रूप से मैट्रिस के स्तंभों के लिए किए जाते हैं, और उनकी पंक्तियों के लिए नहीं।

दो आयामी सरणी के लिए एक पर्याय मैट्रिक्स प्रकार है। हालांकि, यह एक आवश्यकता के बजाय एक स्टाइल सुविधा है।

मैट्रिक्स तत्वों तक पहुंच सूचकांक द्वारा किया जाता है। उदाहरण के लिए, पहले से निर्मित मैट्रिक्स के लिए

 julia> x = rand(1:10, 2, 3) 2×3 Array{Int64,2}: 1 10 2 9 7 7 

हम x [1, 2] => 10 के रूप में एक विशिष्ट तत्व प्राप्त कर सकते हैं। इसलिए पूरे कॉलम को प्राप्त करें, उदाहरण के लिए, दूसरा कॉलम:

 julia> x[:, 2] 2-element Array{Int64,1}: 10 7 

या दूसरी पंक्ति:

 julia> x[2, :] 3-element Array{Int64,1}: 9 7 7 

एक उपयोगी चयन समारोह भी है, जहां आप उस आयाम की क्रमिक संख्या को निर्दिष्ट कर सकते हैं जिसके लिए आप एक चयन करना चाहते हैं, साथ ही साथ इस आयाम के तत्वों के सूचक भी। उदाहरण के लिए, 1 और 3 सूचकांकों का चयन करके 2 आयाम (कॉलम) पर एक नमूना बनाएं। यह दृष्टिकोण सुविधाजनक है, जब स्थितियों के आधार पर, आपको पंक्तियों और स्तंभों के बीच स्विच करने की आवश्यकता होती है। हालांकि, यह बहुआयामी मामले के लिए सच है, जब आयामों की संख्या 2 से अधिक है।

 julia> selectdim(x, 2, [1, 3]) 2×2 view(::Array{Int64,2}, :, [1, 3]) with eltype Int64: 1 2 9 7 

सरणियों के सांख्यिकीय प्रसंस्करण के लिए कार्य
एक-आयामी सरणियों पर अधिक
बहुआयामी Arrays
एक विशेष रूप से रैखिक बीजगणित और मैट्रिस के कार्य

एक फ़ाइल से एक तालिका पढ़ना डेल्स्टीफ़िल्स लाइब्रेरी में कार्यान्वित readdlm फ़ंक्शन का उपयोग करके किया जा सकता है। रिकॉर्डिंग - writedlm का उपयोग कर। ये फ़ंक्शंस सीमांकक के साथ फ़ाइलों के साथ काम प्रदान करते हैं, जिनमें से एक विशेष मामला सीएसवी प्रारूप है।

हम प्रलेखन से एक उदाहरण के साथ स्पष्ट करते हैं:

 julia> using DelimitedFiles julia> x = [1; 2; 3; 4]; julia> y = ["a"; "b"; "c"; "d"]; julia> open("delim_file.txt", "w") do io writedlm(io, [xy]) #      end; julia> readdlm("delim_file.txt") #   4×2 Array{Any,2}: 1 "a" 2 "b" 3 "c" 4 "d" 

इस मामले में, आपको इस तथ्य पर ध्यान देना चाहिए कि तालिका में विभिन्न प्रकार के डेटा शामिल हैं। इसलिए, किसी फ़ाइल को पढ़ते समय, Array {Any, 2} प्रकार का एक मैट्रिक्स बनाया जाता है।
एक अन्य उदाहरण सजातीय डेटा युक्त तालिकाओं को पढ़ रहा है।

 julia> using DelimitedFiles julia> x = [1; 2; 3; 4]; julia> y = [5; 6; 7; 8]; julia> open("delim_file.txt", "w") do io writedlm(io, [xy]) #   end; julia> readdlm("delim_file.txt", Int64) #    Int64 4×2 Array{Int64,2}: 1 5 2 6 3 7 4 8 julia> readdlm("delim_file.txt", Float64) #    Float64 4×2 Array{Float64,2}: 1.0 5.0 2.0 6.0 3.0 7.0 4.0 8.0 

प्रसंस्करण दक्षता के दृष्टिकोण से, यह विकल्प बेहतर है, क्योंकि डेटा को कॉम्पैक्ट रूप से प्रस्तुत किया जाएगा। इसी समय, मैट्रिक्स द्वारा प्रस्तुत तालिकाओं पर एक स्पष्ट प्रतिबंध डेटा एकरूपता के लिए एक आवश्यकता है।

हम प्रलेखन में पूर्ण रीडड्लम विशेषताओं को देखने की सलाह देते हैं। अतिरिक्त विकल्पों में हेडर के प्रसंस्करण मोड, लंघन लाइनों, प्रसंस्करण कोशिकाओं के कार्य आदि को निर्दिष्ट करने की क्षमता है ।

तालिकाओं को पढ़ने का एक वैकल्पिक तरीका CSV.jl पुस्तकालय है। Readdlm और writedlm की तुलना में, यह पुस्तकालय लिखने और पढ़ने के विकल्पों पर काफी अधिक नियंत्रण प्रदान करता है, साथ ही सीमांकित फ़ाइलों में डेटा की जाँच भी करता है। हालाँकि, मूलभूत अंतर यह है कि CSV.File फ़ंक्शन के परिणाम को DataFrame प्रकार में प्रतिस्थापित किया जा सकता है।

DataFrames

DataFrames पुस्तकालय DataFrame डेटा संरचना के लिए समर्थन प्रदान करता है, जो तालिकाओं की प्रस्तुति पर केंद्रित है। यहां मैट्रिक्स से मूलभूत अंतर यह है कि प्रत्येक कॉलम को व्यक्तिगत रूप से संग्रहीत किया जाता है, और प्रत्येक कॉलम का अपना नाम होता है। हम याद करते हैं कि जूलिया के लिए, कॉलम-वार स्टोरेज मोड, सामान्य रूप से, प्राकृतिक है। और, हालांकि यहां हमारे पास एक आयामी सरणियों का एक विशेष मामला है, एक इष्टतम समाधान डेटा प्रतिनिधित्व की गति और लचीलेपन दोनों के संदर्भ में प्राप्त किया जाता है, क्योंकि प्रत्येक स्तंभ का प्रकार अलग-अलग हो सकता है।

आइये देखते हैं कि DataFrame कैसे बनाते हैं।

किसी भी मैट्रिक्स को डाटाफ्रेम में परिवर्तित किया जा सकता है।

 julia> using DataFrames julia> a = [1 2; 3 4; 5 6] 3×2 Array{Int64,2}: 1 2 3 4 5 6 julia> b = convert(DataFrame, a) 3×2 DataFrame │ Row │ x1 │ x2 │ │ │ Int64 │ Int64 │ ├─────┼───────┼───────┤ │ 1 │ 1 │ 2 │ │ 2 │ 3 │ 4 │ │ 3 │ 5 │ 6 │ 

कन्वर्ट फ़ंक्शन निर्दिष्ट प्रकार के लिए डेटा परिवर्तित करता है। तदनुसार, डेटाफ़्रेम प्रकार के लिए, कन्वर्ट फ़ंक्शन के तरीकों को डेटाफ़्रेम लाइब्रेरी में परिभाषित किया गया है (जूलिया शब्दावली के अनुसार, फ़ंक्शन हैं, और विभिन्न तर्कों के साथ उनके कार्यान्वयन की विविधता को विधियों कहा जाता है)। यह ध्यान दिया जाना चाहिए कि मैट्रिक्स के कॉलम को स्वचालित रूप से X1, x2 नाम दिए गए हैं। यही है, यदि हम अब कॉलम नामों का अनुरोध करते हैं, तो हम उन्हें एक सरणी के रूप में प्राप्त करेंगे:

 julia> names(b) 2-element Array{Symbol,1}: :x1 :x2 

और नामों को प्रतीक (रूबी दुनिया में प्रसिद्ध) जैसे प्रारूप में प्रस्तुत किया गया है।

एक DataFrame सीधे बनाया जा सकता है - खाली या निर्माण के समय कुछ डेटा युक्त। उदाहरण के लिए:

 julia> df = DataFrame([collect(1:3), collect(4:6)], [:A, :B]) 3×2 DataFrame │ Row │ A │ B │ │ │ Int64 │ Int64 │ ├─────┼───────┼───────┤ │ 1 │ 1 │ 4 │ │ 2 │ 2 │ 5 │ │ 3 │ 3 │ 6 │ 

यहां हम स्तंभ मानों के साथ एक सरणी और इन स्तंभों के नाम के साथ एक सरणी इंगित करते हैं। फॉर्म इकट्ठा (1: 3) के निर्माण 1 से 3 मानों की एक सरणी में एक पुनरावृत्ति रेंज का रूपांतरण है।

स्तंभों तक पहुंच उनके नाम और अनुक्रमणिका दोनों से संभव है।

सभी मौजूदा पंक्तियों में कुछ मूल्य लिखकर एक नया कॉलम जोड़ना बहुत आसान है। उदाहरण के लिए, ऊपर df, हम स्कोर कॉलम जोड़ना चाहते हैं। ऐसा करने के लिए, हमें लिखना होगा:

 julia> df[:Score] = 0.0 0.0 julia> df 3×3 DataFrame │ Row │ A │ B │ Score │ │ │ Int64 │ Int64 │ Float64 │ ├─────┼───────┼───────┼─────────┤ │ 1 │ 1 │ 4 │ 0.0 │ │ 2 │ 2 │ 5 │ 0.0 │ │ 3 │ 3 │ 6 │ 0.0 │ 

साथ ही सरल मेट्रिसेस के मामले में, हम Vcat, hcat फ़ंक्शन का उपयोग करके DataFrame इंस्टेंस को गोंद कर सकते हैं। हालांकि, वीसीएटी का उपयोग केवल दोनों तालिकाओं में एक ही कॉलम के साथ किया जा सकता है। आप निम्न फ़ंक्शन का उपयोग करके, उदाहरण के लिए, एक DataFrame संरेखित कर सकते हैं:

 function merge_df(first::DataFrame, second::DataFrame)::DataFrame if (first == nothing) return second else names_first = names(first) names_second = names(second) sub_names = setdiff(names_first, names_second) second[sub_names] = 0 sub_names = setdiff(names_second, names_first) first[sub_names] = 0 vcat(second, first) end end 

यहाँ नाम फ़ंक्शन स्तंभ नामों की एक सरणी प्राप्त करता है। उदाहरण में सेटडिफ़ (s1, s2) फ़ंक्शन s1 के सभी तत्वों का पता लगाता है जो s2 में नहीं हैं। अगला, इन तत्वों के लिए DataFrame का विस्तार करें। vcat दो DataFrames को glues करता है और परिणाम देता है। इस मामले में वापसी का उपयोग करना आवश्यक नहीं है, क्योंकि अंतिम ऑपरेशन का परिणाम स्पष्ट है।

हम परिणाम की जांच कर सकते हैं:

 julia> df1 = DataFrame(:A => collect(1:2)) 2×1 DataFrame │ Row │ A │ │ │ Int64 │ ├─────┼───────┤ │ 1 │ 1 │ │ 2 │ 2 │ julia> df2 = DataFrame(:B => collect(3:4)) 2×1 DataFrame │ Row │ B │ │ │ Int64 │ ├─────┼───────┤ │ 1 │ 3 │ │ 2 │ 4 │ julia> df3 = merge_df(df1, df2) 4×2 DataFrame │ Row │ B │ A │ │ │ Int64 │ Int64 │ ├─────┼───────┼───────┤ │ 1 │ 3 │ 0 │ │ 2 │ 4 │ 0 │ │ 3 │ 0 │ 1 │ │ 4 │ 0 │ 2 │ 

ध्यान दें कि जूलिया में नामकरण सम्मेलनों के संदर्भ में, यह अंडरस्कोर का उपयोग करने के लिए प्रथागत नहीं है, लेकिन फिर पठनीयता ग्रस्त है। इस कार्यान्वयन में भी काफी अच्छा नहीं है कि मूल DataFrame संशोधित है। लेकिन, फिर भी, यह उदाहरण कई स्तंभों को संरेखित करने की प्रक्रिया को दर्शाने के लिए अच्छा है।

कॉलम में सामान्य मान द्वारा कई डेटाफ़्रेम्स में शामिल होना संभव है जॉइन फ़ंक्शन (उदाहरण के लिए, आम उपयोगकर्ताओं के पहचानकर्ताओं द्वारा विभिन्न स्तंभों के साथ दो तालिकाओं को चमकाते हुए)।

डेटाफ़्रेम कंसोल में देखने के लिए सुविधाजनक है। आउटपुट का कोई भी तरीका: शो मैक्रो का उपयोग करते हुए, प्रिंटलाइन फंक्शन आदि का उपयोग करते हुए, एक तालिका को कंसोल में एक ऐसे रूप में प्रिंट किया जाएगा जो पढ़ने में आसान हो। यदि DataFrame बहुत बड़ा है, तो प्रारंभ और अंत लाइनें प्रदर्शित की जाएंगी। हालांकि, आप क्रमशः सिर और पूंछ कार्यों के साथ सिर और पूंछ को स्पष्ट रूप से अनुरोध कर सकते हैं।

डेटाफ़्रेम के लिए, निर्दिष्ट फ़ंक्शन के लिए डेटा समूहन और एकत्रीकरण फ़ंक्शन उपलब्ध हैं। उनके लौटने पर मतभेद हैं। यह एक DataFrame के साथ एक संग्रह हो सकता है जो समूहीकरण मानदंडों को पूरा करता है, या एक एकल DataFrame जहां कॉलम नाम मूल नाम और एकत्रीकरण फ़ंक्शन के नाम से बनेगा। संक्षेप में, एक विभाजन-लागू-संयोजन योजना लागू की जाती है। विवरण देखें

हम डेटाफ़्रेम पैकेज के भाग के रूप में उपलब्ध एक उदाहरण तालिका के साथ प्रलेखन से एक उदाहरण का उपयोग करेंगे।

 julia> using DataFrames, CSV, Statistics julia> iris = CSV.read(joinpath(dirname(pathof(DataFrames)), "../test/data/iris.csv")); 

Groupby फ़ंक्शन का उपयोग करके समूह बनाना। समूहीकरण कॉलम का नाम निर्दिष्ट करें और GroupedDataFrame प्रकार का एक परिणाम प्राप्त करें, जिसमें समूह स्तंभ के मानों द्वारा एकत्र किए गए अलग-अलग DataFrames का संग्रह होता है।

 julia> species = groupby(iris, :Species) GroupedDataFrame with 3 groups based on key: :Species First Group: 50 rows │ Row │ SepalLength │ SepalWidth │ PetalLength │ PetalWidth │ Species │ │ │ Float64 │ Float64 │ Float64 │ Float64 │ String │ ├─────┼─────────────┼────────────┼─────────────┼────────────┼─────────┤ │ 1 │ 5.1 │ 3.5 │ 1.4 │ 0.2 │ setosa │ │ 2 │ 4.9 │ 3.0 │ 1.4 │ 0.2 │ setosa │ │ 3 │ 4.7 │ 3.2 │ 1.3 │ 0.2 │ setosa │ 

परिणाम पहले उल्लेखित फ़ंक्शन का उपयोग करके एक सरणी में परिवर्तित किया जा सकता है:

 julia> collect(species) 3-element Array{Any,1}: 50×5 SubDataFrame{Array{Int64,1}} │ Row │ SepalLength │ SepalWidth │ PetalLength │ PetalWidth │ Species │ │ │ Float64 │ Float64 │ Float64 │ Float64 │ String │ ├─────┼─────────────┼────────────┼─────────────┼────────────┼─────────┤ │ 1 │ 5.1 │ 3.5 │ 1.4 │ 0.2 │ setosa │ │ 2 │ 4.9 │ 3.0 │ 1.4 │ 0.2 │ setosa │ │ 3 │ 4.7 │ 3.2 │ 1.3 │ 0.2 │ setosa │ … 

फ़ंक्शन के आधार पर समूह। प्राप्त DataFrame के कॉलम नाम और प्रसंस्करण फ़ंक्शन को निर्दिष्ट करें। द्वारा कार्य का पहला चरण ग्रुपबी फ़ंक्शन के समान है - हमें डेटाफ़्रेम संग्रह मिलता है। ऐसे प्रत्येक DataFrame के लिए, पंक्तियों की संख्या की गणना करें और उन्हें कॉलम N में रखें। परिणाम एक एकल DataFrame में चिपका दिया जाएगा और फ़ंक्शन के परिणाम के रूप में वापस आ जाएगा।

 julia> by(iris, :Species, df -> DataFrame(N = size(df, 1))) 3×2 DataFrame │ Row │ Species │ N │ │ │ String⍰ │ Int64 │ ├─────┼────────────┼───────┤ │ 1 │ setosa │ 50 │ │ 2 │ versicolor │ 50 │ │ 3 │ virginica │ 50 │ 

खैर, अंतिम विकल्प कुल कार्य है। हम समूहीकरण के लिए एक कॉलम और शेष कॉलम के लिए एक एकत्रीकरण फ़ंक्शन निर्दिष्ट करते हैं। परिणाम एक DataFrame है जहां स्तंभ नाम स्रोत स्तंभों और एकत्रीकरण फ़ंक्शन के नाम की ओर से बनाए जाएंगे।

 julia> aggregate(iris, :Species, sum) 3×5 DataFrame │Row│Species │SepalLength_sum│SepalWidth_sum│PetalLength_sum│PetalWidth_sum│ │ │ String │ Float64 │ Float64 │ Float64 │ Float64 │ ├───┼──────────┼───────────────┼──────────────┼───────────────┼──────────────┤ │ 1 │setosa │250.3 │ 171.4 │ 73.1 │ 12.3 │ │ 2 │versicolor│296.8 │ 138.5 │ 213.0 │ 66.3 │ │ 3 │virginica │329.4 │ 148.7 │ 277.6 │ 101.3 │ 

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

 julia> colwise(mean, iris[1:4]) 4-element Array{Float64,1}: 5.843333333333335 3.057333333333334 3.7580000000000027 1.199333333333334 

तालिका का सारांश प्राप्त करने के लिए एक बहुत ही सुविधाजनक कार्य का वर्णन किया गया है। उपयोग उदाहरण:

 julia> describe(iris) 5×8 DataFrame │Row│ variable │mean │min │median│ max │nunique│nmissing│ eltype │ │ │ Symbol │Union… │Any │Union…│ Any │Union… │Int64 │DataType│ ├───┼───────────┼───────┼──────┼──────┼─────────┼───────┼────────┼────────┤ │ 1 │SepalLength│5.84333│ 4.3 │ 5.8 │ 7.9 │ │ 0 │ Float64│ │ 2 │SepalWidth │3.05733│ 2.0 │ 3.0 │ 4.4 │ │ 0 │ Float64│ │ 3 │PetalLength│3.758 │ 1.0 │ 4.35 │ 6.9 │ │ 0 │ Float64│ │ 4 │PetalWidth │1.19933│ 0.1 │ 1.3 │ 2.5 │ │ 0 │ Float64│ │ 5 │Species │ │setosa│ │virginica│ 3 │ 0 │ String │ 

DataFrames सुविधाओं की पूरी सूची ।

मैट्रिक्स मामले के साथ, आप DataFrame में सांख्यिकी मॉड्यूल में उपलब्ध सभी सांख्यिकीय कार्यों का उपयोग कर सकते हैं। Https://docs.julialang.org/en/v1/stdlib/Statistics/index.html देखें

StatPlots.jl लाइब्रेरी का उपयोग डेटाफ़्रेम को रेखांकन करने के लिए किया जाता है। और देखें https://github.com/JuliaPlots/StatPlots.jl
यह लाइब्रेरी विज़ुअलाइज़ेशन को आसान बनाने के लिए मैक्रो का एक सेट लागू करती है।

 julia> df = DataFrame(a = 1:10, b = 10 .* rand(10), c = 10 .* rand(10)) 10×3 DataFrame │ Row │ a │ b │ c │ │ │ Int64 │ Float64 │ Float64 │ ├─────┼───────┼─────────┼─────────┤ │ 1 │ 1 │ 0.73614 │ 7.11238 │ │ 2 │ 2 │ 5.5223 │ 1.42414 │ │ 3 │ 3 │ 3.5004 │ 2.11633 │ │ 4 │ 4 │ 1.34176 │ 7.54208 │ │ 5 │ 5 │ 8.52392 │ 2.98558 │ │ 6 │ 6 │ 4.47477 │ 6.36836 │ │ 7 │ 7 │ 8.48093 │ 6.59236 │ │ 8 │ 8 │ 5.3761 │ 2.5127 │ │ 9 │ 9 │ 3.55393 │ 9.2782 │ │ 10 │ 10 │ 3.50925 │ 7.07576 │ julia> @df df plot(:a, [:b :c], colour = [:red :blue]) 

अंतिम पंक्ति में, @df मैक्रो है, df डेटाफ्रेम के साथ वैरिएबल का नाम है।

Query.jl एक बहुत ही उपयोगी पुस्तकालय हो सकता है। मैक्रोज़ और प्रोसेसिंग चैनल के तंत्र का उपयोग करते हुए, Query.jl एक विशेष क्वेरी भाषा प्रदान करता है। एक उदाहरण 50 से अधिक लोगों की सूची प्राप्त करना है और उनके पास बच्चों की संख्या है:

 julia> using Query, DataFrames julia> df = DataFrame(name=["John", "Sally", "Kirk"], age=[23., 42., 59.], children=[3,5,2]) 3×3 DataFrame │ Row │ name │ age │ children │ │ │ String │ Float64 │ Int64 │ ├─────┼────────┼─────────┼──────────┤ │ 1 │ John │ 23.0 │ 3 │ │ 2 │ Sally │ 42.0 │ 5 │ │ 3 │ Kirk │ 59.0 │ 2 │ julia> x = @from i in df begin @where i.age>50 @select {i.name, i.children} @collect DataFrame end 1×2 DataFrame │ Row │ name │ children │ │ │ String │ Int64 │ ├─────┼────────┼──────────┤ │ 1 │ Kirk │ 2 │ 

या एक चैनल के साथ एक फार्म:

 julia> using Query, DataFrames julia> df = DataFrame(name=["John", "Sally", "Kirk"], age=[23., 42., 59.], children=[3,5,2]); julia> x = df |> @query(i, begin @where i.age>50 @select {i.name, i.children} end) |> DataFrame 1×2 DataFrame │ Row │ name │ children │ │ │ String │ Int64 │ ├─────┼────────┼──────────┤ │ 1 │ Kirk │ 2 │ 

अधिक विवरण देखें

ऊपर दिए गए दोनों उदाहरण कार्यात्मक रूप से dplyr या LINQ के समान क्वेरी भाषाओं के उपयोग को प्रदर्शित करते हैं। इसके अलावा, ये भाषाएँ Query.jl तक सीमित नहीं हैं। डेटाफ्रैम के साथ इन भाषाओं का उपयोग करने के बारे में और जानें ।

अंतिम उदाहरण | संचालक का उपयोग करता है। और देखें

यह ऑपरेटर उस फ़ंक्शन में तर्क को प्रतिस्थापित करता है जिसे इसके दाईं ओर इंगित किया गया है। दूसरे शब्दों में:

 julia> [1:5;] |> x->x.^2 |> sum |> inv 0.01818181818181818 

के बराबर:

 julia> inv(sum( [1:5;] .^ 2 )) 0.01818181818181818 

और आखिरी चीज जो मैं नोट करना चाहूंगा, वह पहले से उल्लेखित CSV.jl लाइब्रेरी का उपयोग करके एक विभाजक के साथ आउटपुट स्वरूप में डेटाफ्रेम लिखने की क्षमता है

 julia> df = DataFrame(name=["John", "Sally", "Kirk"], age=[23., 42., 59.], children=[3,5,2]) 3×3 DataFrame │ Row │ name │ age │ children │ │ │ String │ Float64 │ Int64 │ ├─────┼────────┼─────────┼──────────┤ │ 1 │ John │ 23.0 │ 3 │ │ 2 │ Sally │ 42.0 │ 5 │ │ 3 │ Kirk │ 59.0 │ 2 │ julia> CSV.write("out.csv", df) "out.csv" 

हम रिकॉर्ड किए गए परिणाम की जांच कर सकते हैं:

 > cat out.csv name,age,children John,23.0,3 Sally,42.0,5 Kirk,59.0,2 

निष्कर्ष

उदाहरण के लिए, जूलिया आर के रूप में आम प्रोग्रामिंग भाषा बन जाएगी या नहीं यह अनुमान लगाना कठिन है, लेकिन इस साल यह पहले से ही सबसे तेजी से बढ़ती प्रोग्रामिंग भाषा बन गई है। अगर पिछले साल इसके बारे में केवल कुछ ही जानते थे, तो इस साल, संस्करण 1.0 के जारी होने और पुस्तकालय कार्यों के स्थिरीकरण के बाद, उन्होंने इसके बारे में लिखना शुरू कर दिया, लगभग निश्चित रूप से अगले साल यह एक ऐसी भाषा बन जाएगी, जो डेटा साइंस के क्षेत्र में नहीं जानने के लिए अभद्र होगी। और जिन कंपनियों ने डेटा का विश्लेषण करने के लिए जूलिया का उपयोग करना शुरू नहीं किया था, वे अधिक चुस्त वंशजों द्वारा प्रतिस्थापित किए जाने वाले डायनासोर होंगे।

जूलिया एक युवा प्रोग्रामिंग भाषा है। दरअसल, पायलट प्रोजेक्ट्स के सामने आने के बाद, यह स्पष्ट हो जाएगा कि जूलिया का बुनियादी ढांचा वास्तविक औद्योगिक उपयोग के लिए कितना तैयार है। जूलिया डेवलपर्स बहुत महत्वाकांक्षी हैं और अब तैयार हैं। किसी भी मामले में, जूलिया की सरल लेकिन सख्त वाक्य रचना इसे अभी सीखने के लिए एक बहुत ही आकर्षक प्रोग्रामिंग भाषा बनाती है। उच्च प्रदर्शन आपको एल्गोरिदम को लागू करने की अनुमति देता है जो न केवल शैक्षिक उद्देश्यों के लिए, बल्कि डेटा विश्लेषण में वास्तविक उपयोग के लिए भी उपयुक्त हैं। हम अब विभिन्न परियोजनाओं में जूलिया को लगातार आजमाना शुरू करेंगे।