Bonus_01.Wyrazenia_Regularne.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Wyrażenia Regularne\n",
    "# REGular EXpressions\n",
    "# REGEX\n",
    "---"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Some people, when confronted with a problem, think \"I\n",
    "know, I'll use regular expressions.\" Now they have two\n",
    "problems.\n",
    "-- Jamie Zawinski, '<alt.religion.emacs>' (08/12/1997)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://docs.python.org/3/howto/regex.html#regex-howto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Online RegEx tester i debugger"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://regex101.com/r/70ARRh/3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Simple example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "napis = 'abc def ghi jkl'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(4, 7), match='def'>\n"
     ]
    }
   ],
   "source": [
    "result = re.search('def', napis)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "result = re.search('xyz', napis)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "result = re.match('def', napis)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 3), match='abc'>\n"
     ]
    }
   ],
   "source": [
    "result = re.match('abc', napis)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Składnia wyrażeń regularnych\n",
    "\n",
    "##### Podstawowe wyrażenia\n",
    "\n",
    "- `.` - dopasowanie do _**JAKIEGOKOLWIEK**_ pojedynczego znaku z wyjątkiem końca linii\n",
    "- `^` - dopasowanie do _**POCZĄTKU**_ napisu\n",
    "- `$` - dopasowanie do _**KOŃCA**_ napisu\n",
    "- `[]` - dopasowanie do _**ZBIORU**_ znaków w środku []\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 1), match='a'>\n"
     ]
    }
   ],
   "source": [
    "result = re.search('.', 'abc')\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "result = re.search('.', '')\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(2, 3), match='c'>\n"
     ]
    }
   ],
   "source": [
    "result = re.search('c$', 'abc')\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 1), match='a'>\n"
     ]
    }
   ],
   "source": [
    "result = re.search('^a', 'abc')\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 1), match='a'>\n"
     ]
    }
   ],
   "source": [
    "result = re.search('[aeiou]', 'abc')\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "##### Operatory\n",
    "- `[x-y]` - dopasowanie do _**ZAKRESU**_ znaków od  *x* do *y*\n",
    "- `[^...]` - _**DOPEŁNIENIE**_  _**ZBIORU czy ZAKRESU**_\n",
    "- `a|b` - dopasowanie do _**a LUB b**_\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(1, 2), match='b'>\n"
     ]
    }
   ],
   "source": [
    "result = re.search('[a-z]', 'Abc')\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 1), match='A'>\n"
     ]
    }
   ],
   "source": [
    "result = re.search('[a-z]|[A-Z]', 'Abc')\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 1), match='7'>\n"
     ]
    }
   ],
   "source": [
    "result = re.search('[a-zA-Z0123456-9]', '7Abc')\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 1), match='A'>\n"
     ]
    }
   ],
   "source": [
    "result = re.search('[^0-9]', 'Abc')\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "##### Elementy odpowiedzialne za powtórzenia\n",
    "\n",
    " \n",
    "- `?` -  _**0 lub 1**_ powtórzeń poprzeprzeniego wyrażenia\n",
    "- `*` - _**0 lub więcej**_ powtórzeń poprzedniego wyrażenia (*Domknięcie/gwiazda Kleene'a*)\n",
    "- `+` - _**1 lub więcej**_ powtórzeń poprzedniego wyrażenia (*plus Kleene'a*)\n",
    "- `{N}` - _**DOKŁADNIE N**_ powtórzeń poprzedniego wyrażenia \n",
    "- `{N,}` - _**CO NAJMNIEJ N**_ powtórzeń poprzedniego wyrażenia\n",
    "- `{N,M}` - _**MIĘDZY N a M**_ powtórzeń poprzedniego wyrażenia\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 1), match='a'>\n"
     ]
    }
   ],
   "source": [
    "result = re.search('a?', 'abc')\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 0), match=''>\n"
     ]
    }
   ],
   "source": [
    "result = re.search('a?', 'Abc')\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 9), match='aaaaaaaaa'>\n"
     ]
    }
   ],
   "source": [
    "result = re.search('a*', 'aaaaaaaaabc')\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 0), match=''>\n"
     ]
    }
   ],
   "source": [
    "result = re.search('d*', 'aaaaaaaaabc')\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 9), match='aaaaaaaaa'>\n"
     ]
    }
   ],
   "source": [
    "result = re.search('a+', 'aaaaaaaaabc')\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 4), match='aaaa'>\n"
     ]
    }
   ],
   "source": [
    "result = re.search('a{4}', 'aaaabc')\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "result = re.search('a{4}', 'aaabc')\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "##### KLASY znaków\n",
    "\n",
    " \n",
    "- `\\d` - jeden znak będący _**cyfrą**_  (*\\[0-9\\]*)\n",
    "- `\\D` - jeden znak _**nie będący cyfrą**_ (*\\[^0-9\\]*)\n",
    "- `\\w` - jeden znak typu _**word**_ (alphanumeryczny + \"_\" *\\[a-zA-Z0-9_\\]*)\n",
    "- `\\W` - jeden znak typu _**nie typu word**_ \n",
    "- `\\s` - _**biały znak**_ (spacja, tabulacja, końce linii *\\[ \\t\\n\\r\\f\\v\\]*)\n",
    "- `\\S` - _**nie-biały znak**_ (*\\[^ \\t\\n\\r\\f\\v\\]*)\n",
    "- `\\b` - pusty znak na końcu/początku slowa\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abc', 'def', 'ghi', 'jkl']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'abc def ghi jkl'.split(' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abc', 'def', 'ghi', 'jkl']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.split('[\\\\s,;]','abc def,ghi;jkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abc', 'def', 'ghi', 'jkl']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.split(r'[\\s,;]','abc def,ghi;jkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(4, 7), match='foo'>\n"
     ]
    }
   ],
   "source": [
    "print(re.search(r'\\bfoo\\b', 'abc foo def'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(re.search(r'\\bfoo\\b', 'abcfoodef'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'michal@mail.net'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "email = \"michal@maremove_thisil.net\"\n",
    "m = re.search(\"remove_this\", email)\n",
    "email[:m.start()] + email[m.end():]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Backslash Plague - przekleństwo \"w-tył-ciachów\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `\\section` - napis do znalezienia\n",
    "- `\\\\section` - napis do podania do `compile`\n",
    "- `'\\\\\\\\section'` - literał pytoński\n",
    "- `r'\\\\section'` - literał pytoński typu regex string\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Groupowanie (*grouping*)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = re.search(r'(\\w+) (\\w+)','Isaac Newton - fizyk')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Isaac Newton'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Isaac'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Newton'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Isaac', 'Newton')"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.groups()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('124', '16')"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search(r\"(\\d+)\\.(\\d+)\", \"Długość 124.16 metrów\").groups()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcd'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = re.compile('(a(b)c)d')\n",
    "m = p.match('abcd')\n",
    "m.group(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.group(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'b'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.group(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "##### Niezachłanne powtarzanie (_Non-greedy Repetitions_)\n",
    "\n",
    " \n",
    "- `??` -  _**0 lub 1**_ powtórzeń poprzeprzeniego wyrażenia (niezachłannie)\n",
    "- `*?` -  _**0 lub więcej**_ powtórzeń poprzedniego wyrażenia (niezachłannie)\n",
    "- `+?` - _**1 lub więcej**_ powtórzeń poprzedniego wyrażenia (niezachłannie)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('abcdefg', 'h')"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search(r'(\\w+)(\\w+)','abcdefgh').groups()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('a', 'b')"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.search(r'(\\w+?)(\\w+?)','abcdefgh').groups()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = '<html><head><title>Title</title>'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<html><head><title>Title</title>'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = re.search('<.*>', s)\n",
    "m.group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<html>'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = re.search('<.*?>', s)\n",
    "m.group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<html>\n",
      "<head>\n",
      "<title>\n",
      "</title>\n"
     ]
    }
   ],
   "source": [
    "m = re.findall('<.*?>', s)\n",
    "for i in m:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Flagi kompilacji\n",
    "- `ASCII, A` Dopasowywuje \\w, \\b, \\s and \\d tylko na konkretnych kodach ASCII\n",
    "- `DOTALL, S` . pasuje nawet do końca linii\n",
    "- `IGNORECASE, I` Nierozróżnia małych i dużych liter.\n",
    "- `LOCALE, L` Uwzględnia Locale (strony kodowe).\n",
    "- `UNICODE, U` Uwzględnia znaki Unicode (czyli np. Ó i ó złapie przy I).\n",
    "- `MULTILINE, M` Dopasowywuje cały tekst (nie: linia po linii); wpływa na ^ i $.\n",
    "- `VERBOSE, X` (‘extended’) Czyni wyrażenia regularne bardziej czytelne "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_regex = re.compile('abc', re.I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<re.Match object; span=(0, 3), match='ABC'>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_regex.match('ABC')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This regex:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "pat = re.compile(r\"\\s*(?P<header>[^:]+)\\s*:(?P<value>.*?)\\s*$\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "is the same as the regex below ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "pat = re.compile(r\"\"\"\n",
    "                     \\s* # Skip leading whitespace\n",
    "       (?P<header>[^:]+) # Header name\n",
    "                   \\s* : # Whitespace, and a colon\n",
    "          (?P<value>.*?) # The header's value -- *? used to\n",
    "                         # lose the following trailing whitespace\n",
    "                    \\s*$ # Trailing whitespace to end-of-line\n",
    "\"\"\", re.VERBOSE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = pat.search(' User : michal')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'header': 'User ', 'value': ' michal'}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.groupdict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Rozszerzenia i dialekty\n",
    "- `(?aiLmsux)` - włącza compile flag \n",
    "- `(?P<name>...)` - named group\n",
    "- `(?(id/name)yes-pattern|no-pattern)` - if `id/name` exists:  `yes-pattern` , else:  `no-pattern`\n",
    "- `\\num` - dopasowywuje grupę nr *num*  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "re.search(r'(?i)abc','Abc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = re.compile(r'\\b(\\w+)\\s+\\1\\b')\n",
    "p.search('Paris in the the spring').group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = re.compile(r'(\\w).*\\1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(p.match('xalalalalalx'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(p.match('xalalalalal'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = re.match(r'(?P<first_name>\\w+) (?P<last_name>\\w+)', 'Isaac Newton - physicist')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m.group('first_name')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m.group('last_name')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m.groupdict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = re.compile(r'(<)?(\\w+@\\w+(?:\\.\\w+)+)(?(1)>|$)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(r.match('<ala@onet.pl>'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(r.match('ala@onet.pl'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(r.match('<ala@onet.pl'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## *Lookaheads* i *Look behind*\n",
    "- `(?=regex)` Positive Lookahead - dopasuje jeśli wzorzec ma po nim `regex`\n",
    "- `(?!regex)` Negative Lookahead - dopasuje jeśli wzorzec NIE ma po nim `regex`\n",
    "- `(?<=regex)` Positive look behind – dopasuje jeśli wzorzec ma przed sobą `regex`\n",
    "- `(?<!regex)` Negative look behind  – dopasuje jeśli wzorzec NIE ma przed sobą `regex`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Isaac\n",
      "Bob\n"
     ]
    }
   ],
   "source": [
    "for i in re.findall(r'(\\w+)\\s+(?=Newton)','Isaac Newton, Bob Newton, Albert Einstein'): print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('spreadsheet',)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.match(r'(.*)[.](?!bat$|exe$)[^.]*$','spreadsheet.xls').groups()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(re.match(r'.*[.](?!bat$|exe$)[^.]*$','excel.exe'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Podstawienia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = re.compile( '(blue|white|red)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p.sub( 'colour', 'blue socks and red shoes')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p.sub( 'colour', 'blue socks and red shoes', count=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = re.compile('x*')\n",
    "p.sub('-', 'abxd')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = re.compile('section{ ( [^}]* ) }', re.VERBOSE)\n",
    "str = 'section{First} section{second}'\n",
    "print(str)\n",
    "print(p.sub(r'subsection(\\1)',str))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Psforesor Aeadlbmlok, pesale rperot yuor abcneses pltompry.'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "def repl(m):\n",
    "    inner_word = list(m.group(2))\n",
    "    random.shuffle(inner_word)\n",
    "    return m.group(1) + \"\".join(inner_word) + m.group(3)\n",
    "\n",
    "text = \"Professor Abdolmalek, please report your absences promptly.\"\n",
    "re.sub(\"(\\w)(\\w+)(\\w)\", repl, text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "  \n",
      "bbbbb\n",
      "   cccccc\n",
      "         dddddddddddddd\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#flush left\n",
    "from re import findall,sub\n",
    "from functools import reduce\n",
    "\n",
    "s = \"\"\"\n",
    "          \n",
    "        bbbbb\n",
    "           cccccc\n",
    "                 dddddddddddddd\n",
    "\"\"\"\n",
    "\n",
    "indent = lambda s: reduce(min,map(len,findall('(?m)^ *(?=\\S)',s)))\n",
    "flush_left = lambda s: sub('(?m)^ {%d}' % indent(s),'',s)\n",
    "\n",
    "print(flush_left(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bogatsze regexy niż `re`\n",
    "\n",
    "https://pypi.org/project/regex/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}