Строки файлы и регулярные выражения.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Строки"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Мы уже рассматривали строки как простой тип данных наряду с целыми и вещественными числами и знаем, что строка – это последовательность символов, заключенных в одинарные или двойные кавычки.\n",
    "\n",
    "В Python нет символьного типа, т. е. типа данных, объектами которого являются одиночные символы. Однако язык позволяет рассматривать строки как объекты, состоящие из подстрок длинной в один и более символов. При этом, в отличие от списков, строки не принято относить к структурам данных. Видимо потому, что структуры данных состоят из более простых типов данных, а для строк в Python нет более простого (символьного) типа.\n",
    "\n",
    "С другой стороны, строка, как и список, – это упорядоченная последовательность элементов. Следовательно, из нее можно извлекать отдельные символы и срезы."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Как создать строку\n",
    "\n",
    "Строки всегда создаются одним из трех способов. Вы можете использовать одинарные, двойные и тройные скобки. Давайте посмотрим"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"Добро пожаловать в Python!\"\n",
    "another_string = 'Я новый текст тут...'\n",
    " \n",
    "a_long_string = '''А это у нас\n",
    "новая строка\n",
    "в троичных скобках'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"I'm a Python programmer!\"\n",
    "otherString = 'Слово \"Python\" обычно подразумевает змею'\n",
    "tripleString = \"\"\"В такой \"строке\" мы можем 'использовать' все.\"\"\"\n",
    "strInt = str(123)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Python, начиная с версии 3, все строки являются юникодом."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "World!\n",
      "Hlo ol!\n"
     ]
    }
   ],
   "source": [
    "s = \"Hello, World!\"\n",
    "print(s[0])\n",
    "print(s[7:])\n",
    "print(s[::2])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Важным отличием от списков является неизменяемость строк в Python. Нельзя перезаписать какой-то отдельный символ или срез в строке"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-47-376ff975e39d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'.'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "s[-1] = '.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140468451196656\n"
     ]
    }
   ],
   "source": [
    "print(id(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140468451967920\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Hello, World.'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = s[0:-1] + '.'\n",
    "print(id(s))\n",
    "s\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Методы строк"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "spameggs\n"
     ]
    }
   ],
   "source": [
    "#конкатенация\n",
    "S1 = 'spam'\n",
    "S2 = 'eggs'\n",
    "print(S1 + S2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "spamspamspam\n"
     ]
    }
   ],
   "source": [
    "#Дублирование\n",
    "print('spam' * 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#наличие подстроки в строке\n",
    "print('hello' in 'hello world')\n",
    "print('hello' in 'fasfasdfsf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#длина строки\n",
    "len('spam')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ягоды', 'желуди', 'носорог']"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "phrase = 'ягоды желуди носорог'.split()\n",
    "phrase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fsdfsdf, sdfsf, ertt\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['fsdfsdf', 'sdfsf', 'ertt']"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "phrase = input().split(', ') # функция split принимает в качестве аргумента разделитель\n",
    "phrase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'fsdfsdf ? sdfsf ? ertt'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "' ? '.join(phrase)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Список методов строк\n",
    "https://pythonworld.ru/tipy-dannyx-v-python/stroki-funkcii-i-metody-strok.html\n",
    "\n",
    "Или help(str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Методы find() и replace()\n",
    "Метод find() ищет подстроку в строке и возвращает индекс первого элемента найденной подстроки. Если подстрока не найдена, то возвращает -1.\n",
    "Метод replace() заменяет одну подстроку на другую"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'red blue orange white'\n",
    "s.find('blue')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.find('green')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NET KTO ETOT VASH REPLACE?'"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'DA KTO ETOT VASH REPLACE?'.replace('DA', 'NET')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Метод format \n",
    "Метод позволяет подставлять значения в строку. Причем можно дополнительно указывать порядок подстановки а также использовать передачу по слову-ключу"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a ball. It's red.\n"
     ]
    }
   ],
   "source": [
    "print(\"This is a {0}. It's {1}.\".format(\"ball\", \"red\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'height - 2.3, length - 3, width - 6'"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size2 = \"height - {2}, length - {0}, width - {1}\"\n",
    "size2.format(3, 6, 2.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"This is a table. It's small.\""
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "info = \"This is a {subj}. It's {prop}.\"\n",
    "info.format(subj=\"table\", prop=\"small\")\n",
    "\"This is a table. It's small.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Регулярные выражения"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Регулярные выражения - язык описания шаблонов (patterns) для извлечения информации из текста.\n",
    "Так что по смыслу  правильнее было бы говорить «шаблонные выражения». Регулярное выражение, или коротко «регулярка», состоит из обычных символов и специальных командных последовательностей."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "321-66-13 is a phone number:\n",
      "True\n",
      "Moshi moshi is a phone number:\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def isPhoneNumber(text):\n",
    "    if len(text) != 9:\n",
    "        return False  # not phone number-sized\n",
    "    for i in range(0, 3):\n",
    "        if not text[i].isdecimal():\n",
    "            return False  # not an area code\n",
    "    if text[3] != '-':\n",
    "        return False  # does not have first hyphen\n",
    "    for i in range(4, 6):\n",
    "        if not text[i].isdecimal():\n",
    "            return False  # does not have first 3 digits\n",
    "    if text[6] != '-':\n",
    "        return False  # does not have second hyphen\n",
    "    for i in range(7, 8):\n",
    "        if not text[i].isdecimal():\n",
    "            return False  # does not have last 4 digits\n",
    "    return True  # \"text\" is a phone number!\n",
    "\n",
    "print('321-66-13 is a phone number:')\n",
    "print(isPhoneNumber('321-66-13'))\n",
    "print('Moshi moshi is a phone number:')\n",
    "print(isPhoneNumber('Moshi moshi'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "321-66-13\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "phoneNumRegex = re.compile(r'\\d{3}-\\d{2}-\\d{2}')\n",
    "mo = phoneNumRegex.search('321-66-13 is a phone number:')\n",
    "xo = phoneNumRegex.search('Moshi moshi is a phone number:')\n",
    "print(mo.group())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Импортируем модуль regex с помощью инструкции **import re**\n",
    "* Создаем объект regex с помощью функции re.compile(). При этом используем сырую строку, чтобы избежать экранирования символов \n",
    "* Передаем строку, в которой хотим произвести поиск методу re.search объекта Regex. В случае успеха этот метод вернет объект Мatch \n",
    "* Вызовите метод group() объекта Match, который вернет строку, содержащую фактически найденный текст, соответствующий данному регулярному выражению \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Основы синтаксиса (воспринимать аккуратно, чтобы не запутаться)\n",
    "\n",
    "\n",
    "Любая строка (в которой нет символов .^$*+?{}[]\\|()) сама по себе является регулярным выражением. \n",
    "\n",
    "Так, выражению Хаха будет соответствовать строка “Хаха” и только она.\n",
    "Регулярные выражения являются регистрозависимыми, поэтому строка “хаха” (с маленькой буквы) уже не будет соответствовать выражению выше. \n",
    "\n",
    "Подобно строкам в языке Python, регулярные выражения имеют спецсимволы .^$*+?{}[]\\|(), которые в регулярках являются управляющими конструкциями. \n",
    "Для написания их просто как символов требуется их экранировать, для чего нужно поставить перед ними знак \\. Так же, как и в питоне, в регулярных выражениях выражение \\n соответствует концу строки, а \\t — табуляции. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|||\n",
    "|--- |--- |\n",
    "|.|Соответствует любому единичному символу.|\n",
    "|[ ]|Соответствует любому единичному символу из числа заключённых в скобки. Символ «-» интерпретируется буквально только в том случае, если он расположен непосредственно после открывающей или перед закрывающей скобкой: [abc-] или [-abc]. В противном случае, он обозначает интервал символов. Например, [abc] соответствует «a», «b» или «c». [a-z] соответствует буквам нижнего регистра латинского алфавита. Эти обозначения могут и сочетаться: [abcq-z] соответствует a, b, c, q, r, s, t, u, v, w, x, y, z.\n",
    "| |Чтобы установить соответствие символам «[» или «]», достаточно, чтобы закрывающая скобка была первым символом после открывающей: [][ab] соответствует «]», «[», «a» или «b».|\n",
    "|[^ ]|Соответствует единичному символу из числа тех, которых нет в скобках. Например, [^abc] соответствует любому символу, кроме «a», «b» или «c». [^a-z] соответствует любому символу, кроме символов нижнего регистра в латинском алфавите.|\n",
    "|^|Соответствует началу текста (или началу любой строки в мультистроковом режиме). Ищет с начала текста.|\n",
    "|$|Соответствует концу текста (или концу любой строки в мультистроковом режиме).|\n",
    "|\\(\\)|Объявляет «отмеченное подвыражение» (иногда называется «захват»), которое может быть использовано позже (см. следующий элемент: \\n). «Отмеченное подвыражение» также является «блоком».  В отличие от других операторов, этот (в традиционном синтаксисе) требует бэкслеша.|\n",
    "|\\n | Где n — это цифра от 1 до 9; соответствует n-му отмеченному подвыражению. Эта конструкция теоретически нерегулярна, она не была принята в расширенном синтаксисе регулярных выражений.|\n",
    "|*|Звёздочка после выражения, соответствующего единичному символу, соответствует нулю или более копий этого выражения. Например, «[xyz]*» соответствует пустой строке, «x», «y», «zx», «zyx», и т. д.\n",
    "|\\{x,y\\}|Соответствует последнему блоку, встречающемуся не менее x и не более y раз. Например, «a\\{3,5\\}» соответствует «aaa», «aaaa» или «aaaaa».  В отличие от других операторов, этот (в традиционном синтаксисе) требует бэкслеша.|\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Квантификация\n",
    "    Квантификатор после символа или группы определяет, сколько раз предшествующее выражение может встречаться.\n",
    "\n",
    "    {n,m}        общее выражение, повторений может быть от n до m включительно.\n",
    "    {n,}        общее выражение, n и более повторений.\n",
    "    {,m}        общее выражение, не более m повторений.\n",
    "    {n}        общее выражение, ровно n повторений\n",
    "     ?        Знак вопроса означает 0 или 1 раз, то же самое, что и {0,1}. Например, «colou?r» соответствует и color, и colour.\n",
    "    *        Звёздочка означает 0, 1 или любое число раз ({0,}). Например, «go*gle» соответствует gogle, google, gooogle, ggle, и др.\n",
    "    +        Плюс означает хотя бы 1 раз ({1,}). Например, «go+gle» соответствует gogle, google и т. д. (но не ggle)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Экранирование строк в python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\n",
      "ewt.txt C:\\newt.txt\n"
     ]
    }
   ],
   "source": [
    "s = 'C:\\newt.txt'\n",
    "S = r'C:\\newt.txt'\n",
    "print(s, S)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 15), match='(812) 321-66-13'>\n"
     ]
    }
   ],
   "source": [
    "russian_num = re.compile(r'(\\(\\d{3}\\))\\s?(\\d{3}-\\d{2}-\\d{2})')\n",
    "mo = russian_num.search('(812) 321-66-13 is a phone number:')\n",
    "xo = russian_num.search('Moshi moshi is a phone number:')\n",
    "print(mo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Наборы в регулярных выражениях\n",
    "набор задается внутри квадратных скобок"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 4), match='река'>\n"
     ]
    }
   ],
   "source": [
    "pattern = r'р[еу]ка' # запись означает, что вторым символов может быть a b c \n",
    "string = 'река'\n",
    "match_obj = re.search(pattern, string)\n",
    "print(match_obj)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 4), match='Рука'>\n"
     ]
    }
   ],
   "source": [
    "#ignorecase - и регистр нас уже не волнует\n",
    "pattern = r'р[еу]ка' # запись означает, что вторым символов может быть a b c \n",
    "string = 'Рука'\n",
    "match_obj = re.search(pattern, string, re.IGNORECASE)\n",
    "print(match_obj)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Условия в регулярных выражениях \n",
    "\n",
    "оператор | (канал) позволяет создавать условные конструкции в регулярных выражениях"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Володя'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "phrase = 'Володя кинул Мише мяч, Миша его отбил'\n",
    "reg = re.compile(r'Володя|Миша')\n",
    "mo = reg.search(phrase)\n",
    "mo.group()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Нахождение всех совпадений"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Володя', 'Миша']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fa = reg.findall(phrase)\n",
    "fa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Указание необязательной группы символов с помощью вопросительного знака"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 9), match='321-66-13'>\n"
     ]
    }
   ],
   "source": [
    "russian_num = re.compile(r'(\\(\\d{3}\\))?(\\d{3}-\\d{2}-\\d{2})')\n",
    "mo = russian_num.search('(812)321-66-13 is a phone number:')\n",
    "xo = russian_num.search('321-66-13 is a phone number:')\n",
    "print(xo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Разделение по паттерну"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Analytics ', ' Vidhya']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = re.split(r'\\d', 'Analytics 21 Vidhya')\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Подробнее о регулярных выажениях\n",
    "https://habr.com/ru/post/349860/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Подробнее о регулярных выражениях https://ru.wikibooks.org/wiki/%D0%A0%D0%B5%D0%B3%D1%83%D0%BB%D1%8F%D1%80%D0%BD%D1%8B%D0%B5_%D0%B2%D1%8B%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Некоторые люди, когда сталкиваются с проблемой, думают «Я знаю, я решу её с помощью регулярных выражений.» Теперь у них две проблемы.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Файлы "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Файл — именованная область данных на носителе информации.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python поддерживает множество различных типов файлов, но условно их можно разделить на два виде: текстовые и бинарные.\n",
    "\n",
    "Текстовые файлы - это к примеру файлы с расширением cvs, txt, html, в общем любые файлы, которые сохраняют информацию в текстовом виде.\n",
    "\n",
    "Бинарные файлы - это изображения, аудио и видеофайлы и т.д. В зависимости от типа файла работа с ним может немного отличаться."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<code> with open(file, mode) as file_obj:\n",
    "    инструкции </code>\n",
    "    \n",
    "Эта конструкция определяет для открытого файла переменную file_obj и выполняет набор инструкций. После их выполнения файл автоматически закрывается. Даже если при выполнении инструкций в блоке with возникнут какие-либо исключения, то файл все равно закрывается."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Запись в файл\n",
    "with open(\"hello.txt\", \"w\") as somefile:\n",
    "    somefile.write(\"hello world\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "#добавим ещё одну строку\n",
    "with open(\"hello.txt\", \"a\") as file:\n",
    "    file.write(\"\\ngood bye, world\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['hello world\\n', 'good bye, world']\n"
     ]
    }
   ],
   "source": [
    "#читаем файл построчно\n",
    "with open(\"hello.txt\", \"r\") as file:\n",
    "    for line in file:\n",
    "        print(line, end=\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n",
      "good bye, world\n"
     ]
    }
   ],
   "source": [
    "#читаем файл целиком\n",
    "with open(\"hello.txt\", \"r\") as file:\n",
    "    content = file.read()\n",
    "    print(content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Введите строку 1: ываываы\n",
      "Введите строку 2: ываываыва\n",
      "Введите строку 3: ваываыва\n",
      "Введите строку 4: уукук\n",
      "Считанные сообщения\n",
      "ываываы\n",
      "ываываыва\n",
      "ваываыва\n",
      "уукук\n"
     ]
    }
   ],
   "source": [
    "# имя файла\n",
    "FILENAME = \"messages.txt\"\n",
    "# определяем пустой список\n",
    "messages = list()\n",
    " \n",
    "for i in range(4):\n",
    "    message = input(\"Введите строку \" + str(i+1) + \": \")\n",
    "    messages.append(message + \"\\n\")\n",
    " \n",
    "# запись списка в файл\n",
    "with open(FILENAME, \"a\") as file:\n",
    "    for message in messages:\n",
    "        file.write(message)\n",
    " \n",
    "# считываем сообщения из файла\n",
    "print(\"Считанные сообщения\")\n",
    "with open(FILENAME, \"r\") as file:\n",
    "    for message in file:\n",
    "        print(message, end=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для того чтобы работать с файлами в Питоне следует также понимать принципы работы path\n",
    "Рабочая библиотека **os**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/home/politlen/Documents'"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['EXAMINATION.ipynb',\n",
       " '3три.txt',\n",
       " 'keys.txt',\n",
       " 'proxys.csv',\n",
       " 'testfig.png',\n",
       " 'result.txt',\n",
       " 'async_courts_fin.ipynb',\n",
       " 'df.csv',\n",
       " 'test2.png',\n",
       " 'NKO_clusters_by_name.ipynb',\n",
       " 'opengo.ipynb',\n",
       " 'вводный урок (3).ipynb',\n",
       " 'парсинг сайтов.ipynb',\n",
       " '1раз.txt',\n",
       " 'hello.txt',\n",
       " 'вводный урок.ipynb',\n",
       " 'Строки, файлы и регулярные выражения.ipynb',\n",
       " 'Analyze this.ipynb',\n",
       " 'f1040sb.pdf',\n",
       " 'results.xlsx',\n",
       " 'salary.png',\n",
       " 'Очистка_данных_и_создание_новых.ipynb',\n",
       " 'proxys.ods',\n",
       " 'saratov_map.html',\n",
       " 'links.csv',\n",
       " 'plotly_graphs.ipynb',\n",
       " 'study_scrappy',\n",
       " 'output.csv',\n",
       " 'result.xlsx',\n",
       " '2два.txt',\n",
       " 'messages.txt',\n",
       " 'аналитичекий_ноутбук.ipynb',\n",
       " 'output.png',\n",
       " 'index.html',\n",
       " 'anon_text',\n",
       " 'Знакомство с pandas (3).ipynb',\n",
       " 'функции в python.ipynb',\n",
       " 'Введение_в_программирование_циклы.ipynb',\n",
       " 'Списки и словари.ipynb',\n",
       " 'f1040a.pdf',\n",
       " 'f1040ez.pdf',\n",
       " '2008_swing_states.csv',\n",
       " 'test.csv',\n",
       " 'Знакомство с pandas.ipynb',\n",
       " 'oop',\n",
       " 'data.csv',\n",
       " 'Api vk.ipynb',\n",
       " 'token.txt',\n",
       " 'geo.csv',\n",
       " '.ipynb_checkpoints',\n",
       " 'test3.png',\n",
       " 'geckodriver',\n",
       " 'datacamp.ipynb',\n",
       " 'визуализация данных.ipynb',\n",
       " 'f1040es.pdf',\n",
       " 'test_nan.csv',\n",
       " 'f1040.pdf',\n",
       " 'geckodriver.log']"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.listdir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/home/politlen'"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.chdir('../')\n",
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Подробнее про модуль os https://python-scripts.com/import-os-example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Задача на файлы и строки\n",
    "var = \"\"\"ЭтОТ текст ИМЕЕЕТ явнЫе проБЛЕМы с РЕГИСТРОМ. ЕГО писал нездоровый коллега, \n",
    "КОТОРЫЙ то ли УШЕЛ в отпуск то ли на больничный, и теперь он недоступен.Однако в этом тексте содержится ключевая информация по поставкам, \n",
    "которая срочно должна оказаться на столе у начальника. \n",
    "Дальше идет долгое и подробное описание деталей поставок, характеристик товаров и прочее прочее. Страниц на 100\n",
    "Нам нужно вычленить оТсюда ключевую информацию  записать её в файл:\n",
    "Ford Focus, colour: grey, transmission: automate, price: 1,1 kk rub,  tel: 8(880)456-65-78\n",
    "Ford Mondeo, colour: blue; transmission: automate, price: 1,6 kk rub, tel: 8(880)546-55-79\n",
    "\"\"\"\n",
    "\n",
    "#Хотим чтобы каждое предложение начиналось  с большой буквы, а остальные были с маленькой\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Этот текст имееет явные проблемы с регистром. Его писал нездоровый коллега, \n",
      "который то ли ушел в отпуск то ли на больничный, и теперь он недоступен.однако в этом тексте содержится ключевая информация по поставкам, \n",
      "которая срочно должна оказаться на столе у начальника. Дальше идет долгое и подробное описание деталей поставок, характеристик товаров и прочее прочее. Страниц на 100\n",
      "нам нужно вычленить отсюда ключевую информацию  записать её в файл: \n"
     ]
    }
   ],
   "source": [
    "#Запись в файл. В жизни этот этап был бы пропущен\n",
    "with open(\"hello.txt\", \"w\") as file:\n",
    "    file.write(var)\n",
    "    \n",
    "with open(\"hello.txt\", \"r\") as file:\n",
    "    data = file.read()\n",
    "    \n",
    "\n",
    "text, info = data.split('файл:')\n",
    "textLower = text.lower() + 'файл: '\n",
    "textUpdated =  print(\". \".join(i.capitalize() for i in  re.split(r'\\.\\s+', textLower)))\n",
    "textUpdated"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как видите, \"нам\" не вернулось обратно в исходную форму, потому что не подходит по паттерну. \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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}