पायथन बिल्ट-इन फंक्शंस
पायथन बिल्ट-इन फंक्शंस पायथन द्वारा प्रदान किए गए पूर्वनिर्मित उपकरण हैं, जिन्हें उपयोग करने के लिए किसी अतिरिक्त लाइब्रेरी को आयात करने की आवश्यकता नहीं होती। ये फंक्शंस डेटा स्ट्रक्चर प्रबंधन, प्रकार रूपांतरण, गणना, ऑब्जेक्ट हैंडलिंग और डायनेमिक कोड निष्पादन जैसी कई कार्यक्षमताएँ प्रदान करते हैं। बैकएंड विकास में इनका महत्व इसलिए है क्योंकि ये कोड की पठनीयता बढ़ाते हैं, विकास समय कम करते हैं और प्रदर्शन को अनुकूलित करते हैं। इनका उपयोग तब किया जाता है जब डेटा का विश्लेषण, फ़िल्टरिंग, सॉर्टिंग या एग्रीगेशन करना हो। मुख्य अवधारणाओं में सही सिंटैक्स, एल्गोरिदम का कुशल उपयोग, डेटा स्ट्रक्चर प्रबंधन और OOP सिद्धांतों का पालन शामिल है। इन फंक्शंस का सही उपयोग करके डेवलपर्स मेमोरी लीक, त्रुटि हैंडलिंग समस्याएँ और गैर-कुशल एल्गोरिदम जैसी सामान्य समस्याओं से बच सकते हैं। इस गाइड के माध्यम से पाठक सीखेंगे कि कैसे पायथन के बिल्ट-इन फंक्शंस का सही उपयोग करके सुरक्षित, उच्च प्रदर्शन और स्केलेबल बैकएंड सिस्टम बनाएँ।
एक व्यावहारिक उदाहरण ई-कॉमर्स ऑर्डर प्रोसेसिंग है। मान लें कि हमें कुल बिक्री, उच्चतम और न्यूनतम ऑर्डर, वीआईपी ग्राहक फ़िल्टरिंग और बड़े ऑर्डर की जांच करनी है। इसके लिए हम sum, max, min, filter, sorted और any का उपयोग करेंगे। sum कुल राशि जोड़ता है, max और min चरम मान निर्धारित करते हैं, filter वीआईपी ऑर्डर अलग करता है, sorted राशि के आधार पर सूची क्रमबद्ध करता है, और any बड़ी ऑर्डर की उपस्थिति जांचता है। यह उदाहरण दिखाता है कि कैसे बिल्ट-इन फंक्शंस लिस्ट और डिक्शनरी के साथ कुशलतापूर्वक काम करते हैं, जिससे जटिल लूप की आवश्यकता नहीं रहती। वास्तविक बैकएंड अनुप्रयोगों में यह रिपोर्टिंग, डेटा एनालिटिक्स और रियल-टाइम प्रोसेसिंग को सरल बनाता है। बिल्ट-इन फंक्शंस की समझ और सही उपयोग डेवलपर्स को परफॉर्मेंट और सुरक्षित डेटा पाइपलाइन बनाने में सक्षम बनाता है।
Example
python# उदाहरण: ई-कॉमर्स ऑर्डर विश्लेषण
orders = \[
{"user": "Amit", "amount": 120},
{"user": "Ravi", "amount": 80},
{"user": "Sneha", "amount": 200},
{"user": "Neha", "amount": 50}
]
# कुल बिक्री
total_sales = sum(order\["amount"] for order in orders)
# उच्चतम और न्यूनतम ऑर्डर
highest_order = max(orders, key=lambda o: o\["amount"])
lowest_order = min(orders, key=lambda o: o\["amount"])
# वीआईपी ऑर्डर फ़िल्टर
vip_orders = list(filter(lambda o: o\["amount"] >= 100, orders))
# ऑर्डर राशि के अनुसार सॉर्ट
sorted_orders = sorted(orders, key=lambda o: o\["amount"], reverse=True)
# बड़ी ऑर्डर मौजूद है?
has_big_order = any(o\["amount"] > 150 for o in orders)
print("कुल बिक्री:", total_sales)
print("उच्चतम ऑर्डर:", highest_order)
print("न्यूनतम ऑर्डर:", lowest_order)
print("वीआईपी ऑर्डर:", vip_orders)
print("सॉर्टेड ऑर्डर:", sorted_orders)
print("बड़ी ऑर्डर मौजूद है:", has_big_order)📊 Comprehensive Reference
| फ़ंक्शन | विवरण | सिंटैक्स | उदाहरण | टिप्पणियाँ |
|---|---|---|---|---|
| abs | संख्या का पूर्णांक मान | abs(x) | abs(-5) → 5 | int, float, complex |
| all | सभी तत्व सत्य हैं या नहीं | all(iterable) | all(\[1,True,3]) → True | खाली सूची → True |
| any | कम से कम एक तत्व सत्य है | any(iterable) | any(\[0,False,5]) → True | खाली सूची → False |
| ascii | ASCII प्रतिनिधित्व | ascii(obj) | ascii("हिंदी") → "'\u0939\u093f\u0928\u094d\u0926\u0940'" | डिबगिंग |
| bin | बाइनरी प्रतिनिधित्व | bin(x) | bin(5) → '0b101' | केवल int |
| bool | बूलियन में बदलना | bool(x) | bool("") → False | Python की सच्चाई मानकों का पालन |
| bytearray | बदलने योग्य बाइटस | bytearray(\[65,66]) | bytearray(b'AB') | बाइनरी डेटा |
| bytes | अपरिवर्तनीय बाइटस | bytes("abc","utf-8") | b"abc" | नेटवर्क/फाइल |
| callable | कॉल करने योग्य है या नहीं | callable(obj) | callable(len) → True | call वाले ऑब्जेक्ट |
| chr | यूनिकोड कैरेक्टर | chr(i) | chr(65) → 'A' | ord का विपरीत |
| classmethod | क्लास मेथड बनाना | @classmethod | class C: @classmethod def f(cls): pass | क्लास आधारित |
| compile | स्रोत कोड कम्पाइल | compile(source,filename,mode) | exec(compile("print(5)","","exec")) | eval/exec के लिए |
| complex | कॉम्प्लेक्स नंबर बनाना | complex(real,imag) | complex(2,3) → (2+3j) | या स्ट्रिंग से |
| delattr | एट्रिब्यूट हटाएँ | delattr(obj,name) | delattr(o,"x") | del o.x के बराबर |
| dict | डिक्शनरी बनाना | dict(a=1,b=2) | {"a":1,"b":2} | संरचित डेटा |
| dir | एट्रिब्यूट सूची | dir(obj) | dir(\[]) | डिबग/इंट्रोस्पेक्शन |
| divmod | कोटिएंट और रिमेंडर | divmod(a,b) | divmod(7,3) → (2,1) | a//b,a%b के बजाय |
| enumerate | इंडेक्सेड इटरेटर | enumerate(iterable) | list(enumerate(\["a","b"])) | लूप के लिए |
| eval | एक्सप्रेशन का मूल्यांकन | eval(expr) | eval("3+5") → 8 | सुरक्षा खतरा |
| exec | Python कोड चलाएँ | exec(obj) | exec("x=5") | डायनामिक कोड |
| filter | सिक्वेंस फ़िल्टर | filter(func,iterable) | list(filter(lambda x:x>0,\[-1,2])) | इटरेटर लौटाता है |
| float | फ्लोट में बदलना | float(x) | float("3.14") → 3.14 | स्ट्रिंग या संख्या से |
| format | मान फॉर्मेट करना | format(value, format_spec) | format(255,"x") → 'ff' | str.format का विकल्प |
| frozenset | अपरिवर्तनीय सेट | frozenset(iterable) | frozenset(\[1,2,3]) | dict की key हो सकती है |
| getattr | एट्रिब्यूट पढ़ना | getattr(obj,name\[,default]) | getattr(str,"upper") | AttributeError से बचता है |
| globals | ग्लोबल नेमस्पेस | globals() | globals()\["name"] | डिबगिंग |
| hasattr | एट्रिब्यूट मौजूद है? | hasattr(obj,name) | hasattr(\[], "append") → True | इंट्रोस्पेक्शन |
| hash | हैश मान | hash(obj) | hash("abc") | नॉन-हैशेबल ऑब्जेक्ट पर त्रुटि |
| help | इंटरएक्टिव मदद | help(obj) | help(len) | केवल इंटरएक्टिव |
| hex | हेक्साडेसिमल | hex(x) | hex(255) → '0xff' | डिबग |
| id | यूनिक पहचान | id(obj) | id(123) | मेमोरी एड्रेस |
| input | यूजर इनपुट | input(prompt) | input("नाम:") | केवल इंटरएक्टिव |
| int | int में बदलना | int(x) | int("10") → 10 | आधार विकल्प |
| isinstance | ऑब्जेक्ट का प्रकार | isinstance(obj,cls) | isinstance(5,int) → True | एकाधिक क्लास संभव |
| issubclass | इन्हेरिटेंस चेक | issubclass(C,D) | issubclass(bool,int) | True/False |
| iter | इटरेटर लौटाएँ | iter(obj) | iter(\[1,2,3]) | लूप के लिए |
| len | लंबाई | len(obj) | len(\[1,2,3]) → 3 | सभी सिक्वेंस |
| list | लिस्ट बनाना | list(iterable) | list("abc") → \["a","b","c"] | टाइप कन्वर्ज़न |
| locals | लोकल नेमस्पेस | locals() | locals()\["x"] | डिबग |
| map | फंक्शन लागू करें | map(func,iterable) | list(map(str,\[1,2])) | इटरेटर लौटाता है |
| max | मैक्सिमम | max(iterable) | max(\[1,3,2]) → 3 | key फ़ंक्शन के साथ |
| memoryview | मेमोरी व्यू | memoryview(obj) | memoryview(b"abc")\[0] | बड़े डेटा के लिए |
| min | मिनिमम | min(iterable) | min(\[1,3,2]) → 1 | key फ़ंक्शन के साथ |
| next | अगला तत्व | next(iterator\[,default]) | next(iter(\[1,2])) | डिफ़ॉल्ट विकल्प |
| object | बेस ऑब्जेक्ट | object() | o=object() | सभी क्लासेस का बेस |
| oct | ऑक्टल | oct(x) | oct(8) → '0o10' | डिबग |
| open | फ़ाइल खोलें | open(file,mode) | open("a.txt","w") | close आवश्यक |
| ord | यूनिकोड कोड | ord(c) | ord("A") → 65 | chr का विपरीत |
| pow | घातांक | pow(x,y\[,mod]) | pow(2,3) → 8 | वैकल्पिक modulo |
| आउटपुट | print(obj) | print("नमस्ते") | मल्टीपल आर्ग्युमेंट | |
| property | प्रॉपर्टी बनाना | property(fget,fset) | class C: x=property(...) | एनकैप्सुलेशन |
| range | इंटेगर इटरेटर | range(start,stop,step) | list(range(3)) → \[0,1,2] | लूप के लिए |
| repr | स्ट्रिंग प्रतिनिधित्व | repr(obj) | repr(\[1,2]) | डिबग |
| reversed | रिवर्स इटरेटर | reversed(seq) | list(reversed(\[1,2])) → \[2,1] | इटरेटर लौटाता है |
| round | राउंडिंग | round(x\[,n]) | round(3.14159,2) → 3.14 | वैकल्पिक n |
| set | सेट | set(iterable) | set(\[1,2,2]) → {1,2} | डुप्लीकेट हटाता है |
| setattr | एट्रिब्यूट सेट | setattr(obj,name,value) | setattr(o,"x",5) | o.x=5 के बराबर |
| slice | स्लाइस ऑब्जेक्ट | slice(start,stop,step) | \[1,2,3]\[slice(1,3)] | सिक्वेंस के लिए |
| sorted | सॉर्टेड लिस्ट | sorted(iterable) | sorted(\[3,1,2]) → \[1,2,3] | key फ़ंक्शन के साथ |
| staticmethod | स्टैटिक मेथड | @staticmethod | class C: @staticmethod def f(): pass | क्लास आधारित |
| str | स्ट्रिंग में बदलना | str(obj) | str(123) → '123' | टाइप कन्वर्ज़न |
| sum | योग | sum(iterable\[,start]) | sum(\[1,2,3]) → 6 | केवल नंबर |
| super | पेरेंट मेथड कॉल | super() | super().method() | OOP |
| tuple | टपल बनाना | tuple(iterable) | tuple("ab") → ("a","b") | अपरिवर्तनीय |
| type | टाइप या क्लास | type(obj) | type(5) → int | डायनामिक क्लास संभव |
| vars | एट्रिब्यूट लौटाएँ | vars(obj) | vars(str) | इंट्रोस्पेक्शन |
| zip | मल्टीपल इटरेबल | zip(*iterables) | list(zip(\[1,2],\[3,4])) | इटरेटर लौटाता है |
| import | डायनामिक इम्पोर्ट | import("os") | import("math").sqrt(4) | सीधा कम उपयोग |
🧠 अपने ज्ञान की परीक्षा करें
अपने ज्ञान का परीक्षण करें
पायथन बिल्ट-इन फंक्शंस की आपकी समझ का परीक्षण करें
📝 निर्देश
- हर प्रश्न को ध्यान से पढ़ें
- हर प्रश्न के लिए सबसे अच्छा उत्तर चुनें
- आप जितनी बार चाहें क्विज़ दोबारा दे सकते हैं
- आपकी प्रगति शीर्ष पर दिखाई जाएगी