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

मैंने सप्ताहांत में पढ़ने के लिए 2 छोटी किताबें लिखीं जिनमें पायथन शामिल है, यहां लिंक हैं: (1) https://leanpub.com/learnpython_inweekend_pt1 और (2) https://leanpub.com/learnpython_inweekend_pt2

1. संक्षिप्त कोड के लिए सूची समझ का उपयोग करें

सूची समझ सूचियां बनाने का एक संक्षिप्त तरीका प्रदान करती है। वे अक्सर पारंपरिक फॉर-लूप और कंडीशनल स्टेटमेंट को प्रतिस्थापित कर सकते हैं, जिसके परिणामस्वरूप क्लीनर और अधिक पठनीय कोड प्राप्त होता है।

# Traditional approach
numbers = [1, 2, 3, 4, 5]
squared_numbers = []
for num in numbers:
    squared_numbers.append(num ** 2)

# Using list comprehension
squared_numbers = [num ** 2 for num in numbers]

2. मेमोरी दक्षता के लिए जेनरेटर एक्सप्रेशंस का लाभ उठाएं

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

# List comprehension (creates a list)
squared_numbers = [num ** 2 for num in numbers]

# Generator expression (creates an iterator)
squared_numbers = (num ** 2 for num in numbers)

3. इंडेक्स ट्रैकिंग के लिए enumerate() का उपयोग करें

जब किसी पुनरावर्तनीय पर पुनरावृत्ति होती है और प्रत्येक तत्व के सूचकांक को ट्रैक करने की आवश्यकता होती है, तो enumerate() फ़ंक्शन अमूल्य है।

fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
    print(f"Index: {index}, Fruit: {fruit}")

4. जॉइन() के साथ स्ट्रिंग कॉन्सटेनेशन को सरल बनाएं

स्ट्रिंग्स को जोड़ने के लिए जॉइन() विधि का उपयोग करना ऑपरेटर का उपयोग करने की तुलना में अधिक कुशल है, खासकर बड़े स्ट्रिंग्स के लिए।

fruits = ['apple', 'banana', 'cherry']
fruit_string = ', '.join(fruits)
print(fruit_string)  # Output: apple, banana, cherry

5. मेमोरी उपयोग को कम करने के लिए __स्लॉट्स__ का उपयोग करें

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

class Point:
    __slots__ = ['x', 'y']
    def __init__(self, x, y):
        self.x = x
        self.y = y

6. अपवादों को नज़रअंदाज़ करने के लिए contextlib.suppress का उपयोग करें

Contextlib.suppress संदर्भ प्रबंधक आपको विशिष्ट अपवादों को अनदेखा करने की अनुमति देता है, अनावश्यक प्रयास-छोड़कर ब्लॉकों से बचकर आपके कोड को सरल बनाता है।

from contextlib import suppress

with suppress(FileNotFoundError):
    with open('file.txt', 'r') as file:
        contents = file.read()

7. itertools मॉड्यूल का उपयोग करें

इटरटूल्स मॉड्यूल इटरेटर के साथ काम करने के लिए कुशल कार्यों का एक संग्रह प्रदान करता है। उत्पाद, क्रमपरिवर्तन और संयोजन जैसे कार्य जटिल संचालन को सरल बना सकते हैं।

import itertools

# Calculate all products of an input
print(list(itertools.product('abc', repeat=2)))

# Calculate all permutations
print(list(itertools.permutations('abc')))

8. कैशिंग के लिए functools.lru_cache का उपयोग करें

functools.lru_cache डेकोरेटर महंगे फ़ंक्शन कॉल के परिणामों को कैश कर सकता है, जिससे प्रदर्शन में सुधार हो सकता है।

from functools import lru_cache

@lru_cache(maxsize=32)
def fibonacci(n):
    if n 




  
  
  9. क्लीनर कोड के लिए मास्टर डेकोरेटर्स


डेकोरेटर फ़ंक्शंस या कक्षाओं के व्यवहार को संशोधित करने के लिए एक शक्तिशाली उपकरण हैं। उनका उपयोग लॉगिंग, एक्सेस नियंत्रण और बहुत कुछ के लिए किया जा सकता है।



def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()





  
  
  10. फॉर-एल्स ट्रिक का उपयोग करें


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



for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(f"{n} equals {x} * {n//x}")
            break
    else:
        # Loop fell through without finding a factor
        print(f"{n} is a prime number")








  
  
  निष्कर्ष


इन उन्नत पायथन युक्तियों को अपने विकास वर्कफ़्लो में शामिल करके, आप अधिक कुशल, पठनीय और रखरखाव योग्य कोड लिख सकते हैं।

चाहे आप __slots__ के साथ मेमोरी उपयोग को अनुकूलित कर रहे हों, जॉइन() के साथ स्ट्रिंग ऑपरेशंस को सरल बना रहे हों, या itertools मॉड्यूल की शक्ति का लाभ उठा रहे हों, ये तकनीकें आपके पायथन प्रोग्रामिंग कौशल को महत्वपूर्ण रूप से बढ़ा सकती हैं।

अपनी पायथन यात्रा में आगे रहने के लिए इन अवधारणाओं की खोज और अभ्यास करते रहें।