निर्देशांक रूपांतरण

मूल बातें कॉन्सेप्ट में फंक्शन का परिचय दिया गया था, और उदाहरण कुछ इस तरह थे:

squareit <- function(x) {
    x * x
}

squareit(3)
#> [1] 9

# shorter form
squareit_short <- function(x) x ^ 2

squareit की परिभाषा को ध्यान से देखें, तो हम उसके अलग-अलग हिस्से पहचान सकते हैं:

• यह फंक्शन एक औपचारिक आर्गुमेंट x लेता है।
• इसके अंदर एक फंक्शन बॉडी होती है, जो आमतौर पर ब्रैकेट { } में लिखी जाती है।
• फंक्शन ऑब्जेक्ट बन जाने के बाद उसे एक वेरिएबल squareit में असाइन किया जाता है।

R में फंक्शन एक फर्स्ट क्लास ऑब्जेक्ट है, बिल्कुल संख्याओं और स्ट्रिंग की तरह। इसलिए squareit <- function... भी एक असाइनमेंट है, जो लिखने के तरीके से बिल्कुल x <- 42 जैसा है।

आर्गुमेंट

Python और Julia जैसी दूसरी स्क्रिप्टिंग भाषाओं के उलट, R पोज़िशनल आर्गुमेंट और कीवर्ड आर्गुमेंट में कोई साफ़ अंतर नहीं करता।

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

f <- function(x, y) x / y

# call positionally
f(4, 2)
#> [1] 2

# call by name
f(y = 2, x = 4)
#> [1] 2

वैकल्पिक आर्गुमेंट

फंक्शन बनाते समय आर्गुमेंट की डिफ़ॉल्ट वैल्यू भी दी जा सकती है, लेकिन वह उन सभी आर्गुमेंट के बाद आनी चाहिए जिनकी कोई डिफ़ॉल्ट वैल्यू नहीं है।

इसके बाद हम चुन सकते हैं कि डिफ़ॉल्ट वैल्यू ही लें या उसे बदल दें।

g <- function(x, y = 2) x / y

# default y value
g(6)
#> [1] 3

# explicit y value
g(6, 3)
#> [1] 2

अतिरिक्त आर्गुमेंट

कितने भी अतिरिक्त आर्गुमेंट लेने के लिए फंक्शन की परिभाषा में ... (एलिप्सिस) लगाइए। फंक्शन कॉल में दी गई अतिरिक्त वैल्यू को वेक्टर में बदला जा सकता है, लेकिन इन "डॉट आर्ग्स" का दूसरा तरीका जानने के लिए आगे पढ़िए (कई दूसरी भाषाओं में इन्हें "वारआर्ग्स" कहा जाता है)।

var_f <- function(x, y, ...) {
  print(c(...))
}

var_f(2, 3, "opt1", "opt2")
#> [1] "opt1" "opt2"

फंक्शन एनवायरनमेंट

पहले हमने कहा था कि औपचारिक आर्गुमेंट और फंक्शन बॉडी, दोनों ही फंक्शन के हिस्से होते हैं।

असल में एक तीसरा हिस्सा भी होता है: वह एनवायरनमेंट जिसमें फंक्शन को बनाया जाता है।

इसे नेस्टेड फंक्शन के उदाहरण से समझा जा सकता है:

outer_func <- function(x) {
  inner_func <- function(y) {
    x * y
  }
  
  inner_func(3)
}

outer_func(5)
#> [1] 15

फंक्शन कॉल, आउटर फंक्शन को x = 5 भेजता है, और यह वैल्यू उस फंक्शन बॉडी के अंदर उपलब्ध रहती है।

इनर फंक्शन, आउटर फंक्शन की बॉडी का हिस्सा है, इसलिए उसके पास x की वैल्यू तक पहुँच होती है। दूसरे शब्दों में, x = 5 इनर फंक्शन के एनवायरनमेंट में है।

तकनीकी भाषा में इसे क्लोज़र कहते हैं।

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

f_var <- function(x, ...) {
  sum(x, ...)
}

x <- c(1, 2, NA, 6)

# for sum(), na.rm defaults to FALSE
f_var(x)
#> [1] NA

# pass through the na.rm value
f_var(x, na.rm = TRUE)
#> [1] 9

इस तरीके का इस्तेमाल Tidyverse की लाइब्रेरीज़, जैसे stringr, जमकर करती हैं। stringr के कई फंक्शन, stringi और बेस R के लो-लेवल फंक्शन के ऊपर एक यूज़र-फ्रेंडली रैपर हैं।

str_*() फंक्शन को दिए गए अतिरिक्त आर्गुमेंट सीधे उन्हीं लो-लेवल फंक्शन तक पहुँचा दिए जाते हैं।

रिटर्न वैल्यू के रूप में फंक्शन

कोई आउटर फंक्शन अपने अंदर एक इनर फंक्शन बना सकता है (नाम वाला या अनाम, जैसा नीचे बताया गया है) और उसे रिटर्न वैल्यू के तौर पर लौटा सकता है।

जो फंक्शन लौटाया जाता है, उसमें वह एनवायरनमेंट भी शामिल रहता है जिसमें उसे बनाया गया था।

times_y <- function(x) {
  # anonymous function - see next section
  \(y) x * y
}

f <- times_y(3)
class(f)
#> [1] "function"

f(4)
#> [1] 12

अनाम फंक्शन

जब हम कोई फंक्शन बनाते हैं, तो आमतौर पर बने हुए फंक्शन ऑब्जेक्ट को किसी वेरिएबल से जोड़ देते हैं।

x <- 2

# function definition captures x from the environment
doubleit_short <- function(y) x * y

इससे स्क्रिप्ट में बाद में उस फंक्शन का इस्तेमाल करना आसान हो जाता है, लेकिन ऐसा जोड़ना ज़रूरी नहीं है। जहाँ उसकी ज़रूरत पड़ी हो, वहीं एक बार इस्तेमाल होने वाला छोटा फंक्शन काम आ सकता है। बिना नाम जोड़े ऐसे फंक्शन को अनाम फंक्शन कहा जाता है।

अनाम फंक्शन इतने आम हैं कि (R v4.1.0 से) इन्हें बनाने के लिए एक छोटा तरीका भी है: function शब्द की जगह बैकस्लैश \ लिख दीजिए।

इसका एक उदाहरण पिछले हिस्से में, रिटर्न वैल्यू वाले भाग में दिया गया था।

बदलाव पर कॉपी

R वेक्टर के अलग-अलग एलिमेंट को वैल्यू असाइन करने देता है। अगर हम किसी फंक्शन को आर्गुमेंट के तौर पर एक वेक्टर देते हैं और उसे लौटाने से पहले फंक्शन बॉडी में बदल देते हैं, तो हमें बदला हुआ वेक्टर मिलता है।

लेकिन मूल वेक्टर का क्या हुआ?

f <- function(vec) {
  vec[1] <- 42
  vec
}

vals <- c(1, 3, 4)

# f() returns a modified vector
f(vals)
#> [1] 42  3  4  

# the original vector is unchanged.
vals
#> [1] 1 3 4

R एक ऐसी भाषा है जो डेटा साइंस के लिए बनाई गई है। ऐसा डेटा जमा करने में बहुत समय, मेहनत और कभी-कभी चौंका देने वाली रकम लग सकती है: इसलिए यह बहुत ज़रूरी है कि हम उसे खराब न करें!

आम तौर पर (कुछ अपवादों को छोड़कर) नीति बदलाव पर कॉपी की है। अगर किसी ऑब्जेक्ट (जैसे वेक्टर) को ऐसे तरीके से बदला जाए जिससे आगे दिक्कत हो सकती हो, तो R एक बदली हुई कॉपी लौटाता है और मूल को छेड़ता नहीं।

बड़े डेटा स्ट्रक्चर की कॉपी बनाना कंप्यूटर के लिए महँगा पड़ सकता है, लेकिन जब विकल्प डेटा के खराब हो जाने का हो, तो आम तौर पर यही कम नुकसानदेह रास्ता है।