शुरुआती लोगों के लिए Julia प्रोग्रामिंग ट्यूटोरियल

Julia को कैसे इंस्टॉल और रन करें? 

Julia इंस्टॉल करना सीधा-सा है। Julia वेबसाइट के इस पेज पर अपने ऑपरेटिंग सिस्टम के अनुरूप इंस्टॉलर डाउनलोड करें और Julia को सिस्टम PATH में जोड़ने वाले बॉक्स को चेक करें। यदि आप कमांड लाइन में julia टाइप करते हैं और नीचे जैसा आउटपुट मिलता है, तो सब कुछ सही चल रहा है।

Julia प्रोग्रामिंग भाषा को इंस्टॉल और रन करना

PyCharm और VSCode दोनों Julia प्लगइन्स प्रदान करते हैं जो कोड हाइलाइटिंग और डिबगिंग का समर्थन करते हैं। हालाँकि, चूँकि डेटा वैज्ञानिक आमतौर पर JupyterLab के भीतर काम करना पसंद करते हैं, JupyterLab में Julia कर्नेल जोड़ना भी आसान है। टर्मिनल में julia प्रॉम्प्ट में पहुँचने के बाद, बस ये दो लाइनें दर्ज करें:

using Pkg
add("IJulia")

यह कोड सिस्टम पर Julia इंस्टॉलेशन में IJulia पैकेज जोड़ता है। किसी भी चल रहे JupyterLab सत्र को रीस्टार्ट करें, और आपको Launcher में Julia विकल्प दिखाई देना चाहिए।

JupyterLab में Julia चल रहा है

Julia का बुनियादी सिंटैक्स

इस खंड में हम Julia सिंटैक्स की बुनियादी बातों को कवर करेंगे, जिनमें वेरिएबल्स, डेटा टाइप्स, ऑपरेटर, वेक्टर इत्यादि शामिल हैं।

ऑपरेटर  

प्रोग्रामिंग में, कुछ विशेष कैरेक्टर्स होते हैं जिन्हें ऑपरेटर कहा जाता है, जो विशिष्ट गणितीय या तार्किक प्रक्रियाओं का प्रतिनिधित्व करते हैं। नीचे आप सबसे सामान्य ऑपरेटर देखेंगे, जिनमें जोड़, घटाव, गुणा, भाग इत्यादि शामिल हैं। 

टिप्पणी: Julia में, कमेंट्स एकल # कैरेक्टर से लिखे जाते हैं। # के बाद लिखा गया कुछ भी (लाइन के अंत तक) प्रोग्राम द्वारा नज़रअंदाज़ कर दिया जाता है।

# Addition in Julia
37 + 73

110

# Subtraction in Julia
17 - 19

-2

# Multiplication in Julia
29 * 33

957

# Division in Julia
22 / 7

3.142857142857143

# Backwards division in Julia, the above is equal to 0 / 5.
5 \ 0

0

# The remainder operator in Julia 
98456 % 23

16

# Raising to the power 2 (squaring)
(22 / 7) ^ 2

9.877551020408163

# Raising to the power 3 (cubing)
-7 ^ 3

-343

# Raising to the power 0.5 (square-rooting)
(355 / 133) ^ 0.5

1.633760365638372

वेरिएबल्स

प्रोग्रामिंग में, हम जानकारी को स्टोर करने के लिए वेरिएबल्स का उपयोग करते हैं। वेरिएबल्स किसी जानकारी को एक नाम के जरिए संदर्भित करना आसान बनाते हैं। उदाहरण के लिए, यहाँ हम संख्या 73 को a नामक वेरिएबल में स्टोर कर रहे हैं, और स्ट्रिंग “Hello world!” को “word” वेरिएबल में (हम अगले खंड में Julia के अलग-अलग डेटा टाइप्स पर नज़र डालेंगे)। कमांड लाइन पर वेरिएबल का नाम टाइप करने से उसका मान प्रिंट हो जाता है।

# Storing the number 73 in a variable a
a = 73
a

73

# Storing "Hello world!" in word
word = "Hello world!"
word

Hello world!

सभी Julia ऑपरेटर और फ़ंक्शंस वेरिएबल्स पर भी उसी तरह काम करते हैं।

# Multiplying two numeric variables
a = 73
b = 37
a * b

2701

वेरिएबल नामों में आप किसी भी अल्फ़ान्यूमेरिक कैरेक्टर का उपयोग कर सकते हैं, जिनमें अंडरस्कोर भी शामिल है। हालाँकि, Julia में उनके नामकरण के कुछ प्रचलित मानक हैं। वेरिएबल नाम:

• lower_snake_case में होते हैं (लोअरकेस और शब्द अंडरस्कोर से अलग किए हुए)
• किसी संख्या से शुरू नहीं हो सकते।

Julia में डेटा टाइप्स का परिचय 

डेटा टाइप्स प्रोग्राम को बताते हैं कि कोई वेरिएबल किन मानों को लेता है और उन पर कौन-से गणितीय या तार्किक ऑपरेटर बिना त्रुटि के लागू किए जा सकते हैं। Julia में कई प्रकार के डेटा टाइप्स हैं, नीचे आप सबसे बुनियादी वाले देख सकते हैं।

किसी वेरिएबल का डेटा टाइप typeof() फ़ंक्शन का उपयोग करके प्रिंट किया जा सकता है:

# Getting the type of 3.14
typeof(3.14)

Float64

Julia में ऑपरेशंस करते समय, आपको अलग-अलग डेटा टाइप्स के प्रभावों के प्रति सचेत रहना चाहिए। उदाहरण के लिए, किसी फ्लोट और इंटीजर को गुणा करने पर फ्लोट रिटर्न होता है।

# Bank balance as an integer
balance = 100

# Interest rate as a float
interest_rate = 1.05

# Interest rate as a float
new_balance = balance * interest_rate

typeof(new_balance)

Float64

इसके उलट, स्ट्रिंग्स और न्यूमेरिक डेटा टाइप्स पर ऑपरेशंस करना अक्सर त्रुटि देता है। जैसे कि नीचे दिया गया उदाहरण।

# Bank balance as an integer
balance = 100

# Interest rate as a string
interest_rate = “5%”

# Interest rate as a float
new_balance = balance * interest_rate

ERROR: MethodError:
no method matching *(::Int64, ::String)

Julia में डेटा टाइप्स का रूपांतरण 

Julia में अलग-अलग डेटा टाइप्स को अन्य डेटा टाइप्स में रूपांतरित करना इनबिल्ट फ़ंक्शंस से संभव है। नीचे Julia में डेटा टाइप्स को रूपांतरित करने के तरीकों की सारणी दी गई है। 

Julia में कैरेक्टर्स और स्ट्रिंग्स के साथ काम करना 

हमने पिछले खंड में Julia में कैरेक्टर और स्ट्रिंग डेटा टाइप्स देखे थे, इस खंड में हम सामान्य कैरेक्टर और स्ट्रिंग ऑपरेशंस में गहराई से जाएँगे। याद दिला दें, स्ट्रिंग डबल कोट्स के अंदर कैरेक्टर्स की क्रमबद्ध शृंखला या सादा टेक्स्ट होती है। 

# A string is a series of characters
word = "Hello world!"
word

"Hello world!"

मल्टीलाइन स्ट्रिंग लिखने के लिए, आप ट्रिपल कोट्स का उपयोग कर सकते हैं:

multi_line = """
   This is a
   multi-line string.
"""
print(multi_line)

This is a
multi-line string.

आप अलग-अलग तरीकों से स्ट्रिंग्स से जानकारी और विशेषताएँ निकाल सकते हैं। उदाहरण के लिए, ब्रैकेट इंडेक्सिंग के जरिए आप उनकी पोजीशन के आधार पर अलग-अलग कैरेक्टर या कैरेक्टर्स की रेंज निकाल सकते हैं। इस उदाहरण में, 1:3 1 से 3 तक के समावेशी क्रम को दर्शाता है।

text = "Julia is a high-level, dynamic programming language"
# Extracting the first character in text based on its index
text[1]

'J': ASCII/Unicode U+004A (category Lu: Letter, uppercase)

# Extracting the first three characters in text based on its index
text[1:3]

"Jul"

ऊपर हमने ब्रैकेट के अंदर 1 रखा, और यह पहला कैरेक्टर लौटाता है। वैकल्पिक रूप से, आप विशेष begin ऑपरेटर भी उपयोग कर सकते हैं:

# Extracting the first character in text with the begin operator
text[begin]

'J': ASCII/Unicode U+004A (category Lu: Letter, uppercase)

जब आप किसी स्ट्रिंग से एकल कैरेक्टर निकालते हैं, तो उसका डेटा टाइप Char होता है।

# Extract the type of the fourth character
typeof(text[4])

Char

# Extract the type of the fourth character
typeof(text[4])

हालाँकि, जब आप स्ट्रिंग को स्लाइस करते हैं और एक से अधिक कैरेक्टर्स निकालते हैं, तो आउटपुट भी स्ट्रिंग ही होता है। 

# Extract the type of the first 5 characters
typeof(text[begin:5])

String

ऊपर, हम टेक्स्ट के पहले पाँच कैरेक्टर्स को स्लाइस कर रहे हैं। ध्यान रखें कि कॉलन के दोनों ओर के इंडेक्स समावेशी होते हैं। Python के विपरीत, नेगेटिव इंडेक्स समर्थित नहीं हैं। इसके बजाय, आप end ऑपरेटर को नेगेटिव संख्या के साथ उपयोग करेंगे। उदाहरण के लिए, स्ट्रिंग के अंत से तीसरा कैरेक्टर पाने के लिए आप नीचे लिख सकते हैं। 

# Third from the end of the string
text[end-2]

'a': ASCII/Unicode U+0067 (category Ll: Letter, lowercase)

Julia में सामान्य स्ट्रिंग ऑपरेशंस 

आप length() फ़ंक्शन का उपयोग करके किसी स्ट्रिंग में कैरेक्टर्स की संख्या गिन सकते हैं।

# Count the number of characters in a string
length(text)

51

एक सामान्य कार्य दो या अधिक स्ट्रिंग्स को आपस में जोड़ना है। आप यह string() फ़ंक्शन से कर सकते हैं, जिसमें स्ट्रिंग्स को कॉमा से अलग करके पास किया जाता है।

# Creating one string from "Julia", "is", "awesome"
string("Julia ", "is ", "awesome!")

"Julia is awesome!"

आप स्ट्रिंग्स को जोड़ने के लिए * (मल्टिप्लीकेशन) ऑपरेटर का भी उपयोग कर सकते हैं

# Creating one string by multiplying strings
"73 " * "is " * "the " * "best " * "prime."

"73 is the best prime."

दोनों तरीकों में, शब्दों के बीच स्पेस छोड़ना याद रखें। स्ट्रिंग्स को जोड़ने का एक और तरीका है किसी स्ट्रिंग को कई बार दोहराना। यहाँ यह ^ (एक्सपोनेंशिएशन) ऑपरेटर से किया गया है:

# Creating one string with the exponentiation operator
"Three times the fun!" ^ 3

"Three times the fun! Three times the fun! Three times the fun!"

Julia में एरेज़ 

Julia और अन्य भाषाओं में एक अन्य सामान्य डेटा टाइप एरेज़ है, जैसा कि Julia में इन्हें कहा जाता है। एरेज़ ब्रैकेट्स [] के बीच स्टोर किए गए मानों की सूचियाँ हैं। एरेज़ को उनके डायमेंशंस के आधार पर अलग-अलग नाम दिए जाते हैं। 

• एक-आयामी एरेज़ को वेक्टर कहा जाता है।
• दो-आयामी एरेज़ को मैट्रिक्स कहा जाता है।
• तीन-आयामी और उससे अधिक के एरेज़ को बस एरेज़ कहा जाता है।

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

# Define a three-integer vector
x = [1, 2, 3]

3-element Vector{Int64}:
1
2
3

# Get the type of x
typeof(x)

Vector{Int64} (alias for Array{Int64, 1})

वेक्टर x का टाइप Vector है, जो एक-आयामी एरे का उपनाम है (जैसा कि आउटपुट alias for Array{In664, 1} में सूचीबद्ध है)। इसके सभी तत्वों का डेटा टाइप Int64 है। लेकिन इसका मतलब यह नहीं कि सभी तत्व समान टाइप के होने ही चाहिए। उदाहरण के लिए, यहाँ अलग-अलग टाइप्स वाले तत्वों का एक वेक्टर है। 

# Define a vector with various data types
array = [1, "Hello", 22/7]

3-element Vector{Any}:
1
"Hello"
3.142857142857143

जैसा कि आप देख सकते हैं, वेक्टर तत्वों का डेटा टाइप कर्ली ब्रैकेट्स के अंदर Any है, जो कई डेटा टाइप्स का प्रतिनिधित्व करता है। आप वेक्टर के अंदर वेक्टर भी पास कर सकते हैं।

# Define a vector with various data types, including another vector
array = [1, 2, 3, ["Hello", 73]]

4-element Array{Any,1}:
1
2
3
Any["Hello", 73]

length() फ़ंक्शन वेक्टर पर भी स्ट्रिंग्स की तरह ही काम करता है, क्योंकि यह एरे के अंदर तत्वों की संख्या गिनता है।

# Get the length of a vector
length(array)

3

इंडेक्सिंग नियम भी समान रूप से काम करते हैं — यहाँ, हम एरे में पहले और दूसरे तत्व को इंडेक्स कर रहे हैं।

# Get the first element of a vector
array = [1, "Hello", 22/7]
array[begin]

1

# Get the last element of a vector
array[end-1]

"Hello"

बूलियन ऑपरेटर और संख्यात्मक तुलना 

प्रोग्रामिंग भाषाएँ लॉजिक लागू करने के लिए बूलियन मानों का उपयोग करती हैं। किसी बूलियन में केवल दो मान हो सकते हैं: true या false। बूलियन मान विशेष रूप से संख्यात्मक तुलना और बूलियन ऑपरेटर के साथ काम करते समय उपयोगी होते हैं। पहले संख्यात्मक तुलना पर नज़र डालते हैं।

Julia में संख्यात्मक तुलना ऑपरेटर

नीचे दी गई तालिका में आपको Julia में सबसे अधिक प्रयुक्त संख्यात्मक तुलना ऑपरेटर मिलेंगे। जैसा कि आप उदाहरणों में देखेंगे, आप बूलियन, न्यूमेरिक ऑब्जेक्ट्स, और अधिक की तुलना संख्यात्मक तुलना ऑपरेटरों से कर सकते हैं। ध्यान दें कि आप कम/अधिक या बराबर के लिए एक या दो चिन्हों का उपयोग कर सकते हैं। एक-चिन्ह वाले संस्करण के लिए, \le टाइप करें फिर TAB या \ge टाइप करें फिर TAB।

Julia में बूलियन ऑपरेटर

संख्यात्मक तुलना ऑपरेटरों के अतिरिक्त, बूलियन ऑपरेटर होते हैं — जैसे and/or। इन्हें दो या अधिक बूलियन अभिव्यक्तियों को एक में संयोजित करने के लिए उपयोग किया जा सकता है। नीचे आपको सबसे सामान्य बूलियन ऑपरेटर और उनका उपयोग मिलेगा। 

मध्यम स्तर का Julia सिंटैक्स

Julia में सशर्त कथन

बूलियन मानों और ऑपरेटरों का उपयोग करके, आप सशर्त कथन लिख सकते हैं। उदाहरण के लिए, यदि कुछ true निकले — कोई ऑपरेशन करें। यदि false निकले, तो कोई अन्य करें। सशर्त कथनों को if/else स्टेटमेंट भी कहा जाता है। इन्हें इस तरह लिखा जाता है:

if true
   print("Do something")
else
   print("Do something else")
end

जब भी if कीवर्ड के बाद दी गई शर्त true का मान देती है, if ब्लॉक निष्पादित होता है, अन्यथा else ब्लॉक निष्पादित होता है। यह उदाहरण दिखाता है कि किसी संख्या के सम या विषम होने की जाँच करने वाला एक सशर्त कैसे लिखा जाता है।

number = 5

if number % 2 == 0
   print("The number is even")
else
   print("The number is odd")
end

The number is odd

if के बाद की अभिव्यक्ति में, हम माड्यूलस ऑपरेटर % का उपयोग कर रहे हैं यह जाँचने के लिए कि संख्या को 2 से भाग देने पर शेष 0 आता है या नहीं। यह false निकलती है क्योंकि 5 को 2 से भाग देने पर शेष 1 आता है। इसलिए, else क्लॉज निष्पादित होता है। अब, आइए बूलियन ऑपरेटर और सशर्त कथनों के अपने ज्ञान का उपयोग करके एक प्रोग्राम लिखते हैं जो यह जाँचता है कि कोई संख्या धनात्मक, ऋणात्मक या शून्य है। 

number = 0

if number > 0
   print("The number is positive.")
elseif number == 0
   print("The number is equal to zero.")
else
   print("The number is negative.")

end

The number is equal to zero.

हम elseif क्लॉज का उपयोग करके नई शर्त जोड़ रहे हैं। जब हमें सटीक क्रम में दो या अधिक शर्तों की जाँच करनी होती है तो हम elseif क्लॉज का उपयोग करते हैं। 

For लूप्स 

प्रोग्रामिंग में for लूप का उपयोग किसी अनुक्रम (स्ट्रिंग, वेक्टर, ट्यूपल, सेट, आदि) के प्रत्येक तत्व पर क्रम से इटरेट करने और ऑपरेशंस करने के लिए किया जाता है। Julia में for लूप का सिंटैक्स सीधा है। उदाहरण के लिए, आइए एक लूप बनाते हैं जो किसी वेक्टर के प्रत्येक तत्व को प्रिंट करता है:

languages = ["Julia", "Python", "R"]

for lang = languages
   println(lang)

end

Julia
Python
R

for लूप for कीवर्ड लिखने से शुरू होता है। फिर, हम एक अस्थायी वेरिएबल नाम चुनते हैं। इस मामले में, हम lang चुन रहे हैं, जिसका मान वेक्टर languages के माध्यम से जाने पर बदलता रहता है। फिर, यह निर्दिष्ट करने के लिए कि हम languages के माध्यम से लूप कर रहे हैं, हम असाइनमेंट ऑपरेटर = के बाद उसका नाम लिखते हैं।

लूप के अंदर, हम println() फ़ंक्शन का उपयोग करके languages के प्रत्येक तत्व को प्रिंट करते हैं, जिसे अस्थायी वेरिएबल lang द्वारा दर्शाया गया है। lang को अस्थायी वेरिएबल इसलिए कहा जाता है क्योंकि लूप समाप्त होने के बाद यह सुलभ नहीं रहता।

टिप्पणी: print() और println() के बीच अंतर यह है कि println() आइटम्स को नई लाइनों पर प्रिंट करता है।

आप अब तक सीखी हुई हर चीज़ का उपयोग for लूप्स के अंदर कर सकते हैं। उदाहरण के लिए, आइए 10 इंटीजर का एक एरे बनाएँ और केवल विषम संख्याएँ प्रिंट करें:

integers_vector = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for i = integers_vector
   # Print only odd numbers
   if i % 2 == 1
       println(i)
   end
end

1
3
5
7
9

for लूप और if स्टेटमेंट दोनों को end से बंद करना न भूलें।

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

for letter = "Julia"
   println(letter)

end

J
u
l
i
a

Julia में पैकेजेस इंस्टॉल करना 

अब तक जिन सभी ऑपरेटर्स (+, -, *, ^) , फ़ंक्शंस (print(), println(), typeof()) और कीवर्ड्स (for, if, else) का हमने उपयोग किया, वे Julia इंस्टॉलेशन के साथ आते हैं। हालाँकि, इंस्टॉलेशन में मौजूद कोड हमारी सभी समस्याएँ हल करने के लिए पर्याप्त नहीं है। हमें अतिरिक्त कार्यक्षमता के लिए टूल्स और फ़ंक्शंस लोड करने हेतु पैकेजेस इंस्टॉल करने की ज़रूरत होती है। पैकेजेस पूर्व-लिखित कोड (अन्य प्रोग्रामर्स द्वारा) की लाइब्रेरीज़ होती हैं जिन्हें हम अपनी Julia इंस्टॉलेशन में जोड़ सकते हैं, जो हमें विशिष्ट समस्याएँ सुलझाने में मदद करती हैं।

उदाहरण के लिए, हम DataFrames और CSV नामक दो पैकेज इंस्टॉल करेंगे जो हमें CSV फाइलों में जानकारी मेंनिपुलेट करने में मदद करते हैं। इसे ऐसे करें:

using Pkg
Pkg.add("DataFrames")
Pkg.add("CSV")

Pkg क्लास एक वैश्विक Julia पैकेज मैनेजर है। इसका add() फ़ंक्शन इंस्टॉलेशन में नए पैकेज जोड़ता है। लाइब्रेरीज़ से सभी फ़ंक्शन नाम इम्पोर्ट करने के लिए, हम अपनी स्क्रिप्ट्स के शीर्ष पर using कीवर्ड के साथ उन्हें इम्पोर्ट करते हैं।

using DataFrames
using CSV

हम अगले खंड में इनके फ़ंक्शंस का उपयोग करेंगे।

DataFrames के साथ शुरुआत 

DataFrame डेटा साइंस भाषाओं जैसे Julia, Python या R में तालिकाओं के साथ काम करने के लिए डिज़ाइन किया गया एक विशेष डेटा टाइप है। तालिकाओं को स्टोर करने के लिए सबसे लोकप्रिय फ़ाइल फ़ॉर्मैट CSV (comma-separated values) है। DataFrame लाइब्रेरी में ऐसी फाइलें लोड करने और उनके अंदर की जानकारी मेंनिपुलेट करने के टूल्स होते हैं।

CSV फाइलें इम्पोर्ट करना

हम इस ट्यूटोरियल के लिए diamonds डेटासेट इम्पोर्ट करेंगे। diamonds.csv फाइल कुछ इस तरह दिखती है:

diamonds डेटासेट यहाँ एक्सेस करें

पहली लाइन को हेडर कहा जाता है और इसमें कॉलम के नाम होते हैं। आइए इसे CSV और DataFrames पैकेजेस का उपयोग करके लोड करें।

# Load in the diamonds DataFrame
diamonds = DataFrame(CSV.File("data/diamonds.csv"))
typeof(diamonds)

DataFrame

हम CSV.File() में CSV फाइल का पाथ पास करते हैं, जिसे आगे DataFrame() फ़ंक्शन में पास किया जाता है। typeof() का आउटपुट दिखाता है कि ऑपरेशन सफल रहा।

सरल डेटा मेंनिपुलेशन 

जब आपके पास कोई नया DataFrame होता है, तो सबसे पहले आप इसकी कुछ पंक्तियाँ प्रिंट करते हैं ताकि देखें यह कैसा दिखता है। आप यह first() फ़ंक्शन से कर सकते हैं।

# Print the first 7 rows of diamond
first(diamonds, 7)

7 × 10 DataFrame

diamonds डेटासेट की पहली 7 पंक्तियाँ

first() फ़ंक्शन किसी DataFrame की पहली n पंक्तियाँ लौटाता है। जैसा कि हम देख सकते हैं, यहाँ 6 न्यूमेरिक और 3 श्रेणीबद्ध (टेक्स्ट) कॉलम हैं। Julia DataFrames में इंडेक्स को भी एक कॉलम के रूप में गिना जाता है। 

last() फ़ंक्शन भी होता है जो first() की तरह ही काम करता है। इसके नाम से ही आप अंदाज़ा लगा सकते हैं कि यह क्या करता है। जी हाँ, यह आख़िरी n पंक्तियाँ देता है।

एक और उपयोगी फ़ंक्शन है size()। यह किसी DataFrame की पंक्तियों और कॉलमों की संख्या प्रिंट करता है।

# Print the dimensions of diamonds
size(diamonds)

(10000, 10)

हमारे पास वाले में 10 हज़ार पंक्तियाँ और 10 कॉलम (इंडेक्स सहित) हैं। नंगी आँख सभी 10k पंक्तियाँ नहीं देख सकती, इसलिए हम अपने डेटासेट में कॉलम्स के वितरण का अंदाज़ा लगाने के लिए सारांश सांख्यिकी का उपयोग करते हैं। ऐसा करने के लिए, हम describe() फ़ंक्शन का उपयोग करते हैं

# Summary statistics of diamonds using describe()
describe(diamonds)

10 × 7 DataFrame

describe() फ़ंक्शन का आउटपुट

आउटपुट 7 कॉलम वाला एक सारांश टेबल है। min, max, mean और median कॉलम केवल न्यूमेरिक कॉलम्स पर लागू होते हैं। eltype कॉलम में, आप diamonds के प्रत्येक कॉलम के डेटा टाइप्स देख सकते हैं। String के बगल में दिए गए नंबर उस कॉलम में सबसे लम्बी स्ट्रिंग की लंबाई को दर्शाते हैं।

आप निम्न सिंटैक्स का उपयोग करके DataFrame से व्यक्तिगत कॉलम भी चुन सकते हैं।

# Extracting the first 10 rows of the cut column
diamonds[:, :cut][begin:10]

10-element PooledArrays.PooledArray{String15,UInt32,1,Array{UInt32,1}}:

"Ideal"
"Ideal"
"Ideal"
"Premium"
"Fair"
"Premium"
"Very Good"
"Ideal"
"Ideal"
"Premium"

ब्रैकेट्स के अंदर पहला कॉलन सभी पंक्तियाँ चुनता है। फिर, हम कॉमा और एक अन्य कॉलन के बाद (बिना कोट्स) कॉलम का नाम निर्दिष्ट करते हैं। फिर, लौटाए गए एरे पर इंडेक्सिंग का उपयोग करके हम पहली दस पंक्तियाँ चुन लेते हैं। उपरोक्त कोड को और भी सरल बनाने के लिए, हम पहली दस पंक्तियाँ सीधे पहले ब्रैकेट्स के अंदर इस प्रकार चुन सकते हैं:

# Extracting the first 10 rows of the cut column
diamonds[1:10, :carat]

10-element PooledArrays.PooledArray{String15,UInt32,1,Array{UInt32,1}}:

"Ideal"
"Ideal"
"Ideal"
"Premium"
"Fair"
"Premium"
"Very Good"
"Ideal"
"Ideal"
"Premium"

एकाधिक कॉलम चुनने के लिए, कॉलम नामों (कोलन के साथ) को ब्रैकेट्स के अंदर रखें।

# Extracting the first 5 rows of the cut, carat, price columns
diamonds[1:5, [:carat, :cut, :price]]

5 × 3 DataFrame

diamonds डेटासेट की पहली 5 पंक्तियाँ और 3 कॉलम

आइए केवल न्यूमेरिक कॉलम्स पर describe() फ़ंक्शन चलाएँ

# Running describe on numeric columns only
describe(diamonds[:, [:carat, :depth, :table, :price, :x, :y]])

केवल न्यूमेरिक कॉलम्स पर describe() चलाना

किसी कॉलम के आधार पर DataFrame को आरोही क्रम में देखने के लिए, sort() फ़ंक्शन का उपयोग करें:

# Sort diamonds and see the first 5 rows
sorted_diamonds = sort(diamonds, :price)
first(sorted_diamonds, 5)

सॉर्ट की गई सारणी

अवरोही क्रम में सॉर्ट करने के लिए, कॉलम नाम के चारों ओर order() फ़ंक्शन को रैप करें।

# Sort diamonds in descending order and see the first 5 rows
sorted_diamonds = sort(diamonds, order(:price, rev=true))
first(sorted_diamonds, 5)

सारांश तालिका, अवरोही क्रम में

बहुत बढ़िया! अब आप DataFrames लोड कर सकते हैं और बुनियादी डेटा एक्सप्लोरेशन कर सकते हैं।

Julia के बारे में और जानें 

भले ही Julia एक युवा प्रोग्रामिंग भाषा है, फिर भी भाषा में महारत हासिल करने के लिए संसाधनों की कोई कमी नहीं है। अपने कौशल बढ़ाने के लिए इनमें से कुछ देखें:

• Julia का उभार — क्या 2022 में इसे सीखना सार्थक है?
• MATLAB से Julia की ओर बढ़ना
• हमारे चीट शीट्स देखें, जो सभी डेटा टूल्स और तकनीकों को कवर करती हैं, जिनमें Julia भी शामिल है
• हमारा Introduction to Julia कोर्स देखें