एक नियमित अभिव्यक्ति के अंदर एक चर का उपयोग कैसे करें?

Question

मैं variableअंदर का उपयोग करना चाहूंगा regex, मैं यह कैसे कर सकता हूं Python?

TEXTO = sys.argv[1]

if re.search(r"\b(?=\w)TEXTO\b(?!\w)", subject, re.IGNORECASE):
    # Successful match
else:
    # Match attempt failed

Comments

आप

— क्रिस एबेल

Answer 1

अजगर 3.6 से आप साहित्यिक स्ट्रिंग इंटरपोलेशन , "एफ-स्ट्रिंग्स" का भी उपयोग कर सकते हैं । आपके विशेष मामले में समाधान होगा:

if re.search(rf"\b(?=\w){TEXTO}\b(?!\w)", subject, re.IGNORECASE):
    ...do something

संपादित करें:

चूँकि टिप्पणी में कुछ प्रश्न हैं कि विशेष वर्णों से कैसे निपटा जाए, मैं अपना उत्तर देना चाहता हूँ:

कच्चे तार ('आर'):

मुख्य अभिव्यक्तियों में से एक को आपको समझना होगा जब नियमित अभिव्यक्तियों में विशेष वर्णों के साथ व्यवहार करना स्ट्रिंग शाब्दिकों और नियमित अभिव्यक्ति के बीच अंतर करना है। यह यहाँ बहुत अच्छी तरह से समझाया गया है :

संक्षेप में:

के बजाय एक शब्द सीमा को खोजने का मान लीजिए \bके बाद TEXTOआप स्ट्रिंग का मिलान करना चाहते \boundary। आपको लिखना है:

TEXTO = "Var"
subject = r"Var\boundary"

if re.search(rf"\b(?=\w){TEXTO}\\boundary(?!\w)", subject, re.IGNORECASE):
    print("match")

यह केवल इसलिए काम करता है क्योंकि हम एक कच्चे-स्ट्रिंग का उपयोग कर रहे हैं (regex 'r' से पहले है), अन्यथा हमें regex में "\\\\" सीमा (चार बैकस्लैश) लिखना होगा। इसके अतिरिक्त, '\ r' के बिना, \ b 'एक शब्द सीमा में नहीं बल्कि एक बैकस्पेस में परिवर्तित हो जाएगा!

re.escape :

मूल रूप से किसी विशेष चरित्र के सामने एक बैकस्पेस होता है। इसलिए, यदि आप TEXTO में एक विशेष चरित्र की अपेक्षा करते हैं, तो आपको लिखना होगा:

if re.search(rf"\b(?=\w){re.escape(TEXTO)}\b(?!\w)", subject, re.IGNORECASE):
    print("match")

नोट: किसी भी संस्करण के लिए> = अजगर 3.7: !, ", %, ', ,, /, :, ;, <, =, >, @, और `भाग निकले नहीं हैं। केवल एक regex में अर्थ वाले विशेष वर्ण अभी भी बच गए हैं। _(है। अजगर 3.3 के बाद से फरार हो नहीं है। यहाँ )

घुंघराले ब्रेसिज़:

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

if re.search(rf"\b(?=\w){re.escape(TEXTO)}\d{{2}}\b(?!\w)", subject, re.IGNORECASE):
    print("match")

Comments

2020 तक, यह एक नियमित अभिव्यक्ति के अंदर एक चर का उपयोग करने का सबसे सरल और सबसे आकर्षक तरीका है

— CONvid19

यह निश्चित रूप से एक वाह है ।

— जेसन गोल

क्या कोई "rf" का महत्व यहाँ समझा सकता है

— हर्ष रेड्डी

@ हर्षरेड्डी: 'र': ​​यह स्ट्रिंग एक कच्ची स्ट्रिंग है: यदि आप इसका उपयोग नहीं करते हैं, तो '\ b' बैकस्पेस वर्ण में परिवर्तित हो जाएगा ( docs.python.org/3/howto/regex.html#more- प्रतिमान-शक्ति )। 'एफ' अजगर को बताता है कि यह एक 'एफ-स्ट्रिंग' है, एस। उपरोक्त लिंक, और आपको घुंघराले ब्रेसिज़ में चर लिखने में सक्षम बनाता है-

— एयरबोर्न

एफ-स्ट्रिंग्स में क्वांटिफायर कैसे लिखें: fr"foo{{1,5}}"(ब्रेसिज़ को दोगुना करें)

— पंचशील

Answer 2

आपको एक स्ट्रिंग के रूप में रेगेक्स का निर्माण करना होगा:

TEXTO = sys.argv[1]
my_regex = r"\b(?=\w)" + re.escape(TEXTO) + r"\b(?!\w)"

if re.search(my_regex, subject, re.IGNORECASE):
    etc.

इस बात पर ध्यान दें re.escapeकि यदि आपके पाठ में विशेष वर्ण हैं, तो उन्हें इस तरह से व्याख्यायित नहीं किया जाएगा।

Comments

यदि आपका चर पहले चला जाए तो क्या होगा? r'' + foo + 'bar'?

— विलेख 02392

@ deed02392 r''जरूरी नहीं कि आप करें re.escape(foo), जो आपको वैसे भी करना चाहिए। वास्तव में, मुझे लगता है कि reयह सब कुछ एक यूनिकोड स्ट्रिंग के रूप में दिया गया है, भले ही आप उपसर्ग करें rया नहीं।

— OJFord

क्या .format () re.escape के स्थान पर भी काम करता है या re.escape () आवश्यक है?

— प्रैक्सिटेल्स

@praxiteles क्या आपको उत्तर मिला?

— CONvid19

मुझे यकीन नहीं है कि अगर यह काम करता है तो मुझे एक ऐसे समूह की आवश्यकता होती है जिसमें चर का एक हिस्सा हो। नीचे दिए गए अन्य उत्तर उसके लिए अधिक सहज दिखते हैं, और रेगेक्स को कई अभिव्यक्तियों में नहीं तोड़ते हैं।

— ग्वालियर

Answer 3

if re.search(r"\b(?<=\w)%s\b(?!\w)" % TEXTO, subject, re.IGNORECASE):

यह TEXTO में एक स्ट्रिंग के रूप में regex में सम्मिलित करेगा।

Answer 4

rx = r'\b(?<=\w){0}\b(?!\w)'.format(TEXTO)

Answer 5

मुझे कई छोटे पैटर्न एक साथ स्ट्रिंग करके एक नियमित अभिव्यक्ति पैटर्न बनाने में बहुत सुविधाजनक लगता है।

import re

string = "begin:id1:tag:middl:id2:tag:id3:end"
re_str1 = r'(?<=(\S{5})):'
re_str2 = r'(id\d+):(?=tag:)'
re_pattern = re.compile(re_str1 + re_str2)
match = re_pattern.findall(string)
print(match)

आउटपुट:

[('begin', 'id1'), ('middl', 'id2')]

Answer 6

मैं उपरोक्त सभी से सहमत हूँ जब तक कि:

sys.argv[1] कुछ ऐसा था Chicken\d{2}-\d{2}An\s*important\s*anchor

sys.argv[1] = "Chicken\d{2}-\d{2}An\s*important\s*anchor"

आप उपयोग नहीं करना चाहेंगे re.escape, क्योंकि उस स्थिति में आप चाहेंगे कि यह रेगेक्स की तरह व्यवहार करे

TEXTO = sys.argv[1]

if re.search(r"\b(?<=\w)" + TEXTO + "\b(?!\w)", subject, re.IGNORECASE):
    # Successful match
else:
    # Match attempt failed

Answer 7

मुझे उन उपयोगकर्ता नामों की खोज करने की आवश्यकता थी जो एक दूसरे के समान हैं, और नेड बैचेल्ड ने जो कहा वह अविश्वसनीय रूप से सहायक था। हालाँकि, मुझे पता चला कि जब मैंने अपने पुनः खोज शब्द को बनाने के लिए re.compile का उपयोग किया था, तो मेरा क्लीनर आउटपुट था:

pattern = re.compile(r"("+username+".*):(.*?):(.*?):(.*?):(.*)"
matches = re.findall(pattern, lines)

निम्नलिखित का उपयोग करके आउटपुट प्रिंट किया जा सकता है:

print(matches[1]) # prints one whole matching line (in this case, the first line)
print(matches[1][3]) # prints the fourth character group (established with the parentheses in the regex statement) of the first line.

Answer 8

आप formatग्रामर के उपयोग से एक और उपयोग करने की कोशिश कर सकते हैं :

re_genre = r'{}'.format(your_variable)
regex_pattern = re.compile(re_genre)  

Answer 9

आप इसके लिए प्रारूप कीवर्ड का उपयोग कर सकते हैं। फ़र्मैट विधि उस चर को {} प्लेसहोल्डर को प्रतिस्थापित कर देगी जिसे आपने तर्क के रूप में प्रारूप विधि में पारित किया था।

if re.search(r"\b(?=\w)**{}**\b(?!\w)".**format(TEXTO)**, subject, re.IGNORECASE):
    # Successful match**strong text**
else:
    # Match attempt failed

Answer 10

अधिक उदाहरण

मैं प्रवाह फ़ाइलों के साथ configus.yml है

"pattern":
  - _(\d{14})_
"datetime_string":
  - "%m%d%Y%H%M%f"

अजगर कोड में मैं का उपयोग करें

data_time_real_file=re.findall(r""+flows[flow]["pattern"][0]+"", latest_file)