👩🏿‍🚒 👩🏻‍🤝‍👨🏼 👵🏼 10 पायथन ट्रिक्स के बारे में जानने के लिए 🧑🏿‍🤝‍🧑🏻 🔜 🐦

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

प्लेटफार्मों और ऑपरेटिंग सिस्टम के विशाल बहुमत के साथ संगत।
कई खुले स्रोत ढांचे और उपकरणों की उपस्थिति।
कोड जिसे पढ़ना और बनाए रखना आसान है।
विश्वसनीय मानक पुस्तकालय।
परीक्षण के माध्यम से मानक विकास तंत्र।

पायथन ट्रिक्स

यहां मैं आपके ध्यान में पाइथन प्रोग्रामिंग के बारे में 10 उपयोगी टिप्स लाना चाहूंगा। वे आपके दैनिक कार्यों में आपकी मदद करने में काफी सक्षम हैं।

▍1। स्ट्रिंग संगति

यदि आपको स्ट्रिंग्स की एक सूची को संक्षिप्त करने की आवश्यकता है, तो आप इसे लूप के for कर सकते हैं, अंतिम परिणाम के लिए एक समय में एक पंक्ति जोड़ सकते हैं। हालांकि, यह दृष्टिकोण बहुत अक्षम होगा, खासकर अगर सूची काफी लंबी है। पायथन में, तार अपरिवर्तनीय निकाय हैं। नतीजतन, प्रत्येक स्ट्रिंग संघनन ऑपरेशन का मतलब है कि आपको कुछ लाइनों को एक नई पंक्ति में कॉपी करने की आवश्यकता है।

इस समस्या को हल करने के लिए एक अधिक कुशल दृष्टिकोण join() फ़ंक्शन का उपयोग करना है:

 characters = ['p', 'y', 't', 'h', 'o', 'n'] word = "".join(characters) print(word) # python

▍2। सूची जनरेटरों का उपयोग करना

सूची जनरेटर का उपयोग अन्य पुनरावृत्त वस्तुओं से नई सूची बनाने के लिए किया जाता है। चूंकि जनरेटर रिटर्न की सूची देता है, इसलिए इसका विवरण एक अभिव्यक्ति है, जो वर्ग कोष्ठक में संलग्न है, सूची के प्रत्येक तत्व के लिए निष्पादित किया गया है। इसमें प्रत्येक तत्व से गुजरने वाले लूप का विवरण भी शामिल है। सूची जनरेटर आपको इस तथ्य के कारण सूचियों के साथ काम में तेजी लाने की अनुमति देते हैं कि पायथन दुभाषिया को उन टेम्प्लेट के लिए अनुकूलित किया जाता है जो सूची के फंसने पर दोहराए जाते हैं।

एक उदाहरण के रूप में, सूची जनरेटर का उपयोग करके पहले पांच पूर्णांकों के वर्गों को खोजने पर विचार करें:

 m = [x ** 2 for x in range(5)] print(m) # [0, 1, 4, 9, 16]

अब हम उन संख्याओं को पाते हैं जो प्रत्येक दो सूचियों में दिखाई देती हैं:

 list_a = [1, 2, 3, 4] list_b = [2, 3, 4, 5] common_num = [a for a in list_a for b in list_b if a == b] print(common_num) # [2, 3, 4]

▍3। गणना के साथ सूचियों पर Iterate ()

enumerate() विधि क्रमांकित संग्रह में क्रमांकन को जोड़ता है और एक वस्तु देता है जो तत्वों के जोड़े को बनाता है जिसमें तत्व और यह तत्व स्वयं शामिल हैं।

आइए इंटरव्यू में पेश की जाने वाली क्लासिक FizzBuzz समस्या को हल करें। इस कार्य के लिए यह शर्त है: “एक प्रोग्राम लिखें जो संख्याओं की सूची प्रदर्शित करता है। इस स्थिति में, संख्याओं के बजाय जो 3 के गुणक हैं, fizz प्रदर्शित किया जाता है, संख्या के बजाय जो 5 के गुणक हैं - buzz, और उन संख्याओं के बजाय जो 3 और 5 के गुणक हैं - fizzbuzz। "

 numbers = [30, 42, 28, 50, 15] for i, num in enumerate(numbers):    if num % 3 == 0 and num % 5 == 0:       numbers[i] = 'fizzbuzz'    elif num % 3 == 0:       numbers[i] = 'fizz'    elif num % 5 == 0:       numbers[i] = 'buzz' print(numbers) # ['fizzbuzz', 'fizz', 28, 'buzz', 'fizzbuzz']

▍4। सूचियों के साथ ज़िप () का उपयोग करना

मान लें कि आपको समान लंबाई की कई सूचियों को संयोजित करने और परिणामी सूची प्रदर्शित करने की आवश्यकता है। जैसा कि अन्य मामलों में, एक समान समस्या हल हो सकती है, इसलिए बोलने के लिए, "माथे पर", या आप सार्वभौमिक zip() फ़ंक्शन जैसे कुछ का उपयोग कर सकते हैं:

 countries = ['France', 'Germany', 'Canada'] capitals = ['Paris', 'Berlin', 'Ottawa'] for country, capital in zip(countries,capitals):    print(country, capital) # France Paris                              Germany Berlin                              Canada Ottawa

▍5। Itertools मॉड्यूल का उपयोग करना

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

उपरोक्त समझने के लिए आइए एक वास्तविक उदाहरण पर विचार करें।

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

निम्नलिखित कोड पर एक नज़र डालें:

 import itertools friends = ['Team 1', 'Team 2', 'Team 3', 'Team 4'] list(itertools.combinations(friends, r=2)) # [('Team 1', 'Team 2'),   ('Team 1', 'Team 3'), ('Team 1', 'Team 4'), ('Team 2', 'Team 3'), ('Team 2', 'Team 4'), ('Team 3', 'Team 4')]

यहां आपको इस तथ्य पर ध्यान देने की आवश्यकता है कि मूल्यों का क्रम महत्वहीन है। चूंकि संयोजन ('Team 1', 'Team 2') और ('Team 2', 'Team 1') एक ही जोड़ी की टीमों का प्रतिनिधित्व करते हैं, उनमें से केवल एक को अंतिम सूची में शामिल किया जाएगा। इसी तरह, आप itertools.permutations() विधि और इस मॉड्यूल के अन्य तरीकों का उपयोग कर सकते हैं। itertools लिए एक विस्तृत गाइड यहाँ पाया जा सकता है ।

▍6। पायथन कलेक्शंस का उपयोग करना

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

यह विधि एक सूची या टपल के रूप में एक पुनरावृत्त वस्तु लेती है, और एक शब्दकोश देता है जिसमें सूची में अलग-अलग वस्तुओं की संख्या के बारे में जानकारी होती है (काउंटर शब्दकोश)। इस तरह के शब्दकोश की कुंजी अद्वितीय वस्तुओं में दर्शाए गए अद्वितीय तत्व हैं, और मूल्य ऐसे तत्वों की मात्रा हैं।

एक Counter ऑब्जेक्ट बनाने के लिए, आपको Counter() विधि के लिए एक iterable ऑब्जेक्ट (उदाहरण के लिए,) पास करना होगा:

 import collections count = collections.Counter(['a','b','c','d','b','c','d','b']) print(count) # Counter({'b': 3, 'c': 2, 'd': 2, 'a': 1})

collections मॉड्यूल पर विवरण यहां पाया जा सकता है ।

▍ ▍। दो सूचियों को शब्दकोश में परिवर्तित करें

मान लीजिए हमारे पास दो सूचियाँ हैं। उनमें से एक में छात्रों के नाम हैं, और दूसरे में उनके ग्रेड शामिल हैं। इन दोनों सूचियों को शब्दकोश में कैसे बदलें? यदि हम इसके लिए zip() फ़ंक्शन का सहारा लेते हैं, तो इस समस्या को निम्नानुसार हल किया जा सकता है:

 students = ["Peter", "Julia", "Alex"] marks = [84, 65, 77] dictionary = dict(zip(students, marks)) print(dictionary) # {'Peter': 84, 'Julia': 65, 'Alex': 77}

▍8। जेनरेटर के कार्यों का उपयोग करना

जेनरेटर के कार्य ऐसे कार्य हैं जो पुनरावृत्तियों की तरह व्यवहार करते हैं। वे प्रोग्रामर को जल्दी और आसानी से साफ चलने वाले बनाने के लिए अनुमति देते हैं। एक उदाहरण पर विचार करें जो इस विचार को प्रकट करता है।

मान लीजिए कि हमें 1 से शुरू होने वाले पहले 100,000,000 पूर्णांक के वर्गों का योग खोजने की आवश्यकता है।

यह कार्य सरल प्रतीत होता है। यह सूची जनरेटर का उपयोग करके समस्याओं के बिना हल किया जा सकता है। हालांकि, यहां समस्या बड़ी मात्रा में इनपुट डेटा की है। निम्नलिखित कोड पर एक नज़र डालें:

 import time t1 = time.clock() sum([i * i for i in range(1, 100000000)]) t2 = time.clock() time_diff = t2 - t1 print(f"It took {time_diff} Secs to execute this method") # It took 13.197494000000006 Secs to execute this method

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

 import time t1 = time.clock() sum((i * i for i in range(1, 100000000))) t2 = time.clock() time_diff = t2 - t1 print(f"It took {time_diff} Secs to execute this method") # It took 9.53867000000001 Secs to execute this method

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

यहाँ जनरेटर कार्यों के बारे में सामग्री है।

▍ ९। एक फ़ंक्शन से कई मान लौटा रहा है

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

 def multiplication_division(num1, num2):    return num1*num2, num1/num2 product, division = multiplication_division(15, 3) print("Product =", product, "Quotient =", division) # Product = 45 Quotient = 5.0

▍ १०। क्रमबद्ध () फ़ंक्शन का उपयोग करना

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

 sorted([3,5,2,1,4]) # [1, 2, 3, 4, 5]

और यहाँ अवरोही क्रम में पंक्तियों की सूची को छाँटने का एक उदाहरण है:

 sorted(['france', 'germany', 'canada', 'india', 'china'], reverse=True) # ['india', 'germany', 'france', 'china', 'canada']

परिणाम

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

प्रिय पाठकों! अनुभवी पायथन डेवलपर्स को उन उपयोगी पायथन विशेषताओं के बारे में बात करने के लिए प्रोत्साहित किया जाता है जो वे नियमित रूप से उपयोग करते हैं।

10 पायथन ट्रिक्स के बारे में जानने के लिए