pythonic

तो इसका क्या मतलब है जब कोई कहता है कि फू पाइथोनिक जैसा दिखता है? इसका क्या मतलब है जब कोई हमारे कोड को देखता है और कहता है कि यह अप्राकृतिक है? आइए इसे जानने की कोशिश करें।

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

इसके विपरीत, अनपीथोनिक लेबल का अर्थ है कि कोड पायथन सिंटैक्स में कुछ अन्य प्रोग्रामिंग भाषा के कोड को लिखने के लिए एक क्रूड प्रयास है, न कि एक मुहावरेदार परिवर्तन।

Pythonicity की अवधारणा, Python की न्यूनतम अवधारणा से बहुत निकट से संबंधित है और सिद्धांत से प्रस्थान "ऐसा करने के कई तरीके हैं।" अपठनीय कोड, या अकल्पनीय मुहावरे - यह सब कुछ अप्रसांगिक है।

एक भाषा से दूसरी भाषा में जाने पर, कुछ चीजें “सीखी” जानी चाहिए। हम अन्य प्रोग्रामिंग भाषाओं से क्या जानते हैं कि पायथन में कोई जगह नहीं होगी?

मानक पुस्तकालय का उपयोग करें

मानक पुस्तकालय हमारा मित्र है। उसका उपयोग करते हैं।

>>> foo = "/home/sa" >>> baz = "somefile" >>> foo + "/" + baz # unpythonic '/home/sa/somefile' >>> import os.path >>> os.path.join(foo, baz) # pythonic '/home/sa/somefile' >>> 

Os.path में अन्य उपयोगी कार्य: basename () , dirname (), और splitext () ।

 >>> somefoo = list(range(9)) >>> somefoo [0, 1, 2, 3, 4, 5, 6, 7, 8] >>> import random >>> random.shuffle(somefoo) # pythonic >>> somefoo [8, 4, 5, 0, 7, 2, 6, 3, 1] >>> max(somefoo) # pythonic 8 >>> min(somefoo) # pythonic 0 >>> 

कई उपयोगी अंतर्निहित कार्य हैं जो कई लोग किसी भी कारण से अनजान हैं। उदाहरण के लिए, न्यूनतम () और अधिकतम () । मानक पुस्तकालय में कई उपयोगी मॉड्यूल शामिल हैं। उदाहरण के लिए, यादृच्छिक , जिसमें कार्यक्षमता का एक गुच्छा होता है जिसे लोग अनजाने में अपने दम पर लागू करते हैं।

खाली सूची, टुपल्स, शब्दकोश, आदि बनाएँ।

 >>> bar = list() # unpythonic >>> type(bar) <class 'list'> >>> del bar >>> bar = [] # pythonic >>> type(bar) <class 'list'> >>> foo = {} >>> type(foo) <class 'dict'> >>> baz= set() # {} is a dictionary so we need to use set() >>> type(baz) <class 'set'> >>> 

बैकलैश का उपयोग करना

क्योंकि पायथन व्यवहार करता है लाइन एक अभिव्यक्ति सीमांकक के रूप में टूटता है, और तब से भाव बहुत बार एक पंक्ति में फिट नहीं होते हैं, कई लोग ऐसा करते हैं:

 if foo.bar()['first'][0] == baz.ham(1, 2)[5:9] and \ # unpythonic verify(34, 20) != skip(500, 360): pass 

"\" का उपयोग करना एक अच्छा विचार नहीं है। यह दृष्टिकोण एक अप्रिय बग पैदा कर सकता है: स्लैश के बाद एक यादृच्छिक स्थान लाइन को गलत बना देगा। सर्वोत्तम स्थिति में, हमें सिंटैक्स त्रुटि मिलती है, लेकिन यदि कोड कुछ इस तरह है:

 value = foo.bar()['first'][0]*baz.ham(1, 2)[5:9] \ # unpythonic + verify(34, 20)*skip(500, 360) 

तब यह बस निष्क्रिय होगा। कोष्ठक में निहित रेखा निरंतरता का उपयोग करने के लिए बेहतर है। एक समान कोड बुलेटप्रूफ है:

 value = (foo.bar()['first'][0]*baz.ham(1, 2)[5:9] # pythonic + verify(34, 20)*skip(500, 360)) 

आयात

" फू आयात * से " का उपयोग न करें। यहाँ और यहाँ आप अधिक विस्तृत जानकारी पा सकते हैं।

सामान्य अपवाद

पायथन में एक " सिवाय " अभिव्यक्ति है जो सभी अपवादों को पकड़ती है। क्योंकि कोई भी त्रुटि अपवाद को फेंक देती है, ऐसा कोड कई प्रोग्रामिंग त्रुटियों को रन-टाइम त्रुटियों की तरह बना सकता है, और प्रोग्राम को डीबग करना कठिन बना सकता है। निम्न उदाहरण संपूर्ण है:

 try: foo = opne("somefile") # misspelled "open" except: sys.exit("could not open file!") 

दूसरी पंक्ति एक " NameError " को फेंकती है, जिसे पकड़ा जाएगा, जो कि शब्दशः गलत है, क्योंकि " IOError " को पकड़ने के लिए "छोड़कर" लिखा गया है। बेहतर यह कोड लिखें:

 try: foo = opne("somefile") except IOError: sys.exit("could not open file") 

जब आप यह कोड चलाते हैं, तो पायथन "NameError" को फेंक देगा और आप तुरंत त्रुटि को देखेंगे और ठीक कर देंगे।

चूँकि " SystemExit ", " KeyboardInterrupt ", और " GeneratorExit " (जो अनिवार्य रूप से त्रुटियां नहीं होनी चाहिए और उपयोगकर्ता कोड द्वारा नहीं पकड़े जाने चाहिए) सहित सभी अपवादों को पकड़ता है, वैसे भी एक नंगे "छोड़कर" का उपयोग करना एक बुरा विचार है। उन स्थितियों में जहां हमें अभी भी सभी संभावित असाधारण स्थितियों को कवर करने की आवश्यकता है, हम सभी अपवादों के लिए बेस क्लास का उपयोग कर सकते हैं - " अपवाद "।

हमें शायद ही कभी काउंटरों की आवश्यकता होती है

 >>> counter = 0 # unpythonic >>> while counter < 10: ... # do some stuff ... counter += 1 ... ... >>> counter 10 >>> for counter in range(10): # pythonic ... # do some stuff ... pass ... ... >>> 

एक और उदाहरण:

 >>> food = ['donkey', 'orange', 'fish'] >>> for i in range(len(food)): # unpythonic ... print(food[i]) ... ... donkey orange fish >>> for item in food: # pythonic ... print(item) ... ... donkey orange fish >>> 

स्पष्ट इटरेटर

पायथन आंतरिक रूप से कई पुनरावृत्तियों का उपयोग करता है ... लूप के लिए कोई अपवाद नहीं होना चाहिए:

 >>> counter = 0 # unpythonic >>> while counter < len(somecontainer): ... callable_consuming_container_elements(somecontainer[counter]) ... counter += 1 ... ... >>> for item in somecontainer: # pythonic ... callable_consuming_container_elements(item) ... ... >>> 

हम कह सकते हैं कि साधारण चीजों के लिए हमें स्पष्ट रूप से पुनरावृत्तियों का निर्माण नहीं करना चाहिए। ऐसे कई मामले हैं जहां स्पष्ट पुनरावृत्तियाँ उपयोगी होंगी। उदाहरण के लिए, जब हम कुछ प्रक्रिया करते हैं, रुकते हैं, कुछ और करते हैं, तो वापस जाते हैं और जारी रखते हैं। एक पुनरावृत्तिकर्ता को हमारी स्थिति याद है, और यह अद्भुत है:

 >>> somecontainer = list(range(7)) >>> type(somecontainer) <class 'list'> >>> somecontainer [0, 1, 2, 3, 4, 5, 6] >>> somecontaineriterator = iter(somecontainer) >>> type(somecontaineriterator) <class 'list_iterator'> 

अब हम अपने पुनरावृत्ति का उपयोग शुरू कर सकते हैं:

 >>> for item in somecontaineriterator: # start consuming the iterable somecontainer ... if item < 4: ... print(item) ... ... else: ... break # breaks out of the nearest enclosing for/while loop ... ... ... 0 1 2 3 

मूर्ख मत बनो, itter " somecontaineriterator [5] " पर बंद हो गया, जो 4 है, 3 नहीं। आइए देखें कि आगे क्या होता है:

 >>> print("Something unrelated to somecontaineriterator.") Something unrelated to somecontaineriterator. >>> next(somecontaineriterator) # continues where previous for/while loop left off 5 >>> next(somecontaineriterator) 6 >>> next(somecontaineriterator) Traceback (most recent call last): # we have exhausted the iterator File "<input>", line 1, in <module> StopIteration >>> 

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

असाइनमेंट

यहां आप विस्तार से पढ़ सकते हैं।

लूप्स केवल जब वास्तव में जरूरत हो

ऐसे कई मामले हैं जिनके लिए हम अन्य प्रोग्रामिंग भाषाओं में लूप एक्सप्रेशन का उपयोग करेंगे, लेकिन पायथन के मामले में यह आवश्यक नहीं है।

पायथन किसी भी प्रकार की वस्तु को संभालने के लिए उच्च स्तर की कार्यक्षमता प्रदान करता है। अनुक्रमों के लिए, ये ज़िप () , न्यूनतम () , अधिकतम () फ़ंक्शन हो सकते हैं। फिर, ये "लिस्ट कॉम्प्रिहेंशन", जनरेटर, "सेट कॉम्प्रिहेंशन", आदि जैसी चीजें हैं।

तथ्य यह है कि अगर हम अपने डेटा को मूल पायथन संरचनाओं में सहेजते हैं, जैसे कि सूचियां, ट्यूपल्स, शब्दकोश, सेट आदि, तो हमें उनके साथ काम करने के लिए कार्यक्षमता का एक गुच्छा मिलता है। यहां तक ​​कि अगर हमें एक विशिष्ट संरचना की आवश्यकता है, तो अंतर्निहित डेटा संरचना का उपयोग करके इसे बनाना मुश्किल नहीं है। तो फायदे क्या हैं। हम डिस्क फ़ाइल में संग्रहीत कुछ लोगों के नामों की सूची कैसे प्राप्त कर सकते हैं।

 sa@wks:/tmp$ cat people.txt Dora John Dora Mike Dora Alex Alex sa@wks:/tmp$ python >>> with open('people.txt', encoding='utf-8') as a_file: # context manager ... { line.strip() for line in a_file } # set comprehension ... ... {'Alex', 'Mike', 'John', 'Dora'} >>> 

कोई लूप नहीं, उपयोगकर्ता डेटा संरचनाएं, अतिरिक्त स्थान और डुप्लिकेट हटा दिए गए, सभी पायथोनिक; -]

ट्यूपल केवल पढ़ने वाली सूचियाँ नहीं हैं

यह एक आम गलत धारणा है। बहुत बार सूचियों और टुपल्स का उपयोग एक ही उद्देश्य के लिए किया जाता है। एक ही प्रकार के डेटा को संग्रहीत करने के लिए सूचियों का इरादा है। जबकि टुपल्स एक सेट में विभिन्न प्रकार के डेटा के संयोजन के लिए हैं। दूसरे शब्दों में

संपूर्ण इसके भागों के योग से अधिक है।
- अरस्तू (384 ईसा पूर्व - 322 ईसा पूर्व)

 >>> person = ("Steve", 23, "male", "London") >>> print("{} is {}, {} and lives in {}.".format(person[0], person[1], person[2], person[3])) Steve is 23, male and lives in London. >>> person = ("male", "Steve", 23, "London") #different tuple, same code >>> print("{} is {}, {} and lives in {}.".format(person[0], person[1], person[2], person[3])) male is Steve, 23 and lives in London. >>> 

टपल में एक सूचकांक एक सिमेंटिक भार वहन करता है। आइए इन संरचनाओं की तुलना करें:

 >>> foo = 2011, 11, 3, 15, 23, 59 >>> foo (2011, 11, 3, 15, 23, 59) # tuple >>> list(range(9)) [0, 1, 2, 3, 4, 5, 6, 7, 8] # list >>> 

• इनमें से पहला, एक टपल, एक संरचना है जहां एक तत्व की स्थिति एक निश्चित अर्थ को वहन करती है (पहला तत्व एक वर्ष है)।
• दूसरा, सूची, एक अनुक्रम है जिसमें मान कार्यात्मक रूप से समतुल्य हैं, सूचकांक का कोई मतलब नहीं है।

दोनों संरचनाओं का उपयोग करने का एक बड़ा उदाहरण पायथन डीबी एपीआई से प्राप्त भ्रूण () विधि है, जो परिणाम को ट्यूपल्स की सूची के रूप में लौटाता है।

कक्षाएं समूह कार्यक्षमता के लिए अभिप्रेत नहीं हैं

C # और Java में केवल कक्षाओं के अंदर कोड होता है। परिणामस्वरूप, उपयोगितावादी वर्ग उत्पन्न होते हैं जिनमें केवल स्थैतिक विधियाँ होती हैं। उदाहरण के लिए, गणितीय कार्य पाप () । पायथन में, हम सिर्फ शीर्ष-स्तरीय मॉड्यूल का उपयोग करते हैं:

 sa@wks:/tmp$ echo -e 'def sin():\n pass' > foo.py; cat foo.py def sin(): pass sa@wks:/tmp$ python >>> import foo >>> foo.sin() >>> 

गेटर्स एंड सेटर्स को ना कहें

पाइथन में एनकैप्सुलेशन को प्राप्त करने का तरीका गुणों का उपयोग करना है, गेटर्स और सेटर नहीं। गुणों का उपयोग करके, हम ऑब्जेक्ट की विशेषताओं को बदल सकते हैं और तथाकथित कोड (पढ़ें, स्थिर एपीआई) को प्रभावित किए बिना कार्यान्वयन को ठीक कर सकते हैं।

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

अजगर में, सब कुछ एक वस्तु है। कार्य भी वस्तुएं हैं। कार्य वे वस्तुएं हैं जिन्हें कहा जा सकता है।

 >>> somefoo = [{'price': 9.99}, {'price': 4.99}, {'price': 10}] >>> somefoo [{'price': 9.99}, {'price': 4.99}, {'price': 10}] >>> def lookup_price(someobject): ... return someobject['price'] ... ... >>> somefoo.sort(key=lookup_price) # pass function object lookup_price >>> somefoo [{'price': 4.99}, {'price': 9.99}, {'price': 10}] # in-place sort of somefoo took place >>> type(somefoo) <class 'list'> >>> type(somefoo[0]) <class 'dict'> >>> 

लुकअप_प्राइस और लुकअप_प्राइस () के बीच अंतर होता है - बाद वाला फ़ंक्शन को कॉल करता है, और पहले वाला लुकअप_प्राइस नामक बाइंडिंग देख रहा है। यह हमें साधारण वस्तुओं के रूप में कार्यों का उपयोग करने का अवसर देता है।