केस असंवेदनशील की जगह

Question

पायथन में केस-असंवेदनशील स्ट्रिंग प्रतिस्थापन करने का सबसे आसान तरीका क्या है?

Answer 1

stringप्रकार इस का समर्थन नहीं करता। आप शायद का उपयोग कर बंद सबसे अच्छा कर रहे हैं नियमित अभिव्यक्ति उप विधि के साथ re.IGNORECASE विकल्प।

>>> import re
>>> insensitive_hippo = re.compile(re.escape('hippo'), re.IGNORECASE)
>>> insensitive_hippo.sub('giraffe', 'I want a hIPpo for my birthday')
'I want a giraffe for my birthday'

Comments

यदि आप केवल एक ही प्रतिस्थापन कर रहे हैं, या कोड की लाइनों को बचाना चाहते हैं, तो re.sub और (i) ध्वज: re.sub ('('? I) '+ re के साथ एकल प्रतिस्थापन का उपयोग करना अधिक कुशल है। .स्केप ('हिप्पो'), 'जिराफ', 'मैं अपने जन्मदिन के लिए एक हिप्पो चाहता हूं')

— डी

केवल अक्षरों की एक स्ट्रिंग के लिए re.escape क्यों ? धन्यवाद।

— एलिना

@ एलीना, इसकी आवश्यकता नहीं है 'hippo', लेकिन यह उपयोगी होगा यदि टू-रिप्लेस वैल्यू को एक फ़ंक्शन में पारित किया गया था, इसलिए यह वास्तव में किसी भी चीज़ की तुलना में एक अच्छा उदाहरण है।

— ब्लेयर कॉनराड

re.escapeआपकी सुई के पास होने के अलावा , यहां एक और जाल है, जो इस उत्तर को टालने में विफल रहता है, stackoverflow.com/a/15831118/1709587 में उल्लेख किया गया है : चूंकि re.subप्रक्रियाएं अनुक्रम से बचती हैं , जैसा कि docs.python.org/library/recon#re में नोट किया गया है । .sub , आपको या तो अपने प्रतिस्थापन स्ट्रिंग में सभी बैकस्लैश से बचने या एक लैम्ब्डा का उपयोग करने की आवश्यकता है।

— मार्क अमेरी

Answer 2

import re
pattern = re.compile("hello", re.IGNORECASE)
pattern.sub("bye", "hello HeLLo HELLO")
# 'bye bye bye'

Comments

या एक-लाइनर: re.sub('hello', 'bye', 'hello HeLLo HELLO', flags=re.IGNORECASE)

— लुई यांग

ध्यान दें कि re.subकेवल पायथन 2.7 के बाद से इस ध्वज का समर्थन करता है।

— फेनफुन्दाचटजीग

Answer 3

एक पंक्ति में:

import re
re.sub("(?i)hello","bye", "hello HeLLo HELLO") #'bye bye bye'
re.sub("(?i)he\.llo","bye", "he.llo He.LLo HE.LLO") #'bye bye bye'

या, वैकल्पिक "झंडे" तर्क का उपयोग करें:

import re
re.sub("hello", "bye", "hello HeLLo HELLO", flags=re.I) #'bye bye bye'
re.sub("he\.llo", "bye", "he.llo He.LLo HE.LLO", flags=re.I) #'bye bye bye'

Answer 4

BFloch के उत्तर पर जारी रखते हुए, यह फ़ंक्शन एक नहीं, बल्कि नए के साथ पुराने की सभी घटनाओं को बदल देगा - एक मामले में असंवेदनशील फैशन।

def ireplace(old, new, text):
    idx = 0
    while idx < len(text):
        index_l = text.lower().find(old.lower(), idx)
        if index_l == -1:
            return text
        text = text[:index_l] + new + text[index_l + len(old):]
        idx = index_l + len(new) 
    return text

Comments

बहुत अच्छा किया। रेगेक्स से बहुत बेहतर; यह सभी प्रकार के पात्रों को संभालता है, जबकि रेगेक्स किसी भी गैर-अल्फ़ान्यूमेरिक के बारे में बहुत उधम मचाता है। पसंदीदा उत्तर IMHO।

— fyngyrz

आपको केवल रेगेक्स से बचना होगा: स्वीकृत उत्तर बहुत छोटा है और इससे पढ़ने में आसान है।

— मैड

पलायन केवल मिलान के लिए काम करता है, गंतव्य में बैकस्लैश चीजों को अभी भी गड़बड़ कर सकता है।

— विचारमेन .42

Answer 5

जैसे ब्लेयर कॉनरैड का कहना है कि string.replace इसका समर्थन नहीं करता है।

रेगेक्स का उपयोग करें re.sub, लेकिन पहले प्रतिस्थापन स्ट्रिंग से बचने के लिए याद रखें। ध्यान दें कि 2.6 के लिए कोई झंडे-विकल्प नहीं है re.sub, इसलिए आपको एम्बेडेड संशोधक का उपयोग करना होगा'(?i)' (या आरई-ऑब्जेक्ट, ब्लेयर कॉनराड का जवाब देखें)। इसके अलावा, एक और नुकसान यह है कि उप एक प्रतिस्थापन में पाठ से बचने की प्रक्रिया करेगा, अगर कोई स्ट्रिंग दी जाती है। इससे बचने के लिए एक मेमने में से कोई भी गुजर सकता है।

यहाँ एक समारोह है:

import re
def ireplace(old, repl, text):
    return re.sub('(?i)'+re.escape(old), lambda m: repl, text)

>>> ireplace('hippo?', 'giraffe!?', 'You want a hiPPO?')
'You want a giraffe!?'
>>> ireplace(r'[binfolder]', r'C:\Temp\bin', r'[BinFolder]\test.exe')
'C:\\Temp\\bin\\test.exe'

Answer 6

यह फ़ंक्शन फ़ंक्शन str.replace()और re.findall()फ़ंक्शन दोनों का उपयोग करता है । यह के सभी आवृत्तियां का स्थान ले लेगा patternमें stringसाथ replएक केस-संवेदी तरीके से।

def replace_all(pattern, repl, string) -> str:
   occurences = re.findall(pattern, string, re.IGNORECASE)
   for occurence in occurences:
       string = string.replace(occurence, repl)
       return string

Answer 7

यह RegularExp की आवश्यकता नहीं है

def ireplace(old, new, text):
    """ 
    Replace case insensitive
    Raises ValueError if string not found
    """
    index_l = text.lower().index(old.lower())
    return text[:index_l] + new + text[index_l + len(old):] 

Comments

अच्छा है, हालांकि यह नए के साथ पुराने की सभी घटनाओं को नहीं बदलता है, लेकिन केवल पहली घटना है।

— रासमूर्ति

यह रेगेक्स संस्करण की तुलना में कम पठनीय है। यहां पहिया को सुदृढ़ करने की आवश्यकता नहीं है।

— जोहान्स बिटनर 22

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

— D Coetzee

Answer 8

वाक्यविन्यास विवरण और विकल्पों के बारे में एक दिलचस्प अवलोकन:

पायथन 3.7.2 (टैग्स / v3.7.2: 9a3ffc0492, 23 दिसंबर 2018, 23:09:28) [MSC v.1916 64 बिट (AMD64)] पर win32

import re
old = "TREEROOT treeroot TREerOot"
re.sub(r'(?i)treeroot', 'grassroot', old)

'जमीनी स्तर पर जमीनी स्तर'

re.sub(r'treeroot', 'grassroot', old)

'ट्रेरोट ग्रासरूट ट्रेरोट'

re.sub(r'treeroot', 'grassroot', old, flags=re.I)

'जमीनी स्तर पर जमीनी स्तर'

re.sub(r'treeroot', 'grassroot', old, re.I)

'ट्रेरोट ग्रासरूट ट्रेरोट'

तो मैच अभिव्यक्ति में "(i) उपसर्ग या चौथे तर्क के रूप में" झंडे = पुनः "जोड़ने से केस-असंवेदनशील मैच हो जाएगा। लेकिन, चौथे तर्क के रूप में "re.I" का उपयोग करने से केस-असंवेदनशील मैच नहीं होता है।

तुलना के लिए,

re.findall(r'treeroot', old, re.I)

['TREEROOT', 'treeroot', 'TREerOot']

re.findall(r'treeroot', old)

['पेड़ की जड़']

Comments

यह प्रश्न का उत्तर प्रदान नहीं करता है। कृपया अपने उत्तर को यह सुनिश्चित करने के लिए संपादित करें कि यह इस प्रश्न में पहले से मौजूद अन्य उत्तरों में सुधार करता है।

— hongsy

Answer 9

मैं पलायन अनुक्रम (थोड़ा नीचे स्क्रॉल) में परिवर्तित किया जा रहा था , इसलिए मैंने कहा कि re.sub दृश्यों से बचने के लिए पीछे हटाए गए वर्णों को परिवर्तित करता है।

इसे रोकने के लिए मैंने निम्नलिखित लिखा:

मामले को असंवेदनशील बदलें।

import re
    def ireplace(findtxt, replacetxt, data):
        return replacetxt.join(  re.compile(findtxt, flags=re.I).split(data)  )

इसके अलावा, यदि आप चाहते हैं कि यह भागने के पात्रों से बदल जाए, तो यहां अन्य उत्तरों की तरह जो अनुक्रम से बचने के लिए परिवर्तित किए गए विशेष अर्थ bashslash वर्ण प्राप्त कर रहे हैं, बस अपने खोजने और, या स्ट्रिंग को बदलने के लिए। पायथन 3 में, कुछ ऐसा करना पड़ सकता है ।decode ("unicode_escape") # python3

findtxt = findtxt.decode('string_escape') # python2
replacetxt = replacetxt.decode('string_escape') # python2
data = ireplace(findtxt, replacetxt, data)

पायथन 2.7.8 में परीक्षण किया गया

उम्मीद है की वो मदद करदे।

Answer 10

पहले कभी कोई उत्तर पोस्ट नहीं किया और यह धागा वास्तव में पुराना है, लेकिन मैं एक और सावधानी के साथ आया और लगा कि मुझे आपकी ज़िम्मेदारी मिल सकती है, Im पायथन प्रोग्रामिंग में अनुभवी नहीं है, इसलिए यदि इसमें कुछ कमियां हैं, तो कृपया उनकी अच्छी शिक्षा के बाद से उन्हें इंगित करें: )

i='I want a hIPpo for my birthday'
key='hippo'
swp='giraffe'

o=(i.lower().split(key))
c=0
p=0
for w in o:
    o[c]=i[p:p+len(w)]
    p=p+len(key+w)
    c+=1
print(swp.join(o))

Comments

सीखने के लिए: आम तौर पर जब आप एक खोज करते हैं और एक स्ट्रिंग पर प्रतिस्थापित करते हैं, तो बेहतर होगा कि इसे पहले किसी ऐरे में न बदलें। इसलिए पहला उत्तर शायद सबसे अच्छा है। जबकि यह एक बाहरी मॉड्यूल का उपयोग कर रहा है, यह स्ट्रिंग को एक पूरे स्ट्रिंग के रूप में मान रहा है। यह थोड़ा स्पष्ट भी है कि इस प्रक्रिया में क्या हो रहा है।

— isallw

सीखने के लिए: इस कोड को पढ़ने के लिए किसी भी संदर्भ के साथ एक डेवलपर के लिए यह बहुत मुश्किल है और इसकी क्या हो रही है उसे

— टोड