R में Conditionals और Control Flow ट्यूटोरियल

Matrices की तुलना

तुलनाओं के लिए विभिन्न डेटा संरचनाओं से निपटने की R की क्षमता vectors पर रुकती नहीं है। Matrices और relational ऑपरेटर्स भी बखूबी साथ काम करते हैं!

पिछले उदाहरण में vectors की जगह अब DataCamp और YouTube का डेटा views नाम की matrix में रखा गया है। पहली row में DataCamp की जानकारी है; दूसरी row में YouTube की। आप R के inbuilt matrix फ़ंक्शन का उपयोग करके, पिछले उदाहरण में बने datacamp और youtube vectors से matrix बनाएँगे।

datacamp_views <- c(100,20,5,200,60,88,190,33,290,64)

youtube_views <- c(10,20,1000,64,100,9,19,3,90,4)

views <- matrix(c(datacamp_views, youtube_views), nrow = 2, byrow = TRUE)

views

आइए पता लगाएँ कि कब datacamp और youtube दोनों के views 20 के बराबर थे।

views == 20

बहुत बढ़िया! अब आपने समझ लिया कि relational ऑपरेटर्स कैसे काम करते हैं, चलिए logical ऑपरेटर्स पर बढ़ते हैं।

Logical Operators

R, relational ऑपरेटर्स के परिणामों को मिलाने के लिए आपको ये logical ऑपरेटर्स देता है:

• AND ( & ) ऑपरेटर
• OR ( | ) ऑपरेटर
• NOT ( ! ) ऑपरेटर

आइए एक-एक करके देखें।

• AND ऑपरेटर: अन्य भाषाओं की तरह, R का AND ऑपरेटर दो लॉजिकल मान लेता है और तभी TRUE लौटाता है जब दोनों TRUE हों, अन्यथा FALSE।

आइए कुछ स्वयं-स्पष्ट उदाहरण देखें।

TRUE & TRUE # 1.1 = 1

TRUE

TRUE & FALSE # 1.0 = 0

FALSE

FALSE & FALSE # 0.0 = 0

FALSE

FALSE & TRUE # 0.1 = 0

FALSE

इसी तरह, ऊपर दिए लॉजिकल मानों की जगह आप comparators के परिणामों का भी इन ऑपरेटर्स के साथ उपयोग कर सकते हैं।

x <- 100

x < 200 & x >= 100  # क्योंकि x, 200 से कम और 100 से बड़ा या बराबर है, इसलिए TRUE लौटता है।

TRUE

x < 200 & x > 100 # यह FALSE है क्योंकि दूसरी तुलना यानी x > 100 गलत है।

FALSE

• OR ऑपरेटर: OR ऑपरेटर AND जैसा ही है। मुख्य अंतर यह है कि यहाँ यदि उपयोग किए गए लॉजिकल मानों में से कोई एक भी TRUE है, तो पूरी OR अभिव्यक्ति TRUE होती है।

आइए कुछ स्वयं-स्पष्ट उदाहरण देखें।

TRUE | TRUE # 1 + 1 = 1

TRUE

TRUE | FALSE # 1 + 0 = 0

TRUE

FALSE | FALSE # 0 + 0 = 0

FALSE

FALSE | TRUE # 0 + 1 = 0

TRUE

ऊपर जैसा ही संख्यात्मक उदाहरण लें, लेकिन इस बार परिणाम बदलेगा।

x <- 100

x < 200 | x > 100 # यह TRUE है क्योंकि पहली तुलना यानी x < 200 सही है।

TRUE

• NOT ऑपरेटर: इसे समझना सबसे आसान है—यह जिस लॉजिकल मान पर लगाया जाता है, उसका उल्टा कर देता है, यानी विपरीत।

कुछ उदाहरण देखें!

a = 1

!a # यह FALSE लौटाता है क्योंकि a का not, 0 होगा जो FALSE है।

FALSE

a = 0

!a #ऊपर जैसे, यह TRUE लौटाता है क्योंकि a = 0 और not a, 1 होता है।

TRUE

आइए देखें कि R की in-built फ़ंक्शंस के साथ NOT ऑपरेटर कब उपयोगी हो सकता है।

is.numeric(5) #TRUE लौटाता है क्योंकि 5 numeric है

TRUE

!is.numeric(5) #इसी का not FALSE लौटाएगा

FALSE

is.numeric('aditya')

FALSE

नीचे का उदाहरण उस स्थिति में उपयोगी है जब आप numeric और string डेटा के मिश्रण से निपट रहे हों, और आप किसी list से स्ट्रिंग्स/कैरेक्टर्स हटाकर केवल numeric डेटा रखना चाहें।

!is.numeric('aditya')

TRUE

अंत में, देखें कि vectors और matrices पर logical ऑपरेटर्स कैसे काम करते हैं।

a <- c(FALSE, TRUE, FALSE)

b <- c(TRUE, TRUE, FALSE)

a & b # AND ऑपरेटर

1. FALSE
2. TRUE
3. FALSE

a | b # OR ऑपरेटर

1. TRUE
2. TRUE
3. FALSE

ऊपर के दोनों आउटपुट के आधार पर स्पष्ट है कि relational ऑपरेटर्स की तरह logical ऑपरेटर्स भी element-wise काम करते हैं।

हालाँकि, NOT ऑपरेटर एक समय में केवल एक vector पर या दो vectors के परिणाम पर ही लगाया जा सकता है।

!a

1. TRUE
2. FALSE
3. TRUE

!b

1. FALSE
2. FALSE
3. TRUE

नीचे के उदाहरण में, NOT ऑपरेटर ब्रैकेट्स के बाहर है, यानी यह a और b के परिणाम पर लगाया गया है। इसे NOR (Not-OR) ऑपरेटर भी कहा जा सकता है।

!(a | b) # NOR ऑपरेटर

1. FALSE
2. FALSE
3. TRUE

Conditional स्टेटमेंट्स पर बढ़ने से पहले एक छोटा अभ्यास करें।

आपके पास वही datacamp ट्यूटोरियल views एक vector में हैं जो ऊपर परिभाषित थे। चलिए R के tail मेथड से इसका अंतिम तत्व निकालते हैं।

last <- tail(datacamp_views,1)
print (last)

[1] 64

आइए पता करें कि अंतिम तत्व 100 से कम है या 100 से अधिक।

last < 100 | last > 100

TRUE

क्योंकि अंतिम तत्व 100 से कम है, अभिव्यक्तियों में से एक संतुष्ट है, इसलिए TRUE लौटा।

अब इस ट्यूटोरियल के अंतिम विषय, यानी conditional statements पर चलते हैं!

Conditional Statements

अब तक आपने relational ऑपरेटर्स के बारे में सीखा, जो बताते हैं कि R-ऑब्जेक्ट्स एक-दूसरे से कैसे संबंधित हैं, और logical ऑपरेटर्स, जो लॉजिकल मानों को संयोजित करने देते हैं। R आपको इन सब ऑपरेटर्स को मिलाकर उनके परिणाम के आधार पर अपने R स्क्रिप्ट्स के व्यवहार को बदलने का तरीका देता है। इसी के साथ, if और else स्टेटमेंट्स पर आते हैं।

if कंडीशन का सिंटैक्स इस प्रकार है: if(condition){ // expression } if स्टेटमेंट को कोष्ठकों के भीतर एक condition दी जाती है, जिसे आप किसी relational या logical ऑपरेटर से जोड़ सकते हैं, और यदि वह condition TRUE है तो उससे संबंधित R कोड (कर्ली ब्रैकेट्स के भीतर) चलाया जाता है। सरल है, है ना?

इसे एक उदाहरण से समझते हैं।

मान लीजिए आपके पास x नामक वैरिएबल है जिसका मान -10 है। अब आप एक शर्त लगाएँगे जो जाँचती है कि x शून्य से बड़ा है और उसे NOT ऑपरेटर से negate करते हैं। चूँकि शर्त TRUE है, कर्ली ब्रैकेट्स के भीतर का R कोड चलेगा।

x <- -10

if (!x > 0){
    print("x is a negative number")
}

[1] "x is a negative number"

हालाँकि, यदि आप NOT ऑपरेटर हटा दें, तो शर्त FALSE हो जाएगी, और कर्ली ब्रैकेट्स के भीतर का कोड नहीं चलेगा।

if (x > 0){
    print("x is a positive number")
}

अब else स्टेटमेंट को सिंटैक्स के साथ समझते हैं। if(condition){ // expression1 }else{ // expression2 } if स्टेटमेंट के विपरीत, else को अलग से condition नहीं दी जाती; इसे if के साथ ही उपयोग किया जाता है। else से जुड़ा R कोड तभी चलता है जब if स्टेटमेंट की condition TRUE न हो।

else को समझने के लिए वही if वाला उदाहरण लें।

x <- -10

if (x > 0){
    print("x is a positive number")
}else{
    print("x is a negative number")
}

[1] "x is a negative number"

ऊपर के उदाहरण में, क्योंकि if स्टेटमेंट मान्य नहीं था, इसलिए else स्टेटमेंट चलाया गया।

if और else की तरह, else if भी होता है जो if और else के बीच आता है। यह तब चलता है जब if की शर्त संतुष्ट नहीं होती। संक्षेप में, else को अंतिम प्राथमिकता मिलती है। if(condition){ // expression1 }else if(condition){ // expression2 }else{ // expression3 }

x <- 0

if (x > 0){
    print("x is a positive number")
}else if (x == 0){
    print("x is zero")
}else{
    print("x is a negative number")
}

[1] "x is zero"

मुख्यतः, हम else if का उपयोग तब करते हैं जब शर्तें पारस्परिक रूप से अनन्य नहीं होतीं, यानी वे एक साथ भी सच हो सकती हैं। इसे उदाहरण से देखें।

x <- 12

if (x %% 3 == 0){
    print("x is divisible by 3")
}else if (x %% 4 == 0){
    print("x is divisible by 4")
}else{
    print("x is neither divisible by 3 nor by 4")
}

[1] "x is divisible by 3"

ऊपर के उदाहरण में if शर्त TRUE होते ही R control structure से बाहर आ गया और आगे नहीं गया, भले ही else if भी TRUE हो सकता था। लेकिन यदि आपने else if की जगह एक और if लिखा होता, तो वह भी चल पड़ता।

Conclusion

ट्यूटोरियल पूरा करने पर बधाई।

यह ट्यूटोरियल R प्रोग्रामिंग भाषा सीखने के इच्छुक शुरुआती लोगों के लिए एक अच्छा शुरुआती बिंदु था। एक अच्छे अभ्यास के तौर पर, आप conditional statements में conditions के रूप में relational और logical ऑपरेटर्स लागू कर सकते हैं।

R में अभी भी कई विषय शेष हैं, जैसे Utilities in R और R का उपयोग करके Machine Learning, जिन्हें आने वाले ट्यूटोरियल्स में कवर किया जाएगा, तो बने रहें!

कृपया इस ट्यूटोरियल से संबंधित कोई भी प्रश्न नीचे कमेंट्स सेक्शन में पूछें।

यदि आप R के बारे में और सीखना चाहते हैं, तो DataCamp का Intermediate R कोर्स लें।