मेरे टेलीग्राम-चैनल @pythonetc से टिप्स और ट्रिक, जून 2019

यह मेरे टेलीग्राम-चैनल @pythonetc से पायथन और प्रोग्रामिंग के बारे में सुझावों और ट्रिक्स का एक नया चयन है।

Ations पिछला प्रकाशन


नियमित स्ट्रिंग में \ प्रतीक का विशेष अर्थ है। \t टैब कैरेक्टर है, \r कैरिज रिटर्न वगैरह है।

आप इस व्यवहार को अक्षम करने के लिए कच्चे-तार का उपयोग कर सकते हैं। r'\t' सिर्फ बैकस्लैश और t ।

आप स्पष्ट रूप से ' अंदर r'...' उपयोग नहीं कर सकते। हालाँकि, यह अभी भी बच सकता है, लेकिन स्ट्रिंग में संरक्षित किया गया है:

 >>> print(r'It\'s insane!') It\'s insane! 

सूची की समझ में एक से अधिक और if खंड शामिल हो सकते हैं:

 In : [(x, y) for x in range(3) for y in range(3)] Out: [ (0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2) ] In : [ (x, y) for x in range(3) for y in range(3) if x != 0 if y != 0 ] Out: [(1, 1), (1, 2), (2, 1), (2, 2)] 

इसके अलावा, किसी भी अभिव्यक्ति के for और if पहले से परिभाषित सभी चर का उपयोग कर सकते हैं:

 In : [ (x, y) for x in range(3) for y in range(x + 2) if x != y ] Out: [ (0, 1), (1, 0), (1, 2), (2, 0), (2, 1), (2, 3) ] 

आप मिश्रण कर सकते हैं if एस और एस के for आप चाहते हैं लेकिन:

 In : [ (x, y) for x in range(5) if x % 2 for y in range(x + 2) if x != y ] Out: [ (1, 0), (1, 2), (3, 0), (3, 1), (3, 2), (3, 4) ] 

sorted फ़ंक्शन आपको sorted करने के लिए कस्टम विधि प्रदान करने की अनुमति देता है। यह key तर्क के साथ किया गया है, जो मूल मूल्यों को उन मूल्यों में परिवर्तित करने का वर्णन करता है, जिनकी वास्तव में तुलना की जाती है:

 >>> x = [dict(name='Vadim', age=29), dict(name='Alex', age=4)] >>> sorted(x, key=lambda v: v['age']) [{'age': 4, 'name': 'Alex'}, {'age': 29, 'name': 'Vadim'}] 

काश, सभी पुस्तकालयों कि तुलना के साथ काम इस key तर्क की तरह कुछ का समर्थन नहीं करते। उल्लेखनीय उदाहरण heapq (आंशिक समर्थन) और heapq (कोई समर्थन नहीं)।

स्थिति से निपटने के दो तरीके हैं। पहला कस्टम ऑब्जेक्ट्स का उपयोग करना है जो उचित कंप्रेशन का समर्थन करते हैं:

 >>> class User: ... def __init__(self, name, age): ... self.name = name ... self.age = age ... def __lt__(self, other): ... return self.age < other.age ... >>> x = [User('Vadim', 29), User('Alex', 4)] >>> [x.name for x in sorted(x)] ['Alex', 'Vadim'] 

हालाँकि, आपको ऐसी कक्षाओं के कई संस्करण बनाने पड़ सकते हैं क्योंकि वस्तुओं की तुलना करने के लिए एक से अधिक तरीके हैं। यह थकाऊ हो सकता है, लेकिन दूसरे तरीके से आसानी से हल किया जा सकता है।

कस्टम ऑब्जेक्ट बनाने के बजाय आप tuples (a, b) उपयोग कर सकते हैं जहाँ a (तुलना करने के लिए मूल्य aka prioirty) और b मूल मूल्य है:

 >>> users = [dict(name='Vadim', age=29), dict(name='Alex', age=4)] >>> to_sort = [(u['age'], u) for u in users] >>> [x[1]['name'] for x in sorted(to_sort)] ['Alex', 'Vadim'] 

फ़ंक्शन परिभाषा और जनरेटर परिभाषा के बीच का अंतर फ़ंक्शन बॉडी में yield कीवर्ड की उपस्थिति है:

 In : def f(): ...: pass ...: In : def g(): ...: yield ...: In : type(f()) Out: NoneType In : type(g()) Out: generator 

इसका मतलब है कि एक खाली जनरेटर बनाने के लिए आपको कुछ इस तरह से करना होगा:

 In : def g(): ...: if False: ...: yield ...: In : list(g()) Out: [] 

हालांकि, yield from बाद yield from सरल चलने वालों का समर्थन करता है कि बेहतर दिखने वाला संस्करण यह होगा:

 def g(): yield from [] 

पायथन में, आप तुलना ऑपरेटरों की श्रृंखला कर सकते हैं:

 >>> 0 < 1 < 2 True >>> 0 < 1 < 0 False 

ऐसी श्रृंखलाओं को गणितीय रूप से मान्य नहीं होना चाहिए, आप > और < : मिला सकते हैं

 >>> 0 < 1 > 2 False >>> 0 < 1 < 2 > 1 > 0 True 

अन्य ऑपरेटर जैसे == , is और समर्थित हैं:

 >>> [] is not 3 in [1, 2, 3] True 

प्रत्येक ऑपरेटर को दो निकटतम ऑपरेंड पर लागू किया जाता है। a OP1 b OP2 c कड़ाई से (a OP1 b) AND (b OP2 c) बराबर है। c और c बीच कोई तुलना निहित नहीं है:

 class Spy: def __init__(self, x): self.x = x def __eq__(self, other): print(f'{self.x} == {other.x}') return self.x == other.x def __ne__(self, other): print(f'{self.x} != {other.x}') return self.x != other.x def __lt__(self, other): print(f'{self.x} < {other.x}') return self.x < other.x def __le__(self, other): print(f'{self.x} <= {other.x}') return self.x <= other.x def __gt__(self, other): print(f'{self.x} > {other.x}') return self.x > other.x def __ge__(self, other): print(f'{self.x} >= {other.x}') return self.x >= other.x s1 = Spy(1) s2 = Spy(2) s3 = Spy(3) print(s1 is s1 < s2 <= s3 == s3) 

आउटपुट:

 1 < 2 2 <= 3 3 == 3 True