Замена без учета регистра


Ответы:


217

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'

11
Если вы делаете только одну замену или хотите сохранить строки кода, более эффективно использовать одну замену с re.sub и флагом (? I): re.sub ('(? I)' + re .escape ('бегемот'), 'жираф', 'я хочу hippo на мой день рождения')
D Coetzee

3
Почему re.escape только для строки букв? Спасибо.
Елена

8
@ Елена, это не нужно 'hippo', но было бы полезно, если бы значение для замены было передано в функцию, так что это действительно более хороший пример, чем все остальное.
Блэр Конрад

2
Помимо того, что вам нужно re.escapeстрелять, есть еще одна ловушка, которую этот ответ не может избежать, отмеченная в stackoverflow.com/a/15831118/1709587 : поскольку re.subпроцессы экранируют последовательности, как отмечено в docs.python.org/library/re.html#re .sub , вам нужно либо избежать обратной косой черты в замещающей строке, либо использовать лямбду.
Марк Амери

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

17
Или однострочник: re.sub('hello', 'bye', 'hello HeLLo HELLO', flags=re.IGNORECASE)
Луи Ян

Обратите внимание, что re.subэтот флаг поддерживается только с Python 2.7.
fuenfundachtzig

47

В одной строке:

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'

Или используйте необязательный аргумент «flags»:

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'

14

Продолжая ответ 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

Очень хорошо сделано. Гораздо лучше, чем регулярное выражение; он обрабатывает все виды символов, в то время как регулярные выражения очень суетливы относительно всего, что не алфавитно-цифровое. Предпочтительный ответ ИМХО.
fyngyrz

Все, что вам нужно сделать, это избежать выражения: принятый ответ намного короче и легче для чтения, чем этот.
Безумный физик

Escape работает только на совпадение, обратные слеши в месте назначения могут все еще испортить.
ideasman42

4

Как говорит Блэр Конрад, string.replace не поддерживает это.

Используйте регулярное выражение re.sub , но не забудьте сначала экранировать строку замены. Обратите внимание, что в 2.6 нет опции flags re.sub, поэтому вам придется использовать встроенный модификатор'(?i)' (или RE-объект, см. Ответ Блэра Конрада). Кроме того, другая ловушка заключается в том, что sub будет обрабатывать экранирование обратной косой черты в тексте замены, если задана строка. Чтобы избежать этого, можно вместо этого перейти в лямбду.

Вот функция:

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'

4

Эта функция использует как 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

3

Это не требует 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
Хороший, однако это не меняет все вхождения старого на новое, а только первое вхождение.
rsmoorthy

5
Это менее читабельно, чем версия регулярного выражения. Не нужно изобретать велосипед здесь.
Йоханнес Биттнер

Было бы интересно сделать сравнение производительности между этой и проверенной версиями, это может быть быстрее, что важно для некоторых приложений. Или это может быть медленнее, потому что он работает больше в интерпретируемом Python.
D Coetzee

2

Интересное наблюдение о деталях синтаксиса и опциях:

Python 3.7.2 (tags / 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)

«TREEROOT низовой TREerOot»

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

«Массовый Массовый»

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

«TREEROOT низовой TREerOot»

Таким образом, префикс (? I) в выражении соответствия или добавление «flags = re.I» в качестве четвертого аргумента приведет к нечувствительному к регистру соответствию. НО, использование только «re.I» в качестве четвертого аргумента не приводит к нечувствительному к регистру соответствию.

Для сравнения,

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

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

re.findall(r'treeroot', old)

[ 'Treeroot']


Это не дает ответа на вопрос. Пожалуйста , измените свой ответ , чтобы гарантировать , что она улучшает другие ответы , уже присутствующих в этом вопросе.
hongsy

1

У меня было \ t преобразование в escape-последовательности (прокрутка немного вниз), поэтому я заметил, что re.sub конвертирует экранированные символы с обратной косой чертой в escape-последовательности.

Чтобы предотвратить это, я написал следующее:

Заменить без учета регистра.

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

Кроме того, если вы хотите заменить его на escape-символы, как и в других ответах, которые получают специальные символы bashslash, преобразованные в escape-последовательности, просто декодируйте строку find и или заменяйте строку. В Python 3 может потребоваться что-то вроде .decode ("unicode_escape") # python3

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

Проверено в Python 2.7.8

Надеюсь, это поможет.


0

Я никогда не публиковал ответ, и эта ветка действительно старая, но я придумал другое решение и решил, что могу получить ваш ответ. Я не опытный программист на Python, поэтому, если у него есть явные недостатки, пожалуйста, укажите на них, поскольку он хорошо изучен: )

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))

2
Для обучения: как правило, когда вы выполняете поиск и замену строки, лучше сначала не превращать ее в массив. Вот почему первый ответ, вероятно, самый лучший. Хотя он использует внешний модуль, он обрабатывает строку как одну целую строку. Также немного понятнее, что происходит в процессе.
isaaclw

Для обучения: разработчику без контекста очень трудно прочитать этот код и расшифровать, что он делает :)
Тодд
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.