@Pythonetc जून 2019

यह मेरी @pythonetc फीड से पायथन टिप्स और प्रोग्रामिंग का ग्यारहवां चयन है।

← पिछला संग्रह


एक नियमित लाइन पर \ वर्ण का विशेष अर्थ है। \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) ] 

आप अपनी इच्छानुसार इसमें मिला सकते हैं:

 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 की तुलना (प्राथमिकता) करने के लिए मूल्य है, और 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 सरल पुनरावृत्तियों का समर्थन करता है, अर्थात् एक अच्छा संस्करण:

 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) बराबर है। a और 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