अजगर Regex विभाजित विभाजित करता रहता पैटर्न वर्ण यह एक उदाहरण है समझाने के लिए

Question

सबसे आसान तरीका: 'दस्तावेज़/src/स्क्रिप्ट/अस्थायी' कौन सा मैं जानता हूँ कि दो अलग अलग तरीकों विभाजित करने के लिए कैसे:

re.split('/', 'Docs/src/Scripts/temp') -> ['Docs', 'src', 'Scripts', 'temp'] 

re.split('(/)', 'Docs/src/Scripts/temp') -> ['Docs', '/', 'src', '/', 'Scripts', '/', 'temp'] 

मैं इस स्ट्रिंग है

क्या आगे स्लैश द्वारा विभाजित करने का कोई तरीका है, लेकिन शब्दों के स्लैश भाग को रखें? उदाहरण के लिए, मैं ऊपर स्ट्रिंग चाहते हैं तो इस तरह देखने के लिए:

['Docs/', '/src/', '/Scripts/', '/temp'] 

किसी भी मदद की सराहना की होगी!

Answer 1

दिलचस्प सवाल है, मैं कुछ इस तरह कर रही सुझाव है:

>>> 'Docs/src/Scripts/temp'.replace('/', '/\x00/').split('\x00') 
['Docs/', '/src/', '/Scripts/', '/temp'] 

विचार यहाँ पहली बार है कि मूल का एक हिस्सा नहीं होगा विशेष वर्ण द्वारा अलग दो / पात्रों द्वारा सभी / पात्रों को बदलने के लिए है स्ट्रिंग। मैंने एक नल बाइट ('\x00') का उपयोग किया, लेकिन आप इसे किसी और चीज़ में बदल सकते हैं, फिर आखिरकार उस विशेष चरित्र पर विभाजित हो जाते हैं।

रेगेक्स वास्तव में बहुत अच्छा नहीं है क्योंकि आप शून्य-लंबाई वाले मैचों पर विभाजित नहीं हो सकते हैं, और re.findall() ओवरलैपिंग मैचों को नहीं ढूंढता है, इसलिए आपको संभावित रूप से स्ट्रिंग पर कई पास करने की आवश्यकता होगी।

इसके अलावा, re.split('/', s)s.split('/') जैसा ही काम करेगा, लेकिन दूसरा अधिक कुशल है।

Answer 2

मुझे यकीन नहीं है कि ऐसा करने का एक आसान तरीका है। यह सबसे अच्छा है जिसके साथ मैं आ सकता हूं ...

import re 

lSplit = re.split('/', 'Docs/src/Scripts/temp') 
print [lSplit[0]+'/'] + ['/'+x+'/' for x in lSplit][1:-1] + ['/'+lSplit[len(lSplit)-1]] 

एक गड़बड़ की तरह, लेकिन यह वही करता है जो आप चाहते थे।

Answer 3

1) आप एक ही तय चरित्र पर विभाजित करने के लिए नियमित अभिव्यक्ति की जरूरत नहीं है:

>>> 'Docs/src/Scripts/temp'.split('/') 

[ 'डॉक्स', 'src', 'स्क्रिप्ट', 'अस्थायी']

2) इस पद्धति का उपयोग पर विचार करें:

import os.path 

def components(path): 
    start = 0 
    for end, c in enumerate(path): 
     if c == os.path.sep: 
      yield path[start:end+1] 
      start = end 
    yield path[start:] 

यह विभाजन में शामिल होने-बंटवारे, जो, यह बहुत अधिक पठनीय बनाता है मेरी राय में की तरह चतुर चाल पर निर्भर नहीं करता।

Answer 4

आप दोनों पक्षों पर स्लैश होने पर जोर देते हैं नहीं है, तो यह वास्तव में काफी सरल है:

>>> re.findall(r"([^/]*/)", 'Docs/src/Scripts/temp') 
['Docs/', 'src/', 'Scripts/'] 

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

Answer 5

एक समाधान split() बिना लेकिन lookaheads साथ:

>>> s = 'Docs/src/Scripts/temp' 
>>> r = re.compile(r"(?=((?:^|/)[^/]*/?))") 
>>> r.findall(s) 
['Docs/', '/src/', '/Scripts/', '/temp'] 

स्पष्टीकरण:

(?=  # Assert that it's possible to match... 
(  # and capture... 
    (?:^|/) # the start of the string or a slash 
    [^/]* # any number of non-slash characters 
    /?  # and (optionally) an ending slash. 
)   # End of capturing group 
)   # End of lookahead 

के बाद से एक अग्रदर्शी अभिकथन स्ट्रिंग में हर स्थिति में करने की कोशिश की है और किसी भी वर्ण का उपभोग नहीं करता है, ओवरलैपिंग मैचों के साथ इसमें कोई समस्या नहीं है।

Answer 6

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

re.split(r'(/)', 'Docs/src/Scripts/temp') 

अजगर के दस्तावेज़ से

re.split (पैटर्न, स्ट्रिंग, maxsplit = 0, झंडे = 0)

स्प्लिट से स्ट्रिंग पैटर्न के घटनाएं। यदि कैप्चरिंग कोष्ठक पैटर्न, में उपयोग किया जाता है तो पैटर्न में सभी समूहों का पाठ परिणामस्वरूप सूची के भाग के रूप में भी वापस कर दिया जाता है। यदि maxsplit nonzero है, तो अधिकतम maxsplit विभाजन होता है, और शेष स्ट्रिंग को अंतिम सूची के तत्व के रूप में वापस कर दिया जाता है। (असंगतता ध्यान दें:। मूल अजगर 1.5 रिलीज में, maxsplit नजरअंदाज कर दिया गया यह बाद में विज्ञप्ति में तय किया गया है।)