From 36a76b85590813f510089cff7bc5af2b4e6a96d8 Mon Sep 17 00:00:00 2001 From: = <=> Date: Mon, 30 Oct 2023 12:27:29 +0100 Subject: [PATCH] PD 2 --- lab-01/lab-01.ipynb | 230 ++++++++-------- lab-02/lab-02.ipynb | 640 ++++++++++++++++++++++++++++++++++++++++++++ lab-02/zadanie-1.py | 12 + lab-02/zadanie-2.py | 12 + lab-02/zadanie-3.py | 12 + lab-02/zadanie-4.py | 12 + lab-02/zadanie-5.py | 9 + 7 files changed, 821 insertions(+), 106 deletions(-) create mode 100644 lab-02/lab-02.ipynb create mode 100644 lab-02/zadanie-1.py create mode 100644 lab-02/zadanie-2.py create mode 100644 lab-02/zadanie-3.py create mode 100644 lab-02/zadanie-4.py create mode 100644 lab-02/zadanie-5.py diff --git a/lab-01/lab-01.ipynb b/lab-01/lab-01.ipynb index 968253a..d9c1e71 100644 --- a/lab-01/lab-01.ipynb +++ b/lab-01/lab-01.ipynb @@ -2,24 +2,24 @@ "cells": [ { "cell_type": "markdown", + "id": "f2f83e23-5da0-48a5-a1f8-0e9c1d278054", + "metadata": { + "collapsed": false + }, "source": [ "# Języki formalne i złożoność obliczeniowa\n", "## Część 1: Wprowadzenie do Pythona: Listy i Słowniki" - ], - "metadata": { - "collapsed": false - }, - "id": "f2f83e23-5da0-48a5-a1f8-0e9c1d278054" + ] }, { "cell_type": "markdown", - "source": [ - "### Listy" - ], + "id": "76a7aeff-27be-40b8-ab65-5c335bb43ab0", "metadata": { "collapsed": false }, - "id": "76a7aeff-27be-40b8-ab65-5c335bb43ab0" + "source": [ + "### Listy" + ] }, { "cell_type": "code", @@ -46,8 +46,20 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 1, + "id": "28253e73f0cf6cdf", + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + } + ], "source": [ "# Prosta funkcja, która zwraca długość ciągu znaków\n", "def dlugosc_ciagu(s):\n", @@ -55,15 +67,15 @@ "\n", "# Testowanie funkcji\n", "print(dlugosc_ciagu(\"Hello\")) # Powinno zwrócić 5" - ], - "metadata": { - "collapsed": false - }, - "id": "28253e73f0cf6cdf" + ] }, { "cell_type": "code", "execution_count": null, + "id": "76669dd5fdc80ae3", + "metadata": { + "collapsed": false + }, "outputs": [], "source": [ "# Funkcja, która sprawdza, czy dany ciąg znaków kończy się na danym sufiksie\n", @@ -73,90 +85,100 @@ "# Testowanie funkcji\n", "print(konczy_sie_na(\"Automat\", \"mat\")) # Powinno zwrócić True\n", "print(konczy_sie_na(\"Automat\", \"tom\")) # Powinno zwrócić False" - ], - "metadata": { - "collapsed": false - }, - "id": "76669dd5fdc80ae3" + ] }, { "cell_type": "code", "execution_count": null, + "id": "76ab87d1fada40b4", + "metadata": { + "collapsed": false + }, "outputs": [], "source": [ "lista = [\"a\", \"b\", \"c\"]\n", "for indeks, wartość in enumerate(lista):\n", " print(indeks, wartość)" - ], - "metadata": { - "collapsed": false - }, - "id": "76ab87d1fada40b4" + ] }, { "cell_type": "code", "execution_count": null, + "id": "5f02c815b173da71", + "metadata": { + "collapsed": false + }, "outputs": [], "source": [ "lista1 = [1, 2, 3]\n", "lista2 = [\"a\", \"b\", \"c\"]\n", "for liczba, litera in zip(lista1, lista2):\n", " print(liczba, litera)" - ], - "metadata": { - "collapsed": false - }, - "id": "5f02c815b173da71" + ] }, { "cell_type": "code", "execution_count": null, + "id": "c5dd20abbdf5436", + "metadata": { + "collapsed": false + }, "outputs": [], "source": [ "kwadraty = [x**2 for x in range(10)]\n", "print(kwadraty)" - ], - "metadata": { - "collapsed": false - }, - "id": "c5dd20abbdf5436" + ] }, { "cell_type": "markdown", + "id": "ab397b83e524d8c0", + "metadata": { + "collapsed": false + }, "source": [ "#### Zadanie 1: \n", "Stwórz listę `alfabet`, która będzie zawierać litery alfabetu od 'a' do 'z'. Następnie stwórz listę `stany`, która będzie zawierać stany automatu w postaci \"q0\", \"q1\", ..., \"q25\". Wykorzystaj pętlę for oraz funkcję `range()` do generowania listy `stany`. Wykorzystaj `list comprehension` \n" - ], - "metadata": { - "collapsed": false - }, - "id": "ab397b83e524d8c0" + ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], + "execution_count": 2, + "id": "e2ea41507ffa87cf", "metadata": { "collapsed": false }, - "id": "e2ea41507ffa87cf" + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A\n" + ] + } + ], + "source": [ + "print(ord(a))" + ] }, { "cell_type": "markdown", + "id": "1e5ec4e26f0c50f7", + "metadata": { + "collapsed": false + }, "source": [ "### Słowniki\n", "\n", "Słowniki w Pythonie to nieuporządkowane kolekcje par klucz-wartość. Klucze w słowniku muszą być unikalne." - ], - "metadata": { - "collapsed": false - }, - "id": "1e5ec4e26f0c50f7" + ] }, { "cell_type": "code", "execution_count": null, + "id": "f9c9f57242145098", + "metadata": { + "collapsed": false + }, "outputs": [], "source": [ "# Definicja słownika\n", @@ -173,39 +195,39 @@ "del slownik[\"klucz2\"]\n", "\n", "print(slownik)" - ], - "metadata": { - "collapsed": false - }, - "id": "f9c9f57242145098" + ] }, { "cell_type": "markdown", + "id": "6f0f5a0585b51651", + "metadata": { + "collapsed": false + }, "source": [ "#### Zadanie 2: \n", "Stwórz słownik `delta`, który będzie reprezentować funkcję przejścia dla automatu rozpoznającego ciągi nad alfabetem {a, b}, które kończą się na \"ab\". Słownik powinien mieć postać:\n", "\n" - ], - "metadata": { - "collapsed": false - }, - "id": "6f0f5a0585b51651" + ] }, { "cell_type": "code", "execution_count": null, + "id": "3d6214e7ae9fcb1e", + "metadata": { + "collapsed": false + }, "outputs": [], "source": [ "delta = {}" - ], - "metadata": { - "collapsed": false - }, - "id": "3d6214e7ae9fcb1e" + ] }, { "cell_type": "code", "execution_count": null, + "id": "f8abadaa6bf0e2f6", + "metadata": { + "collapsed": false + }, "outputs": [], "source": [ "def akceptuje(delta, ciag, stan_poczatkowy='q0', stan_akceptujacy='q2'):\n", @@ -226,24 +248,24 @@ "input3 = \"ab\"\n", "output3 = akceptuje(delta, input3)\n", "print(f\"Ciąg '{input3}' jest akceptowany: {output3}\") # True, bo to dokładnie ciąg \"ab\"\n" - ], - "metadata": { - "collapsed": false - }, - "id": "f8abadaa6bf0e2f6" + ] }, { "cell_type": "markdown", + "id": "392d7fbc05a6eb53", + "metadata": { + "collapsed": false + }, "source": [ "## Część 2: Implementacja DFA w Pythonie" - ], - "metadata": { - "collapsed": false - }, - "id": "392d7fbc05a6eb53" + ] }, { "cell_type": "markdown", + "id": "5fa20c2c91c62833", + "metadata": { + "collapsed": false + }, "source": [ "## Definicja DFA\n", "\n", @@ -254,15 +276,19 @@ "- δ to funkcja przejścia\n", "- q_0 to stan początkowy\n", "- F to zbiór stanów akceptujących\n" - ], - "metadata": { - "collapsed": false - }, - "id": "5fa20c2c91c62833" + ] }, { "cell_type": "code", "execution_count": 11, + "id": "7832429ab35cf033", + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-15T15:25:55.448167Z", + "start_time": "2023-10-15T15:25:55.437Z" + }, + "collapsed": false + }, "outputs": [], "source": [ "class DFA:\n", @@ -278,29 +304,25 @@ " for symbol in string:\n", " stan = self.delta[stan][symbol]\n", " return stan in self.F" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-15T15:25:55.448167Z", - "start_time": "2023-10-15T15:25:55.437Z" - } - }, - "id": "7832429ab35cf033" + ] }, { "cell_type": "markdown", - "source": [ - "#### Zadanie 3: Zaimplementuj automat, który akceptuje ciągi nad alfabetem {a,b}, które mają parzystą liczbę liter a." - ], + "id": "6e469ff8ae2db729", "metadata": { "collapsed": false }, - "id": "6e469ff8ae2db729" + "source": [ + "#### Zadanie 3: Zaimplementuj automat, który akceptuje ciągi nad alfabetem {a,b}, które mają parzystą liczbę liter a." + ] }, { "cell_type": "code", "execution_count": null, + "id": "df161735ce34418d", + "metadata": { + "collapsed": false + }, "outputs": [], "source": [ "Q1 = {}\n", @@ -316,14 +338,14 @@ "print(dfa1.akceptuje(\"abab\")) # True\n", "print(dfa1.akceptuje(\"aba\")) # True\n", "print(dfa1.akceptuje(\"aaab\")) # False" - ], - "metadata": { - "collapsed": false - }, - "id": "df161735ce34418d" + ] }, { "cell_type": "markdown", + "id": "347ede9e88ff27d0", + "metadata": { + "collapsed": false + }, "source": [ "### Zadanie domowe:\n", "\n", @@ -350,19 +372,15 @@ "False\n", "True\n", "```" - ], - "metadata": { - "collapsed": false - }, - "id": "347ede9e88ff27d0" + ] }, { "cell_type": "markdown", - "source": [], + "id": "e93220c2185b827b", "metadata": { "collapsed": false }, - "id": "e93220c2185b827b" + "source": [] } ], "metadata": { @@ -381,7 +399,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.10.11" } }, "nbformat": 4, diff --git a/lab-02/lab-02.ipynb b/lab-02/lab-02.ipynb new file mode 100644 index 0000000..1aec1b7 --- /dev/null +++ b/lab-02/lab-02.ipynb @@ -0,0 +1,640 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Języki formalne i złożoność obliczeniowa\n", + "## Część 1: Wprowadzenie do biblioteki re\n" + ], + "metadata": { + "collapsed": false + }, + "id": "f5376d249e31d5aa" + }, + { + "cell_type": "markdown", + "source": [ + "Wyrażenia regularne będziemy robić na podstawie języka python3. Dokumentacja: https://docs.python.org/3.11/library/re.html\n", + "\n", + "Użyteczna strona do testowania wyrażeń regularnych: https://regex101.com/\n" + ], + "metadata": { + "collapsed": false + }, + "id": "ce091d4ec144df32" + }, + { + "cell_type": "markdown", + "source": [ + "# Podstawowe funkcje" + ], + "metadata": { + "collapsed": false + }, + "id": "35428280eb1f704" + }, + { + "cell_type": "markdown", + "source": [ + "## Match\n", + "match - zwraca dopasowanie od początku stringa" + ], + "metadata": { + "collapsed": false + }, + "id": "9674be284007455d" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "import re\n", + "wynik = re.match(r'Ala', 'Ala ma kota. Kot ma Alę.')\n", + "print(wynik)\n", + "print(f\"Dopasowano: '{wynik.group()}', początek: {wynik.start()}, koniec: {wynik.end()}\")\n" + ], + "metadata": { + "collapsed": false + }, + "id": "fa7637b60ae679b5" + }, + { + "cell_type": "markdown", + "source": [ + "## Search\n", + "search - zwraca pierwsze dopasowanie w napisie\n" + ], + "metadata": { + "collapsed": false + }, + "id": "626c591ab52a086" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# search\n", + "wynik = re.search(r'ni', 'Może nie najtaniej, ale jako tako.')\n", + "\n", + "if wynik:\n", + " print(f\"Dopasowano: '{wynik.group()}', początek: {wynik.start()}, koniec: {wynik.end()}\")\n", + "else:\n", + " print('Nie znaleziono szukanego ciągu znaków.')" + ], + "metadata": { + "collapsed": false + }, + "id": "4f5d7077a85b7108" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "tekst = \"Kto zakłóca ciszę nocną musi ponieść karę: 100 batów!\"\n", + "\n", + "wzorzec = re.compile('ci')\n", + "\n", + "wynik = wzorzec.search(tekst)\n", + "\n", + "if wynik:\n", + " print(f\"Dopasowano: '{wynik.group()}', początek: {wynik.start()}, koniec: {wynik.end()}\")\n", + "else:\n", + " print('Nie znaleziono szukanego ciągu znaków.')" + ], + "metadata": { + "collapsed": false + }, + "id": "b9da286f8d6936fb" + }, + { + "cell_type": "markdown", + "source": [ + "## findall\n", + "findall - zwraca listę wszystkich dopasowań\n" + ], + "metadata": { + "collapsed": false + }, + "id": "600b87dd6af48c04" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# findall\n", + "wzorzec = re.compile('o')\n", + "\n", + "wynik = wzorzec.findall(tekst)\n", + "\n", + "if len(wynik) > 0:\n", + " print(type(wynik))\n", + " print(f'Dopasowano: {wynik}')\n", + "else:\n", + " print(f'{wynik} Nie znaleziono szukanego ciągu znaków.')" + ], + "metadata": { + "collapsed": false + }, + "id": "37a93d9d61c6178d" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "wzorzec = re.compile('o')\n", + "\n", + "wynik = wzorzec.finditer(tekst)\n", + "for w in wynik:\n", + " print(type(w))\n", + " print(f'Dopasowano: \"{w.group()}\", początek: {w.start()}, koniec: {w.end()}')" + ], + "metadata": { + "collapsed": false + }, + "id": "3232906632de2fe1" + }, + { + "cell_type": "markdown", + "source": [ + "*Uwaga*: pobierając z iteratora elementy, usuwamy je, nie można zatem ponownie się do nich odwołać." + ], + "metadata": { + "collapsed": false + }, + "id": "62e8a0370ee58827" + }, + { + "cell_type": "markdown", + "source": [ + "## Użycie przedrostka 'r' w wyrażeniach regularnych w Pythonie\n", + "\n", + "W Pythonie przedrostek `r` przed łańcuchem znaków oznacza \"surowy\" łańcuch znaków (ang. *raw string*). Dlaczego jest to przydatne w kontekście wyrażeń regularnych?\n", + "\n", + "Wyrażenia regularne często używają znaków specjalnych, takich jak `\\d`, `\\w`, `\\b` itp. W standardowych łańcuchach znaków w Pythonie, znaki te mają specjalne znaczenie. Na przykład, `\\t` oznacza tabulację, a `\\n` oznacza nową linię.\n", + "\n", + "Jeśli chcemy użyć takiego wyrażenia regularnego w Pythonie, musielibyśmy podwajać znaki ukośnika, aby uniknąć konfliktu z wbudowanymi sekwencjami ucieczki w łańcuchach znaków, np. `\\\\d`, `\\\\w`." + ], + "metadata": { + "collapsed": false + }, + "id": "6342ff85cd5fc35a" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# Bez użycia surowego łańcucha znaków\n", + "result1 = re.findall(\"\\\\d+\", \"123 abc 456\")\n", + "print(result1)\n", + "\n", + "# Używając surowego łańcucha znaków\n", + "result2 = re.findall(r\"\\d+\", \"123 abc 456\")\n", + "print(result2)\n" + ], + "metadata": { + "collapsed": false + }, + "id": "b09fa3103ec18719" + }, + { + "cell_type": "markdown", + "source": [ + "## sub\n", + "Kolejną użyteczną metodą jest sub(), która pozwala na zmianę wzorca na inny ciąg znaków:" + ], + "metadata": { + "collapsed": false + }, + "id": "e9e3f41e90bbd746" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "wzorzec = re.compile(r'ni')\n", + "\n", + "zmieniony = wzorzec.sub('Ni!', tekst)\n", + "print(zmieniony)" + ], + "metadata": { + "collapsed": false + }, + "id": "af633211d7faca67" + }, + { + "cell_type": "markdown", + "source": [ + "## split\n", + "split - dzieli napis na podstawie wzorca" + ], + "metadata": { + "collapsed": false + }, + "id": "ea9205aa03ed7476" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "wzorzec = re.compile(r' ')\n", + "\n", + "wynik = wzorzec.split(tekst)\n", + "print(f'Uzyskano {len(wynik)} wyniki/ów.')\n", + "for w in wynik:\n", + " print(w)" + ], + "metadata": { + "collapsed": false + }, + "id": "71dc3b254a93f31c" + }, + { + "cell_type": "markdown", + "source": [ + "# Metaznaki\n", + "[] - zbiór znaków\n", + "\n", + ". - jakikolwiek znak\n", + "\n", + "^ - początek napisu\n", + "\n", + "$ - koniec napisu\n", + "\n", + "? - znak występuje lub nie występuje\n", + "\n", + "\\* - zero albo więcej pojawień się\n", + "\n", + "\\+ - jeden albo więcej pojawień się\n", + "\n", + "{} - dokładnie tyle pojawień się\n", + "\n", + "| - lub\n", + "\n", + "() - grupa\n", + "\n", + "\\ - znak ucieczki\n", + "\n", + "\\d digit\n", + "\n", + "\\D nie digit\n", + "\n", + "\\s whitespace\n", + "\n", + "\\S niewhitespace" + ], + "metadata": { + "collapsed": false + }, + "id": "4b16abb6848f09ae" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "wzorzec = re.compile(r'.')\n", + "print(wzorzec.findall(tekst))" + ], + "metadata": { + "collapsed": false + }, + "id": "ac6669cac4f52d27" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# jeden lub wiecej / zero lub wiecej\n", + "\n", + "tekst = \"BCAAABGTAABBBCCTTSAGG4324242\"\n", + "print(f'Łańcuch: {tekst}')\n", + "wzorzec = re.compile(r'X+')\n", + "print(f'Jeden lub więcej X: {wzorzec.findall(tekst)}')\n", + "wzorzec = re.compile(r'X*')\n", + "print(f'Zero lub więcej X: {wzorzec.findall(tekst)}')" + ], + "metadata": { + "collapsed": false + }, + "id": "634e4b66a5081f97" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# zero lub jeden\n", + "\n", + "print(f'Łańcuch: {tekst}')\n", + "wzorzec = re.compile(r'.?')\n", + "print(wzorzec.findall(tekst))\n", + "wzorzec = re.compile(r'.?T')\n", + "print(wzorzec.findall(tekst))" + ], + "metadata": { + "collapsed": false + }, + "id": "44195e00a81b23fb" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "print(f'Łańcuch: {tekst}')\n", + "wzorzec = re.compile(r'A+')\n", + "print(f'Dopasowanie zachłanne: {wzorzec.findall(tekst)}')\n", + "wzorzec = re.compile(r'A+?')\n", + "print(f'Dopasowanie leniwe: {wzorzec.findall(tekst)}')" + ], + "metadata": { + "collapsed": false + }, + "id": "ea861a33e942d42a" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "print(f'Łańcuch: {tekst}')\n", + "\n", + "# dokladnie 3 dopasowania\n", + "wzorzec = re.compile(r'A{3}')\n", + "print(f'{wzorzec.findall(tekst)}')\n", + "\n", + "# pomiedzy 2 i 3 dopasowania\n", + "wzorzec = re.compile(r'A{2,3}')\n", + "print(f'{wzorzec.findall(tekst)}')\n", + "\n", + "# 2 lub wiecej dopasowan\n", + "wzorzec = re.compile(r'A{2,}')\n", + "print(f'{wzorzec.findall(tekst)}')\n", + "\n", + "# 3 lub mniej dopasowan\n", + "wzorzec = re.compile(r'A{,3}')\n", + "print(f'{wzorzec.findall(tekst)}')" + ], + "metadata": { + "collapsed": false + }, + "id": "751272b81731af36" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# poczatek lub koniec lancucha\n", + "\n", + "tekst = \"Ale pięknie pachnie! Maciek, co gotujesz?\"\n", + "\n", + "# poczatek lancucha\n", + "wzorzec = re.compile(r'^Ale')\n", + "print(f'{wzorzec.findall(tekst)}')\n", + "\n", + "# poczatek lancucha\n", + "wzorzec = re.compile(r'^ale')\n", + "print(f'{wzorzec.findall(tekst)}')\n", + "\n", + "# koniec lancucha\n", + "wzorzec = re.compile(r'Ale$')\n", + "print(f'{wzorzec.findall(tekst)}')\n", + "\n", + "# koniec lancucha + znak ucieczki\n", + "wzorzec = re.compile(r'gotujesz\\?$')\n", + "print(f'{wzorzec.findall(tekst)}')" + ], + "metadata": { + "collapsed": false + }, + "id": "97bcd3ff7cc3913" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# grupy znakow\n", + "wzorzec = re.compile(r'[A-Z]')\n", + "print(f'Duże litery: {wzorzec.findall(tekst)}')\n", + "\n", + "wzorzec = re.compile(r'[a-z]')\n", + "print(f'Małe litery: {wzorzec.findall(tekst)}')\n", + "\n", + "wzorzec = re.compile(r'[A-z]')\n", + "print(f'Małe i duże litery: {wzorzec.findall(tekst)}')\n", + "\n", + "wzorzec = re.compile(r'[aeiou]')\n", + "print(f'Samogłoski: {wzorzec.findall(tekst)}')" + ], + "metadata": { + "collapsed": false + }, + "id": "ee099e6e1e5e2f80" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# wzorzec(?=X) - dopasowanie, jeśli po nim występuje X\n", + "\n", + "tekst = \"ACABADAHSAIIIQIIINSAODIANSAAGAGAGGGGPAAG\"\n", + "\n", + "print(f'Łańcuch: {tekst}')\n", + "wzorzec = re.compile(r'G+(?=A)')\n", + "print(f'{wzorzec.findall(tekst)}')" + ], + "metadata": { + "collapsed": false + }, + "id": "dd6351952639ef42" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "tekst = \"Ale się zrobiła świąteczna atmosfera.\"\n", + "wzorzec = re.compile(r'Ale|świąteczna|zrobiła')\n", + "print(f'{wzorzec.findall(tekst)}')" + ], + "metadata": { + "collapsed": false + }, + "id": "c7f3e1b9d16c91db" + }, + { + "cell_type": "markdown", + "source": [ + "## Znaki specjalne\n", + "\n", + "\\s\t- biały znak\n", + "\n", + "\\S\t- nie-biały znak\n", + "\n", + "\\d\t- cyfra\n", + "\n", + "\\D\t- nie-cyfra\n", + "\n", + "\\w\t- znaki alfanumeryczne (litery i cyfry) oraz\n", + " \n", + "\\W\t- znaki nie-alfanumeryczne i nie\n", + " \n", + "\\b\t- początek lub koniec ,,słowa’’\n", + " \n", + "\\B\t- nie początek lub koniec ,,słowa''\n", + "\n", + "[a-z]\t- małe litery\n", + "\n", + "[A-Z]\t- wielkie litery\n", + "\n", + "[0-9]\t- cyfry\n" + ], + "metadata": { + "collapsed": false + }, + "id": "c1a7435b7887f5c2" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "wzorzec = re.compile(r'\\w+')\n", + "print(f'Wyrazy: {wzorzec.findall(tekst)}')\n" + ], + "metadata": { + "collapsed": false + }, + "id": "3b1b1f147233455d" + }, + { + "cell_type": "markdown", + "source": [ + "## Część II: Zadania praktyczne\n", + "\n", + "### Zadanie 1: Wyszukiwanie numerów telefonu\n", + "\n", + "Napisz wyrażenie regularne, które znajdzie wszystkie numery telefonu w tekście. Zakładamy, że numer telefonu ma format `xxx-xxx-xxx` lub `xxx xxx xxx`.\n" + ], + "metadata": { + "collapsed": false + }, + "id": "e0670d19927add2b" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "tekst = \"\"\"\n", + "Jan: 123-456-789\n", + "Anna: 987 654 321\n", + "Karol: 456-789-123\n", + "Zbyszek: 53252525342252\n", + "Tytus: aaaa666432\n", + "\"\"\"\n", + "\n", + "wzorzec = re.compile(r\"\")\n", + "print(f'Numery: {wzorzec.findall(tekst)}')" + ], + "metadata": { + "collapsed": false + }, + "id": "aecbbf61477429ac" + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "tekst = \"\"\"\n", + "jan.kowalski@gmail.com\n", + "anna.zielinska@amu.edu.pl\n", + "karol.nowak@interia.pl\n", + "hello world\n", + "@test.pl\n", + "x@x\n", + "fff22@gmail.com\n", + "\"\"\"\n", + "\n", + "wzorzec = re.compile(r\"\")\n", + "print(f'Adresy: {wzorzec.findall(tekst)}')" + ], + "metadata": { + "collapsed": false + }, + "id": "1dcf9585d7b78073" + }, + { + "cell_type": "markdown", + "source": [ + "# Część III Zadanie domowe\n", + "\n", + "## Zadanie 1: Wyszukiwanie kodów pocztowych (2 pkt)\n", + "Napisz wyrażenie regularne, które znajdzie wszystkie polskie kody pocztowe w tekście. Zakładamy, że kod pocztowy ma format XX-XXX, gdzie X to cyfra.\n", + "\n", + "## Zadanie 2: Weryfikacja adresu URL (2 pkt)\n", + "Zaimplementuj wyrażenie regularne, które sprawdzi, czy dany ciąg jest poprawnym adresem URL. Zakładamy, że adres URL zaczyna się od http:// lub https://, po którym następuje nazwa domeny i opcjonalnie ścieżka.\n", + "\n", + "## Zadanie 3: Weryfikacja numeru PESEL (2 pkt)\n", + "Napisz wyrażenie regularne, które sprawdzi, czy dany ciąg jest poprawnym numerem PESEL. PESEL składa się z 11 cyfr.\n", + "\n", + "## Zadanie 4: Wyszukiwanie tagów HTML (3 pkt)\n", + "Zaimplementuj wyrażenie regularne, które znajdzie wszystkie tagi (otwierające i zamykające) w tekście HTML.\n", + "\n", + "## Zadanie 5: Weryfikacja hasła (4 pkt)\n", + "Napisz wyrażenie regularne, które sprawdzi, czy dane hasło spełnia następujące kryteria:\n", + "\n", + "Ma co najmniej 8 znaków.\n", + "\n", + "Zawiera co najmniej jedną dużą literę.\n", + "\n", + "Zawiera co najmniej jedną małą literę.\n", + "\n", + "Zawiera co najmniej jedną cyfrę.\n", + "\n", + "Zawiera co najmniej jeden ze znaków specjalnych: @, #, $, %, &, *, !.\n", + "\n", + "\n", + "Rozwiązania zadań należy wysłać na adres email: **miczar1@amu.edu.pl** z tytułem: **[DJFZ][NrIndeksu] Zadanie domowe Zajęcia 2**. Jako załącznik należy wysłać 5 plików .py (zadanie1.py, zadanie2.py itd.) z rozwiązaniem. Skrpyty na wejściu mają przyjmować plik tekstowy `in.txt` a następnie zapisać rezultaty do pliku `out.txt` (każdy pasujący element to jeden wiersz) lub (True/False jak w poprzednim zadaniu) Przykładowe wywołanie skryptu: `python zadanie1.py in.txt`." + ], + "metadata": { + "collapsed": false + }, + "id": "ae6ffce379f9676d" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/lab-02/zadanie-1.py b/lab-02/zadanie-1.py new file mode 100644 index 0000000..5a29510 --- /dev/null +++ b/lab-02/zadanie-1.py @@ -0,0 +1,12 @@ +import re + +tekst = """ +Jan: 12-452 +Anna: 987 65 +Karol: 456-78 +Zbyszek: 53252525342252 +Tytus: aaaa666432 +""" + +wzorzec = re.compile(r"\d\d-\d\d\d") +print(f'Numery: {wzorzec.findall(tekst)}') \ No newline at end of file diff --git a/lab-02/zadanie-2.py b/lab-02/zadanie-2.py new file mode 100644 index 0000000..5bb30a3 --- /dev/null +++ b/lab-02/zadanie-2.py @@ -0,0 +1,12 @@ +import re + +tekst = """ +Jan: https://regex101.com/ +Anna: 987 65 +Karol: 456-78 +Zbyszek: 53252525342252 +Tytus: aaaa666432 +""" + +wzorzec = re.compile(r"(https|http):\/\/(www.)?[\d\w]+\.\w+[^.]*") +print(f'Numery: {wzorzec.findall(tekst)}') \ No newline at end of file diff --git a/lab-02/zadanie-3.py b/lab-02/zadanie-3.py new file mode 100644 index 0000000..8a9c7bd --- /dev/null +++ b/lab-02/zadanie-3.py @@ -0,0 +1,12 @@ +import re + +tekst = """ +Jan: https://regex101.com/ +Anna: 987 65 +Karol: 456-78 +Zbyszek: 12345678901 +Tytus: aaaa666432 +""" + +wzorzec = re.compile(r"\d{11}") +print(f'Numery: {wzorzec.findall(tekst)}') \ No newline at end of file diff --git a/lab-02/zadanie-4.py b/lab-02/zadanie-4.py new file mode 100644 index 0000000..ccffd80 --- /dev/null +++ b/lab-02/zadanie-4.py @@ -0,0 +1,12 @@ +import re + +tekst = """ +Jan: https://regex101.com/ +Anna: 987 65 +Karol: 456-78 <\a> +Zbyszek: 12345678901 +Tytus: aaaa666432 +""" + +wzorzec = re.compile(r"<[^>]*>") +print(f'Numery: {wzorzec.findall(tekst)}') \ No newline at end of file diff --git a/lab-02/zadanie-5.py b/lab-02/zadanie-5.py new file mode 100644 index 0000000..74d125f --- /dev/null +++ b/lab-02/zadanie-5.py @@ -0,0 +1,9 @@ +import re + +tekst = """ +asdasdas9@asSd +as@d@asjdioajsd7y7asdSa1 +""" + +wzorzec = re.compile(r"(?=.*[a-z])(?=.*[A-Z])(?=.*[\d])(?=.*[@#$%&*!]).{8,}") +print(f'Numery: {wzorzec.findall(tekst)}') \ No newline at end of file