फंक्शन (Function) कोड का एक संगठित, पुन: प्रयोज्य ब्लॉक है जो एक विशिष्ट कार्य को करने के लिए लिखा जाता है। फंक्शन का उपयोग करने से प्रोग्राम में पुनरावृत्ति कम होती है, कोड अधिक पठनीय और रखरखाव में आसान बनता है। पाइथन में फंक्शन को def कीवर्ड से परिभाषित किया जाता है। किसी फलन को उसके नाम और कोष्ठक से बुलाया (call) जाता है।
फंक्शन का मूल सिंटैक्स:
def function_name(parameters):
# फलन का मुख्य भाग
return value
फंक्शन के उपयोग के लाभ: 1. कोड की पुनरावृत्ति से बचाव (DRY सिद्धांत)। 2. बड़े प्रोग्राम को छोटे भागों में विभाजित करना (modularity)। 3. डिबगिंग और परीक्षण सरल होता है। 4. कोड पुन: प्रयोज्य और पठनीय होता है।
def greet():
print("नमस्ते, पाइथन!")
# फलन को बुलाना
greet()
greet() # कई बार बुला सकते हैं
def add(a, b):
result = a + b
print("योग:", result)
add(5, 3) # योग: 8
वे तर्क जो बिना चूके दिए जाने अनिवार्य हैं:
def product(x, y):
return x * y
print(product(4, 5)) # 20
# product(4) → त्रुटि, y अनिवार्य है
जिन तर्कों का डिफ़ॉल्ट मान निर्धारित हो:
def power(base, exp=2):
return base ** exp
print(power(3)) # 9 (exp=2 डिफ़ॉल्ट)
print(power(3, 3)) # 27 (exp=3)
नाम निर्दिष्ट करके तर्क देना, जिससे क्रम बदला जा सकता है:
def student_info(name, age):
print(name, age)
student_info(age=17, name="अनु") # अनु 17
*args टपल में और **kwargs शब्दकोश में अनेक तर्क ग्रहण करता है:
def total(*args):
return sum(args)
print(total(1, 2, 3, 4)) # 10
def show(**kwargs):
for key, value in kwargs.items():
print(key, ":", value)
show(नाम="अनु", अंक=92)
return स्टेटमेंट फलन के परिणाम को बुलाने वाले स्थान पर लौटाता है। फलन एक से अधिक मान भी लौटा सकता है:
def calc(a, b):
return a + b, a - b, a * b
s, d, p = calc(10, 4)
print(s, d, p) # 14 6 40
जिस फलन में return नहीं होता वह None लौटाता है।
x = 10 # वैश्विक चर
def modify():
global x
x = 20
y = 5 # स्थानीय चर
print("फलन में x:", x)
modify()
print("मुख्य में x:", x) # 20
global कीवर्ड से फलन के अंदर वैश्विक चर को बदला जा सकता है। बिना global के असाइनमेंट नया स्थानीय चर बनाता है।
पाइथन में अनेक अंतर्निहित फलन हैं:
| फलन | कार्य |
|---|---|
len() |
लंबाई/तत्वों की संख्या |
type() |
डेटा प्रकार |
min(), max() |
न्यूनतम/अधिकतम |
sum() |
योग |
abs() |
निरपेक्ष मान |
round() |
गोल करना |
range() |
संख्या क्रम |
sorted() |
सॉर्ट की हुई सूची |
input(), print() |
इनपुट/आउटपुट |
मॉड्यूल फलनों, चरों और क्लासों का संग्रह है। import से मॉड्यूल का उपयोग किया जाता है:
import math
print(math.sqrt(16)) # 4.0
print(math.pi) # 3.14159...
print(math.floor(3.7)) # 3
print(math.ceil(3.2)) # 4
from math import sqrt, pow
print(sqrt(25)) # 5.0
पाइथन में तर्क पारित करने की विधि को "पास बाय ऑब्जेक्ट रेफरेंस" (Pass by Object Reference) कहा जाता है। इसका अर्थ है कि फलन में तर्क के रूप में ऑब्जेक्ट का संदर्भ (reference) भेजा जाता है। यदि ऑब्जेक्ट परिवर्तनशील (mutable) है - जैसे सूची या शब्दकोश - तो फलन के अंदर उसके तत्वों में किया गया परिवर्तन मुख्य प्रोग्राम में भी दिखाई देता है:
def add_mark(marks_list):
marks_list.append(100)
my_marks = [85, 90]
add_mark(my_marks)
print(my_marks) # [85, 90, 100] - सूची बदल गई
इसके विपरीत, यदि तर्क अपरिवर्तनशील (immutable) है - जैसे संख्या, स्ट्रिंग या टपल - तो फलन के अंदर उसे बदलने से मूल मान प्रभावित नहीं होता:
def increase(n):
n = n + 10
return n
value = 50
increase(value)
print(value) # 50 - मूल मान अपरिवर्तित
यह अंतर समझना परीक्षा के कोड-विश्लेषण प्रश्नों के लिए अत्यंत महत्वपूर्ण है।
एक फलन में इन सभी प्रकार के तर्कों को संयोजित किया जा सकता है। सही क्रम है: आवश्यक तर्क → डिफ़ॉल्ट तर्क → args → *kwargs:
def describe(name, age=17, *hobbies, **details):
print("नाम:", name)
print("आयु:", age)
print("रुचियाँ:", hobbies)
print("विवरण:", details)
describe("अनु", 17, "गायन", "खेल", शहर="दिल्ली", कक्षा="XII")
इस फलन में name आवश्यक तर्क है, age डिफ़ॉल्ट तर्क है, hobbies टपल में अनेक मान ग्रहण करता है और details शब्दकोश के रूप में अनेक कीवर्ड तर्क ग्रहण करता है। इस प्रकार का लचीलापन फलनों को अनेक परिस्थितियों में उपयोगी बनाता है।
निम्नलिखित उदाहरणों में विभिन्न प्रकार के फलनों का उपयोग दिखाया गया है:
def is_prime(n):
if n < 2:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True
def count_vowels(text):
vowels = 'aeiouAEIOU'
return sum(1 for ch in text if ch in vowels)
def reverse_list(lst):
return lst[::-1]
print(is_prime(17)) # True
print(count_vowels("पाइथन")) # 2
print(reverse_list([1, 2, 3])) # [3, 2, 1]
फलन लिखते समय इस बात का ध्यान रखें कि हर फलन का एक स्पष्ट उद्देश्य हो और उसका नाम उस उद्देश्य को प्रतिबिंबित करे। अच्छे फलन छोटे, समझने में आसान और केवल एक ही कार्य करने वाले होते हैं।
फलन लिखते समय निम्नलिखित सिद्धांतों का पालन करना चाहिए, जिससे कोड अधिक विश्वसनीय बने:
calculate_area, get_student_name।इन सिद्धांतों का पालन करके लिखा गया कोड न केवल परीक्षा में अच्छे अंक दिलाता है, बल्कि बड़े प्रोग्रामों में भी उसे प्रबंधित करना आसान होता है। फलनों का सही उपयोग एक अच्छे प्रोग्रामर की पहचान है।
| प्रकार | विवरण | उदाहरण |
|---|---|---|
| आवश्यक तर्क | अनिवार्य, क्रम से | add(5, 3) |
| डिफ़ॉल्ट तर्क | डिफ़ॉल्ट मान सहित | power(3) |
| कीवर्ड तर्क | नाम के साथ | info(age=17) |
| चर-लंबाई तर्क | args, *kwargs | total(1,2,3) |
| विशेषता | स्थानीय | वैश्विक |
|---|---|---|
| घोषणा स्थान | फलन के अंदर | फलन के बाहर |
| पहुँच | केवल उसी फलन में | पूरे प्रोग्राम में |
| बदलने का तरीका | सामान्य | global कीवर्ड से |
*args और **kwargs के उपयोग और उदाहरण तैयार रखें।फंक्शन पाइथन प्रोग्रामिंग की रीढ़ है। def कीवर्ड से फलन परिभाषित होते हैं और उन्हें कॉल करके पुन: उपयोग किया जाता है। आवश्यक, डिफ़ॉल्ट, कीवर्ड और चर-लंबाई तर्क फलनों को लचीला बनाते हैं। return से फलन मान लौटाता है, और यह एक से अधिक मान भी लौटा सकता है। स्थानीय और वैश्विक चर के बीच का अंतर और global कीवर्ड का उपयोग महत्वपूर्ण है। math जैसे मॉड्यूलों से अंतर्निहित फलनों की सुविधा मिलती है। इन अवधारणाओं की दृढ़ पकड़ परीक्षा में कोड-आउटपुट और फलन-लेखन प्रश्नों में उच्च अंक दिलाती है।