Документация по Python

Регулярные выражения (Regex) в Python

В: Документация по Python

Соответствие началу строки

Первый аргумент re.match() является регулярным выражением, вторая строка , чтобы соответствовать:

 import re

pattern = r"123"
string = "123zzb"

re.match(pattern, string)
# Out: <_sre.SRE_Match object; span=(0, 3), match='123'>

match = re.match(pattern, string)

match.group()
# Out: '123' 

Можно заметить , что переменная шаблона представляет собой строку с префиксом r , что указывает на то, что строка является исходным строка символов.

Сырые строковый литерал имеет несколько иного синтаксис , чем строка буквального, а именно обратный слэш \ в сыре строковых литералов означает «только обратной косой черты» , и нет никакой необходимости удвоения люфтов , чтобы избежать «экранирующих последовательностей» , такие как символ новой строки ( \n ) , вкладки ( \t ), забой ( \ ), формы-каналы ( \r ), и так далее. В обычных строковых литералах каждый обратный слеш должен быть удвоен, чтобы его не принимали за начало escape-последовательности.

Следовательно, r"\n" является строкой из 2 -х символов: \ и n . Regex модель также использовать обратную косую черту, например , \d относится к любому цифровому символу. Мы можем избежать того , чтобы удвоить наши избежать строки ( "\\d" ) с использованием сырьевых строк ( r"\d" ).

Например:

 string = "\\t123zzb" # here the backslash is escaped, so there's no tab, just '\' and 't'
pattern = "\\t123"   # this will match \t (escaping the backslash) followed by 123
re.match(pattern, string).group()   # no match
re.match(pattern, "\t123zzb").group()  # matches '\t123'

pattern = r"\\t123"  
re.match(pattern, string).group()   # matches '\\t123' 

Сопоставление выполняется только с начала строки. Если вы хотите , чтобы соответствовать в любом месте использовать re.search вместо:

 match = re.match(r"(123)", "a123zzb")

match is None
# Out: True

match = re.search(r"(123)", "a123zzb")

match.group()
# Out: '123' 

поиск

 pattern = r"(your base)"
sentence = "All your base are belong to us."

match = re.search(pattern, sentence)
match.group(1)
# Out: 'your base'

match = re.search(r"(belong.*)", sentence)
match.group(1)
# Out: 'belong to us.' 

Поиск осуществляется в любом месте строки , в отличие от re.match . Вы можете также использовать re.findall .

Вы можете также искать в начале строки (используйте ^ ),

 match = re.search(r"^123", "123zzb")
match.group(0)
# Out: '123'

match = re.search(r"^123", "a123zzb")
match is None
# Out: True 

в конце строки (используйте $ ),

 match = re.search(r"123$", "zzb123")
match.group(0)
# Out: '123'

match = re.search(r"123$", "123zzb")
match is None
# Out: True 

или оба (использовать оба ^ и $ ):

 match = re.search(r"^123$", "123")
match.group(0)
# Out: '123' 

группирование

Группировка осуществляется с помощью скобок. Вызов group() возвращает строку , образованную из согласующих скобок подгрупп.

 match.group() # Group without argument returns the entire match found
# Out: '123'
match.group(0) # Specifying 0 gives the same result as specifying no argument
# Out: '123' 

Аргументы могут также быть предоставлена group() для извлечения конкретной подгруппы.

Из документации :

Если есть единственный аргумент, результат - единственная строка; если имеется несколько аргументов, результатом является кортеж с одним элементом на аргумент.

Вызов groups() , с другой стороны, возвращает список кортежей , содержащих подгруппу.

 sentence = "This is a phone number 672-123-456-9910"
pattern = r".*(phone).*?([\d-]+)"

match = re.match(pattern, sentence)

match.groups()   # The entire match as a list of tuples of the paranthesized subgroups
# Out: ('phone', '672-123-456-9910')

m.group()        # The entire match as a string
# Out: 'This is a phone number 672-123-456-9910'

m.group(0)       # The entire match as a string
# Out: 'This is a phone number 672-123-456-9910'

m.group(1)       # The first parenthesized subgroup.
# Out: 'phone'

m.group(2)       # The second parenthesized subgroup.
# Out: '672-123-456-9910'

m.group(1, 2)    # Multiple arguments give us a tuple.
# Out: ('phone', '672-123-456-9910') 

Именованные группы

 match = re.search(r'My name is (?P<name>[A-Za-z ]+)', 'My name is John Smith')
match.group('name')
# Out: 'John Smith'

match.group(1)
# Out: 'John Smith' 

Создает группу захвата, на которую можно ссылаться как по имени, так и по индексу.

Не захватывающие группы

Используя (?:) создает группу, но группа не улавливается. Это означает, что вы можете использовать его как группу, но это не будет загрязнять ваше «групповое пространство».

 re.match(r'(\d+)(\+(\d+))?', '11+22').groups()
# Out: ('11', '+22', '22')

re.match(r'(\d+)(?:\+(\d+))?', '11+22').groups()
# Out: ('11', '22') 

Этот пример соответствует 11+22 или 11 , но не 11+ . Это так + знак и второй член сгруппированы. С другой стороны, + знак не улавливается.

Экранирование специальных персонажей

Специальные символы (например , класса символов скобки [ и ] ниже) не соответствуют буквально:

 match = re.search(r'[b]', 'a[b]c')
match.group()
# Out: 'b' 

Избегая специальных символов, они могут быть сопоставлены буквально:

 match = re.search(r'\[b\]', 'a[b]c')
match.group()
# Out: '[b]' 

re.escape() функция может использоваться , чтобы сделать это для вас:

 re.escape('a[b]c')
# Out: 'a\\[b\\]c'
match = re.search(re.escape('a[b]c'), 'a[b]c')
match.group()
# Out: 'a[b]c' 

re.escape() функция экранирует все специальные символы, так что это полезно , если вы составляете регулярное выражение на основе пользовательского ввода:

 username = 'A.C.'  # suppose this came from the user
re.findall(r'Hi {}!'.format(username), 'Hi A.C.! Hi ABCD!')
# Out: ['Hi A.C.!', 'Hi ABCD!']
re.findall(r'Hi {}!'.format(re.escape(username)), 'Hi A.C.! Hi ABCD!')
# Out: ['Hi A.C.!'] 

Замена

Замены могут быть сделаны на строки , используя re.sub .

Замена строк

 re.sub(r"t[0-9][0-9]", "foo", "my name t13 is t44 what t99 ever t44")
# Out: 'my name foo is foo what foo ever foo' 

Использование групповых ссылок

Замены с небольшим количеством групп можно сделать следующим образом:

 re.sub(r"t([0-9])([0-9])", r"t\2\1", "t13 t19 t81 t25")
# Out: 't31 t91 t18 t52' 

Тем не менее, если вы сделаете идентификатор группы , как «10», это не работает : \10 читаются как «идентификационный номер 1 с последующим 0». Таким образом , вы должны быть более конкретными и использовать \g<i> обозначения:

 re.sub(r"t([0-9])([0-9])", r"t\g<2>\g<1>", "t13 t19 t81 t25")
# Out: 't31 t91 t18 t52' 

Использование функции замены

 items = ["zero", "one", "two"]
re.sub(r"a\[([0-3])\]", lambda match: items[int(match.group(1))], "Items: a[0], a[1], something, a[2]")
# Out: 'Items: zero, one, something, two' 

Найти все неперекрывающиеся совпадения

 re.findall(r"[0-9]{2,3}", "some 1 text 12 is 945 here 4445588899")
# Out: ['12', '945', '444', '558', '889'] 

Обратите внимание , что r перед тем "[0-9]{2,3}" говорит Python интерпретировать строку как есть; как «сырая» строка.

Вы можете также использовать re.finditer() , которая работает точно так же , как re.findall() , но возвращает итератор с SRE_Match объектов вместо списка строк:

 results = re.finditer(r"([0-9]{2,3})", "some 1 text 12 is 945 here 4445588899")
print(results)
# Out: <callable-iterator object at 0x105245890>
for result in results:
     print(result.group(0))
''' Out:
12
945
444
558
889
''' 

Предварительно скомпилированные шаблоны

 import re

precompiled_pattern = re.compile(r"(\d+)")
matches = precompiled_pattern.search("The answer is 41!")
matches.group(1)
# Out: 41

matches = precompiled_pattern.search("Or was it 42?")
matches.group(1)
# Out: 42

 

Компиляция шаблона позволяет использовать его позже в программе. Тем не менее, обратите внимание , что Python кэширует недавно использованные выражения ( документы , SO ответить ), поэтому «программы , которые используют только несколько регулярных выражений в то время , не нужно беспокоиться о составлении регулярных выражений».

 import re

precompiled_pattern = re.compile(r"(.*\d+)")
matches = precompiled_pattern.match("The answer is 41!")
print(matches.group(1))
# Out: The answer is 41

matches = precompiled_pattern.match("Or was it 42?")
print(matches.group(1))
# Out: Or was it 42

 

Может использоваться с re.match ().

Проверка на допустимые символы

Если вы хотите проверить, что строка содержит только определенный набор символов, в этом случае az, AZ и 0-9, вы можете сделать это следующим образом:

 import re

def is_allowed(string):
    characherRegex = re.compile(r'[^a-zA-Z0-9.]')
    string = characherRegex.search(string)
    return not bool(string)

print (is_allowed("abyzABYZ0099")) 
# Out: 'True'

print (is_allowed("#*@#$%^")) 
# Out: 'False'

 

Вы также можете адаптировать выражение линию из [^a-zA-Z0-9.] На [^a-z0-9.] , Чтобы запретить прописные буквы, например.

Частичный кредит: https://codecamp.ru/a/1325265/2697955

Разделение строки с помощью регулярных выражений

Вы также можете использовать регулярные выражения, чтобы разбить строку. Например,

 import re
data = re.split(r'\s+', 'James 94 Samantha 417 Scarlett 74')
print( data )
# Output: ['James', '94', 'Samantha', '417', 'Scarlett', '74'] 

Флаги

В некоторых особых случаях нам нужно изменить поведение регулярного выражения, это делается с помощью флагов. Флаги могут быть установлены двумя способами, через flags ключевого слова или непосредственно в выражении.

Ключевое слово флаги

Ниже приведен пример для re.search , но это работает для большинства функций в re модуле.

 m = re.search("b", "ABC")  
m is None
# Out: True

m = re.search("b", "ABC", flags=re.IGNORECASE)
m.group()
# Out: 'B'

m = re.search("a.b", "A\nBC", flags=re.IGNORECASE) 
m is None
# Out: True

m = re.search("a.b", "A\nBC", flags=re.IGNORECASE|re.DOTALL) 
m.group()
# Out: 'A\nB'


 

Общие флаги

Флаг  Краткое описание  re.IGNORECASE , re.I  Заставляет шаблон игнорировать случай   re.DOTALL , re.S  Делает . сопоставить все, включая переводы строк  re.MULTILINE , re.M  Делает ^ соответствовать началу строки и $ конца строки  re.DEBUG   Включает отладочную информацию

Для полного списка всех доступных флагов проверить документы

Встроенные флаги

Из документации :

(?iLmsux) (один или более букв из набора 'I', 'L', 'м', 'S', 'и', 'х'.)

Группа соответствует пустой строке; буквы устанавливают соответствующие флаги: re.I (игнорировать регистр), re.L (зависит от локали), re.M (многострочный), re.S (точка соответствует всем), re.U (зависит от Unicode) и re.X (многословный), для всего регулярного выражения. Это полезно, если вы хотите включить флаги как часть регулярного выражения вместо передачи аргумента флага в функцию re.compile ().

Обратите внимание, что флаг (? X) изменяет способ анализа выражения. Его следует использовать сначала в строке выражения или после одного или нескольких пробельных символов. Если перед флагом есть непробельные символы, результаты не определены.

Перебор совпадений с использованием `re.finditer`

Вы можете использовать re.finditer перебрать все матчи в строке. Это дает вам (по сравнению с re.findall дополнительной информации, например, информации о местоположении матча в строке (индексы):

 import re
text = 'You can try to find an ant in this string'
pattern = 'an?\w' # find 'an' either with or without a following word character

for match in re.finditer(pattern, text):
    # Start index of match (integer)
    sStart = match.start()

    # Final index of match (integer)
    sEnd = match.end()

    # Complete match (string)
    sGroup = match.group()

    # Print match
    print('Match "{}" found at: [{},{}]'.format(sGroup, sStart,sEnd))

 

Результат:

 Match "an" found at: [5,7]
Match "an" found at: [20,22]
Match "ant" found at: [23,26] 

Соответствовать выражению только в определенных местах

Часто вы хотите , чтобы соответствовать выражение только в определенных местах (оставляя их нетронутыми в других, то есть). Рассмотрим следующее предложение:

 An apple a day keeps the doctor away (I eat an apple everyday).

 

Здесь «яблоко» встречается дважды , которые могут быть решены с помощью так называемым отслеживанием источников глаголов управления , которые поддерживаются в новом regex модуля. Идея заключается в следующем:

 forget_this | or this | and this as well | (but keep this)

 

На нашем примере с яблоком это будет:

import regex as re
string = "An apple a day keeps the doctor away (I eat an apple everyday)."
rx = re.compile(r'''
    \([^()]*\) (*SKIP)(*FAIL)  # match anything in parentheses and "throw it away"
    |                          # or
    apple                      # match an apple
    ''', re.VERBOSE)
apples = rx.findall(string)
print(apples)
# only one

 

Это соответствует «яблоку» только тогда, когда его можно найти за скобками.

Вот как это работает:

  • Глядя слева направо, регулярное выражение двигатель потребляет все , чтобы слева, (*SKIP) действует как «всегда-истинным самоутверждения». После этого, он правильно не работает на (*FAIL) и откатывается.
  • Теперь он попадает в точку (*SKIP) справа налево (он же в то время как возвратов) , где запрещено идти дальше влево. Вместо этого, двигатель сказал , чтобы выбросить что - нибудь налево и перейти к точке , где (*SKIP) был вызван.
Еще от кодкамп
Замечательно! Вы успешно подписались.
Добро пожаловать обратно! Вы успешно вошли
Вы успешно подписались на кодкамп.
Срок действия вашей ссылки истек.
Ура! Проверьте свою электронную почту на наличие волшебной ссылки для входа.
Успех! Ваша платежная информация обновлена.
Ваша платежная информация не была обновлена.