कई पुनरावृत्तियों पर उपयोग के लिए एकाधिक regexes को परिभाषित करने के पाइथोनिक और कुशल तरीके

Question

मैं वर्तमान में कुछ 10,000 या इतने इनपुट दस्तावेज़ों को संसाधित करने के लिए एक पायथन लिपि लिख रहा हूं। स्क्रिप्ट के प्रगति आउटपुट के आधार पर मुझे लगता है कि पहले 400+ दस्तावेज वास्तव में तेजी से संसाधित हो जाते हैं और फिर स्क्रिप्ट धीमा हो जाती है हालांकि इनपुट दस्तावेज़ सभी एक ही आकार के होते हैं।

मुझे लगता है कि यह इस तथ्य से हो सकता है कि अधिकांश दस्तावेज़ प्रसंस्करण regexes के साथ किया जाता है कि मैं संकलित होने के बाद regex ऑब्जेक्ट्स के रूप में सहेजता नहीं हूं। इसके बजाय, जब भी मुझे उनकी ज़रूरत होती है, मैं regexes recompile।

चूंकि मेरी स्क्रिप्ट में लगभग 10 अलग-अलग फ़ंक्शन हैं, जिनमें से सभी 10-20 अलग-अलग रेगेक्स पैटर्न का उपयोग करते हैं, मैं सोच रहा हूं कि पाइथन में रेगिक्स पैटर्न को दोबारा संकलित करने से बचने के लिए एक और अधिक प्रभावी तरीका क्या होगा (पर्ल में मैं बस एक संशोधक //o शामिल कर सकता था)।

मेरे धारणा है कि अगर मैं

pattern = re.compile() 

जिसके परिणामस्वरूप regex वस्तु (अगले चरण के लिए समारोह के अगले मंगलाचरण तक बनाकर नहीं रखे जाएंगे का उपयोग करने वाले कार्यों में regex वस्तुओं की दुकान प्रत्येक कार्य कहा जाता है लेकिन प्रति दस्तावेज़ एक बार)।

प्री-संकलित रेगेक्स की वैश्विक सूची बनाना एक अनैतिक विकल्प प्रतीत होता है क्योंकि मुझे वास्तव में उपयोग किए जाने के बजाय मेरे कोड में एक अलग स्थान पर रेगेक्स की सूची को स्टोर करने की आवश्यकता होगी।

इस साफ-सफाई और कुशलता से निपटने के तरीके पर कोई सलाह यहां दी गई है?

Answer 1

पुनः मॉड्यूल कैश संकलित पैटर्न संकलित। जब यह re._MAXCACHE के आकार तक पहुंच जाता है तो कैश साफ़ हो जाता है जो डिफ़ॉल्ट रूप से 100 होता है। (चूंकि आपके पास 10-20 रेगेक्स प्रत्येक (यानी 100-200 रेगेक्स) के साथ 10 फ़ंक्शन हैं, तो आपके मनाए गए धीमे-डाउन को साफ़ करने के साथ समझ में आता है ।

import re 
re._MAXCACHE = 1000 

Answer 2

संकलित नियमित अभिव्यक्ति स्वचालित रूप से re.compile, re.search और re.match द्वारा कैश कर रहे हैं, लेकिन अधिकतम कैश आकार अजगर 2.7 में 100 है, तो आप कैश बह निकला रहे हैं।

प्री-संकलित रेगेक्स की वैश्विक सूची बनाना एक अनैतिक विकल्प प्रतीत होता है क्योंकि मुझे वास्तव में उपयोग किए जाने के बजाय मेरे कोड में एक अलग स्थान पर रेगेक्स की सूची को स्टोर करने की आवश्यकता होगी।

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

Answer 3

पिछली बार मैंने देखा, re.compile: कैश)

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

def rc(pattern, flags=0): 
    key = pattern, flags 
    if key not in rc.cache: 
     rc.cache[key] = re.compile(pattern, flags) 
    return rc.cache[key] 

rc.cache = {} 

उपयोग::

rc('[a-z]').sub... 
rc('[a-z]').findall <- no compilation here 

मैं भी

class MyRECache(object): 
    def __init__(self): 
     self.cache = {} 
    def compile(self, regex_string): 
     if regex_string not in self.cache: 
      self.cache[regex_string] = re.compile(regex_string) 
     return self.cache[regex_string] 

Answer 4

की "सरल बेहतर है" भावना में मैं इस तरह एक छोटे से सहायक समारोह का उपयोग करेंगे regex को आजमाने का सुझाव दें। स्टॉक फिर से कई अन्य फायदों में से, इसका MAXCACHE डिफ़ॉल्ट रूप से 500 है और पूरी तरह से ओवरफ़्लो पर नहीं छोड़ा जाएगा।