ipynb/regex_and_strings/jun_anl_string.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **19 Работа со строками**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Курс ведёт **Александр Джумурат** Data Scientist в ivi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **19.1** *Введение*\n",
    "\n",
    "Для аналитка обычно открыт доступ к огромным объёмам текстовой информации. В рамках этого модуля я расскажу как извлечь из этого сырого объёма данных какие-то полезные инсайты, к которым можно применить аналитические инструменты, которые мы изучили ранее в первых частях нашей программы.\\\n",
    "Например, в online-кинотеатре [ivi](https://www.ivi.ru) текстовая информация представлена сюжетами фильмов, рецензиями пользователей, а также, например, интересными фактами о съёмочном процессе.\n",
    "\n",
    "В работе со строками есть как стандартные приёмы (такие как удаление знаков пунктуации или приведение к нижнему регистру), так и более продвинутые техники (например, работа с регулярными выражениями). Этим приёмы будут продемонстрированы в рамках этого модуля.\n",
    "\n",
    "Мы будем работать с датасетом, который называется \"описание фильмов\". Давайте посомтрим как выглядит этот датасет.\\\n",
    "Приёмы работы со строками, которые я продемонстрирую, мы будем изучать на примере набора данных с текстовыми описаниями фильмов. Посмотрим как он выглядит.\\\n",
    "Набор данных состоит из двух колонок:\n",
    "- первая колонка называется `content`, - и она содержит в себе ссылку на страницу online-кинотеатра [ivi](https://www.ivi.ru), на которой размещён данный контент,\n",
    "- вторая колонка называется `description`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>content</th>\n",
       "      <th>description</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>https://www.ivi.ru/watch/157318/description</td>\n",
       "      <td>Лучший подарок, который только можно было прид...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>https://www.ivi.ru/watch/98336/description</td>\n",
       "      <td>Через какие трудности приходится проходить Сан...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>https://www.ivi.ru/watch/183533/description</td>\n",
       "      <td>Миловидный Давид - позор для своего отца. Не в...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>https://www.ivi.ru/watch/157319/description</td>\n",
       "      <td>Экранизация сатирического бестселлера Стивена ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>https://www.ivi.ru/watch/51342/description</td>\n",
       "      <td>«Леди удача» – авантюрная романтическая комеди...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                       content  \\\n",
       "0  https://www.ivi.ru/watch/157318/description   \n",
       "1   https://www.ivi.ru/watch/98336/description   \n",
       "2  https://www.ivi.ru/watch/183533/description   \n",
       "3  https://www.ivi.ru/watch/157319/description   \n",
       "4   https://www.ivi.ru/watch/51342/description   \n",
       "\n",
       "                                         description  \n",
       "0  Лучший подарок, который только можно было прид...  \n",
       "1  Через какие трудности приходится проходить Сан...  \n",
       "2  Миловидный Давид - позор для своего отца. Не в...  \n",
       "3  Экранизация сатирического бестселлера Стивена ...  \n",
       "4  «Леди удача» – авантюрная романтическая комеди...  "
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "text_df = pd.read_csv(\"./data/content_description.csv\", sep='\\t')\n",
    "text_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **19.2** *Стандартные приёмы работы с текстом*\n",
    "\n",
    "Очень часто при обработке данных строкового типа (напиример, текстов) требуются дополнительные преобразования, которые помогут повысить качество итогового решения.\n",
    "\n",
    "Основные приёмы:\n",
    "\n",
    "* приведение к нижнему регистру\n",
    "* удаление знаков препинания\n",
    "\n",
    "Эти приёмы следует применять с осторожностью - например, если вы планируете решать задачу извлечения из текста всех пар *имя+фамилия* то к нижнему регистру приводить не нужено - это приведёт к потере важной информации и затруднит решение исходной задачи"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Через какие трудности приходится проходить Санта Клаусу каждый год, чтобы под каждой елкой появился тот самый подарок, расскажет мульт «Нико 2».   Маленький олененок Нико мечтает продолжить дело отца. Ведь его папа самый знаменитый и уважаемый олень на свете. О его работе мечтает каждый – он трудится в упряжке самого Санта Клауса. Но сам Нико пока еще слишком маленький для такого тяжелого и ответственного дела. Так что пока он сам ждет Санту с подарками. Накануне Рождества он встречается со своими самыми близкими друзьями: белкой Джулиусом, лаской Вилмой и сводным братишкой Джонни, чтобы вместе встречать Рождество и не пропустить заветную оленью упряжку. Но, как всегда в пути Санту ждут невероятные приключения. На этот раз все настолько серьезно, что детишки всего мира могут и вовсе остаться без подарков. Хорошо, что Нико и его товарищи всегда готовы прийти на помощь. Им не страшны любые испытания и приключения: ведь среди них – достойный сын одного из оленей упряжки самого Санта Клауса.  Советуем смотреть онлайн «Нико 2», добрый и милый рождественский мультик, который отлично подойдет для семеного просмотра.\n",
      "\n",
      "\n",
      "Приводим к нижнему регистру:\n",
      "через какие трудности приходится проходить санта клаусу каждый год, чтобы под каждой елкой появился тот самый подарок, расскажет мульт «нико 2».   маленький олененок нико мечтает продолжить дело отца. ведь его папа самый знаменитый и уважаемый олень на свете. о его работе мечтает каждый – он трудится в упряжке самого санта клауса. но сам нико пока еще слишком маленький для такого тяжелого и ответственного дела. так что пока он сам ждет санту с подарками. накануне рождества он встречается со своими самыми близкими друзьями: белкой джулиусом, лаской вилмой и сводным братишкой джонни, чтобы вместе встречать рождество и не пропустить заветную оленью упряжку. но, как всегда в пути санту ждут невероятные приключения. на этот раз все настолько серьезно, что детишки всего мира могут и вовсе остаться без подарков. хорошо, что нико и его товарищи всегда готовы прийти на помощь. им не страшны любые испытания и приключения: ведь среди них – достойный сын одного из оленей упряжки самого санта клауса.  советуем смотреть онлайн «нико 2», добрый и милый рождественский мультик, который отлично подойдет для семеного просмотра.\n",
      "\n",
      "\n",
      "Удаляем знаки препинания:\n",
      "через какие трудности приходится проходить санта клаусу каждый год чтобы под каждой елкой появился тот самый подарок расскажет мульт «нико 2»   маленький олененок нико мечтает продолжить дело отца ведь его папа самый знаменитый и уважаемый олень на свете о его работе мечтает каждый – он трудится в упряжке самого санта клауса но сам нико пока еще слишком маленький для такого тяжелого и ответственного дела так что пока он сам ждет санту с подарками накануне рождества он встречается со своими самыми близкими друзьями белкой джулиусом лаской вилмой и сводным братишкой джонни чтобы вместе встречать рождество и не пропустить заветную оленью упряжку но как всегда в пути санту ждут невероятные приключения на этот раз все настолько серьезно что детишки всего мира могут и вовсе остаться без подарков хорошо что нико и его товарищи всегда готовы прийти на помощь им не страшны любые испытания и приключения ведь среди них – достойный сын одного из оленей упряжки самого санта клауса  советуем смотреть онлайн «нико 2» добрый и милый рождественский мультик который отлично подойдет для семеного просмотра\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "\n",
    "sample_str = text_df.description.values[1]\n",
    "\n",
    "print(sample_str + '\\n\\n')\n",
    "\n",
    "print(\"Приводим к нижнему регистру:\")\n",
    "print(sample_str.lower() + '\\n\\n')\n",
    "\n",
    "print(\"Удаляем знаки препинания:\")\n",
    "print(\"\".join([i for i in sample_str.lower() if i not in string.punctuation]) + '\\n\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **19.3** *Регулярные выражения в python*\n",
    "\n",
    "*Регулярные выражения* являются как бы языком программирования внутри языка программирования Python.\n",
    "\n",
    "Они позволяют извлекать из текста очень сложную информацию. На примерах посмотрим как, например, извлекать из текстов e-mail'ы пользователей или, например, норера телефонов и разную другую полезную информацию.\n",
    "\n",
    "Среди стандартных модулей python существует библиотека для работы [с регулярными выражениями re](https://docs.python.org/3/library/re.html) (подробнее [тут](https://tproger.ru/translations/regular-expression-python/))\n",
    "\n",
    "Простешая задача для регулярных выражений - разделение текста на отдельные слова."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "компилированное регулярное вырадение  <class 're.Pattern'> \n",
      "\n",
      "\n",
      "['Леди', 'удача', 'авантюрная', 'романтическая', 'комедия', 'снятая', 'в', 'двадцатые', 'годы', 'ХХ', 'века', 'на', 'заре', 'звукового', 'кинематографа', 'Главную', 'роль', 'исполнила', 'обаятельная', 'Норма', 'Ширер', 'пятикратный', 'номинант', 'и', 'лауреат', 'премии', 'Оскар', 'за', 'фильм', 'Развод', 'Сюжет', 'и', 'посыл', 'картины', 'несмотря', 'на', 'ее', 'почтенный', 'возраст', 'нисколько', 'не', 'устарели', 'В', 'мелодраме', 'которую', 'вы', 'можете', 'посмотреть', 'онлайн', 'представлена', 'забавная', 'история', 'авантюристки', 'по', 'прозвищу', 'Ангельское', 'Личико', 'С', 'равным', 'успехом', 'показанные', 'события', 'могли', 'произойти', 'и', 'в', 'наше', 'время', 'как', 'вы', 'сами', 'можете', 'убедиться', 'люди', 'за', 'несколько', 'десятилетий', 'мало', 'изменились', 'в', 'глобальных', 'вещах', 'Прелестная', 'девушка', 'Долли', 'опасная', 'авантюристка', 'со', 'стажем', 'Она', 'зарабатывает', 'на', 'жизнь', 'шантажом', 'по', 'простой', 'и', 'многократно', 'отработанной', 'схеме', 'Долли', 'знакомится', 'с', 'богатым', 'мужчиной', 'приглашает', 'его', 'к', 'себе', 'на', 'квартиру', 'а', 'затем', 'начинает', 'требовать', 'деньги', 'за', 'соблюдение', 'молчания', 'В', 'результате', 'полицейских', 'происков', 'девушка', 'оказывается', 'под', 'арестом', 'однако', 'избегает', 'строгого', 'наказания', 'Выйдя', 'на', 'свободу', 'она', 'снимает', 'номер', 'в', 'отеле', 'где', 'знакомится', 'с', 'новой', 'жертвой', 'молодым', 'человеком', 'по', 'имени', 'Стив', 'Стив', 'утверждает', 'что', 'он', 'изобретатель', 'миллионер', 'однако', 'несколько', 'искажает', 'факты', 'На', 'самом', 'деле', 'герой', 'просто', 'ученый', 'создавший', 'вещь', 'способную', 'принести', 'миллионы']\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "# строка для примера\n",
    "test_string = text_df.description.values[4]\n",
    "# шаблон регулярного выражения\n",
    "reg_expr = r'\\w+'\n",
    "# компилируем регулярное выражение\n",
    "reg_expr_compiled = re.compile(reg_expr)\n",
    "print(\"компилированное регулярное вырадение \", type(reg_expr_compiled), '\\n\\n')\n",
    "# применяем метод findall для поиска всех совпадений с шаблоном регулярного выражения в тексте \n",
    "res = reg_expr_compiled.findall(test_string) \n",
    "# результат\n",
    "print (res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как видно, скомпилированное регулярное выражение имеет класс `Pattern`. В силу того, что скомпилированное регулярное выражение является *классом*, у него есть некоторые методы, которые мы будем использовать.\n",
    "Мы видим результат применения метода `findall` - это список отдельных слов, совпадающих с регулярным выражением с текстом. Также можно заметить, что эти слова не содержат никаких знаков пунктуации. В то же время, регулярное выражение справилось с тем, что выбрало также и римскую цифру *XX*.\n",
    "\n",
    "В этом примере можно увидеть основные атрибуты регулярных выражений. В частности, мы поняли, что регулярные выражения представляют собой просто строку в кавычках, которую зачастую предворяет спецификатор `r`. Во-вторых, строку перед использованием нужно скомпилировать в отдельный объект регулярного выражения, который имеет полезные атрибуты и методы для работы с текстом. А, в-третьих, внутри шаблона можно использовать спец-символы - в примере это `\\w`. Посмотрим какие ещё спец-символы существуют.\n",
    "\n",
    "В этом примере можно увидеть базовые приёмы применения библиотеки регулярных выражений в python\n",
    "\n",
    "* регулярное выражение - строка в кавычках (перед кавычками вспомогательный символ `r`)\n",
    "* строку перед использованием нужно скомпилировать в специальный объеrn [Regular expression object](https://docs.python.org/3/library/re.html#regular-expression-objects)\n",
    "* В шаблонах можно использовать `спецсимволы`\n",
    "\n",
    "Примеры спецсимволов:\n",
    "\n",
    "* `.` Любой символ\n",
    "* `\\w`  Любая буква (то, что может быть частью слова), а также цифры и _ \n",
    "*  `\\W`  Всё, что не входит в `\\w` \n",
    "*  `\\d`  Любая цифра \n",
    "*  `\\D`  Всё, что не входит в `\\d` \n",
    "* `\\b` граница слова\n",
    "* `[…]`  Символьный класс - любой из перечисленных символов \n",
    "\n",
    "Кроме спецсимволов можно использовать т.н. квантификаторы - указатели количества вхождений\n",
    "\n",
    "* `+` - одно или более вхождений\n",
    "* `*` ноль или больше вхождений\n",
    "* `{m,n}` от m до n вхождений\n",
    "* `{n}` ровно `n` вхождений\n",
    "* `\\s` пробельный символ - например, табуляция\n",
    "* `^` начало вхождения\n",
    "* `$` конец вхождения\n",
    "* `()` - группирующие скобки. Позволяет искать подстроки\n",
    "\n",
    "Продемонстрируем простейшие примеры применения регулярных выражений."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Разделим строку на отдельные символы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['М', 'а', 'м', 'а', ' ', 'm', 'a', 'm', 'a', '@', 'y', 'a', '.', 'r', 'u', ' ', 'м', 'ы', 'л', 'а', ' ', 'р', 'а', 'м', 'у', ' ', 'с', ' ', 'м', 'ы', 'л', 'о', 'м']\n"
     ]
    }
   ],
   "source": [
    "sample_str = 'Мама mama@ya.ru мыла раму с мылом'\n",
    "\n",
    "result = re.findall(r'.', sample_str)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Усложним регулярку и извлечём все слова - идущие подряд непробельные символы (спецсимволы не в счёт)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Мама', '', 'mama', '', 'ya', '', 'ru', '', 'мыла', '', 'раму', '', 'с', '', 'мылом', '']\n"
     ]
    }
   ],
   "source": [
    "result = re.findall(r'\\w*', sample_str)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В выдаче есть пробелы - заменим `*` на `+`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Мама', 'mama', 'ya', 'ru', 'мыла', 'раму', 'с', 'мылом']\n"
     ]
    }
   ],
   "source": [
    "result = re.findall(r'\\w+', sample_str)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Первое слово в тексте"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Мама']\n"
     ]
    }
   ],
   "source": [
    "result = re.findall(r'^\\w+', sample_str)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Последнее слово в тексте"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['мылом']\n"
     ]
    }
   ],
   "source": [
    "result = re.findall(r'\\w+$', sample_str)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вернуть все пары символов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Ма', 'ма', 'ma', 'ma', 'ya', 'ru', 'мы', 'ла', 'ра', 'му', 'мы', 'ло']\n"
     ]
    }
   ],
   "source": [
    "result = re.findall(r'\\w\\w', sample_str)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вернуть все пары символов только в начале слова (включая пробелы)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Ма', 'ma', 'ya', 'ru', 'мы', 'ра', 'с ', 'мы']\n"
     ]
    }
   ],
   "source": [
    "result = re.findall(r'\\b\\w.', sample_str)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вернуть список доменов электронной почты"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['@ya']\n"
     ]
    }
   ],
   "source": [
    "result = re.findall(r'@\\w+', sample_str)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Добавим в результат доменную зону(домен верхнего уровня)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['@ya.ru']\n"
     ]
    }
   ],
   "source": [
    "result = re.findall(r'@\\w+.\\w+', sample_str)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Второй вариант — вытащить только доменную зону, используя группировку"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ru']\n"
     ]
    }
   ],
   "source": [
    "result = re.findall(r'@\\w+.(\\w+)', sample_str)\n",
    "print(result)\n",
    "# из всего совпадение, которое произошло, мы вытаскиваем только его часть, ту, которая заключена в скобочки ()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Наконец, извлечём email полностью"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['mama@ya.ru']\n"
     ]
    }
   ],
   "source": [
    "result = re.findall(r'\\w+@\\w+.\\w+', sample_str)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Т.о. мы решили простейшую задачу: достали e-mail адрес из строки при помощи регулярных выражений. В аналитике встречается много подбных задач.\n",
    "\n",
    "В примерах выше функция `findall` возвращала целый список вхождений регулярного выражения в текст.\\\n",
    "Теперь построим более сложную систему и применить регулярные выражения уже внутри каждого элемента, который мы обнаружили в тексте.\n",
    "\n",
    "Для примера, решим задачу распознавания номера телефона. В данном примере, у нас есть последовательность вхождений цифровых подпоследовательностей в строку.\n",
    "\n",
    "Разбив текст на отдельные слова, мы получаем список отдельных сущностей (т.н. токенов) каждый токен можно обработать отдельно своей регуляркой - например проверить телефонный номер - номер должен быть длиной 10 знаков и начинаться с 8 или 7.\\\n",
    "Сформируем регулярное выражение, которое содержит в себе символьный класс: внутри квадратных скобок мы задаём элементы, которые могут встречаться в начале нашего вхождения (7 или 8). Затем, в фигурных скобках мы задаём квантификатор (количество вхождений элемента, т.е. 7 или 8 должны входить ровно 1 раз).\\\n",
    "В дальнейшем снова идёт символьный класс только с цифрами от 0 до 9. И затем, квантификатор количества, указывающий на то, что всего цифр должно быть 9.\\\n",
    "Для того, чтобы применить это регулярное выражение к тексту, мы вызываем функцию `match`, и если у нас совпадение произошло, мы печатаем отладочное сообщение что это номер телефона, а если вхождение не найдено, - то мы выводим *no*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "phone number\n",
      "no\n",
      "no\n",
      "phone number\n"
     ]
    }
   ],
   "source": [
    "tokens = ['79999999999', '999999-9999', '99999x99999', '79966631324']\n",
    "\n",
    "for val in tokens:\n",
    "    if re.match(r'[7-8]{1}[0-9]{10}', val) and len(val) == 11:\n",
    "        print('phone number')\n",
    "    else:\n",
    "        print('no')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Другой интересный кейс - вытаскивание из текста всех имён собственных. Именем собственным мы будем считать любой текст, заключённый внутри кавычек. Для этой задачи нам помогут группирующие скобки `()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "«Леди удача» – авантюрная романтическая комедия, снятая в двадцатые годы ХХ века, на заре звукового кинематографа. Главную роль исполнила обаятельная Норма Ширер, пятикратный номинант и лауреат премии «Оскар» за фильм «Развод». Сюжет и посыл картины, несмотря на ее почтенный возраст, нисколько не устарели. В мелодраме, которую вы можете посмотреть онлайн, представлена забавная история авантюристки по прозвищу Ангельское Личико. С равным успехом показанные события могли произойти и в наше время – как вы сами можете убедиться, люди за несколько десятилетий мало изменились в глобальных вещах.   Прелестная девушка Долли – опасная авантюристка со стажем. Она зарабатывает на жизнь шантажом по простой и многократно отработанной схеме. Долли знакомится с богатым мужчиной, приглашает его к себе на квартиру, а затем начинает требовать деньги за соблюдение молчания. В результате полицейских происков девушка оказывается под арестом, однако избегает строгого наказания. Выйдя на свободу, она снимает номер в отеле, где знакомится с новой жертвой – молодым человеком по имени Стив. Стив утверждает, что он изобретатель-миллионер, однако несколько искажает факты. На самом деле, герой – просто ученый, создавший вещь, способную принести миллионы.\n",
      "\n",
      "\n",
      "Пользуясь регулярными выражения, доcтанем из текста имена собственные (всё, что внутри кавычек):\n",
      "\n",
      "\n",
      "Леди удача\n",
      "Оскар\n",
      "Развод\n"
     ]
    }
   ],
   "source": [
    "print(text_df.description.values[4])\n",
    "raw_text = text_df.description.values[4]\n",
    "\n",
    "print(\"\\n\\nПользуясь регулярными выражения, доcтанем из текста имена собственные (всё, что внутри кавычек):\\n\\n\")\n",
    "regular_expr = r'«(.*?)»'\n",
    "reg_expr_compiled = re.compile(regular_expr) # компилируем р.в.\n",
    "# применяем выражение к тексту\n",
    "for g in reg_expr_compiled.findall(raw_text): # применяем скомпилированное р.в. ко всему тексту целиком\n",
    "    print(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Итак, пользуясь регулярными выражениями, мы извлекли из текста все имена собственные и распечатали их\n",
    "\n",
    "Таким образом, мы решили довольно сложную задачу, которую невозможно было бы решить с помощью простых приёмов работы с текстом, таких как: приведение к нижнему регистру и удаление знаков препинания.\n",
    "\n",
    "### *Итоги*\n",
    "\n",
    "В данном уроке мы познакомились с таким мощным инструментом для анализа текстов, как регулярные выражения. Пользуясь регулярными выражениями можно извлекать из текста огромное количество факторов. Например: имена телефонов, имена людей или адреса электронной почты. Все эти факторы помогут построить мощную систему аналитики."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **19.4** *Статистики текста*\n",
    "\n",
    "С \"сырым\" текстом аналитику невозможно работать - нужно как-то преобразовать его в численный вид - этот процесс называется *векторизацией*. Когда мы из \"сырого\" текста получаем какое-то численное представление, которое обычно основано на статистиках слов, которые входят в этот текст.\n",
    "\n",
    "Чтобы продемострировать, как применять векторизацию, решим задачу прогнозирования жанра фильма по его описанию.\n",
    "\n",
    "Для начала разобъём текст на слова с помощью регулярных выражений"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['через', 'какие', 'трудности', 'приходится', 'проходить', 'санта', 'клаусу', 'каждый', 'год', 'чтобы', 'под', 'каждой', 'елкой', 'появился', 'тот', 'самый', 'подарок', 'расскажет', 'мульт', 'нико', '2', 'маленький', 'олененок', 'нико', 'мечтает', 'продолжить', 'дело', 'отца', 'ведь', 'его', 'папа', 'самый', 'знаменитый', 'и', 'уважаемый', 'олень', 'на', 'свете', 'о', 'его', 'работе', 'мечтает', 'каждый', 'он', 'трудится', 'в', 'упряжке', 'самого', 'санта', 'клауса', 'но', 'сам', 'нико', 'пока', 'еще', 'слишком', 'маленький', 'для', 'такого', 'тяжелого', 'и', 'ответственного', 'дела', 'так', 'что', 'пока', 'он', 'сам', 'ждет', 'санту', 'с', 'подарками', 'накануне', 'рождества', 'он', 'встречается', 'со', 'своими', 'самыми', 'близкими', 'друзьями', 'белкой', 'джулиусом', 'лаской', 'вилмой', 'и', 'сводным', 'братишкой', 'джонни', 'чтобы', 'вместе', 'встречать', 'рождество', 'и', 'не', 'пропустить', 'заветную', 'оленью', 'упряжку', 'но', 'как', 'всегда', 'в', 'пути', 'санту', 'ждут', 'невероятные', 'приключения', 'на', 'этот', 'раз', 'все', 'настолько', 'серьезно', 'что', 'детишки', 'всего', 'мира', 'могут', 'и', 'вовсе', 'остаться', 'без', 'подарков', 'хорошо', 'что', 'нико', 'и', 'его', 'товарищи', 'всегда', 'готовы', 'прийти', 'на', 'помощь', 'им', 'не', 'страшны', 'любые', 'испытания', 'и', 'приключения', 'ведь', 'среди', 'них', 'достойный', 'сын', 'одного', 'из', 'оленей', 'упряжки', 'самого', 'санта', 'клауса', 'советуем', 'смотреть', 'онлайн', 'нико', '2', 'добрый', 'и', 'милый', 'рождественский', 'мультик', 'который', 'отлично', 'подойдет', 'для', 'семеного', 'просмотра']\n"
     ]
    }
   ],
   "source": [
    "corpus = []\n",
    "# регулярка для поиска слов\n",
    "regular_expr = r'\\w+'\n",
    "reg_expr_compiled = re.compile(regular_expr)\n",
    "\n",
    "for raw_text in text_df.description.values:\n",
    "    # приводим к нижнему регистру\n",
    "    raw_text_lower = raw_text.lower()\n",
    "    # разбиваем текст на слова\n",
    "    text_by_words = reg_expr_compiled.findall(raw_text_lower) \n",
    "    corpus.append(text_by_words)\n",
    "print(corpus[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как видно, слова в тексте могут находиться в разных формах. Например `друзьями` и `друзьям` - это, очевидно, одно и то же слово. Чтобы учесть этот факт, приведём каждое слово к нормальной форме."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['через', 'какой', 'трудность', 'приходиться', 'проходить', 'сант', 'клаус', 'каждый', 'год', 'чтобы', 'под', 'каждый', 'ёлка', 'появиться', 'тот', 'самый', 'подарок', 'рассказать', 'мульт', 'нико', '2', 'маленький', 'оленёнок', 'нико', 'мечтать', 'продолжить', 'дело', 'отец', 'ведь', 'он', 'папа', 'самый', 'знаменитый', 'и', 'уважаемый', 'олень', 'на', 'свет', 'о', 'он', 'работа', 'мечтать', 'каждый', 'он', 'трудиться', 'в', 'упряжка', 'самый', 'сант', 'клаус', 'но', 'сам', 'нико', 'пока', 'ещё', 'слишком', 'маленький', 'для', 'такой', 'тяжёлый', 'и', 'ответственный', 'дело', 'так', 'что', 'пока', 'он', 'сам', 'ждать', 'сант', 'с', 'подарок', 'накануне', 'рождество', 'он', 'встречаться', 'с', 'свой', 'самый', 'близкие', 'друг', 'белка', 'джулиус', 'ласка', 'вилма', 'и', 'сводный', 'братишка', 'джонни', 'чтобы', 'вместе', 'встречать', 'рождество', 'и', 'не', 'пропустить', 'заветный', 'олений', 'упряжка', 'но', 'как', 'всегда', 'в', 'путь', 'сант', 'ждать', 'невероятный', 'приключение', 'на', 'этот', 'раз', 'весь', 'настолько', 'серьёзно', 'что', 'детишки', 'всего', 'мир', 'мочь', 'и', 'вовсе', 'остаться', 'без', 'подарок', 'хорошо', 'что', 'нико', 'и', 'он', 'товарищ', 'всегда', 'готовый', 'прийти', 'на', 'помощь', 'имя', 'не', 'страшный', 'любой', 'испытание', 'и', 'приключение', 'ведь', 'среди', 'они', 'достойный', 'сын', 'один', 'из', 'олень', 'упряжка', 'самый', 'сант', 'клаус', 'советовать', 'смотреть', 'онлайн', 'нико', '2', 'добрый', 'и', 'милый', 'рождественский', 'мультик', 'который', 'отлично', 'подойти', 'для', 'семеный', 'просмотр']\n"
     ]
    }
   ],
   "source": [
    "import pymorphy2\n",
    "\n",
    "normalized_corpus = []\n",
    "morph = pymorphy2.MorphAnalyzer()\n",
    "\n",
    "for token_list in corpus:\n",
    "    normalized_token_list = []\n",
    "    for word in token_list:\n",
    "        parsed_token = morph.parse(word)\n",
    "        normal_form = parsed_token[0].normal_form\n",
    "        normalized_token_list.append(normal_form)\n",
    "    normalized_corpus.append(normalized_token_list)\n",
    "print(normalized_corpus[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Итак, мы преобразовали слова в каждом доступном документе к нормальной форме. Чтобы было удобнее считать статистики, преобразуем текстовый корпус в pandas.DataFrame с колонками `doc_id | word | dummy` где столбец `dummy` - вспомогательный, он будет содержать всегда единицу"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>doc_id</th>\n",
       "      <th>word</th>\n",
       "      <th>dummy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>хороший</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>подарок</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>который</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>только</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>можно</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   doc_id     word  dummy\n",
       "0       0  хороший      1\n",
       "1       0  подарок      1\n",
       "2       0  который      1\n",
       "3       0   только      1\n",
       "4       0    можно      1"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "doc_count = len(normalized_corpus)\n",
    "doc_ids = []\n",
    "tokens = []\n",
    "\n",
    "for doc_id in range(doc_count):\n",
    "    for token in normalized_corpus[doc_id]:\n",
    "        doc_ids.append(doc_id)\n",
    "        tokens.append(token)\n",
    "\n",
    "tokens_df = pd.DataFrame({\n",
    "    'doc_id': doc_ids,\n",
    "    'word': tokens\n",
    "})\n",
    "\n",
    "tokens_df = tokens_df.assign(dummy = 1)\n",
    "\n",
    "tokens_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Пользуясь этой таблицей, можно считать по тексту разнообразные статистики. Например, вычислим top-5 самых употребляемых слов в документа `doc_id==0`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>doc_id</th>\n",
       "      <th>word</th>\n",
       "      <th>dummy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0</td>\n",
       "      <td>в</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>0</td>\n",
       "      <td>и</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>0</td>\n",
       "      <td>который</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>110</th>\n",
       "      <td>0</td>\n",
       "      <td>шерлок</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>83</th>\n",
       "      <td>0</td>\n",
       "      <td>сериал</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>76</th>\n",
       "      <td>0</td>\n",
       "      <td>с</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0</td>\n",
       "      <td>весь</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>74</th>\n",
       "      <td>0</td>\n",
       "      <td>риколетти</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>104</th>\n",
       "      <td>0</td>\n",
       "      <td>холмс</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>0</td>\n",
       "      <td>же</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     doc_id       word  dummy\n",
       "6         0          в     10\n",
       "28        0          и      7\n",
       "36        0    который      5\n",
       "110       0     шерлок      4\n",
       "83        0     сериал      4\n",
       "76        0          с      4\n",
       "8         0       весь      3\n",
       "74        0  риколетти      3\n",
       "104       0      холмс      2\n",
       "22        0         же      2"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word_count_df = tokens_df.groupby(['doc_id','word'])['dummy'].count().reset_index()\n",
    "\n",
    "word_count_df[word_count_df.doc_id==0].sort_values(by='dummy', ascending=False).head(10)"
   ]
  },
  {
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}