Python Language
नियमित अभिव्यक्तियाँ (रेगेक्स)

परिचय

वाक्य - विन्यास

• प्रत्यक्ष नियमित अभिव्यक्तियाँ

• re.match (पैटर्न, स्ट्रिंग, ध्वज = 0) # आउट: स्ट्रिंग या कोई नहीं की शुरुआत में मैच पैटर्न

• re.search (पैटर्न, स्ट्रिंग, ध्वज = 0) # आउट: स्ट्रिंग या कोई नहीं अंदर मैच पैटर्न

• re.findall (पैटर्न, स्ट्रिंग, ध्वज = 0) # आउट: स्ट्रिंग या [] में पैटर्न के सभी मैचों की सूची

• re.finditer (प्रतिमान, स्ट्रिंग, ध्वज = 0) # आउट: re.findall जैसा ही, लेकिन पुनरावृत्त वस्तु

• re.sub (पैटर्न, प्रतिस्थापन, स्ट्रिंग, ध्वज = 0) # आउट: प्रतिस्थापन के साथ स्ट्रिंग (स्ट्रिंग या फ़ंक्शन) पैटर्न के स्थान पर

• Precompiled नियमित अभिव्यक्तियाँ

• precompiled_pattern = re.compile (पैटर्न, ध्वज = 0)

• precompiled_pattern.match (स्ट्रिंग) # आउट: स्ट्रिंग या कोई नहीं की शुरुआत में मैच

• precompiled_pattern.search (स्ट्रिंग) # आउट: स्ट्रिंग या कोई भी कहीं भी मेल खाता है

• precompiled_pattern.findall (स्ट्रिंग) # आउट: सभी मेल खाने वाले पदार्थों की सूची

• precompiled_pattern.sub (स्ट्रिंग / पैटर्न / फ़ंक्शन, स्ट्रिंग) # आउट: प्रतिस्थापित स्ट्रिंग

एक स्ट्रिंग की शुरुआत का मिलान

re.match() का पहला तर्क re.match() नियमित अभिव्यक्ति है, दूसरा मिलान करने के लिए स्ट्रिंग है:

import re

pattern = r"123"
string = "123zzb"

re.match(pattern, string)
# Out: <_sre.SRE_Match object; span=(0, 3), match='123'>

match = re.match(pattern, string)

match.group()
# Out: '123'

आप देख सकते हैं कि पैटर्न चर r साथ उपसर्ग एक स्ट्रिंग है, जो इंगित करता है कि स्ट्रिंग एक कच्चा स्ट्रिंग शाब्दिक है ।

एक कच्चे स्ट्रिंग शाब्दिक में एक स्ट्रिंग शाब्दिक की तुलना में थोड़ा अलग वाक्यविन्यास होता है, अर्थात् एक कच्चे स्ट्रिंग शाब्दिक में एक बैकस्लैश \ _ "बस एक बैकस्लैश" का मतलब है और "एस्केप" जैसे न्यूलाइड्स ( \n ) से बचने के लिए बैकलैश को दोगुना करने की कोई आवश्यकता नहीं है। , टैब ( \t ), बैकस्पेस ( \ ), फॉर्म-फीड ( \r ), और इसी तरह। सामान्य स्ट्रिंग शाब्दिकों में, प्रत्येक बैकस्लैश को दोगुना किया जाना चाहिए ताकि बचने के क्रम के प्रारंभ के रूप में लिया जा सके।

इसलिए, r"\n" 2 वर्णों का एक स्ट्रिंग है: \ और n । Regex पैटर्न भी बैकस्लैश, जैसे \d किसी भी अंकों चरित्र को दर्शाता है। हम कच्चे तार ( r"\d" ) का उपयोग करके अपने तार ( "\\d" ) से बचने के लिए बच सकते हैं।

उदाहरण के लिए:

string = "\\t123zzb" # here the backslash is escaped, so there's no tab, just '\' and 't'
pattern = "\\t123"   # this will match \t (escaping the backslash) followed by 123
re.match(pattern, string).group()   # no match
re.match(pattern, "\t123zzb").group()  # matches '\t123'

pattern = r"\\t123"  
re.match(pattern, string).group()   # matches '\\t123'

मिलान केवल स्ट्रिंग की शुरुआत से किया जाता है। यदि आप कहीं भी मिलान करना चाहते हैं तो इसके बजाय re.search उपयोग करें:

match = re.match(r"(123)", "a123zzb")

match is None
# Out: True

match = re.search(r"(123)", "a123zzb")

match.group()
# Out: '123'

खोज कर

pattern = r"(your base)"
sentence = "All your base are belong to us."

match = re.search(pattern, sentence)
match.group(1)
# Out: 'your base'

match = re.search(r"(belong.*)", sentence)
match.group(1)
# Out: 'belong to us.'

खोज स्ट्रिंग के विपरीत में किया कहीं भी है re.match । आप re.findall भी उपयोग कर सकते हैं।

आप स्ट्रिंग की शुरुआत में भी खोज कर सकते हैं (उपयोग ^ ),

match = re.search(r"^123", "123zzb")
match.group(0)
# Out: '123'

match = re.search(r"^123", "a123zzb")
match is None
# Out: True

स्ट्रिंग के अंत में ( $ उपयोग करें),

match = re.search(r"123$", "zzb123")
match.group(0)
# Out: '123'

match = re.search(r"123$", "123zzb")
match is None
# Out: True

या दोनों ( ^ और $ दोनों का उपयोग करें):

match = re.search(r"^123$", "123")
match.group(0)
# Out: '123'

समूहन

कोष्ठक के साथ समूहन किया जाता है। कॉलिंग group() रिटर्निंग कोष्ठककृत उपसमूहों से बनी स्ट्रिंग लौटाता है।

match.group() # Group without argument returns the entire match found
# Out: '123'
match.group(0) # Specifying 0 gives the same result as specifying no argument
# Out: '123'

किसी विशेष उपसमूह को लाने के लिए group() को तर्क भी प्रदान किए जा सकते हैं।

डॉक्स से :

यदि कोई एकल तर्क है, तो परिणाम एकल स्ट्रिंग है; यदि कई तर्क हैं, तो परिणाम प्रति तर्क एक आइटम के साथ एक टपल है।

दूसरी ओर groups() कॉलिंग, उपसमूह युक्त tuples की एक सूची देता है।

sentence = "This is a phone number 672-123-456-9910"
pattern = r".*(phone).*?([\d-]+)"

match = re.match(pattern, sentence)

match.groups()   # The entire match as a list of tuples of the paranthesized subgroups
# Out: ('phone', '672-123-456-9910')

m.group()        # The entire match as a string
# Out: 'This is a phone number 672-123-456-9910'

m.group(0)       # The entire match as a string
# Out: 'This is a phone number 672-123-456-9910'

m.group(1)       # The first parenthesized subgroup.
# Out: 'phone'

m.group(2)       # The second parenthesized subgroup.
# Out: '672-123-456-9910'

m.group(1, 2)    # Multiple arguments give us a tuple.
# Out: ('phone', '672-123-456-9910')

नामित समूह

match = re.search(r'My name is (?P<name>[A-Za-z ]+)', 'My name is John Smith')
match.group('name')
# Out: 'John Smith'

match.group(1)
# Out: 'John Smith'

एक कैप्चर समूह बनाता है जिसे नाम के साथ-साथ सूचकांक द्वारा संदर्भित किया जा सकता है।

गैर-कब्जा समूह

(?:) का उपयोग करके एक समूह बनाता है, लेकिन समूह कैप्चर नहीं किया जाता है। इसका मतलब है कि आप इसे एक समूह के रूप में उपयोग कर सकते हैं, लेकिन यह आपके "समूह स्थान" को प्रदूषित नहीं करेगा।

re.match(r'(\d+)(\+(\d+))?', '11+22').groups()
# Out: ('11', '+22', '22')

re.match(r'(\d+)(?:\+(\d+))?', '11+22').groups()
# Out: ('11', '22')

यह उदाहरण 11+22 या 11 मेल खाता है, लेकिन 11+ नहीं। यह तब से है + संकेत और दूसरा शब्द समूहीकृत है। दूसरी ओर, + चिह्न कैप्चर नहीं किया गया है।

विशेष वर्ण से बचना

विशेष वर्ण (जैसे चरित्र वर्ग कोष्ठक [ और ] नीचे) का शाब्दिक रूप से मिलान नहीं किया गया है:

match = re.search(r'[b]', 'a[b]c')
match.group()
# Out: 'b'

विशेष पात्रों से बचकर, उनका शाब्दिक रूप से मिलान किया जा सकता है:

match = re.search(r'\[b\]', 'a[b]c')
match.group()
# Out: '[b]'

re.escape() फ़ंक्शन का उपयोग आपके लिए ऐसा करने के लिए किया जा सकता है:

re.escape('a[b]c')
# Out: 'a\\[b\\]c'
match = re.search(re.escape('a[b]c'), 'a[b]c')
match.group()
# Out: 'a[b]c'

re.escape() फ़ंक्शन सभी विशेष वर्णों से बच जाता है, इसलिए यदि आप उपयोगकर्ता इनपुट के आधार पर एक नियमित अभिव्यक्ति की रचना कर रहे हैं तो यह उपयोगी है:

username = 'A.C.'  # suppose this came from the user
re.findall(r'Hi {}!'.format(username), 'Hi A.C.! Hi ABCD!')
# Out: ['Hi A.C.!', 'Hi ABCD!']
re.findall(r'Hi {}!'.format(re.escape(username)), 'Hi A.C.! Hi ABCD!')
# Out: ['Hi A.C.!']

की जगह

re.sub का उपयोग करके स्ट्रिंग्स पर प्रतिस्थापन किया जा सकता है।

तारों को बदलना

re.sub(r"t[0-9][0-9]", "foo", "my name t13 is t44 what t99 ever t44")
# Out: 'my name foo is foo what foo ever foo'

समूह संदर्भ का उपयोग करना

निम्न प्रकार के समूहों के साथ प्रतिस्थापन किया जा सकता है:

re.sub(r"t([0-9])([0-9])", r"t\2\1", "t13 t19 t81 t25")
# Out: 't31 t91 t18 t52'

हालाँकि, यदि आप '10' जैसी एक ग्रुप आईडी बनाते हैं, तो यह काम नहीं करता है : \10 को 'आईडी नंबर 1 के बाद 0' के रूप में पढ़ा जाता है। इसलिए आपको अधिक विशिष्ट बनना होगा और \g<i> संकेतन का उपयोग करना होगा:

re.sub(r"t([0-9])([0-9])", r"t\g<2>\g<1>", "t13 t19 t81 t25")
# Out: 't31 t91 t18 t52'

एक प्रतिस्थापन समारोह का उपयोग करना

items = ["zero", "one", "two"]
re.sub(r"a\[([0-3])\]", lambda match: items[int(match.group(1))], "Items: a[0], a[1], something, a[2]")
# Out: 'Items: zero, one, something, two'

सभी गैर-अतिव्यापी मिलान खोजें

re.findall(r"[0-9]{2,3}", "some 1 text 12 is 945 here 4445588899")
# Out: ['12', '945', '444', '558', '889']

ध्यान दें कि r से पहले "[0-9]{2,3}" अजगर बताता स्ट्रिंग व्याख्या करने के लिए के रूप में है, एक "कच्चे" स्ट्रिंग के रूप में।

तुम भी इस्तेमाल कर सकते हैं re.finditer() जो के रूप में एक ही तरह से काम करता है re.findall() लेकिन वाले पुनरावर्तक रिटर्न SRE_Match स्ट्रिंग की एक सूची के बजाय वस्तुओं:

results = re.finditer(r"([0-9]{2,3})", "some 1 text 12 is 945 here 4445588899")
print(results)
# Out: <callable-iterator object at 0x105245890>
for result in results:
     print(result.group(0))
''' Out:
12
945
444
558
889
'''

पूर्वनिर्धारित पैटर्न

import re

precompiled_pattern = re.compile(r"(\d+)")
matches = precompiled_pattern.search("The answer is 41!")
matches.group(1)
# Out: 41

matches = precompiled_pattern.search("Or was it 42?")
matches.group(1)
# Out: 42

एक पैटर्न को संकलित करना एक कार्यक्रम में बाद में इसका पुन: उपयोग करने की अनुमति देता है। हालाँकि, ध्यान दें कि पायथन ने हाल ही में उपयोग किए गए एक्सप्रेशंस ( डॉक्स , एसओ उत्तर ) को कैश किया है, इसलिए "ऐसे प्रोग्राम जो एक समय में केवल कुछ नियमित एक्सप्रेशन का उपयोग करते हैं, उन्हें रेग्युलर एक्सप्रेशंस कंपाइल करने की चिंता नहीं करनी चाहिए" ।

import re

precompiled_pattern = re.compile(r"(.*\d+)")
matches = precompiled_pattern.match("The answer is 41!")
print(matches.group(1))
# Out: The answer is 41

matches = precompiled_pattern.match("Or was it 42?")
print(matches.group(1))
# Out: Or was it 42

इसका उपयोग re.match () के साथ किया जा सकता है।

अनुमत पात्रों के लिए जाँच की जा रही है

यदि आप यह जांचना चाहते हैं कि एक स्ट्रिंग में केवल कुछ निश्चित वर्ण होते हैं, तो इस स्थिति में az, AZ और 0-9, आप ऐसा कर सकते हैं,

import re

def is_allowed(string):
    characherRegex = re.compile(r'[^a-zA-Z0-9.]')
    string = characherRegex.search(string)
    return not bool(string)
    
print (is_allowed("abyzABYZ0099")) 
# Out: 'True'

print (is_allowed("#*@#$%^")) 
# Out: 'False'

आप उदाहरण के लिए अपरकेस अक्षरों को अस्वीकार करने के लिए [^a-zA-Z0-9.] से [^a-z0-9.] तक अभिव्यक्ति लाइन को भी अनुकूलित कर सकते हैं।

आंशिक क्रेडिट: http://stackoverflow.com/a/1325265/2697955

नियमित अभिव्यक्ति का उपयोग करके एक स्ट्रिंग को विभाजित करना

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

import re
data = re.split(r'\s+', 'James 94 Samantha 417 Scarlett 74')
print( data )
# Output: ['James', '94', 'Samantha', '417', 'Scarlett', '74']

झंडे

कुछ विशेष मामलों के लिए हमें नियमित अभिव्यक्ति के व्यवहार को बदलने की आवश्यकता है, यह झंडे का उपयोग करके किया जाता है। झंडे दो तरीकों से सेट किए जा सकते हैं, flags कीवर्ड के माध्यम से या सीधे अभिव्यक्ति में।

झंडे कीवर्ड

re.search लिए एक उदाहरण के नीचे लेकिन यह re मॉड्यूल में अधिकांश कार्यों के लिए काम करता है।

m = re.search("b", "ABC")  
m is None
# Out: True

m = re.search("b", "ABC", flags=re.IGNORECASE)
m.group()
# Out: 'B'

m = re.search("a.b", "A\nBC", flags=re.IGNORECASE) 
m is None
# Out: True

m = re.search("a.b", "A\nBC", flags=re.IGNORECASE|re.DOTALL) 
m.group()
# Out: 'A\nB'

आम झंडे

सभी उपलब्ध झंडों की पूरी सूची के लिए डॉक्स की जाँच करें

इनलाइन झंडे

डॉक्स से :

(?iLmsux) (सेट 'i', 'L', 'm', 's', 'u', 'x' से एक या अधिक अक्षर)।

समूह खाली स्ट्रिंग से मेल खाता है; पत्र संबंधित झंडे सेट करते हैं: re.I (मामले की अनदेखी करें), re.L (स्थानीय निर्भर), re.M (बहु-पंक्ति), re.S (डॉट सभी से मेल खाता है), re.U (यूनिकोड निर्भर), और re.X (क्रिया), संपूर्ण नियमित अभिव्यक्ति के लिए। यह तब उपयोगी होता है, जब आप फ़्लैग तर्क को re.compile () फ़ंक्शन में भेजने के बजाय, नियमित अभिव्यक्ति के हिस्से के रूप में शामिल करना चाहते हैं।

ध्यान दें कि (? X) ध्वज बदलता है कि अभिव्यक्ति कैसे पार्स की जाती है। इसका उपयोग पहले अभिव्यक्ति स्ट्रिंग में किया जाना चाहिए, या एक या अधिक व्हाट्सएप पात्रों के बाद। यदि ध्वज से पहले गैर-व्हाट्सएप वर्ण हैं, तो परिणाम अपरिभाषित हैं।

`Re.finditer` का उपयोग करके मैचों पर फेरबदल करना

आप एक स्ट्रिंग में सभी मैचों पर पुनरावृति करने के लिए re.finditer का उपयोग कर सकते हैं। यह आपको देता है ( re.findall अतिरिक्त जानकारी की तुलना में, जैसे कि स्ट्रिंग में मिलान स्थान के बारे में जानकारी (अनुक्रमित):

import re
text = 'You can try to find an ant in this string'
pattern = 'an?\w' # find 'an' either with or without a following word character

for match in re.finditer(pattern, text):
    # Start index of match (integer)
    sStart = match.start()

    # Final index of match (integer)
    sEnd = match.end()

    # Complete match (string)
    sGroup = match.group()

    # Print match
    print('Match "{}" found at: [{},{}]'.format(sGroup, sStart,sEnd))

परिणाम:

Match "an" found at: [5,7]
Match "an" found at: [20,22]
Match "ant" found at: [23,26]

केवल विशिष्ट स्थानों में अभिव्यक्ति का मिलान करें

अक्सर आप केवल विशिष्ट स्थानों में एक अभिव्यक्ति से मेल खाना चाहते हैं (उन्हें दूसरों में अछूता छोड़कर, वह है)। निम्नलिखित वाक्य पर विचार करें:

An apple a day keeps the doctor away (I eat an apple everyday).

यहां "ऐप्पल" दो बार होता है जिसे तथाकथित बैकट्रैकिंग नियंत्रण क्रियाओं के साथ हल किया जा सकता है जो नए regex मॉड्यूल द्वारा समर्थित हैं। विचार यह है:

forget_this | or this | and this as well | (but keep this)

हमारे सेब उदाहरण के साथ, यह होगा:

import regex as re
string = "An apple a day keeps the doctor away (I eat an apple everyday)."
rx = re.compile(r'''
    \([^()]*\) (*SKIP)(*FAIL)  # match anything in parentheses and "throw it away"
    |                          # or
    apple                      # match an apple
    ''', re.VERBOSE)
apples = rx.findall(string)
print(apples)
# only one

यह "सेब" से तभी मेल खाता है जब इसे कोष्ठकों के बाहर पाया जा सकता है।

• बाएं से दाएं की ओर देखते हुए , रेगेक्स इंजन बाईं ओर सब कुछ खाता है, (*SKIP) "हमेशा-सच-जोर" के रूप में कार्य करता है। बाद में, यह सही ढंग से (*FAIL) और बैकट्रैक पर विफल रहता है।
• अब यह दाईं से बाईं ओर (*SKIP) की ओर जाता है (बैकग्राउंड करते समय उर्फ) जहां से आगे बाईं ओर जाना मना है। इसके बजाय, इंजन को बाईं ओर कुछ भी फेंकने और उस बिंदु पर कूदने के लिए कहा जाता है जहां (*SKIP) लागू किया गया था।