फ़ंक्शन्स
जैसे-जैसे आपके प्रोग्राम बढ़ते हैं, आप एक ही लॉजिक को एक से अधिक स्थानों पर लिखेंगे। फ़ंक्शन्स आपको लॉजिक को एक बार लिखने, उसका नाम देने, और हर जगह उपयोग करने की अनुमति देते हैं। इसे एक जगह ठीक करें और हर कॉल को सुधार स्वचालित रूप से मिलेगा।
def greet(name):
return f"Hello, {name}!"
print(greet("आरव")) # "Hello, आरव!"
print(greet("प्रिया")) # "Hello, प्रिया!"एक बार लिखें, हर जगह उपयोग करें, एक जगह ठीक करें।
एक फ़ंक्शन को परिभाषित करना
def कीवर्ड एक फ़ंक्शन की परिभाषा शुरू करता है, उसके बाद नाम, कोष्ठक, एक कोलन, और एक इंडेंटेड बॉडी आता है। एक फ़ंक्शन तब तक कुछ नहीं करता जब तक आप उसे कॉल नहीं करते। इसे def के साथ परिभाषित करें, फिर इसे () के साथ नाम से कॉल करें।
def say_hello():
print("Hello!")
say_hello() # फ़ंक्शन को कॉल करेंपैरामीटर्स और आर्ग्युमेंट्स
पैरामीटर्स वे इनपुट हैं जिनकी आपका फ़ंक्शन अपेक्षा करता है। उन्हें कोष्ठक के अंदर सूचीबद्ध करें। जब आप फ़ंक्शन को कॉल करते हैं, तो आप जो मान पास करते हैं वे क्रम में पैरामीटर्स से मिलाए जाते हैं।
def greet(name, greeting):
print(f"{greeting}, {name}!")
greet("आरव", "Hello") # "Hello, आरव!"
greet("प्रिया", "Hi") # "Hi, प्रिया!"पैरामीटर्स बनाम आर्ग्युमेंट्स
पैरामीटर फ़ंक्शन परिभाषा में नाम है। आर्ग्युमेंट वह वास्तविक मान है जो आप फ़ंक्शन को कॉल करते समय पास करते हैं। व्यवहार में, लोग इन शब्दों का परस्पर उपयोग करते हैं। बस दस्तावेज़ पढ़ते समय अंतर के बारे में जागरूक रहें।
डिफ़ॉल्ट वैल्यूज़
आप पैरामीटर्स को एक डिफ़ॉल्ट वैल्यू दे सकते हैं। यदि कॉलर वह आर्ग्युमेंट प्रदान नहीं करता है, तो डिफ़ॉल्ट का उपयोग किया जाता है। डिफ़ॉल्ट वाले पैरामीटर्स बिना डिफ़ॉल्ट वाले पैरामीटर्स के बाद आने चाहिए।
def greet(name, greeting="Hello"):
print(f"{greeting}, {name}!")
greet("आरव") # "Hello, आरव!"
greet("आरव", "Hi") # "Hi, आरव!"डिफ़ॉल्ट वाले पैरामीटर्स बिना डिफ़ॉल्ट वाले पैरामीटर्स के बाद आने चाहिए।
कीवर्ड आर्ग्युमेंट्स
किसी फ़ंक्शन को कॉल करते समय, आप आर्ग्युमेंट्स को नाम दे सकते हैं। यह कॉल्स को पढ़ने योग्य बनाता है, विशेष रूप से कई पैरामीटर्स वाले फ़ंक्शन्स के लिए, और आपको उन्हें किसी भी क्रम में पास करने की अनुमति देता है।
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) # मिक्स: पोज़िशनल पहलेरिटर्न वैल्यूज़
return कॉलर को एक मान वापस भेजता है। return के बिना, एक फ़ंक्शन None वापस देता है। एक बार return चलता है, फ़ंक्शन तुरंत बाहर निकल जाता है। उस ब्लॉक में इसके बाद का कोई भी कोड छोड़ दिया जाता है।
def add(a, b):
return a + b
result = add(3, 4) # result = 7
print(result)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 प्रत्येक लौटाए गए मान को संबंधित नाम को असाइन करता है।
स्कोप
एक फ़ंक्शन के अंदर बनाए गए वेरिएबल्स केवल उस फ़ंक्शन के अंदर मौजूद होते हैं। आप उन्हें बाहर से नहीं देख सकते। सभी फ़ंक्शन्स के बाहर परिभाषित वेरिएबल्स हर जगह दिखाई देते हैं, लेकिन आप उन्हें एक स्पष्ट घोषणा के बिना एक फ़ंक्शन के अंदर से नहीं बदल सकते।
def calculate():
result = 42 # इस फ़ंक्शन के लिए लोकल
return result
calculate()
print(result) # NameError, result यहाँ बाहर मौजूद नहीं हैcount = 0
def increment():
global count # घोषित करें कि आप ग्लोबल को संशोधित करना चाहते हैं
count += 1
increment()
print(count) # 1global का उपयोग अंतिम उपाय होना चाहिए। यह कोड को समझना कठिन बनाता है। मानों को अंदर पास करना और बाहर लौटाना पसंद करें।
*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)डॉकस्ट्रिंग्स
एक डॉकस्ट्रिंग एक फ़ंक्शन के शीर्ष पर एक स्ट्रिंग है जो वर्णन करती है कि यह क्या करता है। Python संपादक और टूल्स इसका उपयोग तब सहायता दिखाने के लिए करते हैं जब आप किसी फ़ंक्शन कॉल पर होवर करते हैं। ट्रिपल कोट्स का उपयोग करें, और सरल फ़ंक्शन्स के लिए एक पंक्ति लिखें।
def normalise(value, min_val, max_val):
"""Scale a value to the 0-1 range given the known min and max."""
return (value - min_val) / (max_val - min_val)def build_url(base, version, resource, *, secure=True):
"""
Build an API endpoint URL.
Returns a fully-qualified URL string. If secure is False,
the URL will use http instead of 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]टाइप हिंट्स वैकल्पिक हैं लेकिन किसी भी फ़ंक्शन पर मूल्यवान हैं जिसे कई स्थानों से कॉल किया जाएगा। वे दस्तावेज़ीकरण हैं जिन्हें टूल्स सत्यापित कर सकते हैं।
मानों के रूप में फ़ंक्शन्स
Python में फ़ंक्शन्स मान हैं, बिल्कुल स्ट्रिंग्स या संख्याओं की तरह। आप उन्हें वेरिएबल्स को असाइन कर सकते हैं और उन्हें अन्य फ़ंक्शन्स को पास कर सकते हैं। इसी तरह sorted() एक key= फ़ंक्शन को स्वीकार करता है।
def double(x):
return x * 2
def apply(func, value):
return func(value)
apply(double, 5) # 10आर्ग्युमेंट्स के रूप में फ़ंक्शन्स पास करना sorted(), map(), और filter() के साथ लगातार दिखाई देता है। आप इसे Lambda, comprehensions, and zip अध्याय में भी देखेंगे।
व्यवहार में
दो फ़ंक्शन्स जो एक साथ काम करते हैं: 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 = [letter_grade(s) for s in scores]
print(f"Average: {avg:.1f}")
print(f"Grades: {', '.join(grades)}")
summarise([87, 92, 74, 65, 91])