पाइथन में सर्वोत्तम प्रथाएँ

यह लेख पाइथन की सर्वोत्तम प्रथाओं को समझाता है।

हम पाइथन की सर्वोत्तम प्रथाओं को वास्तविक कोड नमूनों के साथ समझाएँगे, और पठनीय व अनुरक्षित कोड लिखने के तरीके बताएँगे।

YouTube Video

पाइथन में सर्वोत्तम प्रथाएँ

पठनीयता को सर्वोच्च प्राथमिकता दें

सबसे पहले, 'पठनीयता को सर्वोच्च प्राथमिकता देने' को देखें।

पाइथन एक ऐसी भाषा है जो 'पठनीयता' को महत्व देती है। सबसे पहले, ऐसा कोड लिखना प्राथमिकता दें जिसकी मंशा एक नजर में स्पष्ट हो।

1# Bad example: unclear variable names
2a = 10
3b = 5
4c = a * b

इस कोड में, वेरिएबल के नाम उनका अर्थ नहीं बताते, जिससे दूसरों को बाद में समझने में समय लगता है।

1# Good example: descriptive variable names
2price = 10
3quantity = 5
4total_cost = price * quantity

वेरिएबल के नाम स्पष्ट देने से आपका कोड ही दस्तावेज़ जैसा बन जाता है।

स्पष्ट कोड लिखें

अब, 'स्पष्ट कोड लिखने' को देखें।

पाइथन में, 'स्पष्ट मंशा' को 'अंतर्निहित व्यवहार' से अधिक प्राथमिकता दी जाती है।

1# Bad example: implicit truthy check
2if data:
3    process(data)

इस कोड में, data से क्या अपेक्षित है यह स्पष्ट नहीं है, जिससे बग होने की संभावना बढ़ जाती है।

1# Good example: explicit condition
2if len(data) > 0:
3    process(data)

शर्तों को स्पष्ट करने से कोड की मंशा उसकी स्पेसिफिकेशन से मेल खाती है।

फंक्शनों को छोटा रखें और उन्हें केवल एक जिम्मेदारी पर केंद्रित रखें

अब, 'फंक्शनों को छोटा और एक जिम्मेदारी पर केंद्रित रखने' को देखें।

जब कोई फंक्शन बहुत सारे काम करता है, तो परीक्षण और अनुरक्षण कठिन हो जाता है।

1# Bad example: doing too many things
2def handle_user(user):
3    save_to_database(user)
4    send_email(user)
5    write_log(user)

इस कोड में, प्रक्रियाएँ आपस में जुड़ जाती हैं जिससे पुन: उपयोग और परिवर्तन कठिन हो जाता है।

1# Good example: single responsibility
2def save_user(user):
3    save_to_database(user)
4
5def notify_user(user):
6    send_email(user)
7
8def log_user(user):
9    write_log(user)

फंक्शनों को विभाजित करने से उनकी भूमिका स्पष्ट होती है और परीक्षण आसान हो जाता है।

टाइप हिंट्स का सक्रिय रूप से उपयोग करें

अब, 'टाइप हिंट्स का सक्रिय रूप से उपयोग करने' को देखें।

टाइप हिंट्स दस्तावेज़ के रूप में काम करते हैं और बग रोकने के लिए एक शक्तिशाली उपकरण होते हैं।

1# Bad example: Without type hints
2def add(a, b):
3    return a + b

इस कोड में, तर्कों और रिटर्न मूल्यों की प्रकार स्पष्ट नहीं है, जिससे गलत उपयोग की संभावना बढ़ जाती है।

1# Good example: With type hints
2def add(a: int, b: int) -> int:
3    return a + b

टाइप हिंट्स के साथ, IDE का कम्प्लीशन, स्थैतिक विश्लेषण और पठनीयता काफी बेहतर होती है।

None लौटाने की संभावना को स्पष्ट रूप से दर्शाएँ

अब, 'None लौटाने की संभावना को स्पष्ट रूप से दर्शाने' को देखें।

ऐसे फंक्शन जो None लौटाते हैं, उन्हें उपयोग करने वाले अक्सर अनदेखा कर देते हैं।

1# Bad example: Ambiguous return value
2def find_user(user_id):
3    if user_id == 1:
4        return {"id": 1, "name": "Alice"}
5    return None

इस कोड में यह स्पष्ट नहीं है कि कोई रिटर्न वैल्यू होगी या नहीं।

1# Good example: explicit return type
2from typing import Optional, Dict, Any
3
4def find_user(user_id: int) -> Optional[Dict[str, Any]]:
5    if user_id == 1:
6        return {"id": 1, "name": "Alice"}
7    return None

Optional का उपयोग करके, आप None लौटाने की संभावना को एक प्रकार के रूप में बता सकते हैं।

अपवादों (exceptions) को बहुत व्यापक रूप से न पकड़ें

अब, 'अपवादों को बहुत व्यापक रूप में न पकड़ने' को देखें।

अपवाद प्रबंधन केवल आवश्यक अपवादों को ही पकड़ना चाहिए।

1# Bad example: catching all exceptions
2try:
3    result = int(value)
4except Exception:
5    result = 0

यह कोड उन बग्स को छिपा सकता है जिन्हें पहचानना चाहिए था।

1# Good example: catch specific exception
2try:
3    result = int(value)
4except ValueError:
5    result = 0

अपवादों को सीमित करके, आप अप्रत्याशित समस्याओं को नज़रअंदाज नहीं करेंगे।

with स्टेटमेंट के साथ संसाधनों को सुरक्षित रूप से संभालें

अब, 'with स्टेटमेंट के साथ संसाधनों को सुरक्षित रूप से संभालने' को देखें।

फाइल्स और लॉक जैसे संसाधनों को हमेशा विश्वसनीय रूप से मुक्त किया जाना चाहिए।

1# Bad example: manual close
2file = open("data.txt")
3content = file.read()
4file.close()

इस कोड में, अगर कोई अपवाद आता है, तो close() नहीं चल सकता है।

1# Good example: using context manager
2with open("data.txt") as file:
3    content = file.read()

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

लिस्ट कम्प्रिहेंशन का उपयुक्त उपयोग करें

अब, 'लिस्ट कॉम्प्रिहेंशन का उपयुक्त उपयोग करने' को देखें।

सरल ट्रांसफॉर्मेशन प्रक्रियाएँ लिस्ट कॉम्प्रिहेंशन द्वारा संक्षिप्त रूप से लिखी जा सकती हैं।

1# Bad example: Verbose loop
2squares = []
3for i in range(10):
4    squares.append(i * i)

इस कोड में, मुख्य प्रक्रिया देखना कठिन है।

1# Good example: Clear list comprehension
2squares = [i * i for i in range(10)]

लिस्ट कॉम्प्रिहेंशन का उपयुक्त उपयोग करके कोड की पठनीयता बढ़ती है।

जादुई संख्याओं (magic numbers) से बचें

अब, 'जादुई संख्याओं से बचने' को देखें।

संख्या और स्ट्रिंग को सीधे लिखने से उनका अर्थ अस्पष्ट हो जाता है।

1# Bad example: magic number
2if status == 404:
3    handle_not_found()

इस कोड में, यह माना गया है कि आप 404 का अर्थ जानते हैं।

1# Good example: named constant
2NOT_FOUND = 404
3
4if status == NOT_FOUND:
5    handle_not_found()

नाम देने से मंशा स्पष्ट हो जाती है।

ऐसा कोड लिखें जो अनुरक्षित हो सके, न कि केवल वह कोड जो 'काम करता है'

अंत में, 'ऐसा कोड लिखना जो अनुरक्षित रहे, न कि सिर्फ वह जो चलता है' को देखें।

महत्वपूर्ण बात यह है कि क्या आप भविष्य में या कोई और उस कोड को पढ़ सकता है।

1# Bad example: Hard to maintain
2def f(x):
3    return x * 1.08 + 100

इस कोड में, स्पेसिफिकेशन को कोड से समझा नहीं जा सकता।

1# Good example: Easy to maintain
2TAX_RATE = 1.08
3BASE_FEE = 100
4
5def calculate_total(price: float) -> float:
6    return price * TAX_RATE + BASE_FEE

नामों में अर्थ स्पष्ट करके, कोड स्वयं ही उसकी स्पेसिफिकेशन बन जाता है।

सारांश

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

आप हमारे YouTube चैनल पर Visual Studio Code का उपयोग करके ऊपर दिए गए लेख के साथ आगे बढ़ सकते हैं। कृपया YouTube चैनल को भी देखें।

YouTube Video