{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f47e46ad-2c9d-406a-ae3f-de637a0355c2",
   "metadata": {},
   "source": [
    "<table align=right>\n",
    "    <tr>\n",
    "        <td align=center>\n",
    "            <font size=6><b>Программирование $-$ 2026.</b></font>  \n",
    "        </td>\n",
    "        <td align=right>\n",
    "<img src=\"logoMM.png\" align=right width=120>\n",
    "        </td>\n",
    "    </tr>\n",
    "    </table>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-000",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Регулярные выражения в Python: продолжение"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-001",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**ВАЖНО** : Практикум на полчаса-час прилагается отдельным файлом для самостоятельного разбора.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "lecture60-002",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-003",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 1. Повторение и постановка задачи\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-004",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Шаблон кода: две заглавные латинские буквы, дефис, три цифры.\n",
    "Как проверить, вся ли строка является кодом? Есть ли код внутри строки?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "lecture60-005",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "text = \"Заказ AB-007 принят\"\n",
    "print(bool(re.fullmatch(r\"[A-Z]{2}-[0-9]{3}\", text)))\n",
    "print(bool(re.search(r\"[A-Z]{2}-[0-9]{3}\", text)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-006",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`fullmatch()` проверяет всю строку; `search()` находит первый подходящий фрагмент. Результат — объект совпадения или `None`.\\\n",
    "`bool()` используется здесь только для краткого вывода.\n",
    "\n",
    "**Новая задача**: получить код → выделить части → обработать все коды → преобразовать текст.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-007",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 2. Объект совпадения: group() и span()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-008",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`search()` возвращает объект `Match`, а не саму найденную строку.\n",
    "\n",
    "| Метод | Результат |\n",
    "|---|---|\n",
    "| group() или group(0) | Всё совпадение |\n",
    "| start() | Индекс начала |\n",
    "| end() | Индекс конца, не включительно |\n",
    "| span() | Кортеж границ |\n",
    "\n",
    "Перед вызовом методов проверяем результат поиска.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "lecture60-009",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "text = \"Код: AB-007.\"\n",
    "match = re.search(r\"[A-Z]{2}-[0-9]{3}\", text)\n",
    "if match:\n",
    "    print(match.group())\n",
    "    print(match.group(0))\n",
    "    print(match.span())\n",
    "    start, end = match.span()\n",
    "    print(text[start:end])\n",
    "else:\n",
    "    print(\"Код не найден\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-010",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Напоминание \n",
    "\n",
    "Если строка, соответствующая шаблону, не найдена, вызвать `group()` нельзя! У `None` нет метода `group()`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "lecture60-011",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "match = re.search(r\"[A-Z]{2}-[0-9]{3}\", \"Кода здесь нет\")\n",
    "if match:\n",
    "    print(match.group())\n",
    "else:\n",
    "    print(\"Код не найден\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-013",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 3. Захватывающие группы\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-014",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Сравните:\n",
    "\n",
    "```python\n",
    "r\"[A-Z]{2}-[0-9]{3}\"\n",
    "r\"([A-Z]{2})-([0-9]{3})\"\n",
    "```\n",
    "\n",
    "Формат одинаков; скобки во втором шаблоне выделяют ***группы***.\n",
    "\n",
    "```text\n",
    "([A-Z]{2}) - ([0-9]{3})\n",
    "     1             2\n",
    "```\n",
    "\n",
    "Нумерация групп по открывающим скобкам слева направо, начиная с 1. \\\n",
    "Группа 0 $-$ всё совпадение с шаблоном. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "lecture60-015",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "match = re.fullmatch(r\"([A-Z]{2})-([0-9]{3})\", \"AB-007\")\n",
    "if match:\n",
    "    print(\"Весь код:\", match.group(0))\n",
    "    print(\"Буквы:\", match.group(1))\n",
    "    print(\"Цифры:\", match.group(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-016",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### group() и groups()\n",
    "\n",
    "- `group(`): всё совпадение, строка.\n",
    "- `group(1)`: первая группа.\n",
    "- `groups()`: кортеж всех захватывающих групп без группы 0.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "lecture60-017",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('AB', '007')\n",
      "AB\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "if match:\n",
    "    print(match.groups())\n",
    "    letters, digits = match.groups()\n",
    "    print(letters)\n",
    "    print(int(digits))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-018",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Пример: время\n",
    "\n",
    "Группа 1 — часы 00–23, группа 2 — минуты 00–59. \\\n",
    "Выведите содержимое групп и число минут, прошедшее с начала от начала суток.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "lecture60-019",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('09', '05')\n",
      "545\n"
     ]
    }
   ],
   "source": [
    "match = re.fullmatch(r\"([01][0-9]|2[0-3]):([0-5][0-9])\", \"09:05\")\n",
    "if match:\n",
    "    hours, minutes = match.groups()\n",
    "    print(match.groups())\n",
    "    print(int(hours) * 60 + int(minutes))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-020",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Частые ошибки: \n",
    "- вызов метода у `None`;\n",
    "- обращение к несуществующей группе (IndexError). "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-021",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 4. findall(): все найденные значения\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-022",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Возвращает список неперекрывающихся совпадений слева направо. Нет совпадений — пустой список.\n",
    "\n",
    "### Без захватывающих групп: полные совпадения\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "lecture60-023",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['AB-007', 'CD-125']\n"
     ]
    }
   ],
   "source": [
    "text = \"Коды: AB-007, CD-125.\"\n",
    "print(re.findall(r\"[A-Z]{2}-[0-9]{3}\", text))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-024",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Одна группа: содержимое группы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "lecture60-025",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['AB', 'CD']\n"
     ]
    }
   ],
   "source": [
    "print(re.findall(r\"([A-Z]{2})-[0-9]{3}\", text))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-026",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Несколько групп: список кортежей"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "lecture60-027",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('AB', '007'), ('CD', '125')]\n",
      "AB 7\n",
      "CD 125\n"
     ]
    }
   ],
   "source": [
    "pairs = re.findall(r\"([A-Z]{2})-([0-9]{3})\", text)\n",
    "print(pairs)\n",
    "for letters, digits in pairs:\n",
    "    print(letters, int(digits))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "lecture60-029",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "print(re.findall(r\"[0-9]+\", \"Чисел нет\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-030",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 5. Незахватывающие группы (?:...)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-031",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Дана строка, содержащая числа. Хотим получить числа целиком. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "lecture60-032",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['', '.5', '.25']\n"
     ]
    }
   ],
   "source": [
    "text = \"Значения: 12, 3.5, 7.25\"\n",
    "print(re.findall(r\"[0-9]+(\\.[0-9]+)?\", text))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-033",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "***Ошибка!*** Получены только дробные части. \\\n",
    "Еще раз: если есть группы, то `findall` возвращает содержимое групп. Для первого числа необязательной группы не оказалось и `findall` вернул пустую строку в соответствующем элементе.\n",
    "\n",
    "**Исправляем:** превращаем группу для дробной части в незахватывающую группу.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "lecture60-034",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['12', '3.5', '7.25']\n"
     ]
    }
   ],
   "source": [
    "print(re.findall(r\"[0-9]+(?:\\.[0-9]+)?\", text))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-035",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```text\n",
    "(...)    — объединить и захватить\n",
    "(?:...)  — только объединить\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-037",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 6. finditer(): объекты всех совпадений\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "lecture60-038",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AB-007 (6, 12) ('AB', '007')\n",
      "CD-125 (14, 20) ('CD', '125')\n"
     ]
    }
   ],
   "source": [
    "text = \"Коды: AB-007, CD-125.\"\n",
    "for match in re.finditer(r\"([A-Z]{2})-([0-9]{3})\", text):\n",
    "    print(match.group(), match.span(), match.groups())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81eae39f-1f1a-46df-b16d-e54395f23ac3",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`finditer()` возвращает итератор объектов Match.\n",
    "\n",
    "| Нужно | Выбор |\n",
    "|---|---|\n",
    "| Готовый список значений | findall() |\n",
    "| Позиции и группы | finditer() |\n",
    "| Последовательная обработка без списка всех результатов | finditer() |\n",
    "| Только первое совпадение шаблона | search() |\n",
    "\n",
    "- Итератор исчерпывается после обхода.\n",
    "- `finditer()` не обязательно быстрее.\n",
    "- Исходная строка уже находится в памяти; экономия относится к отсутствию списка всех результатов."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b77b9da5-27e6-410f-8f2f-d2196b7a82b9",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Пример: Досрочный выход\n",
    "\n",
    "Найдём первую числовую запись со значением больше 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "lecture60-040",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140\n"
     ]
    }
   ],
   "source": [
    "text = \"Значения: 12, 75, 140, 200, 350.\"\n",
    "for match in re.finditer(r\"[0-9]+\", text):\n",
    "    number = int(match.group())\n",
    "    if number > 100:\n",
    "        print(number)\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-041",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 7. split(): разбиение по шаблону"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-042",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "В `findall()` описываем нужные фрагменты; в `split()` $-$ разделители.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "lecture60-043",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['12', '7', '25']\n"
     ]
    }
   ],
   "source": [
    "print(re.split(r\"[,;\\s]+\", \"12, 7;   25\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-044",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Разделители на краях\n",
    "\n",
    "Могут возникать пустые крайние элементы.  // *Это не баг, а фича.*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "lecture60-045",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['', '12', '7', '']\n"
     ]
    }
   ],
   "source": [
    "print(re.split(r\"[,;]\", \";12,7;\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-046",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Захватывающие группы сохраняют разделители\n",
    "\n",
    "Это правило `split()`: содержимое групп шаблона разделителя включается в результат.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "lecture60-047",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['12', '7', '25']\n",
      "['12', ',', '7', ';', '25']\n",
      "['12', '7', '25']\n"
     ]
    }
   ],
   "source": [
    "text = \"12,7;25\"\n",
    "print(re.split(r\"[,;]\", text))\n",
    "print(re.split(r\"([,;])\", text))\n",
    "print(re.split(r\"(?:[,;])\", text))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-050",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 8. sub(): замена с группами"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-051",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Преобразуем ГГГГ-ММ-ДД  в ДД.ММ.ГГГГ.\n",
    "\n",
    "| Группа | Часть | Ссылка в замене |\n",
    "|---|---|---|\n",
    "| 1 | Год | `\\g<1>` |\n",
    "| 2 | Месяц | `\\g<2>` |\n",
    "| 3 | День | `\\g<3>` |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "lecture60-052",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Дата: 07.11.2026\n"
     ]
    }
   ],
   "source": [
    "text = \"Дата: 2026-11-07\"\n",
    "result = re.sub(\n",
    "    r\"([0-9]{4})-([0-9]{2})-([0-9]{2})\",\n",
    "    r\"\\g<3>.\\g<2>.\\g<1>\",\n",
    "    text\n",
    ")\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-053",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "В строке замены `\\g<номер>` подставляет содержимое группы.\n",
    "\n",
    "- `match.group(1)` $-$ вызов метода в Python.\n",
    "- `\\g<1>` — ссылка внутри строки замены.\n",
    "\n",
    "\n",
    "### Задача\n",
    "\n",
    "Обрамить каждую последовательность цифр квадратными скобками без отдельной захватывающей группы\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "lecture60-054",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Результаты: [12], [7], [25].\n"
     ]
    }
   ],
   "source": [
    "# Используем группу 0.\n",
    "print(re.sub(r\"[0-9]+\", r\"[\\g<0>]\", \"Результаты: 12, 7, 25.\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-055",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 9. IGNORECASE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-056",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Флаг меняет правила сопоставления, игнорируя строчные и заглавные буквы в исходном тексте. Найденные фрагменты сохраняют своё написание."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "lecture60-057",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python']\n",
      "['Python', 'PYTHON', 'python']\n"
     ]
    }
   ],
   "source": [
    "text = \"Python, PYTHON и python\"\n",
    "print(re.findall(r\"python\", text))\n",
    "print(re.findall(r\"python\", text, flags=re.IGNORECASE))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28ea3936-2394-4ec1-95fd-a212500b321c",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Флаг работает с Unicode-текстом."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "lecture60-058",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Математика', 'МАТЕМАТИКА', 'математика']\n"
     ]
    }
   ],
   "source": [
    "text = \"Математика, МАТЕМАТИКА, математика\"\n",
    "print(re.findall(r\"математика\", text, flags=re.IGNORECASE))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-060",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 10. compile(): объект шаблона\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-061",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Сравните:\n",
    "\n",
    "```python\n",
    "re.findall(pattern, text)\n",
    "```\n",
    "\n",
    "```python\n",
    "compiled_pattern = re.compile(pattern)\n",
    "compiled_pattern.findall(text)\n",
    "```\n",
    "\n",
    "Шаблон и флаги хранятся в объекте `compiled_pattern`. Повторно передавать шаблон методу не нужно.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4786821-fead-4b26-9601-978a603f14c1",
   "metadata": {},
   "source": [
    "### Зачем нужен `re.compile`?\n",
    "\n",
    "#### 1. Производительность при повторном использовании\n",
    "\n",
    "Когда вы вызываете `re.search(pattern, s)`, модуль `re` **каждый раз** заново компилирует строку `pattern` в машинное представление. Если один и тот же шаблон применяется в цикле к тысяче строк, — это лишняя работа.\n",
    "\n",
    "`re.compile` позволяет **скомпилировать шаблон один раз** и переиспользовать его.\n",
    "\n",
    "#### 2. Удобство и читаемость\n",
    "\n",
    "Именованная переменная `date_pattern` понятнее, чем «магическая» строка `r\"\\d{2}\\.\\d{2}\\.\\d{4}\"` внутри вызова функций поиска и замены.\n",
    "\n",
    "#### 3. Дополнительные методы\n",
    "\n",
    "У скомпилированного объекта есть методы с необязательным аргументом `pos` — позицией, с которой нужно начать поиск:\n",
    "\n",
    "```python\n",
    "pat.search(text, pos)\n",
    "```\n",
    "\n",
    "#### Внутренний кэш модуля `re`\n",
    "\n",
    "Если честно, то модуль `re` сам кэширует последние скомпилированные шаблоны (по умолчанию — 512). Поэтому вызов `re.search` в цикле не так страшен. Тем не менее, `re.compile` делает намерение программиста явным и надёжным."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25fe645e-fd38-4287-ab93-3b121f161303",
   "metadata": {},
   "source": [
    "Если шаблон известен заранее и используется в цикле — компилируйте его **до** цикла."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "lecture60-062",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'A cat is here.': cat\n",
      "'A concatenation of cats.': нет\n",
      "'Cat and CAT are here.': нет\n"
     ]
    }
   ],
   "source": [
    "# Пример: пользователь задаёт искомое слово\n",
    "word = 'cat'\n",
    "\n",
    "# Формируем шаблон — ищем это слово как отдельное слово\n",
    "pattern = re.compile(r'\\b' + word + r'\\b')\n",
    "\n",
    "texts = [\n",
    "    'A cat is here.',\n",
    "    'A concatenation of cats.',\n",
    "    'Cat and CAT are here.',\n",
    "]\n",
    "\n",
    "for t in texts:\n",
    "    m = pattern.search(t)\n",
    "    print(f'{t!r}:', m.group() if m else 'нет')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-063",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "| Операция | Метод объекта |\n",
    "|---|---|\n",
    "| Проверка | pattern.fullmatch(text) |\n",
    "| Первый фрагмент | pattern.search(text) |\n",
    "| Все значения | pattern.findall(text) |\n",
    "| Обход | pattern.finditer(text) |\n",
    "| Разбиение | pattern.split(text) |\n",
    "| Замена | pattern.sub(replacement, text) |\n",
    "\n",
    "Главное — понятное имя и повторное использование. Ускорение не гарантируется)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-064",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 11. Итоги и вопросы"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lecture60-065",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "| Нужно | Инструмент | Результат |\n",
    "|---|---|---|\n",
    "| Проверить всю строку | fullmatch() | Match или None |\n",
    "| Найти первый фрагмент | search() | Match или None |\n",
    "| Получить всё совпадение | group() | Строка |\n",
    "| Получить группы | groups() | Кортеж |\n",
    "| Узнать границы | span() | Кортеж |\n",
    "| Получить все значения | findall() | Список строк или кортежей |\n",
    "| Обойти совпадения | finditer() | Итератор |\n",
    "| Разделить текст | split() | Список |\n",
    "| Преобразовать текст | sub() | Строка |\n",
    "| Сохранить шаблон | compile() | Объект регулярного выражения |\n",
    "\n",
    "\n",
    "### Возможные вопросы на экзамене\n",
    "\n",
    "- Чем различаются `group()` и `groups()`?\n",
    "- Когда `findall()` возвращает кортежи?\n",
    "- Зачем нужны `(?:...)`?\n",
    "- Когда выбрать `finditer()`?\n",
    "- Почему скобки сохраняют разделители в `split()`?\n",
    "- Чем флаг отличается от изменения регистра строки?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bec3bf38-f6e6-40e6-bae4-406574238688",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
