R Academy · पाठ

ऑपरेटर प्राथमिकता और जटिल expressions

मूल्यांकन क्रम समझें और जटिल expressions सुरक्षित रूप से लिखें।

पाठ 4, कुल 4 में से13 चरण

ऑपरेटर प्राथमिकता और जटिल expressions, CoddyKit पर R Academy का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह R Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। R Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

ऑपरेटर प्राथमिकता क्या है

ऑपरेटर प्राथमिकता यह निर्धारित करती है कि किसी एक्सप्रेशन में ऑपरेशनों का मूल्यांकन किस क्रम में किया जाएगा। गणित की तरह, गुणा का मूल्यांकन जोड़ से पहले किया जाता है। R एक सुव्यवस्थित प्राथमिकता-सारणी का पालन करता है।

# Precedence in action
result1 <- 2 + 3 * 4    # * before +
result2 <- (2 + 3) * 4  # parentheses override
cat('2 + 3 * 4 =', result1, '
')   # 14
cat('(2+3) * 4 =', result2, '
')   # 20

R प्राथमिकता-सारणी (उच्च से निम्न)

R ऑपरेटरों का मूल्यांकन इस क्रम में करता है (सबसे पहले उच्चतम प्राथमिकता):

  1. ^ — घातांक
  2. - (यूनरी) — ऋणात्मक करना
  3. : — अनुक्रम
  4. %%, %/%, %*%, %in% — विशेष इन्फ़िक्स
  5. *, / — गुणा, भाग
  6. +, - (बाइनरी) — जोड़, घटाव
  7. <, >, <=, >=, ==, != — तुलना
  8. ! — NOT
  9. &, && — AND
  10. |, || — OR
  11. <-, = — असाइनमेंट
# Exponentiation before multiplication
cat('2 * 3 ^ 2 =', 2 * 3 ^ 2, '
')   # 2 * 9 = 18
cat('(2*3)^2 =', (2 * 3) ^ 2, '
')   # 6^2 = 36

# Unary minus applied after exponentiation
cat('-2 ^ 2 =', -2 ^ 2, '
')    # -(2^2) = -4
cat('(-2)^2 =', (-2) ^ 2, '
')  # 4

कोलन ऑपरेटर की प्राथमिकता

: अनुक्रम ऑपरेटर की प्राथमिकता + और - से अधिक होती है। इससे शुरुआती लोगों से होने वाली एक आम गलती सामने आती है: 1:n+1 को (1:n)+1 पढ़ा जाता है, न कि 1:(n+1)।

n <- 5

# Common mistake: colon before addition
cat('1:n+1 =', 1:n + 1, '
')   # (1:5)+1 = 2 3 4 5 6
cat('1:(n+1) =', 1:(n + 1), '
') # 1:6 = 1 2 3 4 5 6

# These are DIFFERENT results!
# Always use parentheses when the upper bound involves arithmetic

विशेष ऑपरेटरों की प्राथमिकता

%%, %/% और %in% जैसे विशेष ऑपरेटरों की प्राथमिकता + और - से अधिक, लेकिन ^ से कम होती है। इसे गलत समझने पर सूक्ष्म बग उत्पन्न हो सकते हैं।

# %% has higher precedence than +
cat('10 + 7 %% 3 =', 10 + 7 %% 3, '
')   # 10 + (7%%3) = 10+1 = 11
cat('(10+7) %% 3 =', (10 + 7) %% 3, '
') # 17 %% 3 = 2

# %in% precedence
nums <- 1:5
cat('1 + 1 %in% nums =', 1 + 1 %in% nums, '
')  # (1+1) %in% nums? No! 1 + (1 %in% nums) = 2

तार्किक ऑपरेटरों से पहले तुलना

तुलना ऑपरेटरों (<, >, == आदि) का मूल्यांकन तार्किक ऑपरेटरों (!, &, |) से पहले किया जाता है। इसलिए x > 0 & y < 10 अतिरिक्त कोष्ठकों के बिना अपेक्षानुसार काम करता है।

x <- 5
y <- 8

# This works as intended: comparisons first, then &
cat('x > 0 & y < 10:', x > 0 & y < 10, '
')  # TRUE & TRUE = TRUE

# ! NOT has higher precedence than &
vec <- c(TRUE, FALSE, TRUE)
cat('!vec & TRUE:', !vec & TRUE, '
')  # (!vec) & TRUE, not !(vec & TRUE)
cat('!(vec & TRUE):', !(vec & TRUE), '
')

पेचीदा प्राथमिकता बग #1

एक आम बग यह है कि लोग भूल जाते हैं कि ! की प्राथमिकता तुलना से कम होती है। इसलिए !x == y को (!x) == y पढ़ा जाता है, न कि !(x == y)।

x <- 5
y <- 5

# BUG: meant to check 'x is not equal to y'
bug_result <- !x == y      # reads as (!x) == y
cat('!x == y (bug):', bug_result, '
')   # !5 means FALSE, FALSE==5 is FALSE

# CORRECT: use != or !(x == y)
cat('x != y:', x != y, '
')             # FALSE (correct)
cat('!(x == y):', !(x == y), '
')       # FALSE (correct)

पेचीदा प्राथमिकता बग #2

एक और सूक्ष्म बग: -1:5 अनुक्रम -1, 0, 1, 2, 3, 4, 5 बनाता है — यूनरी माइनस केवल 1 पर लागू होता है, पूरी सीमा पर नहीं। ऋणात्मक मान से शुरू होने वाली सीमा पाने के लिए कोष्ठकों का उपयोग करें।

# Misleading: looks like range from -1 to 5 starting at negative
seq1 <- -1:5
cat('-1:5 =', seq1, '
')  # -1 0 1 2 3 4 5 (correct here)

# But -2^2 is a trap:
cat('-2^2 =', -2 ^ 2, '
')    # -4 (not 4)
cat('(-2)^2 =', (-2) ^ 2, '
') # 4

# Always parenthesise to be safe
cat('(-1):5 =', (-1):5, '
')   # same as -1:5 but explicit

स्पष्टता के लिए कोष्ठकों का उपयोग

कोष्ठक सख्ती से आवश्यक न होने पर भी उनका उपयोग कोड को पढ़ने में आसान और त्रुटियों की संभावना कम बनाता है। पूरी प्राथमिकता-सारणी याद रखने पर निर्भर न रहें — अपना आशय स्पष्ट रूप से व्यक्त करने के लिए कोष्ठकों का उपयोग करें।

# Hard to read — requires knowing precedence
result_unclear <- 2 + 3 * 4 ^ 2 / 8 - 1

# Clear intent with parentheses
result_clear <- 2 + ((3 * (4 ^ 2)) / 8) - 1

cat('Unclear:', result_unclear, '
')
cat('Clear:  ', result_clear, '
')
cat('Same result?', result_unclear == result_clear, '
')

एक्सप्रेशन में असाइनमेंट

असाइनमेंट (<-) की प्राथमिकता बहुत कम होती है — अधिकांश ऑपरेटरों से भी कम। इसका अर्थ है कि आप किसी भी जटिल एक्सप्रेशन के परिणाम को एक ही पंक्ति में निर्दिष्ट कर सकते हैं, लेकिन यह भी कि एक्सप्रेशन के अंदर असाइनमेंट का व्यवहार अप्रत्याशित हो सकता है।

# <- has very low precedence
# This assigns (3 + 4) to x, then evaluates (TRUE)
result <- x <- 3 + 4   # x gets 7, result gets 7
cat('x:', x, 'result:', result, '
')

# Be careful with == vs <- 
# x <- 5 is assignment
# x == 5 is comparison (always use == for testing)

व्यावहारिक सुझाव: प्राथमिकता संबंधी त्रुटियों से बचना

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

# Complex formula: compound interest
principal <- 1000
rate <- 0.05
years <- 10

# Hard to verify in one line
bad <- principal * (1 + rate) ^ years

# Easier to verify step by step
growth_factor <- (1 + rate) ^ years
final_amount <- principal * growth_factor
cat('Growth factor:', round(growth_factor, 4), '
')
cat('Final amount: $', round(final_amount, 2), '
')

तार्किक AND/OR के साथ प्राथमिकता

& (AND) की प्राथमिकता | (OR) से अधिक होती है। इसलिए A | B & C का मूल्यांकन A | (B & C) के रूप में किया जाता है। सूक्ष्म तार्किक बग से बचने के लिए AND और OR को मिलाते समय हमेशा कोष्ठकों का उपयोग करें।

A <- TRUE
B <- FALSE
C <- TRUE

# & before | — may surprise you
cat('A | B & C:', A | B & C, '
')     # A | (B & C) = TRUE | FALSE = TRUE
cat('(A|B) & C:', (A | B) & C, '
')   # TRUE & TRUE = TRUE

# Different with:
A2 <- FALSE
cat('A2 | B & C:', A2 | B & C, '
')   # FALSE | (FALSE & TRUE) = FALSE
cat('(A2|B) & C:', (A2 | B) & C, '
') # (FALSE|FALSE) & TRUE = FALSE

त्वरित जाँच

R में -3 ^ 2 का मूल्यांकन किस परिणाम में होता है?

पुनरावृत्ति: ऑपरेटर प्राथमिकता

उत्कृष्ट! इस पाठ की मुख्य बातें यहाँ दी गई हैं:

  • प्राथमिकता क्रम (उच्च → निम्न): ^, यूनरी -, :, %%/%/%*%%in%, */, +-, तुलनाएँ, !, &, |, असाइनमेंट
  • -2^2 = -4 क्योंकि ^ की प्राथमिकता यूनरी माइनस से अधिक है — 4 पाने के लिए (-2)^2 का उपयोग करें
  • 1:n+1 का अर्थ (1:n)+1 है — लंबी सीमा चाहिए तो 1:(n+1) का उपयोग करें
  • & की प्राथमिकता | से अधिक है — मिले-जुले AND/OR तर्क में कोष्ठक लगाएँ
  • संदेह होने पर कोष्ठकों का उपयोग करें ताकि आपका आशय स्पष्ट हो और बग से बचा जा सके
# Golden rule: parentheses for clarity
n <- 4
# Intended: sequence 1 to n+1
cat('Wrong : 1:n+1  =', 1:n + 1, '
')
cat('Correct: 1:(n+1)=', 1:(n + 1), '
')

# Intended: -(2^2)
cat('Correct: -2^2 = -(2^2) =', -2 ^ 2, '
')
शुरुआत निःशुल्क

एआई शिक्षक के साथ R सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम
43
पाठ
159

अक्सर पूछे जाने वाले प्रश्न

क्या “ऑपरेटर प्राथमिकता और जटिल expressions” पाठ निःशुल्क है?

हाँ — R Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “ऑपरेटर प्राथमिकता और जटिल expressions” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। R Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“ऑपरेटर प्राथमिकता और जटिल expressions” में मैं क्या सीखूँगा?

मूल्यांकन क्रम समझें और जटिल expressions सुरक्षित रूप से लिखें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ R Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या R Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर R Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।

“ऑपरेटर प्राथमिकता और जटिल expressions” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस R Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर R Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

  1. अंकगणितीय और तुलना ऑपरेटर
  2. तार्किक ऑपरेटर और Boolean तर्क
  3. असाइनमेंट और विशेष ऑपरेटर
  4. ऑपरेटर प्राथमिकता और जटिल expressions
← R Academy पर वापस जाएँ