Wyrażenia regularne

Znaki specjalne

Klasy znaków

Dla częstych klas znaków dostępne są poniższe skróty.

Kwantyfikatory wyrażeń regularnych

Kwantyfikatory określają ilość powtórzeń znaków lub sekwencji we wzorcach. Domyślnie kwantyfikatory są zachłanne, tzn. starają się dopasować maksymalną możliwą ilość znaków w tekście.

Kwantyfikatory niezachłanne

Dodanie znaku zapytania po kwantyfikatorze przekształca go w kwantyfikator niezachłanny (leniwy). Kwantyfikator niezachłanny stara się dopasować minimalną możliwą ilość tekstu.

Asercje

Asercje (kotwice) pozwalają wyznaczyć miejsce w tekście, w którym musi pojawić się dopasowanie. Asercje mają w dopasowaniu zerową długość.

W przypadku asercji wstecznych (ang. lookbehind) implementacja dla Pythona dopuszcza skończoną i ustaloną długość wzorca e. Zatem użycie operatora Kleen'a * lub operatora zakresu {n,m} jest niedozwolone w asercji wstecznej.

Surowe ciągi znaków

Przykłady zwykłych łańcuchów i równoważnych im surowych łańcuchów:

Grupowanie

Nawiasy oprócz zwykłej funkcji, wpływania na kolejność obliczeń, pełnią drugą ważną rolę - tworzą z wyrażenia w nawiasach tzw. grupę.

• Po dopasowaniu grupy we wzorcu można odwoływać się we wzorcu do jej zawartości poprzez odwołania wsteczne \numer.
• Numerowanie grup we wzorcu przebiega począwszy od 1, od lewej do prawej, wg. wystąpienia lewego nawiasu otwierającego.
• Cały wzorzec tworzy grupę zerową, do jej zawartości możemy się odwoływać przy zamianie tekstów funkcją sub.
• Dodanie we wzorcu nowej grupy przechwytującej (wyrażenia w nawiasach) może wprowadzić konieczność zmiany numeracji odwołań wstecznych. W celu uniknięcia błędów i większej czytelności wprowadzono także grupy nazwane.

• w łańcucu zastępującym możemy użyć odwołań wstecznych \1, \2, ....
• Do grupy zerowej (całe dopasowanie) oraz do grup nazwanych musimy się odwoływać odpowiednio poprzez \g<0> oraz \g<name>, gdzie name to nazwa grupy nazwanej.
• Do grup 1, 2, ... możemy też odwoływać się poprzez \g<1>,\g<2>,.... Jest to przydatne np. do rozróżnienia pomiędzy zawartością grupy dwudziestej \20 a zawartością grupy drugiej, po której następuje literał 0: \g<2>0

Przykłady zastosowania grupowania do wyszukiwania i zastępowania wzorców:

pattern = r'\w+ \w+'
r = re.compile(pattern)
m = r.match('Hello world, ...') # dopasowuje pare slow rozdzielonych spacja

pattern = r'(\w+) \1'
r = re.compile(pattern)
m = r.match('Hello world, ...') # brak dopasowania
m = r.match('Hello Hello, ...') # dopasowanie

pattern = r'(?P<word>\w+) (?P=word)'  # to samo co r'(\w+) \1' przy pomocy grupy nazwanej
r = re.compile(pattern)
m = r.match('Hello Hello, ...') 

str = r'http://www.python.org'
pattern = r'(http://\w+(\.\w+)+)' 
r = re.compile(pattern)
link = r.sub(r'<a href="\1">\1</a>', str)

str = r'http://www.python.org'
pattern = r'(?P<addr>http://\w+(\.\w+)+)'
r = re.compile(pattern)
link = r.sub(r'<a href="\g<addr>">\g<addr></a>', str)

grouping.py

Opcje i modyfikatory

Opcje i modyfikatory wpływają na sposób dopasowywania wzorca w tekście.

Opcje można przekazywać do szeregu funkcji, w tym funkcji re.compile. Chcąc przekazać do funkcji wiele opcji należy użyć alternatywy bitowej:

r = re.compile("This is regex pattern",  re.VERBOSE | re.IGNORECASE | re.DOTALL | re.MULTILINE)

W odróżnieniu od opcji, modyfikatory są częścią samego wzorca.

• Modyfikatory można łączyć ze sobą. Przykładowo modyfikatory (?i) oraz (?m) można zapisać łącznie jako (?im).
• Włączona modyfikatorem opcja dotyczy całego wzorca w którym się znajduje, niezależnie od położenia.
• W Pythonie opcje można włączać, ale nie można ich wyłączać modyfikatorem, tzn. nie są zaimplementowane wyłączniki typu (?-i).

a = re.compile(r"\d+\.\d*")

b = re.compile(r"""\d+   # czesc calkowita
                   \.    # kropka dziesietna
                   \d*   # czesc ulamkowa""", re.X)

c = re.compile(r"""(?x)  # wlacz komentarze
                   \d+   # czesc calkowita
                   \.    # kropka dziesietna
                   \d*   # czesc ulamkowa""")

Dodatkowo istnieje jeszcze możliwość wstawiania we wzorcu komentarzy w postaci (?#komentarz).

Moduł re

Poniższy przykład znajduje w łańcuchu liczbę zmiennoprzecinkową przy pomocy prostej wersji wyrażenia regularnego dla liczb zmiennoprzecinkowych.

import re

pattern = r'(\d+).(\d*)'
str = '342.79+12.56'

m = re.match(pattern,str)
if m:
    print("{0} pasuje do {1}".format(pattern, str) )
else:
    print("{0} nie pasuje do {1}".format(pattern, str) )

W przypadku, gdy będziemy wyszukiwali dany wzorzec wiele razy, efektywniej jest na początku dokonać kompilacji wzorca do obiektu. Obiekty wyrażeń regularnych tworzone są metodą re.compile Poprzedni przykład, tym razem z kompilacją wzorca będzie wyglądał następująco:

import re

pattern = r'(\d+).(\d*)'
str = '342.79+12.56'

r = re.compile(pattern)
m = r.match(str)
if m:
    print("{0} pasuje do {1}".format(pattern, str) )
else:
    print("{0} nie pasuje do {1}".format(pattern, str) )

Analogicznie do metody match w powyższych przykładach, większość metod modułu re istnieje w dwóch wariantach: z kompilacją wzorca i bez kompilacji wzorca.

Obiekty dopasowania

• group(n) - zwraca tekst dopasowania dla grupy n,
• groups() - zwraca krotkę zawierającą dopasowania wszystkich grup, począwszy od 1. grupy,
• start(n) - zwraca indeks początkowy dla grupy n,
• end(n) - zwraca indeks końcowy dla grupy n,
• span(n) - zwraca dla grupy n krotkę (indeks początkowy, indeks końcowy).

import re

pattern = r'(\d+).(\d*)'
str = '342.79+12.56'

r = re.compile(pattern)
m = r.match(str)

print( m.group(0) )           # 342.79, cale dopasowanie
print( m.group(1) )           # 342, dopasowanie (\d+)
print( m.group(2) )           # 79, dopasowanie (\d*)
print( m.start(1), m.end(1) ) # 0, 3
print( m.start(2), m.end(2) ) # 4, 6

Metody modułu re

re.search(pattern, str [, pos [, endpos]])

Szuka dopasowania wyrażenia regularnego pattern w całym łańcuchu str. Zakres poszukiwań można ograniczyć podając parametry pos (indeks łańcucha, gdzie rozpocznie się poszukiwanie) oraz endpos, (indeks łańcucha, gdzie skończy się poszukiwanie).

re.match(pattern, str [, pos [, endpos]])

Szuka dopasowania wyrażenia regularnego pattern, ale tylko na początku łańcucha str, czym różni się od funkcji search

re.split(pattern, str)

Zwraca listę stringów powstałą z podzielenia łańcucha str na każdym dopasowania wyrażenia regularnego pattern. Jeśli wzorzec pattern umieszczono w nawiasach, każde dopasowanie tego wzorca na łańcuchu str znajdzie się w liście wynikowej.

re.findall(pattern, str)

Jeśli wzorzec nie zawiera nawiasów przechwytujących znajduje wszystkie dopasowania wyrażenia regularnego pattern w łańcuchu str i zwraca je w formie listy stringów. Jeśli wzorzec pattern zawiera nawiasy przechwytujące, zwraca dopasowania grup przechwytujących w formie listy krotek. W odróżnieniu od funkcji findall funkcje search oraz match znajdują tylko jedno dopasowanie.

re.finditer(pattern, str)

Zwraca iterator zwracający kolejne obiekty dopasowania wzorca pattern w łańcuchu str.

re.sub(pattern, repl, str)

Zwraca kopię łańcucha str, gdzie wszystkie dopasowania wyrażenia regularnego pattern zamienione zostały na repl.

re.subn(pattern, repl, str)

Działa podobnie jak funkcja sub, zwraca parę (zmodyfikowany łańcuch, liczba zamian)

Przykłady

Materiały

• Szczegółowa dokumentacja modułu re
• http://www.regular-expressions.info
• Regular Expressions Cookbook, J. Goyvaerts, S. Levithan