दिलचस्प पोस्ट
एक साजिश में 4 घटता प्लॉटिंग, 3 वाई-एक्से के साथ वेक्टर ड्रेनेबल – क्या यह एंड्रॉइड के प्री-लॉलीपॉप संस्करणों के लिए किसी तरह उपलब्ध है? बाइट के लिए उचित हाइबरनेट एनोटेशन एकत्रीकरण प्रश्नों पर मोंगोडीबी का प्रदर्शन आधार वर्ग को व्युत्पन्न वर्ग में परिवर्तित करें एक बार एक बार तैनाती के लिए फाइलें जोड़ना मैं एक एंड्रॉइड ऐप कैसे प्रोग्राम "रीस्टार्ट" करूँ? रिक्त तर्क के लिए विधि ओवरलोडिंग सी में उपयोगकर्ता से इनपुट प्राप्त करने का सबसे अच्छा तरीका क्या है? 64-बिट में एक संयुक्त गुणा और डिवाइड ऑपरेशन करने का सबसे सटीक तरीका है? क्यों strncpy असुरक्षित है? ब्लूटूथ का उपयोग करते हुए दो आईफोन डिवाइसेस के बीच दूरी कैसे मापें? "फाइल नहीं मिली" निर्माण के डेक्सडबबग कार्य में अपवाद कॉलम फ़ील्ड के लिए दो पंक्तियों के बीच अंतर कैसे प्राप्त करें? एकाधिक क्रियाएं मिलीं जो वेब एपीआई में अनुरोध से मेल खाती हैं

पायथन में एक नियमित अभिव्यक्ति के पीछे

मैं एक नियमित अभिव्यक्ति को रिवर्स करना चाहता हूं Ie ने एक नियमित अभिव्यक्ति दी, मैं किसी भी स्ट्रिंग का उत्पादन करना चाहता हूँ जो उस रेगेक्स से मेल खाएगा।

मुझे यह पता है कि यह एक सैद्धांतिक कंप्यूटर साइंस पृष्ठभूमि से एक परिमित राज्य मशीन का उपयोग करके कैसे करना है, लेकिन मैं यह जानना चाहता हूं कि अगर कोई ऐसा करने के लिए पहले से ही एक लाइब्रेरी लिखी है तो 🙂

मैं पायथन का उपयोग कर रहा हूं, इसलिए मुझे एक पायथन लाइब्रेरी चाहिए।

दोहराए जाने के लिए, मुझे केवल एक स्ट्रिंग चाहिए जो रैगेक्स से मेल खाएगा। इस तरह की चीजें "।" या "। *" स्ट्रिंग की एक अनंत राशि को रेगेक्स से मेल खाती है, लेकिन मुझे सभी विकल्पों के बारे में परवाह नहीं है

मैं इस लाइब्रेरी के लिए तैयार हूं, केवल रेगेक्स के एक निश्चित सबसेट पर काम करना।

Solutions Collecting From Web of "पायथन में एक नियमित अभिव्यक्ति के पीछे"

किसी और के पास एक समान (डुप्लिकेट?) सवाल है , और मैं अजगर के साथ यादृच्छिक स्ट्रिंग्स उत्पन्न करने के लिए थोड़ा सहायक लाइब्रेरी प्रदान करना चाहूंगा, जिस पर मैं काम कर रहा हूं।

इसमें एक विधि, xeger() है जो आपको एक xeger() से एक स्ट्रिंग बनाने की अनुमति देता है:

 >>> import rstr >>> rstr.xeger(r'[AZ]\d[AZ] \d[AZ]\d') u'M5R 2W4' 

अभी, यह सबसे बुनियादी नियमित अभिव्यक्तियों के साथ काम करता है, लेकिन मुझे विश्वास है कि यह सुधार किया जा सकता है।

यद्यपि मुझे इसमें बहुत कुछ नहीं लगता है, यहां जाता है:

 import re import string def traverse(tree): retval = '' for node in tree: if node[0] == 'any': retval += 'x' elif node[0] == 'at': pass elif node[0] in ['min_repeat', 'max_repeat']: retval += traverse(node[1][2]) * node[1][0] elif node[0] == 'in': if node[1][0][0] == 'negate': letters = list(string.ascii_letters) for part in node[1][1:]: if part[0] == 'literal': letters.remove(chr(part[1])) else: for letter in range(part[1][0], part[1][1]+1): letters.remove(chr(letter)) retval += letters[0] else: if node[1][0][0] == 'range': retval += chr(node[1][0][1][0]) else: retval += chr(node[1][0][1]) elif node[0] == 'not_literal': if node[1] == 120: retval += 'y' else: retval += 'x' elif node[0] == 'branch': retval += traverse(node[1][1][0]) elif node[0] == 'subpattern': retval += traverse(node[1][1]) elif node[0] == 'literal': retval += chr(node[1]) return retval print traverse(re.sre_parse.parse(regex).data) 

मैं रेगुलर एक्सप्रेशन सिंटैक्स से लेकर समूह तक सब कुछ ले लिया – यह एक उचित उपसमुच्चय जैसा दिखता है – और मैंने कुछ विवरणों की उपेक्षा की, जैसे लाइन एंडिंग्स त्रुटि संभाल, आदि रीडर के लिए एक व्यायाम के रूप में छोड़ दिया है।

रेगेक्स में 12 विशेष वर्णों में से, हम 6 पूरी तरह से अनदेखा कर सकते हैं (2 भी परमाणु के साथ लागू होते हैं), 4.5 एक मामूली प्रतिस्थापन के लिए नेतृत्व और 1.5 हमें वास्तव में सोचें।

क्या इस से बाहर आता है भी बहुत दिलचस्प नहीं है, मुझे लगता है।

मुझे ऐसा करने के लिए किसी भी मॉड्यूल का पता नहीं है। यदि आपको कुकबुक या पीईपीआई में इस तरह से कुछ भी नहीं मिलता है, तो आप (अंडोग्राडेड) re.sre_parse मॉड्यूल का उपयोग करके अपने खुद के रोलिंग की कोशिश कर सकते हैं। इससे आपको शुरू करने में मदद मिल सकती है:

 In [1]: import re In [2]: a = re.sre_parse.parse("[abc]+[def]*\d?z") In [3]: a Out[3]: [('max_repeat', (1, 65535, [('in', [('literal', 97), ('literal', 98), ('literal', 99)])])), ('max_repeat', (0, 65535, [('in', [('literal', 100), ('literal', 101), ('literal', 102)])])), ('max_repeat', (0, 1, [('in', [('category', 'category_digit')])])), ('literal', 122)] In [4]: eval(str(a)) Out[4]: [('max_repeat', (1, 65535, [('in', [('literal', 97), ('literal', 98), ('literal', 99)])])), ('max_repeat', (0, 65535, [('in', [('literal', 100), ('literal', 101), ('literal', 102)])])), ('max_repeat', (0, 1, [('in', [('category', 'category_digit')])])), ('literal', 122)] In [5]: a.dump() max_repeat 1 65535 in literal 97 literal 98 literal 99 max_repeat 0 65535 in literal 100 literal 101 literal 102 max_repeat 0 1 in category category_digit literal 122 

जब तक कि आपके regex अत्यंत सरल (यानी कोई तारे या प्लसस नहीं), असीम रूप से कई तार होंगे जो इसे मैच करेंगे। यदि आपके regex में केवल एकता और वैकल्पिकता शामिल है, तो आप अपनी सभी संभावनाओं में प्रत्येक परिवर्तन का विस्तार कर सकते हैं, उदाहरण के लिए (foo|bar)(baz|quux) सूची में विस्तार किया जा सकता है ['foobaz', 'fooquux', 'barbaz', 'barquux']

जबकि अन्य जवाबों का उपयोग करने के लिए फिर से इंजिन का उपयोग तत्वों को पार्स करने के लिए करते हैं, मैंने अपनी खुद की गड़बड़ी की है जो कि पार्स करता है और एक न्यूनतम पैटर्न देता है जो मैच होगा। (ध्यान दें कि यह [^ विज्ञापन] को नियंत्रित नहीं करता है, फैंसी ग्रुपिंग निर्माण, विशेष वर्णों की शुरुआत / समाप्ति) अगर आप वास्तव में पसंद करते हैं तो मैं इकाई परीक्षण की आपूर्ति कर सकता हूँ 🙂

 import re class REParser(object): """Parses an RE an gives the least greedy value that would match it""" def parse(self, parseInput): re.compile(parseInput) #try to parse to see if it is a valid RE retval = "" stack = list(parseInput) lastelement = "" while stack: element = stack.pop(0) #Read from front if element == "\\": element = stack.pop(0) element = element.replace("d", "0").replace("D", "a").replace("w", "a").replace("W", " ") elif element in ["?", "*"]: lastelement = "" element = "" elif element == ".": element = "a" elif element == "+": element = "" elif element == "{": arg = self._consumeTo(stack, "}") arg = arg[:-1] #dump the } arg = arg.split(",")[0] #dump the possible , lastelement = lastelement * int(arg) element = "" elif element == "[": element = self._consumeTo(stack, "]")[0] # just use the first char in set if element == "]": #this is the odd case of []<something>] self._consumeTo(stack, "]") # throw rest away and use ] as first element elif element == "|": break # you get to an | an you have all you need to match elif element == "(": arg = self._consumeTo(stack, ")") element = self.parse( arg[:-1] ) retval += lastelement lastelement = element retval += lastelement #Complete the string with the last char return retval def _consumeTo(self, stackToConsume, endElement ): retval = "" while not retval.endswith(endElement): retval += stackToConsume.pop(0) return retval 

UtilityMill पर regex पलटनेवाला की जाँच करें । (पिरपार्सिंग विकी से इस उदाहरण के आधार पर स्रोत कोड को देखा जा सकता है।)

मैंने ऐसा करने के लिए एक पायथन मॉड्यूल नहीं देखा है, लेकिन मैंने पर्ल में एक (आंशिक) कार्यान्वयन देखा है: Regexp::Genex । मॉड्यूल विवरण से, ऐसा लगता है कि कार्यान्वयन पर्ल के नियमित अभिव्यक्ति इंजन के आंतरिक विवरणों पर निर्भर करता है, इसलिए यह सैद्धांतिक दृष्टि से भी उपयोगी नहीं हो सकता है (मैंने कार्यान्वयन की जांच नहीं की है, बस दस्तावेजों में टिप्पणियां )।

मुझे लगता है कि जो भी आप सामान्य रूप में प्रस्तावित करते हैं वह एक कठिन समस्या है और नोडेटेमेरिनिस्टिक प्रोग्रामिंग तकनीकों के उपयोग की आवश्यकता हो सकती है। एक शुरुआत नियमित अभिव्यक्ति को पार्स करने के लिए और एक पार्स ट्री का निर्माण करना होगा, फिर पेड़ को पार करना और आप जाने पर नमूना स्ट्रिंग तैयार करना होगा। चुनौतीपूर्ण बिट्स संभवतः बैक्रीएरेन्शंस जैसी चीजें और आपके कार्यान्वयन में असीमित छोरों से बचेंगी।

मैंने हाल ही में सी ++ में स्वत: रीगेक्स उत्क्रमण किया है: http://www.benhanson.net/lexertl/blog.html#rev_regex1

पायथन संस्करण पाने के लिए लेक्स्टल के लिए पायथन कोड आउटपुट करने के लिए कोड जनरेटर लिखना काफी आसान होगा। मैं पायथन पर नहीं हूं, लेकिन यदि आप सिंटैक्स के साथ मदद करना चाहते हैं, तो मुझे ऐसा करने के लिए एक फाइल बनाने में खुशी होती है।

Exrex regexes से तार बना सकते हैं

Exrex एक कमांड लाइन टूल और अजगर मॉड्यूल है जो किसी भी रेगुलर एक्सप्रेशन के लिए सभी या या यादृच्छिक मिलान स्ट्रिंग उत्पन्न करता है और अधिक।

उदाहरण:

 >>> exrex.getone('\d{4}-\d{4}-\d{4}-[0-9]{4}') '3096-7886-2834-5671'