lectures/2016-03-03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Регулярные выражения в Python\n",
    "\n",
    "## Теория:\n",
    "\n",
    "Регулярные выражения - формальный язык для поиска и манипуляций текстом, в частности подстроками.\n",
    "\n",
    "Регулярные выражения основаны на масках (pattern). Это шаблоны или правила, которые удовлетворяют некоторому множеству строк.\n",
    "Так, из простых примеров, можно найти все вхождения \"кот\" в строку \"кот терракот котом котором\".\n",
    "\n",
    "Плюсы:\n",
    "+ удобны в использовании\n",
    "+ универсальны\n",
    "\n",
    "Минусы:\n",
    "- регулярные выражения для сложных задач (с множеством условий) нечитабельны и сложны в разработке\n",
    "- регулярные выражения работают медленно\n",
    "\n",
    "\n",
    "В Python регулярные выражения предоставляются библиотекой \"re\". Она изначально установлена для всех официальных сборок Python.\n",
    "\n",
    "Рассмотрим самые часто используемые методы:\n",
    "- `re.match()`\n",
    "- `re.search()`\n",
    "- `re.findall()`\n",
    "- `re.split()`\n",
    "- `re.sub()`\n",
    "- `re.compile()`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Text for searching:\n",
      "The object has the words \"NO STEP\" on it and could be from the plane's horizontal stabilizer - the wing-like parts attached to the tail, sources say. It was discovered by an American who has been blogging about the search for MH370.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "# Текст, над которым мы будем проводить операции с помощью регулярных выражений\n",
    "text = \"The object has the words \\\"NO STEP\\\" on it and could be from the plane's horizontal stabilizer - \\\n",
    "        the wing-like parts attached to the tail, sources say. It was discovered by an American who has been \\\n",
    "        blogging about the search for MH370.\"\n",
    "\n",
    "print(\"Text for searching:\\n%s\\n\" % (text))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Рассмотрим методны на простом примере: поиске полного соответствия\n",
    "\n",
    "```python\n",
    "re.match(pattern, string)\n",
    "``` \n",
    "ищет подходящую под маску pattern строку в начале строки text.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Searching for \"The\" using match.\n",
      "Result:\n",
      "The\n",
      "\n"
     ]
    }
   ],
   "source": [
    "pattern = r'The'  # r перед строкой указывает, что это \"raw string\" для регулярного выражения\n",
    "\n",
    "# Почему так см.\n",
    "# https://docs.python.org/3/howto/regex.html#the-backslash-plague\n",
    "\n",
    "result = re.match(pattern, text)\n",
    "# При успешном поиске будет создан особый объект с результатом, при неуспешном в result запишется None, то есть ничего.\n",
    "# Если попытаться вывести result - возникнет ошибка\n",
    "\n",
    "# Если найдено, вывести найденный текст, если нет, вывести, что не найдено.\n",
    "result = result.group(0) if result else \"Not found\"\n",
    "# используем метод .group(0) чтобы указать, что хотим получить результат\n",
    "# первой группы. О группах позже\n",
    "print(\"Searching for \\\"%s\\\" using match.\\nResult:\\n%s\\n\" %\n",
    "      (str(pattern), str(result)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Попробуем использовать match для поиска второго слова\n",
    "\n",
    "Напишем вспомогательную функцию"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Searching for \"object\" using match.\n",
      "Result:\n",
      "Not found\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def result_or_not_found(result):\n",
    "    return result.group(0) if result else \"Not found\"\n",
    "\n",
    "pattern = r'object'\n",
    "result = result_or_not_found(re.match(pattern, text))\n",
    "print(\"Searching for \\\"%s\\\" using match.\\nResult:\\n%s\\n\" %\n",
    "      (str(pattern), str(result)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`re.search(pattern, string)` похож на `match()`, но он ищет не только в начале строки\n",
    "\n",
    "Повторим опыт с помощью `search`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Searching for \"The\" using search.\n",
      "Result:\n",
      "The\n",
      "\n"
     ]
    }
   ],
   "source": [
    "pattern = r'The'\n",
    "result = result_or_not_found(re.search(pattern, text))\n",
    "print(\"Searching for \\\"%s\\\" using search.\\nResult:\\n%s\\n\" %\n",
    "      (str(pattern), str(result)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Попробуем использовать search для поиска второго слова"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Searching for \"object\" using search.\n",
      "Result:\n",
      "object\n",
      "\n"
     ]
    }
   ],
   "source": [
    "pattern = r'object'\n",
    "result = result_or_not_found(re.search(pattern, text))\n",
    "print(\"Searching for \\\"%s\\\" using search.\\nResult:\\n%s\\n\" %\n",
    "      (str(pattern), str(result)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В отличие от match мы получили искомую строку.\n",
    "\n",
    "-----\n",
    "\n",
    "`re.findall(pattern, string)` возвращает список всех найденных совпадений"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Searching for \"the\" using findall.\n",
      "Result:\n",
      "['the', 'the', 'the', 'the', 'the']\n",
      "\n"
     ]
    }
   ],
   "source": [
    "pattern = r'the'\n",
    "result = re.findall(pattern, text)\n",
    "print(\"Searching for \\\"%s\\\" using findall.\\nResult:\\n%s\\n\" %\n",
    "      (str(pattern), str(result)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`re.split(pattern, string, [maxsplit=0])` делит строку по маске\n",
    "`maxsplit` определяет максимальное количество разделений. При 0 метод разделит строку столько раз, сколько возможно."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Splitting text by \"the\" using split.\n",
      "Result:\n",
      "['The object has ', ' words \"NO STEP\" on it and could be from ', \" plane's horizontal stabilizer - \", ' wing-like parts attached to ', ' tail, sources say. It was discovered by an American who has been blogging about ', ' search for MH370.']\n",
      "\n"
     ]
    }
   ],
   "source": [
    "pattern = r'the'\n",
    "result = re.split(pattern, text)\n",
    "print(\"Splitting text by \\\"%s\\\" using split.\\nResult:\\n%s\\n\" %\n",
    "      (str(pattern), str(result)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`re.sub(pattern, repl, string)` ищет маску `pattern` в строке `string` и заменяет её на строку `repl`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Replacing \"NO STEP\" by \"LAMBDA\" using sub.\n",
      "Result:\n",
      "The object has the words \"LAMBDA\" on it and could be from the plane's horizontal stabilizer - the wing-like parts attached to the tail, sources say. It was discovered by an American who has been blogging about the search for MH370.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "pattern = r'NO STEP'\n",
    "repl = 'LAMBDA'\n",
    "result = re.sub(pattern, repl, text)\n",
    "print(\"Replacing \\\"%s\\\" by \\\"%s\\\" using sub.\\nResult:\\n%s\\n\" %\n",
    "      (str(pattern), str(repl), str(result)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`re.compile()` создает из строки отдельный объект, который мы можем использовать для дальнейших операций.\n",
    "Компиляция паттерна регулярного выражения ускоряет поиск."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Searching for \"re.compile('the')\" using findall with compiled str in text1.\n",
      "Result:\n",
      "['the', 'the', 'the', 'the', 'the']\n",
      "\n"
     ]
    }
   ],
   "source": [
    "pattern = re.compile(r'the')\n",
    "result = pattern.findall(text)\n",
    "print(\"Searching for \\\"%s\\\" using findall with compiled str in text1.\\nResult:\\n%s\\n\" %\n",
    "      (str(pattern), str(result)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Searching for \"re.compile('the')\" using findall with compiled str in text2.\n",
      "Result:\n",
      "['the', 'the']\n",
      "\n"
     ]
    }
   ],
   "source": [
    "text2 = \"Early photographic analysis of the object suggests it could have come from the doomed jet,\\\n",
    "         which vanished almost exactly 2 years ago.\"\n",
    "result = pattern.findall(text2)  # Не нужно компилировать паттерн заново\n",
    "print(\"Searching for \\\"%s\\\" using findall with compiled str in text2.\\nResult:\\n%s\\n\" %\n",
    "      (str(pattern), str(result)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Пока что в наших паттернах использовались только обычные символы.\n",
    "\n",
    "\"The\" соответствует на языке регулярных выражений только строке \"The\".\n",
    "\n",
    "Посмотрим на мощный инструмент: метасимволы.\n",
    "Метасимволы это символы, которые соответстуют особым шаблонам. Вот они.\n",
    "\n",
    "- `.`   Один любой символ, кроме новой строки `\\n`.\n",
    "- `?`   0 или 1 вхождение шаблона слева\n",
    "- `+`   1 и более вхождений шаблона слева\n",
    "- `*`   0 и более вхождений шаблона слева\n",
    "- `\\w`  Любая цифра или буква (`\\W` — все, кроме буквы или цифры)\n",
    "- `\\d`  Любая цифра `[0-9]` (`\\D` — все, кроме цифры)\n",
    "- `\\s`  Любой пробельный символ (`\\S` — любой непробельнй символ)\n",
    "- `\\b`  Граница слова\n",
    "- `[..]`    Один из символов в скобках (`[^..]` — любой символ, кроме тех, что в скобках)\n",
    "- `\\`   Экранирование специальных символов (`\\.` означает точку или `\\+` — знак «плюс»)\n",
    "- `^` и `$`   Начало и конец строки соответственно\n",
    "- `{n,m}`   От `n` до `m` вхождений (`{,m}` — от `0` до `m`)\n",
    "- `a|b` Соответствует `a` или `b`\n",
    "- `()`  Группирует выражение и возвращает найденный текст\n",
    "- `\\t`, `\\n`, `\\r`  Символ табуляции, новой строки и возврата каретки соответственно\n",
    "\n",
    "-----\n",
    "\n",
    "Примеры использования:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "all_symbols = r'*'  # Соответствует всей строе\n",
    "# соответстует одному символу, findall с этим паттерном вернет список\n",
    "# символов в строке\n",
    "symbols = r'.'\n",
    "# соответстует одной букве или цифре, findall с этим паттерном вернет\n",
    "# список символов в строке за исключением пробелов\n",
    "letters_and_numbers = r'\\w'\n",
    "# findall с этим паттерном вернет список цифр найденных в строке\n",
    "number = r'\\d'\n",
    "# findall с этим паттерном вернет список a и an найденных в строке\n",
    "articules = r'a|an'\n",
    "# findall с этим паттерном вернет список со всеми точками в строке.\n",
    "# Заметьте что из-за экранирования паттерн не соответствует никаким\n",
    "# символам, кроме точи\n",
    "dots = r'\\.'\n",
    "# findall с этим паттерном вернет список с последним словом в строке\n",
    "last_word = r'\\w*\\.$'\n",
    "all_words = r'\\w+'  # findall с этим паттерном вернет список слов\n",
    "# findall с этим паттерном вернет слова, заключенные в кавычки\n",
    "quoted = r'\\\".*\\\"'\n",
    "\n",
    "# findall с этим паттерном вернет слова с 5 или более буквами\n",
    "longwords = r'\\w{5,}'\n",
    "\n",
    "# findall с этим паттерном вернет первые 3 буквы каждого слова\n",
    "first_three_letters = r'\\b\\w{3}'\n",
    "\n",
    "# findall с этим паттерном вернет слова начинающиеся на a, b или с\n",
    "starting_with = r'\\b[abc]\\w+'\n",
    "\n",
    "# findall с этим паттерном вернет слова не начинающиеся на a, b или с.\n",
    "# Обратите внимание на пробел в скобках: он означает, что мы не ищем\n",
    "# последовательности символов начинающиеся с пробела.\n",
    "starting_not_with = r'\\b[^abc ]\\w+'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Проверка телефонного номера"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "li = ['9999999999', '999999-999', '99999x9999', '892512303', '89293536800']\n",
    "for val in li:\n",
    "    if re.match(r'[8-9]{1}[0-9]{9}', val) and len(val) == 10:\n",
    "        print(True)\n",
    "    else:\n",
    "        print(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Источники и дальнейшее чтение:\n",
    "\n",
    "http://tproger.ru/translations/regular-expression-python/\n",
    "https://habrahabr.ru/post/115825/\n",
    "\n",
    "http://pep8.ru/doc/dive-into-python-3/7.html\n",
    "\n",
    "https://docs.python.org/3/howto/regex.html\n",
    "\n",
    "\n",
    "Для закрепления знаний:\n",
    "    Напишите программу, которая позволяет пользователю ввести с клавиатуры email и пароль. Проверьте их на следующие правила:\n",
    "\n",
    "        email:\n",
    "            содержит только латинские буквы, цифры, @ и точку \n",
    "            содержит @ и домен и зону (.ru, .com и прочее)\n",
    "            домен не короче 3 символов, не длиннее 10 символов, не начинается с цифры\n",
    "            доменная зона не короче двух символов, не имеет цифр\n",
    "            имя пользователя не длиннее 10 символов, не начинается с цифры\n",
    "\n",
    "        пароль:\n",
    "            длиннее трех, короче четырех\n",
    "            содержит любые символы кроме пробела, таба и переноса строки\n",
    "            содержит хотя бы одну латинскую букву, одну цифру, одну латинскую букву верхнего регистра\n",
    "            не содержит последовательностей букв длиннее трех символов\n",
    "\n",
    "    Вам не обязетельно реализовывать все правила в одном регулярном выражении. Вы можете поступать как удобно, главное чтобы это работало корректно и вы сами могли понять то, что написали."
   ]
  }
 ],
 "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.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}