ऑब्जेक्ट ओरिएंटेड शॉर्टकट

यह अध्याय पायथन में विभिन्न अंतर्निहित कार्यों, फ़ाइल I / O संचालन और ओवरलोडिंग अवधारणाओं के बारे में विस्तार से बात करता है।

पायथन निर्मित कार्य

पायथन दुभाषिया में कई प्रकार के कार्य होते हैं जिन्हें अंतर्निहित कार्य कहा जाता है जो उपयोग के लिए आसानी से उपलब्ध हैं। अपने नवीनतम संस्करण में, पायथन में 68 अंतर्निहित कार्य शामिल हैं, जो नीचे दी गई तालिका में सूचीबद्ध हैं -

बिल्ड-इन फंक्शंस
पेट ()	dict ()	मदद()	मिनट ()	setattr ()
सब()	निर्देशिका ()	हेक्स ()	आगे()	टुकड़ा ()
कोई भी()	divmod ()	आईडी ()	वस्तु ()	क्रमबद्ध ()
ascii ()	गणना ()	इनपुट ()	अक्टूबर ()	staticmethod ()
बिन ()	eval ()	पूर्णांक ()	खुला हुआ()	str ()
bool ()	कार्यकारी ()	isinstance ()	ord ()	योग ()
bytearray ()	फिल्टर ()	issubclass ()	पॉव ()	उत्तम()
बाइट ()	नाव ()	आईटीईआर ()	प्रिंट ()	टपल ()
प्रतिदेय ()	प्रारूप ()	लेन ()	संपत्ति()	प्रकार()
chr ()	frozenset ()	सूची()	रेंज ()	वार्स ()
classmethod ()	getattr ()	स्थानीय लोगों ()	रेपर ()	ज़िप ()
संकलन ()	वैश्विक ()	नक्शा()	उलट ()	__आयात__()
जटिल ()	hasattr ()	अधिकतम ()	गोल()
delattr ()	हैश ()	स्मृति दर्शन()	सेट()

यह खंड कुछ महत्वपूर्ण कार्यों के बारे में संक्षेप में चर्चा करता है -

len () फ़ंक्शन

लेन () फ़ंक्शन को स्ट्रिंग्स, सूची या संग्रह की लंबाई मिलती है। यह किसी वस्तु की लंबाई या संख्या को लौटाता है, जहां वस्तु एक स्ट्रिंग, सूची या संग्रह हो सकती है।

>>> len(['hello', 9 , 45.0, 24])
4

len () फ़ंक्शन आंतरिक रूप से काम करता है list.__len__() या tuple.__len__()। इस प्रकार, ध्यान दें कि लेन () केवल उन वस्तुओं पर काम करती है जिनमें एक __ हैlen__() तरीका।

>>> set1
{1, 2, 3, 4}
>>> set1.__len__()
4

हालांकि, व्यवहार में, हम पसंद करते हैं len() के स्थान पर __len__() निम्नलिखित कारणों के कारण कार्य -

• यह अधिक कुशल है। और यह आवश्यक नहीं है कि एक विशेष विधि __len__ जैसे विशेष तरीकों तक पहुंच से इनकार करने के लिए लिखी गई हो।

• इसे बनाए रखना आसान है।

• यह पिछड़ी अनुकूलता का समर्थन करता है।

उलट (सेक)

यह रिवर्स इट्रेटर लौटाता है। seq एक ऑब्जेक्ट होना चाहिए जिसमें __reversed __ () विधि हो या अनुक्रम प्रोटोकॉल (__len __) विधि और __getitem __ () विधि का समर्थन करता है। यह आमतौर पर में प्रयोग किया जाता हैfor लूप्स जब हम वापस से सामने की ओर आइटम पर लूप करना चाहते हैं।

>>> normal_list = [2, 4, 5, 7, 9]
>>>
>>> class CustomSequence():
   def __len__(self):
      return 5
   def __getitem__(self,index):
      return "x{0}".format(index)
>>> class funkyback():
   def __reversed__(self):
      return 'backwards!'
>>> for seq in normal_list, CustomSequence(), funkyback():
      print('\n{}: '.format(seq.__class__.__name__), end="")
      for item in reversed(seq):
         print(item, end=", ")

अंत में लूप के लिए एक सामान्य सूची की उलटी सूची और दो कस्टम अनुक्रमों के उदाहरणों को प्रिंट करता है। आउटपुट से पता चलता है किreversed() उन तीनों पर काम करता है, लेकिन जब हम परिभाषित करते हैं तो बहुत अलग परिणाम होते हैं __reversed__।

उत्पादन

जब आप ऊपर दिए गए कोड को निष्पादित करते हैं तो आप निम्नलिखित आउटपुट देख सकते हैं -

list: 9, 7, 5, 4, 2,
CustomSequence: x4, x3, x2, x1, x0,
funkyback: b, a, c, k, w, a, r, d, s, !,

की गणना

enumerate () विधि एक काउंटर को चलने योग्य में जोड़ता है और एन्यूमरेट ऑब्जेक्ट को लौटाता है।

गणना का सिंटैक्स () है -

enumerate(iterable, start = 0)

यहाँ दूसरा तर्क start वैकल्पिक है, और डिफ़ॉल्ट सूचकांक शून्य (0) से शुरू होता है।

>>> # Enumerate
>>> names = ['Rajesh', 'Rahul', 'Aarav', 'Sahil', 'Trevor']
>>> enumerate(names)
<enumerate object at 0x031D9F80>
>>> list(enumerate(names))
[(0, 'Rajesh'), (1, 'Rahul'), (2, 'Aarav'), (3, 'Sahil'), (4, 'Trevor')]
>>>

इसलिए enumerate()एक पुनरावृत्ति देता है जो एक टपल पैदा करता है जो अनुक्रम में पारित तत्वों की गिनती रखता है। चूंकि रिटर्न वैल्यू एक इटरेटर है, इसलिए सीधे इसे एक्सेस करना ज्यादा उपयोगी नहीं है। Enumerate () के लिए एक बेहतर दृष्टिकोण लूप के लिए गणना कर रहा है।

>>> for i, n in enumerate(names):
   print('Names number: ' + str(i))
   print(n)
Names number: 0
Rajesh
Names number: 1
Rahul
Names number: 2
Aarav
Names number: 3
Sahil
Names number: 4
Trevor

मानक पुस्तकालय में कई अन्य कार्य हैं, और यहां कुछ और व्यापक रूप से उपयोग किए जाने वाले कार्यों की एक और सूची है -

• hasattr, getattr, setattr तथा delattr, जो किसी वस्तु की विशेषताओं को उनके स्ट्रिंग नामों से हेरफेर करने की अनुमति देता है।

• all तथा any, जो एक चलने योग्य वस्तु को स्वीकार करते हैं और वापस लौटते हैं True यदि सभी, या कोई भी, आइटम सत्य होने का मूल्यांकन करते हैं।

• nzip, जो दो या दो से अधिक क्रम लेता है और ट्यूपल्स के एक नए अनुक्रम को लौटाता है, जहां प्रत्येक ट्यूपल में प्रत्येक अनुक्रम से एक एकल मान होता है।

फ़ाइल I / O

फ़ाइलों की अवधारणा ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग शब्द से जुड़ी है। पायथन ने इंटरफ़ेस को लपेटा है जो कि अमूर्त में दिए गए ऑपरेटिंग सिस्टम हैं जो हमें फ़ाइल ऑब्जेक्ट्स के साथ काम करने की अनुमति देता है।

open()बिल्ट-इन फ़ंक्शन का उपयोग फ़ाइल खोलने और फ़ाइल ऑब्जेक्ट को वापस करने के लिए किया जाता है। यह दो तर्कों के साथ सबसे अधिक इस्तेमाल किया जाने वाला कार्य है -

open(filename, mode)

ओपन () फ़ंक्शन दो तर्क कहता है, पहला फ़ाइलनाम है और दूसरा मोड है। यहाँ मोड केवल पढ़ने के लिए मोड के लिए 'r' हो सकता है, केवल लिखने के लिए 'w' (एक ही नाम वाली मौजूदा फ़ाइल मिटा दी जाएगी), और 'a' में अपीयरेंस के लिए फ़ाइल को खोलता है, फ़ाइल में लिखा गया कोई भी डेटा अपने आप जुड़ जाता है अंत की ओर। 'r +' पढ़ने और लिखने दोनों के लिए फाइल खोलता है। डिफ़ॉल्ट मोड केवल पढ़ा जाता है।

विन्डोज़ पर, मोड के लिए 'बी' संलग्न फ़ाइल को बाइनरी मोड में खोलता है, इसलिए 'आरबी', 'डब्ल्यूबी' और 'आर + बी' जैसे मोड भी हैं।

>>> text = 'This is the first line'
>>> file = open('datawork','w')
>>> file.write(text)
22
>>> file.close()

कुछ मामलों में, हम केवल मौजूदा फ़ाइल को अपग्रेड करना चाहते हैं, फिर इसे ओवर राइट कर रहे हैं, इसके लिए हम एक मोड तर्क के रूप में मान 'a' की आपूर्ति कर सकते हैं, मौजूदा फ़ाइल को पूरी तरह से अधिलेखित करने के बजाय, फ़ाइल के अंत में संलग्न करने के लिए। सामग्री।

>>> f = open('datawork','a')
>>> text1 = ' This is second line'
>>> f.write(text1)
20
>>> f.close()

एक बार पढ़ने के लिए एक फ़ाइल खोलने के बाद, हम फ़ाइल की सामग्री को प्राप्त करने के लिए रीड, रीडलाइन या रीडलाइन की विधि को कॉल कर सकते हैं। रीड विधि फ़ाइल की संपूर्ण सामग्री को एक str या बाइट्स ऑब्जेक्ट के रूप में लौटाती है, जो इस बात पर निर्भर करती है कि दूसरा तर्क 'b' है या नहीं।

पठनीयता के लिए, और एक बार में एक बड़ी फ़ाइल को पढ़ने से बचने के लिए, फ़ाइल ऑब्जेक्ट पर सीधे लूप के लिए उपयोग करना अक्सर बेहतर होता है। पाठ फ़ाइलों के लिए, यह एक बार में प्रत्येक पंक्ति, एक को पढ़ेगा, और हम इसे लूप बॉडी के अंदर प्रोसेस कर सकते हैं। बाइनरी फ़ाइलों के लिए हालांकि रीड () विधि का उपयोग करके डेटा के निश्चित-आकार वाले विखंडू को पढ़ना बेहतर है, पढ़ने के लिए अधिकतम बाइट्स के लिए एक पैरामीटर पास करना।

>>> f = open('fileone','r+')
>>> f.readline()
'This is the first line. \n'
>>> f.readline()
'This is the second line. \n'

फ़ाइल पर लिखना, फ़ाइल ऑब्जेक्ट पर लिखने की विधि के माध्यम से फ़ाइल के लिए एक स्ट्रिंग (बाइनरी डेटा के लिए बाइट्स) ऑब्जेक्ट लिखेंगे। लेखन पद्धति तार के अनुक्रम को स्वीकार करती है और फ़ाइल में प्रत्येक पुनरावृत्त मान लिखती है। अनुक्रम में प्रत्येक आइटम के बाद रिटलाइन विधि एक नई रेखा नहीं जोड़ती है।

अंत में क्लोज़ () विधि को तब बुलाया जाना चाहिए जब हम फ़ाइल को पढ़ना या लिखना समाप्त कर रहे हैं, यह सुनिश्चित करने के लिए कि कोई भी बफर लिखना डिस्क पर लिखा गया है, कि फ़ाइल को ठीक से साफ किया गया है और फ़ाइल के साथ बंधे सभी संसाधनों को वापस जारी किया गया है ऑपरेटिंग सिस्टम। बंद () विधि को कॉल करने के लिए यह एक बेहतर तरीका है, लेकिन तकनीकी रूप से यह स्क्रिप्ट के मौजूद होने पर स्वचालित रूप से होगा।

ओवरलोडिंग की विधि का एक विकल्प

मेथड ओवरलोडिंग से तात्पर्य एक ही नाम से कई विधियों का होना है जो विभिन्न प्रकार के तर्कों को स्वीकार करते हैं।

किसी एक विधि या कार्य को देखते हुए, हम अपने मापदंडों की संख्या निर्दिष्ट कर सकते हैं। फ़ंक्शन परिभाषा के आधार पर, इसे शून्य, एक, दो या अधिक मापदंडों के साथ कहा जा सकता है।

class Human:
   def sayHello(self, name = None):
      if name is not None:
         print('Hello ' + name)
      else:
         print('Hello ')

#Create Instance
obj = Human()

#Call the method, else part will be executed
obj.sayHello()

#Call the method with a parameter, if part will be executed
obj.sayHello('Rahul')

उत्पादन

Hello
Hello Rahul

डिफ़ॉल्ट तर्क

कार्य वस्तुएं भी हैं

एक कॉल करने योग्य ऑब्जेक्ट एक ऑब्जेक्ट है जो कुछ तर्कों को स्वीकार कर सकता है और संभवतः एक ऑब्जेक्ट वापस कर देगा। पायथन में एक फ़ंक्शन सबसे आसान कॉल करने योग्य ऑब्जेक्ट है, लेकिन अन्य भी हैं जैसे कि कक्षाएं या कुछ निश्चित वर्ग उदाहरण।

पायथन में प्रत्येक फ़ंक्शन एक ऑब्जेक्ट है। ऑब्जेक्ट में विधियाँ या कार्य हो सकते हैं, लेकिन ऑब्जेक्ट आवश्यक नहीं है।

def my_func():
   print('My function was called')
my_func.description = 'A silly function'
def second_func():

   print('Second function was called')

   second_func.description = 'One more sillier function'

def another_func(func):
   print("The description:", end=" ")
   print(func.description)
   print('The name: ', end=' ')
   print(func.__name__)
   print('The class:', end=' ')
   print(func.__class__)
   print("Now I'll call the function passed in")
   func()

another_func(my_func)
another_func(second_func)

उपरोक्त कोड में, हम अपने तीसरे फ़ंक्शन में तर्क के रूप में दो अलग-अलग कार्यों को पारित करने में सक्षम हैं, और प्रत्येक के लिए अलग-अलग आउटपुट प्राप्त करते हैं -

The description: A silly function
The name: my_func
The class: 
      
        Now I'll call the function passed in My function was called The description: One more sillier function The name: second_func The class: 
       
         Now I'll call the function passed in Second function was called 
       
      

callable objects

Just as functions are objects that can have attributes set on them, it is possible to create an object that can be called as though it were a function.

In Python any object with a __call__() method can be called using function-call syntax.