przykłady re

dzien6/regexp/analiza_logow1.py

+import re
+
+pattern = re.compile(r'^([^\|]+)\|install\|([^\|]+)\|([^\|]+)\|')
+
+with open('zypper.log') as plik:
+    for linia in plik:
+        m = pattern.match(linia)
+        if m:
+            data = m[1]
+            pakiet = m[2]
+            wersja = m[3]
+            if 'python' in pakiet:
+                print('Pakiet', pakiet, 'w wersji', wersja, 'zainstalowano w dniu', data)
+

dzien6/regexp/re_podstawy.py

+import re
+
+wzorzec1 = '[1-2][0-9][0-9][0-9]-[0-1][0-9]-[0-3][0-9]'
+wzorzec2 = r'[1-2]\d{3}-((0[1-9])|(1[0-2]))-((0[1-9])|([1-2][0-9])|(3[0-1]))'
+
+# w tej wersji w wyrażeniu zaznaczamy 3 "grupy"
+# grupę oznacza się za pomocą nazwiasów okrągłych,
+# ale żeby w innym miejscu nawiasy nie miały specjalnego znaczenia (nie tworzyły grupy),
+# to dopisujemy na początku (?:  - wtedy to są "grupy anonimowe"
+wzorzec3 = r'([1-2]\d{3})-((?:0[1-9])|(?:1[0-2]))-((?:0[1-9])|(?:[1-2][0-9])|(?:3[0-1]))'
+
+while True:
+    tekst = input('Podaj tekst: ')
+    if not tekst: break
+
+    if re.match(wzorzec1, tekst):
+        print('pasuje do wzorca1')
+    else:
+        print('nie pasuje do wzorca1')
+
+    if re.match(wzorzec2, tekst):
+        print('pasuje do wzorca2')
+    else:
+        print('nie pasuje do wzorca2')
+
+    m = re.match(wzorzec3, tekst)
+    if m:
+        # dwa sposoby odczytania wartości grupy (czyli fragmentu, który pasował do (nazwiasów) we wzorcu:
+        y = m.group(1)
+        y = m[1]
+        month = m[2]
+        day = m[3]
+        print(f'pasuje do wzorca3. y={y}, m={month}, d={day}')
+
+

dzien6/regexp/re_podstawy_inne.py

+import re
+
+# Gdy mamy jakieś napisy
+txt1 = 'ala.kowalska@gmail.com'
+txt2 = 'toniejestemail#costam.net'
+
+# i chcemy sprawdzić czy napis "pasuje do wzorca"
+# najlepiej użyć wyrażeń regularnych (regular expression / regexp / regex / re)
+
+wzorzec = '[a-z.]+@[a-z.]+[a-z]+'
+
+if re.match(wzorzec, txt1):
+    print('txt1 pasuje')
+else:
+    print('txt1 nie pasuje')
+
+if re.match(wzorzec, txt2):
+    print('txt2 pasuje')
+else:
+    print('txt2 nie pasuje')

dzien6/regexp/re_przyklady.py

+import re
+
+txt1 = 'Ala ma kota, Ola ma psa, Zuzia ma rybki, Ela ma świnkę, babulaxyz.'
+
+txt2 = '''
+Ala ma kota Filemona.
+Ola ma psa Burka.
+Linia, która nie pasuje.
+Bożena ma rybkę.
+p12_inne bzdury
+'''
+
+mail = 'ala.kowalska@gmail.com'
+zlymail = 'ala$toniejestmail.pl'
+mail_z_dodatkami = 'ala.kowalska@gmail.com i jeszcze jakieś bzdury'
+mail_w_ukryty_w_srodku = 'początkowe bzdury ala.kowalska@gmail.com i jeszcze jakieś bzdury'
+
+# match : dopasowuje początek tekstu do wzorca
+print('match')
+
+wzorzec_emaila = r'[A-Za-z0-9_.\-]+@([A-Za-z0-9_\-]+\.)+[A-Za-z]+'
+
+# Jeśli napis uda się dopasować do wzorca, to wynikiem jest obiekt Match opisujący szczegóły dopasowania
+# m = re.match('.+@.+', mail)
+m = re.match(wzorzec_emaila, mail)
+print('wynik dla dobrego maila:', m)
+
+# match kończy się sukcesem, gdy tekst na początku zawiera szukany fragment
+
+# Jeśli napisu nie uda się dopasować, to wynikiem jest None
+m = re.match(wzorzec_emaila, zlymail)
+print('wynik dla złego maila:', m)
+
+m = re.match(wzorzec_emaila, mail_z_dodatkami)
+print('wynik dla maila z dodatkami:', m)
+
+m = re.match(wzorzec_emaila, mail_w_ukryty_w_srodku)
+print('wynik dla maila ukrytego w środku:', m)
+
+# Najbardziej typowy zapis wykorzystujący match:
+m = re.match(wzorzec_emaila, mail_z_dodatkami)
+if m:
+    print('Tekst pasuje')
+    print('Pozycje znalezionego tekstu:', m.start(), m.end())
+    print('Dopasowany fragment:', m.group())  # albo m[0]
+    print('Wycięty fragment:', mail_z_dodatkami[m.start():m.end()])
+else:
+    print('Tekst nie pasuje')
+print('\n----------\n')
+
+m = re.match(r'.la', txt1)
+print('match:', m)
+
+m = re.fullmatch(r'.la', txt1)
+print('fullmatch:', m)
+print()
+
+# fullmatch : dopasowuje cały tekst do wzorca
+# Zwraca None jeśli tekst zawiera dodatkowe znaki na końcu
+print('fullmatch')
+
+m = re.fullmatch(wzorzec_emaila, mail)
+print('wynik dla dobrego maila:', m)
+
+# Jeśli napisu nie uda się dopasować, to wynikiem jest None
+m = re.fullmatch(wzorzec_emaila, zlymail)
+print('wynik dla złego maila:', m)
+
+m = re.fullmatch(wzorzec_emaila, mail_z_dodatkami)
+print('wynik dla maila z dodatkami:', m)
+
+m = re.fullmatch(wzorzec_emaila, mail_w_ukryty_w_srodku)
+print('wynik dla maila ukrytego w środku:', m)
+
+print('\n----------\n')
+
+# search - szuka wystąpienia wzorca wewnątrz tekstu, nie musi on być na początku
+# znajduje pierwsze (ale maksymalne) dopasowanie
+print('search')
+
+m = re.search(r'.la', txt1)
+print(m)
+
+m = re.search(r'.la', txt1)
+print(m) # zwraca to sam, nie idzie dalej
+
+# w praktyce możemy wyciąć fragment napisu
+m = re.search(r'.la', txt1[10:])
+print(m) # zwraca to sam, nie idzie dalej
+
+
+m = re.search(r'k..a', txt1)
+print(m)
+
+m = re.search('chomik', txt1)
+print(m)
+
+# . oznacza dowolny
+# \. oznacza kropkę
+m = re.search(r'..\.', txt1)
+print(m)
+
+print()
+
+m = re.search(wzorzec_emaila, mail)
+print('wynik dla dobrego maila:', m)
+
+# Jeśli napisu nie uda się dopasować, to wynikiem jest None
+m = re.search(wzorzec_emaila, zlymail)
+print('wynik dla złego maila:', m)
+
+m = re.search(wzorzec_emaila, mail_z_dodatkami)
+print('wynik dla maila z dodatkami:', m)
+
+m = re.search(wzorzec_emaila, mail_w_ukryty_w_srodku)
+print('wynik dla maila ukrytego w środku:', m)
+
+print('\n----------\n')
+
+# findall : zwraca listę wszystkich dopasowanych fragmentów (listę stringów)
+
+lista = re.findall(r'.la', txt1)
+print(lista)
+
+lista = re.findall(r'\w+ ma \w+', txt2)
+print(lista)
+print('\n----------\n')
+
+# finditer - zwraca iterator pozwalający odczytać szczegóły kolejnych dopasowań
+# x = re.finditer(r'.la', txt1)
+# print(x)
+
+for m in re.finditer(r'.la', txt1):
+    print('Znaleziono', m)
+print()
+
+for m in re.finditer(r'\w+ ma \w+', txt2):
+    print(f'Znaleziono napis "{m.group()}" na pozycji od {m.start()} do {m.end()}')
+
+print('\n----------\n')
+
+# Za pomocą nawiasów okrągłych mogę oznaczać fragmenty wzorców - potem traktować jako tzw. grupy
+
+for m in re.finditer(r'(\w+) ma (\w+)', txt2):
+    print('Cały napis:', m.group())
+    print('  Grupa 0:', m.group(0))
+    print('  Osoba:', m.group(1))
+    print('  Zwierzę:', m.group(2))
+    # zamiast wywoływać group można też użyć indeksacji
+    print('  Osoba:', m[1])
+    print('  Zwierzę:', m[2])
+    #cale, osoba, zwierze = m
+    #print(cale, osoba, zwierze)
+
+    print()
+print('\n----------\n')
+
+# Jeśli mam taką potrzebę, to mogę wziąć pewien fragment w nawias, ale nie robić z niego grupy - zapis (?:  tzw. "grupa anonimowa"
+print('Grupy anonimowe:')
+for m in re.finditer(r'(?:\w+) ma (\w+)', txt2):
+    print('Cały napis:', m.group())
+    print('  grupa 1:', m.group(1))
+    print()
+print('\n----------\n')
+
+# Jeśli szukamy po jednym fragmencie w każdej linii, to lepiej zastosować schemat
+# for linia in linie: match
+
+linie = txt2.split('\n')
+for linia in linie:
+    #print(linia)
+    m = re.match(r'(\w+) ma (\w+)', linia)
+    if m:
+        print(f'Zalezione: imie = {m[1]}, zwierze = {m[2]}')
+    else:
+        print('  -- nie pasuje --')
+print()
+
+print('========')
+# w celu zwiększenia wydajności regexpa używane wielokrotnie (np. w pętli) warto wcześniej skompilować
+pattern = re.compile(r'(\w+) ma (\w+)')
+for linia in linie:
+    #print(linia)
+    m = pattern.match(linia)
+    if m:
+        print(f'Zalezione: imie = {m[1]}, zwierze = {m[2]}')
+    else:
+        print('  -- nie pasuje --')
+
+

dzien6/regexp/re_teksty.txt

+Ala ma pięć kotów i adres ala@warszawa.pl
+Ola mieszka pod kodem 02-333 Warszawa, data urodzenia 12 Feb 1995
+Ela ma maila ela@krakow.pl i 20 Sep 2001, kod pocztowy 31-100 Kraków
+Katarzyna pisze maile pod adres kasia@x.y.z.com i mieszka w 01-234 cośtam
+Jan ma datę z jedną cyfrą 3 May 2020.

dzien6/regexp/re_z_pliku1.py

+import re
+
+# Wersja pokazująca przetwarzanie linia po linii - ale w przypadku tego zadania to nie jest najlepszy sposób.
+
+with open('re_teksty.txt', encoding='utf-8') as wejscie:
+    for linia in wejscie:
+        # print(linia)
+        imie = re.search(r'\w+', linia).group()
+
+        m_kod = re.search(r'\d{2}-\d{3}', linia)
+        # w niektórych liniach kodu nie ma
+        if m_kod:
+            kod = m_kod.group()
+        else:
+            kod = '-'
+
+        m_email = re.search(r'[\w\-.]+@(\w+\.)+\w+', linia)
+        # inny zapis if-a
+        email = m_email.group() if m_email else '-'
+        print(f'imię: {imie}, kod: {kod}, email: {email}')

dzien6/regexp/re_z_pliku2.py

+import re
+
+# Wersja pokazująca przetwarzanie linia po linii - ale w przypadku tego zadania to nie jest najlepszy sposób.
+
+with open('re_teksty.txt', encoding='utf-8') as wejscie:
+    for linia in wejscie:
+        m_imie = re.search(r'\w+', linia)
+        imie = m_imie.group() if m_imie else '???'
+
+        m_kod = re.search(r'\d{2}-\d{3}', linia)
+        kod = m_kod.group() if m_kod else '-'
+
+        m_email = re.search(r'[\w\-.]+@(\w+\.)+\w+', linia)
+        email = m_email.group() if m_email else '-'
+
+        print(f'imię: {imie}, kod: {kod}, email: {email}')

dzien6/regexp/re_z_pliku3.py

+import re
+
+# Jeśli z wyrażenia korzystamy wielokrotnie (np. w pętli),
+# to warto je "skompilować" i korzystać z powstałego obiektu
+# To może mocno wpłynąć na wydajność.
+imie_pattern = re.compile(r'\w+')
+kod_pattern = re.compile(r'\d{2}-\d{3}')
+email_pattern = re.compile(r'[\w\-.]+@(\w+\.)+\w+')
+
+with open('re_teksty.txt', encoding='utf-8') as wejscie:
+    for linia in wejscie:
+        m_imie = imie_pattern.search(linia)
+        imie = m_imie.group() if m_imie else '???'
+
+        m_kod = kod_pattern.search(linia)
+        kod = m_kod.group() if m_kod else '-'
+
+        m_email = email_pattern.search(linia)
+        email = m_email.group() if m_email else '-'
+
+        print(f'imię: {imie}, kod: {kod}, email: {email}')

dzien6/regexp/re_z_pliku4.py

+import re
+
+with open('re_teksty.txt', encoding='utf-8') as f:
+    tresc = f.read() # wczytaj cały plik jako jeden string
+
+kody = re.findall(r'\d{2}-\d{3}', tresc)
+print('Kody pocztowe: ', kody)
+
+emaile = re.findall(r'[\w\-]+@(?:\w+\.)+\w+', tresc)
+print('Adresy email: ', emaile)
+
+daty = re.findall(r'\d{1,2} \w{3} \d{4}', tresc)
+print('Daty: ', daty)

dzien6/regexp/re_z_pliku5.py

+import re
+
+# wersja Konrada
+
+POST_CODE_PATTERN = re.compile(r'\d{2}-\d{3}')
+EMAIL_PATTERN = re.compile(r'[\w\-]+@(?:\w+\.)+\w+')
+DATE_PATTERN = re.compile(r'\d{1,2} \w{3} \d{4}')
+
+with open('re_teksty.txt', encoding='utf-8') as f:
+    tresc = f.read()
+    print('Kody pocztowe:', ', '.join(POST_CODE_PATTERN.findall(tresc)))
+    print('Adresy email:', ', '.join(EMAIL_PATTERN.findall(tresc)))
+    print('Daty:', ', '.join(DATE_PATTERN.findall(tresc)))

dzien6/regexp/zadanie.py

+# Napisz program znajdujący w dostarczonym pliku wszystkie wystąpienia:
+# I kodów pocztowych - 12-123
+# I adresów email - test@email.com
+# I dat - 12 Jan 1990
+# Skorzystaj z modułu re.
+
+import re
+
+with open('re_teksty.txt') as plik:
+    tresc = plik.read()
+
+kody = re.findall(r'\d{2}-\d{3}', tresc)
+print('Kody pocztowe:', kody)
+
+# daty = re.findall(r'\d{1,2} \w{3} \d{4}', tresc)
+daty = re.findall(r'\d{1,2} [A-Z][a-z]{2} \d{4}', tresc)
+print('Daty:', daty)
+
+maile = re.findall(r'[\w\-.]+@(?:\w+\.)+[a-z]+', tresc)
+print('Emaile:', maile)