Julia Language
comprehensions

ऐरे की समझ

बेसिक सिंटेक्स

जूलिया की सरणी समझ निम्नलिखित सिंटैक्स का उपयोग करती है:

[expression for element = iterable]

ध्यान दें कि साथ के रूप में for छोरों , के सभी = , in , और ∈ समझ के लिए स्वीकार कर रहे हैं।

यह लगभग खाली सरणी बनाने और push! for लूप का उपयोग करने के बराबर है push! यह करने के लिए आइटम।

result = []
for element in iterable
    push!(result, expression)
end

हालाँकि, एक सरणी समझ का प्रकार जितना संभव हो उतना संकीर्ण है, जो प्रदर्शन के लिए बेहतर है।

उदाहरण के लिए, पूर्णांक के वर्गों के एक सरणी को 1 से 10 तक प्राप्त करने के लिए, निम्नलिखित कोड का उपयोग किया जा सकता है।

squares = [x^2 for x=1:10]

-लूप संस्करण के for यह एक साफ, संक्षिप्त प्रतिस्थापन है।

squares = []
for x in 1:10
    push!(squares, x^2)
end

सशर्त सरणी समझ

जूलिया 0.5 से पहले, सरणी समझ के अंदर की स्थितियों का उपयोग करने का कोई तरीका नहीं है। लेकिन, यह अब सच नहीं है। जूलिया 0.5 में हम निम्न स्थितियों की तरह अंदर की स्थितियों का उपयोग कर सकते हैं:

julia> [x^2 for x in 0:9 if x > 5] 
4-element Array{Int64,1}:
 36
 49
 64
 81

उपरोक्त उदाहरण का स्रोत यहां पाया जा सकता है ।

यदि हम नेस्टेड सूची समझ का उपयोग करना चाहते हैं:

julia>[(x,y) for x=1:5 , y=3:6 if y>4 && x>3 ]
4-element Array{Tuple{Int64,Int64},1}:
 (4,5)
 (5,5)
 (4,6)
 (5,6)

बहुआयामी सरणी समझ

लूप्स के for नेस्ट का उपयोग कई अनूठे पुनरावृत्तियों पर पुन: व्यवस्थित करने के लिए किया जा सकता है।

result = []
for a = iterable_a
    for b = iterable_b
        push!(result, expression)
    end
end

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

[expression for a = iterable_a, b = iterable_b]

उदाहरण के लिए, 1:3 और 1:2 के कार्टेशियन उत्पाद को उत्पन्न करने के लिए निम्नलिखित का उपयोग किया जा सकता है।

julia> [(x, y) for x = 1:3, y = 1:2]
3×2 Array{Tuple{Int64,Int64},2}:
 (1,1)  (1,2)
 (2,1)  (2,2)
 (3,1)  (3,2)

चपटे बहुआयामी सरणी समझ समान हैं, सिवाय इसके कि वे आकार खो देते हैं। उदाहरण के लिए,

julia> [(x, y) for x = 1:3 for y = 1:2]
6-element Array{Tuple{Int64,Int64},1}:
 (1, 1)
 (1, 2)
 (2, 1)
 (2, 2)
 (3, 1)
 (3, 2)

ऊपर का एक चपटा संस्करण है। वाक्यात्मक अंतर यह है कि एक अतिरिक्त है for एक अल्पविराम के बजाय प्रयोग किया जाता है।

जनरेटर की समझ

जेनरेटर कॉम्प्रिहेंशन एरे कॉम्प्रिहेंशन के समान प्रारूप का अनुसरण करते हैं, लेकिन वर्ग कोष्ठक [] बजाय कोष्ठक () उपयोग करते हैं।

(expression for element = iterable)

ऐसी अभिव्यक्ति Generator ऑब्जेक्ट को लौटाती है।

julia> (x^2 for x = 1:5)
Base.Generator{UnitRange{Int64},##1#2}(#1,1:5)

कार्य तर्क

कोष्ठक के एक अतिरिक्त सेट की आवश्यकता के बिना, एक समारोह में एकमात्र तर्क के रूप में जनरेटर की समझ प्रदान की जा सकती है।

julia> join(x^2 for x = 1:5)
"1491625"

हालांकि, यदि एक से अधिक तर्क प्रदान किए जाते हैं, तो जनरेटर की समझ अपने स्वयं के कोष्ठकों के सेट को पुन: उत्पन्न करती है।

julia> join(x^2 for x = 1:5, ", ")
ERROR: syntax: invalid iteration specification

julia> join((x^2 for x = 1:5), ", ")
"1, 4, 9, 16, 25"