नियमित अभिव्यक्ति, शुरुआती के लिए एक गाइड। भाग २

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

अधिक मेटाचैकर

कुछ मेटाचैकर हैं जिनका हमने अभी तक अध्ययन नहीं किया है। उनमें से ज्यादातर इस खंड में चर्चा की जाएगी।

शेष मेटाचट्रैक्टर्स में से कुछ शून्य-आकार के बयान हैं । वे लाइन के माध्यम से जाने के लिए इंजन को कॉल नहीं करते हैं, वे किसी भी वर्ण को कवर नहीं करते हैं, बस सफलता या विफलता संभव है। उदाहरण के लिए, \b एक कथन है कि वर्तमान स्थिति शब्द की सीमा पर है, जबकि \b वर्ण स्वयं स्थिति नहीं बदलता है। इसका मतलब यह है कि शून्य आकार के बयानों को कभी भी दोहराया नहीं जाना चाहिए, क्योंकि यदि वे दिए गए स्थान में एक बार मेल खाते हैं, तो वे स्पष्ट रूप से इस जगह पर अनंत बार मेल खाते हैं।

|
OR ऑपरेटर से मेल खाती है। यदि ए और बी नियमित अभिव्यक्ति हैं, तो A|B किसी भी स्ट्रिंग से मेल खाएगा जो ए या बी मेटाचैकर से मेल खाता है जब आप एक स्ट्रिंग के कई वर्णों को वैकल्पिक रूप से काम करने के लिए यह एक बहुत कम प्राथमिकता है। क्रो | सर्वो या तो Crow या Servo साथ एक मैच की तलाश करेगा, न कि Cro('w' 'S')ervo ।

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

उदाहरण के लिए, यदि आप केवल उन पंक्तियों को ढूंढना चाहते हैं जो शुरुआत से हैं, तो ^From नियमित अभिव्यक्ति में लिखा गया है:

>>> प्रिंट री । खोज ( '^ से' , 'यहाँ से अनंत काल तक' )
< _sre। 0x ... > पर SRE_Match ऑब्जेक्ट
>>> प्रिंट री । खोज ( '^ से' , 'मेमोरी से पुनरावृत्ति' )
कोई नहीं

$
^ समान, लेकिन पंक्ति के अंत में, जो या तो रेखा के वास्तविक छोर द्वारा निर्धारित किया जाता है, या नई पंक्ति के चरित्र द्वारा।

>>> प्रिंट री । खोज ( '} $' , '{ब्लॉक}' )
< _sre। 0x ... > पर SRE_Match ऑब्जेक्ट
>>> प्रिंट री । खोज ( '} $' , '{ब्लॉक}' )
कोई नहीं
>>> प्रिंट री । खोज ( '} $' , '{ब्लॉक} \ n ' )
< _sre। 0x ... > पर SRE_Match ऑब्जेक्ट

\A
केवल पंक्ति की शुरुआत में मेल खाता है, MULTILINE ^ के समान है, लेकिन MULTILINE ध्वज पर निर्भर नहीं करता है

\Z
केवल पंक्ति के अंत में मेल खाता है, MULTILINE , $ के समान है, लेकिन MULTILINE ध्वज पर निर्भर नहीं करता है

\b
शब्द सीमा। एक शब्द को संख्याओं और / या अक्षरों के पात्रों के अनुक्रम के रूप में परिभाषित किया जाता है, ताकि शब्द की सीमाएं रिक्त स्थान या किसी भी वर्ण का प्रतिनिधित्व करती हैं जो सूचीबद्ध नहीं हैं।

निम्नलिखित उदाहरण केवल शब्द class लिए खोज करता है जब यह एक शब्द होता है। यदि यह किसी अन्य शब्द में समाहित है, तो कोई मेल नहीं है:

>>> पी = री । संकलित करें ( r ' \ b वर्ग \ b ' )
>>> प्रिंट पी। खोज ( 'कोई कक्षा नहीं' )
< _sre। 0x ... > पर SRE_Match ऑब्जेक्ट
>>> प्रिंट पी। खोज ( 'अघोषित एल्गोरिथ्म' )
कोई नहीं
>>> प्रिंट पी। खोज ( 'एक उपवर्ग है' )
कोई नहीं

इस विशेष अनुक्रम का उपयोग करते समय आपको दो सूक्ष्मताएं याद रखनी चाहिए। सबसे पहले, यह पायथन स्ट्रिंग शाब्दिक और नियमित अभिव्यक्ति अनुक्रमों के बीच सबसे खराब टकरावों में से एक है: पायथन स्ट्रिंग शाब्दिकों में, \b बैकस्पेस वर्ण है, ASCII है। 8. यदि आप कच्चे तार का उपयोग नहीं करते हैं, तो पायथन बैकस्पेस को \b बदल देगा, और आपका रेगेक्स इरादा नहीं होगा:

>>> पी = री । संकलन ( ' \ b वर्ग \ b ' )
>>> प्रिंट पी। खोज ( 'कोई कक्षा नहीं' )
कोई नहीं
>>> प्रिंट पी। खोज ( ' \ b ' + 'वर्ग' + ' b ' )
< _sre। 0x ... > पर SRE_Match ऑब्जेक्ट

दूसरे, इस संयोजन का उपयोग वर्ण वर्ग के अंदर नहीं किया जा सकता है, क्योंकि स्ट्रिंग लिटरल्स के साथ संयोजन के लिए संयोजन \b , पायथन बैकस्पेस चरित्र का प्रतिनिधित्व करता है।

\ _ बी
पिछले संयोजन के विपरीत, वर्तमान स्थिति के अनुसार शब्द सीमा पर नहीं।

समूह

अक्सर, अधिक जानकारी की जरूरत है कि क्या आरवी एक मैच पाता है या नहीं। क्वेरी के विभिन्न घटकों के अनुरूप कई उपसमूहों में विभाजित नियमित अभिव्यक्तियों को लिखकर नियमित अभिव्यक्तियों का उपयोग अक्सर लाइनों को काटने के लिए किया जाता है। उदाहरण के लिए, RFC-822 मानक में, हेडर में विभिन्न क्षेत्र होते हैं, जो एक कोलन द्वारा अलग किए जाते हैं:

From: author@example.com
User-Agent: Thunderbird 1.5.0.9 (X11/20061227)
MIME-Version: 1.0
To: editor@example.com

इसे पूरे शीर्षक बार से मेल खाने वाली एक नियमित अभिव्यक्ति लिखकर नियंत्रित किया जा सकता है, और इसमें एक समूह है जो हेडर के नाम से मेल खाता है, और एक अन्य समूह जो हेडर के मूल्य से मेल खाता है।

समूहों को मेटाचेसर्स द्वारा कोष्ठक '(', ')' के रूप में इंगित किया जाता है। '(' और ')' का वही अर्थ है जो गणितीय अभिव्यक्तियों में है; वे समूह में सम्‍मिलित भाव सम्‍मिलित करते हैं, और आप समूह की सामग्री को दोहरा सकते हैं जैसे कि *, +, ? और {m, n} । उदाहरण के लिए, (ab)* शून्य या अधिक ab repetitions से मेल खाएगा।

>>> पी = री । संकलन ( '(अब) *' )
>>> प्रिंट पी। मैच ( 'अबाबाबब' ) । स्पान ( )
( 0 , 10 )

कोष्ठक समूह मिलान पाठ के आरंभ और अंत सूचक पर भी कब्जा करते हैं; यह group(), start(), end() और span() तर्कों को पारित करके प्राप्त किया जा सकता है। समूह 0 से शुरू होते हैं। समूह 0 हमेशा मौजूद होता है, यह पूरी नियमित अभिव्यक्ति ही है, इसलिए MatchObject तरीकों में हमेशा डिफ़ॉल्ट तर्क के रूप में 0 होते हैं:

>>> पी = री । संकलित ( 'ए) बी' )
>>> एम = पी। मैच ( 'अब' )
>>> एम। समूह ( )
'अब'
>>> एम। समूह ( 0 )
'अब'

उपसमूहों को बाएं से दाएं, 1 से आगे की ओर गिना जाता है। समूहों को नेस्टेड किया जा सकता है; अनुलग्नकों की संख्या निर्धारित करने के लिए, हम बस बाएं से दाएं खुलने वाले ब्रैकेट के वर्णों की गणना करते हैं:

>>> पी = री । संकलन ( '(a (b) c) d' )
>>> एम = पी। मैच ( 'abcd' )
>>> एम। समूह ( 0 )
'एबीसीडी'
>>> एम। समूह ( 1 )
'एबीसी'
>>> एम। समूह ( 2 )
'बी'

group() एक ही समय में एक अनुरोध में कई समूह संख्याएँ ले सकता है, और संबंधित समूहों के लिए एक टपल युक्त मान वापस किया जाएगा:

>>> एम। समूह ( 2 , 1 , 2 )
( 'बी' , 'एबीसी' , 'बी' )

groups() विधि 1 के साथ शुरू होने वाले सभी उपसमूहों के लिए पंक्तियों की एक टुकड़ी लौटाती है:

>>> एम। समूह ( )
( 'एबीसी' , 'बी' )

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

उदाहरण के लिए, निम्नलिखित RW एक पंक्ति में एक पंक्ति में नकली शब्दों का पता लगाता है:

>>> पी = री । संकलित करें ( r '( \ b \ w +) \ s + \ 1 ' )
>>> पी। खोज ( 'पेरिस इन द स्प्रिंग' ) । समूह ( )
'द'

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

सामग्री कैप्चर समूह और नामांकित समूह

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

पर्ल 5 ने मानक नियमित अभिव्यक्तियों के लिए कुछ अतिरिक्त फ़ंक्शन जोड़े, और re मॉड्यूल उनमें से अधिकांश का समर्थन करता है। नई विशेषताओं को पेश करने के लिए नए एकल-चरित्र मेटाचैकर्स या नए बैकस्लैश दृश्यों को चुनना मुश्किल होगा ताकि पर्ल नियमित अभिव्यक्ति मानक नियमित अभिव्यक्तियों के साथ भ्रमित हो। यदि आप चुनते हैं, उदाहरण के लिए, & नए मेटाचैकर के रूप में, तो पुराने नियमित भाव इसे एक नियमित चरित्र के रूप में स्वीकार करेंगे और आप इससे बच नहीं सकते।

पर्ल डेवलपर्स द्वारा चुना गया समाधान सिंटैक्स एक्सटेंशन के रूप में (?...) का उपयोग करना था। सामान्य आरवी के मामले में कोष्ठक के बाद प्रश्न चिह्न एक सिंटैक्स त्रुटि है, चूंकि ? दोहराने के लिए कुछ भी नहीं है, इसलिए यह किसी भी संगतता मुद्दों को जन्म नहीं देता है। तुरंत बाद प्रतीक ? दिखाओ कि किस एक्सटेंशन का उपयोग किया गया है, इसलिए (?=foo) यह एक है (पूर्वावलोकन के बारे में सकारात्मक कथन), और (?:foo) यह कुछ और है (सामग्री को कैप्चर किए बिना एक समूह, सबप्रॉपशन foo सहित)।

पायथन ने पर्ल एक्सटेंडेड सिंटैक्स में अपना खुद का एक्सटेंशन जोड़ा है। यदि प्रश्न चिह्न के बाद पहला वर्ण P , तो इसका मतलब है कि पायथन-विशिष्ट एक्सटेंशन का उपयोग किया जा रहा है। वर्तमान में, ऐसे दो एक्सटेंशन हैं: ( ?P<some_name>... ) एक नामित समूह को परिभाषित करता है, और ( ?P=some_name ) इसके लिए एक ?P=some_name रूप में कार्य करता है। यदि पर्ल 5 की भविष्य की विशेषताएं एक अलग सिंटैक्स का उपयोग करके समान विशेषताएं जोड़ती हैं, तो संगतता के लिए पायथन सिंटैक्स को बनाए रखते हुए नए मॉड्यूल को नए सिंटैक्स का समर्थन करने के लिए संशोधित किया जाएगा।

कभी-कभी आपको एक समूह का उपयोग करने के लिए एक नियमित अभिव्यक्ति का हिस्सा इकट्ठा करने की आवश्यकता होती है, लेकिन आपको समूह की सामग्री निकालने में कोई दिलचस्पी नहीं है। आप सामग्री को कैप्चर किए बिना समूह का उपयोग करके ऐसा कर सकते हैं: (?:...) , जहां आप प्रतिस्थापित कर सकते हैं ... किसी भी अन्य नियमित अभिव्यक्ति के साथ:

>>> एम = री । मैच ( "([एबीसी]) +" , "एबीसी" )
>>> एम। समूह ( )
( 'c' )
>>> एम = री । मैच ( "(?: [abc]) +" , "abc" )
>>> एम। समूह ( )
( )

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

एक और महत्वपूर्ण विशेषता को समूहों का नाम दिया गया है: संख्याओं द्वारा उन्हें संदर्भित करने के बजाय, इन समूहों को नाम से संदर्भित किया जा सकता है।

नामित समूहों का सिंटैक्स विशिष्ट पायथन एक्सटेंशनों में से एक है: (?P<some_name>...) । नामांकित समूह बिल्कुल नियमित लोगों की तरह व्यवहार करते हैं, लेकिन इसके अलावा वे किसी प्रकार के नाम से जुड़े होते हैं। MatchObject तरीके जो नियमित समूहों के लिए उपयोग किए गए थे, दोनों संख्याओं को स्वीकार करते हैं जो समूह संख्या को संदर्भित करते हैं, और आवश्यक समूह के नाम वाले तार। अर्थात्, नामित समूह भी संख्याओं को स्वीकार करते हैं, इसलिए आप समूह की जानकारी दो तरीकों से प्राप्त कर सकते हैं:

>>> पी = री । संकलित ( r '(? p <शब्द> \ b \ w + \ b )' )
>>> एम = पी। खोज ( '((((विराम चिह्नों का))' )
>>> एम। समूह ( 'शब्द' )
'बहुत सारे'
>>> एम। समूह ( 1 )
'बहुत सारे'

नामांकित समूह सुविधाजनक हैं कि वे आपको संख्याओं के बजाय आसान-से-याद नामों का उपयोग करने की अनुमति देते हैं। यहाँ imaplib मॉड्यूल से एक नियमित अभिव्यक्ति का एक उदाहरण दिया गया है:

आतंरिकडाय = पुनः । संकलित करें ( r 'आंतरिक' '
r '(? (P <दिन> [123] [0-9]) - (? P <mon> [AZ] [az] [az]) -'
r '(?; P <year> [0-9] [0-9] [0-9] [0-9])'
r '(?; P <hour> [0-9] [0-9]) :(? p <min> [0-9] [0-9]) :(? P <sec> [0-9] [? 0-9]) '
r '(? P <zonen> [- +]) (? P <Zoneh> [0-9] [0-9]) (? P <zonem> [0-9] [0-9])'
आर '' ' )

प्रकार की नियमित अभिव्यक्ति में बैकलिंक सिंटैक्स (...)\1 समूह संख्या को संदर्भित करता है। संख्या के बजाय समूह नामों का उपयोग करना अधिक स्वाभाविक होगा। एक और पायथन विस्तार: (?P=name) इंगित करता है कि नामित समूह की सामग्री को वर्तमान स्थिति में फिर से मेल खाना चाहिए। डुप्लिकेट शब्द खोजने के लिए हमारी पिछली नियमित अभिव्यक्ति, (\b\w+)\s+\1 को भी लिखा जा सकता है (?P<doble_word>\b\w+)\s+(?P=doble_word) :

>>> पी = री । संकलन ( r '(? P <शब्द> \ b \ w +) \ s + ((? P = शब्द)' )
>>> पी। खोज ( 'पेरिस इन द स्प्रिंग' ) । समूह ( )
'द'

अग्रिम चेक

चेक सकारात्मक और नकारात्मक (पूर्वव्यापी) रूप में उपलब्ध हैं, और इस तरह दिखते हैं:

(?=...)
सकारात्मक जाँच। मामले के अनुरूप, जब निहित अभिव्यक्ति, यहाँ के रूप में प्रतिनिधित्व किया ... वर्तमान स्थिति से मेल खाती है। लेकिन, निहित अभिव्यक्ति का परीक्षण किए जाने के बाद, तुलना इंजन आगे नहीं बढ़ता है; टेम्पलेट के शेष भाग की तुलना आगे उस दाईं ओर की जाती है जहाँ अनुमोदन शुरू होता है।

(?!...)
एक नकारात्मक जांच उस मामले से मेल खाती है जब निहित अभिव्यक्ति स्ट्रिंग की वर्तमान स्थिति से मेल नहीं खाती है।

बारीकियों के लिए, उस मामले पर विचार करें जिसमें एक पूर्वावलोकन उपयोगी है। एक फ़ाइल नाम की तुलना करने और इसे भागों में तोड़ने के लिए एक सरल टेम्पलेट पर विचार करें: एक डॉट द्वारा अलग किए गए नाम ही और विस्तार।

ऐसी तुलना के लिए खाका काफी सरल है:

.*[.].*$

ध्यान दें कि प्रतीक . विशेष कोष्ठकों की आवश्यकता होती है, क्योंकि बिंदु स्वयं एक मेटाचैकर है, जैसा कि एक ही अभिव्यक्ति में देखा जा सकता है। अंतिम $ पर भी ध्यान दें; यह सुनिश्चित करने के लिए जोड़ा जाता है कि विस्तार में शेष रेखा शामिल है।

अब, समस्या को थोड़ा व्यापक मानें; क्या होगा यदि आप उन सभी फाइलों के नामों की तुलना करना चाहते हैं जिनका विस्तार bat नहीं है? कुछ गलत प्रयास:

.*[.][^b].*$
पहला प्रयास यह है कि पहले विस्तार चरित्र को b न होने की आवश्यकता के कारण bat को बाहर bat जाए। यह गलत है क्योंकि टेम्पलेट foo.bar को भी बाहर कर foo.bar ।

.*[.]([^b]..|.[^a].|..[^t])$
जब आप आवश्यक वर्णों के एक अलग कार्य द्वारा पहले समाधान को सही करने का निर्णय लेते हैं, तो अभिव्यक्ति और भी अधिक गड़बड़ हो जाएगी: विस्तार का पहला चरित्र ख नहीं होना चाहिए; दूसरा नहीं है; तीसरा नहीं है। यह foo.bar को सक्षम foo.bar और autoexec.bat को अस्वीकार कर देगा, लेकिन इसके लिए तीन-अक्षर के एक्सटेंशन की आवश्यकता होती है और यह दो-वर्ण फ़ाइल नाम एक्सटेंशन के साथ काम नहीं करेगा, उदाहरण के लिए sendmail.cf । फिर हमें इस समस्या को हल करने के लिए फिर से टेम्पलेट को जटिल करना होगा:

.*[.]([^b].?.?|.[^a]?.?|..?[^t]?)$
तीसरे प्रयास में, तीन वर्णों से कम विस्तार की अनुमति देने के लिए दूसरे और तीसरे अक्षर को वैकल्पिक बनाया गया है।

टेम्प्लेट अब वास्तव में तैयार है, इसे पढ़ना और समझना मुश्किल है। इससे भी बदतर, अगर समस्या बदल जाती है और आपको बल्ले और एक्सई एक्सटेंशन दोनों को बाहर करने की आवश्यकता होती है, तो टेम्पलेट और भी जटिल और भ्रमित हो जाएगा।

एक नकारात्मक लीड चेक इन सभी कठिनाइयों को हल करता है:

.*[.](?!bat$).*$
एक नकारात्मक पूर्वावलोकन का मतलब है: यदि bat अभिव्यक्ति दी गई स्थिति से मेल नहीं खाती है, तो बाकी टेम्पलेट की तुलना करें; अगर मैचिंग bat$ , तो पूरा खाका हमें शोभा नहीं देता। अभिव्यक्ति को sample.batch $ साइन की आवश्यकता है ताकि sample.batch जैसी अभिव्यक्ति sample.batch ।

एक और विस्तार को छोड़ना अब आसान है; बस इसे एक ही बयान में एक विकल्प के रूप में जोड़ें। निम्न पैटर्न फ़ाइल नामों को शामिल करता है जो bat या exe विस्तार के साथ समाप्त होते हैं:

.*[.](?!bat$|exe$).*$

पंक्ति परिवर्तन

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

विधि / गुण	लक्ष्य
विभाजन ()	एक सूची में एक पंक्ति को तोड़ो जहां एक मैच है
उप ()	पीबी के साथ मैचों के सभी सबस्ट्रिंग का पता लगाएं और उन्हें एक और स्ट्रिंग के साथ बदलें
सब्न ()	उप () के समान है, लेकिन एक नई लाइन और प्रतिस्थापन की संख्या लौटाता है

लाइन टूट गई

split() टेम्प्लेट विधि स्ट्रिंग को उन हिस्सों में विभाजित करती है जहां पीबी के लिए एक मैच होता है, भागों की सूची लौटाता है। यह स्ट्रिंग विधि split() समान है, लेकिन विभाजन के लिए उपयोग किए जाने वाले सीमांकक में सार्वभौमिकता प्रदान करता है; नियमित split() केवल व्हाट्सएप पात्रों या एक निश्चित स्ट्रिंग द्वारा विभाजित होता है। जैसा कि अपेक्षित था, एक मॉड्यूलर फ़ंक्शन re.split() ।

.plplit (स्ट्रिंग [, मैक्ससिलेट = 0])
नियमित अभिव्यक्ति मैचों द्वारा एक स्ट्रिंग को तोड़ता है। यदि पीबी में कोष्ठक कैप्चरिंग हैं, तो उनकी सामग्री भी प्राप्त सूची के भाग के रूप में वापस आ जाएगी। यदि maxsplit शून्य नहीं है, तो maxsplit विभाजन से अधिक maxsplit , शेष पंक्ति को सूची के अंतिम तत्व के रूप में वापस किया जाएगा।

निम्नलिखित उदाहरण में, विभाजक गैर-अल्फ़ान्यूमेरिक वर्णों का कोई अनुक्रम है।

>>> पी = री । संकलित करें ( r ' \ W +' )
>>> पी। स्प्लिट ( 'यह एक परीक्षण है, विभाजन की छोटी और प्यारी,)।' )
[ 'यह' , 'है' , 'ए' , 'टेस्ट' , 'शॉर्ट' , 'और' , 'स्वीट' , 'ऑफ' , 'स्प्लिट' , '' ]
>>> पी। विभाजन ( 'यह एक परीक्षण है, छोटा और मीठा, विभाजन का) ()। , 3 )
[ 'यह' , 'है' , 'ए' , 'परीक्षण, छोटा और मीठा, विभाजन का ()।' ]

कभी-कभी आप रुचि रखते हैं कि न केवल क्या पाठ सीमांकक के बीच था, बल्कि यह भी जानना आवश्यक है कि किस परिसीमन का उपयोग किया गया था। यदि आरवी में कोष्ठक कैप्चरिंग हैं, तो ये मान सूची के भाग के रूप में भी वापस आ जाते हैं। की तुलना करें:

>>> पी = री । संकलित करें ( r ' \ W +' )
>>> P2 = री । संकलन ( r '( \ W +)' )
>>> पी। विभाजन ( 'यह ... एक परीक्षा है।' )
[ 'यह' , 'है' , 'ए' , 'परीक्षण' , '' ]
>>> P2। विभाजन ( 'यह ... एक परीक्षा है।' )
[ 'यह ’ , '…’ , '’ , ’ ’ ,, a’ , ’’ , ' परीक्षण ’ , ’ ’। , '' ]

पहला तर्क के रूप में re.split() मॉड्यूल फ़ंक्शन PB लेता है, और अन्यथा भी व्यवहार करता है:

>>> पुनः । स्प्लिट ( '[ \ W ] +' , 'शब्द, शब्द, शब्द।' )
[ 'शब्द' , 'शब्द' , 'शब्द' , '' ]
>>> पुनः । स्प्लिट ( '([ \ W ] +)' , 'शब्द, शब्द, शब्द।' )
[ 'शब्द' , ',' , 'शब्द' , ',' , 'शब्द' , '' , '' ]
>>> पुनः । विभाजन ( '[ \ W ] +' , 'शब्द, शब्द, शब्द।' , 1 )
[ 'शब्द' , 'शब्द, शब्द।' ]

खोजें और बदलें

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

.sub (प्रतिस्थापन, स्ट्रिंग [, गिनती = 0])
प्रतिस्थापन के परिणामस्वरूप स्ट्रिंग लौटाता है। यदि पैटर्न नहीं मिला है, तो स्ट्रिंग अपरिवर्तित लौटा दी जाती है।

अतिरिक्त तर्क संख्या बदली जाने वाले मैचों की अधिकतम संख्या है।

sub() विधि का उपयोग करने का एक सरल उदाहरण। रंग नामों को शब्द colour बदल दिया जाता है:

>>> पी = री । संकलन ( '(नीला | सफेद | लाल)' )
>>> पी। उप ( 'रंग' , 'नीले मोजे और लाल जूते' )
'रंग मोजे और रंग के जूते'
>>> पी। उप ( 'रंग' , 'नीले मोजे और लाल जूते' , गिनती = 1 )
'रंग मोजे और लाल जूते'

सबन () विधि एक ही करती है, लेकिन एक नई लाइन और बदले गए प्रतिस्थापनों की संख्या वाला एक टपल लौटाती है:

>>> पी = री । संकलन ( '(नीला | सफेद | लाल)' )
>>> पी। सबन ( 'रंग' , 'नीले मोजे और लाल जूते' )
( 'रंगीन मोजे और रंग के जूते' , 2 )
>>> पी। सबन ( 'रंग' , 'कोई रंग नहीं' )
( 'कोई रंग नहीं' , 0 )

खाली मैचों को केवल तब बदला जाता है जब वे पिछले मैच से सटे नहीं होते हैं:

>>> पी = री । संकलन ( 'x *' )
>>> पी। उप ( '-' , 'एबक्सड' )
'-Abd-'

यदि स्ट्रिंग एक विकल्प है, तो भागने वाले वर्णों का समर्थन किया जाता है। तो, \n एक एकल न्यूलाइन वर्ण है, \r एक गाड़ी वापसी है, और इसी तरह। Backlinks, जैसे कि \6 को प्रतिस्थापित करके प्रतिस्थापित किया जाता है जो PB में संबंधित समूह से मेल खाता है। यह आपको स्ट्रिंग को बदलने के परिणाम में मूल पाठ के कुछ हिस्सों को शामिल करने की अनुमति देता है।

उदाहरण पंक्ति के भाग में शब्द section से मेल खाता है, जो कि घुंघराले ब्रेसेस {, } में भाग से पहले है, और subsection साथ section को प्रतिस्थापित करता है:

>>> पी = री । संकलन ( 'अनुभाग {(^ ^} * *)}' , फिर से । VERBOSE )
>>> पी। उप ( r 'उपधारा { \ 1 }' , 'खंड {पहला} खंड {दूसरा}' )
'उपधारा {प्रथम} उपधारा {दूसरा}'

नामित समूहों को संदर्भित करना भी संभव है। ऐसा करने के लिए, अनुक्रम \g<...> , जहां समूह की संख्या या नाम का उपयोग किया जा सकता है ... \g<2> \2 के समतुल्य है, लेकिन यह \g<2>0 जैसे प्रतिस्थापन में अस्पष्ट नहीं है। (+ \20 को समूह 20 के संदर्भ के रूप में समझा जाएगा, न कि शाब्दिक '0' के बाद दूसरे समूह के रूप में)। निम्नलिखित ऑपरेशन समान हैं, लेकिन तीन अलग-अलग तरीकों का उपयोग करें:

>>> पी = री । संकलित करें ( 'अनुभाग {(? P <name> [^}] *)}' , पुनः । VERBOSE )
>>> पी। उप ( आर 'उपधारा { \ 1 }' , 'खंड {पहला}' )
'उपधारा {प्रथम}'
>>> पी। उप ( r 'उपधारा { \ g <1>}' , 'खंड {पहला}' )
'उपधारा {प्रथम}'
>>> पी। उप ( r 'उपधारा { \ g <नाम>}' , 'खंड {पहला}' )
'उपधारा {प्रथम}'

वैकल्पिक भी एक सुविधा हो सकती है जो आपको अधिक नियंत्रण प्रदान करती है। यदि हां, तो फ़ंक्शन को गैर-अतिव्यापी पैटर्न के प्रत्येक मामले के लिए कहा जाता है। हर बार फ़ंक्शन को कॉल करने के बाद, MatchObject को एक तर्क के रूप में पारित किया जाता है।

निम्न उदाहरण में, प्रतिस्थापित फ़ंक्शन दशमलव संख्याओं को हेक्साडेसिमल में परिवर्तित करता है:

>>> हेक्सरेप ( मैच ) :
... "दशमलव संख्या के लिए हेक्स स्ट्रिंग लौटें"
... मान = इंट ( मिलान। समूह ) ( )
... वापसी हेक्स ( मूल्य )
...
>>> पी = री । संकलित करें ( r ' \ d +' )
>>> पी। उप ( हेक्सरेप्ल, 'मुद्रण के लिए 65490 पर कॉल करें, उपयोगकर्ता कोड के लिए 49152।' )
'मुद्रण के लिए 0xffd2 पर कॉल करें, उपयोगकर्ता कोड के लिए 0xc000।'

आम समस्याएं

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

स्ट्रिंग विधियों का उपयोग करना

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

कल्पना करें कि आपको एक निश्चित पंक्ति को दूसरे के साथ बदलने की आवश्यकता है, उदाहरण के लिए, एक शब्द wordको एक शब्द के साथ बदलें deed। यहां, निश्चित रूप से, फ़ंक्शन उपयुक्त है re.sub(), लेकिन स्ट्रिंग विधि पर विचार करें replace()। ध्यान दें कि replace()यह भी बदल दिया जाएगा wordशब्दों के भीतर, बदल रहा है swordfishकरने के लिएsdeedfish, लेकिन एक सरल नियमित अभिव्यक्ति वही करेगी। (शब्दों के हिस्सों पर प्रतिस्थापन करने से बचने के लिए, टेम्पलेट में होना चाहिए \bword\b)।

एक अन्य सामान्य कार्य किसी एकल वर्ण को स्ट्रिंग से निकालना या किसी अन्य वर्ण से प्रतिस्थापित करना है। आप इसे कुछ इस तरह बना सकते हैं re.sub('\n', ' ', S), लेकिन अनुवाद () विधि दोनों कार्यों को संभाल लेगी और इसे किसी भी नियमित अभिव्यक्ति की तुलना में तेज़ बना देगी।

संक्षेप में, एक मॉड्यूल का उपयोग करने से पहले re, देखें कि क्या समस्या को तेज और सरल स्ट्रिंग विधियों से हल किया जा सकता है।

मिलान () खोज की तुलना में ()

फ़ंक्शन match()लाइन की शुरुआत में एक मैच की खोज करता है , जबकि यह search()पूरी लाइन में मैच की खोज करता है। इस अंतर को ध्यान में रखना महत्वपूर्ण है:

>>> print re . match ( 'super' , 'superstition' ) . span ( )
( 0 , 5 )
>>> print re . match ( 'super' , 'insuperable' )
None
>>> print re . search ( 'super' , 'superstition' ) . span ( )
( 0 , 5 )
>>> print re . search ( 'super' , 'insuperable' ) . span ( )
( 2 , 7 )

आपको हमेशा re.match()अपनी नियमित अभिव्यक्ति के सामने जोड़ने का उपयोग करने के लिए लुभाया जा सकता है .*। इस प्रलोभन का विरोध करें, और इसके बजाय इसका उपयोग करें re.search()। मिलान प्रक्रिया को गति देने के लिए रेगेक्स कंपाइलर आरवी विश्लेषण का एक सा करता है। एक प्रकार का विश्लेषण यह निर्धारित करने के लिए है कि पहला मैच चरित्र क्या होना चाहिए, उदाहरण के लिए, एक पैटर्न के साथ शुरू होने वाले मैच के साथ शुरू Crowहोना चाहिए 'C'। यह विश्लेषण इस तथ्य की ओर जाता है कि इंजन प्रारंभिक चरित्र की तलाश में लाइन के माध्यम से जल्दी से चलता है, और केवल एक पूर्ण तुलना शुरू करता है यदि चरित्र 'सी' पाया जाता है।

इसके अलावा.*इस अनुकूलन को पंक्ति के अंत तक स्कैन करने की आवश्यकता होती है और फिर नियमित अभिव्यक्ति के शेष की तुलना करने के लिए वापस लौटा दिया जाता है। इसके बजाय उपयोग करें re.search()।

लालची बनाम गैर-लालची

जब एक PB में दोहराया जाता है, जैसे कि a*, परिणामी क्रिया जितना संभव हो उतना पैटर्न खाती है। यह अक्सर उन लोगों के लिए जलता है जो सममित पहचानकर्ताओं की एक जोड़ी को खोजना चाहते हैं, जैसे कि कोण कोष्ठक <>, HTML टैग्स के आसपास। HTML टैग मैपिंग टेम्प्लेट का भोली दृष्टिकोण "लालची" प्रकृति के कारण काम नहीं करेगा .*:

>>> s = '<html><head><title>Title</title>'
>>> len ( s )
32
>>> print re . match ( '<.*>' , s ) . span ( )
( 0 , 32 )
>>> print re . match ( '<.*>' , s ) . group ( )
< html >< head >< title > Title < /title >

PB '<'पहले टैग - html में मेल खाता है, और .*बाकी की लाइन को हटा देता है। नतीजतन, तुलना उद्घाटन '<'टैग कंकाल htmlसे >'समापन टैग के समापन कोष्ठक तक फैली हुई है /title, जो निश्चित रूप से, वह नहीं है जो हम चाहते थे।

इस मामले में, समाधान गैर-लालची पहचानकर्ताओं का उपयोग करना है *?, +?, ??या {m,n}?जो संभव के रूप में छोटे पाठ से मेल खाते हैं। ऊपर दिए गए उदाहरण में, पहले अक्षर '>' का चयन '<' के बाद किया जाएगा, और केवल अगर यह काम नहीं करता है, तो इंजन अगली स्थिति में '>' अक्षर खोजने की कोशिश करता रहेगा, यह इस बात पर निर्भर करता है कि टैग नाम कितना लंबा है। यह वांछित परिणाम देता है:

>>> प्रिंट री । मैच ( '<। *?>' , एस ) । समूह ( )
< html >

(ध्यान दें कि नियमित अभिव्यक्ति का उपयोग करके HTML या XML को पार्स करना दर्दनाक है। जल्दबाजी में बनाया गया टेम्प्लेट कुछ चीजें कर सकता है, लेकिन जब आप पेज कोड बदलते हैं तो यह क्रैश हो जाता है। और अच्छी तरह से डिज़ाइन किया गया टेम्प्लेट संशोधित करने का प्रयास करने के लिए बहुत जटिल हो सकता है । ऐसे कार्यों के लिए, HTML या XML पार्सर मॉड्यूल का उपयोग करना बेहतर है।)

Re.VERBOSE का उपयोग करना

अब तक, आपने शायद देखा है कि पीबी का एक बहुत ही कॉम्पैक्ट रिकॉर्ड है, लेकिन कभी-कभी वे बहुत पठनीय नहीं होते हैं। मध्यम जटिलता के आरडब्ल्यू लंबे समय तक स्लैश, कोष्ठक, मेटाचैकर्स के अनुक्रम हो सकते हैं, जिससे उन्हें पढ़ना और समझना मुश्किल हो जाता है।

ऐसे PBs के लिए, एक नियमित अभिव्यक्ति का संकलन करते समय VERBOSE ध्वज को निर्दिष्ट करना उपयोगी हो सकता है क्योंकि यह आपको एक स्पष्ट तरीके से नियमित अभिव्यक्ति को प्रारूपित करने की अनुमति देता है।

VERBOSE ध्वज में कई विशेषताएं हैं। PB में रिक्त स्थान जो वर्ण वर्ग के अंदर नहीं हैं, को अनदेखा किया जाता है। इसका अर्थ है कि इस तरह के भाव dog | catकम पठनीय व्हाट्सएप के बराबर हैं dog|cat, लेकिन [ab] अभी भी वर्णों से मेल खाएंगे'a', 'b'या एक स्थान। इसके अलावा, आप पीबी के अंदर टिप्पणियां भी डाल सकते हैं जो चरित्र #से अगली पंक्ति तक होती हैं। ट्रिपल उद्धरण का उपयोग करते समय स्वरूपण अधिक सटीक होगा:

pat = पुनः । संकलित करें ( r ""
\ " s * # अग्रणी व्हाट्सएप छोड़ें
(? पी <हैडर> [^: +) # हैडर नाम
\ _ *: # व्हॉट्सएप, और एक कोलोन
(? पी <मूल्य>। *?) # # मूल्य के हेडर के - * करने के लिए प्रयुक्त
निम्नलिखित पिछली श्वेत रिक्ति को खोने #
\ रों को * $ # पिछली श्वेत रिक्ति के अंत लाइन
"" " , फिर से । वर्बोज़ )

यह पढ़ने में बहुत आसान है:

pat = पुनः । संकलन ( आर " \ s * (पी <header> [^:]? +) \ s ?।? * :( पी <मूल्य की> *) \ s * $" )

निष्कर्ष में

रे
हैब्रलॉग रेगुलर एक्सप्रेशंस मॉड्यूल डॉक्यूमेंटेशन
रेगेक्सप एडिटर