उपयोगी पायथन टिप्स जो आप पहले कभी नहीं मिले हैं। भाग २

हमने हाल ही में सामग्री का अनुवाद प्रकाशित किया है, जो पायथन प्रोग्रामर्स के लिए उपयोगी सुझाव प्रदान करता है। उस सामग्री की अगली कड़ी है जिसे आज हम आपके ध्यान में ला रहे हैं।

स्लाइस फ़ंक्शन का उपयोग करके स्लाइस नामकरण

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

#       ID First Name   Last Name line_record = "2    John Smith" ID = slice(0, 8) FIRST_NAME = slice(9, 21) LAST_NAME = slice(22, 27) name = f"{line_record[FIRST_NAME].strip()} {line_record[LAST_NAME].strip()}" # name == "John Smith" 

इस उदाहरण में, आप देख सकते हैं कि स्लाइस फ़ंक्शन का उपयोग करके स्लाइस नाम देकर, और इन नामों का उपयोग करके स्ट्रिंग के टुकड़े प्राप्त करने के लिए, हम जटिल इंडेक्स से छुटकारा पाने में सक्षम थे। आप .start , .stop और .step विशेषताओं का उपयोग करके slice ऑब्जेक्ट के बारे में अधिक जान सकते हैं।

कार्यक्रम के निष्पादन के दौरान उपयोगकर्ता से एक पासवर्ड का अनुरोध करना

कई कमांड लाइन टूल या स्क्रिप्ट को काम करने के लिए उपयोगकर्ता नाम और पासवर्ड की आवश्यकता होती है। यदि आपको ऐसा प्रोग्राम लिखना है, तो आपको getpass मॉड्यूल getpass हो सकता getpass :

 import getpass user = getpass.getuser() password = getpass.getpass() #   ... 

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

स्ट्रिंग्स में करीबी मैच खोजना

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

 import difflib difflib.get_close_matches('appel', ['ape', 'apple', 'peach', 'puppy'], n=2) # returns ['apple', 'ape'] 

difflib.get_close_matches विधि सबसे अच्छा, "पर्याप्त पर्याप्त" मेल खाती है। इस पद्धति का पहला तर्क खोज स्ट्रिंग निर्दिष्ट करता है, दूसरा तर्क उस सूची को निर्दिष्ट करता है जिसमें खोज की जाती है। इस विधि को एक वैकल्पिक तर्क n पास किया जा सकता है, जो लौटाए गए मैचों की अधिकतम संख्या को निर्दिष्ट करता है। यह विधि वैकल्पिक नामित तर्क cutoff का भी समर्थन करती है (डिफ़ॉल्ट रूप से यह 0.6 सेट है), जो आपको मैचों के मूल्यांकन के लिए एक थ्रेशोल्ड मान सेट करने की अनुमति देता है।

IP पते के साथ काम करें

यदि आपको नेटवर्क के साथ काम करने के लिए पायथन प्रोग्राम लिखना है, तो इसका मतलब है कि ipaddress मॉड्यूल आपके लिए बहुत उपयोगी हो सकता है। इसका उपयोग करने का एक विकल्प सीआईडीआर प्रारूप (क्लासलेस इंटर-डोमेन रूटिंग, क्लासलेस एड्रेसिंग) में निर्दिष्ट पते की एक श्रृंखला से आईपी पते की एक सूची तैयार करना है।

 import ipaddress net = ipaddress.ip_network('74.125.227.0/29') #      IPv6 # IPv4Network('74.125.227.0/29') for addr in net:    print(addr) # 74.125.227.0 # 74.125.227.1 # 74.125.227.2 # 74.125.227.3 # ... 

इस मॉड्यूल की एक अन्य उपयोगी विशेषता एक निश्चित नेटवर्क से संबंधित आईपी पते की जांच कर रही है:

 ip = ipaddress.ip_address("74.125.227.3") ip in net # True ip = ipaddress.ip_address("74.125.227.12") ip in net # False 

ipaddress मॉड्यूल में कई अन्य रोचक विशेषताएं हैं जिनके बारे में मैं यहां बात नहीं कर रहा हूं। उसके बारे में यहाँ और पढ़ें। सच है, इस मॉड्यूल का उपयोग करते हुए, नेटवर्क प्रोग्रामिंग से संबंधित अन्य मॉड्यूल के साथ इसके संयुक्त कार्य के बारे में सीमाओं पर विचार करें। उदाहरण के लिए, आप IPv4Network इंस्टेंस का उपयोग एड्रेस स्ट्रिंग्स के रूप में नहीं कर सकते। इसके लिए समान वस्तुओं को पहले str का उपयोग करके तार में परिवर्तित किया जाना चाहिए।

कमांड लाइन पर एक प्रोग्राम डिबगिंग

यदि आप उन लोगों में से हैं जो IDE का उपयोग नहीं करना चाहते हैं और Vim या Emacs में कोड लिखते हैं, तो आप ऐसी स्थिति में हो सकते हैं, जहां आपको IDE में डिबगर की आवश्यकता होगी। और आपको पता है क्या? आपके पास पहले से ही ऐसा डिबगर है। इसका उपयोग करने के लिए, बस python3.8 -i जैसी संरचना का उपयोग करके कार्यक्रम python3.8 -i । -i झंडा कार्यक्रम के पूरा होने पर, एक इंटरैक्टिव शेल लॉन्च करने की अनुमति देता है। इसका उपयोग करते हुए, आप चर और कॉल फ़ंक्शन की जांच कर सकते हैं। यह एक दिलचस्प विशेषता है, लेकिन असली डिबगर (पीडीबी) के बारे में क्या? चलिए निम्नलिखित सरल प्रोग्राम के साथ प्रयोग करते हैं, जिसका कोड script.py फ़ाइल में है:

 def func():    return 0 / 0 func() 

इसे python3.8 -i script.py और निम्न प्राप्त करें:

 #   ... Traceback (most recent call last):  File "script.py", line 4, in <module>    func()  File "script.py", line 2, in func    return 0 / 0 ZeroDivisionError: division by zero >>> import pdb >>> pdb.pm() #      > script.py(2)func() -> return 0 / 0 (Pdb) 

हम उस कार्यक्रम की जगह देखते हैं जहां दुर्घटना हुई थी। एक ब्रेकपॉइंट सेट करें:

 def func():    breakpoint() # import pdb; pdb.set_trace()    return 0 / 0 func() 

स्क्रिप्ट फिर से चलाएँ।

script.py(3)func()
-> return 0 / 0
(Pdb) #
(Pdb) step
ZeroDivisionError: division by zero
> script.py(3)func()
-> return 0 / 0
(Pdb)
ज्यादातर स्थितियों में, स्क्रिप्ट को डीबग करने के लिए print कमांड और ट्रेस परिणाम पर्याप्त होते हैं, लेकिन कभी-कभी एक जटिल विफलता से निपटने के लिए, आपको प्रोग्राम में खुदाई करने और क्या हो रहा है, इसके सार को समझने की आवश्यकता है। ऐसे मामलों में, ब्रेकप्वाइंट को कोड में सेट किया जाता है और कार्यक्रम की जांच की जाती है। उदाहरण के लिए, वे फ़ंक्शन के तर्कों को देखते हैं, अभिव्यक्ति का मूल्यांकन करते हैं, चर के मूल्यों की जांच करते हैं, या, जैसा कि ऊपर दिखाया गया है, बस चरण-दर-चरण कोड निष्पादन करते हैं। पीडीबी एक पूरी तरह कार्यात्मक पायथन आवरण है। इस शेल में, आप लगभग कुछ भी कर सकते हैं। काम के दौरान, कुछ विशिष्ट डिबगर कमांड काम आएंगे, जिसके लिए यहां मदद मिल सकती है ।

एक कक्षा में कई निर्माणकर्ताओं की घोषणा करना

फ़ंक्शन ओवरलोडिंग एक ऐसी विशेषता है जो विभिन्न प्रोग्रामिंग भाषाओं में व्यापक रूप से उपयोग की जाती है, लेकिन पायथन में नहीं। और भले ही आप पायथन में एक नियमित फ़ंक्शन को अधिभार नहीं दे सकते हैं, हम क्लास तरीकों का उपयोग करके ओवरलोडिंग निर्माणकर्ताओं की तरह कुछ का उपयोग कर सकते हैं:

 import datetime class Date:    def __init__(self, year, month, day):        self.year = year        self.month = month        self.day = day    @classmethod    def today(cls):        t = datetime.datetime.now()        return cls(t.year, t.month, t.day) d = Date.today() print(f"{d.day}/{d.month}/{d.year}") # 14/9/2019 

इसी तरह की स्थिति में, क्लास के तरीकों का उपयोग करने के बजाय, आपको __init__ में वैकल्पिक कंस्ट्रक्टर्स के सभी तर्क रखने और *args , **kwargs और बहुत सारे if का उपयोग करके समस्या को हल करने के लिए लुभाया जा सकता है। परिणाम कार्य कोड हो सकता है, लेकिन इस कोड को पढ़ना और बनाए रखना मुश्किल होगा। यहाँ मैं __init__ में न्यूनतम तर्क रखने और अलग-अलग तरीकों / निर्माणकर्ताओं में सभी कार्यों को करने की सिफारिश करूँगा। इस दृष्टिकोण के साथ, हमें अपने निपटान में एक साफ कोड होगा जो इस कोड के लेखक दोनों के लिए सुविधाजनक होगा और जो कोई भी इस कोड का उपयोग करेगा।

कैशिंग फ़ंक्शन एक डेकोरेटर का उपयोग करके कॉल करता है

क्या आपने कभी ऐसे फ़ंक्शन लिखे हैं जो कुछ लंबे पढ़ने / लिखने के संचालन, या धीमी गति से पुनरावर्ती गणना करते हैं? उसी समय, क्या आपने सोचा था कि परिणामों को कैशिंग करने से ऐसे कार्यों को चोट नहीं पहुंचेगी? आप functools मॉड्यूल से lru_cache डेकोरेटर का उपयोग करके फ़ंक्शन कॉल के परिणामों को कैश (याद) कर सकते हैं:

 from functools import lru_cache import requests @lru_cache(maxsize=32) def get_with_cache(url):    try:        r = requests.get(url)        return r.text    except:        return "Not Found" for url in ["https://google.com/",            "https://martinheinz.dev/",            "https://reddit.com/",            "https://google.com/",            "https://dev.to/martinheinz",            "https://google.com/"]:    get_with_cache(url) print(get_with_cache.cache_info()) # CacheInfo(hits=2, misses=4, maxsize=32, currsize=4) 

इस उदाहरण में, हम GET अनुरोधों को निष्पादित करते हैं जिनके परिणाम कैश किए जाते हैं (32 परिणाम तक कैश किया जा सकता है)। यहां आप देख सकते हैं कि हम cache_info पद्धति का उपयोग करके फ़ंक्शन कैश के बारे में जानकारी प्राप्त करते हैं। डेकोरेटर हमें clear_cache विधि भी देता है, जिसका उपयोग कैश को clear_cache करने के लिए किया जाता है। यहां मैं यह भी ध्यान देना चाहूंगा कि कैशिंग का उपयोग उन कार्यों के साथ नहीं किया जा सकता है जिनके दुष्प्रभाव हैं, या उन कार्यों के साथ जो हर कॉल के साथ परस्पर वस्तुओं का निर्माण करते हैं।

उन वस्तुओं को ढूंढना जो सबसे अधिक बार उपयोग करने योग्य वस्तु में पाए जाते हैं

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

 from collections import Counter cheese = ["gouda", "brie", "feta", "cream cheese", "feta", "cheddar",          "parmesan", "parmesan", "cheddar", "mozzarella", "cheddar", "gouda",          "parmesan", "camembert", "emmental", "camembert", "parmesan"] cheese_count = Counter(cheese) print(cheese_count.most_common(3)) # : [('parmesan', 4), ('cheddar', 3), ('gouda', 2)] 

Counter क्लास के आंतरिक तंत्र एक शब्दकोश पर आधारित होते हैं जो तत्वों के पत्राचार और सूची में प्रविष्टियों की संख्या को संग्रहीत करता है। इसलिए, संबंधित वस्तु को एक नियमित रूप से dict वस्तु के रूप में उपयोग किया जा सकता है:

 print(cheese_count["mozzarella"]) # : 1 cheese_count["mozzarella"] += 1 print(cheese_count["mozzarella"]) # : 2 

इसके अलावा, Counter साथ काम करते समय, हमारे पास हमारे update(more_words) विधि है, जिसका उपयोग काउंटर में नए तत्वों को जोड़ने के लिए किया जाता है। Counter की एक अन्य उपयोगी विशेषता यह है कि यह आपको इस वर्ग के उदाहरणों के साथ काम करते समय गणितीय संचालन (जोड़ और घटाव) का उपयोग करने की अनुमति देता है।

परिणाम

मुझे लगता है कि आज दिए गए अधिकांश सुझावों का उपयोग उन लोगों द्वारा किया जा सकता है जो पायथन में लगभग रोज लिखते हैं। मुझे आशा है कि आप उनमें से कुछ ऐसा पाएंगे जो आपके लिए उपयोगी है।

प्रिय पाठकों! क्या आप कोई दिलचस्प पायथन प्रोग्रामिंग ट्रिक्स जानते हैं? यदि हां, तो कृपया उन्हें साझा करें।