मजबूत पायथन लिपियों का विकास करना

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

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



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

सामग्री के लेखक, जिसका अनुवाद आज हम प्रकाशित करते हैं, उदाहरण के रूप में क्लासिक फ़िज़ बज़ टेस्ट का उपयोग करके इस तरह के "परिवर्तन" का प्रदर्शन करने जा रहा है। यह कार्य विशेष लाइनों के साथ उनमें से कुछ की जगह, 1 से 100 तक की संख्या प्रदर्शित करना है। तो, यदि संख्या 3 की एक बहु है - इसके बजाय आपको स्ट्रिंग Fizz को प्रिंट करने की आवश्यकता है, यदि संख्या 5 की एक बहु है - स्ट्रिंग Buzz , और यदि ये दोनों स्थितियाँ मिलती हैं - FizzBuzz ।

स्रोत कोड

यहाँ एक पायथन स्क्रिप्ट का स्रोत कोड है जो समस्या को हल करता है:

 import sys for n in range(int(sys.argv[1]), int(sys.argv[2])):    if n % 3 == 0 and n % 5 == 0:        print("fizzbuzz")    elif n % 3 == 0:        print("fizz")    elif n % 5 == 0:        print("buzz")    else:        print(n) 

आइए इसे सुधारने के तरीके के बारे में बात करते हैं।

प्रलेखन

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

 #!/usr/bin/env python3 """Simple fizzbuzz generator. This script prints out a sequence of numbers from a provided range with the following restrictions: - if the number is divisible by 3, then print out "fizz", - if the number is divisible by 5, then print out "buzz", - if the number is divisible by 3 and 5, then print out "fizzbuzz". """ 

पहली पंक्ति स्क्रिप्ट के उद्देश्य का एक संक्षिप्त विवरण देती है। शेष पैराग्राफ स्क्रिप्ट के बारे में अतिरिक्त जानकारी प्रदान करते हैं।

कमांड लाइन तर्क

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

 import argparse import sys class CustomFormatter(argparse.RawDescriptionHelpFormatter,                      argparse.ArgumentDefaultsHelpFormatter):    pass def parse_args(args=sys.argv[1:]):    """Parse arguments."""    parser = argparse.ArgumentParser(        description=sys.modules[__name__].__doc__,        formatter_class=CustomFormatter)    g = parser.add_argument_group("fizzbuzz settings")    g.add_argument("--fizz", metavar="N",                   default=3,                   type=int,                   help="Modulo value for fizz")    g.add_argument("--buzz", metavar="N",                   default=5,                   type=int,                   help="Modulo value for buzz")    parser.add_argument("start", type=int, help="Start value")    parser.add_argument("end", type=int, help="End value")    return parser.parse_args(args) options = parse_args() for n in range(options.start, options.end + 1):    # ... 

इन बदलावों से स्क्रिप्ट को काफी फायदा होता है। अर्थात्, पैरामीटर अब ठीक से प्रलेखित हैं, आप --help ध्वज का उपयोग करके उनके उद्देश्य का पता लगा सकते हैं। इसके अलावा, इसी कमांड के अनुसार, पिछले डॉक्यूमेंट में हमने जो डॉक्यूमेंटेशन लिखा था वह भी प्रदर्शित है:

 $ ./fizzbuzz.py --help usage: fizzbuzz.py [-h] [--fizz N] [--buzz N] start end Simple fizzbuzz generator. This script prints out a sequence of numbers from a provided range with the following restrictions: - if the number is divisible by 3, then print out "fizz", - if the number is divisible by 5, then print out "buzz", - if the number is divisible by 3 and 5, then print out "fizzbuzz". positional arguments:  start     Start value  end      End value optional arguments:  -h, --help  show this help message and exit fizzbuzz settings:  --fizz N   Modulo value for fizz (default: 3)  --buzz N   Modulo value for buzz (default: 5) 

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

लॉगिंग

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

 import logging import logging.handlers import os import sys logger = logging.getLogger(os.path.splitext(os.path.basename(sys.argv[0]))[0]) 

तब हम लॉगिंग के दौरान प्रदर्शित जानकारी के विवरण को नियंत्रित करना संभव बना देंगे। तो, logger.debug() कमांड को कुछ तभी आउटपुट करना चाहिए जब स्क्रिप्ट को --debug स्विच के साथ चलाया जाए। यदि स्क्रिप्ट को --silent साथ चलाया जाता है, तो स्क्रिप्ट को अपवाद संदेशों के अलावा कुछ भी प्रदर्शित नहीं करना चाहिए। इन सुविधाओं को लागू करने के लिए, निम्नलिखित कोड को parse_args() :

 #  parse_args() g = parser.add_mutually_exclusive_group() g.add_argument("--debug", "-d", action="store_true",               default=False,               help="enable debugging") g.add_argument("--silent", "-s", action="store_true",               default=False,               help="don't log to console") 

लॉगिंग को कॉन्फ़िगर करने के लिए प्रोजेक्ट कोड में निम्न फ़ंक्शन जोड़ें:

 def setup_logging(options):    """Configure logging."""    root = logging.getLogger("")    root.setLevel(logging.WARNING)    logger.setLevel(options.debug and logging.DEBUG or logging.INFO)    if not options.silent:        ch = logging.StreamHandler()        ch.setFormatter(logging.Formatter(            "%(levelname)s[%(name)s] %(message)s"))        root.addHandler(ch) 

मुख्य स्क्रिप्ट कोड निम्नानुसार बदल जाएगा:

 if __name__ == "__main__":    options = parse_args()    setup_logging(options)    try:        logger.debug("compute fizzbuzz from {} to {}".format(options.start,                                                             options.end))        for n in range(options.start, options.end + 1):            # ..    except Exception as e:        logger.exception("%s", e)        sys.exit(1)    sys.exit(0) 

यदि आप उपयोगकर्ता की प्रत्यक्ष भागीदारी के बिना स्क्रिप्ट को चलाने की योजना बनाते हैं, उदाहरण के लिए, crontab का उपयोग करके, आप इसके आउटपुट को syslog जा सकते हैं:

 def setup_logging(options):    """Configure logging."""    root = logging.getLogger("")    root.setLevel(logging.WARNING)    logger.setLevel(options.debug and logging.DEBUG or logging.INFO)    if not options.silent:        if not sys.stderr.isatty():            facility = logging.handlers.SysLogHandler.LOG_DAEMON            sh = logging.handlers.SysLogHandler(address='/dev/log',                                                facility=facility)            sh.setFormatter(logging.Formatter(                "{0}[{1}]: %(message)s".format(                    logger.name,                    os.getpid())))            root.addHandler(sh)        else:            ch = logging.StreamHandler()            ch.setFormatter(logging.Formatter(                "%(levelname)s[%(name)s] %(message)s"))            root.addHandler(ch) 

हमारी छोटी स्क्रिप्ट में, कोड की एक समान राशि केवल logger.debug() कमांड का उपयोग करने के लिए आवश्यक लगती है। लेकिन वास्तविक लिपियों में यह कोड ऐसा नहीं लगेगा और इससे होने वाला लाभ सबसे आगे आएगा, अर्थात् इसकी मदद से उपयोगकर्ता समस्या को हल करने की प्रगति के बारे में पता लगा पाएंगे।

 $ ./fizzbuzz.py --debug 1 3 DEBUG[fizzbuzz] compute fizzbuzz from 1 to 3 1 2 fizz 

परीक्षण

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

 def fizzbuzz(n, fizz, buzz):    """Compute fizzbuzz nth item given modulo values for fizz and buzz.    >>> fizzbuzz(5, fizz=3, buzz=5)    'buzz'    >>> fizzbuzz(3, fizz=3, buzz=5)    'fizz'    >>> fizzbuzz(15, fizz=3, buzz=5)    'fizzbuzz'    >>> fizzbuzz(4, fizz=3, buzz=5)    4    >>> fizzbuzz(4, fizz=4, buzz=6)    'fizz'    """    if n % fizz == 0 and n % buzz == 0:        return "fizzbuzz"    if n % fizz == 0:        return "fizz"    if n % buzz == 0:        return "buzz"    return n 

आप pytest का उपयोग करके फ़ंक्शन के सही संचालन को सत्यापित कर सकते हैं:

 $ python3 -m pytest -v --doctest-modules ./fizzbuzz.py ============================ test session starts ============================= platform linux -- Python 3.7.4, pytest-3.10.1, py-1.8.0, pluggy-0.8.0 -- /usr/bin/python3 cachedir: .pytest_cache rootdir: /home/bernat/code/perso/python-script, inifile: plugins: xdist-1.26.1, timeout-1.3.3, forked-1.0.2, cov-2.6.0 collected 1 item fizzbuzz.py::fizzbuzz.fizzbuzz PASSED                 [100%] ========================== 1 passed in 0.05 seconds ========================== 

यह सब काम करने के लिए, आपको स्क्रिप्ट नाम के बाद आने के लिए .py विस्तार की आवश्यकता है। मैं स्क्रिप्ट नामों में एक्सटेंशन जोड़ना पसंद नहीं करता: भाषा केवल एक तकनीकी विवरण है जिसे उपयोगकर्ता को दिखाने की आवश्यकता नहीं है। हालांकि, ऐसा लगता है कि एक स्क्रिप्ट नाम को एक एक्सटेंशन के साथ लैस करना सबसे आसान तरीका है जो सिस्टम को चलाने के लिए परीक्षण करता है, जैसे कि pytest , कोड में शामिल परीक्षणों को ढूंढें।

यदि कोई त्रुटि pytest एक संदेश प्रदर्शित करेगा जो संबंधित कोड के स्थान और समस्या की प्रकृति को दर्शाता है:

 $ python3 -m pytest -v --doctest-modules ./fizzbuzz.py -k fizzbuzz.fizzbuzz ============================ test session starts ============================= platform linux -- Python 3.7.4, pytest-3.10.1, py-1.8.0, pluggy-0.8.0 -- /usr/bin/python3 cachedir: .pytest_cache rootdir: /home/bernat/code/perso/python-script, inifile: plugins: xdist-1.26.1, timeout-1.3.3, forked-1.0.2, cov-2.6.0 collected 1 item fizzbuzz.py::fizzbuzz.fizzbuzz FAILED                 [100%] ================================== FAILURES ================================== ________________________ [doctest] fizzbuzz.fizzbuzz _________________________ 100 101   >>> fizzbuzz(5, fizz=3, buzz=5) 102   'buzz' 103   >>> fizzbuzz(3, fizz=3, buzz=5) 104   'fizz' 105   >>> fizzbuzz(15, fizz=3, buzz=5) 106   'fizzbuzz' 107   >>> fizzbuzz(4, fizz=3, buzz=5) 108   4 109   >>> fizzbuzz(4, fizz=4, buzz=6) Expected:    fizz Got:    4 /home/bernat/code/perso/python-script/fizzbuzz.py:109: DocTestFailure ========================== 1 failed in 0.02 seconds ========================== 

यूनिट परीक्षणों को नियमित कोड के रूप में भी लिखा जा सकता है। कल्पना करें कि हमें निम्नलिखित फ़ंक्शन का परीक्षण करने की आवश्यकता है:

 def main(options):    """Compute a fizzbuzz set of strings and return them as an array."""    logger.debug("compute fizzbuzz from {} to {}".format(options.start,                                                         options.end))    return [str(fizzbuzz(i, options.fizz, options.buzz))            for i in range(options.start, options.end+1)] 

स्क्रिप्ट के अंत में, हम पैरामीटर परीक्षण कार्यों का उपयोग pytest लिए pytest का उपयोग करते हुए निम्नलिखित इकाई परीक्षण pytest :

 #   import pytest          # noqa: E402 import shlex          # noqa: E402 @pytest.mark.parametrize("args, expected", [    ("0 0", ["fizzbuzz"]),    ("3 5", ["fizz", "4", "buzz"]),    ("9 12", ["fizz", "buzz", "11", "fizz"]),    ("14 17", ["14", "fizzbuzz", "16", "17"]),    ("14 17 --fizz=2", ["fizz", "buzz", "fizz", "17"]),    ("17 20 --buzz=10", ["17", "fizz", "19", "buzz"]), ]) def test_main(args, expected):    options = parse_args(shlex.split(args))    options.debug = True    options.silent = True    setup_logging(options)    assert main(options) == expected 

कृपया ध्यान दें कि, चूंकि स्क्रिप्ट कोड sys.exit() कॉल के साथ समाप्त होता है, इसलिए जब इसे सामान्य रूप से कहा जाता है, तो परीक्षण निष्पादित नहीं किए जाएंगे। इसके लिए धन्यवाद, स्क्रिप्ट को चलाने के लिए किसी भी प्रकार की आवश्यकता नहीं है।

मापदंडों के प्रत्येक समूह के लिए परीक्षण फ़ंक्शन को एक बार बुलाया जाएगा। parse_args() इकाई को parse_args() फ़ंक्शन के इनपुट के रूप में उपयोग किया जाता है। इस तंत्र के लिए धन्यवाद, हमें वह मिलता है जो हमें main() फ़ंक्शन को पास करने की आवश्यकता है। expected इकाई की तुलना main() । अगर सब कुछ उम्मीद के pytest काम करता है, तो यहां हमें बताएंगे:

 $ python3 -m pytest -v --doctest-modules ./fizzbuzz.py ============================ test session starts ============================= platform linux -- Python 3.7.4, pytest-3.10.1, py-1.8.0, pluggy-0.8.0 -- /usr/bin/python3 cachedir: .pytest_cache rootdir: /home/bernat/code/perso/python-script, inifile: plugins: xdist-1.26.1, timeout-1.3.3, forked-1.0.2, cov-2.6.0 collected 7 items fizzbuzz.py::fizzbuzz.fizzbuzz PASSED                 [ 14%] fizzbuzz.py::test_main[0 0-expected0] PASSED              [ 28%] fizzbuzz.py::test_main[3 5-expected1] PASSED              [ 42%] fizzbuzz.py::test_main[9 12-expected2] PASSED             [ 57%] fizzbuzz.py::test_main[14 17-expected3] PASSED             [ 71%] fizzbuzz.py::test_main[14 17 --fizz=2-expected4] PASSED        [ 85%] fizzbuzz.py::test_main[17 20 --buzz=10-expected5] PASSED        [100%] ========================== 7 passed in 0.03 seconds ========================== 

यदि कोई त्रुटि होती है, तो pytest क्या हुआ के बारे में उपयोगी जानकारी प्रदान करेगा:

 $ python3 -m pytest -v --doctest-modules ./fizzbuzz.py [...] ================================== FAILURES ================================== __________________________ test_main[0 0-expected0] __________________________ args = '0 0', expected = ['0']    @pytest.mark.parametrize("args, expected", [        ("0 0", ["0"]),        ("3 5", ["fizz", "4", "buzz"]),        ("9 12", ["fizz", "buzz", "11", "fizz"]),        ("14 17", ["14", "fizzbuzz", "16", "17"]),        ("14 17 --fizz=2", ["fizz", "buzz", "fizz", "17"]),        ("17 20 --buzz=10", ["17", "fizz", "19", "buzz"]),    ])    def test_main(args, expected):        options = parse_args(shlex.split(args))        options.debug = True        options.silent = True        setup_logging(options)       assert main(options) == expected E    AssertionError: assert ['fizzbuzz'] == ['0'] E     At index 0 diff: 'fizzbuzz' != '0' E     Full diff: E     - ['fizzbuzz'] E     + ['0'] fizzbuzz.py:160: AssertionError ----------------------------- Captured log call ------------------------------ fizzbuzz.py        125 DEBUG compute fizzbuzz from 0 to 0 ===================== 1 failed, 6 passed in 0.05 seconds ===================== 

इस आउटपुट में logger.debug() कमांड से आउटपुट logger.debug() शामिल है। स्क्रिप्टिंग में लॉगिंग तंत्र का उपयोग करने का यह एक और अच्छा कारण है। यदि आप pytest की महान विशेषताओं के बारे में अधिक जानना चाहते हैं, तो इस सामग्री पर एक नज़र डालें।

परिणाम

इन चार चरणों का पालन करके आप पायथन लिपियों को अधिक विश्वसनीय बना सकते हैं:

• फ़ाइल के शीर्ष पर स्थित दस्तावेज़ के साथ स्क्रिप्ट से लैस करें।
• उन मापदंडों का दस्तावेजीकरण करने के लिए argparse मॉड्यूल का उपयोग करें argparse साथ स्क्रिप्ट को बुलाया जा सकता है।
• स्क्रिप्ट संचालन प्रक्रिया के बारे में जानकारी प्रदर्शित करने के लिए logging मॉड्यूल का उपयोग करें।
• इकाई परीक्षण लिखें।

यहाँ चर्चा की गई उदाहरण के लिए पूरा कोड है। आप इसे अपनी स्वयं की स्क्रिप्ट के लिए टेम्पलेट के रूप में उपयोग कर सकते हैं।

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

प्रिय पाठकों! क्या आप इस प्रकाशन में दी गई पायथन लिपियों को लिखने के लिए सिफारिशें लागू करने की योजना बना रहे हैं?