उदाहरणों के साथ बेहतर कोड के लिए 30 शानदार Python ट्रिक्स

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

यदि आपकी Python कौशल अभी मानक पर नहीं हैं, तो आप हमारे Python Programming स्किल ट्रैक से उन्हें निखार सकते हैं।

सीक्वेंस और डेटा स्ट्रक्चर ट्रिक्स

#1 Slicing

a = "Hello World!"
print(a[::-1])

"""
!dlroW olleH
"""संचालित द्वारा

Slicing Python में एक फ़ीचर है जो इंडेक्सिंग पर निर्भर करता है और उपयोगकर्ताओं को किसी सीक्वेंस का एक उपसमुच्चय एक्सेस करने देता है। इंडेक्स किसी सीक्वेंस में तत्व की स्थिति होता है। अगर सीक्वेंस टाइप mutable है, तो आप slicing का उपयोग डेटा निकालने और संशोधित करने के लिए कर सकते हैं। 

नोट: हम immutable सीक्वेंस पर भी slicing कर सकते हैं, लेकिन slice को संशोधित करने की कोशिश करने पर TypeError उठेगा। 

Slices का फ़ॉर्मेट है: sequence[start:stop:step]। यदि start, stop और step पैरामीटर में मान निर्धारित नहीं किए गए हैं, तो डिफ़ॉल्ट्स लागू होंगे। डिफ़ॉल्ट्स हैं: 

• "start" का डिफ़ॉल्ट 0 है
• "stop" का डिफ़ॉल्ट सीक्वेंस की लंबाई है
• "step" का डिफ़ॉल्ट 1 है, यदि निर्दिष्ट न हो। 

जब आप sequence[start:stop] देते हैं, तो लौटे हुए तत्व starting इंडेक्स से लेकर stop - 1 तक होंगे (stop इंडेक्स शामिल नहीं होता)। 

हम negative indices भी पास कर सकते हैं, जिन्हें सीक्वेंस को रिवर्स करने के लिए इस्तेमाल किया जा सकता है। उदाहरण के लिए, 4 तत्वों की सूची में, 0वां इंडेक्स -4 इंडेक्स भी है, और आखिरी इंडेक्स -1 भी है। ऊपर दिए गए कोड में, इस बात का उपयोग सीक्वेंस के step पैरामीटर में किया गया है। नतीजतन, स्ट्रिंग को उल्टा प्रिंट किया गया, सीक्वेंस के अंत से लेकर इंडेक्स 0 तक।   

#2 इन-प्लेस स्वैप / एकसाथ असाइनमेंट

a = 10
b = 5
print(f"First: {a, b}")

"""
First: (10, 5)
"""

a, b = b, a + 2
print(f"Second: {a, b}")

"""
Second: (5, 12)
"""संचालित द्वारा

यदि आपकी पहली धारणा यह थी कि b का मान 7 होगा न कि 12, तो आप इन-प्लेस swapping के जाल में फँस गए। 

Python में, हम ऑटोमैटिक अनपैकिंग का उपयोग करके एक ही असाइनमेंट में किसी iterable को वेरिएबल्स में अनपैक कर सकते हैं। उदाहरण के लिए: 

a, b, c = [1, 2, 3]
print(a)
print(b)
print(c)

"""
1
2
3
"""संचालित द्वारा

हम कई मानों को * का उपयोग करके एक ही वेरिएबल में इकट्ठा भी कर सकते हैं – इस Python ट्रिक को packing कहते हैं। नीचे packing का एक उदाहरण है।  

a, *b = 1, 2, 3
print(a, b)
"""
1 [2, 3]
"""संचालित द्वारा

ऑटोमैटिक packing और unpacking को मिलाकर एक तकनीक बनती है जिसे simultaneous assignment कहते हैं। हम एकसाथ असाइनमेंट का उपयोग कई मानों को कई वेरिएबल्स में असाइन करने के लिए कर सकते हैं।

#3 लिस्ट बनाम ट्यूपल 

import sys

a = [1, 2, 3, 4, 5]
b = (1, 2, 3, 4, 5)

print(f"List size: {sys.getsizeof(a)} bytes")
print(f"Tuple size: {sys.getsizeof(b)} bytes")

"""
List size: 52 bytes
Tuple size: 40 bytes
"""संचालित द्वारा

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

सबसे पहले, लिस्ट mutable होती हैं, यानी हम उन्हें अपनी इच्छा से बदल सकते हैं: 

a = [1,2,3,4,5]
a[2] = 8
print(a)

"""
[1,2,8,4,5]
"""संचालित द्वारा

दूसरी ओर, ट्यूपल immutable होती हैं, यानी उन्हें बदलने की कोशिश करने पर TypeError उठेगा। 

इसी वजह से, ट्यूपल अधिक मेमोरी-कुशल होती हैं क्योंकि Python डेटा के लिए आवश्यक सही मेमोरी ब्लॉक अलॉट कर सकता है। इसके विपरीत, लिस्ट में अतिरिक्त मेमोरी अलॉट करनी पड़ती है ताकि भविष्य में उसे बढ़ाया जा सके – इसे dynamic memory allocation कहते हैं। 

संक्षेप में; जिन परिस्थितियों में आप नहीं चाहते कि डेटा बदले, मेमोरी कारणों से लिस्ट की अपेक्षा ट्यूपल को प्राथमिकता देनी चाहिए। ट्यूपल लिस्ट से तेज भी होती हैं। 

इस ट्यूटोरियल में Python डेटा स्ट्रक्चर के बारे में अधिक जानें। 

#4 Generators

a = [x * 2 for x in range(10)]
b = (x * 2 for x in range(10))

print(a)
print(b)

"""
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
<generator object <genexpr> at 0x7f61f8808b50>
"""संचालित द्वारा

लिस्ट कॉम्प्रिहेंशन किसी अन्य iterable से लिस्ट बनाने का pythonic तरीका है – यह for लूप से कहीं तेज़ है। लेकिन क्या होगा यदि आप गलती से ब्रैकेट्स [] से बदलकर () कर दें? आपको एक generator ऑब्जेक्ट मिलेगा।

Python में, लिस्ट कॉम्प्रिहेंशन जैसी लॉजिक को गोल ब्रैकेट्स में लिखने से generator ऑब्जेक्ट बनता है। जेनरेटर एक विशेष तरह के iterable होते हैं। लिस्ट के विपरीत, वे अपने आइटम स्टोर नहीं करते। इसके बजाय, वे प्रत्येक तत्व को क्रम में उत्पन्न करने के निर्देश और iteration की वर्तमान अवस्था स्टोर करते हैं।

हर तत्व केवल अनुरोध पर उत्पन्न होता है, जिसे lazy evaluation कहते हैं। जेनरेटर का मुख्य लाभ यह है कि यह कम मेमोरी का उपयोग करता है क्योंकि पूरी सीक्वेंस एक साथ नहीं बनती। 

#5 Aliasing 

a = [1, 2, 3, 4 ,5]
b = a

# Change the 4th index in b
b[4] = 7

print(id(a))
print(id(b))
print(a) # Remember we did not explicitly make changes to a.

"""
15136008
15136008
[1, 2, 3, 4, 7]
"""संचालित द्वारा

Python एक ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग भाषा है – सब कुछ ऑब्जेक्ट है। इसलिए, किसी ऑब्जेक्ट को किसी पहचानकर्ता (identifier) को असाइन करना उस ऑब्जेक्ट का रेफरेंस बनाना है। 

जब हम एक पहचानकर्ता को दूसरे पहचानकर्ता को असाइन करते हैं, तो दोनों एक ही ऑब्जेक्ट को रेफर करते हैं। इसे aliasing कहते हैं। एक एलियस में किए गए परिवर्तन दूसरे को प्रभावित करेंगे। कभी-कभी यह व्यवहार वांछित होता है, लेकिन अक्सर यह हमें चौंका देता है। 

इससे बचने का एक तरीका यह है कि mutable ऑब्जेक्ट्स का उपयोग करते समय aliasing से बचें। एक और समाधान यह हो सकता है कि रेफरेंस के बजाय मूल ऑब्जेक्ट का क्लोन बनाया जाए। 

क्लोन बनाने का सबसे सरल तरीका slicing का उपयोग करना है: 

b = a[:] संचालित द्वारा

यह b पहचानकर्ता में एक नए लिस्ट ऑब्जेक्ट का रेफरेंस बनाएगा। 

आप कई अन्य समाधान भी अपना सकते हैं, जैसे असाइन करते समय list(a) कॉल करना या copy() मेथड का उपयोग करना। 

#6 ‘not’ ऑपरेटर

a = []
print(not a)

"""
True
"""संचालित द्वारा

अगली Python टिप है not ऑपरेटर से अपनी डेटा स्ट्रक्चर के खाली होने की जाँच करने का सबसे आसान तरीका। Python का बिल्ट-इन not एक लॉजिकल ऑपरेटर है जो अभिव्यक्ति सच न होने पर True लौटाता है, अन्यथा False – यह बूलियन अभिव्यक्तियों और ऑब्जेक्ट्स के truth value को उलट देता है।  

एक और तरीका जिससे आप इसे देख सकते हैं, वह है if स्टेटमेंट में: 

if not a:
    # do something... संचालित द्वारा

जब a True होता है, तब not ऑपरेटर False लौटाएगा, और इसके उलट भी सही है। 

यह शुरुआत में उलझा सकता है, तो इसे आज़माएँ।

स्ट्रिंग और आउटपुट ट्रिक्स

#7 F-strings

first_name = "John"
age = 19

print(f"Hi, I'm {first_name} and I'm {age} years old!")

"""
Hi, I'm John and I'm 19 years old!
"""संचालित द्वारा

कभी-कभी हमें किसी स्ट्रिंग ऑब्जेक्ट को फ़ॉर्मेट करना पड़ता है; Python 3.6 ने इस प्रक्रिया को सरल बनाने के लिए f-strings नामक एक शानदार फीचर पेश किया। नए तरीके को बेहतर समझने के लिए यह जानना मददगार है कि नए रिलीज़ से पहले स्ट्रिंग्स कैसे फ़ॉर्मेट की जाती थीं। 

पहले स्ट्रिंग्स इस तरह फ़ॉर्मेट होती थीं: 

first_name = "John"
age  = 19

print("Hi, I'm {} and I'm {} years old!".format(first_name, age))

"""
Hi, I'm John and I'm 19 years old!
"""संचालित द्वारा

मूलतः, नया फ़ॉर्मेटिंग तरीका तेज़, अधिक पठनीय, अधिक संक्षिप्त और गलती की गुंजाइश कम करने वाला है।

f-strings का एक और उपयोग किसी पहचानकर्ता का नाम उसके मान के साथ प्रिंट करना है। यह Python 3.8 में पेश किया गया था।

x = 10
y = 20
print(f"{x = }, {y = }")

"""
x = 10, y = 20
"""संचालित द्वारा

और जानने के लिए यह ट्यूटोरियल देखें: Python में F-string फ़ॉर्मेटिंग। 

#8 print() फ़ंक्शन का ‘end’ पैरामीटर

languages = ["english", "french", "spanish", "german", "twi"]
print(' '.join(languages))

"""
english french spanish german twi
"""संचालित द्वारा

अक्सर हम print स्टेटमेंट को उसके किसी वैकल्पिक पैरामीटर के बिना ही उपयोग करते हैं। परिणामस्वरूप, कई Pythonistas इस बात से अनजान रहते हैं कि आप आउटपुट को कुछ हद तक नियंत्रित कर सकते हैं।

एक वैकल्पिक पैरामीटर जिसे हम बदल सकते हैं वह है end। end पैरामीटर यह निर्दिष्ट करता है कि print कॉल के अंत में क्या दिखाया जाना चाहिए। 

end का डिफ़ॉल्ट "\n" है, जो Python को नई पंक्ति शुरू करने के लिए कहता है। ऊपर के कोड में, हमने इसे स्पेस में बदला। इसलिए, आउटपुट में हमारी लिस्ट के सारे तत्व एक ही पंक्ति में प्रिंट हुए।

#9 ट्यूपल में जोड़ना

a = (1, 2, [1, 2, 3])
a[2].append(4)
print(a)

"""
(1, 2, [1, 2, 3, 4])
"""संचालित द्वारा

हम पहले ही जानते हैं कि ट्यूपल immutable हैं – देखें Python ट्रिक #3 लिस्ट बनाम ट्यूपल। ट्यूपल की स्टेट बदलने की कोशिश करने पर TypeError फेंका जाएगा। लेकिन, यदि आप ट्यूपल ऑब्जेक्ट को एक ऐसी नामों की सीक्वेंस मानें जिनकी बाइंडिंग्स ऑब्जेक्ट्स से हैं जिन्हें बदला नहीं जा सकता, तो बात अलग दिखेगी।

हमारे ट्यूपल के पहले दो तत्व integers हैं – वे immutable हैं। आखिरी तत्व एक लिस्ट है, जो Python में mutable ऑब्जेक्ट है।

यदि हम अपनी लिस्ट को ट्यूपल के भीतर एक और नाम भर मानें जिसकी बाइंडिंग किसी ऑब्जेक्ट से है और वह बाइंडिंग बदली नहीं जा सकती, तो हमें एहसास होगा कि लिस्ट को ट्यूपल के अंदर से भी बदला जा सकता है।

क्या हम इसे व्यवहार में करने की सलाह देंगे? शायद नहीं, लेकिन यह जानने योग्य बात है!

#10 डिक्शनरीज़ को मर्ज करना

a = {"a": 1, "b": 2}
b = {"c": 3, "d": 4}

a_and_b = a | b
print(a_and_b)

"""
{"a": 1, "b": 2, "c": 3, "d": 4}
"""संचालित द्वारा

Python 3.9 और उससे ऊपर में, | (बिटवाइज़ OR) का उपयोग करके डिक्शनरीज़ को मर्ज करना संभव है। इस विशेष Python ट्रिक के बारे में और कहने को ज़्यादा नहीं है सिवाय इसके कि यह अधिक पठनीय समाधान है! 

कोड स्टाइल और सिंटैक्स ट्रिक्स

#11 टर्नरी ऑपरेटर / कंडीशनल एक्सप्रेशंस 

condition = True
name = "John" if condition else "Doe"

print(name)

"""
John
"""संचालित द्वारा

ऊपर के कोड में आपने टर्नरी ऑपरेटर देखा – इसे कंडीशनल एक्सप्रेशन भी कहा जाता है। हम टर्नरी ऑपरेटर्स का उपयोग इस आधार पर मान निर्धारित करने के लिए करते हैं कि कोई शर्त True है या False।

हम अपना कोड इस तरह भी लिख सकते थे:

condition = True
if condition:
    name = "John"
else:
    name = "Doe"

print(name)
"""
John
"""संचालित द्वारा

भले ही दोनों कोड समान आउटपुट दें, ध्यान दें कि टर्नरी कंडीशनल हमें कहीं छोटा और साफ़ कोड लिखने देता है। यही वह ‘Pythonic’ तरीका है जिसे Pythonistas पसंद करते हैं। 

#12 लिस्ट से डुप्लीकेट हटाना

a = [1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 2, 2]
print(list(set(a)))

"""
[1, 2, 3, 4, 5, 6, 7]
"""संचालित द्वारा

लिस्ट से डुप्लीकेट तत्व हटाने का सबसे सरल तरीका यह है कि लिस्ट को set में बदल दें (और चाहें तो फिर वापस लिस्ट में)।

म्यूटेबिलिटी के आधार पर, Python में सेट और लिस्ट काफी समान लग सकते हैं। हम दोनों में मनचाहे तत्व जोड़-हटा सकते हैं, फिर भी वे काफी अलग हैं।

लिस्ट ordered, zero-based indexed और mutable होती हैं। सेट unordered और unindexed होते हैं। सेट के तत्व immutable टाइप के होने चाहिए, भले ही सेट स्वयं mutable हो – किसी इंडेक्स से तत्व निकालने या तत्व को संशोधित करने की कोशिश करने पर त्रुटि होगी।

सेट और लिस्ट के बीच एक और महत्वपूर्ण अंतर यह है कि सेट में डुप्लीकेट नहीं हो सकते। यही बात हमें लिस्ट के डुप्लीकेट तत्व हटाने में मदद करती है।

#13 स्वतंत्र अंडरस्कोर 

>>> print(_)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>

>>> 1 + 2
3

>>> print(_)
3संचालित द्वारा

अंडरस्कोर (_) Python में एक वैध पहचानकर्ता है, इसलिए इसे किसी ऑब्जेक्ट के रेफरेंस के रूप में उपयोग करना संभव है। लेकिन अंडरस्कोर की एक और जिम्मेदारी भी है: आख़िरी मूल्यांकन के परिणाम को स्टोर करना।

डॉक्यूमेंटेशन के अनुसार, "इंटरैक्टिव इंटरप्रेटर आख़िरी मूल्यांकन का परिणाम _ वेरिएबल में उपलब्ध कराता है। (यह builtins मॉड्यूल में स्टोर होता है, print जैसी बिल्ट-इन फ़ंक्शंस के साथ)।"

चूँकि हमने पहली पंक्ति में अंडरस्कोर को किसी ऑब्जेक्ट से असाइन नहीं किया था, हमें त्रुटि मिली। लेकिन 1 + 2 का आउटपुट निकालने पर इंटरैक्टिव इंटरप्रेटर ने परिणाम को हमारे लिए _ पहचानकर्ता में स्टोर कर दिया। 

#14 मानों को अनदेखा करने के लिए अंडरस्कोर

for _ in range(100):
    print("The index doesn't matter")

"""
The index doesn't matter
The index doesn't matter
...
"""संचालित द्वारा

Python टिप #13 में हमने देखा कि इंटरैक्टिव इंटरप्रेटर आख़िरी मूल्यांकन का परिणाम अंडरस्कोर (_) पहचानकर्ता में उपलब्ध कराता है, लेकिन इसका उपयोग यहीं तक सीमित नहीं है।

हम इसे उन ऑब्जेक्ट्स के लिए भी इस्तेमाल कर सकते हैं जिनकी हमें परवाह नहीं है या जिन्हें हम प्रोग्राम में आगे उपयोग नहीं करेंगे। यह इसलिए महत्वपूर्ण है क्योंकि किसी पहचानकर्ता के बजाय अंडरस्कोर (_) का उपयोग न करने पर प्रोग्राम की लिंटिंग करते समय F841 त्रुटि मिलेगी। F841 त्रुटि यह बताती है कि किसी स्थानीय वेरिएबल का नाम असाइन किया गया था लेकिन प्रोग्राम में उपयोग नहीं हुआ, जो खराब प्रैक्टिस है।

#15 Trailing underscores

list_ = [0, 1, 2, 3, 4]
global_ = "Hi there" संचालित द्वारा

पिछली दो ट्रिक्स से आगे बढ़ते हुए, Python में अंडरस्कोर (_) का एक और उद्देश्य Python कीवर्ड्स के साथ संघर्ष से बचना है। 

PEP 8 बताता है कि trailing underscore (_) "परंपरा से Python कीवर्ड्स के साथ संघर्ष से बचने के लिए उपयोग किया जाना चाहिए।" यह यह भी कहता है कि "आम तौर पर किसी एकल trailing underscore को जोड़ना किसी संक्षेप या गलत वर्तनी करने से बेहतर है। अतः list_ lst से बेहतर है।"

#16 Leading underscores

class Example:
    def __init__(self):
        self._internal = 2
        self.external = 20संचालित द्वारा

आप अक्सर देखेंगे कि अनुभवी Python प्रोग्रामर किसी पहचानकर्ता या मेथड नाम के आगे अंडरस्कोर लगाते हैं – और इसके पीछे कारण है।

किसी पहचानकर्ता या मेथड के आगे लगा अंडरस्कोर एक छिपा अर्थ लिए होता है: यह वेरिएबल या मेथड केवल आंतरिक उपयोग के लिए है। मूलतः, यह अन्य प्रोग्रामर्स के लिए एक डिस्क्लेमर है जिसे PEP 8 में परिभाषित किया गया है लेकिन Python द्वारा प्रवर्तित नहीं है। इसलिए, leading underscores एक कमजोर संकेतक हैं।

Java के विपरीत, Python में private और public वेरिएबल्स के बीच सख्त भेद नहीं है। दूसरे शब्दों में, इसका अर्थ केवल इसलिए है क्योंकि Python समुदाय ने इसे अर्थ देने पर सहमति बनाई है। इनका शामिल होना आपके प्रोग्राम्स के व्यवहार को प्रभावित नहीं करता।

#17 अंडरस्कोर विजुअल

अंडरस्कोर पर आख़िरी टिप; अब तक हमने अंडरस्कोर के तीन अलग-अलग उपयोग देखे हैं, लेकिन और जानने के लिए हमारा ट्यूटोरियल देखें: Python में अंडरस्कोर (_) की भूमिका। 

number = 1_500_000
print(number)

"""
15000000
"""संचालित द्वारा

अंडरस्कोर का एक और उपयोग संख्यात्मक लिटरल्स (integral, floating-point और complex) में अंकों के समूहों को अलग करने के लिए विजुअल सेपरेटर के रूप में है – यह Python 3.6 में पेश किया गया था। 

विचार यह था कि लंबे लिटरल्स की पठनीयता बढ़े, या ऐसे लिटरल्स जिनके मान को भागों में स्पष्ट रूप से अलग दिखना चाहिए – इसके बारे में अधिक PEP 515 में पढ़ सकते हैं।

कोड स्टाइल और सिंटैक्स ट्रिक्स

#18 __name__ == “__main__” 

if __name__ == "__main__":
    print("Read on to understand what is going on when you do this.")

"""
print("Read on to understand what is going on when you do this.")
"""संचालित द्वारा

काफी संभावना है कि आपने यह सिंटैक्स कई Python प्रोग्राम्स में देखा होगा; Python एक विशेष नाम "__main__" का उपयोग करता है और यदि चल रही Python फ़ाइल मुख्य प्रोग्राम है, तो इसे __name__ पहचानकर्ता को सेट करता है।

यदि हम स्क्रीनशॉट में दिखाए मॉड्यूल को किसी अन्य मॉड्यूल (Python फ़ाइल) में इम्पोर्ट करें और वह फ़ाइल चलाएँ, तो हमारे कोड में अभिव्यक्ति का सत्य False होगा। ऐसा इसलिए क्योंकि जब हम किसी अन्य मॉड्यूल से इम्पोर्ट करते हैं, तो __name__ पहचानकर्ता उस मॉड्यूल (Python फ़ाइल) के नाम पर सेट होता है। 

#19 ‘setdefault’ मेथड 

import pprint

text = "It's the first of April. It's still cold in the UK. But I'm going to the museum so it should be a wonderful day"

counts = {}
for word in text.split():
    counts.setdefault(word, 0)
    counts[word] += 1

pprint.pprint(counts)

"""
{'April.': 1,
'But': 1,
"I'm": 1,
"It's": 2,
'UK.': 1,
'a': 1,
'be': 1,
'cold': 1,
'day': 1,
'first': 1,
'going': 1,
'in': 1,
'it': 1,
'museum': 1,
'of': 1,
'should': 1,
'so': 1,
'still': 1,
'the': 3,
'to': 1,
'wonderful': 1}
"""संचालित द्वारा

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

1. जाँचें कि कुंजी डिक्शनरी में मौजूद है या नहीं
2. यदि है, तो मान में 1 जोड़ दें।
3. यदि नहीं है, तो उसे जोड़ें और मान 1 सेट करें।

कोड में यह इस तरह दिखता है:

counts = {}
for word in text.split():
    if word in counts:
        counts[word] += 1
    else:
      counts[word] = 1संचालित द्वारा

इसे करने का अधिक संक्षिप्त तरीका आपकी डिक्शनरी पर setdefault() मेथड का उपयोग करना है।

मेथड को दिया गया पहला आर्ग्युमेंट वह कुंजी है जिसकी हम जाँच करना चाहते हैं। दूसरा आर्ग्युमेंट वह मान है जो तब सेट किया जाएगा जब कुंजी डिक्शनरी में पहले से मौजूद न हो – यदि कुंजी मौजूद है, तो मेथड कुंजी का मान लौटाता है, अतः उसे बदला नहीं जाएगा।

प्रोग्राम स्ट्रक्चर ट्रिक्स

#20 Regex मिलान

import re

number = re.compile(r"(0)?(\+44)?\d{10}")
num_1 = number.search("My number is +447999999999")
num_2 = number.search("My number is 07999999999")

print(num_1.group())
print(num_2.group())

"""
'+447999999999'
'07999999999'
"""संचालित द्वारा

रेगुलर एक्सप्रेशंस आपको खोजने के लिए टेक्स्ट का पैटर्न निर्दिष्ट करने देती हैं; अधिकांश लोग जानते हैं कि हम CTRL + F (Windows) से चीजें खोज सकते हैं, लेकिन यदि आपको ठीक-ठीक पता नहीं कि क्या खोज रहे हैं, तो आप कैसे खोजेंगे? जवाब है पैटर्न खोजना।  

उदाहरण के लिए, यूके नंबर एक समान पैटर्न का पालन करते हैं: वे शुरुआत में शून्य और फिर दस अंक रखते हैं, या शून्य की जगह +44 और फिर दस अंक – दूसरी स्थिति अंतरराष्ट्रीय फ़ॉर्मेट दर्शाती है। 

रेगुलर एक्सप्रेशंस बड़ा समय बचाती हैं। यदि हम regex के बजाय अपनी छवि में दिखे मामलों को पकड़ने के लिए नियम कोड करें, तो 10+ पंक्तियाँ लग सकती हैं। 

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

#21 Regex pipe

import re

heros = re.compile(r"Super(man|woman|human)")

h1 = heros.search("This will find Superman")
h2 =  heros.search("This will find Superwoman")
h3 = heros.search("This will find Superhuman")

print(h1.group())
print(h2.group())
print(h3.group())

"""
Superman
Superwoman
Superhuman
"""संचालित द्वारा

रेगुलर एक्सप्रेशंस में pipe (|) नामक एक विशेष कैरेक्टर होता है जो आपको कई अभिव्यक्तियों में से किसी एक से मिलान करने देता है, और इसे कहीं भी उपयोग किया जा सकता है। जब आपके पास कई समान पैटर्न हों, यह बहुत काम आता है।

उदाहरण के लिए, 'Superman', 'Superwoman' और 'Superhuman' सभी का वही प्रीफ़िक्स है। इसलिए, आप pipe का लाभ उठाकर पैटर्न के दोहराए जाने वाले हिस्से को बनाए रख सकते हैं और जिन भागों को अलग चाहिए उन्हें बदल सकते हैं। एक बार फिर, आपका क़ीमती समय बचता है।

ध्यान दें: यदि जिन सभी अभिव्यक्तियों का आप मिलान करना चाहते हैं वे एक ही टेक्स्ट में मौजूद हैं, तो मिलान के लिए टेक्स्ट की पहली आवृत्ति लौटेगी – जैसे, "An example text containing Superwoman, Superman, Superhuman," का परिणाम Superwoman होगा।

#22 print() फ़ंक्शन का ‘sep’ पैरामीटर

day = "04"
month = "10"
year = "2022"

print(day, month, year)
print(day, month, year, sep = "")
print(day, month, year, sep = ".")

"""
04 10 2022
04/10/2022
04.10.2022
"""संचालित द्वारा

print() फ़ंक्शन की पूरी क्षमताओं से अनजान Python प्रोग्रामर्स की संख्या चौंकाने वाली है; यदि “Hello World” आपका पहला प्रोग्राम था, तो print() शायद Python सीखते समय आपके पहले बिल्ट-इन फ़ंक्शंस में से एक रहा होगा। हम स्क्रीन पर फ़ॉर्मेटेड संदेश दिखाने के लिए print() का उपयोग करते हैं, लेकिन print() में इससे कहीं ज़्यादा है। 

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

डिफ़ॉल्ट रूप से वे स्पेस से अलग होते हैं, लेकिन हमने अपनी print स्टेटमेंट्स में यह बदल दिया है – एक में sep को "" सेट किया है और दूसरे में sep को "."।

#23 Lambda फ़ंक्शंस 

def square(num:int) -> int:
    return num ** 2

print(f"Function call: {square(4)}")
"""
Function call: 16
"""

square_lambda = lambda x: x**2
print(f"Lambda function: {square_lambda(4)}")
"""
Lambda functional: 16
"""संचालित द्वारा

Lambda फ़ंक्शंस आपको Python से जुड़े अधिक इंटरमीडिएट-एडवांस्ड कामों तक ले जाती हैं – इस कोर्स से Intermediate Python सीखें। पहली नज़र में वे जटिल दिखती हैं, लेकिन दरअसल काफी सरल हैं।

हमारे उदाहरण कोड में, हमने केवल एक आर्ग्युमेंट उपयोग किया, लेकिन चाहें तो कई भी कर सकते हैं:

square = lambda a, b: a ** b
print(f"Lambda function: {square(4, 2)}")
"""
16
"""संचालित द्वारा

मूल रूप से, lambda कीवर्ड हमें एक पंक्ति में छोटे, सीमित, अनाम फ़ंक्शन बनाने देता है। वे def कीवर्ड से घोषित सामान्य फ़ंक्शन की तरह ही व्यवहार करते हैं, सिवाय इसके कि इन फ़ंक्शंस का नाम नहीं होता।

#24 ‘swapcase’ मेथड

string = "SoMe RaNDoM sTriNg"
print(string.swapcase())

"""
sOmE rAndOm StRInG
"""संचालित द्वारा

swapcase() मेथड को स्ट्रिंग ऑब्जेक्ट पर लागू कर हम एक ही पंक्ति में अपरकेस अक्षरों को लोअरकेस और लोअरकेस अक्षरों को अपरकेस में बदल सकते हैं। swapcase() के बहुत अधिक उपयोग के मामले नहीं हैं, लेकिन यह जानना अच्छा है।

#25 ‘isalnum’ मेथड

password = "ABCabc123"
print(password.isalnum())

"""
True
"""संचालित द्वारा

मान लें हम एक प्रोग्राम बना रहे हैं जिसमें उपयोगकर्ताओं को पासवर्ड इनपुट करना है, लेकिन उसमें अंकों और अक्षरों का संयोजन होना चाहिए। हम इसे एक ही पंक्ति में स्ट्रिंग इंस्टेंस पर isalnum() कॉल करके कर सकते हैं।

यह मेथड जाँचता है कि सभी कैरेक्टर्स अल्फाबेट (A-Za-z) और न्यूमेरिक (0-9) के हिस्से हैं या नहीं। कोई स्पेस या प्रतीक (!#%$&? आदि) False लौटाएगा।

#26 Exception हैंडलिंग

def get_ration(x:int, y:int) -> int:
    try:
        ratio = x/y
    except ZeroDivisionError:
        y = y + 1
        ratio = x/y
    return ratio

print(get_ration(x=400, y=0))

"""
400.0
"""संचालित द्वारा

Python प्रोग्राम किसी त्रुटि का सामना करने पर समाप्त हो जाते हैं।

कभी-कभी, हम यह व्यवहार नहीं चाहते, जैसे जब हमारा कोड किसी एंड-यूज़र के साथ इंटरैक्ट कर रहा हो। ऐसी स्थिति में हमारा कोड समय से पहले समाप्त हो जाए तो यह कितना बुरा होगा?

अपवादजन्य मामलों से निपटने के कई तरीके हैं। अधिकांश Python प्रोग्रामर आमतौर पर इस विचार को अपनाते हैं कि इजाज़त लेने से आसान माफी माँगना है। यानी वे त्रुटि उठने पर उसे पकड़ना और उसके आस-पास ऐसा संदर्भ देना पसंद करेंगे जो अपवाद को संभाल सके। इस विचार के पीछे तर्क यह है कि हर संभावित अपवादजन्य मामले से बचाव करने में समय बर्बाद करने का कोई मतलब नहीं।

लेकिन यह तभी सही है जब समस्या होने के बाद उससे निपटने का कोई तंत्र मौजूद हो।

#27 लिस्ट्स में अंतर पहचानना

list_1 = [1, 3, 5, 7, 8]
list_2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]

solution_1 = list(set(list_2) - set(list_1))
solution_2 = list(set(list_1) ^ set(list_2))
solution_3 = list(set(list_1).symmetric_difference(set(list_2)))

print(f"Solution 1: {solution_1}")
print(f"Solution 2: {solution_2}")
print(f"Solution 3: {solution_3}")

"""
Solution 1: [9, 2, 4, 6]
Solution 2: [2, 4, 6, 9]
Solution 3: [2, 4, 6, 9]
"""संचालित द्वारा

यहाँ Python में दो लिस्ट्स के बीच का अंतर तुलना करने के तीन अलग-अलग तरीके हैं। 

नोट: जब तक आपको पक्का न पता हो कि list_1, list_2 का सबसेट है, तब तक समाधान 1 बाकी दो समाधानों जैसा नहीं है।

#28 Args और kwargs

def some_function(*args, **kwargs):
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

some_function(1, 2, 3,  a=4, b=5, c=6)

"""
Args: (1, 2, 3)
Kwargs: {'a': 4, 'b': 5, 'c': 6}
"""संचालित द्वारा

हम *args और **kwargs का उपयोग फ़ंक्शन के पैरामीटर्स के रूप में तब करते हैं जब हमें नहीं पता होता कि हमारा फ़ंक्शन कितने वेरिएबल्स की अपेक्षा करे। 

*args पैरामीटर हमें non-keyworded (अर्थात जिन पैरामीटर्स के साथ नाम आवश्यक नहीं) की स्थिति में किसी फ़ंक्शन को परिवर्तनीय संख्या में पैरामीटर्स पास करने देता है। दूसरी ओर, **kwargs पैरामीटर हमें किसी फ़ंक्शन को मनमानी संख्या में keyworded पैरामीटर्स पास करने देता है।

वास्तव में, *args और **kwargs शब्द अपने-आप में जादुई नहीं हैं: जादू तो स्टार (*) में है। इसका मतलब यह है कि हम स्टार के बाद कोई भी शब्द इस्तेमाल कर सकते थे, लेकिन args और kwargs का उपयोग आम प्रचलन है और Python डेवलपर्स के बीच मान्य है। 

#29 Ellipsis

print(...)

"""
Ellipsis
"""

def some_function():
    ...

# Alternative solution
def another_function():
    passसंचालित द्वारा

Ellipsis एक Python ऑब्जेक्ट है जिसे तीन बिंदु (...) देकर या ऑब्जेक्ट (Ellipsis) को स्वयं कॉल करके बुलाया जा सकता है।

इसका सबसे उल्लेखनीय उपयोग NumPy में बहु-आयामी ऐरे एक्सेस और slicing के लिए होता है, उदाहरण के लिए:

import numpy as np

arr = np.array([[2,3], [1,2], [9,8]])

print(arr[...,0])
"""
[2 1 9]
"""
print(arr[...])

"""
[[2 3]
[1 2]
[9 8]]
"""संचालित द्वारा

लेकिन Ellipsis का एक और उपयोग अनइम्प्लीमेंटेड फ़ंक्शन में placeholder के रूप में है। 

इसका अर्थ है कि आप Ellipsis, ..., या pass में से कुछ भी दे सकते हैं, और तीनों मान्य होंगे।

#30 लिस्ट कॉम्प्रिहेंशन

even_numbers = [x for x in range(10) if x % 2 == 0 and x != 0]
print(even_numbers)

"""
[2, 4, 6, 8]
"""संचालित द्वारा

हमारी अंतिम Python ट्रिक है लिस्ट कॉम्प्रिहेंशन, जो किसी अन्य सीक्वेंस से लिस्ट बनाने का एक सुरुचिपूर्ण तरीका है। ये आपको जटिल लॉजिक और फ़िल्टरिंग करने देती हैं, जैसा हमने ऊपर के कोड में किया है।

उसी लक्ष्य को हासिल करने के अन्य तरीके भी हैं; उदाहरण के लिए, हम इस तरह lambda फ़ंक्शन का उपयोग कर सकते थे:

even_numbers = list(filter(lambda x: x % 2 ==0 and x != 0, range(10)))
print(even_numbers)
"""
[0, 2, 4, 6, 8]
"""संचालित द्वारा

लेकिन कई Pythonistas तर्क देंगे कि यह समाधान लिस्ट कॉम्प्रिहेंशन की तुलना में कम पठनीय है।