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

पिछले चयन ।

संरचनात्मक तुलना

कभी-कभी परीक्षण करते समय कुछ मूल्यों की अनदेखी करते हुए, जटिल संरचनाओं की तुलना करना आवश्यक होता है। यह आमतौर पर ऐसी संरचना से विशिष्ट मूल्यों की तुलना करके किया जा सकता है:

>>> d = dict(a=1, b=2, c=3) >>> assert d['a'] == 1 >>> assert d['c'] == 3 

हालाँकि, आप एक विशेष मान बना सकते हैं जो किसी अन्य के बराबर हो:

 >>> assert d == dict(a=1, b=ANY, c=3) 

यह __eq__ मैजिक विधि का उपयोग करके आसानी से किया जाता है:

 >>> class AnyClass: ... def __eq__(self, another): ... return True ... >>> ANY = AnyClass() 

stdout

sys.stdout एक रैपर है जो आपको स्ट्रिंग मान लिखने देता है, बाइट्स नहीं। ये स्ट्रिंग मान स्वचालित रूप से sys.stdout.encoding का उपयोग कर एन्कोडेड हैं:

 >>> sys.stdout.write('Straße\n') Straße >>> sys.stdout.encoding 'UTF-8' sys.stdout.encoding 

केवल-पढ़ने और डिफ़ॉल्ट एन्कोडिंग के बराबर, जिसे PYTHONIOENCODING पर्यावरण PYTHONIOENCODING का उपयोग करके कॉन्फ़िगर किया जा सकता है:

 $ PYTHONIOENCODING=cp1251 python3 Python 3.6.6 (default, Aug 13 2018, 18:24:23) [GCC 4.8.5 20150623 (Red Hat 4.8.5-28)] on linux Type "help", "copyright", "credits" or "license" for more information. >>> import sys >>> sys.stdout.encoding 'cp1251' 

यदि आप बाइट्स को sys.stdout.buffer लिखना चाहते हैं, तो आप रैपर में रखे बफर के sys.stdout.buffer उपयोग करके स्वचालित एन्कोडिंग को छोड़ सकते हैं:

 >>> sys.stdout <_io.TextIOWrapper name='<stdut>' mode='w' encoding='cp1251'> >>> sys.stdout.buffer <_io.BufferedWriter name='<stdut>'> >>> sys.stdout.buffer.write(b'Stra\xc3\x9fe\n') Straße sys.stdout.buffer 

एक आवरण भी। यह फ़ाइल डिस्क्रिप्टर को sys.stdout.buffer.raw साथ संपर्क करके बाईपास किया जा सकता है:

 >>> sys.stdout.buffer.raw.write(b'Stra\xc3\x9fe') Straße 

लगातार इलिप्सिस

पायथन में बहुत कम अंतर्निर्मित स्थिरांक हैं। उनमें से एक, Ellipsis को भी लिखा जा सकता है ... दुभाषिया के लिए, इस स्थिरांक का कोई विशिष्ट मूल्य नहीं है, लेकिन इसका उपयोग उस स्थान पर किया जाता है जहां इस तरह के वाक्यविन्यास उपयुक्त होते हैं।

numpy को numpy तर्क के रूप में समर्थन करता है, उदाहरण के लिए, x[...] x सभी तत्वों को लौटाता है।

PEP 484 इस स्थिरांक के लिए एक और मूल्य निर्धारित करता है: Callable[..., type] आपको तर्कों के प्रकारों को निर्दिष्ट किए बिना कॉल के प्रकारों को निर्धारित करने की अनुमति देता है।

अंत में, आप उपयोग कर सकते हैं ... यह इंगित करने के लिए कि एक फ़ंक्शन अभी तक लागू नहीं हुआ है। यह पायथन कोड पूरी तरह से सही है:

 def x(): ... 

हालाँकि, पायथन 2 में Ellipsis को नहीं लिखा जा सकता है ... एक अपवाद a[...] , जिसकी व्याख्या a[Ellipsis] ।

यह वाक्यविन्यास पायथन 3 के लिए सही है, लेकिन पायथन 2 के लिए केवल पहली पंक्ति सही है:

 a[...] a[...:2:...] [..., ...] {...:...} a = ... ... is ... def a(x=...): ... 

पुन: आयात मॉड्यूल

पहले से आयातित मॉड्यूल फिर से लोड नहीं होंगे। import foo कमांड केवल कुछ नहीं करता है। हालांकि, यह एक संवादात्मक वातावरण में काम करते समय मॉड्यूल को फिर से खोलने के लिए उपयोगी है। पायथन 3.4+ में, इसके लिए importlib का उपयोग किया जाना चाहिए:

 In [1]: import importlib In [2]: with open('foo.py', 'w') as f: ...: f.write('a = 1') ...: In [3]: import foo In [4]: foo.a Out[4]: 1 In [5]: with open('foo.py', 'w') as f: ...: f.write('a = 2') ...: In [6]: foo.a Out[6]: 1 In [7]: import foo In [8]: foo.a Out[8]: 1 In [9]: importlib.reload(foo) Out[9]: <module 'foo' from '/home/v.pushtaev/foo.py'> In [10]: foo.a Out[10]: 2 

autoreload लिए एक autoreload एक्सटेंशन भी है, जो आवश्यक होने पर स्वचालित रूप से मॉड्यूल को फिर से autoreload करेगा:

 In [1]: %load_ext autoreload In [2]: %autoreload 2 In [3]: with open('foo.py', 'w') as f: ...: f.write('print("LOADED"); a=1') ...: In [4]: import foo LOADED In [5]: foo.a Out[5]: 1 In [6]: with open('foo.py', 'w') as f: ...: f.write('print("LOADED"); a=2') ...: In [7]: import foo LOADED In [8]: foo.a Out[8]: 2 In [9]: with open('foo.py', 'w') as f: ...: f.write('print("LOADED"); a=3') ...: In [10]: foo.a LOADED Out[10]: 3 

\ _ जी

कुछ भाषाओं में आप \G अभिव्यक्ति का उपयोग कर सकते हैं। यह उस स्थिति से मेल खाता है जिस पर पिछली खोज समाप्त हुई थी। यह हमें परिमित राज्य मशीनों को लिखने की अनुमति देता है जो शब्द द्वारा स्ट्रिंग मानों को संसाधित करते हैं (शब्द एक नियमित अभिव्यक्ति द्वारा निर्धारित किया जाता है)।

पायथन में, इस अभिव्यक्ति की तरह कुछ भी नहीं है, और आप नियमित अभिव्यक्ति कार्यों के लिए स्ट्रिंग की स्थिति और गुजरने वाले हिस्से को मैन्युअल रूप से ट्रैक करके समान कार्यक्षमता को लागू कर सकते हैं:

 import re import json text = '<a><b>foo</b><c>bar</c></a><z>bar</z>' regex = '^(?:<([az]+)>|</([az]+)>|([az]+))' stack = [] tree = [] pos = 0 while len(text) > pos: error = f'Error at {text[pos:]}' found = re.search(regex, text[pos:]) assert found, error pos += len(found[0]) start, stop, data = found.groups() if start: tree.append(dict( tag=start, children=[], )) stack.append(tree) tree = tree[-1]['children'] elif stop: tree = stack.pop() assert tree[-1]['tag'] == stop, error if not tree[-1]['children']: tree[-1].pop('children') elif data: stack[-1][-1]['data'] = data print(json.dumps(tree, indent=4)) 

उपरोक्त उदाहरण में, आप लाइन को बार-बार तोड़े बिना प्रसंस्करण पर समय बचा सकते हैं, और re मॉड्यूल को किसी अन्य स्थिति से देखना शुरू करने के लिए कह सकते हैं।

ऐसा करने के लिए, आपको कोड में कुछ बदलाव करने होंगे। सबसे पहले, re.search खोज की शुरुआत की स्थिति निर्धारित करने का समर्थन नहीं करता है, इसलिए आपको नियमित रूप से अभिव्यक्ति को मैन्युअल रूप से संकलित करना होगा। दूसरे, ^ स्ट्रिंग मान की शुरुआत को दर्शाता है, और खोज की शुरुआत की स्थिति नहीं, इसलिए आपको मैन्युअल रूप से जांचने की आवश्यकता है कि मैच उसी स्थिति में मिला है।

 import re import json text = '<a><b>foo</b><c>bar</c></a><z>bar</z>' * 10 def print_tree(tree): print(json.dumps(tree, indent=4)) def xml_to_tree_slow(text): regex = '^(?:<([az]+)>|</([az]+)>|([az]+))' stack = [] tree = [] pos = 0 while len(text) > pos: error = f'Error at {text[pos:]}' found = re.search(regex, text[pos:]) assert found, error pos += len(found[0]) start, stop, data = found.groups() if start: tree.append(dict( tag=start, children=[], )) stack.append(tree) tree = tree[-1]['children'] elif stop: tree = stack.pop() assert tree[-1]['tag'] == stop, error if not tree[-1]['children']: tree[-1].pop('children') elif data: stack[-1][-1]['data'] = data def xml_to_tree_slow(text): regex = '^(?:<([az]+)>|</([az]+)>|([az]+))' stack = [] tree = [] pos = 0 while len(text) > pos: error = f'Error at {text[pos:]}' found = re.search(regex, text[pos:]) assert found, error pos += len(found[0]) start, stop, data = found.groups() if start: tree.append(dict( tag=start, children=[], )) stack.append(tree) tree = tree[-1]['children'] elif stop: tree = stack.pop() assert tree[-1]['tag'] == stop, error if not tree[-1]['children']: tree[-1].pop('children') elif data: stack[-1][-1]['data'] = data return tree _regex = re.compile('(?:<([az]+)>|</([az]+)>|([az]+))') def _error_message(text, pos): return text[pos:] def xml_to_tree_fast(text): stack = [] tree = [] pos = 0 while len(text) > pos: error = f'Error at {text[pos:]}' found = _regex.search(text, pos=pos) begin, end = found.span(0) assert begin == pos, _error_message(text, pos) assert found, _error_message(text, pos) pos += len(found[0]) start, stop, data = found.groups() if start: tree.append(dict( tag=start, children=[], )) stack.append(tree) tree = tree[-1]['children'] elif stop: tree = stack.pop() assert tree[-1]['tag'] == stop, _error_message(text, pos) if not tree[-1]['children']: tree[-1].pop('children') elif data: stack[-1][-1]['data'] = data return tree print_tree(xml_to_tree_fast(text)) 

परिणाम:

 In [1]: from example import * In [2]: %timeit xml_to_tree_slow(text) 356 µs ± 16.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) In [3]: %timeit xml_to_tree_fast(text) 294 µs ± 6.15 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) 

गोल संख्या

यह आइटम टेलीग्राम चैनल @itgram_channel के लेखक orininium द्वारा लिखा गया था।

round फ़ंक्शन दशमलव स्थानों की निर्दिष्ट संख्या के लिए एक संख्या को round करता है।

 >>> round(1.2) 1 >>> round(1.8) 2 >>> round(1.228, 1) 1.2 

आप एक नकारात्मक गोलाई सटीकता भी निर्धारित कर सकते हैं:

 >>> round(413.77, -1) 410.0 >>> round(413.77, -2) 400.0 round 

इनपुट नंबर के समान मान का रिटर्न देता है:

 >>> type(round(2, 1)) <class 'int'> >>> type(round(2.0, 1)) <class 'float'> >>> type(round(Decimal(2), 1)) <class 'decimal.Decimal'> >>> type(round(Fraction(2), 1)) <class 'fractions.Fraction'> 

अपनी स्वयं की कक्षाओं के लिए, आप __round__ विधि का उपयोग करके round प्रसंस्करण को परिभाषित कर सकते हैं:

 >>> class Number(int): ... def __round__(self, p=-1000): ... return p ... >>> round(Number(2)) -1000 >>> round(Number(2), -2) -2 

यहाँ मानों को निकटतम 10 ** (-precision) कई 10 ** (-precision) । उदाहरण के लिए, precision=1 मान 0.1: round(0.63, 1) कई के साथ round(0.63, 1) 0.6 । यदि दो एकाधिक संख्याएँ समान रूप से पास हैं, तो एक सम संख्या में गोलाई का प्रदर्शन किया जाता है:

 >>> round(0.5) 0 >>> round(1.5) 2 

कभी-कभी एक अस्थायी बिंदु संख्या को गोल करना एक अप्रत्याशित परिणाम दे सकता है:

 >>> round(2.85, 1) 2.9 

तथ्य यह है कि अधिकांश दशमलव अंशों को एक फ्लोटिंग पॉइंट नंबर ( https://docs.python.org/3.7/tutorial/floatingpoint.html ) का उपयोग करके सटीक रूप से व्यक्त नहीं किया जा सकता है:

 >>> format(2.85, '.64f') '2.8500000000000000888178419700125232338905334472656250000000000000' 

यदि आप आधा चक्कर decimal.Decimal चाहते हैं, तो decimal.Decimal उपयोग करें decimal.Decimal :

 >>> from decimal import Decimal, ROUND_HALF_UP >>> Decimal(1.5).quantize(0, ROUND_HALF_UP) Decimal('2') >>> Decimal(2.85).quantize(Decimal('1.0'), ROUND_HALF_UP) Decimal('2.9') >>> Decimal(2.84).quantize(Decimal('1.0'), ROUND_HALF_UP) Decimal('2.8')