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

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

यदि आपकी Python स्किल्स अभी धारदार नहीं हैं, तो आप हमारे Python Skill Track से उन्हें निखार सकते हैं।

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

#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] दिया जाता है, तो लौटे हुए तत्व start इंडेक्स से लेकर stop - 1 तक होंगे (stop इंडेक्स शामिल नहीं होता)। 

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

#2 Inplace swap / simultaneous assignment

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 नहीं, तो आप in-place swapping के जाल में फंस गए। 

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

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

"""
1
2
3
"""

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

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

ऑटोमैटिक packing और unpacking को मिलाकर एक तकनीक बनती है जिसे simultaneous assignment कहते हैं। इससे हम मानों की एक श्रृंखला को वेरिएबल्स की एक श्रृंखला में असाइन कर सकते हैं।

#3 List बनाम tuples 

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 प्रोग्रामर list डेटा स्ट्रक्चर से परिचित होते हैं। वही बात tuples के लिए नहीं कही जा सकती। दोनों इटेरेबल हैं, इंडेक्सिंग की अनुमति देते हैं, और heterogeneous डेटा टाइप स्टोर कर सकते हैं। लेकिन कुछ स्थितियों में list के बजाय tuple का उपयोग बेहतर हो सकता है। 

सबसे पहले, lists mutable होती हैं, यानी हम उन्हें अपनी मर्जी से बदल सकते हैं: 

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

"""
[1,2,8,4,5]
"""

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

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

संक्षेप में: जिन परिस्थितियों में आप डेटा बदला नहीं जाना चाहते, वहाँ मेमोरी कारणों से list के बजाय tuple को प्राथमिकता दें। Tuples lists की तुलना में तेज भी होते हैं। 

इस ट्यूटोरियल में Python Data Structures के बारे में और जानें। 

#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>
"""

List comprehensions, किसी और इटेरेबल से लिस्ट बनाने का pythonic तरीका है—यह for loop से काफी तेज है। लेकिन अगर आप गलती से [] की जगह () लगा दें तो क्या होता है? आपको एक generator object मिलता है।

Python में, list comprehension जैसी लॉजिक को गोल ब्रैकेट्स में लिखने पर generator object बनता है। Generators एक विशेष प्रकार के इटेरेबल हैं। लिस्ट के विपरीत, वे अपने आइटम स्टोर नहीं करते। वे केवल प्रत्येक एलिमेंट को क्रम से जनरेट करने के निर्देश और इटरेशन की मौजूदा स्थिति स्टोर करते हैं।

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

#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 एक ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग भाषा है—सब कुछ ऑब्जेक्ट है। अतः, किसी ऑब्जेक्ट को किसी आइडेंटिफायर को असाइन करना उस ऑब्जेक्ट का रेफरेंस बनाना है। 

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

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

क्लोन बनाने का सबसे आसान तरीका slicing का इस्तेमाल करना है: 

b = a[:] 

यह b आइडेंटिफायर में एक नए list ऑब्जेक्ट का रेफरेंस बनाएगा। 

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

#6 'not' ऑपरेटर

a = []
print(not a)

"""
True
"""

किसी डेटा स्ट्रक्चर के खाली होने की जांच करने का सबसे आसान तरीका है not ऑपरेटर का उपयोग करना। Python का बिल्ट-इन not एक लॉजिकल ऑपरेटर है जो अभिव्यक्ति सच न होने पर True लौटाता है, अन्यथा False—यह Boolean अभिव्यक्तियों और ऑब्जेक्ट्स के 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!
"""

कभी-कभी हमें string ऑब्जेक्ट को फ़ॉर्मैट करना होता है; 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
"""

और जानने के लिए इस ट्यूटोरियल पर नज़र डालें: F-string Formatting in Python। 

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

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

"""
english french spanish german twi
"""

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

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

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

#9 Tuple में append करना

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

"""
(1, 2, [1, 2, 3, 4])
"""

हम पहले से जानते हैं कि tuples immutable होते हैं—देखें Python ट्रिक #3 List बनाम Tuples। Tuple की state बदलने की कोशिश करने पर TypeError आता है। पर यदि आप tuple ऑब्जेक्ट को उन नामों की श्रृंखला के रूप में सोचें जिनकी bindings बदली नहीं जा सकतीं, तो बात अलग दिखेगी।

हमारे tuple के पहले दो तत्व integers हैं—वे immutable हैं। अंतिम तत्व list है, जो Python में mutable ऑब्जेक्ट है।

यदि हम अपनी list को एक ऐसे नाम की तरह मानें जिसकी binding बदली नहीं जा सकती, तो यह समझ आएगा कि list को tuple के अंदर रहते हुए भी बदला जा सकता है।

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

#10 Dictionaries मर्ज करना

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 और आगे में, dictionaries को | (bitwise OR) से मर्ज करना संभव है। इस ट्रिक पर कहने को बहुत कुछ नहीं—बस इतना कि यह ज्यादा पढ़ने योग्य समाधान है! 

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

#11 Ternary ऑपरेटर / conditional expressions 

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

print(name)

"""
John
"""

ऊपर दिए कोड में आप ternary ऑपरेटर देख सकते हैं—इसे conditional expression भी कहा जाता है। हम इसका उपयोग शर्त के True या False होने पर मान चुनने के लिए करते हैं।

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

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

print(name)
"""
John
"""

हालाँकि दोनों कोड एक जैसा आउटपुट देते हैं, ternary conditional हमें अधिक छोटा और स्पष्ट कोड लिखने देता है। यह अधिक 'Pythonic' तरीका है। 

#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 में बदलना (और चाहें तो वापस list में)।

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

Lists ordered, ज़ीरो-बेस्ड indexed और mutable होती हैं। Sets unordered और unindexed होते हैं। Set के तत्व immutable टाइप के होने चाहिए, भले ही set स्वयं mutable हो—इंडेक्स से एलिमेंट लाने या एलिमेंट बदलने की कोशिश करने पर error आएगा।

एक और बड़ा अंतर यह है कि sets में डुप्लिकेट नहीं होते। इसी से हमने अपनी लिस्ट से डुप्लिकेट हटाए।

#13 अकेला underscore 

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

>>> 1 + 2
3

>>> print(_)
3

Underscore (_) Python में वैध आइडेंटिफायर है, अतः इसे किसी ऑब्जेक्ट को रेफर करने के लिए इस्तेमाल किया जा सकता है। लेकिन underscore का एक और दायित्व भी है: अंतिम इवैल्युएशन के नतीजे को स्टोर करना।

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

क्योंकि हमने पहली लाइन में underscore को कोई ऑब्जेक्ट असाइन नहीं किया था, हमें error मिला। लेकिन जब हमने 1 + 2 का आउटपुट निकाला, तो इंटरप्रेटर ने नतीजा _ आइडेंटिफायर में स्टोर कर दिया। 

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

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

"""
The index doesn't matter
The index doesn't matter
...
"""

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

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

#15 Trailing underscores

list_ = [0, 1, 2, 3, 4]
global_ = "Hi there" 

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

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

#16 Leading underscores

class Example:
    def __init__(self):
        self._internal = 2
        self.external = 20

आप अक्सर अनुभवी Python प्रोग्रामर्स को किसी आइडेंटिफायर या मेथड नाम के आगे underscore लगाते देखेंगे—और उसके पीछे वजह है।

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

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

#17 Underscore visual

यह underscores पर आखिरी टिप है; अब तक हमने underscore के तीन अलग-अलग उपयोग कवर किए हैं, लेकिन आप हमारे ट्यूटोरियल में और जान सकते हैं: Role of Underscore(_) in Python। 

number = 1_500_000
print(number)

"""
15000000
"""

underscore को इंटीग्रल, फ्लोटिंग-पॉइंट और कॉम्प्लेक्स नंबर लिटरल्स में अंकों के समूहों के बीच विजुअल सेपरेटर की तरह भी इस्तेमाल किया जा सकता है—यह 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__ आइडेंटिफायर पर सेट करता है।

यदि हम स्क्रीनशॉट में दिखाए मॉड्यूल को किसी दूसरी फ़ाइल (मॉड्यूल) में इम्पोर्ट करें और वह फ़ाइल चलाएँ, तो हमारे कोड में अभिव्यक्ति का सत्य 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}
"""

आप dictionary में विभिन्न keys के लिए कोई मान सेट करना चाह सकते हैं। उदाहरण के लिए, जब आप किसी corpus में शब्दों की गिनती ट्रैक कर रहे हों। आम तरीका इस प्रकार है: 

1. जाँचें कि key dictionary में मौजूद है या नहीं
2. अगर है, तो मान 1 से बढ़ाएँ।
3. अगर नहीं है, तो उसे जोड़ें और मान 1 सेट करें।

कोड में यह कुछ यूँ दिखता है:

counts = {}
for word in text.split():
    if word in counts:
        counts[word] += 1
    else:
      counts[word] = 1

इसे और संक्षिप्त रूप में करने का तरीका है dictionary ऑब्जेक्ट पर setdefault() मेथड का उपयोग।

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

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

#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'
"""

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

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

Regex बहुत समय बचाती है। यदि हम इमेज में दिखे मामलों को पकड़ने के लिए regex के बजाय नियमों का कोड लिखें, तो 10+ लाइनों तक लग सकती हैं। 

Regex कैसे काम करती है यह सीखना ज़रूरी है, भले आप कोड न लिखते हों। अधिकतर आधुनिक टेक्स्ट एडिटर्स और वर्ड प्रोसेसर में regex के साथ find/replace करने की सुविधा होती है।

#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
"""

Regular expressions में 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
"""

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

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

डिफॉल्ट रूप से वे स्पेस से अलग होते हैं, लेकिन हमने अपनी print स्टेटमेंट्स में इसे बदला है—एक में 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() मेथड किसी string ऑब्जेक्ट पर लागू होकर एक ही लाइन में uppercase अक्षरों को lowercase और lowercase अक्षरों को uppercase में बदल देता है। इसके बहुत अधिक उपयोग नहीं हैं, पर जानना अच्छा है।

#25 'isalnum' मेथड

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

"""
True
"""

मान लीजिए हम ऐसा प्रोग्राम बना रहे हैं जिसमें यूज़र को पासवर्ड इनपुट करना है, और उसमें अक्षरों व अंकों का संयोजन होना चाहिए। हम string इंस्टेंस पर 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 का subset है, समाधान 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 शब्दों में कुछ जादुई नहीं—जादू तो asterisks (*) में है। मतलब, asterisks के बाद हम कोई भी शब्द रख सकते हैं, पर 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 List comprehension

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

"""
[2, 4, 6, 8]
"""

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

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

even_numbers = list(filter(lambda x: x % 2 ==0 and x != 0, range(10)))
print(even_numbers)
"""
[0, 2, 4, 6, 8]
"""

पर कई Pythonista तर्क देंगे कि यह समाधान list comprehension से काफी कम पढ़ने योग्य है।