फ़ंक्शन्स
जैसे-जैसे आपके प्रोग्राम्स बड़े होते हैं, आप एक ही लॉजिक को एक से अधिक जगह लिखेंगे। फ़ंक्शन्स आपको लॉजिक को एक बार लिखने, उसे नाम देने, और हर जगह उपयोग करने देते हैं। इसे एक जगह ठीक करें और हर कॉल को ठीक किया जाता है।
def greet(name):
return f"Hello, {name}!"
print(greet("अरुण")) # "Hello, अरुण!"
print(greet("भारत")) # "Hello, भारत!"इसे एक बार लिखें, हर जगह उपयोग करें, एक जगह ठीक करें।
एक फ़ंक्शन को परिभाषित करना
def कीवर्ड एक फ़ंक्शन परिभाषा शुरू करता है, उसके बाद नाम, कोष्ठक, एक कोलन, और एक इंडेंटेड बॉडी आती है। एक फ़ंक्शन तब तक कुछ नहीं करता जब तक आप इसे कॉल नहीं करते। इसे def से परिभाषित करें, फिर इसे () के साथ नाम से कॉल करें।
def say_hello():
print("Hello!")
say_hello() # फ़ंक्शन को कॉल करें
def name(): लिखें और बॉडी को नीचे इंडेंट करें। जब तक आप इसे name() के साथ कॉल नहीं करते कुछ नहीं होता, def केवल इसे सेट अप करता है। और अगर आप एक return भूल जाते हैं, तो फ़ंक्शन शांति से None वापस करता है, जो शुरुआत में मुझे एक से अधिक बार पकड़ा गया। पैरामीटर्स और आर्गुमेंट्स
पैरामीटर्स आपके फ़ंक्शन की अपेक्षित इनपुट्स हैं। उन्हें कोष्ठक के अंदर सूचीबद्ध करें। जब आप फ़ंक्शन को कॉल करते हैं, तो आप जो वैल्यूज़ पास करते हैं उन्हें पैरामीटर्स के साथ क्रम में मैच किया जाता है।
def greet(name, greeting):
print(f"{greeting}, {name}!")
greet("अरुण", "नमस्ते") # "नमस्ते, अरुण!"
greet("भारत", "हाय") # "हाय, भारत!"पैरामीटर फ़ंक्शन परिभाषा में नाम है। आर्गुमेंट वास्तविक वैल्यू है जिसे आप कॉल करते समय देते हैं। व्यावहारिक रूप से लोग शब्दों का परस्पर उपयोग करते हैं; भेद मुख्य रूप से तब मायने रखता है जब डॉक्स पढ़ते हैं।
डिफ़ॉल्ट वैल्यूज़
आप पैरामीटर्स को एक डिफ़ॉल्ट वैल्यू दे सकते हैं। अगर कॉलर वह आर्गुमेंट नहीं देता है, तो डिफ़ॉल्ट का उपयोग किया जाता है। डिफ़ॉल्ट वैल्यूज़ वाले पैरामीटर्स को डिफ़ॉल्ट वैल्यूज़ के बिना पैरामीटर्स के बाद आना चाहिए।
def greet(name, greeting="नमस्ते"):
print(f"{greeting}, {name}!")
greet("अरुण") # "नमस्ते, अरुण!"
greet("अरुण", "हाय") # "हाय, अरुण!"डिफ़ॉल्ट वैल्यूज़ वाले पैरामीटर्स को डिफ़ॉल्ट वैल्यूज़ के बिना पैरामीटर्स के बाद आना चाहिए।
कीवर्ड आर्गुमेंट्स
फ़ंक्शन को कॉल करते समय, आप आर्गुमेंट्स को नाम दे सकते हैं। यह कॉल्स को पठनीय बनाता है, विशेष रूप से कई पैरामीटर्स वाले फ़ंक्शन्स के लिए, और आपको उन्हें किसी भी क्रम में पास करने देता है।
def describe_player(name, score, level):
print(f"{name} | Score: {score} | Level: {level}")
describe_player("अरुण", 87, 5) # पोजिशनल
describe_player(name="अरुण", level=5, score=87) # कीवर्ड, कोई भी क्रम
describe_player("अरुण", level=5, score=87) # मिश्रण: पोजिशनल पहलेscore=87) और कॉल अपने आप को समझाता है, साथ ही आप उन्हें किसी भी क्रम में पास कर सकते हैं। एक नियम: कोई पोजिशनल आर्गुमेंट्स नाम वाले से पहले आना चाहिए। बहुत सारे पैरामीटर्स वाले फ़ंक्शन्स के लिए बहुत अच्छा। रिटर्न वैल्यूज़
return कॉलर को एक वैल्यू भेजता है। बिना return के, एक फ़ंक्शन None देता है। एक बार return चलता है, फ़ंक्शन तुरंत बाहर निकलता है। उस ब्लॉक में इसके बाद का कोई भी कोड छोड़ दिया जाता है।
def add(a, b):
return a + b
result = add(3, 4) # result = 7
print(result)return भी तुरंत फ़ंक्शन को बाहर निकालता है। उस ब्लॉक में इसके बाद का कोई भी कोड नहीं चलता है।
return फ़ंक्शन को कॉल करने वाले को एक वैल्यू देता है, और फ़ंक्शन वहीं बंद हो जाता है, इसके बाद कुछ भी छोड़ दिया जाता है। `return` को छोड़ दें और आप None वापस पाते हैं। print एक वैल्यू दिखाता है, return इसे उपयोग करने के लिए देता है, मुझे वह अंतर महसूस करने में एक समय लगा। एकाधिक वैल्यूज़ रिटर्न करना
Python आपको कॉमा के साथ एकाधिक वैल्यूज़ को अलग करके रिटर्न करने देता है। कॉलर उन्हें एक ट्यूपल के रूप में प्राप्त करता है और उन्हें एक लाइन में अलग नामों में अनपैक कर सकता है।
def min_max(numbers):
return min(numbers), max(numbers)
low, high = min_max([3, 7, 1, 9, 4])
print(low, high) # 1 9low, high = ... सिंटैक्स अनपैकिंग है: Python रिटर्न की गई हर वैल्यू को संगत नाम को असाइन करता है।
low, high = min_max(...), एक नाम प्रति वैल्यू। सुविधाजनक जब भी एक फ़ंक्शन स्वाभाविक रूप से एक से अधिक उत्तर देता है। स्कोप
फ़ंक्शन के अंदर बनाए गए वेरिएबल्स केवल उस फ़ंक्शन के अंदर मौजूद होते हैं। आप उन्हें बाहर से नहीं देख सकते। सभी फ़ंक्शन्स के बाहर परिभाषित वेरिएबल्स हर जगह दिखाई देते हैं, लेकिन आप एक स्पष्ट घोषणा के बिना फ़ंक्शन के अंदर से उन्हें बदल नहीं सकते।
global लाइन की आवश्यकता है। लगभग कभी भी इसे न करें: वैल्यूज़ को अंदर पास करें, परिणामों को बाहर रिटर्न करें, और फ़ंक्शन सरल रहता है। def calculate():
result = 42 # इस फ़ंक्शन के लिए स्थानीय
return result
calculate()
print(result) # NameError, result यहाँ मौजूद नहीं हैcount = 0
def increment():
global count # घोषित करें कि आप वैश्विक को संशोधित करना चाहते हैं
count += 1
increment()
print(count) # 1global का उपयोग करना एक अंतिम उपाय होना चाहिए। यह कोड को समझने में कठिन बनाता है। वैल्यूज़ को अंदर पास करने और उन्हें बाहर रिटर्न करने के लिए वरीयता दें। स्कोप सीधे इस पर बनता है कि असाइनमेंट एक नाम को एक वैल्यू में कैसे बाँधता है, जिसे Variables and types अध्याय में शामिल किया गया है।
*args और **kwargs
कभी-कभी आप नहीं जानते कि एक फ़ंक्शन कितने आर्गुमेंट्स प्राप्त करेगा। *args किसी भी संख्या में पोजिशनल आर्गुमेंट्स को एक ट्यूपल में एकत्र करता है। **kwargs किसी भी संख्या में कीवर्ड आर्गुमेंट्स को एक डिक्शनरी में एकत्र करता है। args और kwargs के नाम सम्मेलन हैं; सितारे महत्वपूर्ण हैं।
def total(*args):
return sum(args)
total(1, 2, 3) # 6
total(1, 2, 3, 4, 5) # 15def display(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
display(name="अरुण", score=87, level=5)आप उन्हें नियमित पैरामीटर्स के साथ मिश्रित कर सकते हैं। नियमित पैरामीटर्स पहले आते हैं:
def describe(title, *tags, **metadata):
print(f"{title} | tags: {tags} | meta: {metadata}")
describe("Python intro", "beginner", "python", author="अरुण", year=2024)*args किसी भी संख्या में अतिरिक्त पोजिशनल आर्गुमेंट्स को एक ट्यूपल के रूप में लेता है, **kwargs अतिरिक्त नाम दिए गए को एक डिक्ट के रूप में लेता है। शब्द args और kwargs केवल सम्मेलन हैं, * और ** वास्तविक काम करते हैं। सुविधाजनक जब आप आगे कह नहीं सकते कि कितनी चीज़ें आती हैं। डॉकस्ट्रिंग्स
एक डॉकस्ट्रिंग एक फ़ंक्शन के शीर्ष पर एक स्ट्रिंग है जो वर्णन करता है कि यह क्या करता है। Python संपादक और टूल्स इसे दिखाने के लिए उपयोग करते हैं जब आप एक फ़ंक्शन कॉल पर होते हैं। ट्रिपल कोट्स का उपयोग करें, और सरल फ़ंक्शन्स के लिए एक लाइन लिखें।
def normalise(value, min_val, max_val):
"""दिए गए न्यूनतम और अधिकतम के अनुसार एक वैल्यू को 0-1 रेंज में स्केल करें।"""
return (value - min_val) / (max_val - min_val)def build_url(base, version, resource, *, secure=True):
"""
एक API एंडपॉइंट URL बनाएं।
एक पूरी तरह से योग्य URL स्ट्रिंग रिटर्न करता है। अगर secure False है,
URL http के बजाय https का उपयोग करेगा।
"""
scheme = "https" if secure else "http"
base = base.replace("https://", "").replace("http://", "")
return f"{scheme}://{base}/{version}/{resource}"किसी भी फ़ंक्शन के लिए एक डॉकस्ट्रिंग लिखें जिसका उद्देश्य इसके नाम और हस्ताक्षर से स्पष्ट नहीं है।
टाइप हिंट्स
टाइप हिंट्स आपको यह एनोटेट करने देते हैं कि एक फ़ंक्शन क्या प्रकार की अपेक्षा करता है और क्या रिटर्न करता है। Python उन्हें रनटाइम पर लागू नहीं करता है, लेकिन संपादक उन्हें आप कुछ भी चलाने से पहले गलतियों को पकड़ने के लिए उपयोग करते हैं। कोलन से पहले -> रिटर्न प्रकार को निर्दिष्ट करता है।
def greet(name: str, score: int) -> str:
return f"{name} scored {score}"def log(message: str) -> None:
print(f"[LOG] {message}")def top_scores(scores: list[int], n: int) -> list[int]:
return sorted(scores, reverse=True)[:n]टाइप हिंट्स ऑप्शनल हैं लेकिन कई जगह से कॉल किए जाने वाले किसी भी फ़ंक्शन पर मूल्यवान हैं। वे डॉक्यूमेंटेशन हैं जो टूल्स सत्यापन कर सकते हैं।
name: str और `-> str` रिटर्न के लिए। Python इसे चलाते समय लागू नहीं करेगा, लेकिन आपका संपादक इसे पढ़ता है और आपको चलाने से पहले चेतावनी देता है। उन्हें टूल्स के रूप में सोचें जो जाँच सकते हैं। फ़ंक्शन्स को वैल्यूज़ के रूप में
Python में फ़ंक्शन्स वैल्यूज़ हैं, स्ट्रिंग्स या संख्या की तरह। आप उन्हें वेरिएबल्स को असाइन कर सकते हैं और उन्हें दूसरे फ़ंक्शन्स को पास कर सकते हैं। यह है कि कैसे sorted() एक key= फ़ंक्शन को स्वीकार करता है।
def double(x):
return x * 2
def apply(func, value):
return func(value)
apply(double, 5) # 10फ़ंक्शन्स को आर्गुमेंट्स के रूप में पास करना sorted(), map(), और filter() के साथ लगातार दिखाई देता है। आप इसे Lambdas and comprehensions अध्याय में भी देखेंगे।
व्यावहारिक में
दो फ़ंक्शन्स जो एक साथ काम करते हैं: letter_grade एक स्कोर को एक अक्षर में परिवर्तित करता है, और summarise इसे एक लिस्ट में हर स्कोर के लिए कॉल करता है:
def letter_grade(score: int) -> str:
if score >= 90:
return "A"
elif score >= 80:
return "B"
elif score >= 70:
return "C"
else:
return "F"
def summarise(scores: list[int]) -> None:
total = sum(scores)
avg = total / len(scores)
grades = []
for s in scores:
grades.append(letter_grade(s))
print(f"Average: {avg:.1f}")
print(f"Grades: {', '.join(grades)}")
summarise([87, 92, 74, 65, 91])