आर कार्य
एक फ़ंक्शन कोड का एक ब्लॉक होता है जो केवल तब चलता है जब इसे कॉल किया जाता है।
आप किसी फ़ंक्शन में पैरामीटर के रूप में ज्ञात डेटा पास कर सकते हैं।
एक फ़ंक्शन परिणामस्वरूप डेटा वापस कर सकता है।
एक समारोह बनाना
फ़ंक्शन बनाने के लिए, function()कीवर्ड का उपयोग करें:
उदाहरण
my_function <- function() { # create a function with the name my_function
print("Hello World!")
}
फ़ंक्शन को कॉल करें
किसी फ़ंक्शन को कॉल करने के लिए, कोष्ठक के बाद फ़ंक्शन नाम का उपयोग करें, जैसे my_function() :
उदाहरण
my_function <- function() {
print("Hello World!")
}
my_function() # call the function named my_function
बहस
सूचना को तर्क के रूप में कार्यों में पारित किया जा सकता है।
कोष्ठक के अंदर फ़ंक्शन नाम के बाद तर्क निर्दिष्ट किए जाते हैं। आप जितने चाहें उतने तर्क जोड़ सकते हैं, बस उन्हें अल्पविराम से अलग करें।
निम्न उदाहरण में एक तर्क (fname) के साथ एक फ़ंक्शन है। जब फ़ंक्शन को कॉल किया जाता है, तो हम पहले नाम के साथ पास करते हैं, जिसका उपयोग फ़ंक्शन के अंदर पूरा नाम प्रिंट करने के लिए किया जाता है:
उदाहरण
my_function <- function(fname) {
paste(fname, "Griffin")
}
my_function("Peter")
my_function("Lois")
my_function("Stewie")
पैरामीटर या तर्क?
शब्द "पैरामीटर" और "तर्क" का उपयोग एक ही चीज़ के लिए किया जा सकता है: जानकारी जो किसी फ़ंक्शन में पारित की जाती है।
एक समारोह के नजरिए से:
एक पैरामीटर फ़ंक्शन परिभाषा में कोष्ठक के अंदर सूचीबद्ध चर है।
एक तर्क वह मान है जिसे फ़ंक्शन को तब भेजा जाता है जब उसे कॉल किया जाता है।
तर्कों की संख्या
डिफ़ॉल्ट रूप से, किसी फ़ंक्शन को तर्कों की सही संख्या के साथ कॉल किया जाना चाहिए। इसका मतलब है कि यदि आपका फ़ंक्शन 2 तर्कों की अपेक्षा करता है, तो आपको फ़ंक्शन को 2 तर्कों के साथ कॉल करना होगा, अधिक नहीं, और कम नहीं:
उदाहरण
यह फ़ंक्शन 2 तर्कों की अपेक्षा करता है, और 2 तर्क प्राप्त करता है:
my_function <- function(fname, lname) {
paste(fname, lname)
}
my_function("Peter", "Griffin")
यदि आप फ़ंक्शन को 1 या 3 तर्कों के साथ कॉल करने का प्रयास करते हैं, तो आपको एक त्रुटि मिलेगी:
उदाहरण
यह फ़ंक्शन 2 तर्कों की अपेक्षा करता है, और 1 तर्क प्राप्त करता है:
my_function <- function(fname, lname) {
paste(fname, lname)
}
my_function("Peter")
डिफ़ॉल्ट पैरामीटर मान
निम्न उदाहरण दिखाता है कि डिफ़ॉल्ट पैरामीटर मान का उपयोग कैसे करें।
यदि हम बिना किसी तर्क के फ़ंक्शन को कॉल करते हैं, तो यह डिफ़ॉल्ट मान का उपयोग करता है:
उदाहरण
my_function <- function(country = "Norway") {
paste("I am
from", country)
}
my_function("Sweden")
my_function("India")
my_function()
# will get the default value, which is Norway
my_function("USA")
वापसी मूल्य
किसी फ़ंक्शन को परिणाम वापस करने के लिए, return()फ़ंक्शन का उपयोग करें:
उदाहरण
my_function <- function(x) {
return (5 * x)
}
print(my_function(3))
print(my_function(5))
print(my_function(9))
उपरोक्त कोड का आउटपुट होगा:
[1] 15
[1] 25
[1] 45
नेस्टेड कार्य
नेस्टेड फ़ंक्शन बनाने के दो तरीके हैं:
- किसी फ़ंक्शन को किसी अन्य फ़ंक्शन के भीतर कॉल करें।
- किसी फ़ंक्शन के भीतर एक फ़ंक्शन लिखें।
उदाहरण
किसी फ़ंक्शन को किसी अन्य फ़ंक्शन के भीतर कॉल करें:
Nested_function <- function(x, y) {
a <- x + y
return(a)
}
Nested_function(Nested_function(2,2), Nested_function(3,3))
उदाहरण समझाया गया
फ़ंक्शन x को y जोड़ने के लिए कहता है।
पहला इनपुट Nested_function(2,2) मुख्य फ़ंक्शन का "x" है।
दूसरा इनपुट Nested_function(3,3) मुख्य फ़ंक्शन का "y" है।
इसलिए आउटपुट (2+2) + (3+3) = 10 है।
उदाहरण
किसी फ़ंक्शन के भीतर फ़ंक्शन लिखें:
Outer_func <- function(x) {
Inner_func <- function(y) {
a <- x + y
return(a)
}
return
(Inner_func)
}
output <- Outer_func(3) # To
call the Outer_func
output(5)
उदाहरण समझाया गया
आप सीधे फ़ंक्शन को कॉल नहीं कर सकते क्योंकि Inner_func को Outer_func के अंदर परिभाषित (नेस्टेड) किया गया है।
दूसरे चरण के रूप में Inner_func को कॉल करने के लिए हमें पहले Outer_func को कॉल करना होगा।
हमें आउटपुट नामक एक नया वेरिएबल बनाने और इसे एक मान देने की आवश्यकता है, जो यहां 3 है।
फिर हम आउटपुट को "y" के वांछित मान के साथ प्रिंट करते हैं, जो इस मामले में 5 है।
इसलिए आउटपुट 8 (3 + 5) है।
प्रत्यावर्तन
आर फ़ंक्शन रिकर्सन को भी स्वीकार करता है, जिसका अर्थ है कि एक परिभाषित फ़ंक्शन स्वयं को कॉल कर सकता है।
रिकर्सन एक सामान्य गणितीय और प्रोग्रामिंग अवधारणा है। इसका मतलब है कि एक फ़ंक्शन स्वयं को कॉल करता है। इसका अर्थ यह है कि परिणाम तक पहुंचने के लिए आप डेटा के माध्यम से लूप कर सकते हैं।
डेवलपर को रिकर्सन के साथ बहुत सावधान रहना चाहिए क्योंकि यह एक ऐसा फ़ंक्शन लिखने में काफी आसान हो सकता है जो कभी समाप्त नहीं होता है, या जो अधिक मात्रा में मेमोरी या प्रोसेसर पावर का उपयोग करता है। हालांकि, जब सही ढंग से लिखा जाता है, तो प्रोग्रामिंग के लिए रिकर्सन एक बहुत ही कुशल और गणितीय-सुरुचिपूर्ण दृष्टिकोण हो सकता है।
इस उदाहरण में, tri_recursion()एक फ़ंक्शन है जिसे हमने खुद को कॉल करने के लिए परिभाषित किया है ("रिकर्स")। हम
kवेरिएबल को डेटा के रूप में उपयोग करते हैं, जो -1हर बार जब हम रिकर्स करते हैं तो ( ) घटते हैं। रिकर्सन समाप्त होता है जब स्थिति 0 से अधिक नहीं होती है (यानी जब यह 0 हो)।
एक नए डेवलपर के लिए यह पता लगाने में कुछ समय लग सकता है कि यह वास्तव में कैसे काम करता है, इसका पता लगाने का सबसे अच्छा तरीका इसका परीक्षण और संशोधन करना है।
उदाहरण
tri_recursion <- function(k) {
if (k > 0) {
result <- k + tri_recursion(k - 1)
print(result)
} else {
result = 0
return(result)
}
}
tri_recursion(6)