Classes/8/Strings & List Comprehensions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# String Operations\n",
    "\n",
    "В одном из первых семинаров мы говорили о типах данных, и одним из этих типов была строка (str). \n",
    "**Строка** -- это любая неизменяемая последовательность символов. В нее могут входить буквы алфавита, цифры, знаки препинания, пробельные символы и др.\n",
    "\n",
    "В питоне предусмотрен целый ряд функций для работы со строками. Некоторые из них мы уже разбирали:\n",
    "* длина строки \n",
    "* разбиение на слова\n",
    "* разбиение на символы\n",
    "* извлечение символа по индексу\n",
    "* срезы (slices)\n",
    "* наличие подстроки в строке"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n",
      "['The', 'cat', 'is', 'on', 'the', 'mat']\n",
      "['T', 'h', 'e', ' ', 'c', 'a', 't', ' ', 'i', 's', ' ', 'o', 'n', ' ', 't', 'h', 'e', ' ', 'm', 'a', 't']\n",
      "T\n",
      "is on the ma\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "sent = \"The cat is on the mat\"\n",
    "\n",
    "# длина строки в символах\n",
    "print(len(sent))\n",
    "\n",
    "# разбиение на слова\n",
    "print(sent.split())\n",
    "\n",
    "# разбиение на символы\n",
    "print(list(sent))\n",
    "\n",
    "# извлечение символа по индексу\n",
    "print(sent[0])\n",
    "\n",
    "# срез\n",
    "print(sent[8:-1])\n",
    "\n",
    "# наличие подстроки в строке\n",
    "print(\"cat\" in sent)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Лирическое отступление №1: токенизация\n",
    "\n",
    "Выше мы разбивали предложения на слова: это простейший пример **токенизации**, или разбиения строки на значимые элементы. Такими элементами, или **токенами**, могут быть не только слова, но и знаки пунктуации, части слов, смайлики, хэштеги и т.п. Токенизация -- это первый после нормализации (см. ниже) этапов предобработки текста. Подробности -- в следующем семинаре!\n",
    "\n",
    "## Функции для работы со строками \n",
    "\n",
    "### join()\n",
    "Раз строку можно разбить, то можно ее и соединить обратно! Для этого существует метод `join()`. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'acada', 'a']\n",
      "a__acada__a\n"
     ]
    }
   ],
   "source": [
    "s = 'abracadabra'\n",
    "chars = s.split('br')\n",
    "print(chars) \n",
    "\n",
    "# в кавычках то, что будет между элементами\n",
    "# аргумент -- список\n",
    "s2 = '__'.join(chars)\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### replace()\n",
    "Кроме того, можно заменить один символ(ы) на другой с помощью функции `replace()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'aBRacadaBRa'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.replace('br', 'BR')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### strip()\n",
    "\n",
    "Текст, с которым приходится работать, не всегда выглядит идеально: в нем может быть много лишних пробелов и прочего мусора, от которого нужно избавиться, прежде чем переходить к дальнейшей работе. Процесс очистки текста от мусора называется **нормализацией**.\n",
    "\n",
    "Допустим, у нас есть строка с лишними пробельными символами по краям. Отрезать их позволяет функция `strip()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t   \tThe cat is on the mat   \n",
      "\n",
      "['\\t', '', '', '\\tThe', 'cat', 'is', 'on', 'the', 'mat', '', '', '\\n']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['The', 'cat', 'is', 'on', 'the', 'mat']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sent = \"\\t   \\tThe cat is on the mat   \\n\"\n",
    "print(sent)\n",
    "print(sent.split(\" \"))\n",
    "\n",
    "# обрезаем мусор\n",
    "# обратите внимания, что можно \"приклеивать\" методы друг к другу!\n",
    "sent.strip(\" \").split()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вообще-то функция `split()` хитрая, и если вызвать её без аргумента, то она сделает c пробельными символами ровно то же самое, что и последняя строчка кода в предыдущей ячейке."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['The', 'cat', 'is', 'on', 'the', 'mat']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sent.split()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Часто также требуется избавиться от пунктуации. Чтобы это сделать, нужно подать функции `strip()` в качестве аргумента строку из пунктуационных знаков, которые нужно убрать."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The cat is on the mat\n",
      "!The cat is on the mat?!!\n",
      "???!The cat is on the mat\n",
      "The cat is on the mat?!!?\n"
     ]
    }
   ],
   "source": [
    "sent = \"???!The cat is on the mat?!!?\"\n",
    "\n",
    "# убираем все\n",
    "print(sent.strip(\"?!\"))\n",
    "\n",
    "# убираем только ? (до первого встретившегося другого символа с обеих сторон)\n",
    "print(sent.strip(\"?\"))\n",
    "\n",
    "# убираем знаки справа\n",
    "print(sent.rstrip(\"?!\"))\n",
    "\n",
    "# убираем знаки слева\n",
    "print(sent.lstrip(\"?!\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для удобства в питоне даже есть встроенная переменная punctuation, но для русскоязычных текстов там знаков маловато."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The cat is on the mat\n",
      "„“«»†?!The cat is on the mat\n"
     ]
    }
   ],
   "source": [
    "from string import punctuation\n",
    "\n",
    "sent = \"&%$$???!The cat is on the mat?@#**^!!?>\"\n",
    "print(sent.strip(punctuation))\n",
    "\n",
    "# а если так?\n",
    "sent = \"&%$„“«»†?!The cat is on the mat?@#**^!!?>\"\n",
    "print(sent.strip(punctuation))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Во втором примере не получилось удалить символы `„“«»†`, потому что они не предусмотрены в `punctuation` (в этом легко убедиться). Что делать в таком случае? Просто задать необходимую пунктуацию самомстоятельно! Назвать это можно как угодно.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~\n",
      "The cat is on the mat\n"
     ]
    }
   ],
   "source": [
    "print(punctuation)\n",
    "\n",
    "# так-то лучше!\n",
    "punct = \"!\\\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~„“«»†*—/\\-\"\n",
    "print(sent.strip(punct))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### upper(), lower() и title()\n",
    "\n",
    "Питон также позволяет работать с регистром, т.е. приводить все к верхнему или нижнему регистру, или же писать слово с большой буквы. Приведение к нижнему регистру часто будет требоваться вам при работе с текстовыми данными."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CAT\n",
      "abracadabra\n",
      "Нижний Новгород\n"
     ]
    }
   ],
   "source": [
    "print('cat'.upper())\n",
    "print('ABRACADABRA'.lower())\n",
    "print('нижний новгород'.title())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Проверка условий\n",
    "\n",
    "Иногда необходимо проверить, удовлетворяет ли строка какому-либо условию:\n",
    "\n",
    "* **s.startswith()** -- начинается с определенного символа\n",
    "* **s.endswith()** -- заканчивается определенным символом\n",
    "* **s.isalpha()** -- состоит только из букв алфавита\n",
    "* **s.isalnum()** -- состоит из букв алфавита и цифр\n",
    "* **s.isdigit()** -- состоит только из цифр\n",
    "* **s.islower()** -- написана в нижнем регистре\n",
    "* **s.isupper()** -- написана в верхнем регистре\n",
    "* **s.istitle()** -- написана с большой буквы (т.е. первая буква прописная, остальные строчные)\n",
    "\n",
    "Для всего этого есть простые функции."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['cats']\n",
      "['mat']\n",
      "['The', 'cats', 'ARE', 'on', 'the', 'mat']\n",
      "['3']\n",
      "['The', '3', 'cats', 'ARE', 'on', 'the', 'mat']\n",
      "['ARE']\n",
      "['9-legged', 'cats', 'on', 'the', 'mat']\n",
      "['The']\n"
     ]
    }
   ],
   "source": [
    "sent = \"The 3 9-legged cats ARE on the mat\"\n",
    "\n",
    "# начинается на определенный символ(ы)\n",
    "print([w for w in sent.split() if w.startswith(\"c\")])\n",
    "\n",
    "# заканчивается на определенный символ(ы)\n",
    "print([w for w in sent.split() if w.endswith(\"at\")])\n",
    "\n",
    "# состоит только из букв алфавита\n",
    "print([w for w in sent.split() if w.isalpha()])\n",
    "\n",
    "# состоит только из цифр\n",
    "print([w for w in sent.split() if w.isdigit()])\n",
    "\n",
    "# состоит из цифр и букв алфавита\n",
    "print([w for w in sent.split() if w.isalnum()])\n",
    "\n",
    "# верхнй регистр\n",
    "print([w for w in sent.split() if w.isupper()])\n",
    "\n",
    "# нижний регистр\n",
    "print([w for w in sent.split() if w.islower()])\n",
    "\n",
    "# с большой буквы, как в предложении\n",
    "print([w for w in sent.split() if w.istitle()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Лирическое отступление №2: list comprehensions\n",
    "\n",
    "В ячейке выше вас наверняка удивил код в [ ]. Это **генераторы списков** (list comprehensions) -- конструкция, которая создает список по определенным правилам. И способ сократить простейший цикл for до одной строчки. :)\n",
    "\n",
    "Возьмем один из рассмотренных выше примеров, где мы хотим выбрать из предложения  сохранить в список только те токены, которые состоят из букв алфавита. Можно записать эту операцию в виде цикла."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['The', 'cats', 'ARE', 'on', 'the', 'mat']\n"
     ]
    }
   ],
   "source": [
    "sent = \"The 3 9-legged cats ARE on the mat\"\n",
    "\n",
    "words = []\n",
    "for word in sent.split():\n",
    "    if word.isalpha():\n",
    "        words.append(word)\n",
    "        \n",
    "print(words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Приведенный выше код построчно читается как\n",
    "\n",
    "    words -- это список\n",
    "    для каждого элемента в строке sent, разбитой по пробелам,\n",
    "    если слово состоит только из символов алфавита,\n",
    "    добавь этот элемент в список words\n",
    "\n",
    "Такая запись хороша тем, что ее очень легко прочитать, но это целых 4 строчки! А можно записать эти 4 строчки в одну, и читаться это будет точно так же."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['The', 'cats', 'ARE', 'on', 'the', 'mat']\n"
     ]
    }
   ],
   "source": [
    "# записываем результат в переменную, как в примере выше\n",
    "words = [w for w in sent.split() if w.isalpha()]\n",
    "\n",
    "# или сразу его печатаем\n",
    "print([w for w in sent.split() if w.isalpha()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В этом примере в генераторе списков спрятан цикл `for` и простое условие `if`, но можно сделать условие более распространенным с помощью `else`. В таком случае сначало должно идти условие, а затем цикл."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['The', 'Ooops!', 'Ooops!', 'cats', 'ARE', 'on', 'the', 'mat']\n"
     ]
    }
   ],
   "source": [
    "words = [ w if w.isalpha() else \"Ooops!\" for w in sent.split()]\n",
    "print(words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задание\n",
    "\n",
    "**Удивительная кошка**\n",
    "\n",
    "_Несчастная кошка порезала лапу- <br>\n",
    "Сидит, и ни шагу не может ступить.<br>\n",
    "Скорей, чтобы вылечить кошкину лапу<br>\n",
    "Воздушные шарики надо купить!<br>\n",
    "<br>\n",
    "И сразу столпился народ на дороге-<br>\n",
    "Шумит, и кричит, и на кошку глядит.<br>\n",
    "А кошка отчасти идет по дороге,<br>\n",
    "Отчасти по воздуху плавно летит!<br>_\n",
    "\n",
    "1. Скопировать текст, сохранить его в переменную. \n",
    "2. Узнать длину текста в символах.\n",
    "3. Очистить текст от пунктуации, используя list compehensions. На выходе должен получиться список слов.\n",
    "4. Объединить слова из получившегося списка в строку через пробел.\n",
    "4. С помощью list comprehensions проверить, написано ли слово с большой буквы, и если да, то привести его к нижнему регистру. На выходе должен получиться список из всех слов стихотворения, написанных с маленькой буквы (не только те, которые изначально были с маленькой буквы, а все).\n",
    "5. Узнать длину текста в словах.\n",
    "6. Узнать количество уникальных слов.\n",
    "7. Распечатать последние 10 слов.\n",
    "8. Посчитать биграммы.\n",
    "9. Соединить полученный список в строку. Слова в строке должны быть написаны через знак переноса строки. \n",
    "10. Распечатать с 20 по 30 символ этой строки (включительно)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Как писать многострочный текст\n",
    "\n",
    "\n",
    "poem = \"\"\"\n",
    "Удивительная кошка\n",
    "\n",
    "Несчастная кошка порезала лапу-\n",
    "Сидит, и ни шагу не может ступить.\n",
    "Скорей, чтобы вылечить кошкину лапу\n",
    "Воздушные шарики надо купить!\n",
    "\n",
    "И сразу столпился народ на дороге-\n",
    "Шумит, и кричит, и на кошку глядит.\n",
    "А кошка отчасти идет по дороге,\n",
    "Отчасти по воздуху плавно летит!\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Удивительная', 'кошка', 'Несчастная', 'кошка', 'порезала', 'лапу', 'Сидит', 'и', 'ни', 'шагу', 'не', 'может', 'ступить', 'Скорей', 'чтобы', 'вылечить', 'кошкину', 'лапу', 'Воздушные', 'шарики', 'надо', 'купить', 'И', 'сразу', 'столпился', 'народ', 'на', 'дороге', 'Шумит', 'и', 'кричит', 'и', 'на', 'кошку', 'глядит', 'А', 'кошка', 'отчасти', 'идет', 'по', 'дороге', 'Отчасти', 'по', 'воздуху', 'плавно', 'летит']\n"
     ]
    }
   ],
   "source": [
    "# решение пункта №3 без генератора списков\n",
    "\n",
    "words = []\n",
    "\n",
    "for word in poem.split():\n",
    "    words.append(word.strip(\"!?.,-\"))\n",
    "    \n",
    "print(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Удивительная', 'кошка', 'Несчастная', 'кошка', 'порезала', 'лапу', 'Сидит', 'и', 'ни', 'шагу', 'не', 'может', 'ступить', 'Скорей', 'чтобы', 'вылечить', 'кошкину', 'лапу', 'Воздушные', 'шарики', 'надо', 'купить', 'И', 'сразу', 'столпился', 'народ', 'на', 'дороге', 'Шумит', 'и', 'кричит', 'и', 'на', 'кошку', 'глядит', 'А', 'кошка', 'отчасти', 'идет', 'по', 'дороге', 'Отчасти', 'по', 'воздуху', 'плавно', 'летит']\n"
     ]
    }
   ],
   "source": [
    "# решение пункта №3 с генератором списков\n",
    "\n",
    "words = [word.strip(\"!?.,-\") for word in poem.split()]\n",
    "print(words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Аннотация некоторой магии (поиск всех слов, в которых не меньше двух букв 'a'):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['hakuna ', 'matata ', 'aroma ', 'appeal ', 'savannah ']"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "re.findall(\"\\S*a\\S*a\\S* \", \" hakuna matata ... He found his aroma lacked a certain appeal\\\n",
    "                                             He could clear the savannah after every meal\")"
   ]
  }
 ],
 "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}