Julia 1.0 - Noteworthy Differences from other Languages

अन्य भाषाओं से उल्लेखनीय अंतर




julia

अन्य भाषाओं से उल्लेखनीय अंतर

MATLAB से उल्लेखनीय अंतर

हालांकि MATLAB उपयोगकर्ता जूलिया के वाक्यविन्यास से परिचित हो सकते हैं, जूलिया MATLAB क्लोन नहीं है। प्रमुख वाक्यात्मक और कार्यात्मक अंतर हैं। निम्नलिखित कुछ उल्लेखनीय मतभेद हैं जो MATLAB के आदी जूलिया उपयोगकर्ताओं की यात्रा कर सकते हैं:

  • जूलिया सरणियों को वर्ग कोष्ठक, A[i,j] साथ अनुक्रमित किया जाता है।
  • जूलिया सरणियों की नकल तब नहीं की जाती है जब किसी अन्य चर को सौंपा जाता है। A = B बाद, A = B के बदलते तत्व A को भी संशोधित करेंगे।
  • किसी फ़ंक्शन में दिए जाने पर जूलिया मान कॉपी नहीं किया जाता है। यदि कोई फ़ंक्शन किसी सरणी को संशोधित करता है, तो कॉल करने वाले में परिवर्तन दिखाई देगा।
  • जूलिया एक असाइनमेंट स्टेटमेंट में स्वचालित रूप से एरेज नहीं बढ़ाता है। जबकि MATLAB a(4) = 3.2 में सरणी बना सकते हैं a = [0 0 0 3.2] और a(5) = 7 इसे a = [0 0 0 3.2 7] , संबंधित जूलिया स्टेटमेंट a[5] = 7 एक त्रुटि फेंकता है अगर की लंबाई 5 से कम है या यदि यह कथन पहचानकर्ता का पहला उपयोग a । जूलिया ने push! और append! , जो MATLAB's a(end+1) = val की तुलना में Vector अधिक कुशलता से बढ़ते हैं।
  • काल्पनिक इकाई sqrt(-1) को जूलिया में im रूप में दर्शाया गया है, न कि MATLAB में i या j रूप में।
  • जूलिया में, दशमलव बिंदु के बिना शाब्दिक संख्याएं (जैसे 42 ) अस्थायी बिंदु संख्याओं के बजाय पूर्णांक बनाती हैं। मनमाने ढंग से बड़े पूर्णांक शाब्दिक का समर्थन किया जाता है। परिणामस्वरूप, कुछ ऑपरेशन जैसे 2^-1 एक डोमेन त्रुटि को फेंक देंगे क्योंकि परिणाम पूर्णांक नहीं है (विवरण के लिए डोमेन त्रुटियों पर FAQ प्रविष्टि देखें)।
  • जूलिया में, कई मान लौटाए जाते हैं और टुपल्स के रूप में असाइन किए जाते हैं, जैसे (a, b) = (1, 2) या a, b = 1, 2 । MATLAB का nargout , जिसका उपयोग अक्सर MATLAB में वैकल्पिक मानों की संख्या के आधार पर वैकल्पिक कार्य करने के लिए किया जाता है, जूलिया में मौजूद नहीं है। इसके बजाय, उपयोगकर्ता समान क्षमताओं को प्राप्त करने के लिए वैकल्पिक और कीवर्ड तर्क का उपयोग कर सकते हैं।
  • जूलिया सच एक आयामी arrays है। कॉलम वैक्टर N के आकार के होते हैं, Nx1 नहीं। उदाहरण के लिए, rand(N) 1-आयामी सरणी बनाता है।
  • जूलिया में, [x,y,z] हमेशा x , y और z वाले 3-तत्व सरणी का निर्माण करेगा।
    • पहले ("लंबवत") आयाम में vcat(x,y,z) लिए या तो vcat(x,y,z) या अर्धविराम ( [x; y; z] ) के साथ अलग करें।
    • दूसरे ("क्षैतिज") आयाम में hcat(x,y,z) लिए या तो hcat(x,y,z) या रिक्त स्थान ( [xyz] ) के साथ अलग करें।
    • ब्लॉक मेट्रिसेस (पहले दो आयामों में hvcat ) का निर्माण करने के लिए, या तो hvcat उपयोग करें या रिक्त स्थान और अर्धविराम ( [ab; cd] ) को संयोजित करें।
  • जूलिया a:b और a:b:c निर्माण AbstractRange ऑब्जेक्ट करता है। MATLAB की तरह एक पूर्ण वेक्टर का निर्माण करने के लिए, collect(a:b) । आमतौर पर, हालांकि कॉल collect करने की कोई आवश्यकता नहीं है। एक AbstractRange ऑब्जेक्ट ज्यादातर मामलों में एक सामान्य सरणी की तरह काम करेगा लेकिन यह अधिक कुशल है क्योंकि यह आलसी अपने मूल्यों की गणना करता है। पूर्ण सरणियों के बजाय विशेष ऑब्जेक्ट बनाने का यह पैटर्न अक्सर उपयोग किया जाता है, और range जैसे कार्यों में भी देखा जाता range , या enumerate और zip जैसे पुनरावृत्तियों के साथ। विशेष वस्तुओं का ज्यादातर उपयोग किया जा सकता है जैसे कि वे सामान्य सरणियां थीं।
  • जूलिया में फ़ंक्शंस फ़ंक्शन मान में return के लिए चर के नामों को सूचीबद्ध करने के बजाय उनकी अंतिम अभिव्यक्ति या return कीवर्ड से मान लौटाते हैं (विवरण के लिए रिटर्न कीवर्ड देखें)।
  • जूलिया स्क्रिप्ट में किसी भी संख्या में फ़ंक्शन हो सकते हैं, और फ़ाइल लोड होने पर सभी परिभाषाएं बाहरी रूप से दिखाई देंगी। फ़ंक्शन परिभाषाएँ वर्तमान कार्य निर्देशिका के बाहर फ़ाइलों से लोड की जा सकती हैं।
  • जूलिया में, prod प्रत्येक तत्व के ऊपर कटौती, जैसे कि sum , prod और max को एक तर्क के साथ बुलाया जाता है, जैसे कि sum(A) , भले ही A में A से अधिक आयाम हों।
  • जूलिया में, कोष्ठक का उपयोग rand(N) जैसे rand(N) में शून्य तर्कों के साथ एक फ़ंक्शन को कॉल करने के लिए किया जाना चाहिए।
  • जूलिया अर्धविराम का इस्तेमाल बयानों को समाप्त करने के लिए करता है। बयानों के परिणाम स्वचालित रूप से मुद्रित नहीं होते हैं (इंटरैक्टिव प्रॉम्प्ट को छोड़कर), और कोड की पंक्तियों को अर्धविराम के साथ समाप्त करने की आवश्यकता नहीं है। @printf या @printf का उपयोग विशिष्ट आउटपुट को प्रिंट करने के लिए किया जा सकता है।
  • जूलिया में, यदि A और B सरणियाँ हैं, तो A == B जैसे तार्किक तुलनात्मक संचालन, बूलियन की एक सरणी नहीं लौटाते हैं। इसके बजाय, A .== B उपयोग करें, और इसी तरह अन्य बूलियन ऑपरेटरों के लिए collect(a:b) , collect(a:b) और =
  • जूलिया में, ऑपरेटरों & collect(a:b) , और ⊻ ( ⊻ ) MATLAB में क्रमशः and , or , और xor बराबर बिटवाइज़ संचालन करते हैं, और पायथन के बिटवाइज़ ऑपरेटरों (C के विपरीत) के समान पूर्वता है। वे स्केल पर या तत्व-वार को सरणियों पर संचालित कर सकते हैं और तार्किक सरणियों को संयोजित करने के लिए उपयोग किया जा सकता है, लेकिन संचालन के क्रम में अंतर पर ध्यान दें: कोष्ठक की आवश्यकता हो सकती है (जैसे, 1 या 2 उपयोग के बराबर A तत्वों का चयन करना (A .== 1) .| (A .== 2) )।
  • जूलिया में, संग्रह के तत्वों को फलैट ऑपरेटर का उपयोग करके एक फ़ंक्शन के तर्क के रूप में पारित किया जा सकता है ... , जैसा कि xs=[1,2]; f(xs...) xs=[1,2]; f(xs...)
  • जूलिया का svd घने विकर्ण मैट्रिक्स के रूप में एक वेक्टर के रूप में एकवचन मान देता है।
  • जूलिया में, ... कोड की लाइनों को जारी रखने के लिए उपयोग नहीं किया जाता है। इसके बजाय, अधूरी अभिव्यक्तियाँ स्वचालित रूप से अगली पंक्ति पर जारी रहती हैं।
  • जूलिया और MATLAB दोनों में, चर ans एक इंटरैक्टिव सत्र में जारी अंतिम अभिव्यक्ति के मूल्य पर सेट है। MATLAB के विपरीत जूलिया में, ans तब सेट नहीं किया जाता है जब जूलिया कोड गैर-संवादात्मक मोड में चलाया जाता है।
  • MATLAB के class तों के विपरीत जूलिया की struct रन टाइम पर गतिशील रूप से फ़ील्ड जोड़ने का समर्थन नहीं करती है। इसके बजाय, एक Dict उपयोग करें।
  • जूलिया में प्रत्येक मॉड्यूल का अपना वैश्विक दायरा / नाम स्थान होता है, जबकि MATLAB में सिर्फ एक वैश्विक गुंजाइश होती है।
  • MATLAB में, अवांछित मानों को हटाने का एक मुहावरेदार तरीका यह है कि लॉजिकल इंडेक्सिंग का उपयोग किया जाए, जैसे एक्सप्रेशन x(x>3) या x -इन को संशोधित करने के लिए स्टेटमेंट x(x>3) = [] में। इसके विपरीत, जूलिया उच्च क्रम फ़ंक्शन filter और filter! प्रदान करता है filter! उपयोगकर्ताओं को संबंधित ट्रांसलेशन x[x.>3] और x = x[x.>3] विकल्प के रूप में filter(z->z>3, x) और filter!(z->z>3, x) लिखने की अनुमति देता है x = x[x.>3] filter! का उपयोग करना filter! अस्थायी सरणियों के उपयोग को कम करता है।
  • MATLAB में vertcat(A{:}) जैसे सेल सरणी के सभी तत्वों को निकालने (या "dereferencing") के एनालॉग को जूलिया में splat ऑपरेटर, जैसे vcat(A...) रूप में लिखा जाता है।

आर से उल्लेखनीय अंतर

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

  • जूलिया के एकल उद्धरण में तार नहीं, पात्रों को शामिल किया गया है।

  • जूलिया स्ट्रिंग्स में अनुक्रमण करके सबस्ट्रिंग बना सकती है। आर में, स्ट्रिंग्स को सब्सट्रेट बनाने से पहले चरित्र वैक्टर में परिवर्तित किया जाना चाहिए।

  • जूलिया में, पायथन की तरह लेकिन आर के विपरीत, तार ट्रिपल उद्धरण """ ... """ के साथ बनाए जा सकते हैं। यह सिंटैक्स स्ट्रिंग्स के निर्माण के लिए सुविधाजनक है जिसमें लाइन ब्रेक होते हैं।

  • जूलिया में, वैर को स्पैट ऑपरेटर का उपयोग करके निर्दिष्ट किया जाता है ... , जो हमेशा आर के विपरीत एक विशिष्ट चर के नाम का अनुसरण करता है, जिसके लिए ... अलगाव में हो सकता है।

  • जूलिया में, मापांक mod(a, b) , a %% b । जुलिया में % शेष ऑपरेटर है।

  • जूलिया में, सभी डेटा संरचनाएं तार्किक अनुक्रमण का समर्थन नहीं करती हैं। इसके अलावा, जूलिया में तार्किक अनुक्रमण को केवल अनुक्रमित की जा रही वस्तु के बराबर लंबाई के वैक्टर के साथ समर्थन किया जाता है। उदाहरण के लिए:

    • R, c(1, 2, 3, 4)[c(TRUE, FALSE)] में c(1, 3) बराबर है।
    • R, c(1, 2, 3, 4)[c(TRUE, FALSE, TRUE, FALSE)] में c(1, 3) बराबर है।
    • जूलिया में, [1, 2, 3, 4][[true, false]] एक BoundsError फेंकता है।
    • जूलिया में, [1, 2, 3, 4][[true, false, true, false]] [1, 3] पैदा करता है।
  • कई भाषाओं की तरह, जूलिया हमेशा आर के विपरीत विभिन्न लंबाई के वैक्टर पर संचालन की अनुमति नहीं देता है, जहां वैक्टर को केवल एक सामान्य सूचकांक सीमा साझा करने की आवश्यकता होती है। उदाहरण के लिए, c(1, 2, 3, 4) + c(1, 2) मान्य R है, लेकिन समतुल्य [1, 2, 3, 4] + [1, 2] जूलिया में एक त्रुटि फेंक देगा।

  • जूलिया एक वैकल्पिक अनुगामी अल्पविराम की अनुमति देता है जब वह अल्पविराम कोड का अर्थ नहीं बदलता है। यह सरणियों में अनुक्रमित होने पर आर उपयोगकर्ताओं के बीच भ्रम पैदा कर सकता है। उदाहरण के लिए, आर में x[1,] मैट्रिक्स की पहली पंक्ति लौटाएगा; जूलिया में, हालांकि, अल्पविराम को नजरअंदाज कर दिया जाता है, इसलिए x[1,] == x[1] , और पहले तत्व को वापस करेगा। पंक्ति निकालने के लिए, उपयोग करना सुनिश्चित करें : जैसा कि x[1,:]

  • जूलिया का map पहले फ़ंक्शन लेता है, फिर उसके तर्क, आर में lapply(<structure>, function, ...) विपरीत। इसी तरह आर में जूलिया apply(X, MARGIN, FUN, ...) के समान apply(X, MARGIN, FUN, ...) जहां कार्य है पहला तर्क है।

  • बहुभिन्नरूपी आर में लागू होते हैं, उदाहरण के लिए mapply(choose, 11:13, 1:3) , जूलिया में broadcast(binomial, 11:13, 1:3) रूप में लिखा जा सकता है। समान रूप से जूलिया वेक्टरिंग कार्यों binomial.(11:13, 1:3) लिए एक छोटा डॉट सिंटैक्स प्रदान करता है binomial.(11:13, 1:3)

  • जूलिया सशर्त ब्लॉकों के end को दर्शाने के लिए अंत का उपयोग करता है, जैसे if , लूप ब्लॉक, जैसे / while और फ़ंक्शन। एक-लाइन के बदले में if ( cond ) statement , जूलिया फॉर्म के बयान की अनुमति देता है if cond; statement; end if cond; statement; end if cond; statement; end , cond && statement और !cond || statement । बाद के दो सिंटैक्स में असाइनमेंट स्टेटमेंट को स्पष्ट रूप से कोष्ठक में लपेटा जाना चाहिए, जैसे कि cond && (x = value)

  • जूलिया में, <- , <<- और -> असाइनमेंट ऑपरेटर नहीं हैं।

  • जूलिया का -> एक अनाम फ़ंक्शन बनाता है।

  • जूलिया ब्रैकेट का उपयोग करके वैक्टर का निर्माण करती है। जूलिया का [1, 2, 3] R के c(1, 2, 3) के बराबर है।

  • जूलिया के collect(a:b) ऑपरेटर R के विपरीत मैट्रिक्स गुणा कर सकते हैं। यदि A और B मैट्रिसेस हैं, तो A * B , R के A %*% B बराबर जूलिया में मैट्रिक्स गुणन को दर्शाता है। आर में, यह एक ही संकेतन एक तत्व-वार (हैडमार्ड) उत्पाद का प्रदर्शन करेगा। तत्व-वार गुणन क्रिया प्राप्त करने के लिए, आपको जूलिया में A। A .* B लिखना होगा।

  • जूलिया transpose फ़ंक्शन और संयुग्मित ट्रांसपोज़िशन का उपयोग करके मैट्रिक्स ट्रांसपोज़न करता है, जो ' ऑपरेटर या adjoint फ़ंक्शन का उपयोग करता है। जूलिया का transpose(A) इसलिए आर के t(A) के बराबर है। इसके अतिरिक्त जूलिया में एक गैर-पुनरावर्ती permutedims , permutedims फ़ंक्शन द्वारा प्रदान किया जाता है।

  • जूलिया को बयान while या जब / छोरों के for लिखते समय कोष्ठक की आवश्यकता नहीं होती है: इसके बदले for i in [1, 2, 3] उपयोग करें for (i in c(1, 2, 3)) और if i == 1 बजाय if (i == 1)

  • जूलिया 0 और 1 नंबर को बुलियन नहीं मानते हैं। आप if (1) जूलिया में नहीं लिख सकते हैं, क्योंकि if बयान केवल बूलियन को स्वीकार करते हैं। इसके बजाय, आप लिख सकते हैं if true , if Bool(1) , या if 1==1

  • जूलिया nrow और ncol प्रदान नहीं करता है। इसके बजाय, nrow(M) लिए size(M, 1) उपयोग करें और nrow(M) size(M, 2) का ncol(M)

  • जूलिया स्केलर, वैक्टर और मैट्रिस को भेद करने के लिए सावधान है। आर में, 1 और c(1) समान हैं। जूलिया में, उन्हें परस्पर उपयोग नहीं किया जा सकता है।

  • जूलिया के diagm और diagm , आर जैसे नहीं हैं।

  • जूलिया एक असाइनमेंट ऑपरेशन के बाईं ओर फ़ंक्शन कॉल के परिणामों को निर्दिष्ट नहीं कर सकता: आप diag(M) = fill(1, n) नहीं लिख सकते।

  • जूलिया कार्यों के साथ मुख्य नाम स्थान की आबादी को हतोत्साहित करता है। जूलिया के लिए अधिकांश सांख्यिकीय कार्यक्षमता जूलियास्टैट्स संगठन के तहत packages में पाई जाती है । उदाहरण के लिए:

    • वितरण पैकेज द्वारा संभाव्यता वितरण से संबंधित कार्य प्रदान किए जाते हैं।
    • DataFrames पैकेज डेटा फ़्रेम प्रदान करता है।
    • सामान्यीकृत रैखिक मॉडल GLM पैकेज द्वारा प्रदान किए जाते हैं।
  • जूलिया ट्यूपल्स और असली हैश टेबल प्रदान करता है, लेकिन आर-स्टाइल सूची नहीं। कई वस्तुओं को वापस करते समय, आपको आमतौर पर एक ट्यूपल या एक नामित टपल का उपयोग करना चाहिए: list(a = 1, b = 2) बजाय list(a = 1, b = 2) , (1, 2) या (a=1, b=2)

  • जूलिया उपयोगकर्ताओं को अपने स्वयं के प्रकार लिखने के लिए प्रोत्साहित करता है, जो table(x::TypeA) S3 या S4 ऑब्जेक्ट्स की तुलना में उपयोग करना आसान है। जूलिया के मल्टीपल डिस्पैच सिस्टम का मतलब है कि table(x::TypeA) और table(x::TypeB) table(x::TypeA) R की table.TypeA(x) की तरह कार्य करते हैं। table.TypeA(x) और table.TypeB(x)table.TypeB(x)

  • जूलिया में, मूल्यों को कॉपी नहीं किया जाता है जब एक फ़ंक्शन को सौंपा या पास किया जाता है। यदि कोई फ़ंक्शन किसी सरणी को संशोधित करता है, तो कॉल करने वाले में परिवर्तन दिखाई देगा। यह आर से बहुत अलग है और नए कार्यों को बड़ी डेटा संरचनाओं पर अधिक कुशलतापूर्वक संचालित करने की अनुमति देता है।

  • जूलिया में, वैक्टर और मेट्रिसेस को hcat(x,y,z) , vcat(x,y,z) और hvcat का उपयोग करके hcat(x,y,z) hvcat , न कि c , rbind और cbind जैसे आर।

  • जूलिया में, a a:b जैसी श्रेणी R की तरह वेक्टर के लिए शॉर्टहैंड नहीं है, लेकिन एक विशेष AbstractRange ऑब्जेक्ट है जो उच्च मेमोरी ओवरहेड के बिना पुनरावृत्ति के लिए उपयोग किया जाता है। किसी श्रेणी को वेक्टर में बदलने के लिए, collect(a:b)

  • जूलिया का max और min क्रमशः आर में pmax और pmin के बराबर हैं, लेकिन दोनों तर्कों को समान आयामों की आवश्यकता है। जबकि maximum और minimum आर में maximum और minimum प्रतिस्थापित करते हैं, महत्वपूर्ण अंतर हैं।

  • जूलिया की sum , prod , maximum , और minimum आर में उनके समकक्षों से अलग हैं। वे सभी एक या दो तर्क स्वीकार करते हैं। पहला तर्क एक पुनरावृत्त संग्रह है जैसे कि एक सरणी। यदि दूसरा तर्क है, तो यह तर्क उन आयामों को इंगित करता है, जिनके ऊपर ऑपरेशन किया जाता है। उदाहरण के लिए, A = [1 2; 3 4] A = [1 2; 3 4] जूलिया और B <- rbind(c(1,2),c(3,4)) R में समान मैट्रिक्स हैं। तो sum(A) sum(B) के समान परिणाम देता है, लेकिन sum(A, dims=1) एक पंक्ति वेक्टर है जिसमें प्रत्येक स्तंभ पर योग होता है और sum(A, dims=2) प्रत्येक पंक्ति के ऊपर एक कॉलम वेक्टर होता है। यह R के व्यवहार के विपरीत है, जहां अलग-अलग colSums(B) और rowSums(B) फ़ंक्शन ये कार्य प्रदान करते हैं। यदि dims कीवर्ड तर्क एक वेक्टर है, तो यह सभी आयामों को निर्दिष्ट करता है, जिस पर योग किया जाता है, जबकि sum(A, dims=(1,2)) == hcat(10) सरणी के आयामों को बनाए रखते हुए, जैसे sum(A, dims=(1,2)) == hcat(10) । यह ध्यान दिया जाना चाहिए कि दूसरे तर्क के संबंध में कोई त्रुटि जाँच नहीं है।

  • जूलिया के कई कार्य हैं जो उनके तर्कों को म्यूट कर सकते हैं। उदाहरण के लिए, इसमें sort और sort! दोनों हैं sort!

  • आर में, प्रदर्शन को वैश्वीकरण की आवश्यकता होती है। जूलिया में, लगभग विपरीत सच है: सबसे अच्छा प्रदर्शन कोड अक्सर devectorized छोरों का उपयोग करके प्राप्त किया जाता है।

  • जूलिया का बेसब्री से मूल्यांकन किया जाता है और वह आर-स्टाइल आलसी मूल्यांकन का समर्थन नहीं करता है। अधिकांश उपयोगकर्ताओं के लिए, इसका अर्थ है कि बहुत कम अयोग्य अभिव्यक्तियाँ या स्तंभ नाम हैं।

  • जूलिया NULL प्रकार का समर्थन नहीं करता है। निकटतम समकक्ष nothing , लेकिन यह सूची की तरह एक स्केलर मूल्य की तरह व्यवहार करता है। is.null(x) बजाय x == nothing उपयोग करें।

  • जूलिया में, लापता मूल्यों को NA बजाय missing वस्तु द्वारा दर्शाया जाता है। ismissing(x) बजाय ismissing(x) उपयोग करें। skipmissing फ़ंक्शन का उपयोग आमतौर पर na.rm=TRUE बजाय किया जाता है (हालाँकि कुछ विशेष मामलों में फ़ंक्शन एक skipmissing तर्क skipmissing है)।

  • जूलिया में R के assign या get के बराबर है।

  • जूलिया में, return को कोष्ठक की आवश्यकता नहीं होती है।

  • R में, अवांछित मानों को हटाने का एक मुहावरेदार तरीका तार्किक अनुक्रमण का उपयोग करना है, जैसे कि x[x>3] या कथन x = x[x>3] स्थान को संशोधित करने के लिए कथन x = x[x>3] में। इसके विपरीत, जूलिया उच्च क्रम फ़ंक्शन filter और filter! प्रदान करता है filter! उपयोगकर्ताओं को संबंधित ट्रांसलेशन x[x.>3] और x = x[x.>3] विकल्प के रूप में filter(z->z>3, x) और filter!(z->z>3, x) लिखने की अनुमति देता है x = x[x.>3] filter! का उपयोग करना filter! अस्थायी सरणियों के उपयोग को कम करता है।

पायथन से उल्लेखनीय अंतर

  • जूलिया को एक ब्लॉक को end करने की आवश्यकता होती है। पायथन के विपरीत, जूलिया का कोई pass कीवर्ड नहीं है।
  • जूलिया में, सरणियों, तारों आदि का अनुक्रमण 0-आधारित नहीं 0-आधारित है।
  • जूलिया के स्लाइस इंडेक्सिंग में पायथन के विपरीत अंतिम तत्व शामिल है। जूलिया में a[1:3] पायथन में a[1:3] है।
  • जूलिया नकारात्मक सूचकांकों का समर्थन नहीं करता है। विशेष रूप से, किसी सूची या सरणी का अंतिम तत्व जूलिया के end में अनुक्रमित है, न कि -1 पायथन में।
  • जूलिया के for , if , while , आदि ब्लॉक end कीवर्ड द्वारा समाप्त किए जाते हैं। संकेत स्तर महत्वपूर्ण नहीं है क्योंकि यह पायथन में है।
  • जूलिया में कोई रेखा निरंतरता वाक्यविन्यास नहीं है: यदि, एक पंक्ति के अंत में, अब तक का इनपुट एक पूर्ण अभिव्यक्ति है, तो यह माना जाता है; अन्यथा इनपुट जारी है। एक अभिव्यक्ति को जारी रखने के लिए मजबूर करने का एक तरीका यह है कि इसे कोष्ठक में लपेटा जाए।
  • जूलिया सरणियाँ स्तंभ प्रमुख हैं (फोरट्रान आदेशित) जबकि न्यूमपी सरणियाँ डिफ़ॉल्ट रूप से पंक्ति प्रमुख (सी-आदेशित) हैं। सरणियों पर लूपिंग करते समय इष्टतम प्रदर्शन प्राप्त करने के लिए, लूप्स के क्रम को न्यूपिया के विपरीत जूलिया में उलट दिया जाना चाहिए ( प्रदर्शन टिप्स के प्रासंगिक अनुभाग देखें)।
  • जूलिया के अपडेटिंग ऑपरेटर (जैसे += , -= , ...) इन-प्लेस नहीं हैं जबकि न्यूमी के हैं। इसका मतलब A = [1, 1]; B = A; B += [3, 3] A = [1, 1]; B = A; B += [3, 3] A = [1, 1]; B = A; B += [3, 3] A में मूल्यों को नहीं बदलता है, बल्कि यह B नाम को राइट-हैंड साइड B = B + 3 के परिणाम के लिए पुन: स्थापित करता है, जो एक नया सरणी है। इन-प्लेस ऑपरेशन के लिए, B .+= 3 ( डॉट ऑपरेटर भी देखें), स्पष्ट लूप, या InplaceOps.jl
  • जूलिया हर बार विधि तर्कों के डिफ़ॉल्ट मानों का मूल्यांकन करता है, पाइथन के विपरीत, जहां फ़ंक्शन को परिभाषित करते समय डिफ़ॉल्ट मानों का केवल एक बार मूल्यांकन किया जाता है। उदाहरण के लिए, फ़ंक्शन f(x=rand()) = x हर बार एक नया रैंडम नंबर लौटाता है, जिसे बिना तर्क के लागू किया जाता है। दूसरी ओर, फ़ंक्शन g(x=[1,2]) = push!(x,3) रिटर्न [1,2,3] हर बार इसे g() कहा जाता है।
  • जूलिया में % शेष ऑपरेटर है, जबकि पायथन में यह मापांक है।

C / C ++ से उल्लेखनीय अंतर

  • जूलिया सरणियों को वर्ग कोष्ठक के साथ अनुक्रमित किया जाता है, और इसमें एक से अधिक आयाम A[i,j] । यह सिंटैक्स केवल सूचक या पते के संदर्भ में सी / सी ++ की तरह सिंटैक्टिक चीनी नहीं है। सरणी निर्माण के लिए सिंटैक्स के लिए जूलिया प्रलेखन देखें (यह संस्करणों के बीच बदल गया है)।
  • जूलिया में, सरणियों, तारों आदि का अनुक्रमण 0-आधारित नहीं 0-आधारित है।
  • जूलिया सरणियों की नकल तब नहीं की जाती है जब किसी अन्य चर को सौंपा जाता है। A = B बाद, A = B के बदलते तत्व A को भी संशोधित करेंगे। अद्यतन करने वाले ऑपरेटर जैसे += इन-प्लेस को संचालित नहीं करते हैं, वे A = A + B बराबर होते हैं जो दाएं-हाथ की अभिव्यक्ति के परिणाम के लिए बाएं हाथ की ओर को दोहराते हैं।
  • जूलिया सरणियाँ स्तंभ प्रमुख हैं (फोरट्रान आदेशित) जबकि C / C ++ सरणियाँ पंक्ति प्रमुख हैं जो डिफ़ॉल्ट रूप से क्रमबद्ध हैं। सरणियों पर लूपिंग करते समय इष्टतम प्रदर्शन प्राप्त करने के लिए, लूप्स का क्रम C / C ++ के सापेक्ष जूलिया में उलटा होना चाहिए ( प्रदर्शन टिप्स के प्रासंगिक अनुभाग देखें)।
  • जूलिया मूल्यों को कॉपी नहीं किया जाता है जब एक फ़ंक्शन को सौंपा या पास किया जाता है। यदि कोई फ़ंक्शन किसी सरणी को संशोधित करता है, तो कॉल करने वाले में परिवर्तन दिखाई देगा।
  • जूलिया में, व्हाट्सएप महत्वपूर्ण है, सी / सी ++ के विपरीत, इसलिए जूलिया प्रोग्राम से व्हॉट्सएप को जोड़ते / हटाते समय सावधानी बरतनी चाहिए।
  • जूलिया में, दशमलव बिंदु के बिना शाब्दिक संख्याएं (जैसे 42 ) प्रकार के हस्ताक्षरित पूर्णांक बनाते हैं, Int , लेकिन मशीन शब्द आकार में फिट होने के लिए बहुत बड़े शाब्दिक स्वचालित रूप से बड़े आकार के प्रकार, जैसे कि Int64 (यदि Int है) को बढ़ावा दिया जाएगा Int32 ), Int128 , या मनमाने ढंग से बड़े Int128 प्रकार। अहस्ताक्षरित और / या हस्ताक्षरित बनाम हस्ताक्षरित इंगित करने के लिए कोई संख्यात्मक शाब्दिक प्रत्यय नहीं हैं, जैसे L , LL , U , UL , ULL । दशमलव शाब्दिक हमेशा हस्ताक्षरित होते हैं, और हेक्साडेसिमल शाब्दिक (जो 0x जैसे C / C ++ से शुरू होते हैं), अहस्ताक्षरित हैं। हेक्साडेसिमल शाब्दिक भी, सी / सी ++ / जावा के विपरीत और जूलिया में दशमलव शाब्दिक के विपरीत, एक प्रकार का शाब्दिक है, जिसमें प्रमुख 0s शामिल हैं। उदाहरण के लिए, 0x0 और 0x00 में टाइप करें UInt8 , 0x000 और 0x0000 में टाइप करें UInt16 , फिर 5 से 8 हेक्स UInt32 टाइप करें UInt32 , 9 से 16 हेक्स UInt64 टाइप UInt64 और 17 से 32 हेक्स UInt128 टाइप UInt128 । हेक्साडेसिमल मास्क को परिभाषित करते समय इसे ध्यान में रखा जाना चाहिए, उदाहरण के लिए ~0xf == 0xf0 ~0x000f == 0xfff0 से बहुत अलग है। 64 बिट Float64 64 और 32 बिट Float32 32 बिट 1.0f0 क्रमशः 1.0 और 1.0f0 रूप में व्यक्त किए 1.0f0 हैं। फ़्लोटिंग पॉइंट शाब्दिक हैं (और BigFloat प्रकार के लिए प्रचारित नहीं) अगर उन्हें बिल्कुल प्रतिनिधित्व नहीं किया जा सकता है। फ्लोटिंग पॉइंट शाब्दिक व्यवहार में C / C ++ के करीब हैं। ऑक्टल ( 0b साथ उपसर्ग) और बाइनरी ( 0b साथ उपसर्ग) को भी अहस्ताक्षरित माना जाता है।
  • स्ट्रिंग शाब्दिक या तो " या """ साथ सीमांकित किया जा सकता है, """ सीमांकित शाब्दिक में """ जैसे उद्धरण के बिना वर्ण शामिल हो सकते हैं। स्ट्रिंग शाब्दिकों में अन्य चर या भावों के मान हो सकते हैं, जिन्हें $variablename संकेत दिया गया है। $(expression) , जो फ़ंक्शन के संदर्भ में चर नाम या अभिव्यक्ति का मूल्यांकन करता है।
  • // एक Rational संख्या को इंगित करता है, और एकल-पंक्ति टिप्पणी नहीं है (जो जूलिया में # है)
  • #= एक बहुस्तरीय टिप्पणी की शुरुआत को इंगित करता है, और =# इसे समाप्त करता है।
  • जूलिया में फ़ंक्शंस उनके अंतिम अभिव्यक्ति (एस) या return कीवर्ड से मान return । एकाधिक मानों को फ़ंक्शंस से लौटाया जा सकता है और ट्यूपल्स के रूप में असाइन किया जा सकता है, जैसे (a, b) = myfunction() या a, b = myfunction() , मानों को पॉइंटर्स पास करने के बजाय जैसे कि C / ++ ++ में करना होगा; यानी a = myfunction(&b)
  • जूलिया को बयानों को समाप्त करने के लिए अर्धविराम के उपयोग की आवश्यकता नहीं है। अभिव्यक्तियों के परिणाम स्वचालित रूप से मुद्रित नहीं होते हैं (इंटरैक्टिव प्रॉम्प्ट, अर्थात आरईपीएल को छोड़कर), और कोड की पंक्तियों को अर्धविराम के साथ समाप्त होने की आवश्यकता नहीं है। @printf या @printf का उपयोग विशिष्ट आउटपुट को प्रिंट करने के लिए किया जा सकता है। REPL में ; उत्पादन को दबाने के लिए इस्तेमाल किया जा सकता है। ; [ ] भीतर भी एक अलग अर्थ है, बाहर देखने के लिए कुछ। ; एक ही पंक्ति पर अलग-अलग अभिव्यक्तियों के लिए इस्तेमाल किया जा सकता है, लेकिन कई मामलों में सख्ती से आवश्यक नहीं हैं, और पठनीयता के लिए अधिक सहायता है।
  • जूलिया में, ऑपरेटर ⊻ ( ⊻ ) ⊻ XOR ऑपरेशन करता है, यानी C / C ++ में collect(a:b) । इसके अलावा, बिटवाइज़ ऑपरेटर्स के पास C / ++ जैसी पूर्वता नहीं है, इसलिए कोष्ठक की आवश्यकता हो सकती है।
  • जूलिया का collect(a:b) ⊻ (पॉव) है, C / C ++ (जूलिया में or या ⊻ उपयोग करें) के रूप में ⊻ ⊻
  • जूलिया के दो राइट-शिफ्ट ऑपरेटर हैं, >> और >>>>>> एक अंकगणितीय पारी करता है, >> हमेशा C / C ++ के विपरीत एक तार्किक बदलाव करता है, जहां >> का अर्थ स्थानांतरित किए जाने वाले मूल्य के प्रकार पर निर्भर करता है।
  • जूलिया का -> एक अनाम फ़ंक्शन बनाता है, यह एक पॉइंटर के माध्यम से एक सदस्य तक नहीं पहुंचता है।
  • जूलिया को बयान while या जब / छोरों के for लिखते समय कोष्ठक की आवश्यकता नहीं होती है: for i in [1, 2, 3] बजाय का उपयोग करें for (int i=1; i <= 3; i++) और if i == 1 बजाय if (i == 1)
  • जूलिया 0 और 1 नंबर को बुलियन नहीं मानते हैं। आप if (1) जूलिया में नहीं लिख सकते हैं, क्योंकि if बयान केवल बूलियन को स्वीकार करते हैं। इसके बजाय, आप लिख सकते हैं if true , if Bool(1) , या if 1==1
  • जूलिया सशर्त ब्लॉकों के end को दर्शाने के लिए अंत का उपयोग करता है, जैसे if , लूप ब्लॉक, जैसे / while और फ़ंक्शन। एक-लाइन के बदले में if ( cond ) statement , जूलिया फॉर्म के बयान की अनुमति देता है if cond; statement; end if cond; statement; end if cond; statement; end , cond && statement और !cond || statement । बाद के दो वाक्यविन्यासों में असाइनमेंट स्टेटमेंट को स्पष्ट रूप से कोष्ठक में लपेटा जाना चाहिए, जैसे संचालक पूर्ववर्तीता के कारण cond && (x = value)
  • जूलिया में कोई रेखा निरंतरता वाक्यविन्यास नहीं है: यदि, एक पंक्ति के अंत में, अब तक का इनपुट एक पूर्ण अभिव्यक्ति है, तो यह माना जाता है; अन्यथा इनपुट जारी है। एक अभिव्यक्ति को जारी रखने के लिए मजबूर करने का एक तरीका यह है कि इसे कोष्ठक में लपेटा जाए।
  • जूलिया मैक्रोज़ कार्यक्रम के पाठ के बजाय पार्स अभिव्यक्तियों पर काम करते हैं, जो उन्हें जूलिया कोड के परिष्कृत परिवर्तनों को करने की अनुमति देता है। मैक्रो नाम @ वर्ण से शुरू होते हैं, और दोनों में फ़ंक्शन-जैसे सिंटैक्स, @mymacro(arg1, arg2, arg3) और एक स्टेटमेंट-जैसे सिंटैक्स, @mymacro arg1 arg2 arg3 । रूप विनिमेय हैं; फ़ंक्शन की तरह फ़ॉर्म विशेष रूप से उपयोगी है यदि मैक्रो किसी अन्य अभिव्यक्ति के भीतर दिखाई देता है, और अक्सर स्पष्ट होता है। स्टेटमेंट-जैसे फॉर्म का उपयोग अक्सर ब्लॉक को एनोटेट करने के लिए किया जाता है, जैसा कि निर्माण के for वितरित किया जाता है: @distributed for i in 1:n; #= body =#; end @distributed for i in 1:n; #= body =#; end @distributed for i in 1:n; #= body =#; end । जहां मैक्रो कंस्ट्रक्शन का अंत अस्पष्ट हो सकता है, फ़ंक्शन जैसे फॉर्म का उपयोग करें।
  • जूलिया के पास अब एक गणन प्रकार है, जिसे मैक्रो @enum(name, value1, value2, ...) का उपयोग करके व्यक्त किया गया है: उदाहरण के लिए: @enum(Fruit, banana=1, apple, pear)
  • अधिवेशन के द्वारा, अपने तर्कों को संशोधित करने वाले कार्यों में ए ! नाम के अंत में, उदाहरण के लिए push!
  • C ++ में, डिफ़ॉल्ट रूप से, आपके पास गतिशील प्रेषण है, यानी आपको डायनामिक प्रेषण करने के लिए किसी फ़ंक्शन को वर्चुअल के रूप में एनोटेट करने की आवश्यकता है। दूसरी ओर, जूलिया में प्रत्येक विधि "आभासी" है (हालांकि यह उससे अधिक सामान्य है क्योंकि विधियां हर तर्क प्रकार पर भेजी जाती हैं, यही नहीं, सबसे विशिष्ट-घोषणा नियम का उपयोग करके)।