R में फ़ंक्शनों का उपयोग ट्यूटोरियल

जानें कि R फ़ंक्शन क्या हैं, R में फ़ंक्शनों के अलग-अलग प्रकार, और R में अपने स्वयं के फ़ंक्शन कैसे बनाएँ।

अपडेट किया गया 25 सित॰ 2026 · 11 मि॰ पढ़ें

AI के साथ खोजें

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

फ़ंक्शन लगभग हर आधुनिक प्रोग्रामिंग भाषा में एक केंद्रीय अवधारणा हैं, जिनमें डेटा साइंस की लोकप्रिय भाषाएँ भी शामिल हैं, जैसे Python, Julia, और, स्वाभाविक रूप से, R।

इस ट्यूटोरियल में, हम जानेंगे कि R फ़ंक्शन क्या होते हैं और आप उनका उपयोग कैसे कर सकते हैं। R में उपलब्ध फ़ंक्शनों के उद्देश्य, सिंटैक्स और प्रकारों को कवर करके, आपको प्रोग्रामिंग की इस महत्वपूर्ण अवधारणा में महारत हासिल करने के लिए आवश्यक हर चीज़ मिल जाएगी। और साथ ही, आपको फ़ंक्शन बनाने की कला से भी परिचित कराया जाएगा।

R में फ़ंक्शन क्या है?

प्रोग्रामिंग में, फ़ंक्शन विशिष्ट कार्य को पूरा करने के लिए एक साथ संगठित निर्देश होते हैं। फ़ंक्शन के पीछे का तर्क यह है कि आत्मनिर्भर प्रोग्राम बनाए जाएँ जिन्हें केवल आवश्यकता पड़ने पर ही बुलाया जाए।

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

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

फ़ंक्शन के स्रोत के आधार पर, हम R में तीन मुख्य प्रकार के फ़ंक्शनों में भेद कर सकते हैं:

बिल्ट-इन फ़ंक्शन
R पैकेजों में उपलब्ध फ़ंक्शन
यूज़र-डिफ़ाइंड फ़ंक्शन (UDF)

आगे के अनुभागों में, हम R में उपलब्ध विभिन्न प्रकार के फ़ंक्शनों की विशेषताओं को समझाएँगे।

R में बिल्ट-इन फ़ंक्शन

R एक शक्तिशाली प्रोग्रामिंग भाषा है, जो बिल्ट-इन फ़ंक्शनों की एक विस्तृत सूची के साथ आती है जिन्हें कभी भी बुलाया जा सकता है। एक गणित-उन्मुख भाषा होने के नाते, R संख्यात्मक ऑपरेशनों को करने के लिए अच्छी-खासी संख्या में फ़ंक्शन प्रदान करता है। नीचे कुछ सबसे उपयोगी फ़ंक्शनों की सूची दी गई है:

print(). R कंसोल पर किसी R ऑब्जेक्ट को प्रदर्शित करता है
min(), max(). किसी न्यूमेरिक वेक्टर का न्यूनतम और अधिकतम निकालता है
sum(). किसी न्यूमेरिक वेक्टर का योग निकालता है
mean(). किसी न्यूमेरिक वेक्टर का औसत निकालता है
range(). किसी न्यूमेरिक वेक्टर के न्यूनतम और अधिकतम मान निकालता है
str(). किसी R ऑब्जेक्ट की संरचना प्रदर्शित करता है
ncol(). किसी मैट्रिक्स या डेटा फ़्रेम के कॉलमों की संख्या लौटाता है
length(). किसी R ऑब्जेक्ट जैसे वेक्टर, सूची और मैट्रिक्स में आइटमों की संख्या लौटाता है।

नीचे दिए गए कोड में, आप देख सकते हैं कि किसी वेक्टर से कुछ आँकड़े निकालने के लिए इन फ़ंक्शनों का उपयोग करना कितना सरल है:

>>> v <- c(1, 3, 0.2, 1.5, 1.7)
>>> print(v)
[1] 1.0 3.0 0.2 1.5 1.7
>>> sum(v)
[1] 7.4
>>> mean(v)
[1] 1.48
>>> length(v)
[1] 5

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

R पैकेजों में फ़ंक्शन

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

इन कार्यों को करने के लिए अधिकांश फ़ंक्शन बाहरी पैकेजों या लाइब्रेरी में उपलब्ध होते हैं। पैकेज R फ़ंक्शन, डेटा, और कम्पाइल्ड कोड का सुव्यवस्थित प्रारूप में संग्रह होते हैं, जिन्हें विशिष्ट कार्यक्षमता जोड़ने के लिए बनाया जाता है। इनमें से अधिकतर पैकेज निःशुल्क उपयोग किए जा सकते हैं और लोकप्रिय रिपॉज़िटरी में मिलते हैं, जैसे CRAN, जहाँ वर्तमान में लगभग 20,000 योगदानित पैकेज उपलब्ध हैं।

किसी पैकेज में उपलब्ध फ़ंक्शनों का उपयोग करने के लिए, पहले आपको उसे इंस्टॉल करना होगा। उदाहरण के लिए, यदि आप stringr इंस्टॉल करना चाहते हैं, जो रेगुलर एक्सप्रेशन के साथ काम करने के लिए एक लोकप्रिय पैकेज है, तो आप निम्न कथन का उपयोग कर सकते हैं:

install.packages('stringr')

इंस्टॉल करने के बाद, इसे अपने R वातावरण में लोड करने के लिए library कथन का उपयोग करें

library(stringr)

अब आप stringr पैकेज में उपलब्ध सभी फ़ंक्शनों का उपयोग करने के लिए तैयार हैं। उदाहरण के लिए, आइए str_detect() फ़ंक्शन आज़माएँ, जो प्रत्येक ऐसे स्ट्रिंग एलिमेंट के लिए TRUE वाला लॉजिकल वेक्टर लौटाता है जो पैटर्न से मेल खाता है, अन्यथा FALSE।

str_detect('DataCamp', "Data")
[1] TRUE

यदि आप R पैकेजों और उनका उपयोग कैसे करें, इसके बारे में अधिक जानना चाहते हैं, तो यह DataCamp R पैकेज ट्यूटोरियल देखें।

यूज़र-डिफ़ाइंड फ़ंक्शन

यह समझने का सबसे अच्छा तरीका कि R में फ़ंक्शन कैसे काम करते हैं, अपने स्वयं के फ़ंक्शन बनाना है। तथाकथित यूज़र-डिफ़ाइंड फ़ंक्शन (UDF) प्रोग्रामरों द्वारा किसी विशिष्ट कार्य को करने के लिए डिज़ाइन किए जाते हैं।

R फ़ंक्शन सामान्यतः निम्न सिंटैक्स अपनाते हैं:

function_name <- function(argument_1, argument_2) { 
  function body
  return (output)
}

हम चार मुख्य तत्वों को अलग कर सकते हैं:

फ़ंक्शन का नाम. UDF बनाने के लिए, पहले आपको उसे एक नाम देना होता है और एक नए ऑब्जेक्ट के रूप में सहेजना होता है। फ़ंक्शन का उपयोग जब भी करना हो, बस उस नाम को कॉल करना होता है।
आर्गुमेंट्स. फ़ंक्शन आर्गुमेंट्स (जिन्हें पैरामीटर्स भी कहते हैं) को कोष्ठकों के भीतर प्रदान किया जाता है। आर्गुमेंट्स यह बताने में महत्वपूर्ण हैं कि फ़ंक्शन को किस डेटा को इनपुट के रूप में लेना है और/या फ़ंक्शन के व्यवहार को कैसे बदलना है।
फ़ंक्शन बॉडी. कर्ली ब्रेसेज़ के भीतर फ़ंक्शन की बॉडी आती है, यानी दिए गए आर्गुमेंट्स से मिली जानकारी के आधार पर विशेष कार्य को हल करने के निर्देश।
रिटर्न स्टेटमेंट. यदि आप फ़ंक्शन के परिणाम/परिणामों को वेरिएबल्स के रूप में सहेजना चाहते हैं, तो रिटर्न स्टेटमेंट आवश्यक है, जो फ़ंक्शन बॉडी में किए गए ऑपरेशन्स के बाद मिलता है।

उदाहरण के लिए, यदि आप दो संख्याओं का औसत निकालने वाला फ़ंक्शन बनाना चाहते हैं:

mean_two_numbers <- function(num_1, num_2) {
  mean <- (num_1 + num_2) / 2
  return (mean)
}

अब, यदि आप 10 और 20 का औसत निकालना चाहते हैं, तो फ़ंक्शन को इस तरह कॉल करें:

>>> mean_two_numbers(10,20)
[1] 15

R फ़ंक्शनों में आर्गुमेंट्स के प्रकार

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

hello <- function() {
  print('hello, my friend')
}

>>> hello()
[1] "hello, my friend"

R फ़ंक्शनों में आर्गुमेंट्स की संख्या पर कोई सीमा नहीं है; आप उन्हें कोष्ठकों में अल्पविराम से अलग करके जोड़ सकते हैं। सामान्यतः, अधिक आर्गुमेंट्स वाले फ़ंक्शन अधिक जटिल होते हैं।

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

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

mean_two_numbers <- function(num_1, num_2 = 30) {
  mean <- (num_1 + num_2) / 2
  return (mean)
}

यदि अब हम num_2 पैरामीटर का मान दिए बिना फ़ंक्शन को कॉल करते हैं, तो R स्वचालित रूप से डिफ़ॉल्ट मान (यानी, 30) ले लेगा:

>>> mean_two_numbers(num_1 = 10)
[1] 20

R फ़ंक्शनों में रिटर्न वैल्यू समझना

आमतौर पर फ़ंक्शन कुछ डेटा को इनपुट के रूप में लेते हैं और आउटपुट के रूप में एक परिणाम देते हैं। कुछ प्रोग्रामिंग भाषाओं में, किसी फ़ंक्शन के परिणाम को वेरिएबल के रूप में सहेजने के लिए, आपको फ़ंक्शन बॉडी के अंत में स्पष्ट रूप से return स्टेटमेंट शामिल करना पड़ता है। अन्यथा, फ़ंक्शन केवल ऐसा मान प्रदर्शित करेगा जो वेरिएबल के स्कोप के भीतर ही मौजूद होता है।

R में ऐसा नहीं है, जो हमेशा ऐसा मान लौटाएगा जिसे किसी वेरिएबल में संग्रहीत किया जा सकता है। फिर भी, पठनीयता के लिए, फ़ंक्शन परिभाषित करते समय रिटर्न स्टेटमेंट शामिल करना हमेशा अच्छा अभ्यास है।

mean_two_numbers <- function(num_1, num_2) {
  # Function with return 
  mean <- (num_1 + num_2) / 2
  return (mean)
}
mean_two_numbers_2 <- function(num_1, num_2) {
  # Function without return
  mean <- (num_1 + num_2) / 2
  mean
}

> mean_two_numbers(10,50)
[1] 30
 > mean_two_numbers_2(10,50)
[1] 30

अंत में, यदि आप चाहते हैं कि आपका फ़ंक्शन कई मान लौटाए, तो आपको विभिन्न परिणामों को एक सूची में संग्रहीत करना होगा और उसे रिटर्न स्टेटमेंट में शामिल करना होगा:

mean_sum <- function(num_1, num_2) {
  mean <- (num_1 + num_2) / 2
  sum <- num_1 + num_2
  return (list(mean, sum))
}

>>> mean_sum (10, 20)
[[1]]
[1] 15
[[2]]
[1] 30

R में फ़ंक्शनों को कॉल करना

पिछले अनुभागों में, हम पहले ही यह देख चुके हैं कि किसी फ़ंक्शन को कैसे कॉल किया जाता है। हालाँकि, यह स्पष्ट करना महत्वपूर्ण है कि जब हम आर्गुमेंट्स पास करते हैं तो अंदर ही अंदर R कैसे काम करता है।

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

यदि हम आर्गुमेंट्स को नाम द्वारा पास करते हैं, तो हमें आर्गुमेंट्स के नाम और उनके संबंधित मानों को स्पष्ट रूप से निर्दिष्ट करना होगा। चूँकि आर्गुमेंट्स और मानों का मिलान हो गया है, इसलिए क्रम मायने नहीं रखता।

अंततः, दोनों रणनीतियों को मिलाना भी संभव है। इस स्थिति में, नामित आर्गुमेंट्स को आर्गुमेंट्स की सूची से निकालकर पहले मिलान किया जाता है, जबकि बाकी आर्गुमेंट्स का मिलान स्थिति के आधार पर होता है।

hello <- function(name, surname) {
  print(paste('Hello', name, surname))
}

# Calling arguments by position
> hello('Greta','Thunberg')
[1] "Hello, Greta Thunberg"
# Calling arguments by name
> hello(surname='Thunberg', name='Greta')
[1] "Hello, Greta Thunberg"
# Calling arguments by position and by name
> hello(surname='Thunberg', 'Greta')
[1] "Hello, Greta Thunberg"

R में फ़ंक्शनों का डॉक्यूमेंटेशन

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

hello <- function(name, surname) {
  # Say hello to a person with name and surname
  print(paste('Hello', name, surname))
}

>>> hello
function(name, surname) {
  # Say hello to a person with name and surname
  print(paste('Hello,', name, surname))

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

निष्कर्ष

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