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

कुछ और अंतर्निहित फ़ंक्शंस

enumerate(iterable, start=0)

क्लास एन्यूमरेट(ऑब्जेक्ट) - एक एन्यूमरेट ऑब्जेक्ट लौटाएं। पुनरावृत्ति का समर्थन करने वाला एक ऑब्जेक्ट।

    एन्युमरेट ऑब्जेक्ट जोड़े उत्पन्न करता है जिसमें एक गिनती (शुरुआत से, जो शून्य पर डिफ़ॉल्ट है) और पुनरावृत्त (iterable) तर्क द्वारा उत्पन्न एक मान होता है।

सूचकांक सूची प्राप्त करने के लिए enumerate उपयोगी है: (0, seq[0]), (1, seq[1]), (2, seq[2]), ...

उदाहरण 1

list_1 = ['a', 'b', 'c']
for index, item in enumerate(list_1, start=1):
    print( index, item )         # प्रत्येक आइटम/तत्व का सूचकांक संख्या +1 और उसका संबंधित मूल्य आउटपुट करता है, जैसा कि नीचे दिखाया गया है:

1 a
2 b
3 c

zip(object)

zip(*iterables, strict=False) --> इनपुट समाप्त होने तक टुपल्स उत्पन्न करें।

list(zip('abcdefg', range(3), range(4))) # [('a', 0, 0), ('b', 1, 1), ('c', 2, 2) ]

    zip ऑब्जेक्ट n-लंबाई टुपल्स उत्पन्न करता है, जहां n zip() के लिए स्थितीय तर्क के रूप में पारित किए गए पुनरावृत्तों (iterables) की संख्या है। प्रत्येक टुपल में i-th तत्व i-th पुनराव­र्तनीय तर्क से zip() तक आता है। यह तब तक जारी रहता है जब तक कि सबसे छोटा तर्क समाप्त न हो जाए। यदि strict True है और एक तर्क दूसरों के सामने समाप्त हो गया है, तो एक ValueError दिखाया जाएगा।

उदाहरण 2

list_1 = ['a', 'b', 'c']
list_2 = ['x', 'y', 'z']
zip_obj = zip(list_1, list_2)
print( zip_obj )             # आउटपुट <zip object at 0x0000013DA8235240> है।
print( list(zip_obj) )    # आउटपुट [('a', 'x'), ('b', 'y'), ('c', 'z')] है।

    उपरोक्त उदाहरण में, यदि दोनों list_1 या list_2 में से आइटम्स/तत्वों की कुल संख्या मेल नहीं खाता है (अर्थात, वे आइटम कम या ज्यादा हैं), कोई त्रुटि नहीं दिखाई जाएगी, जब तक कि आप (कोष्ठक के भीतर सभी पुनराव­र्तनीय iterables पारित होने के बाद) अंतिम तर्क True प्रदान नहीं करते। zip() अंतर्निहित फ़ंक्शन में अंतिम तर्क strict के लिए डिफ़ॉल्ट मान False है। केवल वे आइटम आउटपुट में शामिल किए जाते हैं, जो सभी पुनराव­र्तनीयों के (पहले) समान सूचकांक संख्या में हैं।

उदाहरण 3

    निम्नलिखित उदाहरण 3 में, आप पहले for लूप के अंदर, वेरिएबल i जोड़ सकते हैं, यानी print() फ़ंक्शन में, persons[i] से पहले, और आपको वही आउटपुट मिलेगा जो enumerate() बिल्ट-इन फ़ंक्शन देता है। जब आप नेस्टेड for लूप को टिप्पणी हटाते (अनकम्मेंट करते) हैं, तो स्ट्रिंग डेटा का प्रत्येक अक्षर प्रदर्शित होता है। आप विभिन्न तरीकों से प्रयोग कर सकते हैं, जैसा कि निम्न­लिखित उदाहरण के दूसरे for लूप में दिखाया गया है।

persons = ['abc', 'def', 'ghi', 'jkl', 'mno']
items = ['yz', 'vwx', 'stu', 'pqr']

for i in range(0, len(persons)):
    print(persons[i]) # i पूर्णांक डेटा-प्रकार है
    # for j in persons[i]:
    #    print(j)

for i in items:
    print(i, len(i))
    for j in i:
        print(j, len(j))

for index, item in enumerate(persons):
    print(index, item)     # यदि आप print() फ़ंक्शन से index (चर नाम) हटाते हैं, तो आउटपुट इस उदाहरण के पहले for लूप के समान होगा।

for i, j in zip(persons, items):
    print(i, j)

    enumerate() अंतर्निहित फ़ंक्शन को एक पुनरावृत्त (iterable) ऑब्जेक्ट पर लागू किया जाता है, अर्थात, एक सूची या टुपल में सूचकांक संख्या और संबंधित मान लाने के लिए। आप उदाहरण 1 (ऊपर दिखाया गया) में देख सकते हैं कि start पैरामीटर वैकल्पिक है, और जब इसका मान प्रदान नहीं किया जाता है, तो सूचकांक संख्या 0 (शून्य) से शुरू होगी। उदाहरण 3 में तीसरे for लूप का आउटपुट नीचे देखें।

    और, आम तौर पर एक डिक्शनरी बनाने के लिए, zip() अंतर्निहित फ़ंक्शन दो पुनराव­र्तनीय ऑब्जेक्ट (iterables) पर लागू किया जाता है (आप इसे तीन या अधिक पुनराव­र्तनीय ऑब्जेक्ट पर भी लागू कर सकते हैं)। बड़ी मात्रा में डेटा संसाधित होने पर कुंजी:मान जोड़े के मैन्युअल निर्माण से बचने के लिए इन बिल्ट-इन फ़ंक्शंस और उनकी विधियों (अन्य डेटा-प्रकारों और मॉड्यूल के भी) का उपयोग किया जाता है। एक अच्छा प्रोग्राम इस प्रकार लिखा जाता है कि प्रोग्रामर और उपयोग­कर्ता लिखें कम, अधिक करें!

उदाहरण 3 में पहले for लूप का आउटपुट

abc
def
ghi
jkl
mno

उदाहरण 3 में दूसरे for लूप का आउटपुट

yz 2
y 1
z 1
vwx 3
v 1
w 1
x 1
stu 3
s 1
t 1
u 1
pqr 3
p 1
q 1
r 1

उदाहरण 3 में तीसरे for लूप का आउटपुट

0 abc
1 def
2 ghi
3 jkl
4 mno

उदाहरण 3 में चौथे for लूप का आउटपुट

abc yz
def vwx
ghi stu
jkl pqr

min(...)

    एकल पुनराव­र्तनीय तर्क के साथ, इसकी सबसे छोटी वस्तु (आइटम) लौटाएँ। डिफ़ॉल्ट कीवर्ड-ओनली तर्क किसी ऑब्जेक्ट को निर्दिष्ट करता है कि यदि प्रदान किया गया पुनराव­र्तनीय खाली है तो वापस लौटाया जाए। दो या दो से अधिक तर्कों के साथ, सबसे छोटा तर्क लौटाएँ।

min(पुनरावर्तनीय, *[, डिफ़ॉल्ट=obj, कुंजी=func]) -> मान

min(arg1, arg2, *args, *[, key=func]) -> मान

उदाहरण 4

list_1 = ['a', 'b', 'c']
print( min(list_1) )   # आउटपुट a है।
print( min( 23, 34, 12, 43, 61, 56 ) )   # आउटपुट 12 है।

max(...)

    एकल पुनराव­र्तनीय तर्क के साथ, इसकी सबसे बड़ी वस्तु (आइटम) लौटाएँ। डिफ़ॉल्ट कीवर्ड-ओनली तर्क किसी ऑब्जेक्ट को निर्दिष्ट करता है कि यदि प्रदान किया गया पुनराव­र्तनीय खाली है तो वापस लौटाया जाए। दो या दो से अधिक तर्कों के साथ, सबसे बड़ा तर्क लौटाएँ।

max(पुनरावर्तनीय, *[, डिफ़ॉल्ट=obj, key=func]) -> मान

max(arg1, arg2, *args, *[, key=func]) -> मान

उदाहरण 5

list_1 = ['a', 'b', 'c']
print( max(list_1) )   # आउटपुट c है।
print( max( 23, 34, 12, 43, 61, 56 ) )   # आउटपुट 61 है।

sorted(पुनरावर्तनीय, /, *, key=None, reverse=False)

    एक नई सूची लौटाएँ जिसमें पुनराव­र्तनीय (iterable) से सभी आइटम आरोही (ascen­ding) क्रम में हों। सॉर्ट क्रम को अनुकूलित करने के लिए एक कस्टम कुंजी फ़ंक्शन प्रदान किया जा सकता है, और परिणाम को अवरोही (desce­nding) क्रम में अनुरोध करने के लिए रिवर्स (reverse) फ़्लैग सेट किया जा सकता है।

    आप सहायता प्राप्त करें पृष्ठ (के नीचे) में देख सकते हैं कि sort सूची (list) विधि None वापस करता है। लेकिन sorted() अंतर्निर्मित फ़ंक्शन उन सभी आइटम्स (items) को (उन्हें क्रमबद्ध करने के बाद), एक नया सूची (list) वापस (रिटर्न) देता है जब तर्क के रूप में पुनरावर्तनीय (सूची/ट्यूपल) कोष्ठक के भीतर पारित किया जाता है। जब आप इसे किसी वेरिएबल नाम पर निर्दिष्ट करते हैं, तो sorted() फ़ंक्शन एक नई सूची बनाता है। जब आप sorted() अंतर्निहित फ़ंक्शन लागू करते हैं, तो मूल सूची या टुपल नहीं बदला जाता है।

my_list = ['d', 'a', 'x', 'm', 'b']
new_list = sorted( my_list )
print( my_list )     # आउटपुट ['d', 'a', 'x', 'm', 'b'] है।
print( new_list )   # आउटपुट ['a', 'b', 'd', 'm', 'x'] है।

my_tuple = (34, 23, 5, 62, 7, 1)
new_tuple = sorted( my_tuple )
print( my_tuple )     # आउटपुट (34, 23, 5, 62, 7, 1) है।
print( new_tuple )   # आउटपुट [1, 5, 7, 23, 34, 62] है।

    आप देख सकते हैं कि sort(self, /, *, key = None, reverse = False) सूची विधि के पैरामीटर्स, पहले पैरामीटर को छोड़कर, sorted() अंतर्निहित फ़ंक्शन के समान है। key पैरामीटर एक कस्टम फ़ंक्शन नाम भी ले सकता है, और reverse पैरामीटर True हो सकता है। और, इस प्रकार पुनरावर्तनीय को तदनुसार क्रमबद्ध किया जाएगा। आप अगले पृष्ठों में कस्टम फ़ंक्शन के बारे में जानेंगे।

slice()

क्लास slice(ऑब्जेक्ट) - slice(stop), slice(start, stop [, step])

एक स्लाइस ऑब्जेक्ट बनाएं. इसका उपयोग विस्तारित स्लाइसिंग के लिए किया जाता है (उदाहरण के लिए a[0:10:2])।

S.indices(len) -> (start, stop, stride)

    लंबाई len के अनुक्रम को मानते हुए, प्रारंभ और स्टॉप सूचकांकों की गणना करें, और S द्वारा वर्णित विस्तारित स्लाइस की स्ट्राइड लंबाई की गणना करें। सीमा से बाहर सूचकांकों को सामान्य स्लाइस की हैंडलिंग के अनुरूप तरीके से क्लिप किया जाता है।

exit()

क्लास क्विटर(बिल्टइन्स.ऑब्जेक्ट)

quit()

क्लास क्विटर(बिल्टइन्स.ऑब्जेक्ट)

    आप पिछले पृष्ठों में slice(), quit() और exit() फ़ंक्शंस पहले ही देख चुके हैं। इनका उल्लेख यहां आपको यह याद दिलाने के लिए किया गया है कि ये फ़ंक्शन बिल्ट-इन हैं, लेकिन कार्यक्रमों में शायद ही कभी उपयोग किए जाते हैं। slice() बिल्ट-इन फ़ंक्शन का छोटा रूप, यानी, a[0:10:2] सामान्यतः प्रयोग किया जाता है। quit() और exit() फ़ंक्शंस प्रोग्राम को तुरंत समाप्त कर देते हैं, और इसलिए केवल पायथन सीएलआई >>> में उपयोग किया जाता है। हालाँकि, इन दोनों फ़ंक्शन के स्थान पर return कीवर्ड का उपयोग किया जाता है।