कक्षाएं लिखना बंद करें

एक संकेत है कि वस्तु एक वर्ग नहीं होनी चाहिए - अगर इसकी केवल 2 विधियां हैं, और उनमें से एक है आरंभीकरण, __init__। हर बार जब आप इसे देखते हैं, तो सोचें: "मुझे शायद केवल एक फ़ंक्शन की आवश्यकता है।"

हर बार जब आप एक लिखित कक्षा से केवल एक ही उदाहरण बनाते हैं, तो इसे केवल एक बार उपयोग करें, और तुरंत इसे फेंक दें, आपको सोचना चाहिए: "ओह, मुझे इसे फिर से भरना चाहिए! आप इसे आसान बना सकते हैं, बहुत आसान! "

जैक डिड्रिक की एक रिपोर्ट का अनुवाद, पायथन भाषा के प्रमुख डेवलपर्स में से एक। इस रिपोर्ट को 9 मार्च, 2012 को PyCon US सम्मेलन में दिया गया था ।

आप सभी ने ज़ेन पायथन को पढ़ा होगा, शायद कई बार। यहाँ से कुछ बिंदु हैं:

• सरल जटिल से बेहतर है
• फ्लैट नेस्टिंग से बेहतर है
• पठनीयता महत्वपूर्ण है
• यदि कार्यक्रम को समझाना मुश्किल है, तो यह बुरा है
• यदि कार्यक्रम की व्याख्या करना आसान है, तो यह शायद अच्छा है

यह पाठ टिम पीटर्स द्वारा लिखा गया था। वह आपसे और मुझसे ज्यादा होशियार है। आप कितने लोगों को जानते हैं जिनके बाद छँटाई एल्गोरिथ्म का नाम दिया गया है? यहां ऐसे ही एक आदमी ने लिखा है जेन पायथन। और सभी बिंदुओं को पढ़ते हैं: “मुश्किल मत करो। बस करो। ”इस पर चर्चा की जाएगी।

इसलिए, सबसे पहले, इसे मुश्किल न बनाएं, जहां इसे आसान किया जा सकता है। कक्षाएं बहुत जटिल हैं या बहुत जटिल हो सकती हैं। लेकिन हम अभी भी इसे मुश्किल बना रहे हैं, यहां तक ​​कि इसे आसान बनाने की कोशिश कर रहे हैं। इसलिए, इस रिपोर्ट में, हम थोड़ा कोड पढ़ेंगे और सीखेंगे कि कैसे नोटिस करें कि हम गलत तरीके से जा रहे हैं, और वापस कैसे आएं।

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

कक्षाएं

इस रिपोर्ट से, आपको सबसे पहले इस कोड को याद रखना होगा। यह प्रकृति में पाया जाने वाला सबसे बड़ा वर्ग दुर्व्यवहार है।

class Greeting(object): def __init__(self, word='Hello'): self.word = word def greet(self, name): return '%s, %s!' % (self.word, name) >>> greeting = Greeting('Hola') >>> greeting.greet('Jorge') Hola, Jorge! 

यह एक वर्ग नहीं है, हालांकि यह एक वर्ग जैसा दिखता है। नाम एक संज्ञा है, "अभिवादन।" यह तर्क लेता है और उन्हें __in__ में संग्रहीत करता है। हाँ, यह एक वर्ग जैसा दिखता है। उसके पास एक विधि है जो किसी वस्तु की स्थिति को पढ़ती है और कुछ और करती है, जैसे कि कक्षाओं में। नीचे यह लिखा गया है कि इस वर्ग का उपयोग कैसे किया जाता है: अभिवादन का एक उदाहरण बनाएं और फिर इस अभिवादन का उपयोग कुछ और करने के लिए करें।

लेकिन यह एक वर्ग नहीं है, या यह एक वर्ग नहीं होना चाहिए। इसका एक संकेत यह है कि इसकी केवल 2 विधियाँ हैं, और उनमें से एक है आरंभीकरण, __init__। हर बार जब आप इसे देखते हैं, तो सोचें: "मुझे शायद केवल एक फ़ंक्शन की आवश्यकता है।"

हर बार जब आप एक लिखित कक्षा से केवल एक ही उदाहरण बनाते हैं, तो इसे केवल एक बार उपयोग करें, और तुरंत इसे फेंक दें, आपको सोचना चाहिए: "ओह, मुझे इसे फिर से भरना चाहिए! आप इसे आसान बना सकते हैं, बहुत आसान! "

 def greet(name): ob = Greeting('') print ob.greet(name) return 

इस फ़ंक्शन में कोड की 4 लाइनें हैं। और यहां बताया गया है कि आप इसे केवल 2 लाइनों में कैसे कर सकते हैं:

 def greet(greeting, name): return '%s, %s!' % (greeting, name) import functools greet = functools.partial(greet, '') greet('') 

यदि आप हमेशा समान तर्क के साथ फ़ंक्शन कहते हैं, तो मानक लाइब्रेरी में एक उपकरण होता है! functools.partial। ऊपर दिए गए कोड को देखें: एक तर्क जोड़ें, और परिणाम को कई बार कहा जा सकता है।

मुझे पता नहीं है कि आप में से कितने के पास आईटी में डिग्री है, मेरे पास है। मैंने जैसे कॉन्सेप्ट सिखाए

- शक्तियों का पृथक्करण
- कोड सुसंगतता में कमी
- एनकैप्सुलेशन
- बिक्री का अलगाव

जब से मैंने स्नातक की उपाधि प्राप्त की है, मैंने 15 वर्षों से इन शर्तों का उपयोग नहीं किया है। इन शब्दों को सुनकर, आप जानते हैं, आपको बेवकूफ बनाया जा रहा है। इन शर्तों की आवश्यकता नहीं है प्रति से। यदि उनका उपयोग किया जाता है, तो लोगों को पूरी तरह से अलग चीजों से मतलब होता है जो केवल बातचीत में हस्तक्षेप करते हैं।

उदाहरण: पैंट बारी ...

आप में से कई लोग अपने दैनिक कार्य में थर्ड-पार्टी लाइब्रेरी का उपयोग करते हैं। हर बार जब आपको किसी और के कोड का उपयोग करने की आवश्यकता होती है, तो सबसे पहले इसे पढ़ना होगा। आखिरकार, यह ज्ञात नहीं है कि क्या गुणवत्ता है, क्या उनके पास परीक्षण और इतने पर हैं। इसे चालू करने से पहले आपको कोड की जांच करनी होगी। कभी-कभी कोड पढ़ना कठिन होता है।

एक तृतीय-पक्ष एपीआई पुस्तकालय, चलो इसे शौरमेल कहते हैं, इसमें 1 पैकेज, 22 मॉड्यूल, 20 कक्षाएं और कोड की 660 लाइनें शामिल हैं। उत्पाद में इसे शामिल करने से पहले मुझे यह सब पढ़ना था। लेकिन यह उनकी आधिकारिक एपीआई थी, इसलिए हमने इसका इस्तेमाल किया । जितनी बार एपीआई अपडेट आया, मुझे अलग-अलग देखना पड़ा, क्योंकि यह नहीं पता था कि वे क्या बदलते हैं। आपने पैच भेजे - क्या वे अपडेट में दिखाई दिए?

कोड की 660 लाइनें, 20 कक्षाएं थोड़ी अधिक हैं यदि प्रोग्राम को केवल ईमेल पते, पत्र के पाठ की एक सूची देने और यह पता लगाने की आवश्यकता है कि कौन से पत्र वितरित नहीं किए गए थे, और कौन बिना सदस्यता के।

वर्ग दुर्व्यवहार क्या है? अक्सर लोग सोचते हैं कि उन्हें भविष्य में कुछ चाहिए होगा। ... जरूरत नहीं। जरूरत पड़ने पर सब कुछ लिखें। ShaurMail लाइब्रेरी में एक ShaurHash मॉड्यूल है, जिसमें कोड की 2 लाइनें हैं:

 class ShaurHash(dict): pass 

किसी ने फैसला किया कि बाद में एक शब्दकोश ऐड-ऑन की आवश्यकता होगी। इसकी जरूरत नहीं थी, लेकिन कोड में हर जगह पहले की तरह लाइनें थीं:

 my_hash = ShaurMail.ShaurHash.ShaurHash(id='cat') d = dict(id='cat') d = {'id': 'cat'} 

कोड की दूसरी और तीसरी पंक्ति - किसी को भी उन्हें समझाने की जरूरत नहीं है। लेकिन, यह मंत्र "शौरमेल-शौर्यश-शौर्यश" हर जगह दोहराया गया। शब्द "शौर" की तीन पुनरावृत्ति अतिरिक्तता का एक और संकेत है। पुनरावृत्ति से सभी को केवल नुकसान होता है। आप उपयोगकर्ता को तीन बार "शौर" लिखने के लिए मजबूर करके परेशान करते हैं। (यह असली कंपनी का नाम नहीं है, बल्कि एक काल्पनिक है।)

तब उन्होंने इस आदमी को निकाल दिया और किसी ऐसे व्यक्ति को काम पर रख लिया जो जानता था कि वह क्या कर रहा है। यहाँ एपीआई का दूसरा संस्करण है:

 class API: def __init__(self, key): self.header = dict(apikey=key) def call(self, method, params): request = urllib2.Request( self.url + method[0] + '/' + method[1], urllib.urlencode(params), self.header ) try: response = json.loads(urllib2.urlopen(request).read()) return response except urllib2.HTTPError as error: return dict(Error=str(error)) 

उस एक की 660 लाइनें थीं, इस एक की 15. सब कुछ था जो यह कोड मानक पुस्तकालय के तरीकों का उपयोग करता है। इसे पूरी तरह से, आसानी से, सेकंड में पढ़ा जा सकता है, और आप तुरंत समझ सकते हैं कि यह क्या कर रहा है। वैसे, इसमें 20 लाइनों के परीक्षणों का एक सेट भी था। यहाँ कैसे लिखना है। जब उन्होंने एपीआई को अद्यतन किया, तो मैं सचमुच कुछ सेकंड में बदलाव पढ़ सकता था।

लेकिन यहां आप समस्या को नोटिस कर सकते हैं। कक्षा के दो तरीके हैं, और उनमें से एक __init__ है। लेखकों ने इसे छिपाया नहीं। दूसरी विधि कॉल है, "कॉल करें।" यहाँ इस एपीआई का उपयोग कैसे करें:

 ShaurMail.API(key=' ').call(('mailing', 'statistics'), {'id': 1}) 

लाइन लंबी है, इसलिए हम एक उपनाम करते हैं और इसे कई बार कहते हैं:

 ShaurMail.request = ShaurMail.API(key=' ').call ShaurMail.request(('mailing', 'statistics'), {'id': 1}) 

ध्यान दें कि हम इस क्लास को एक फंक्शन के रूप में उपयोग करते हैं। यह होना चाहिए। यदि आप इसे देखते हैं, तो जान लें कि यहां कक्षा की आवश्यकता नहीं है। इसलिए मैंने उन्हें एपीआई का तीसरा संस्करण भेजा:

 ShaurMail_API = url = 'https://api.shaurmail.com/%s/%s' ShaurMail_API_KEY = ' ' def request(noun, verb, **params): headers = {'apikey': ShaurMail_API_KEY} request = urllib2.Request(ShaurMail_API % (noun, verb), urllib.urlencode(params), headers) return json.loads(urllib2.urlopen(request).read()) 

यह हमारे प्रोजेक्ट में बिल्कुल भी फाइल नहीं बनाता है, क्योंकि मैंने इसे उस मॉड्यूल में डाला है जहां इसका उपयोग किया जाता है। यह वह सब कुछ करता है जो 15-स्ट्रिंग एपीआई ने किया था, और 660-स्ट्रिंग एपीआई ने जो कुछ भी किया था।

यह वह जगह है जहां हमने शुरुआत की थी और हम यहां आए थे:

• 1 पैकेज + 20 मॉड्यूल => 1 मॉड्यूल
• 20 कक्षाएं => 1 वर्ग => 0 वर्ग
• 130 विधियाँ => 2 विधियाँ => 1 कार्य
• 660 लाइनों का कोड => 15 लाइनें => 5 लाइनें

उपयोग करने में आसान, लिखने में आसान, किसी को यह पता लगाने की आवश्यकता नहीं है कि क्या हो रहा है।

मानक पुस्तकालय

जो कोई भी जावा भाषा से आया है वह सोच सकता है कि नामस्थानों को वर्गीकरण के लिए आवश्यक है। यह सच नहीं है। मिलान नामों को रोकने के लिए उनकी आवश्यकता होती है। यदि आपके पास रिक्त स्थान की गहरी पदानुक्रम है, तो यह किसी को भी कुछ नहीं देता है। ShaurMail.ShaurHash.ShaurHash केवल अतिरिक्त शब्द हैं जिन्हें लोगों को याद रखने और लिखने की आवश्यकता है।

पायथन मानक पुस्तकालय में, नाम स्थान बहुत उथला है, क्योंकि आपको या तो याद है कि मॉड्यूल क्या कहा जाता है, या आपको दस्तावेज में देखने की आवश्यकता है। कुछ भी अच्छा नहीं है अगर आपको श्रृंखला का पता लगाने की ज़रूरत है, जिसमें पैकेज देखना है, तो उसमें कौन सा पैकेज है, किस पैकेज में है, और इसमें मॉड्यूल का नाम क्या है। आपको बस मॉड्यूल का नाम पता होना चाहिए।

हमारे लिए शर्म की बात है, यहाँ हमारे कोड से एक उदाहरण है, और एक ही पाप यहाँ देखा जा सकता है:

 services.crawler.crawlerexceptions.ArticleNotFoundException 

एक पैकेज जिसमें 2-लाइन मॉड्यूल, एक अपवाद वर्ग और "पास" है। इस अपवाद का उपयोग करने के लिए, आपको दो बार "क्रॉलर" लिखना होगा, दो बार "अपवाद" शब्द। ArticleNotFoundException नाम ही दोहराता है। तो मत करो। यदि आप अपवाद कहते हैं, तो इसे EmptyBeer, BeerError, BeerNotFound होने दें, लेकिन BeerNotFoundError पहले से ही बहुत कुछ है।

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

इसके अलावा, कोड में अपवाद आमतौर पर उठाने और अपवाद के बाद जाते हैं, और हर कोई तुरंत समझता है कि ये अपवाद हैं। इसलिए, आपको नाम में "अपवाद" जोड़ने की आवश्यकता नहीं है।

पायथन मानक पुस्तकालय में जंग लगे हिस्से भी हैं, लेकिन यह कोड संगठन का एक बहुत अच्छा उदाहरण है:

• कोड की 200,000 लाइनें
• 200 शीर्ष स्तर के मॉड्यूल
• प्रति पैकेज औसतन 10 फाइलें
• 165 अपवाद

एक पैकेज में 10 फाइलें बहुत हैं, लेकिन केवल पुस्तकालय में जोड़े गए कुछ तृतीय-पक्ष परियोजनाओं के कारण, जहां केवल 2 फाइलों के पैकेज थे। यदि आप एक नया अपवाद बनाने का निर्णय लेते हैं, तो बेहतर सोचें, क्योंकि मानक पुस्तकालय में कोड की 1200 लाइनों के लिए 1 अपवाद है।

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

पायथन लाइब्रेरी का एकमात्र अपवाद हीप मॉड्यूल है। एक ढेर कतार, एक ढेर कतार, एक सरणी है जो हमेशा हल होती है। हीपेक मॉड्यूल में एक दर्जन तरीके हैं, और वे सभी एक ही ढेर के साथ काम करते हैं। पहला तर्क हमेशा एक ही रहता है, जिसका अर्थ है कि वर्ग वास्तव में भीख माँगता है।

 heapify(data) pushleft(data, item) popleft(data) pushright(data, item) popright(data) 

आदि

जब भी मुझे heapq का उपयोग करने की आवश्यकता होती है, मैं अपने टूलकिट से इस वर्ग का कार्यान्वयन करता हूं।

 class Heap(object): def __init__(self, data=None, key=lambda x: None): self.heap = data or [] heapq.heapify(self.heap) self.key = key def pushleft(self, item): if self.key: item = (self.key(item), item) heapq.pushleft(self.heap, item) def popleft(self): return heapq.popleft(self.heap)[1] 

कक्षाएं मातम की तरह बढ़ती हैं

पायथन में OAuth की स्थिति महत्वहीन है। फिर, तीसरे पक्ष के पुस्तकालय हैं, और उन्हें अपनी परियोजना में उपयोग करने से पहले, आपको उन्हें पढ़ने की आवश्यकता है।

मैंने Google के url reducer का उपयोग करने का प्रयास किया: मुझे urls लेने और बस उन्हें छोटा करने की आवश्यकता थी। Google के पास एक प्रोजेक्ट है जिसमें 10,000 लाइनें हैं। 115 मॉड्यूल और 207 कक्षाएं। मैंने Google + में इसके बारे में एक खंडन लिखा था, लेकिन कुछ लोगों ने इसे देखा, और गुइडो (वैन रोसुम - लगभग।) टिप्पणी की: "मैं Google के एपीआई कोड के लिए ज़िम्मेदारी लेता हूं।" कोड की 10,000 लाइनें - कुछ होना निश्चित है। - शौरमले जैसा कुछ। यहां, उदाहरण के लिए, फ्लो क्लास है, जिसमें से अन्य को विरासत में मिला है।

 class Flow(object): pass class Storage(object): def put(self, data): _abstract() def get(self): _abstract() def _abstract(): raise NotImplementedError 

वह खाली है। लेकिन उसके पास अपना खुद का मॉड्यूल है, और हर बार उस वर्ग को पढ़ना जो उसे विरासत में मिला है, आपको बाहर जाने की जरूरत है, उस फाइल को देखें और फिर से सुनिश्चित करें कि वह कक्षा खाली है। किसी ने भविष्य को देखा और निर्णय लिया: "अब मैं कोड की 3 पंक्तियाँ लिखूंगा, ताकि भविष्य में ये 3 परिवर्तन न हों।" और अपने पुस्तकालय को पढ़ने वाले सभी लोगों से समय लिया। स्टोरेज क्लास भी है, जो लगभग कुछ भी नहीं करता है। यह मानक अपवादों का उपयोग करके त्रुटियों को सही ढंग से संभालता है, लेकिन वे उपनाम करते हैं, और फिर आपको यह जानने के लिए उनके कोड को पढ़ने की आवश्यकता है कि यह कैसे काम करता है।

OAuth2 को लागू करने में मुझे एक सप्ताह का समय लगा। कोड की दस हजार पंक्तियों को पढ़ने में मुझे कुछ दिनों का समय लगा, जिसके बाद मैंने अन्य पुस्तकालयों की तलाश शुरू की। पाया अजगर- oauth2 यह अजगर-ओएथ का दूसरा संस्करण है, लेकिन यह वास्तव में OAuth2 के साथ काम करना नहीं जानता है, जो तुरंत स्पष्ट नहीं था। हालांकि, यह पुस्तकालय Google से थोड़ा बेहतर है: केवल 540 लाइनें और 15 कक्षाएं।

मैंने इसे और भी आसान बताया और अजगर-फोहाथ 2 कहा। कोड और ३ वर्गों की १३५ लाइनें, और यह अभी भी बहुत कुछ है, मैंने इसे पर्याप्त रूप से प्रतिबिंबित नहीं किया। यहाँ इन तीन वर्गों में से एक है:

 class Error(Exception): pass 

अपमान!

जीवन

अंतिम उदाहरण। आप सभी ने कॉनवे का जीवन खेल देखा होगा, भले ही आपको उसका नाम पता न हो। एक चेकर क्षेत्र है, प्रत्येक चाल जिसे आप मानते हैं, प्रत्येक कोशिका के निकट है, और उनके आधार पर, यह जीवित या मृत हो जाएगा। और आपको ग्लाइडर के रूप में इस तरह के सुंदर स्थिर पैटर्न मिलते हैं: कोशिकाएं सामने आती हैं और पीठ में मर जाती हैं, और ग्लाइडर पूरे क्षेत्र में उड़ने लगता है।

खेल "जीवन" बहुत सरल है: एक क्षेत्र और नियमों का एक जोड़ा। हम साक्षात्कार में इस कार्य को पूछते हैं, क्योंकि यदि आप नहीं जानते कि यह कैसे करना है, तो हमारे पास बात करने के लिए कुछ भी नहीं है। कई लोग तुरंत कहते हैं, “एक कोशिका एक संज्ञा है। वर्ग की जरूरत है। ”इस वर्ग में क्या गुण हैं? जगह, जीवित या नहीं, राज्य अगली बारी, सब कुछ? अभी भी पड़ोसी हैं। फिर वे क्षेत्र का वर्णन करना शुरू करते हैं। एक क्षेत्र बहुत सारी कोशिकाएं हैं, इसलिए यह एक ग्रिड है, इसकी एक "गणना" विधि है, जो कोशिकाओं को अंदर से गिनती है।

 class Cell(object): def __init__(self, x, y, alive=True): self.x = x self.y = y self.alive = alive self.next = None def neigbors(self): for i, j in itertools.product(range(-1, 2), repeat=2): if (i, j) != (0, 0): yield (self.x + i, self.y + j) class Board(object): def __init__(self): self.cells = {} # { (x, y): Cell() } def advance(self): for (x, y), cell in self.cells.items(): alive_neighbors = len(cell.neighbors) cell.next = (alive_neighbors == 3 or (alive_neighbors == 2 and cell.alive)) 

इस बिंदु पर "रोक" कहना आवश्यक है: हमारे पास फ़ील्ड क्लास है, जिसमें 2 विधियाँ हैं: __init__ और "एक चाल करें"। इसमें एक संपत्ति है - एक शब्दकोश, जिसका अर्थ है कि आपको शब्दकोश के साथ काम करने की आवश्यकता है। ध्यान दें कि आपको बिंदु के पड़ोसियों को संग्रहीत करने की आवश्यकता नहीं है, वे पहले से ही शब्दकोश में हैं। एक जीवित बिंदु या नहीं बस एक बूलियन मूल्य है, इसलिए हम केवल जीवित कोशिकाओं के निर्देशांक को संग्रहीत करेंगे। और चूंकि केवल ट्रू शब्दकोष में संग्रहीत किया गया है, आपको शब्दकोश की आवश्यकता नहीं है, लेकिन बस निर्देशांक का एक सेट है। अंत में, एक नए राज्य की आवश्यकता नहीं है, आप बस जीवित कोशिकाओं की सूची को फिर से बना सकते हैं।

 def neigbors(point): x, y = point for i, j in itertools.product(range(-1, 2), repeat=2): if any((i, j)): yield (x + i, y + j) def advance(board): newstate = set() recalc = board | set(itertools.chain(*map(neighbors, board))) for point in recalc: count = sum((neigh in board) for neigh in neighbors(point)) if count == 3 or (count == 2 and point in board): newstate.add(point) return newstate glider = set([(0, 0), (1, 0), (2, 0), (0, 1), (1, 2)]) for i in range(1000): glider = advance(glider) print glider 

यह खेल का एक बहुत ही सरल, संक्षिप्त कार्यान्वयन है। यहां दो वर्गों की जरूरत नहीं है। नीचे - ग्लाइडर के निर्देशांक, उन्हें क्षेत्र में डाला जाता है, और ग्लाइडर उड़ जाता है। वह सब है। यह खेल "जीवन" का पूर्ण कार्यान्वयन है।

सारांश

1. यदि आप __init__ सहित दो विधियों के साथ एक वर्ग देखते हैं, तो यह एक वर्ग नहीं है।
2. अगर जरूरत न हो (और उनकी जरूरत न हो) नए अपवाद न बनाएं।
3. कठिन को सरल बनाएं।

एक अनुवादक से: टिप्पणियों में, मैं देख रहा हूं कि कई ने रिपोर्ट को PLO के पूर्ण खंडन के रूप में माना है। यह एक गलती है। परिणाम के बिंदु 1 में स्पष्ट रूप से कहा गया है कि यह एक वर्ग नहीं है। कक्षाओं की आवश्यकता है, लेकिन रिपोर्ट का सार यह है कि उनका दुरुपयोग नहीं किया जाना चाहिए।