Python Regex SuperPower [полный учебник]

import re


text = '''
LADY CAPULET

    Alack the day, she's dead, she's dead, she's dead!

CAPULET

    Ha! let me see her: out, alas! she's cold:
    Her blood is settled, and her joints are stiff;
    Life and these lips have long been separated:
    Death lies on her like an untimely frost
    Upon the sweetest flower of all the field.

Nurse

    O lamentable day!
'''


print(re.findall('she', text))
'''
Finds the pattern 'she' four times in the text:

['she', 'she', 'she', 'she']
'''


print(re.search('she', text))
'''
Finds the first match of 'she' in the text:



The match object contains important information
such as the matched position.
'''


print(re.match('she', text))
'''
Tries to match any string prefix -- but nothing found:

None
'''


print(re.fullmatch('she', text))
'''
Fails to match the whole string with the pattern 'she':

None
'''


print(re.split('\n', text))
'''
Splits the whole string on the new line delimiter '\n':

['', 'LADY CAPULET', '',
"    Alack the day, she's dead, she's dead, she's dead!",
'', 'CAPULET', '',
"    Ha! let me see her: out, alas! she's cold:",
'    Her blood is settled, and her joints are stiff;',
'    Life and these lips have long been separated:',
'    Death lies on her like an untimely frost',
'    Upon the sweetest flower of all the field.', '',
'Nurse', '', '    O lamentable day!', '']
'''

print(re.sub('she', 'he', text))
'''
Replaces all occurrences of 'she' with 'he':

LADY CAPULET

    Alack the day, he's dead, he's dead, he's dead!

CAPULET

    Ha! let me see her: out, alas! he's cold:
    Her blood is settled, and her joints are stiff;
    Life and these lips have long been separated:
    Death lies on her like an untimely frost
    Upon the sweetest flower of all the field.

Nurse

    O lamentable day!
'''

import re

text = '''
    Ha! let me see her: out, alas! he's cold:
    Her blood is settled, and her joints are stiff;
    Life and these lips have long been separated:
    Death lies on her like an untimely frost
    Upon the sweetest flower of all the field.
'''

print(re.findall('.a!', text))
'''
Finds all occurrences of an arbitrary character that is
followed by the character sequence 'a!'.
['Ha!']
'''

print(re.findall('is.*and', text))
'''
Finds all occurrences of the word 'is',
followed by an arbitrary number of characters
and the word 'and'.
['is settled, and']
'''

print(re.findall('her:?', text))
'''
Finds all occurrences of the word 'her',
followed by zero or one occurrences of the colon ':'.
['her:', 'her', 'her']
'''

print(re.findall('her:+', text))
'''
Finds all occurrences of the word 'her',
followed by one or more occurrences of the colon ':'.
['her:']
'''


print(re.findall('^Ha.*', text))
'''
Finds all occurrences where the string starts with
the character sequence 'Ha', followed by an arbitrary
number of characters except for the new-line character. 
Can you figure out why Python doesn't find any?
[]
'''

print(re.findall('\n$', text))
'''
Finds all occurrences where the new-line character '\n'
occurs at the end of the string.
['\n']
'''

print(re.findall('(Life|Death)', text))
'''
Finds all occurrences of either the word 'Life' or the
word 'Death'.
['Life', 'Death']
'''

import re

text = '''
   Ha! let me see her: out, alas! he's cold:
   Her blood is settled, and her joints are stiff;
   Life and these lips have long been separated:
   Death lies on her like an untimely frost
   Upon the sweetest flower of all the field.
'''

print(re.findall('\w+\W+\w+', text))
'''
Matches each pair of words in the text.

['Ha! let', 'me see', 'her: out', 'alas! he',
's cold', 'Her blood', 'is settled', 'and her',
'joints are', 'stiff;\n Life', 'and these',
'lips have', 'long been', 'separated:\n Death',
'lies on', 'her like', 'an untimely',
'frost\n Upon', 'the sweetest', 'flower of', 'all the']

Note that it matches also across new lines: 'stiff;\n Life'
is also matches!

Note also that what is already matched is "consumed" and
doesn't match again. This is why the combination 'let me' is not
a matching substring.
'''

print(re.findall('\d', text))
'''
No integers in the text:

[ ]
'''

print(re.findall('\n\t', text))
'''
Match all occurrences where a tab follows a newline:

[ ]

No match because each line starts with a sequence of four
whitespaces rather than the tab character.
'''

print(re.findall('\n ', text))
'''
Match all occurrences where 4 whitespaces ' ' follow a newline:

['\n ', '\n ', '\n ', '\n ', '\n ']

Matches all five lines.
'''

import re

text = '''
    Ha! let me see her: out, alas! he's cold:
    Her blood is settled, and her joints are stiff;
    Life and these lips have long been separated:
    Death lies on her like an untimely frost
    Upon the sweetest flower of all the field.
'''

>>> re.findall('her', text)
['her', 'her', 'her']

>>> re.findall('\\bf\w+\\b', text)
['frost', 'flower', 'field']

re.findall(pattern, string, flags=0)

import re

text = '''
    Ha! let me see her: out, alas! he's cold:
    Her blood is settled, and her joints are stiff;
    Life and these lips have long been separated:
    Death lies on her like an untimely frost
    Upon the sweetest flower of all the field.
'''

print(re.findall('HER', text, flags=re.IGNORECASE))
# ['her', 'Her', 'her', 'her']

import re

text = '''
    Ha! let me see her: out, alas! he's cold:
    Her blood is settled, and her joints are stiff;
    Life and these lips have long been separated:
    Death lies on her like an untimely frost
    Upon the sweetest flower of all the field.
'''

print(re.findall('   HER   # Ignored', text,
                 flags=re.IGNORECASE + re.VERBOSE))
# ['her', 'Her', 'her', 'her']

re.search(pattern, string, flags=0)

>>> m = re.search('h...o', 'hello world')
>>> m.start()
0
>>> m.end()
5
>>> 'hello world'[m.start():m.end()]
'hello'

>>> import re
>>> text = '''
    Ha! let me see her: out, alas! he's cold:
    Her blood is settled, and her joints are stiff;
    Life and these lips have long been separated:
    Death lies on her like an untimely frost
    Upon the sweetest flower of all the field.
'''

>>> re.search('her', text)

>>> m = re.search('her', text)
>>> m.start()
20
>>> m.end()
23

>>> text = 'Python is superior to Python'
>>> re.search('Py...n', text)

>>> re.findall('Py...n', text)
['Python', 'Python']

>>> text = 'Slim Shady is my name'
>>> re.search('Shady', text)

>>> re.match('Shady', text)
>>>

re.match(pattern, string, flags=0)

>>> m = re.match('h...o', 'hello world')
>>> m.start()
0
>>> m.end()
5
>>> 'hello world'[m.start():m.end()]
'hello'

>>> import re
>>> text = '''
    Ha! let me see her: out, alas! he's cold:
    Her blood is settled, and her joints are stiff;
    Life and these lips have long been separated:
    Death lies on her like an untimely frost
    Upon the sweetest flower of all the field.
'''

>>> re.match('lips', text)
>>>

>>> re.match('(.|\n)*lips', text)
>>> m = re.match('(.|\n)*lips', text)
>>> text[m.start():m.end()]
"\n    Ha! let me see her: out, alas! he's cold:\n    Her blood is settled, and her joints are stiff;\n    Life and these lips"

>>> m = re.match('.*lips', text, flags=re.DOTALL)
>>> text[m.start():m.end()]
"\n    Ha! let me see her: out, alas! he's cold:\n    Her blood is settled, and her joints are stiff;\n    Life and these lips"

>>> text = 'Python is superior to Python'
>>> re.match('Py...n', text)

>>> re.findall('Py...n', text)
['Python', 'Python']

>>> text = 'Slim Shady is my name'
>>> re.search('Shady', text)

>>> re.match('Shady', text)
>>>

re.fullmatch(pattern, string, flags=0)

>>> import re
>>> text = '''
Call me Ishmael. Some years ago--never mind how long precisely
--having little or no money in my purse, and nothing particular
to interest me on shore, I thought I would sail about a little
and see the watery part of the world.
'''

>>> re.fullmatch('Call(.|\n)*', text)
>>>

>>> re.fullmatch('\nCall(.|\n)*', text)
 
В чем разница между Re.fullmatch () и Re.match ()?
 
Методы Re.fullmatch (шаблон, строка) и Re.match (шаблон, строка) оба возвращают объект совпадения. Оба попытки соответствовать в начале строки. Единственное отличие заключается в том, что Re.fullmatch () также пытается подобрать конец строки: он хочет сопоставить всю строку!
 
Вы можете увидеть эту разницу в следующем коде:
 
>>> text = 'More with less'
>>> re.match('More', text)

>>> re.fullmatch('More', text)
>>>
 
Метод Re.match («Дополнитель», Text) соответствует строке «больше» в начале строки «больше с меньшими». Но метод Re.fullmatch («Еже», текст) не соответствует цельному тексту. Следовательно, он возвращает объект NOTE - ничего не напечатано в вашу оболочку!
 
В чем разница между Re.fullmatch () и Re.findall ()?
 
Существует два различия между Re.fullmatch (Pattern, Strattion) и Re.findall (шаблон, строки) методами:
 
Re.fullmatch (шаблон, строка) Возвращает объект совпадения, когда re.findall (шаблон, строка) возвращает список соответствующих строк.
 
Re.fullmatch (шаблон, строка) может соответствовать всей строке, в то время как Re.findall (шаблон, строка) может вернуть несколько совпадений в строке.
 
Оба можно увидеть в следующем примере:
 
>>> text = 'the 42th truth is 42'
>>> re.fullmatch('.*?42', text)

>>> re.findall('.*?42', text)
['the 42', 'th truth is 42']
 
Обратите внимание, что Regex. *? соответствует произвольному количеству персонажей, но он пытается потреблять как можно меньше персонажей. Это называется «не жадный» матч (*? Оператор). Метод FullMatch () возвращает только объект совпадения, который соответствует всей строке. Метод findall () возвращает список всех вхождений. Как матч не жадный, он находит два таких матча.
 
В чем разница между Re.fullmatch () и Re.Search ()?
 
Методы Re.fullmatch () и Re.Search (шаблон, строка) оба возвращают объект совпадения. Тем не менее, Re.fullmatch () пытается сопоставить всю строку во время Re.Search () в любой точке строки.
 
Вы можете увидеть эту разницу в следующем коде:
 
>>> text = 'Finxter is fun!'
>>> re.search('Finxter', text)

>>> re.fullmatch('Finxter', text)
>>>
 
Метод Re.Search () извлекает совпадение подстроки Finxter 'в качестве объекта совпадения. Но метод Re.fullmatch () не имеет возвращаемого значения, потому что подстрочка 'finxter' не соответствует целой строке 'Finxter - это весело!'.
 
Резюме
 
Теперь вы знаете метод Re.fullmatch (Pattern, String), который пытается сопоставить всю строку и возвращает объект совпадения, если он удается или нет, если это не так.
 
компилировать ()
 
Эта статья все о Re.compile (Pattern) Метод Python Re библиотека Отказ Прежде чем нырять в Re.compile (), давайте получим обзор четырех связанных методов, которые вы должны понимать:
 
 findall (шаблон, строка) Метод возвращает список строковых совпадений.
 
 Поиск (шаблон, строка) Метод возвращает объект совпадения первого матча. Матч (шаблон, строка) Метод Возвращает объект совпадения, если установки Regeex в начале строки.
 
 FullMatch (шаблон, строка) Метод возвращает объект совпадения, если Regeex соответствует всей строке.
 
Оснащен этим быстрым обзором наиболее критически важных методов Regex, давайте ответим на следующий вопрос:
 
Как работает re.compile () в Python?
 
Метод Re.compile (Pattern) возвращает объект регулярного выражения (см. Следующий раздел)
 
Затем вы используете объект, чтобы вызвать важные методы Regex, такие как поиск (строка), совпадение (String), Fullmatch (String) и Findall (String).
 
Короче говоря: вы компилируете шаблон сначала. Вы ищете шаблон в строке второй.
 
Этот двухэтапный подход более эффективен, чем вызов, скажем, поиск (шаблон, строка) одновременно. То есть Если вы называете метод поиска () несколько раз на один и тот же шаблон Отказ Почему? Потому что вы можете повторно использовать скомпилированный шаблон несколько раз.
 
Вот пример:
 
import re

# These two lines ...
regex = re.compile('Py...n')
match = regex.search('Python is great')

# ... are equivalent to ...
match = re.search('Py...n', 'Python is great')
 
В обоих случаях переменная матча содержит следующий объект совпадения:
 
 
Но в первом случае мы можем найти шаблон не только в строке «Python - это здорово», но и в других строках - без какой-либо избыточной работы составления шаблона снова и снова.
 
Спецификация :
 
re.compile(pattern, flags=0)
 
Метод имеет до двух аргументов.
 
шаблон : Регулярное выражение выражения, которое вы хотите сопоставить.
 
Флаги (Необязательный аргумент): более продвинутый модификатор, который позволяет настроить поведение функции. Хотите знать Как использовать эти флаги? Проверьте эту подробную статью на блог Finxter.
 
Мы подробно рассмотрим эти аргументы позже.
 
Возвращаемое значение:
 
Метод Re.comPile (Paills, Flags) возвращает объект регулярного выражения. Вы можете спросить (и правильно):
 
Какой объект регулярного выражения?
 
Python внутренне создает Объект регулярного выражения (Из класса шаблона) для подготовки процесса соответствия шаблона. Вы можете вызвать следующие методы на объекте Regex:
 

  

    

      
Метод
      
Описание
    
    

      
Pattern.Search (строка [, POS [, ENDPOS]])
      
Ищется Regex в любом месте строки и возвращает объект совпадения или нет. Вы можете определить начальные и конечные позиции поиска.
    
    

      
Pattern.match (строка [, pos [, endpos]]))
      
Ищет регулярное выражение в начале строки и возвращает объект матча или нет. Вы можете определить начальные и конечные позиции поиска.
    
    

      
Pattern.fullmatch (строка [, POS [, ENDPOS]])
      
Соответствует Regex со всей строкой и возвращает объект Match или None. Вы можете определить начальные и конечные позиции поиска.
    
    

      
Pattern.split (строка)
      
Делит строку в список подстроки. Regex - разделитель. Вы можете определить максимальное количество расщеплений.
    
    

      
Pattern.findall (строка [, POS [, ENDPOS]]))
      
Выполнивает Regex в любом месте строки и возвращает список подходящих подстрок. Вы можете определить начальные и конечные позиции поиска.
    
    

      
Pattern.finditer (строка [, POS [, ENDPOS]]))
      
Возвращает итератор, который переходит на все спички Regex в строке (возвращает один объект совпадения за другим). Вы можете определить начальные и конечные позиции поиска.
    
    

      
Package.sub (rep, string,)
      
Возвращает новую строку, заменив первые вхождения вхождения Regex в строке (слева направо) с помощью замены String Rep.
    
    

      
Pattern.subn (rep, string,)
      
Возвращает новую строку, заменив первые вхождения вхождения Regex в строке (слева направо) с помощью замены String Rep. Однако он возвращает кортеж с замененной строкой в качестве первого и количества успешных замен в качестве второго значения кортежа.
    
  
 
Если вы знакомы с наиболее основными методами Regex, вы поймете, что все они появляются в этой таблице. Но есть одно различие: вам не нужно определять шаблон как аргумент. Например, метод Regex Re.Search (Pattern, String) предоставит внутренне компилировать объект REGEX P и затем вызов P.Search (String).
 
Вы можете увидеть этот факт в официальной реализации метода Re.Search (Pattern, String):
 
def search(pattern, string, flags=0):
    """Scan through string looking for a match to the pattern, returning
    a Match object, or None if no match was found."""
    return _compile(pattern, flags).search(string)
 
(Источник: репозиторий GitHub повторной упаковки)
 
Метод Re.Search (Pattern, String) - это простое обертку для первого составления шаблона и вызова функции P.Search (String) на скомпилированном объекте REGEX P.
 
Стоит ли использовать Python's Re.compile ()?
 
Нет, в подавляющем большинстве случаев, это не стоит дополнительной линии.
 
Рассмотрим следующий пример:
 
import re

# These two lines ...
regex = re.compile('Py...n')
match = regex.search('Python is great')

# ... are equivalent to ...
match = re.search('Py...n', 'Python is great')
 
Не поймите меня неправильно. Составление рисунка один раз и используя его много раз на протяжении всего вашего кода (например, в цикле) поставляется с большим преимуществом производительности. В некоторых случаях анекдота, составление шаблона сначала привести к 10x до 50x Speedup по сравнению с составлением его снова и снова.
 
Но причина, по которой она не стоит дополнительной линии, это то, что библиотека Python Re Bistance с внутренним кэшем. Во время этого письма кэш имеет ограничение до 512 скомпилированных объектов REGEX. Таким образом, для первых 512 раз вы можете быть уверены при вызове Re.Search (Pattern, String), что кэш уже содержит скомпилированный шаблон.
 
Вот соответствующий кодовый фрагмент из Репозиторий Re's Github :
 
# --------------------------------------------------------------------
# internals

_cache = {}  # ordered!

_MAXCACHE = 512
def _compile(pattern, flags):
    # internal: compile pattern
    if isinstance(flags, RegexFlag):
        flags = flags.value
    try:
        return _cache[type(pattern), pattern, flags]
    except KeyError:
        pass
    if isinstance(pattern, Pattern):
        if flags:
            raise ValueError(
                "cannot process flags argument with a compiled pattern")
        return pattern
    if not sre_compile.isstring(pattern):
        raise TypeError("first argument must be string or compiled pattern")
    p = sre_compile.compile(pattern, flags)
    if not (flags & DEBUG):
        if len(_cache) >= _MAXCACHE:
            # Drop the oldest item
            try:
                del _cache[next(iter(_cache))]
            except (StopIteration, RuntimeError, KeyError):
                pass
        _cache[type(pattern), pattern, flags] = p
    return p
 
Можете ли вы найти места, где кэш инициализируется и используется?
 
В большинстве случаев вам не нужно компилировать шаблон в некоторых случаях. Они следуют непосредственно из предыдущей реализации:
 
У вас есть больше, чем узоры MaxCache в вашем коде.
 
У тебя больше, чем maxcache разные Шаблоны между двумя то же самое экземпляры схема. Только в этом случае вы увидите «пропустить кэш», где кэш уже прократил, казалось бы, скорейшие экземпляры шаблонов, чтобы освободить место для более новых.
 
Вы используете шаблон несколько раз. Потому что, если вы этого не сделаете, не имеет смысла использовать редкую память, чтобы сохранить их в вашей памяти.
 
(Даже тогда это может быть полезно только в том случае, если узоры относительно сложны. В противном случае вы не увидите много преимуществ производительности на практике.)
 
Чтобы обобщить, сначала компиляцию шаблона и хранение скомпилированного рисунка в переменной для более позднего использования часто бывает ничего, кроме «преждевременной оптимизации», - одна из смертных грехов начинающих и промежуточных программиров.
 
Что делает Re.compile () действительно?
 
Это не кажется много, не делает это? Моя интуиция заключалась в том, что реальная работа находится в нахождении шаблона в тексте, который происходит после компиляции. И, конечно же, сопоставляя шаблон это тяжелая часть. Но разумная компиляция много помогает приготовить шаблон, который должен быть эффективно сопутствуется с помощью двигателя Regex, которая в противном случае была бы выполнена двигателем Regex.
 
Метод Compile () Regex () делает много вещей, таких как:
 
Объедините два последующих символа в Regex, если они вместе указывают на особый символ, такой как определенные греческие символы.
 
Приготовьте регельс, чтобы игнорировать прописные и строчные.
 
Проверьте на определенные (меньшие) шаблоны в Regex.
 
Анализируйте соответствующие группы в Regex, заключенном в скобки.
 
Реализация метода Compile () не легко читать (поверь мне, я пытался). Он состоит из многих разных шагов.
 
Просто отметьте, что вся эта работа должна быть сделана двигателем Regex в «Соответствующем времени выполнения», если вы сначала не скомпилируйте шаблон. Если мы сможем сделать это только один раз, это, безусловно, с низким виселом для оптимизации производительности - особенно для длительного регулярного выражения.
 
Как использовать дополнительный аргумент флага?
 
Как вы видели в спецификации, метод Compile () поставляется с необязательным третьим аргументом «Флаг»:
 
re.compile(pattern, flags=0)
 
Вот как бы вы использовали его в практическом примере:
 
import re

text = 'Python is great (python really is)'

regex = re.compile('Py...n', flags=re.IGNORECASE)

matches = regex.findall(text)
print(matches)
# ['Python', 'python']
 
Хотя ваше Regeex «Python» является прописным в верхнем регистре, мы игнорируем капитализацию, используя флаг Re.ignorecase.
 
Резюме
 
Вы узнали о методе Re.comPile (Pattern), который готовит шаблон регулярной экспрессии - и возвращает объект Regex, который вы можете использовать несколько раз в вашем коде.
 
расколоть()
 
Почему регулярные выражения пережили семь десятилетий технологического разрушения? Поскольку кодеры, которые понимают регулярные выражения, имеют огромное преимущество при работе с текстовыми данными. Они могут написать в одной строке кода, что делает других десятков!
 
Эта статья все о Re.Split (шаблон, строка) метод Библиотека Python's Re.
 
Давайте ответим на следующий вопрос:
 
Как работает re.Split () в Python?
 
Метод Re.Split (Pattern, String, string,) Возвращает список строк, сопоставив все вхождения шаблона в строке и разделив строку вдоль тех.
 
Вот минимальный пример:
 
>>> import re
>>> string = 'Learn Python with\t     Finxter!'
>>> re.split('\s+', string)
['Learn', 'Python', 'with', 'Finxter!']
 
Строка содержит четыре слова, разделенные персонажами пробелов (в частности: пустое пространство «» и табличным символом «\ T»). Вы используете регулярное выражение «\ S +», чтобы соответствовать всем вхождению положительного числа последующих пробелов. Соответствующие подстроки служат разграничителями. Результатом является строка, разделенная вдоль этих разделителей.
 
Но это не все! Давайте посмотрим на официальное определение метода разделения.
 
Спецификация
 
re.split(pattern, string, maxsplit=0, flags=0)
 
Способ имеет четыре аргумента - два из которых являются необязательными.
 
шаблон : Шаблон регулярного выражения, который вы хотите использовать в качестве разделителя.
 
строка : текст, который вы хотите разрушить в список строк.
 
maxsplit (Необязательный аргумент): максимальное количество размеров разделенных операций возвращаемого списка). По умолчанию аргумент MaxSplit 0, что означает, что он игнорируется.
 
Флаги (Необязательный аргумент): более продвинутый модификатор, который позволяет настроить поведение функции. По умолчанию модуль Regex не считает никаких флагов. Хотите знать Как использовать эти флаги? Проверьте эту подробную статью на блог Finxter.
 
Первые и второе аргументы требуются. Третий и четвертый аргументы являются необязательными.
 
Вы узнаете о этих аргументах более подробно позже.
 
Возвращаемое значение:
 
Метод разделения REGEX возвращает список подстроек, полученных с помощью Regex в качестве разделителя.
 
Regex разделен минимальный пример
 
Давайте изучим еще несколько примеров - от простых до сложных.
 
Самое простое использование состоит в том, что только два аргумента: разделитель Regex и строка для разделения.
 
>>> import re
>>> string = 'fgffffgfgPythonfgisfffawesomefgffg'
>>> re.split('[fg]+', string)
['', 'Python', 'is', 'awesome', '']
 
Вы используете произвольное количество символов «F» или «G» в качестве разделителей регулярных выражений. Как вы это делаете? Объединяя класс символов Regex [A] и одно или более Regex A + в следующее Regex: [FG] +. Строки между между ними добавляются в список возврата.
 
Как использовать аргумент MaxSplit?
 
Что, если вы не хотите разделить всю строку, но только ограниченное количество раз. Вот пример:
 
>>> string = 'a-bird-in-the-hand-is-worth-two-in-the-bush'
>>> re.split('-', string, maxsplit=5)
['a', 'bird', 'in', 'the', 'hand', 'is-worth-two-in-the-bush']
>>> re.split('-', string, maxsplit=2)
['a', 'bird', 'in-the-hand-is-worth-two-in-the-bush']
 
Мы используем простое разделитель Regex '-', чтобы разделить строку в подстроки. В первом вызове метода мы устанавливаем, чтобы получить шесть элементов списка. Во втором вызове метода мы установили, чтобы получить три элемента списка. Можете ли вы увидеть шаблон?
 
Вы также можете использовать позиционные аргументы для сохранения некоторых символов:
 
>>> re.split('-', string, 2)
['a', 'bird', 'in-the-hand-is-worth-two-in-the-bush']
 
Но столько кодеров не знают о аргументе MaxSPlit, вы, вероятно, должны использовать аргумент ключевых слов для чтения.
 
Как использовать дополнительный аргумент флага?
 
Как вы видели в спецификации, метод Re.Split () поставляется с дополнительным аргументом «Флаг»:
 
re.split(pattern, string, maxsplit=0, flags=0)
 
Вот как бы вы использовали его на практике:
 
>>> import re
>>> re.split('[xy]+', text, flags=re.I)
['the', 'russians', 'are', 'coming']
 
Хотя ваше регулярное выражение строчное, мы игнорируем капитализацию, используя флаг Re.i, который коротко для Re.ignorecase. Если бы мы этого не сделали, результат будет совсем другим:
 
>>> re.split('[xy]+', text)
['theXXXYYYrussiansXX', 'are', 'Y', 'coming']
 
Поскольку класс символов [XY] содержит только символы Lowerspace символов «x» и «y», их заглавные варианты появляются в возвращенном списке, а не используется в качестве разделителей.
 
В чем разница между Re.Split () и String.Split () методами в Python?
 
Метод Re.Split () гораздо мощнее. Метод Re.Split (Pattern, String) может разделить строку вдоль всех вхождений сопоставленного шаблона. Шаблон может быть произвольно сложен. Это в отличие от метода string.split (разделитель), который также разделяет строку в подстроки вдоль разделителя. Однако разделитель должен быть нормальной строкой.
 
Пример, где более мощный метод Re.Split () превосходит, находится в разделении текста вдоль любых пробеловных символов:
 
import re


text = '''
    Ha! let me see her: out, alas! he's cold:
    Her blood is settled, and her joints are stiff;
    Life and these lips have long been separated:
    Death lies on her like an untimely Frost
    Upon the sweetest flower of all the field.
'''

print(re.split('\s+', text))
'''
['', 'Ha!', 'let', 'me', 'see', 'her:', 'out,', 'alas!',
"he's", 'cold:', 'Her', 'blood', 'is', 'settled,', 'and',
'her', 'joints', 'are', 'stiff;', 'Life', 'and', 'these',
'lips', 'have', 'long', 'been', 'separated:', 'Death',
'lies', 'on', 'her', 'like', 'an', 'untimely', 'Frost',
'Upon', 'the', 'sweetest', 'flower', 'of', 'all', 'the',
'field.', '']
'''
 
Метод Re.Split () делит строку вдоль любого положительного числа пробеловных символов. Вы не смогли добиться такого результата с String.Split (разделитель), потому что разделитель должен быть строкой с постоянной размером.
 
Резюме
 
Вы узнали о методе Re.Split (Pattern, String), который разделяет строку вдоль сопоставленных вхождений шаблонов и возвращает список подстроки.
 
Sub ()
 
Хотите заменить все вхождения шаблона в строке? Ты в нужном месте! Эта статья все о re.sub (шаблон, строка) Метод Python Re библиотека Отказ
 
Давайте ответим на следующий вопрос:
 
Как работает re.sub () в Python?
 
Метод Re.Sub (Pattern, Repl, String ,,) Возвращает новую строку, в которой все вхождения шаблона в старой строке заменены на REPL.
 
Вот минимальный пример:
 
>>> import re
>>> text = 'C++ is the best language. C++ rocks!'
>>> re.sub('C\+\+', 'Python', text)
'Python is the best language. Python rocks!'
>>>
 
Текст содержит два вхождения строки «C ++». Вы используете метод re.sub () для поиска всех этих вхождений. Ваша цель - заменить все те, которые с новой строкой «Python» (Python - лучший язык в конце концов).
 
Обратите внимание, что вы должны избежать символа «+» в «C ++», как иначе это будет означать по крайней мере один  Regex Отказ
 
Вы также можете увидеть, что метод Sub () заменяет все сопоставленные шаблоны в строке - не только первый.
 
Но есть больше! Давайте посмотрим на официальное определение метода Sub ().
 
Спецификация
 
re.sub(pattern, repl, string, count=0, flags=0)
 
Способ имеет четыре аргумента - два из которых являются необязательными.
 
шаблон : Шаблон регулярного выражения для поиска строк, которые вы хотите заменить.
 
Реп : замена строки или функция. Если это функция, она должна принять один аргумент (объект матча), который передается для каждого возникновения шаблона. Возвращаемое значение функции замены представляет собой строку, которая заменяет соответствующую подстроку.
 
строка : текст, который вы хотите заменить.
 
Считать (Дополнительный аргумент): максимальное количество замены, которые вы хотите выполнить. По умолчанию вы используете который читается как Заменить все вхождения шаблона Отказ
 
Флаги (Дополнительный аргумент): более продвинутый модификатор, который позволяет настроить поведение метода. По умолчанию вы не используете никаких флагов.
 
Первоначальные три аргумента необходимы. Остальные два аргумента являются необязательными.
 
Вы узнаете о этих аргументах более подробно позже.
 
Возвращаемое значение:
 
Новая строка, где Считать вхождения первых подстрок, которые соответствуют шаблон заменены строковым значением, определенным в Реп аргумент
 
Regex Sub Минимальный пример
 
Давайте изучим еще несколько примеров - от простых до сложных.
 
Самое простое использование - это только три аргумента: шаблон «петь», строка замены «программа» и строка, которую вы хотите изменить (текст в нашем примере).
 
>>> import re
>>> text = 'Learn to sing because singing is fun.'
>>> re.sub('sing', 'program', text)
'Learn to program because programing is fun.'
 
Просто не игнорируйте ошибку грамматики на данный момент. Вы получаете точку: мы не будем петь, мы программируем.
 
Но что, если вы хотите на самом деле исправить эту ошибку грамматики? В конце концов, это Программирование , не Программирование Отказ В этом случае нам необходимо заменить «петь» с «программой» в некоторых случаях и «петь» с «программой» в других случаях.
 
Вы видите, где это приводит нас: подпунктив должен быть функцией! Итак, давайте попробуем это:
 
import re


def sub(matched):
    if matched.group(0)=='singing':
        return 'programming'
    else:
        return 'program'


text = 'Learn to sing because singing is fun.'
print(re.sub('sing(ing)?', sub, text))
# Learn to program because programming is fun.
 
В этом примере вы сначала определяете функцию подстановки Sub. Функция принимает соответствующий объект в качестве ввода и возвращает строку. Если он соответствует более длинному «пению», он возвращает «программирование». Иначе он соответствует более короткой форме «петь», поэтому вместо этого она возвращает более короткую строку замены «программа».
 
Как использовать подсчет аргумента метода Regeex?
 
Что делать, если вы не хотите заменить все вхождения узора, но только ограниченное количество их? Просто используйте Считать АРУДА! Вот пример:
 
>>> import re
>>> s = 'xxxxxxhelloxxxxxworld!xxxx'
>>> re.sub('x+', '', s, count=2)
'helloworld!xxxx'
>>> re.sub('x+', '', s, count=3)
'helloworld!'
 
В первой операции замены вы заменяете только два вхождения шаблона «x +». Во-вторых, вы заменяете все три.
 
Вы также можете использовать позиционные аргументы для сохранения некоторых символов:
 
>>> re.sub('x+', '', s, 3)
'helloworld!'
 
Но столько кодеров не знают о Считать Аргумент, вы, вероятно, должны использовать аргумент ключевых слов для читабельности.
 
Как использовать дополнительный аргумент флага?
 
Как вы видели в спецификации, метод Re.Sub () поставляется с необязательной четвертой Флаг Аргумент:
 
re.sub(pattern, repl, string, count=0, flags=0)
 
Какова цель аргумента флагов?
 
Флаги позволяют управлять регулярным механизмом выражения. Поскольку регулярные выражения настолько мощны, они являются полезным способом включения и отключения определенных функций (например, следует ли игнорировать капитализацию при сопоставлении вашего Regex).
 
Вот как вы будете использовать аргумент флагов в минимальном примере:
 
>>> import re
>>> s = 'xxxiiixxXxxxiiixXXX'
>>> re.sub('x+', '', s)
'iiiXiiiXXX'
>>> re.sub('x+', '', s, flags=re.I)
'iiiiii'
 
Во второй операции замены вы игнорируете капитализацию, используя флаг Re.i, который коротко для Re.ignorecase. Вот почему это заменит даже верхние символы «X», которые сейчас соответствуют Regex 'X +'.
 
В чем разница между регелем Sub и String заменить?
 
В некотором смысле, метод Re.Sub () является более мощным вариантом метода String.replace (), который подробно описан в этой статье блога Finxter.
 
Почему? Поскольку вы можете заменить все вхождения рисунка Regex, а не только все вхождения строки в другой строке.
 
Так что с Re.Sub () вы можете сделать все, что вы можете сделать со String.replace () Но некоторые вещи больше!
 
Вот пример:
 
>>> 'Python is python is PYTHON'.replace('python', 'fun')
'Python is fun is PYTHON'
>>> re.sub('(Python)|(python)|(PYTHON)', 'fun', 'Python is python is PYTHON')
'fun is fun is fun'
 
Метод String.replace () заменяет только нижние слова «Python», в то время как метод re.sub () заменяет все вхождения верхних или строчных вариантов.
 
Примечание, вы можете сделать то же самое еще проще с Флаги аргумент
 
>>> re.sub('python', 'fun', 'Python is python is PYTHON', flags=re.I)
'fun is fun is fun'
 
Как удалить рисунок Regex в Python?
 
Ничего проще, чем это. Просто используйте пустую строку как строку замены:
 
>>> re.sub('p', '', 'Python is python is PYTHON', flags=re.I)
'ython is ython is YTHON'
 
Вы заменяете все вхождения шаблона «p» с пустой строкой «. Другими словами, вы удалите все вхождения« p ». Как вы используете аргумент .i, вы игнорируете капитализацию.
 
Резюме
 
Вы узнали метод re.sub (pattern, reft, string ,,), возвращает новую строку, в которой все вхождения шаблона в старой строке заменены на REPL.
 
Точечный оператор.
 
Вы собираетесь узнать один из самых часто используемых операторов Regex: Dot Regex Отказ в Python's Re библиотека Отказ
 
Что такое Dot Regex в библиотеке Python Re?
 
Dot Regex. соответствует всем персонажам, кроме символа Newline. Например, регулярное выражение «...» соответствует строкам «Эй» и «Том» Отказ Но это не соответствует строке 'Йо \ Ntom' который содержит новенький символ '\ N' Отказ
 
Давайте изучим некоторые основные примеры, чтобы помочь вам получить более глубокое понимание.
 
>>> import re
>>> 
>>> text = '''But then I saw no harm, and then I heard
Each syllable that breath made up between them.'''
>>> re.findall('B..', text)
['But']
>>> re.findall('heard.Each', text)
[]
>>> re.findall('heard\nEach', text)
['heard\nEach']
>>>
 
Вы сначала импортируете библиотеку Python Re для регулярного обращения с выражением. Затем вы создаете многострочный текст, используя цитаты Triple String.
 
Давайте погрузимся в первый пример:
 
>>> re.findall('B..', text)
['But']
 
Вы используете метод Re.findall (Pattern, String), который находит все вхождения шаблона в строке и возвращает список всех подходящих подстроек.
 
Первый аргумент - это шаблон регулярного выражения 'B ..' Отказ Второй аргумент - это строка для поиска шаблона. Вы хотите найти все шаблоны, начиная с символа «B», а затем два произвольных символа, кроме символа Newline.
 
Метод findall () находит только одно такое явление: строку «но».
 
Второй пример показывает, что оператор DOT не соответствует символу Newline:
 
>>> re.findall('heard.Each', text)
[]
 
В этом примере вы смотрите на простой шаблон «слышно. Вы хотите найти все вхождения строки «слышали», а затем произвольный символ без пробела, а затем строку «каждый».
 
Но такой узор не существует! Многие кодеры интуитивно читают точечное регулярное выражение как произвольный характер Отказ Вы должны знать, что правильное определение Dot Regex - это произвольный характер, кроме новой строки Отказ Это источник многих ошибок в регулярных выражениях.
 
Третий пример показывает, как явно соответствовать новой строке символа «\ N»:
 
>>> re.findall('heard\nEach', text)
['heard\nEach']
 
Теперь двигатель Regex соответствует подстроке.
 
Естественно, возникает следующий актуальный вопрос:
 
Как сопоставить произвольный персонаж (включая новую строку)?
 
Dot Regex. соответствует одному произвольному характеру, кроме символа Newline. Но что, если вы хотите подобрать новенький персонаж тоже? Есть два основных способа достичь этого.
 
Используйте Re.dotall флаг.
 
Используйте класс символов [. \ N] Отказ
 
Вот конкретный пример, показывающий оба случая:
 
>>> import re
>>> 
>>> s = '''hello
python'''
>>> re.findall('o.p', s)
[]
>>> re.findall('o.p', s, flags=re.DOTALL)
['o\np']
>>> re.findall('o[.\n]p', s)
['o\np']
 
Вы создаете многострочную строку. Затем вы пытаетесь найти рисунок Regex 'O.P' в строке. Но нет совпадения, потому что оператор DOT не соответствует новичкому символу по умолчанию. Однако, если вы определяете флаг RE.DOTALL, символ Newline также будет действительным совпадением.
 
Альтернативой состоит в том, чтобы использовать чуть более сложный рисунок Regex [. \ N]. Квадратные скобки прилагают Класс персонажей - Набор символов, которые являются действительным совпадением. Подумайте о классе персонажа как и или операция: точно один символ должен совпадать.
 
Что делать, если вы действительно хотите сопоставить точку?
 
Если вы используете символ '.' В регулярном выражении Питон предполагает, что это точечный оператор, о котором вы говорите. Но что, если вы действительно хотите сопоставить точку, например, чтобы соответствовать периоду в конце предложения?
 
Ничего проще, чем это: избежать точечного регулятора, используя обратную косание: '\.' Отказ Обратная черта не обнаруживает смысл специального символа ". ' в Regex. Двигатель Regex теперь знает, что вы на самом деле ищете точечный персонаж, а не произвольный символ, кроме новой строки.
 
Вот пример:
 
>>> import re
>>> text = 'Python. Is. Great. Period.'
>>> re.findall('\.', text)
['.', '.', '.', '.']
 
Метод findall () возвращает все четыре периода в предложении в качестве соответствующих подстроек для Regex '\.' Отказ
 
В этом примере вы узнаете, как вы можете объединить его с другими регулярными выражениями:
 
>>> re.findall('\.\s', text)
['. ', '. ', '. ']
 
Теперь вы ищете период срока, а затем произвольный пробел. В тексте только три таких соответствующих подстроки.
 
В следующем примере вы узнаете, как объединить это с классом персонажа:
 
>>> re.findall('[st]\.', text)
['s.', 't.']
 
Вы хотите найти либо персонаж или символ «T», а затем символ периода ». '. Две подстроки соответствуют этому Regex.
 
Обратите внимание, что пропуская обратная косание требуется. Если вы забудете это, это может привести к странному поведению:
 
>>> re.findall('[st].', text)
['th', 's.', 't.']
 
В качестве произвольного символа разрешено после класса символов, подстрок «Th» также соответствует Regex.
 
Резюме
 
Вы узнали все, что вам нужно знать о Dot Regex. В этом руководстве.
 
Резюме : Точечное регулярное выражение. соответствует всем персонажам, кроме символа Newline. Например, регулярное выражение «...» соответствует строкам «Эй» и «Том» Отказ Но это не соответствует строке 'Йо \ Ntom' который содержит новенький символ '\ N' Отказ
 
Оператор Звездочки *
 
Каждый компьютерный ученый знает вентилификатор звездочка регулярных выражений. Но многие не техники это тоже знают. Каждый раз, когда вы ищете текстовый файл * .txt на вашем компьютере, вы используете оператор Asterisk.
 
Этот раздел все о Asterisk * Quantifier.
 
Какой квантификатор Python Re *?
 
При применении к регулярному выражению А , Питон A * Контификатор соответствует нулю или более вхождению А Отказ * Quantifier называется Звездочный оператор И это всегда относится только к предыдущему регулярному выражению. Например, регулярное выражение «Да *» соответствует строкам 'ye' , «Да» и «YESSSSSSS» Отказ Но это не соответствует пустой строке, потому что asterisk Quantifier * не распространяется на все Regex «Да» Но только до предшествующего регеляции 'S' Отказ
 
Давайте изучим два основных примера, чтобы помочь вам получить более глубокое понимание. Вы все их получаете?
 
>>> import re
>>> text = 'finxter for fast and fun python learning'
>>> re.findall('f.* ', text)
['finxter for fast and fun python ']
>>> re.findall('f.*? ', text)
['finxter ', 'for ', 'fast ', 'fun ']
>>> re.findall('f[a-z]*', text)
['finxter', 'for', 'fast', 'fun']
>>>
 
Не волнуйтесь, если у вас были проблемы, понимая эти примеры. Вы узнаете о них дальше. Вот первый пример:
 
Пример жадного звездочка
 
>>> re.findall('f.* ', text)
['finxter for fast and fun python ']
 
Первый аргумент метода Re.findall () является регулярным рисунком выражения 'f. *' Отказ Второй аргумент - это строка для поиска шаблона. На простом английском языке вы хотите найти все шаблоны в строке, которая начинается с символа «F», а затем произвольное количество необязательных символов, а затем пустое пространство.
 
Метод findall () возвращает только одну соответствующую подстроку: 'Finxter для быстрого и веселого Python' Отказ Quantifier Asterisk * жадный. Это означает, что он пытается сопоставить как можно больше вхождений предыдущего регулятора. Таким образом, в нашем случае он хочет сопоставить как можно больше произвольных персонажей, чтобы узор до сих пор подобран. Следовательно, двигатель Regex «потребляет» все предложение.
 
Пример не жадного звездочка
 
Но что, если вы хотите найти все слова, начиная с «F»? Другими словами: как сопоставить текст с не жадным оператором Asterisk?
 
Второй пример следующий:
 
>>> re.findall('f.*? ', text)
['finxter ', 'for ', 'fast ', 'fun ']
 
В этом примере вы смотрите на аналогичный образец только с одним разницей: вы используете не жадный оператор Asterisk *? Отказ Вы хотите найти все вхождения символов F 'F', за которым следуют произвольное количество символов (но как можно меньше), а затем пустое пространство.
 
Следовательно, двигатель REGEX находит четыре матча: «Финктер Строки», «для», «быстрая» и «веселье».
 
Asterisk + Пример символов
 
Третий пример следующий:
 
>>> re.findall('f[a-z]*', text)
['finxter', 'for', 'fast', 'fun']
 
Это Regeex достигает почти то же самое: нахождение всех слов, начиная с f. Но вы используете квантификатор Asterisk в сочетании с классом символов, который конкретно определяет, какие символы являются действительными совпадениями.
 
В классе персонажа вы можете определить диапазоны символов. Например, диапазон символов [A-Z] соответствует одному символу строчных букв в алфавите, когда диапазон символов [A-Z] соответствует одному прописному символу в алфавите.
 
Но обратите внимание, что пустое пространство не является частью класса символов, поэтому он не будет соответствовать, если оно появится в тексте. Таким образом, результат является одним и тем же списком слов, начинающихся с символа F: «Finxter», «для ',« быстрая »и« веселье ».
 
Что, если вы хотите подобрать саму персонаж Asterisk?
 
Вы знаете, что квантификатор Asterisk соответствует произвольному числу предыдущего регулярного выражения. Но что, если вы ищете сам персонаж звездочки (или звезды)? Как вы можете искать его в строке?
 
Ответ прост: избегайте символа звездочка в регулярном выражении, используя обратную косание. В частности, используйте «\ *» вместо «*». Вот пример:
 
>>> import re
>>> text = 'Python is ***great***'
>>> re.findall('\*', text)
['*', '*', '*', '*', '*', '*']
>>> re.findall('\**', text)
['', '', '', '', '', '', '', '', '', '', '***', '', '', '', '', '', '***', '']
>>> re.findall('\*+', text)
['***', '***']
 
Вы найдете все вхождения символа Star в тексте, используя Regex '\ *'. Следовательно, если вы используете Regex '\ **', вы ищете произвольное количество вхождений символа звездочки (включая нулевые вхождения). И если вы хотите найти все максимальное количество вхождений последующих символов Asterisk в тексте, вы бы использовали Regex '\ * +'.
 
В чем разница между Python Re * и? Количественные кванты?
 
Вы можете прочитать Python Re a? квантификатор как нулевое или одно регез : Предыдущее Regex a соответствует нулевым временам, либо точно один раз. Но это не совсем не совсем не совсем.
 
Аналогично, вы можете прочитать оператор Python Re * как нулевое или больше регеекс (Я знаю, что это звучит немного неуклюжем): предыдущее регулярное выражение поднимается произвольным количеством раз.
 
Вот пример, который показывает разницу:
 
>>> import re
>>> re.findall('ab?', 'abbbbbbb')
['ab']
>>> re.findall('ab*', 'abbbbbbb')
['abbbbbbb']
 
Regex 'AB?' Соответствует символу «A» в строке, за которым следует символ «B», если он существует (что он делает в коде).
 
Regex 'ab *' соответствует символу «A» в строке, а затем как можно больше символов B '.
 
В чем разница между Python Re * и + квантами?
 
Вы можете прочитать квантификатор Python Re * As нулевое или больше регеекс : Предыдущее Regex A соответствует произвольному количеству раз.
 
Аналогично, вы можете прочитать оператор Python Re A + как по крайней мере, когда регельс : Предыдущее Regex A также соответствует произвольному количеству раз, но, по крайней мере, один раз.
 
Вот пример, который показывает разницу:
 
>>> import re
>>> re.findall('ab*', 'aaaaaaaa')
['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']
>>> re.findall('ab+', 'aaaaaaaa')
[]
 
Regex 'ab *' соответствует символу «A» в строке, за которым следует новенький номер вхождения символов «B». Подстрока «A» прекрасно соответствует этой формулировке. Поэтому вы обнаружите, что Regeex совпадает с восемь раз в строке.
 
Regex 'AB +' соответствует персонажу «A», а затем как можно больше персонажей B ', но хотя бы один. Однако персонаж «B» не существует, так что нет совпадения.
 
Резюме : При применении к регулярному выражению А , Питон A * Контификатор соответствует нулю или более вхождению А Отказ Quevifier называется Asterisk оператор, и он всегда применяется только к предыдущему регулярному выражению. Например, регулярное выражение «Да *» соответствует строкам 'ye' , «Да» и «YESSSSSSS» Отказ Но это не соответствует пустой строке, потому что asterisk Quantifier * не распространяется на все Regex «Да» Но только до предшествующего регеляции 'S' Отказ
 
Оператор нуля или один: вопросительный знак (?)
 
Поздравляем, вы собираетесь изучать один из наиболее часто используемых операторов Regex: Quantifier Mark Rege А? Отказ
 
Что такое Python Re? Квантификатор
 
При применении к регулярному выражению А , Питон А?  квантификатор соответствует нулю или одному вхождению А Отказ ? Контификатор всегда применяется только к предыдущему регулярному выражению. Например, регулярное выражение 'Привет?' соответствует оба строкам «Он» и «Эй» Отказ Но это не соответствует пустой строке, потому что? Quantifier не распространяется на все Regex «Эй», но только к предшествующему Regex 'Y'.
 
Давайте изучим два основных примера, чтобы помочь вам получить более глубокое понимание. Вы все их получаете?
 
>>> import re
>>>
>>> re.findall('aa[cde]?', 'aacde aa aadcde')
['aac', 'aa', 'aad']
>>>
>>> re.findall('aa?', 'accccacccac')
['a', 'a', 'a']
>>>
>>> re.findall('[cd]?[cde]?', 'ccc dd ee')
['cc', 'c', '', 'dd', '', 'e', 'e', '']
 
Не волнуйтесь, если у вас были проблемы, понимая эти примеры. Вы узнаете о них дальше. Вот первый пример:
 
>>> re.findall('aa[cde]?', 'aacde aa aadcde')
['aac', 'aa', 'aad']
 
Вы используете метод re.findall (). Опять же, метод Re.Findall (Pattern, String) находит все вхождения шаблона в строке и возвращает список всех совпадающих подстроек.
 
Первый аргумент - это шаблон регулярного выражения 'AA [CDE]?' Отказ Второй аргумент - это строка для поиска шаблона. На простом английском языке вы хотите найти все шаблоны, которые начинаются с двух символов «A», за которыми следует один дополнительный символ, который может быть либо «C», «D», либо «E».
 
Метод findall () возвращает три подстрочных подстроки:
 
Сначала строка «AAC» соответствует шаблону. После того, как Python потребляет сопоставленную подстроку, оставшаяся подстрока - «de aa aadcde».
 
Во-вторых, строка «AA» соответствует шаблону. Python потребляет его, что приводит к оставшейся подстроке «AADCDE».
 
В-третьих, строка «AAD» соответствует шаблону в оставшейся подстроке. Что остается «CDE», который больше не содержит соответствующую подстроку.
 
Второй пример следующий:
 
>>> re.findall('aa?', 'accccacccac')
['a', 'a', 'a']
 
В этом примере вы смотрите на простой шаблон «аа?». Вы хотите найти все вхождения символа «A», а затем необязательный второй «A». Но имейте в виду, что необязательный второй «A» не нужен для шаблона, чтобы соответствовать.
 
Следовательно, двигатель REGEX находит три матча: символы «A».
 
Третий пример следующий:
 
>>> re.findall('[cd]?[cde]?', 'ccc dd ee')
['cc', 'c', '', 'dd', '', 'e', 'e', '']
 
Это рисунок Regex выглядит сложно: «CD]? [CDE]? '. Но это действительно?
 
Давайте сломаемся пошаговым шагом:
 
Первая часть Regex [CD]? Определяет класс символов [CD], который читается как «совпадение C или D». Контификатор вопросительного знака указывает, что вы хотите сопоставить один или нулевые вхождения этого шаблона.
 
Вторая часть Regex [CDE]? Определяет класс символов [CDE], который читается как «совпадение C, D или E». Опять же, вопрос вопросительного знака указывает на соответствие нулевой или одному требованию.
 
Поскольку обе части необязательны, пустая строка соответствует шаблону Regex. Тем не менее, попытки двигателя Python RegeX как можно больше Отказ
 
Таким образом, двигатель REGEX выполняет следующие шаги:
 
Первый матч в строке «CCC DD EE» является «CC». Двигатель Regex потребляет соответствующую подстроку, поэтому остается строка «C DD EE».
 
Второй матч в оставшейся строке - это символ «C». Пустое пространство «» не совпадает с регулярным выражением, поэтому вторая часть Regex [CDE] не совпадает. Из-за квантификатора вопросительного знака это нормально для двигателя Regex. Оставшаяся строка - «DD EE».
 
Третий матч - пустая строка «. Конечно, Python не пытается сопоставить одну и ту же позицию дважды. Таким образом, он перемещается на обработку оставшейся строки« DD EE ».
 
Четвертый матч - это строковая «DD». Оставшаяся строка «EE».
 
Пятый матч - это строка ". Оставшаяся строка" EE '.
 
Шестого матча - это строка «E». Оставшаяся строка «E».
 
Седьмой матч - это строка «E». Оставшаяся строка ".
 
Восьмой матч - это строка ". Ничего не остается.
 
Это было самым сложным для наших примеров. Поздравляю, если вы все это поняли!
 
В чем разница между Python Re? и * кванты?
 
Вы можете прочитать Python Re a? квантификатор как нулевое или одно регез : Предыдущее Regex a соответствует нулевым временам, либо точно один раз. Но это не совсем не совсем не совсем.
 
Аналогично, вы можете прочитать оператор Python Re * как Ноль-или-Многократное Regex (Я знаю, что это звучит немного неуклюжем): предыдущее регулярное выражение поднимается произвольным количеством раз.
 
Вот пример, который показывает разницу:
 
>>> import re
>>> re.findall('ab?', 'abbbbbbb')
['ab']
>>> re.findall('ab*', 'abbbbbbb')
['abbbbbbb']
 
Regex 'AB?' Соответствует символу «A» в строке, за которым следует символ «B», если он существует (что он делает в коде).
 
Regex 'ab *' соответствует символу «A» в строке, а затем как можно больше символов B '.
 
В чем разница между Python Re? и + кванты?
 
Вы можете прочитать Python Re a? квантификатор как нулевое или одно регез : Предыдущее Regex a соответствует нулевым временам, либо точно один раз. Но это не совсем не совсем не совсем.
 
Аналогично, вы можете прочитать оператор Python Re A + как по крайней мере, когда регельс : Предыдущее Regex A сопоставляется произвольным количеством раз, но, по крайней мере, один раз.
 
Вот пример, который показывает разницу:
 
>>> import re
>>> re.findall('ab?', 'aaaaaaaa')
['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']
>>> re.findall('ab+', 'aaaaaaaa')
[]
 
Regex 'AB?' Соответствует символу «A» в строке, за которым следует символ «B», если он существует - но он не в коде.
 
Regex 'AB +' соответствует символу «a» в строке, а затем как можно больше символов, но хотя бы один. Однако персонаж «B» не существует, так что нет совпадения.
 
Что такое Python Re *?, +? ?? Количественные кванты?
 
Вы узнали о трех квантах:
 
Контификатор A * соответствует произвольному количеству шаблонов A.
 
Контификатор A + соответствует хотя бы одному рисунку A.
 
Квантификатор а? соответствует шаблону нулевой или один A.
 
Эти три - все жадный : Они соответствуют максимально возможным вхождении шаблона. Вот пример, который показывает свою жадность:
 
>>> import re
>>> re.findall('a*', 'aaaaaaa')
['aaaaaaa', '']
>>> re.findall('a+', 'aaaaaaa')
['aaaaaaa']
>>> re.findall('a?', 'aaaaaaa')
['a', 'a', 'a', 'a', 'a', 'a', 'a', '']
 
Код показывает, что все три кванции *, + и? Сопоставьте как можно больше символов «A».
 
Итак, логический вопрос: как можно сопоставить как можно меньше? Мы называем это не жадный Соответствие. Вы можете добавить знак вопроса после соответствующих количественных квантов, чтобы сообщить двигателю Regex, который вы намереваетесь максимально сопоставить как можно меньше шаблонов: *?, +? И ??.
 
Вот тот же пример, но с не жадными квантами:
 
>>> import re
>>> re.findall('a*?', 'aaaaaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '']
>>> re.findall('a+?', 'aaaaaaa')
['a', 'a', 'a', 'a', 'a', 'a', 'a']
>>> re.findall('a??', 'aaaaaaa')
['', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '', 'a', '']
 
В этом случае код показывает, что все три кванции *?, +? И ?? Сопоставьте как можно меньше символов «A».
 
Резюме
 
Вы узнали все, что вам нужно знать о Quantier Mark? В этом руководстве Regex.
 
Резюме : При применении к регулярному выражению A, Python's A? Контификатор соответствует нулю или одному вхождению A.? Контификатор всегда применяется только к предыдущему регулярному выражению. Например, регулярное выражение «Эй?» соответствует обеим струнам «он» и «эй». Но это не соответствует пустой строке, потому что? Quantifier не распространяется на все Regex «Эй», но только к предшествующему Regex 'Y'.
 
Оператор с наименьшим один + один +
 
Давайте узнаем о Плюс символ "+" в библиотеке Python Re Отказ
 
Что такое Python Re + Quantifier?
 
Скажи, у вас есть какое-либо регулярное выражение А Отказ Регулярное выражение (Regex) A + затем соответствует одному или нескольким вхождению А Отказ Мы называем символ «+». Например, регулярное выражение «Да +» соответствует строкам «Да» , «Дамс» и «YESSSSSSS» Отказ Но это не соответствует строке 'ye' , ни пустая строка « Потому что плюс квантификатор + не распространяется на все Regex « Да » Но только к предшествующему Regex ' .
 
Давайте изучим некоторые примеры, чтобы помочь вам получить более глубокое понимание.
 
>>> import re
>>> re.findall('a+b', 'aaaaaab')
['aaaaaab']
>>> re.findall('ab+', 'aaaaaabb')
['abb']
>>> re.findall('ab+', 'aaaaaabbbbb')
['abbbbb']
>>> re.findall('ab+?', 'aaaaaabbbbb')
['ab']
>>> re.findall('ab+', 'aaaaaa')
[]
>>> re.findall('[a-z]+', 'hello world')
['hello', 'world']
 
Далее мы объясним эти примеры один за другим.
 
Примеры 1 и 2: жадные плюс (+) кванты
 
Вот первый пример:
 
>>> re.findall('a+b', 'aaaaaab')
['aaaaaab']
 
Первый аргумент метода findall () - это шаблон регулярного выражения 'A + B' И второй аргумент - это строка для поиска. На простом английском, вы хотите найти все шаблоны в строке, которая начинается с по крайней мере с одной, но, возможно, многие символы «A», а затем символ «B».
 
Метод findall () возвращает соответствующую подстроку: «AAAAAAB» Отказ Quantifier Asterisk + жадный. Это означает, что он пытается сопоставить как можно больше вхождений предыдущего регулятора. Таким образом, в нашем случае он хочет сопоставить как можно больше произвольных персонажей, чтобы узор до сих пор подобран. Следовательно, двигатель Regex «потребляет» все предложение.
 
Второй пример похож:
 
>>> re.findall('ab+', 'aaaaaabb')
['abb']
 
Вы ищете персонажа «A», а затем хотя бы один символ «B». Поскольку квантификатор Plus (+) жадный, он совпадает с точностью, когда он может положить его руки.
 
Примеры 3 и 4: не жадные плюс (+) кванты
 
Но что, если вы хотите соответствовать хотя бы одному возникновению регеляции не жадным образом. Другими словами, вы не хотите, чтобы двигатель Regeex потребляет все больше и больше, чем может, но возвращается как можно быстрее, насколько это может от обработки.
 
Опять же, вот пример жадного матча:
 
>>> re.findall('ab+', 'aaaaaabbbbb')
['abbbbb']
 
Двигатель Regex начинается с первого символа «A» и находит, что это частичное совпадение. Итак, он движется, чтобы соответствовать второму «a'-которое нарушает шаблон» AB + ', что позволяет только для одного символа «A». Так что он движется к третьему персонажу, и так далее, пока не достигнет последнего символа «A» в строке «AAAAABABBBBB». Это частичное совпадение, поэтому он движется к первому возникновению характера «B». Это понимает, что символ «B» может быть сопоставлен частью Regex 'B +'. Таким образом, двигатель начинает соответствовать «B». И это жадно соответствует «B», пока не может соответствовать ни одному другому характеру. В этот момент он смотрит на результат и видит, что он нашел соответствующую подстроку, которая является результатом работы.
 
Тем не менее, он мог остановиться намного раньше, чтобы произвести не жадный матч после сопоставления первого символа «B». Вот пример не жадного квантификатора '+? (Оба символа вместе образуют одно выражение Regex).
 
>>> re.findall('ab+?', 'aaaaaabbbbb')
['ab']
 
Теперь двигатель Regex не жадно «потреблять» как можно больше «B» символов. Вместо этого он останавливается, как только шаблон соответствует (не жадным).
 
Примеры 5 и 6
 
Ради вашего тщательного понимания, давайте посмотрим на другой данный пример:
 
>>> re.findall('ab+', 'aaaaaa')
[]
 
Вы можете увидеть, что Quantifier Plus (+) требует, чтобы по меньшей мере одному возникновению предыдущего регеляции совпадают. В примере это персонаж «B», который не совпадает с частично. Таким образом, результатом является пустой список, указывающий, что совпадающая подстрока не обнаружена.
 
Еще одним интересным примером является следующее:
 
>>> re.findall('[a-z]+', 'hello world')
['hello', 'world']
 
Вы используете квантов Plus (+) в сочетании с классом символов, который определяет конкретно, какие символы являются действительными совпадениями.
 
Примечание Класс персонажей : В классе символов вы можете определить диапазоны символов. Например, диапазон символов [A-Z] соответствует одному символу строчных букв в алфавите, когда диапазон символов [A-Z] соответствует одному прописному символу в алфавите.
 
Пустое пространство не является частью данного класса символов [A-Z], поэтому он не будет сопоставлен в тексте. Таким образом, результат является список слов, начинающихся с по меньшей мере одного персонажа: «Hello», «Мир».
 
Что, если вы хотите подобрать саму символ плюс (+)?
 
Вы знаете, что плюс квантификатор соответствует хотя бы одному из предыдущих регулярных выражений. Но что, если вы ищете сам символ плюс (+)? Как вы можете искать его в строке?
 
Ответ прост: избегайте символа плюс в вашем регулярном выражении, используя обратную косание. В частности, используйте «\ +» вместо «+». Вот пример:
 
>>> import re
>>> text = '2 + 2 = 4'
>>> re.findall(' + ', text)
[]
>>> re.findall(' \+ ', text)
[' + ']
>>> re.findall(' \++ ', '2 ++++ 2 = 4')
[' ++++ ']
 
Если вы хотите найти символ «+» в своей строке, вам нужно избежать его, используя обратную косание. Если вы этого не сделаете, двигатель Python Regex будет интерпретировать его как нормальный «по крайней мере - один раз» Regex. Конечно, вы можете комбинировать Seakaped Plus Symbol '\ +' с помощью Regex «AT-MIKE - один раз» по поиску по меньшей мере одного вхождения символа плюс.
 
В чем разница между Python Re + и? Количественные кванты?
 
Вы можете прочитать Python Re a? квантификатор как нулевое или одно регез : Предыдущее Regex a соответствует нулевым временам, либо точно один раз. Но это не совсем не совсем не совсем.
 
Аналогично, вы можете прочитать оператор Python Re A + как по крайней мере, когда регельс : Предыдущее Regex a соответствует произвольному количеству раз, но, по крайней мере, один раз (как следует наименование).
 
Вот пример, который показывает разницу:
 
>>> import re
>>> re.findall('ab?', 'abbbbbbb')
['ab']
>>> re.findall('ab+', 'abbbbbbb')
['abbbbbbb']
 
Regex 'AB?' Соответствует символу «A» в строке, за которым следует символ «B», если он существует (что он делает в коде).
 
Regex 'ab +' соответствует символу «a» в строке, а затем как можно больше символов B '(и, по меньшей мере, один).
 
В чем разница между Python Re * и + квантами?
 
Вы можете прочитать квантификатор Python Re * As нулевое или больше регеекс : Предыдущее Regex A соответствует произвольному количеству раз.
 
Аналогично, вы можете прочитать оператор Python Re A + как по крайней мере, когда регельс : Предыдущее Regex A также соответствует произвольному количеству раз, но, по крайней мере, один раз.
 
Вот пример, который показывает разницу:
 
>>> import re
>>> re.findall('ab*', 'aaaaaaaa')
['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']
>>> re.findall('ab+', 'aaaaaaaa')
[]
 
Regex 'ab *' соответствует символу «A» в строке, за которым следует новенький номер вхождения символов «B». Подстрока «A» прекрасно соответствует этой формулировке. Поэтому вы обнаружите, что Regeex совпадает с восемь раз в строке.
 
Regex 'AB +' соответствует персонажу «A», а затем как можно больше персонажей B ', но хотя бы один. Однако персонаж «B» не существует, так что нет совпадения.
 
Резюме
 
Regex A + соответствует одному или нескольким вхождению Regex A. Символ «+» - наименьший квантователь, потому что он требует, по меньшей мере, одно вхождение предыдущего регулятора. Не жадная версия, как минимум-один, как минимум, когда-то квантификатор составляет +? с трейлинговым вопросительным знаком.
 
Начать ^ и заканчивать $
 
Эта статья все о Начало строки ^ и конец строки $ Регулярные выражения в библиотеке Python's Re Отказ
 
Эти два Regexes являются фундаментальными для всех регулярных выражений - даже за пределами мира Python. Так что инвестируйте 5 минут сейчас и освоить их один раз и навсегда!
 
Python Re Start-of String (^) Regex
 
Вы можете использовать оператор CARET ^, чтобы соответствовать началу строки. Например, это полезно, если вы хотите убедиться, что в начале строки появится шаблон. Вот пример:
 
>>> import re
>>> re.findall('^PYTHON', 'PYTHON is fun.')
['PYTHON']
 
Метод Findall (Pattern, String) находит все вхождения рисунка в строке. Карета в начале картины «^ Python» гарантирует, что вы соответствуете слову Python только в начале строки. В предыдущем примере это не имеет никакого значения. Но в следующем примере это делает:
 
>>> re.findall('^PYTHON', 'PYTHON! PYTHON is fun')
['PYTHON']
 
Хотя есть два вхождения подстроки «Python», есть только одна соответствующая подстрока - в начале строки.
 
Но что, если вы хотите сопоставить не только в начале строки, но в начале каждой строки в многострочной строке? Другими словами:
 
Python Re Start-of Line (^) Regex
 
Оператор CARET по умолчанию относится только к началу строки. Поэтому, если у вас есть многострочная строка, например, при чтении текстового файла - он все равно будет соответствовать только один раз: в начале строки.
 
Однако вы можете подобрать в начале каждой строки. Например, вы можете найти все строки, которые начинаются с «Python» в данной строке.
 
Вы можете указать, что оператор Caret соответствует началу каждой строки через флаг Re.multiline. Вот пример, показывающий оба использования - без и с установкой флага Re.multiline:
 
>>> import re
>>> text = '''
Python is great.
Python is the fastest growing
major programming language in
the world.
Pythonistas thrive.'''
>>> re.findall('^Python', text)
[]
>>> re.findall('^Python', text, re.MULTILINE)
['Python', 'Python', 'Python']
>>>
 
Первый выход - это пустой список, потому что строка «Python» не отображается в начале строки.
 
Второй выход - это список трех соответствующих подстрок, потому что строка «Python» появляется три раза в начале строки.
 
Python re.sub ()
 
RE.SUB (Pattern, repl, string ,,) Метод возвращает новую строку, в которой все вхождения рисунка в старой строке заменены на REPL.
 
Вы можете использовать оператор CARET для замены, где какой-то шаблон появляется в начале строки:
 
>>> import re
>>> re.sub('^Python', 'Code', 'Python is \nPython')
'Code is \nPython'
 
Только начало строки соответствует шаблону Regex, поэтому у вас есть только одна замена.
 
Опять же, вы можете использовать флаг Re.multiline, чтобы соответствовать началу каждой строки с оператором Caret:
 
>>> re.sub('^Python', 'Code', 'Python is \nPython', flags=re.MULTILINE)
'Code is \nCode'
 
Теперь вы заменяете оба внешности строки «Python».
 
Python re.match (), re.search (), re.findall () и Re.fulllmatch ()
 
Давайте быстро переправимся самым важным методам Regex в Python:
 
 Re.findall (шаблон, строка) Метод возвращает список строковых совпадений.
 
 Re.Search (шаблон, строка,) Метод возвращает объект совпадения первого матча.
 
 Re.match (шаблон, строка,) Метод Возвращает объект совпадения, если установки Regeex в начале строки.
 
 Re.fullmatch (шаблон, строка,) Метод возвращает объект совпадения, если Regeex соответствует всей строке.
 
Вы можете увидеть, что все четыре метода поиска шаблона в данной строке. Вы можете использовать оператор CARET ^ в каждом шаблоне, чтобы соответствовать началу строки. Вот один пример на один метод:
 
>>> import re
>>> text = 'Python is Python'
>>> re.findall('^Python', text)
['Python']
>>> re.search('^Python', text)

>>> re.match('^Python', text)

>>> re.fullmatch('^Python', text)
>>>
 
Таким образом, вы можете использовать оператор Caret, чтобы соответствовать в начале строки. Однако следует отметить, что не имеет большого смысла использовать его для методов Match () и Fullmatch (), поскольку они по определению, начнут, пытаясь сопоставить первый символ строки.
 
Вы также можете использовать флаг Re.multiline, чтобы соответствовать началу каждой строки (а не только начало строки):
 
>>> text = '''Python is
Python'''
>>> re.findall('^Python', text, flags=re.MULTILINE)
['Python', 'Python']
>>> re.search('^Python', text, flags=re.MULTILINE)

>>> re.match('^Python', text, flags=re.MULTILINE)

>>> re.fullmatch('^Python', text, flags=re.MULTILINE)
>>>
 
Опять же, это сомнительно, имеет ли это смысл для методов Re.match () и Re.fullmatch (), поскольку они ищут только матч в начале строки.
 
Python Re конец строки ($) Regex
 
Точно так же вы можете использовать оператор долларовой знак $, чтобы соответствовать концу строки. Вот пример:
 
>>> import re
>>> re.findall('fun$', 'PYTHON is fun')
['fun']
 
Метод findall () находит все вхождения рисунка в строке - хотя приводной долларовой знак $ гарантирует, что регулярные выражения соответствуют только в конце строки.
 
Это может значительно изменить значение вашего регулярного выражения, как вы можете увидеть в следующем примере:
 
>>> re.findall('fun$', 'fun fun fun')
['fun']
 
Хотя, есть три вхождения подстроки «Веселье», есть только одна подходящая подстрока - в конце строки.
 
Но что, если вы хотите подобрать не только в конце строки, но в конце каждой строки в многострочной строке?
 
Python Re конец строки ($)
 
Оператор долларовой подписи по умолчанию относится только к концу строки. Таким образом, если у вас есть многострочная строка, например, при чтении текстового файла - все равно будет только один раз: в конце строки.
 
Однако вы можете подобрать в конце каждой строки. Например, вы можете найти все строки, которые заканчиваются «.py».
 
Для достижения этого вы можете указать, что оператор долларового знака соответствует концу каждой строки через флаг Re.multiline. Вот пример, показывающий оба использования - без и с установкой флага Re.multiline:
 
>>> import re
>>> text = '''
Coding is fun
Python is fun
Games are fun
Agreed?'''
>>> re.findall('fun$', text)
[]
>>> re.findall('fun$', text, flags=re.MULTILINE)
['fun', 'fun', 'fun']
>>>
 
Первый выход - это пустой список, потому что строка «Веселье» не отображается в конце строки.
 
Второй выход - это список трех подходящих подстроек, потому что строка «Веселье» появляется три раза в конце строки.
 
Python re.sub ()
 
RE.SUB (Pattern, repl, string ,,) Метод возвращает новую строку, в которой все вхождения рисунка в старой строке заменены на REPL. Читайте больше в Учебник блогов Finxter Отказ
 
Вы можете использовать оператор Dollar-Sign для замены, где какой-то шаблон появляется в конце строки:
 
>>> import re
>>> re.sub('Python$', 'Code', 'Is Python\nPython')
'Is Python\nCode'
 
Только конец строки соответствует шаблону Regex, поэтому есть только одна замена.
 
Опять же, вы можете использовать флаг Re.multiline, чтобы соответствовать концу каждой строки с оператором долларового знака:
 
>>> re.sub('Python$', 'Code', 'Is Python\nPython', flags=re.MULTILINE)
'Is Code\nCode'
 
Теперь вы заменяете оба внешности строки «Python».
 
Python re.match (), re.search (), re.findall () и Re.fulllmatch ()
 
Все четыре метода - Re.findall (), Re.Search (), Re.match () и Re.fulllmatch () - поиск шаблона в данной строке. Вы можете использовать оператор долларовой знак $ в каждом шаблоне, чтобы соответствовать концу строки. Вот один пример на один метод:
 
>>> import re
>>> text = 'Python is Python'
>>> re.findall('Python$', text)
['Python']
>>> re.search('Python$', text)

>>> re.match('Python$', text)
>>> re.fullmatch('Python$', text)
>>>
 
Таким образом, вы можете использовать оператор долларового знака, чтобы соответствовать в конце строки. Однако следует отметить, что не имеет большого смысла использовать его для методов fullmatch (), как это, по определению, уже требует, чтобы последний символ строки является частью соответствующей подстроки.
 
Вы также можете использовать флаг Re.multiline, чтобы соответствовать концу каждой строки (а не только конец всей строки):
 
>>> text = '''Is Python
Python'''
>>> re.findall('Python$', text, flags=re.MULTILINE)
['Python', 'Python']
>>> re.search('Python$', text, flags=re.MULTILINE)

>>> re.match('Python$', text, flags=re.MULTILINE)
>>> re.fullmatch('Python$', text, flags=re.MULTILINE)
>>>
 
Поскольку шаблон не соответствует префиксе строки, как Re.match (), так и Re.fullmatch () возвращает пустые результаты.
 
Как сопоставить Caret (^) или символы доллара ($) в вашем Regex?
 
Вы знаете, что символы CARET и DOLLAR имеют особое значение в регулярном модуле Python Module: они соответствуют началу или конце каждой строки/линии. Но что, если вы ищете сами символы CARET (^) или доллар ($)? Как вы можете сопоставить их в строке?
 
Ответ прост: избегайте символов CARET или DOLLAR в вашем регулярном выражении, используя обратную косание. В частности, используйте «\ ^» вместо «^ 'и' \ $ 'вместо $'. Вот пример:
 
>>> import re
>>> text = 'The product ^^^ costs $3 today.'
>>> re.findall('\^', text)
['^', '^', '^']
>>> re.findall('\$', text)
['$']
 
Сбежав на специальные символы ^ и $, вы говорите двигатель Regex, чтобы игнорировать свое особое значение.
 
Резюме
 
Вы узнали все, что вам нужно знать о операторе CARET ^ и оператора долларового знака $ в этом руководстве REGEX.
 
Резюме : Оператор CARET ^ матчи в начале строки. Оператор долларовой подписи $ соответствует в конце строки. Если вы хотите подобрать в начале или в конце каждой строки в многострочной строке, вы можете установить флаг Re.multiline во всех соответствующих методах RE.
 
Regex или оператор |
 
Эта статья все о или |. Оператор библиотеки Python's Re Отказ
 
Что такое Python Regex или | Оператор?
 
Учитывая строку. Скажем, ваша цель - найти все подстроки, которые соответствуют либо строке «iPhone», либо строку «iPad». Как вы можете достичь этого?
 
Самый простой способ добиться этого - питон или оператор | Используя шаблон регулярного выражения (iPhone | iPad).
 
Вот пример:
 
>>> import re
>>> text = 'Buy now: iPhone only $399 with free iPad'
>>> re.findall('(iPhone|iPad)', text)
['iPhone', 'iPad']
 
У вас есть текст (Saley), который содержит оба строки «iPhone», так и «iPad».
 
Вы используете метод re.findall (). Если вы этого не знаете, вот определение из статьи блог Finxter:
 
Метод Re.findall (Pattern, String) находит все вхождения шаблона в строке и возвращает список всех совпадающих подстроек.
 
Пожалуйста, обратитесь к статью в блоге, чтобы узнать все, что вам нужно знать об этом фундаментальном методе Python.
 
Первый аргумент - это шаблон (iPhone | iPad). Это либо соответствует первой части прямо перед ним или символом | - который является iPhone - или вторая часть после того, как она является iPad.
 
Второй аргумент - это текст «Купить сейчас: iPhone всего за $ 399 с бесплатным iPad», который вы хотите найти шаблон.
 
Результатом показан, что в тексте в тексте есть две соответствующие подстроки: «iPhone» и «iPad».
 
Python Regex или: примеры
 
Давайте изучим еще несколько примеров, чтобы научить вас все возможное использование и пограничные случаи - один за другим.
 
Вы начинаете с предыдущего примера:
 
>>> import re
>>> text = 'Buy now: iPhone only $399 with free iPad'
>>> re.findall('(iPhone|iPad)', text)
['iPhone', 'iPad']
 
Что произойдет, если вы не используете скобки?
 
>>> text = 'iPhone iPhone iPhone iPadiPad'
>>> re.findall('(iPhone|iPad)', text)
['iPhone', 'iPhone', 'iPhone', 'iPad', 'iPad']
>>> re.findall('iPhone|iPad', text)
['iPhone', 'iPhone', 'iPhone', 'iPad', 'iPad']
 
Во втором примере вы только что пропустили скобки с помощью Regex Pattern iPhone | iPad, а не (iPhone | iPad). Но никаких проблем - это все еще работает и генерирует тот же самый вывод!
 
Но что произойдет, если вы оставите одну сторону или работу пустые?
 
>>> re.findall('iPhone|', text)
['iPhone', '', 'iPhone', '', 'iPhone', '', '', '', '', '', '', '', '', '', '']
 
Выход не так странно, как кажется. Оператор или оператор позволяет для пустых операндов - в этом случае он хочет соответствовать непустой строке. Если это невозможно, он соответствует пустой строке (так что все будет совпадением).
 
Предыдущий пример также показывает, что он все еще пытается соответствовать непустой строке, если это возможно. Но что, если тривиальное пустое совпадение на левой стороне или операнда?
 
>>> re.findall('|iPhone', text)
['', 'iPhone', '', '', 'iPhone', '', '', 'iPhone', '', '', '', '', '', '', '', '', '', '']
 
Это показывает некоторые тонкости двигателя REGEX. Прежде всего, он все еще соответствует непустой строке, если это возможно! Но что более важно, вы можете увидеть, что двигатель Regex соответствует слева направо. Сначала пытается сопоставить левое регулярное выражение (которое он делает на каждом положении в тексте). Пустая строка, которая уже соответствует, больше не будет рассмотрена. Только тогда он пытается сопоставить Regex на правой стороне или оператору.
 
Подумайте об этом таким образом: двигатель Regex движется слева направо-одному положению одновременно. Это соответствует пустой строке каждый раз. Затем он движется над пустой строкой и в некоторых случаях он все еще может соответствовать непустой строке. Каждый матч «потребляет» подстроку и больше не может быть сопоставлено. Но пустая строка не может быть потреблена. Вот почему вы видите, что первый матч - это пустая строка, а второй матч - это подстрочный iPhone ».
 
Как гнездить Python Regex или оператор?
 
Хорошо, ты не легко доволен, ты? Давайте попробуем гнездить Python Regex или оператора |.
 
>>> text = 'xxx iii zzz iii ii xxx'
>>> re.findall('xxx|iii|zzz', text)
['xxx', 'iii', 'zzz', 'iii', 'xxx']
 
Таким образом, вы можете использовать несколько или операторы подряд. Конечно, вы также можете использовать оператор группировки (скобки) для гнезда произвольной сложной конструкции или операций:
 
>>> re.findall('x(i|(zz|ii|(x| )))', text)
[('x', 'x', 'x'), (' ', ' ', ' '), ('x', 'x', 'x')]
 
Но это редко приводит к чистоту и читаемому коду. И он обычно можно легко избежать, положив немного мысли в ваш дизайн Regex.
 
Python Regex или: класс персонажа
 
Если вы хотите только сопоставить один символ из набора символов, класс символов гораздо лучший способ сделать это:
 
>>> import re
>>> text = 'hello world'
>>> re.findall('[abcdefghijklmnopqrstuvwxyz]+', text)
['hello', 'world']
 
Короче и более краткая версия будет использовать оператор диапазона в классах символов:
 
>>> re.findall('[a-z]+', text)
['hello', 'world']
 
Класс персонажа заключен в нотацию кронштейна [], и он буквально означает «совпадение именно один из символов в классе». Таким образом, он несет одинаковую семантику, что и оператор: |. Однако, если вы попытаетесь что-то сделать на этих линиях ...
 
>>> re.findall('(a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z)+', text)
['o', 'd']
 
... Вы сначайте напишите гораздо менее лаконичный код и, во-вторых, риск запутаны на выходе. Причина в том, что в скобках является оператор группы - он фиксирует позицию и подстроку, соответствующую Regex. Используется в методе findall (), он возвращает только содержание последней сопоставленной группы. Это оказывается последним характером слова «Hello» и последнего характера слова «мир».
 
Как сопоставить или символу (вертикальную линию «|»)?
 
Так что если персонаж «|» обозначает или Персонаж в данном Regex возникает вопрос, как соответствовать символу вертикальной линии «|» сам?
 
Ответ прост: сбежать или символ в вашем регулярном выражении, используя обратную косание. В частности, используйте «a \ | b ' вместо «A | B», чтобы соответствовать строке «A | B». Вот пример:
 
>>> import re
>>> re.findall('A|B', 'AAAA|BBBB')
['A', 'A', 'A', 'A', 'B', 'B', 'B', 'B']
>>> re.findall('A\|B', 'AAAA|BBBB')
['A|B']
 
Вы действительно понимаете результаты этого фрагмента кода? В первом примере вы ищете персонажа «A» или символ «B». Во втором примере вы ищете строку «A | B» (которая содержит символ «|»).
 
Python Regex нет
 
Как вы можете искать строку для подстроки, которые не соответствуют данному шаблону? Другими словами, какой «негативный рисунок» в регулярных выражениях Python?
 
Ответ в два раза:
 
Если вы хотите сопоставить всех персонажей, кроме набора определенных символов, вы можете использовать отрицательный класс символов [^ ...].
 
Если вы хотите сопоставить все подстроки, кроме тех, которые соответствуют шаблону Regex, вы можете использовать функцию Отрицательный взгляд (?! ...).
 
Вот пример для отрицательного класса символов:
 
>>> import re
>>> re.findall('[^a-m]', 'aaabbbaababmmmnoopmmaa')
['n', 'o', 'o', 'p']
 
И вот пример для негативного образца Lookahead соответствует всем «словам, которые не за ними»:
 
>>> re.findall('[a-z]+(?![a-z]+)', 'hello world')
['hello', 'world']
 
Отрицательный полей Ahead (?! [A-Z] +) не потребляет ( Match ) любой символ. Это просто проверяет, не совпадает ли шаблон [A-Z] + не в заданном положении. Единственные времена это происходит, просто перед пустым пространством и концом строки.
 
Резюме
 
Вы узнали все, что вам нужно знать о Python Regex или Оператор.
 
Учитывая строку. Скажем, ваша цель - найти все подстроки, которые соответствуют либо строке «iPhone», либо строку «iPad». Как вы можете достичь этого?
 
Самый простой способ добиться этого - питон или оператор | Используя шаблон регулярного выражения (iPhone | iPad).
 
Regex и оператор
 
Этот учебник все о И оператор библиотеки Python's Re Отказ Вы можете спросить: что? (И справедливо так.)
 
Конечно, есть оператор или оператор (пример: «iPhone | iPad»). Но в чем смысл соответствовать одному регулярному выражению и другому?
 
Существуют различные интерпретации и оператора в регулярном выражении (Regex):
 
Заказал : Соответствовать одному рисунку Regex за другим. Другими словами, вы сначала сопоставляете шаблон A, а затем соответствуете шаблону B. Здесь ответа простой: вы используете шаблон AB для соответствия обоим.
 
Неупорядоченные : Сопоставьте несколько шаблонов в строке, но без определенного порядка ( Источник ). В этом случае вы будете использовать подход мешок слов.
 
Я обсужу оба в следующем.
 
Заказанный Python Regex и оператор
 
Учитывая строку. Скажем, ваша цель - найти все подстроки, которые соответствуют строке «iPhone», а затем строку «iPad». Вы можете просмотреть это как и оператор двух регулярных выражений. Как вы можете достичь этого?
 
Простое и эксплуатация обеих строк является регулярным шаблоном выражения iPhoneiPad.
 
В следующем примере вы хотите сопоставить шаблон «AAA» и BBB'-в этом порядке.
 
>>> import re
>>> text = 'aaabaaaabbb'
>>> A = 'aaa'
>>> B = 'bbb'
>>> re.findall(A+B, text)
['aaabbb']
>>>
 
Вы используете метод re.findall (). Первый аргумент - это шаблон A + B, который оценивает «AABKB». Ничего не нравится об этом: каждый раз, когда вы пишете строку, состоящую из более чем одного символа, вы, по сути, используете заказал И оператор.
 
Второй аргумент - это текст «AAABAAAAABBB», который вы хотите искать шаблон.
 
Результат показывает, что в тексте есть соответствующая подстрока: «AABKB».
 
Неупорядоченный Python Regex и оператор
 
Но что, если вы хотите найти данный текст для шаблона A и Pattern B-но ни в одном конкретном порядке? Другими словами: если оба образца появляются в любом месте строки, вся строка должна быть возвращена в виде совпадения.
 
Теперь это немного сложнее, потому что какая-либо регулярная структура выражения заказывается слева направо. Простое решение состоит в том, чтобы использовать Ahead Assertion (?. * A) Чтобы проверить, появится ли Regeex A в любой точке строки. (Обратите внимание, что мы принимаем одну строку строки, поскольку шаблон. * По умолчанию не соответствует символу Newline.)
 
Давайте сначала посмотрим на минимальное решение для проверки двух шаблонов в любой точке строки (скажем, шаблоны «Привет» и «вы»).
 
>>> import re
>>> pattern = '(?=.*hi)(?=.*you)'
>>> re.findall(pattern, 'hi how are yo?')
[]
>>> re.findall(pattern, 'hi how are you?')
['']
 
В первом примере оба слова не появляются. Во втором примере они делают.
 
Но как работает Alahead Assertion? Вы должны знать, что любой другой рисунок Regex «потребляет» соответствующую подстроку. Потребляемая подстрока не может быть сопоставлена любой другой частью Regex.
 
Думайте о утверждении Lookahead в качестве непоглощающего списка шаблонов. Двигатель REGEX идет слева направо - поиск шаблона. В каждой точке он имеет одну «текущую» положение для проверки, является ли эта позиция первой позиции оставшегося совпадения. Другими словами, двигатель REGEX пытается «потреблять» следующий символ как (частичное) совпадение шаблона.
 
Преимущество выражения Lookahead заключается в том, что он не потребляет ничего. Это просто «выглядит вперед», начиная с текущей позиции, следует ли сделать то, что теоретически соответствует образе узора. Если это не так, двигатель Regex не может двигаться дальше.
 
Простой пример lookahead. Регулярный механизм экспрессии соответствует («потребляет») строку частично. Затем он проверяет, может ли оставшийся шаблон быть сопоставлен без надобрения его.
 
Давайте вернемся к выражению (? =. * Привет) (? =. * Вы), чтобы сопоставить строки, которые содержат как «HI», так и «вы». Почему это работает?
 
Причина в том, что выражения Lookahead не потребляют ничего. Вы сначала поищите произвольное количество персонажей. *, А затем слово привет. Но поскольку двигатель Regex ничего не употреблял, это все еще в То же самое положение в начале строки Отказ Итак, вы можете повторить то же самое для этого слова.
 
Обратите внимание, что этот метод не заботится о порядке двух слов:
 
>>> import re
>>> pattern = '(?=.*hi)(?=.*you)'
>>> re.findall(pattern, 'hi how are you?')
['']
>>> re.findall(pattern, 'you are how? hi!')
['']
 
Независимо от того, какое слово «HI» или «Вы» появляются первым в тексте, двигатель Regex находит обоими.
 
Вы можете спросить: почему вывод пустой строки? Причина в том, что двигатель Regex не употреблял какой-либо характер. Он только что проверил поиск. Таким образом, простое решение - потреблять всех символов следующим образом:
 
>>> import re
>>> pattern = '(?=.*hi)(?=.*you).*'
>>> re.findall(pattern, 'you fly high')
['you fly high']
 
Теперь вся строка - это совпадение, потому что после проверки Lookahead с '(? =. * Привет) (? =. * Вы)', вы также употребляете всю строку «. *».
 
Резюме:
 
Существуют различные интерпретации и оператора в регулярном выражении (Regex):
 
Заказал : Соответствовать одному рисунку Regex за другим. Другими словами, вы сначала сопоставляете шаблон A, а затем соответствуете шаблону B. Здесь ответа простой: вы используете шаблон AB для соответствия обоим.
 
Неупорядоченные : Сопоставьте несколько шаблонов в строке, но без определенного порядка. В этом случае вы будете использовать подход мешок слов.
 
Куда пойти отсюда
 
Вот это да. Вы потратили много времени, узнав все, что вам нужно знать о регулярных выражениях Python. Спасибо за ваше время!
 
На данный момент я знаю, что у вас есть навыки. Но вы на самом деле используете эти навыки самым эффективным способом? Другими словами: Вы зарабатываете деньги с Python?
 
Если ответ нет, позвольте мне показать вам простой способ, которым вы можете создать свой простым домашним кодировщиком бизнеса онлайн:
 
Присоединяйтесь к бесплатному Webinar: Как стать кодом из шести фигура в качестве среднего кодера?
 
Начните свой новый процветающий бизнес сейчас!
 
Работая в качестве исследователя в распределенных системах, доктор Кристиан Майер нашел свою любовь к учению студентов компьютерных наук.
 
Чтобы помочь студентам достичь более высоких уровней успеха Python, он основал сайт программирования образования Finxter.com Отказ Он автор популярной книги программирования Python One-listers (Nostarch 2020), Coauthor of Кофе-брейк Python Серия самооставленных книг, энтузиаста компьютерных наук, Фрилансера и владелец одного из лучших 10 крупнейших Питон блоги по всему миру.
 
Его страсти пишут, чтение и кодирование. Но его величайшая страсть состоит в том, чтобы служить стремлению кодер через Finxter и помогать им повысить свои навыки. Вы можете присоединиться к его бесплатной академии электронной почты здесь.