Zen of Python से मिली सीख

Zen of Python क्या है? 

Zen of Python उन्नीस सूत्रों का एक संग्रह है जो Python के डिज़ाइन के लिए मार्गदर्शक सिद्धांतों के रूप में काम करता है। दरअसल, यह बीस सूत्र होने थे; लेकिन Python के निर्माता Guido van Rossum ने अब तक Tim Peters (Zen of Python के निर्माता) की मंशा के अनुसार अंतिम सूत्र नहीं जोड़ा है। रिपोर्ट के मुताबिक Guido ने कहा था कि गायब बीसवां सूत्र “Tim Peters का कोई अजीब सा अंदरूनी मज़ाक” है।

बीसवां सूत्र न होने के बावजूद, Zen of Python को 2004 में PEP 20 के रूप में मानकीकृत किया गया क्योंकि इसका Python प्रोग्रामरों की विकास प्रक्रिया पर गहरा प्रभाव था। Zen of Python का पालन करना अनिवार्य नहीं है, लेकिन इसे जानना और ध्यान में रखना उचित है। यदि आप कभी ये सीखें भूल जाएँ, तो Python इंटरप्रेटर से import this चलाकर आसानी से याद ताज़ा कर सकते हैं। 

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

इस लेख में, हम प्रत्येक सीख को विस्तार से समझेंगे। 

#1 सुंदर, भद्दे से बेहतर है 

यदि आप प्रोग्रामर हैं, तो इसमें संदेह नहीं कि आप अत्यंत कुशल हैं। कोड के ज़रिए समस्याएँ सुलझाना आसान काम नहीं है, लेकिन एक Pythonista के रूप में आपसे और अपेक्षा की जाती है। सुंदर कोड भद्दे कोड से बेहतर होता है। Python की तेज़ी से बढ़ती लोकप्रियता का एक कारण इसकी सुगमता भी है: यह सरल, पठनीय और सुरुचिपूर्ण है। एक Python डेवलपर के रूप में, सुंदर कोड लिखकर pythonic मानक बनाए रखना आपकी ज़िम्मेदारी है। 

सुंदर कोड क्या है? खैर, यह व्यक्तिपरक है — सौंदर्य देखने वाले की नज़र में होता है वगैरह वगैरह। एक आसान नीयम जो आपको संतुलित रखेगा: साफ-सुथरा, पठनीय कोड लिखें जिसे अन्य डेवलपर आसानी से समझ सकें। उदाहरण के लिए: 

"""
Initial code was created by Vishal Sharma
See:  https://towardsdatascience.com/the-zen-of-python-a-guide-to-pythons-design-principles-93f3f76d088a
"""
def collatz(num):
    if num % 2 == 0:
        return num // 2
    else:
        return 3 * num + 1

number = input("Enter a number: ")

while number != 1:
    number = collatz(int(number))
    print(number)

"""
Enter a number: 5
16
8
4
2
1
"""

ऊपर का कोड ठीक चलता है, पर यह ज़रूरी नहीं कि यह सुंदर भी हो। हमारी collatz फ़ंक्शन में एक अनावश्यक else है, जिसे ऐसे हटाया जा सकता है: 

def collatz(num):
  if num % 2 == 0:
      return num // 2
 
  return 3 * num + 1

इसलिए, जब आपके पास दो काम करने वाले समाधानों में चुनाव हो, तो वही चुनें जो सरल, अधिक पठनीय और समझने में आसान हो। 

#2 स्पष्ट, अप्रत्यक्ष से बेहतर है

किसी भी सूत्र को “स्वयंस्पष्ट” कहना बड़ी भूल है — फिर भी लोग ऐसा करते दिखेंगे। “स्पष्ट, अप्रत्यक्ष से बेहतर है” का मर्म यह है कि विस्तारपूर्वक लिखा गया कोड परोक्ष, घुमावदार कोड से बेहतर होता है। हरसंभव करें कि आपके कोड की कार्यप्रणाली किसी दुर्लभ या धुंधली भाषा के पीछे छिपी न रहे। जिसे आपके प्रोग्राम का पूर्वज्ञान न हो, वह भी आपके कोड में क्या हो रहा है, समझ सके। 

#3 सरल, जटिल से बेहतर है

यदि आपका दोस्त खाने के बाद बर्तन धोने को जेटवॉश निकाल ले, तो आप शायद हँसेंगे। यह न सिर्फ़ मूर्खतापूर्ण हल है, बल्कि प्लेटों के टूटने की भी पूरी आशंका है। इसी तरह, किसी सरल प्रोग्रामिंग समस्या पर अति-जटिल समाधान थोपना बेहद अव्यावहारिक है। समाधान को अनावश्यक रूप से पेचीदा न बनाएं, चाहे आपको लगे इससे आप अधिक चतुर दिखेंगे। इससे लाभ से अधिक हानि हो सकती है, और Python में इसकी कद्र नहीं। 

इस स्ट्रिंग को उल्टा करने वाली फ़ंक्शन को देखें: 

def reverse_string(string):
    if len(string) == 1:
        return string
    else:
        return reverse_string(string[1:]) + string[0]


string = "kurtis"

print(reverse_string(string))

"""
sitruk
"""

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

string = "kurtis"

# annonymous function solution
reverse_string = lambda x: x[::-1]

# function solution
def reverse(string):
    return string[::-1]

print(reverse_string(string))
print(reverse(string))

"""
sitruk
sitruk
"""

#4 जटिल, उलझे (complicated) से बेहतर है 

अब, जेटवॉश से प्लेट धोना अव्यावहारिक है: साधारण नल के पानी जैसा सरल उपाय बेहतर है। पर यदि काम 4x4 Range Rover को साफ़ करना हो? पिछला और यह सूत्र याद दिलाते हैं कि एक ही समस्या के लिए सरल और जटिल, दोनों तकनीकें लागू हो सकती हैं। 4x4 Range Rover साफ़ करना सरल समस्या नहीं है, और प्लेट धोने की तकनीकें वहाँ लगाना कारगर हो सकता है पर जेटवॉश की तुलना में ज़्यादा उलझा होगा। इसलिए सादगी को तरजीह दें, पर जहाँ सादगी अव्यावहारिक हो, वहाँ जटिलता अपनाना बेहतर है — सादगी की सीमा जानें। 

#5 समतल (फ्लैट) संरचना, नेस्टेड से बेहतर है 

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

सारा कोड एक टॉप-लेयर मॉड्यूल में रखना गलत नहीं है: यानी आपको किसी विशेष फ़ंक्शनैलिटी के लिए from spam.foo.bar.john.doe import chicken जैसा कुछ नहीं करना पड़े। जितनी अधिक उप-श्रेणियाँ जोड़ेंगे, कोड उतना जटिल होता जाएगा। जहाँ संभव हो, फ्लैट संरचना अपनाने की कोशिश करें।

#6 विरल (स्पार्स) कोड, घना (डेंस) से बेहतर है

प्रोग्रामर अत्यंत बुद्धिमान माने जाते हैं, इसलिए अपनी बुद्धि दिखाने के लिए अतिरंजित हैक्स की ज़रूरत नहीं। एक आम चलन है “कैसे [कोई जटिल काम] सिर्फ़ 1 लाइन में करें।” कभी-कभी वन-लाइनर उचित होते हैं, पर सिर्फ़ एक लाइन में सारी कार्यक्षमता समेटने के चक्कर में पठनीयता से समझौता करने से बचें। 

उदाहरण के लिए यह कोड देखें: 

"""
Code source Al Sweigart
See: https://inventwithpython.com/blog/author/al-sweigart.html0
"""
print('\n'.join("%i bytes = %i bits which has %i possible values." % (j, j*8, 256**j-1) for j in (1 << i for i in range(8))))
"""
1 bytes = 8 bits which has 255 possible values.
2 bytes = 16 bits which has 65535 possible values.
4 bytes = 32 bits which has 4294967295 possible values.
8 bytes = 64 bits which has 18446744073709551615 possible values.
16 bytes = 128 bits which has 340282366920938463463374607431768211455 possible values.
32 bytes = 256 bits which has 115792089237316195423570985008687907853269984665640564039457584007913129639935 possible values.
64 bytes = 512 bits which has 13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095 possible values.
128 bytes = 1024 bits which has 179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137215 possible values.
"""

कोड काम तो करता है, लेकिन समझने में बेहद कठिन है: ठूँसा हुआ और पढ़ने में भारी। 

देखें, वही कोड विरल शैली में कैसा लगेगा: 

# Sparse example
bytes_and_bits = {j: j*8 for j in (1 << i for i in range(8))}

for bytes, bits in bytes_and_bits.items():
    print(f"{bytes} bytes = {bits} which has {256**bytes-1} possible values")

"""
1 bytes = 8 which has 255 possible values
2 bytes = 16 which has 65535 possible values
4 bytes = 32 which has 4294967295 possible values
8 bytes = 64 which has 18446744073709551615 possible values
16 bytes = 128 which has 340282366920938463463374607431768211455 possible values
32 bytes = 256 which has 115792089237316195423570985008687907853269984665640564039457584007913129639935 possible values
64 bytes = 512 which has 13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084095 possible values
128 bytes = 1024 which has 179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137215 possible values
"""

यह कोड पढ़ने में कहीं आसान है और वही काम करता है जो वन-लाइनर करता था।

#7 पठनीयता मायने रखती है

यदि अब तक आपने समझ न लिया हो, तो Python में पठनीयता सचमुच मायने रखती है। आपका काम कोड एक बार लिखना है। लेकिन इसे कई बार पढ़ा जाएगा। इसे ध्यान में रखते हुए, वेरिएबल और फ़ंक्शन नामों से स्वरों को हटाना अच्छा विचार नहीं है: जहाँ आप create_lst और create_list में से चुन सकते हों, वहाँ बाद वाला चुनें। 

#8 विशेष मामलों को नियम तोड़ने लायक विशेष नहीं समझें

Python [और सामान्यतः प्रोग्रामिंग] में कई सर्वोत्तम प्रथाएँ हैं जिनका पालन करना चाहिए। अपनी मनमानी करने से बेहतर है सर्वोत्तम प्रथाओं का अनुसरण करना, क्योंकि मनमानी अक्सर असंगत और अपठनीय कोड की ओर ले जाती है। 

#9 यद्यपि व्यावहारिकता, शुद्धता पर भारी पड़ती है

नौवीं सीख, आठवीं का विस्तार है। हाँ, सर्वोत्तम प्रथाओं का पालन बेहतर है, पर नियमों का अंधानुकरण भी अपठनीय कोड दे सकता है। इसलिए, हर नियम के अपवाद हो सकते हैं। यदि आपका समाधान अधिक व्यावहारिक, पठनीय और समझने में आसान है, तो स्थापित सर्वोत्तम प्रथाओं से कुछ अलग जाना बेहतर है। 

#10 त्रुटियाँ कभी चुपचाप न गुजरें 

मौन त्रुटि वह है जब प्रोग्राम अपवाद उठाने के बजाय कोई एरर कोड या None लौटा दे। त्रुटि दबाकर प्रोग्राम चलने देने से बेहतर है कि वह क्रैश हो जाए। लंबी अवधि में त्रुटियों को दबाना ऐसे बग्स को जन्म दे सकता है जिन्हें बाद में मिटाना कहीं कठिन हो जाता है। 

#11 जब तक कि उन्हें स्पष्ट रूप से मौन न किया जाए

ग्यारहवीं सीख, दसवीं का विस्तार है। कुछ स्थितियों में आप अपने प्रोग्राम द्वारा उत्पन्न त्रुटियों को अनदेखा करना चाहेंगे। ऐसे मामलों में, सर्वोत्तम तरीका यह है कि अपने कोड में त्रुटि को स्पष्ट रूप से मौन करें। 

#12 अस्पष्टता की स्थिति में, अनुमान लगाने के प्रलोभन का विरोध करें

कंप्यूटर वही करते हैं जो हम उन्हें करने को कहते हैं: यदि आपका कोड मनमाफिक व्यवहार नहीं कर रहा, तो वह वही कर रहा है जो आपने उसे बताया है। बिना समझे, कई समाधान आज़माते जाना ताकि कोई एक काम कर जाए — यह बुरी रणनीति है; आप समस्या सुलझाने के बजाय उसे ढँक सकते हैं। प्रलोभन का विरोध करें। इसके बजाय, समस्या की तर्कशृंखला पर सोचें और विवेक से उपयुक्त समाधान निकालें। 

#13 इसे करने का एक — और अधिमानतः सिर्फ़ एक — स्पष्ट तरीका होना चाहिए 

Perl प्रोग्रामिंग भाषा का नारा है: “इसे करने के एक से अधिक तरीके हैं!” बहुत सारे विकल्प अक्सर निर्णय-अधिभार (choice overload) लाते हैं। वैसा ही तब होता है जब एक ही लक्ष्य साधने के कई कोड-तरीके हों। आपके पास कोड लिखने की अधिक लचीलापन तो होगी, पर अब कोड पढ़ने के लिए आपको सभी संभावित तरीकों को जानना पड़ेगा: यह अतिरिक्त सीखने का बोझ अनावश्यक है। 

#14 यद्यपि वह तरीका पहले स्पष्ट न हो — जब तक कि आप डच न हों

यह सूत्र Tim Peters के हास्यबोध को दिखाता है: Python के निर्माता और Python के BDFL (Benevolent Dictator For Life) Guido van Rossum डच हैं। यह मज़ाक याद दिलाता है कि Python की भाषा-नियमों को समझना और याद रखना, इसके निर्माता को छोड़कर, सबके लिए कठिन हो सकता है। 

#15 अभी, कभी नहीं से बेहतर है

यह सूत्र बताता है कि अनंत लूप में फँसा या अटका हुआ कोड, उस कोड से भी बुरा है जो नहीं चलता। 

#16 यद्यपि कई बार “कभी नहीं” “अभी तुरंत” से बेहतर होता है

पिछली सीख के आगे बढ़ते हुए: आपके प्रोग्राम के पूरा होने का इंतज़ार करना, उसे बीच में रोककर गलत परिणाम लेने से बेहतर है। 

#17 यदि कार्यान्वयन समझाना कठिन है, तो यह बुरा विचार है

सिर्फ़ इतना काफी नहीं कि आप अपनी ही रचना समझते हैं — “मैं जानता हूँ मैं क्या कहना चाहता हूँ” चल नहीं पाता। प्रोग्रामिंग टीमगत गतिविधि है, और यदि आप अपने साथियों को अपना कार्यान्वयन समझा नहीं पा रहे, तो बहुत संभव है आपने समाधान अनावश्यक रूप से जटिल बना दिया है। 

#18 यदि कार्यान्वयन समझाना आसान है, तो यह अच्छा विचार हो सकता है

हालाँकि, आसानी से समझाया जा सकना यह नहीं दर्शाता कि कोड बुरा नहीं है — यह सिर्फ़ दर्शाता है कि उसे समझाना आसान है। कोड अभी भी ख़राब हो सकता है, पर उसे सहजता से समझा पाना बताता है कि आप सही दिशा में हैं। 

#19 नेमस्पेस बेहतरीन सोच है — ऐसे और करें!

नेमस्पेस, Python में एक अमूर्तता (abstraction) है जिसका उपयोग प्रोग्राम में ऑब्जेक्ट्स को सौंपे गए नामों को व्यवस्थित करने के लिए होता है। किसी विशेष नेमस्पेस और स्कोप के संदर्भ में, जब आप किसी सांकेतिक नाम को कॉल करते हैं, तो Python यह निर्धारित कर पाता है कि आप किस ऑब्जेक्ट का संदर्भ दे रहे हैं। इस सूत्र का आशय बस इतना है कि Python पर्दे के पीछे सांकेतिक नामों को जिस तरह व्यवस्थित करता है, वह काफ़ी शानदार है। 

निष्कर्ष 

इस लेख में, हमने Zen of Python की अपनी व्याख्या प्रस्तुत की — ऐसे दिशा-निर्देश जो Python प्रोग्रामरों को साफ-सुथरा, पठनीय कोड लिखने के लिए प्रेरित करते हैं। जहाँ कुछ लोग Zen of Python को सहज कोड-लेखन का अंतिम ब्लूप्रिंट मानते हैं, वहीं कुछ इसे उतनी गंभीरता से नहीं लेते। हम सुझाव देते हैं कि आप इन सिद्धांतों को अपने कोड में आज़माएँ और देखें कि ये आपके काम में प्रत्यक्ष रूप से कैसे सुधार लाते हैं। यदि आप अनुकूलित कोड लिखने के बारे में और सीखना चाहते हैं, तो DataCamp का Writing Efficient Python Code देखें।