एलिस के जादुई सामान

Julia का एक मुख्य उद्देश्य है संख्यात्मक डेटा पर तेज़ी से और कुशलता से गणना कर पाना। वह भी बहुत सारे संख्यात्मक डेटा पर।

आम तौर पर यह डेटा ऐरे (या उससे जुड़े किसी टाइप) में संग्रहीत होता है, इसलिए यह कहना सही ही होगा कि ऐरे Julia भाषा के केंद्र में हैं।

ऐरे किसी भी आकार के हो सकते हैं (बस आपके हार्डवेयर की मेमोरी की सीमा का ध्यान रखना है), और उनमें कितने भी आयाम हो सकते हैं।

यह परिचयात्मक कॉन्सेप्ट 1-आयामी ऐरे की बुनियादी बातों पर केंद्रित है, जिन्हें वेक्टर कहा जाता है।

वेक्टर बनाना

Julia में वेक्टर वैल्यूओं का एक क्रमबद्ध अनुक्रम होता है, जिन्हें इंडेक्स संख्या से पढ़ा जा सकता है।

वेक्टर बनाने का सबसे आसान तरीका है वैल्यूओं को चौकोर ब्रैकेट में लिखना:

julia> num_vec = [1, 4, 9]
3-element Vector{Int64}:
 1
 4
 9

julia> str_vec = ["arrays", "are", "important"]
3-element Vector{String}:
 "arrays"
 "are"
 "important"

वेक्टर का टाइप उसके हर एलिमेंट के टाइप से मेल खाता है।

तो क्या वेक्टर के सारे एलिमेंट एक ही टाइप के होने चाहिए?

किसी हद तक हाँ, और अगर आपको सबसे अच्छा प्रदर्शन चाहिए तो इसी की कोशिश करने की सलाह दी जाती है। फिर भी, ज़रूरी होने पर Julia Any टाइप इस्तेमाल करके इस सीमा से बच सकती है:

julia> mixed_vector = [1, "str", 'c']
3-element Vector{Any}:
 1
  "str"
  'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)

खाली वेक्टर बनाते समय Julia डिफ़ॉल्ट रूप से एलिमेंट टाइप Any चुनती है, लेकिन खाली ऐरे पर मनचाहा एलिमेंट टाइप लिखकर इसे और स्पष्ट तरीके से तय किया जा सकता है।

julia> empty_vec = []
Any[]

julia> empty_int_vec = Int64[]
Int64[]

कृपया इस नियम को पढ़िए और याद रखिए:

• डिफ़ॉल्ट रूप से Julia में इंडेक्सिंग 0 से नहीं, 1 से शुरू होती है।

जिन लोगों ने डेटा साइंस की दूसरी भाषाएँ (R, Matlab, Fortran...) इस्तेमाल की हैं, उनके लिए यह बात जानी-पहचानी है, लेकिन C जैसी भाषाओं की पृष्ठभूमि रखने वाले लोगों को यह चौंकाने वाली लग सकती है।

बाकी सब कुछ वैसे ही काम करता है जैसा आप अंदाज़ा लगाएँगे: इंडेक्स को बस चौकोर ब्रैकेट में लिख दीजिए:

squares = [0, 1, 4, 9, 16]
squares[1]  # 0
squares[3]  # 4
squares[begin]  # 0 ("begin" is synonym for 1)
squares[end]  # 16 ("end" is synonym for length(squares))

ध्यान दीजिए कि end से इंडेक्स करना कितना सुविधाजनक है (यह बहुत काम का है) और begin से भी (जो शायद उतना काम का नहीं है)।

Python प्रोग्रामर सोच रहे होंगे कि ऋणात्मक इंडेक्स का क्या हुआ। ऐसा मत सोचिए: ये Julia का हिस्सा नहीं हैं, और इनसे BoundsError मिलती है। यही हाल 1 से छोटे या length(squares) से बड़े किसी भी इंडेक्स का होगा।

वेक्टर पर काम करना

Julia में वेक्टर बदलने योग्य होते हैं: हम किसी भी एक एलिमेंट की वैल्यू बदल सकते हैं।

julia> vals = [1, 3, 5, 7]
4-element Vector{Int64}:
 1
 3
 5
 7

julia> vals[2] = 4  # reassign the value of this element
4

# Only the value at position 2 changes:
julia> vals
4-element Vector{Int64}:
 1
 4
 5
 7

वेक्टर पर काम करने के लिए कई फंक्शन उपलब्ध हैं, हालाँकि Julia का दस्तावेज़ इन्हें वेक्टर तक सीमित न रखकर "कलेक्शन" तक बढ़ा देता है।

ध्यान दीजिए कि एक परंपरा के तौर पर जो फंक्शन अपने इनपुट को बदलते हैं, उनके नाम में ! होता है। कंपाइलर इसे लागू नहीं करता, लेकिन Julia की दुनिया में यह एक बहुत पक्की परंपरा है।

यहाँ कुछ काम के फंक्शन दिए गए हैं:

• वेक्टर के अंत में वैल्यू जोड़ने के लिए push!() इस्तेमाल कीजिए।
• अंतिम वैल्यू हटाने के लिए pop!() इस्तेमाल कीजिए।
• वेक्टर की शुरुआत पर काम करने के लिए इसी तरह के फंक्शन pushfirst!() और popfirst!() हैं।
• किसी भी जगह पर एलिमेंट जोड़ने या हटाने के लिए insert!() और deleteat!() हैं।

julia> vals = [1, 3]
2-element Vector{Int64}:
 1
 3

julia> push!(vals, 5, 6)  # can add multiple values
4-element Vector{Int64}:
 1
 3
 5
 6

julia> pop!(vals)  # mutates vals, return popped value
6

julia> vals
3-element Vector{Int64}:
 1
 3
 5