मेरे टेलीग्राम-चैनल @pythonetc से टिप्स एंड ट्रिक्स, फरवरी 2019

यह मेरे टेलीग्राम-चैनल @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() 

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

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

sys.stdout.encoding केवल-पढ़ने के लिए है और पायथन डिफ़ॉल्ट एन्कोडिंग के बराबर है, जिसे 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' 

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

 >>> sys.stdout <_io.TextIOWrapper name='<stdout>' mode='w' encoding='cp1251'> >>> sys.stdout.buffer <_io.BufferedWriter name='<stdout>'> >>> _ = 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 जिसे लिखा भी जा सकता है ... इस स्थिरांक का दुभाषिया के लिए कोई विशेष अर्थ नहीं है, लेकिन उन स्थानों पर उपयोग किया जाता है जहां इस तरह के वाक्यविन्यास उपयुक्त होते हैं।

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

पीईपी 484 अतिरिक्त अर्थ को परिभाषित करता है: Callable[..., type] एक प्रकार का कॉलबैल परिभाषित करने का एक तरीका है जिसमें कोई तर्क प्रकार निर्दिष्ट नहीं है।

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

 def x(): ... 

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

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

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

मॉड्यूल पुनःपूर्ति

पहले से आयातित मॉड्यूल फिर से लोड नहीं होंगे। import foo सिर्फ कुछ नहीं करता है। हालांकि, यह एक संवादात्मक वातावरण में काम करते समय मॉड्यूल को पुन: आयात करने के लिए उपयोगी साबित हुआ। पायथन importlib में ऐसा करने का उचित तरीका है 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 

ipython में 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 अभिकथन का उपयोग कर सकते हैं। यह उस स्थिति से मेल खाता है जहां पिछला मैच समाप्त हुआ है। यह परिमित ऑटोमेटा लिखने की अनुमति देता है जो शब्द द्वारा स्ट्रिंग शब्द के माध्यम से चलते हैं (जहां शब्द रेगेक्स द्वारा परिभाषित किया गया है)।

हालाँकि, पायथन में ऐसी कोई बात नहीं है। उचित वर्कअराउंड स्थिति को मैन्युअल रूप से ट्रैक करना और rexx फ़ंक्शन के विकल्प को पास करना है:

 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)) 

पिछले उदाहरण में, हम बार-बार स्ट्रिंग को स्लाइस करने से बचाकर कुछ समय बचा सकते हैं लेकिन पुनः मॉड्यूल को इसके बजाय एक अलग स्थिति से शुरू करने के लिए खोज करने के लिए कह सकते हैं।

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

 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(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__ विधि के साथ गोल प्रसंस्करण को परिभाषित कर सकते हैं:

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

मानों को निकटतम 10 ** (-precision) संख्या के लिए गोल किया जाता है। उदाहरण के लिए, precision=1 मान 0.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 उपयोग कर सकते हैं।

 >>> 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')