पायथन में "ईएएफपी सिद्धांत का उपयोग करके" का क्या अर्थ है? क्या आप कोई उदाहरण दे सकते हैं?
पायथन में "ईएएफपी सिद्धांत का उपयोग करके" का क्या अर्थ है? क्या आप कोई उदाहरण दे सकते हैं?
जवाबों:
से शब्दकोष :
अनुमति की तुलना में क्षमा मांगना आसान है। यह सामान्य पायथन कोडिंग शैली वैध कुंजी या विशेषताओं के अस्तित्व को मानती है और यदि अपवाद गलत साबित होता है तो अपवादों को पकड़ता है। यह साफ और तेज शैली कई
try
औरexcept
बयानों की उपस्थिति की विशेषता है । तकनीक LBYL शैली के साथ कई अन्य भाषाओं जैसे कि C के विपरीत है ।
एक उदाहरण एक शब्दकोश कुंजी तक पहुंचने का प्रयास होगा।
EAFP:
try:
x = my_dict["key"]
except KeyError:
# handle missing key
LBYL:
if "key" in my_dict:
x = my_dict["key"]
else:
# handle missing key
LBYL संस्करण को दो बार शब्दकोश के अंदर कुंजी की खोज करनी है, और इसे थोड़ा कम पठनीय भी माना जा सकता है।
x
जब कुंजी मौजूद नहीं है: यदि नहीं है तो x = mydict.get('key')
वापस आ जाएगा ; आप भी कर सकते हैं , और फिर x को कुछ सौंपा जाएगा यदि कुंजी शब्दकोश में नहीं है। और अतिरिक्त कोड से बचने के लिए अच्छी चीजें हैं। None
'key'
my_dict
.get('key', <something>)
dict.setdefault()
collections.defaultdict
except KeyError
के साथ-साथ AttributeError
सरल लेकिन सबसे खराब उदाहरण हैं। इसलिए कई बार मैं कुछ डिबगिंग में फंस गया क्योंकि except AttributeError
गलत जगह डाल दिया गया था, जो अंत में गलत विशेषता त्रुटि को पकड़ रहा था जो श्रृंखला में गहराई से बढ़ा। मुझे लगता है कि बेहतर उदाहरण हैं try: open() ... except: IOError
:। याtry: parseLine() ... except ParseError
मैं इसे दूसरे उदाहरण से समझाने की कोशिश करूँगा।
यहां हम फ़ाइल तक पहुंचने और कंसोल में सामग्री प्रिंट करने का प्रयास कर रहे हैं।
हम जाँच सकते हैं कि क्या हम फ़ाइल तक पहुँच सकते हैं और यदि हम कर सकते हैं, तो हम इसे खोलेंगे और सामग्री प्रिंट करेंगे। यदि हम उस फ़ाइल तक नहीं पहुँच सकते हैं जो हम else
भाग को मारेंगे। कारण यह है कि यह एक दौड़ की स्थिति है क्योंकि हम पहले एक एक्सेस-चेक बनाते हैं। जब तक हम पहुंचते हैं, तब तक with open(my_file) as f:
हम कुछ अनुमति के मुद्दों के कारण इसे एक्सेस नहीं कर सकते हैं (उदाहरण के लिए एक अन्य प्रक्रिया एक अनन्य फ़ाइल लॉक प्राप्त करती है)। यह कोड संभवतः एक त्रुटि फेंक देगा और हम उस त्रुटि को नहीं पकड़ पाएंगे क्योंकि हमने सोचा था कि हम फ़ाइल तक पहुंच सकते हैं।
import os
my_file = "/path/to/my/file.txt"
# Race condition
if os.access(my_file, os.R_OK):
with open(my_file) as f:
print(f.read())
else:
print("File can't be accessed")
इस उदाहरण में, हम केवल फ़ाइल को खोलने का प्रयास कर रहे हैं और यदि हम इसे नहीं खोल सकते हैं, तो यह एक फेंक देगा IOError
। यदि हम कर सकते हैं, तो हम फ़ाइल खोलेंगे और सामग्री प्रिंट करेंगे। इसलिए कुछ पूछने के बजाय हम इसे करने की कोशिश कर रहे हैं । अगर यह काम करता है, महान! यदि यह नहीं होता है तो हम त्रुटि को पकड़ लेते हैं और उसे संभाल लेते हैं।
# # No race condition
try:
f = open(my_file)
except IOError as e:
print("File can't be accessed")
else:
with f:
print(f.read())
मैं इसे "आशावादी प्रोग्रामिंग" कहता हूं। विचार यह है कि ज्यादातर लोग सही काम करेंगे, और त्रुटियां कुछ कम होनी चाहिए। इसलिए "सही बात" के लिए पहले कोड करें, और फिर त्रुटियों को पकड़ें यदि वे नहीं करते हैं।
मेरी भावना यह है कि यदि कोई उपयोगकर्ता गलतियाँ करने जा रहा है, तो उन्हें समय के परिणाम भुगतने चाहिए। जो लोग उपकरण का सही तरीके से उपयोग करते हैं, उनके माध्यम से किया जाता है।