جوليا. العمل مع الجداول

جوليا هي واحدة من أحدث لغات البرمجة الرياضية ، تدعي أنها لغة البرمجة الرئيسية في هذا المجال. لسوء الحظ ، لا يوجد في الوقت الحالي ما يكفي من الأدب باللغة الروسية ، وتحتوي المواد المتاحة باللغة الإنجليزية على معلومات لا تتوافق دائمًا مع الإصدار الحالي ، بسبب التطور الديناميكي لجوليا ، ولكن هذا ليس واضحًا لمبرمجي جوليا المبتدئين. سنحاول سد الثغرات ونقل أفكار جوليا للقراء في شكل أمثلة بسيطة.

الغرض من هذه المقالة هو إعطاء القراء فكرة عن الطرق الأساسية للعمل مع الجداول في لغة برمجة جوليا لتشجيعهم على البدء في استخدام لغة البرمجة هذه لمعالجة البيانات الحقيقية. نفترض أن القارئ على دراية بلغات البرمجة الأخرى ، لذلك لن نعطي سوى الحد الأدنى من المعلومات حول كيفية القيام بذلك ، لكننا لن ندخل في تفاصيل طرق معالجة البيانات.

بالطبع ، واحدة من أهم المراحل في عمل برنامج يقوم بتحليل البيانات هي استيرادها وتصديرها. علاوة على ذلك ، فإن تنسيق عرض البيانات الأكثر شيوعًا هو جدول. هناك مكتبات لجوليا توفر الوصول إلى DBMS العلائقية ، وتستخدم تنسيقات التبادل مثل HDF5 ، MATLAB ، JLD. ولكن في هذه الحالة ، سنكون مهتمين فقط بتنسيق النص لتمثيل الجداول ، مثل CSV.

قبل النظر في الجداول ، تحتاج إلى تقديم مقدمة صغيرة لعرض هيكل البيانات هذا. بالنسبة إلى جوليا ، يمكن تمثيل الجدول كمصفوفة ثنائية الأبعاد أو كإطار DataFrame.

المصفوفات

لنبدأ بالصفائف في جوليا. يبدأ ترقيم العناصر برقم واحد. هذا أمر طبيعي تمامًا للرياضيين ، بالإضافة إلى ذلك ، يتم استخدام نفس المخطط في فورتران ، باسكال ، ماتلاب. بالنسبة للمبرمجين الذين لم يستخدموا هذه اللغات مطلقًا ، قد يبدو هذا الترقيم غير مريح ويسبب أخطاء عند كتابة شروط الحدود ، ولكن في الواقع ، هذه مجرد مسألة اعتيادية. بعد أسبوعين من استخدام جوليا ، لم يعد يُطرح سؤال التبديل بين النماذج اللغوية.

النقطة الثانية المهمة في هذه اللغة هي التمثيل الداخلي للمصفوفات. بالنسبة إلى جوليا ، فإن الصفيف الخطي هو عمود. في نفس الوقت ، بالنسبة للغات مثل C ، Java ، فإن الصفيف أحادي البعد هو سلسلة.

نوضح ذلك بمصفوفة تم إنشاؤها في سطر الأوامر (REPL)

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

انتبه إلى نوع الصفيف - Array {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 

أي ، حصلنا على مصفوفة من صف واحد وثلاثة أعمدة.

هذا العرض للصفوف والأعمدة هو أيضًا سمة مميزة لـ Fortran و Matlab ، ولكن يجب أن نتذكر فقط أن جوليا هي لغة موجهة بشكل خاص إلى مجال تطبيقها.

مصفوفة جوليا عبارة عن صفيف ثنائي الأبعاد ، حيث تكون جميع الخلايا من نفس النوع. دعنا ننتبه إلى حقيقة أن النوع يمكن أن يكون مجرّدًا أي أو محددًا تمامًا ، مثل Int64 أو Float64 أو حتى String.

يمكننا إنشاء مصفوفة في شكل حرفي:

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

إنشاء باستخدام المنشئ وتخصيص الذاكرة دون التهيئة (undef):

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

أو مع التهيئة إذا تم تحديد أي قيمة محددة بدلاً من undef.

الغراء من أعمدة منفصلة:

 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 × 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 في المثال عبارة عن تشغيل متعدد للدالة لحساب متوسط ​​الوقت الذي يستغرقه التنفيذ. يتم توفير هذا الماكرو من قبل مكتبة BenchmarkTools.jl. تحتوي مجموعة جوليا الأساسية على ماكرو زمني ، لكنها تقيس فاصل زمني واحد ، في هذه الحالة ، سيكون غير دقيق. يعرض الماكرو show التعبير وقيمته المحسوبة في وحدة التحكم.

يعد تحسين تخزين العمود مناسبًا لإجراء العمليات الإحصائية باستخدام جدول. نظرًا لأنه تقليديًا ، يكون الجدول محدودًا بعدد الأعمدة ، ويمكن أن يكون عدد الصفوف أيًا ، يتم تنفيذ معظم العمليات ، مثل حساب المتوسط ​​، والحد الأدنى ، والقيم القصوى ، على وجه التحديد لأعمدة المصفوفات ، وليس لصفوفها.

مرادف لصفيف ثنائي الأبعاد هو نوع المصفوفة. ومع ذلك ، هذا هو أسلوب الراحة بدلاً من الضرورة.

يتم الوصول إلى عناصر المصفوفة عن طريق الفهرس. على سبيل المثال ، لمصفوفة تم إنشاؤها مسبقًا

 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 

هناك أيضًا وظيفة selectdim مفيدة ، حيث يمكنك تحديد العدد الترتيبي للبعد الذي تريد تحديده ، بالإضافة إلى مؤشرات عناصر هذا البعد. على سبيل المثال ، قم بعمل عينات في البعد الثاني (الأعمدة) عن طريق تحديد الفهرس الأول والثالث. يعد هذا النهج مناسبًا عندما تحتاج ، وفقًا للظروف ، إلى التبديل بين الصفوف والأعمدة. ومع ذلك ، هذا صحيح بالنسبة للحالة متعددة الأبعاد ، عندما يكون عدد الأبعاد أكثر من 2.

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

وظائف للمعالجة الإحصائية للمصفوفات
المزيد عن المصفوفات أحادية البعد
صفائف متعددة الأبعاد
وظائف الجبر الخطي والمصفوفات ذات الشكل الخاص

يمكن قراءة جدول من ملف باستخدام وظيفة readdlm التي تم تنفيذها في مكتبة DelimitedFiles. التسجيل - باستخدام writedlm. توفر هذه الوظائف العمل مع الملفات ذات المحددات ، والحالة الخاصة هي تنسيق CSV.

نوضح بمثال من الوثائق:

 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 

من وجهة نظر كفاءة المعالجة ، يفضل هذا الخيار ، حيث سيتم تقديم البيانات بشكل مضغوط. في الوقت نفسه ، يعد تقييدًا واضحًا للجداول التي تمثلها المصفوفة شرطًا لتوحيد البيانات.

نوصي بالاطلاع على ميزات readdlm الكاملة في الوثائق. من بين الخيارات الإضافية هناك القدرة على تحديد وضع المعالجة للرؤوس ، وخطوط التخطي ، ووظيفة خلايا المعالجة ، وما إلى ذلك.

تعد مكتبة CSV.jl طريقة بديلة لقراءة الجداول. مقارنةً بقراءة readdlm و writedlm ، توفر هذه المكتبة المزيد من التحكم بشكل كبير في خيارات الكتابة والقراءة ، بالإضافة إلى فحص البيانات في الملفات المحددة. ومع ذلك ، فإن الفرق الأساسي هو أنه يمكن تجسيد نتيجة CSV.File في نوع DataFrame.

Dataframes

توفر مكتبة DataFrames دعمًا لهيكل بيانات DataFrame ، والذي يركز على عرض الجداول. الفرق الأساسي من المصفوفة هنا هو أن كل عمود يتم تخزينه بشكل فردي ، وكل عمود له اسمه الخاص. نذكر أنه بالنسبة لجوليا ، يعد وضع التخزين حسب العمود بشكل عام أمرًا طبيعيًا. وعلى الرغم من أن لدينا هنا حالة خاصة من المصفوفات أحادية البعد ، يتم الحصول على حل أمثل من حيث السرعة والمرونة لتمثيل البيانات ، حيث يمكن أن يكون نوع كل عمود فرديًا.

دعونا نرى كيفية إنشاء 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 │ 

تقوم وظيفة التحويل بتحويل البيانات إلى النوع المحدد. وفقًا لذلك ، بالنسبة لنوع DataFrame ، يتم تعريف طرق وظيفة التحويل في مكتبة DataFrames (وفقًا لمصطلحات جوليا ، هناك وظائف ، ويطلق على مجموعة متنوعة من تطبيقاتها مع وسائط مختلفة طرق). وتجدر الإشارة إلى أن أعمدة المصفوفة يتم تعيينها تلقائيًا للأسماء 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 │ 

وكذلك في حالة المصفوفات البسيطة ، يمكننا لصق مثيلات DataFrame باستخدام وظائف vcat ، hcat. ومع ذلك ، لا يمكن استخدام vcat إلا مع نفس الأعمدة في كلا الجدولين. يمكنك محاذاة 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 

تحصل وظيفة الأسماء هنا على مجموعة من أسماء الأعمدة. تكشف الدالة setdiff (s1، s2) في المثال جميع عناصر s1 التي ليست في s2. بعد ذلك ، قم بتوسيع DataFrame لهذه العناصر. vcat لصق إطارين DataFrames وإرجاع النتيجة. استخدام العودة في هذه الحالة ليس ضروريًا ، لأن نتيجة العملية الأخيرة واضحة.

يمكننا التحقق من النتيجة:

 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 مناسب للعرض في وحدة التحكم. أي طريقة للإخراج: استخدام الماكرو show ، باستخدام وظيفة println ، وما إلى ذلك ، سيؤدي إلى طباعة جدول إلى وحدة التحكم في نموذج يسهل قراءته. إذا كان DataFrame كبيرًا جدًا ، فسيتم عرض سطري البداية والنهاية. ومع ذلك ، يمكنك أن تطلب صراحة الرأس والذيل مع وظائف الرأس والذيل ، على التوالي.

بالنسبة لـ DataFrame ، تتوفر وظائف تجميع البيانات وتجميعها للدالة المحددة. هناك اختلافات في ما يعودون. يمكن أن تكون هذه مجموعة مع DataFrame يفي بمعايير التجميع ، أو DataFrame واحد حيث سيتم تشكيل أسماء الأعمدة من الاسم الأصلي واسم وظيفة التجميع. في الجوهر ، يتم تنفيذ مخطط تقسيم التقسيم. انظر التفاصيل

سنستخدم مثال من الوثائق مع جدول مثال متاح كجزء من حزمة DataFrames.

 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 المستلم. المرحلة الأولى من العمل تشبه وظيفة groupby - نحصل على مجموعة 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 │ 

تطبق الدالة colwise الوظيفة المحددة على جميع أعمدة DataFrame المحددة أو فقط.

 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 .

كما هو الحال مع حالة Matrix ، يمكنك استخدام جميع الوظائف الإحصائية المتاحة في وحدة الإحصائيات في DataFrame. انظر https://docs.julialang.org/en/v1/stdlib/Statistics/index.html

يتم استخدام مكتبة StatPlots.jl لعرض DataFrame بشكل رسومي. شاهد المزيد 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 هو اسم المتغير مع DataFrame.

يمكن أن يكون 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. تعرف على المزيد حول استخدام هذه اللغات مع DataFrames هنا .

يستخدم المثال الأخير عامل | |. شاهد المزيد .

يستبدل هذا العامل الحجة في الدالة المشار إليها على يمينها. بعبارة أخرى:

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

تعادل:

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

وآخر شيء أود أن أشير إليه هو القدرة على كتابة DataFrame إلى تنسيق الإخراج باستخدام فاصل باستخدام مكتبة 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 

الخلاصة

من الصعب التنبؤ بما إذا كانت جوليا ستصبح لغة برمجة شائعة مثل R ، على سبيل المثال ، ولكن هذا العام أصبحت بالفعل لغة البرمجة الأسرع نموًا. إذا كان القليل منهم فقط يعرفون عنها في العام الماضي ، هذا العام ، بعد إصدار الإصدار 1.0 وتثبيت وظائف المكتبة ، فقد بدأوا في الكتابة عنها ، ومن المؤكد تقريبًا في العام المقبل أنها ستصبح لغة سيكون من غير اللائق عدم معرفتها في مجال علوم البيانات. والشركات التي لم تبدأ في استخدام جوليا لتحليل البيانات ستكون ديناصورات صريحة سيتم استبدالها بأحفاد أكثر مرونة.

جوليا هي لغة برمجة شابة. في الواقع ، بعد ظهور المشاريع التجريبية ، سيكون من الواضح مدى جاهزية البنية التحتية لجوليا للاستخدام الصناعي الحقيقي. مطورو جوليا طموحون للغاية وجاهزون الآن. على أي حال ، فإن بنية جوليا البسيطة ولكن الصارمة تجعلها لغة برمجة جذابة للغاية للتعلم في الوقت الحالي. يسمح لك الأداء العالي بتنفيذ خوارزميات مناسبة ليس فقط للأغراض التعليمية ، ولكن أيضًا للاستخدام الحقيقي في تحليل البيانات. سنبدأ في محاولة جوليا باستمرار في مشاريع مختلفة الآن.