R.I.B.H.U. Academy - Conference & Showcase

कंस्ट्रक्टर विधियाँ

टपल (Tuple) डेटा-प्रकार के लिए केवल दो विधियाँ हैं: count() और index()। आप में से कई (पाठक) यह तर्क दे सकते हैं कि प्रत्येक अंतर्निहित (built-in) फ़ंक्शन के लिए बहुत सारी विधियाँ दिखाई गई हैं, जब उन (str, int, float, bool, list, tuple, आदि में से प्रत्येक,) को dir() कोष्ठक के भीतर रखा गया, और print() फ़ंक्शन के साथ कोड (फ़ाइल में) सहेजने के बाद, पायथन सीएलआई >>> या कमांड प्रॉम्प्ट C:\xampp\htdocs\python2023> (या आपके प्रोजेक्ट फ़ोल्डर) में निष्पादित किया गया है।

print( dir( tuple ) )

print( help( tuple ) )

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

उदाहरण के लिए, __add__() यह परिभाषित करता है कि दो या दो से अधिक ऑपरेंड को + प्रतीक के साथ कैसे जोड़ा जाएगा (जो bool, int, float, complex, list, tuple, string, bytearray, bytes डेटा के प्रकार के लिए उपलब्ध है)। इसी प्रकार, __mul__() विधि परिभाषित करती है कि bool, int, float, complex, list, tuple, string, bytearray, bytes डेटा-प्रकार में कोई भी कैसे पूर्णांक (integer) मान से गुणा किया जाता है। एक संख्यात्मक डेटा-प्रकार, जैसे कि बूलियन, पूर्णांक या फ्लोट को बूलियन और फ्लोट डेटा-प्रकारों के साथ भी जोड़ा (addition) और गुणा (multiplication) किया जा सकता है।

हालाँकि, एक स्ट्रिंग, सूची या टपल शाब्दिक को केवल समान डेटा-प्रकार के साथ (या तो + प्रतीक या __add__() विधि के साथ) संयोजित (concatenate) किया जा सकता है। अर्थात्, एक स्ट्रिंग शाब्दिक को केवल एक स्ट्रिंग डेटा-प्रकार के साथ जोड़ा जा सकता है। एक सूची शाब्दिक को केवल एक सूची डेटा-प्रकार के साथ जोड़ा जा सकता है। एक टपल शाब्दिक को केवल एक टपल डेटा-प्रकार के साथ जोड़ा जा सकता है। इसके अलावा, एक स्ट्रिंग, सूची या टुपल शाब्दिक को गैर-int (पूर्णांक डेटा-प्रकार के अलावा अन्य) से गुणा करने पर त्रुटि दिखाई देगी।

print( help( tuple.__add__ ) )

Help on wrapper_descriptor:

__add__(self, value, /)
Return self+value.

None

print( help( tuple.__mul__ ) )

Help on wrapper_descriptor:

__mul__(self, value, /)
Return self*value.

None

उदाहरण 1

my_tuple = (1, 2, 3, 4)
new_tuple = (5, 6)
modified_tuple = tuple.__add__( my_tuple, new_tuple )
adding_tuples = my_tuple + new_tuple

print( my_tuple, new_tuple )
print( modified_tuple )
print( adding_tuples )

multi_tuple = tuple.__mul__( my_tuple, 3 )
many_tuple = my_tuple * 3

print( multi_tuple )
print( many_tuple )

(1, 2, 3, 4) (5, 6)
(1, 2, 3, 4, 5, 6)
(1, 2, 3, 4, 5, 6)
(1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4)
(1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4)

उपरोक्त आउटपुट में पहली पंक्ति दो अलग-अलग टुपल्स दिखाती है।

उदाहरण 2

print( (1, 2, 3, 4).__add__( (5, 6) ) ) # आउटपुट (1, 2, 3, 4, 5, 6) (ऊपर की तरह) है।

print( (1, 2, 3, 4).__mul__( 3 ) ) # आउटपुट (1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4) (ऊपर की तरह) है।

उदाहरण 3

print( "hello" + " world" ) # आउटपुट hello world है।

print( "hello" * 5 ) # आउटपुट hellohellohellohellohello है।

उदाहरण 4

print( [1, 2, 3] + [4, 5, 6] ) # आउटपुट [1, 2, 3, 4, 5, 6] है।

print( [1, 2, 3] * 4 ) # आउटपुट [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3] है।

ये ऊपर बताए गए तरीके हैं, जिनमें आप स्ट्रिंग्स, सूचियाँ या टुपल्स जोड़ या गुणा कर सकते हैं। हालाँकि, इन कंस्ट्रक्टर विधियों का उपयोग गैर-संख्यात्मक डेटा-प्रकारों के लिए शायद ही किया जाता है। (पुराने दिनों में, प्रोग्रामर इन तरीकों की मदद से अपने प्रोग्राम को आकर्षक बनाते थे, उदाहरण के लिए −
******************************** (कई तारांकन) or
================================ दस्तावेज़ में विभाजक (divider/separator) दिखाने के लिए कई अन्य चिन्ह, जैसा कि एटलस में विभिन्न सीमाओं borders के लिए वर्णित होता है!)

जब आप विभिन्न डेटा-प्रकारों के लिए एक ही नाम की कंस्ट्रक्टर विधियों की तुलना करते समय ध्यान से अध्ययन (जांच) करेंगे, तो आपको आश्चर्य होगा कि, कई विधियाँ अन्य डेटा-प्रकारों के लिए उपलब्ध नहीं हो सकती हैं। उदाहरण के लिए __add__() और __mul__() विधियाँ dictionary, set, frozenset, memoryview डेटा के प्रकार उपलब्ध नहीं हैं।

विभिन्न डेटा-प्रकारों के लिए उपलब्ध __len__ विधि का अर्थ है कि len() अंतर्निहित फ़ंक्शन को उस विशेष डेटा-प्रकार पर लागू किया जा सकता है। आप पिछले पृष्ठ में पहले ही देख चुके हैं कि len() फ़ंक्शन को संख्याओं और बूलियन पर लागू नहीं किया जा सकता है। कुछ कंस्ट्रक्टर विधियाँ और उनके संबंधित समकक्ष ऑपरेटर नीचे दिखाए गए हैं।

`__add__`	`__mul__`	`__ge__`	`__gt__`	`__le__`	`__lt__`
`+`	`*`	`>=`	`>`	`<=`	`<`

`__iadd__`	`__imul__`	`__eq__`	`__ne__`	`__len__`	`x.__getitem__(y)`
`+=`	`*=`	`==`	`!=`	`len()`	`x[y]`

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

इसी प्रकार, x.__setitem__(y, मान) विधि (केवल list, dictionary, bytearray और memoryview डेटा-प्रकारों के लिए उपलब्ध) x[y] = value के बराबर है, और किसी आइटम/तत्व का मूल्य या तो x.__setitem__(y, मान) या x[y] = value उपयोग करके बदला जा सकता है।

print( help( tuple.__sizeof__ ) )

Help on method_descriptor:

__sizeof__(self, /)
Size of object in memory, in bytes.

None

उदाहरण 1 (जारी)

print( tuple.__sizeof__( my_tuple ) )
print( tuple.__sizeof__( new_tuple ) )
print( tuple.__sizeof__( modified_tuple ) )
print( tuple.__sizeof__( adding_tuples ) )

56
40
72
72

__sizeof__() विधि कोष्ठक के भीतर कोई तर्क नहीं लेता हैं, और (रैम में ऑब्जेक्ट का) मेमोरी आकार बाइट्स में आउटपुट करता हैं।

print( (1, 2, 3, 4).__mul__( 3 ).__sizeof__() ) # आउटपुट 120 है। यह भिन्न हो सकता है क्योंकि अलग-अलग ऑपरेटिंग सिस्टम आउटपुट के मूल्य को अलग-अलग तरीके से संग्रहीत करते हैं!

आप देख सकते हैं कि प्रत्येक डेटा-प्रकार के लिए __dir__ और __doc__ विधियाँ उपलब्ध हैं। __dir__ विधि dir() अंतर्निहित फ़ंक्शन के बराबर है। __doc__ विधि जब कुछ डेटा-प्रकार शाब्दिक, या उन डेटा-प्रकारों के लिए अंतर्निहित फ़ंक्शंस का अनुसरण (follows) करती है, उदाहरण के लिए, print( tuple.__doc__ ) तो print( help( tuple ) ) के डॉकस्ट्रिंग (पहली कुछ पंक्तियाँ) परिचय को आउटपुट करता है। आप कस्टम फ़ंक्शंस और उनके डॉकस्ट्रिंग्स बनाते समय __doc__ विधि के बारे में अधिक जानेंगे।

print( help( tuple.__dir__ ) )

Help on method_descriptor:

__dir__(self, /)
Default dir() implementation.

None

पूर्णांकों, फ़्लोट्स, बूलियन्स आदि के लिए अन्य कंस्ट्रक्टर विधियाँ।

`__abs__`	`__and__`	`__bool__`	`__float__`	`__floordiv__`	`__int__`
`abs()`	`&`	`True` except 0 which is False	`float()`	`//`	`int()`

print( help( int.__pos__ ) )

Help on wrapper_descriptor:

__pos__(self, /)
+self

None

print( help( int.__neg__ ) )

Help on wrapper_descriptor:

__neg__(self, /)
-self

None

__pos__ और __neg__ विधियाँ किसी संख्या के सकारात्मक और नकारात्मक चरित्र को परिभाषित करते हैं। किसी भी संख्या या संख्यात्मक स्ट्रिंग से पहले + और - चिह्न लगाकर (सकारात्मक) पहचान और निषेध (नकारात्मक) किया जा सकता है। उदाहरण के लिए, +1 (अन्य प्रोग्रामिंग भाषाओं में 1 की पहचान identity) और -1 (1 का निषेध negation) आमतौर पर गणितीय कार्यों में उपयोग किया जाता है। ये दोनों __add__ (जोड़ ऑपरेटर) और __sub__ (घटाव ऑपरेटर) से भिन्न हैं, जो दो तर्क (operands) लेते हैं (self और value − ऊपर देखें)।

यह जानने के लिए कि किसी अंतर्निहित फ़ंक्शन या विधि को किसी विशेष डेटा-प्रकार पर लागू किया जा सकता है या नहीं, नियमित रूप से help() और dir() अंतर्निहित फ़ंक्शन्स को पढ़ना और जांचना उपयोगी है। हालाँकि, इन कंस्ट्रक्टर विधियों का सख्ती से उपयोग करने की अनुशंसा (recommend) नहीं की जाती है! उदाहरण के लिए, संयोजन (concatenation), काटना (slicing), निष्कर्षण (extraction), जोड़ (addition), गुणा (multiplication), सकारात्मकता (पहचान), नकारात्मकता (निषेध), आदि आसानी से संबंधित ऑपरेटरों और विन्यासों (syntaxes) के साथ किया जा सकता है।

R.I.B.H.U. Academy^®

Recreative Interaction on Biodiversity & Humanity Universe ^*

Please support if you like my work by payment through upi: sinhamit@icici or payment by bank

account name: Amit Kumar Sinha,
account number: 2646728782
IFSC code: KKBK0005660
SWIFT: KKBKINBB

Tuple Methods in Category: पाइथन by amit