पायथन में केस-असंवेदनशील स्ट्रिंग प्रतिस्थापन करने का सबसे आसान तरीका क्या है?
पायथन में केस-असंवेदनशील स्ट्रिंग प्रतिस्थापन करने का सबसे आसान तरीका क्या है?
जवाबों:
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'
'hippo'
, लेकिन यह उपयोगी होगा यदि टू-रिप्लेस वैल्यू को एक फ़ंक्शन में पारित किया गया था, इसलिए यह वास्तव में किसी भी चीज़ की तुलना में एक अच्छा उदाहरण है।
re.escape
आपकी सुई के पास होने के अलावा , यहां एक और जाल है, जो इस उत्तर को टालने में विफल रहता है, stackoverflow.com/a/15831118/1709587 में उल्लेख किया गया है : चूंकि re.sub
प्रक्रियाएं अनुक्रम से बचती हैं , जैसा कि docs.python.org/library/recon#re में नोट किया गया है । .sub , आपको या तो अपने प्रतिस्थापन स्ट्रिंग में सभी बैकस्लैश से बचने या एक लैम्ब्डा का उपयोग करने की आवश्यकता है।
import re
pattern = re.compile("hello", re.IGNORECASE)
pattern.sub("bye", "hello HeLLo HELLO")
# 'bye bye bye'
re.sub('hello', 'bye', 'hello HeLLo HELLO', flags=re.IGNORECASE)
re.sub
केवल पायथन 2.7 के बाद से इस ध्वज का समर्थन करता है।
एक पंक्ति में:
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'
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
जैसे ब्लेयर कॉनरैड का कहना है कि 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'
यह फ़ंक्शन फ़ंक्शन 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
यह 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):]
वाक्यविन्यास विवरण और विकल्पों के बारे में एक दिलचस्प अवलोकन:
पायथन 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)
['पेड़ की जड़']
मैं पलायन अनुक्रम (थोड़ा नीचे स्क्रॉल) में परिवर्तित किया जा रहा था , इसलिए मैंने कहा कि 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 में परीक्षण किया गया
उम्मीद है की वो मदद करदे।
पहले कभी कोई उत्तर पोस्ट नहीं किया और यह धागा वास्तव में पुराना है, लेकिन मैं एक और सावधानी के साथ आया और लगा कि मुझे आपकी ज़िम्मेदारी मिल सकती है, 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))