नियमित अभिव्यक्ति: दो स्लेश के बीच मिलान स्ट्रिंग यदि स्ट्रिंग में स्लेश से बच निकला है

Question

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

परीक्षण कार्यक्रम:

#!/usr/bin/python 
import re 
teststrings=[ 
    """/hello world/""", 
    """/string with foreslash here \/ and here\//""", 
    """/this one ends with backlash\\\\/"""] 

patt="""^\/(?P<pattern>.*)(?<!\\\\)\/$""" 

for t in teststrings: 
    m=re.match(patt,t) 
    if m!=None: 
     print t,' => MATCH' 
    else: 
     print t," => NO MATCH" 

उत्पादन:

/hello world/ => MATCH 
/string with foreslash here \/ and here\// => MATCH 
/this one ends with backlash\\/ => NO MATCH 

कैसे करने के लिए केवल वर्तमान स्थिति में एक भी प्रतिक्रिया नहीं है, तो हिट मैं दावे को संशोधित करेगा, लेकिन नहीं दो?

या रेगेक्स निकालने का कोई बेहतर तरीका है? (ध्यान दें, वास्तविक फ़ाइल में मैं पार्स करने के लिए लाइनों सिर्फ regex से अधिक शामिल करने की कोशिश मैं बस प्रत्येक पंक्ति में पहली और आखिरी स्लेश के लिए खोज नहीं कर सकते हैं और सब कुछ inbetween मिलता है।।)

Answer 1

इस प्रयास करें:

pattern = re.compile(r"^/(?:\\.|[^/\\])*/") 

स्पष्टीकरण:

^  # Start of string 
/  # Match/
(?:  # Match either... 
\\. # an escaped character 
|  # or 
[^/\\] # any character except slash/backslash 
)*  # any number of times. 
/  # Match/

अपने "वास्तविक दुनिया" आवेदन के लिए (पहले "स्लेश-सीमांकित स्ट्रिंग" की खोज, भाग निकले स्लैश अनदेखी), मैं प्रयोग करेंगे

+०१२३५१६४१०६१

pattern = re.compile(r"^(?:\\.|[^/\\])*/((?:\\.|[^/\\])*)/") 

यह आप निम्नलिखित हो जाता है:

>>> pattern.match("foo /bar/ baz").group(1) 
'bar' 
>>> pattern.match("foo /bar\/bam/ baz").group(1) 
'bar\\/bam' 
>>> pattern.match("foo /bar/bam/ baz").group(1) 
'bar' 
>>> pattern.match("foo\/oof /bar\/bam/ baz").group(1) 
'bar\\/bam'