मामला असंवेदनशील नियमित अभिव्यक्ति के बिना re.compile?

Question

पायथन में, मैं केस-असंवेदनशील होने के लिए एक नियमित अभिव्यक्ति संकलित कर सकता हूं re.compile:

>>> s = 'TeSt'
>>> casesensitive = re.compile('test')
>>> ignorecase = re.compile('test', re.IGNORECASE)
>>> 
>>> print casesensitive.match(s)
None
>>> print ignorecase.match(s)
<_sre.SRE_Match object at 0x02F0B608>

क्या ऐसा करने का कोई तरीका है, लेकिन बिना उपयोग के re.compile। मुझे डॉक्यूमेंट में पर्ल के iप्रत्यय (जैसे m/test/i) जैसा कुछ भी नहीं मिला ।

Comments

आप नियमित एक्सर्साइज़ के लिए एक उत्कृष्ट परिचय पा सकते हैं: python-course.eu/re.php

— 2Obe

Answer 1

दर्रा re.IGNORECASEके लिए flagsकी परम search, matchया sub:

re.search('test', 'TeSt', re.IGNORECASE)
re.match('test', 'TeSt', re.IGNORECASE)
re.sub('test', 'xxxx', 'Testing', flags=re.IGNORECASE)

Comments

re.match('test', 'TeSt', re.IGNORECASE)TypeErrorजब दोनों में से कोई भी विशेषता हो सकती है None। First_string == second_string द्वारा मिलान try & exceptपकड़ने के लिए उपयोग करना TypeError। नमूना कोड def equal_ignore_case(first_string, second_string): try: return re.match(first_string, second_string, re.IGNORECASE) is not None except (AttributeError, TypeError): return first_string == second_string डेमो कोड

— अभिजीत २ ''१

@ अबिजीत आपको वास्तव में उस मामले को छोड़कर कोशिश नहीं करनी चाहिए। बस जाँच करें कि क्या कोई तार Noneपहले हैं।

— ERB

यह नाम दिया है तर्क का उपयोग करने के लिए महत्वपूर्ण है flagsके लिए re.subअन्यथा यह गुजरता है re.IGNORECASEकरने के लिए countतर्क (रों भी। Stackoverflow.com/questions/42581/... )

— L3n95

Answer 2

आप IGNORECASE ध्वज (पायथन 2.7.3 में परीक्षण) के बिना खोज / मिलान का उपयोग करके मामले को असंवेदनशील खोज भी कर सकते हैं:

re.search(r'(?i)test', 'TeSt').group()    ## returns 'TeSt'
re.match(r'(?i)test', 'TeSt').group()     ## returns 'TeSt'

Comments

दस्तावेज़ में किसी विशेष संस्करण में जोड़े जा रहे फ़ीचर का उल्लेख नहीं किया गया है (जैसा कि विरोध किया गया है, (?(condition)yes|no)जो कहता है कि इसे 2.4 में जोड़ा गया था), इसलिए मुझे उम्मीद है कि यह हमेशा reमॉड्यूल के पहले संस्करण के बाद से उपलब्ध है , जो मुझे लगता है कि जोड़ा गया था 1.5 में। मूल रूप से सभी इरादों और उद्देश्यों के लिए समय की शुरुआत के बाद से जब यह पायथन की बात आती है। यह इस पृष्ठ के पहले खंड के माध्यम से आधे रास्ते के बारे में प्रलेखित है: docs.python.org/2/library/re.html# अनियमित-expression

— syntax

यहाँ हम जाते हैं - मैंने 1.5 के लिए दस्तावेज के माध्यम से देखा और पाया कि यह इस पृष्ठ के लगभग 60% तरीके से प्रलेखित है : docs.python.org/release/1.5/lib/… मैंने भी 1.4 प्रलेखन की जाँच की, जिसमें कोई उल्लेख नहीं किया गया था यह सुविधा। इसलिए मुझे लगता है कि यह 1.5 में जोड़ा गया था, जब regexमॉड्यूल मॉड्यूल के पक्ष में पदावनत किया गया था re।

— आर्टऑफवर्फ

यह एक अच्छा समाधान है क्योंकि इसमें ध्वज की आवश्यकता नहीं होती है। मेरे मामले में मैं रेडिस में खोज के तार संग्रहीत कर रहा हूं और यह वास्तव में मददगार है।

— निजी

@ मुख्य: वैचारिक रूप से यह पूरे रेगेक्स पर re.I फ्लैग को सेट करता है - न कि केवल उस कैप्चर ग्रुप को जो वह पहले से है। इस बात से अवगत रहें कि re.match(r'''A ((?i)B) C''', "a b c").group(0)हर चीज (ए और सी) पर केस-असंवेदनशील मिलान का कारण बनता है, न कि केवल बी पर! यदि आप केवल विशिष्ट कैप्चर समूह पर केस-इन्सेंस मिलान चाहते हैं, तो यह वह ड्रॉइड नहीं है जिसकी आप तलाश कर रहे हैं।

— 21

@ पेशेवर: हाँ पूरी तरह से। मेरी बात वैचारिक रूप से यह झंडा स्थापित करने के समान है। पूरे रेगेक्स पर। यहां तक ​​कि समूह जो इसे पहले (!)। "केवल निम्नलिखित कैप्चर समूहों पर केस-असंवेदनशील" कहने के लिए कोई सिंटैक्स नहीं है।

— 14

Answer 3

केस-असंवेदनशील मार्कर, (?i)को सीधे रेगेक्स पैटर्न में शामिल किया जा सकता है:

>>> import re
>>> s = 'This is one Test, another TEST, and another test.'
>>> re.findall('(?i)test', s)
['Test', 'TEST', 'test']

Comments

बेहतर विकल्प, रेगेक्स को प्लेटफार्मों पर पोर्टेबल बनाता है और घोषणा पर स्पष्ट है

— सीना मदनी

इस '(?i)'दृष्टिकोण का यह भी फायदा है कि आप regexp की सूची बना सकते हैं, जिनमें से कुछ मामले असंवेदनशील हैं और कुछ नहीं हैं। (और निश्चित रूप से, re.compileयदि आप चाहें तो आप उस सूची पर मैप कर सकते हैं।)

— नहीं-अभी-अभी-

@SinaMadani मैं उलझन में हूँ। इससे अधिक पोर्टेबल कैसे है flags=re.IGNORECASE?

— रोमेन विंसेंट

Answer 4

आप पैटर्न संकलन के दौरान मामले को असंवेदनशील भी परिभाषित कर सकते हैं:

pattern = re.compile('FIle:/+(.*)', re.IGNORECASE)

Comments

प्रश्न में ओपी इसका उपयोग करता है और पूछता है कि क्या ऐसा करने का एक और तरीका है।

— पीटर वुड

तेजी से स्क्रॉल करने वालों के लिए मददगार।

— स्टेवेक

Answer 5

आयात में

import re

रन टाइम प्रोसेसिंग में:

RE_TEST = r'test'
if re.match(RE_TEST, 'TeSt', re.IGNORECASE):

यह उल्लेख किया जाना चाहिए कि उपयोग re.compileकरना बेकार नहीं है। हर बार जब उपरोक्त मैच विधि को बुलाया जाता है, तो नियमित अभिव्यक्ति संकलित की जाएगी। यह अन्य प्रोग्रामिंग भाषाओं में भी दोषपूर्ण अभ्यास है। नीचे बेहतर अभ्यास है।

एप्लिकेशन प्रारंभ में:

self.RE_TEST = re.compile('test', re.IGNORECASE)

रन टाइम प्रोसेसिंग में:

if self.RE_TEST.match('TeSt'):

Comments

धन्यवाद! कोई भी कभी संकलन के बारे में बात नहीं करता है, फिर भी यह सबसे चतुर विकल्प है!

— स्टीफनजॉलियर

ओपी सचमुच एक समाधान के लिए पूछता है जो उपयोग नहीं करता हैre.compile() ....

— 16

Answer 6

#'re.IGNORECASE' for case insensitive results short form re.I
#'re.match' returns the first match located from the start of the string. 
#'re.search' returns location of the where the match is found 
#'re.compile' creates a regex object that can be used for multiple matches

 >>> s = r'TeSt'   
 >>> print (re.match(s, r'test123', re.I))
 <_sre.SRE_Match object; span=(0, 4), match='test'>
 # OR
 >>> pattern = re.compile(s, re.I)
 >>> print(pattern.match(r'test123'))
 <_sre.SRE_Match object; span=(0, 4), match='test'>

Answer 7

केस-असंवेदनशील संचालन करने के लिए, पुन: डिज़ाइन करें

>>> import re
>>> test = 'UPPER TEXT, lower text, Mixed Text'
>>> re.findall('text', test, flags=re.IGNORECASE)
['TEXT', 'text', 'Text']

और अगर हम केस से मेल खाते टेक्स्ट को बदलना चाहते हैं ...

>>> def matchcase(word):
        def replace(m):
            text = m.group()
            if text.isupper():
                return word.upper()
            elif text.islower():
                return word.lower()
            elif text[0].isupper():
                return word.capitalize()
            else:
                return word
        return replace

>>> re.sub('text', matchcase('word'), test, flags=re.IGNORECASE)
'UPPER WORD, lower word, Mixed Word'

Answer 8

यदि आप प्रतिस्थापित करना चाहते हैं, लेकिन फिर भी पिछले स्ट्रोक की शैली को ध्यान में रखते हैं। हो सकता है।

उदाहरण के लिए: स्ट्रिंग "परीक्षण asdasd टेस्ट asd tEst asdasd" पर प्रकाश डालें।

sentence = "test asdasd TEST asd tEst asdasd"
result = re.sub(
  '(test)', 
  r'<b>\1</b>',  # \1 here indicates first matching group.
  sentence, 
  flags=re.IGNORECASE)

परीक्षण asdasd टेस्ट asd tEst asdasd

Answer 9

केस असंवेदनशील नियमित अभिव्यक्ति (रेगेक्स) के लिए: आपके कोड में जोड़कर दो तरीके हैं:

1. flags=re.IGNORECASE

   Regx3GList = re.search("(WCDMA:)((\d*)(,?))*", txt, **re.IGNORECASE**)

2. केस-असंवेदनशील मार्कर (?i)

   Regx3GList = re.search("**(?i)**(WCDMA:)((\d*)(,?))*", txt)