1.2_LEC_regular_expressions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XQe7nsuY__r7"
   },
   "source": [
    "Определите длину каждого из этих списков"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "TkYg2RmtA66L"
   },
   "outputs": [],
   "source": [
    "a = [1, 2, 3]\n",
    "b = [1, [2, 3]]\n",
    "c = []\n",
    "d = [1, 2, 3][1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AMHNsoZd59w2"
   },
   "source": [
    "## Изменяемые и неизменяемые типы данных"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Ndf43O1F6ZSj"
   },
   "outputs": [],
   "source": [
    "some_names = ['John', 'James', 'Linda']  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "pVlzWQlj4Hyx",
    "outputId": "7a4e774d-729e-466f-924e-aa8268bf3759"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['James', 'John', 'Linda']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "some_names.sort()\n",
    "\n",
    "some_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "z_U4KUt04H1n",
    "outputId": "ac82b08d-3402-49b4-8a42-4ef1acd7b1dc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "my_string = 'Hello world'\n",
    "\n",
    "res = my_string.lower()\n",
    "\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "tIKGWXTQ4H4P",
    "outputId": "f9aed79b-5a5f-41d3-e4ff-00143c6def0e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['James', 'John', 'Linda']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "res = sorted(some_names)\n",
    "\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "5TBq1es84H6_",
    "outputId": "2cba33c2-0de7-4112-ae38-b1ebcfddeded"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['John', 'James', 'Linda']\n"
     ]
    }
   ],
   "source": [
    "some_names = ['John', 'James', 'Linda']  \n",
    "sorted(some_names)\n",
    "\n",
    "print(some_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XOY7VKI357LA"
   },
   "source": [
    "Как можно \"разгладить\" список. Задачка на мышление  \n",
    "Должен получится результат:\n",
    "\n",
    "`['Екатеринбург', 'Москва', 'Санкт-Петербург', 'Норильск', 'Пермь', 'Астрахань']`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "TL8qWkEI6mLE"
   },
   "outputs": [],
   "source": [
    "my_list = [['Екатеринбург', 'Москва'], ['Санкт-Петербург', 'Норильск'], ['Пермь', 'Астрахань']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "gNqto9KB6sDG",
    "outputId": "7db5c4d5-703f-44c3-c6d8-32136f69b0ba"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Екатеринбург', 'Москва']\n",
      "Екатеринбург\n",
      "Москва\n",
      "['Санкт-Петербург', 'Норильск']\n",
      "Санкт-Петербург\n",
      "Норильск\n",
      "['Пермь', 'Астрахань']\n",
      "Пермь\n",
      "Астрахань\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['Екатеринбург', 'Москва', 'Санкт-Петербург', 'Норильск', 'Пермь', 'Астрахань']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = []\n",
    "\n",
    "for el in my_list:\n",
    "    print(el)\n",
    "    for city in el:\n",
    "        print(city)\n",
    "        res.append(city)\n",
    "\n",
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "xaM-vnUR7IIK",
    "outputId": "b4762d87-0cc3-4e10-a33f-276318bda68e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Екатеринбург', 'Москва']\n",
      "['Санкт-Петербург', 'Норильск']\n",
      "['Пермь', 'Астрахань']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['Екатеринбург', 'Москва', 'Санкт-Петербург', 'Норильск', 'Пермь', 'Астрахань']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = []\n",
    "\n",
    "for el in my_list:\n",
    "    print(el)\n",
    "    res += el\n",
    "\n",
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "eqDlz1KP7aCs",
    "outputId": "a56008f6-9694-49fe-fa32-8f1dabaedf45"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 2] + [3, 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ER7W-cvn7k-H",
    "outputId": "e9785de8-cdf9-41e0-8545-235875696dbc"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Екатеринбург', 'Москва', 'Санкт-Петербург', 'Норильск', 'Пермь', 'Астрахань']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(my_list, [])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "embfzDW873q5",
    "outputId": "82140367-23c9-4afc-d158-e531b4d5886c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sum in module builtins:\n",
      "\n",
      "sum(iterable, /, start=0)\n",
      "    Return the sum of a 'start' value (default: 0) plus an iterable of numbers\n",
      "    \n",
      "    When the iterable is empty, return the start value.\n",
      "    This function is intended specifically for use with numeric values and may\n",
      "    reject non-numeric types.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rLyLP81sEeYY"
   },
   "source": [
    "## Гипотеза Сиракуз\n",
    "https://ru.wikipedia.org/wiki/Гипотеза_Коллатца  \n",
    "Гипотеза Сиракуз гласит, что любое натуральное число сводится к единице при следующих действиях над ним: \n",
    "\n",
    "а) если число четное, то разделить его пополам, \n",
    "\n",
    "б) если число нечетное, то умножить его на 3, прибавить 1 и результат разделить на 2. \n",
    "\n",
    "Над вновь полученным числом вновь повторить действия a) или б) в зависимости от четности числа. Рано или поздно число станет равным 1.\n",
    "\n",
    "Напишем программу, проверяющую гипотезу Сиракуз. Пусть пользователь вводит любое натуральное число. Будем выполнять в цикле над ним вышеуказанные действия, пока оно не станет равным 1. Если гипотеза верна, то рано или поздно цикл закончится, а если нет - то произойдет зацикливание программы.\n",
    "\n",
    "https://www.youtube.com/watch?v=QgzBDZwanWA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "fNPueODdEeYY",
    "outputId": "57122e88-bdb0-4d25-dbe3-ac774896b6c3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9789690303392599179036234\n",
      "1.0 367\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "counter = 0\n",
    "while n != 1:\n",
    "    counter += 1\n",
    "    if n % 2 == 0:\n",
    "        n /= 2\n",
    "    else:\n",
    "        n = (n * 3 + 1) / 2\n",
    "print(n, counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "E6ywQi0G5-o1"
   },
   "source": [
    "## else и циклы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rrt2CXpIxlJz"
   },
   "source": [
    "Напишем игру \"Угадай число\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "8oU2aES0g53U",
    "outputId": "76f829a3-fd71-4f77-e168-af77cadf9b8e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n",
      "Назови свой вариант18\n",
      "Вы победили!\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "number = random.randint(1, 100)\n",
    "print(number)\n",
    "max_tries = 3\n",
    "tries = 0\n",
    "\n",
    "while tries < max_tries:\n",
    "    guess = int(input('Назови свой вариант'))\n",
    "    tries += 1\n",
    "    if guess < number:\n",
    "        print('Загаданное число больше')\n",
    "    elif guess > number:\n",
    "        print('Загаданное число меньше')\n",
    "    else:\n",
    "        print('Вы победили!')\n",
    "        break\n",
    "else: \n",
    "    print('Вы проиграли')\n",
    "    print('Было загадано число:', number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "qzwdSp8K-vzh",
    "outputId": "83a592fa-b062-4f4e-a55e-f2db580885bc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "Found even number 2\n"
     ]
    }
   ],
   "source": [
    "numbers = [2, 3, 5]\n",
    "position = 0\n",
    "while position < len(numbers):\n",
    "  print(position)\n",
    "  number = numbers[position]\n",
    "  if number % 2 == 0:\n",
    "    print('Found even number', number)\n",
    "    break\n",
    "  position += 1\n",
    "else:\n",
    "  print('No even number found')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Kw49bjVz_GIM",
    "outputId": "e57227ac-53d3-4a4f-9f8b-84396169227e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found even number 2\n"
     ]
    }
   ],
   "source": [
    "numbers = [2, 3, 5]\n",
    "for number in numbers:\n",
    "  if number % 2 == 0:\n",
    "    print('Found even number', number)\n",
    "    break\n",
    "else:\n",
    "  print('No even number found')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "v23yWHR_7yO3"
   },
   "source": [
    "Выведем на экран список всех слов длиннее n букв из текста"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZfRx-Pag7wjm"
   },
   "outputs": [],
   "source": [
    "text = 'Python — высокоуровневый язык программирования, ориентированный на повышение производительности разработчика и читаемости кода.'\n",
    "n = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "0SwJmvOG8FVs",
    "outputId": "312c2629-017f-4304-b53b-beca76100b70"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n",
      "Python\n",
      "—\n",
      "—\n",
      "высокоуровневый\n",
      "высокоуровневый\n",
      "язык\n",
      "язык\n",
      "программирования,\n",
      "программирования\n",
      "ориентированный\n",
      "ориентированный\n",
      "на\n",
      "на\n",
      "повышение\n",
      "повышение\n",
      "производительности\n",
      "производительности\n",
      "разработчика\n",
      "разработчика\n",
      "и\n",
      "и\n",
      "читаемости\n",
      "читаемости\n",
      "кода.\n",
      "кода\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['Python',\n",
       " 'высокоуровневый',\n",
       " 'программирования',\n",
       " 'ориентированный',\n",
       " 'повышение',\n",
       " 'производительности',\n",
       " 'разработчика',\n",
       " 'читаемости']"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = []\n",
    "\n",
    "for word in text.split():\n",
    "    # print(word)\n",
    "    word = word.strip(',.!?')\n",
    "    # print(word)\n",
    "    if len(word) > n:\n",
    "        res.append(word)\n",
    "\n",
    "res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1dYKDsmV_U4o"
   },
   "source": [
    "## Сумма элементов по главной диагонали в матрице"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "XcpgxMI19KLl"
   },
   "outputs": [],
   "source": [
    "data = [\n",
    "    [13, 25, 23, 34],\n",
    "    [45, 32, 44, 47],\n",
    "    [12, 33, 23, 95],\n",
    "    [13, 53, 34, 35]\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "tSlpdpFf9S7x",
    "outputId": "684b7fef-525a-4860-d99e-698cbd733bdb"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "103"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = 0\n",
    "index = 0\n",
    "for row in data:\n",
    "    result += row[index]\n",
    "    index += 1\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Ac9wLlZsA_2e",
    "outputId": "5f5da0fa-b2ea-4537-8894-b33e7ef5f2f6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "124"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = 0\n",
    "index = -1\n",
    "for row in data:\n",
    "    result += row[index]\n",
    "    index -= 1\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZhsS0uFL_J9l"
   },
   "source": [
    "## Выведем фамилии построчно с указанием профессии в виде:\n",
    "```\n",
    "IT:  \n",
    "Гейтс  \n",
    "Джобс  \n",
    "Возняк  \n",
    "\n",
    "Физика:  \n",
    "Эйнштейн  \n",
    "Фейнман  \n",
    "\n",
    "Математика:  \n",
    "Эвклид  \n",
    "Ньютон\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "z4y6_PVy_S0v"
   },
   "outputs": [],
   "source": [
    "professions = ['IT', 'Физика', 'Математика']\n",
    "persons = [['Гейтс', 'Джобс', 'Возняк'], ['Эйнштейн', 'Фейнман'], ['Эвклид', 'Ньютон']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "4dXBJV0D_Pr3",
    "outputId": "fbe1bc17-1140-4acd-f3d6-49693ea096ee"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IT:\n",
      "Гейтс\n",
      "Джобс\n",
      "Возняк\n",
      "\n",
      "Физика:\n",
      "Эйнштейн\n",
      "Фейнман\n",
      "\n",
      "Математика:\n",
      "Эвклид\n",
      "Ньютон\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for pro, names in zip(professions, persons):\n",
    "    print(f'{pro}:')\n",
    "    for name in names:\n",
    "        print(name)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "nxT-J2s4CO1b",
    "outputId": "8a317555-630d-4878-ec96-7a6ce813ca87"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IT:\n",
      "Гейтс\n",
      "Джобс\n",
      "Возняк\n",
      "\n",
      "Физика:\n",
      "Эйнштейн\n",
      "Фейнман\n",
      "\n",
      "Математика:\n",
      "Эвклид\n",
      "Ньютон\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for pro, names in zip(professions, persons):\n",
    "    print(f'{pro}:')\n",
    "    print('\\n'.join(names))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "id": "D5G9r-oZCcv9",
    "outputId": "5ea7a699-5d98-479d-fa9f-38c9882419a7"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      },
      "text/plain": [
       "'sdgsd?sdgsdg?sdgsdgg4w3'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'?'.join(['sdgsd', 'sdgsdg', 'sdgsdgg4w3'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nJCfRLdINDG-"
   },
   "source": [
    "Необходимо у пользователя запрашивать набор чисел разделенных пробелом. В результате в отсортированном порядке должны выводиться числа, которые повторяются в вводе более одного раза."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "-X1rbA4qNCrP",
    "outputId": "5bd9ac31-f764-4bf7-ab09-e1dac14fc513"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Введите числа через пробел11 222 333 3 3 3 4 45 5 5\n",
      "['11', '222', '333', '3', '3', '3', '4', '45', '5', '5']\n",
      "[3, 5]\n"
     ]
    }
   ],
   "source": [
    "numbers = input('Введите числа через пробел').split()\n",
    "print(numbers)\n",
    "res = []\n",
    "\n",
    "for number in numbers:\n",
    "    if numbers.count(number) > 1 and int(number) not in res:\n",
    "        res.append(int(number))\n",
    "\n",
    "res.sort()\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "dsdjawt8D5VU",
    "outputId": "9acb4389-817a-48ed-cb85-e8b7a2e70702"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', '1', '1', '2', '2', '3', '444', '55', '1111', '111', '11', '4', '56']\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print(numbers)\n",
    "\n",
    "print(numbers.count('2'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HskSJH7qwPDv"
   },
   "source": [
    "# Регулярные выражения\n",
    "Регулярные выражения (Regular Expressions, regex) – это строки, содержащие совокупность обычных символов и специальных метасимволов, которые описывают определенный шаблон.\n",
    "\n",
    "Эти шаблоны, к примеру, можно использовать для того, чтобы:  \n",
    "- находить и заменять что-то в текстовых данных;  \n",
    "- валидировать строковые поля.  \n",
    "\n",
    "Шаблоны могут быть настолько сложными, что другими способами определить их будет крайне трудно.\n",
    "\n",
    "Одна из особенностей регулярных выражений в их универсальности, стоит вам выучить синтаксис, и вы сможете применять их в любом (почти) языке программирования (JavaScript, Java, VB, C #, C / C++, Python, Perl, Ruby, Delphi, R, Tcl, и многих других). Небольшие отличия касаются только наиболее продвинутых функций и версий синтаксиса, поддерживаемых движком."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bmNLm5bMwPDw"
   },
   "source": [
    ">Если у вас есть проблема, и вы собираетесь ее решать с помощью регулярных выражений, тогда у вас будет уже две проблемы.\n",
    "\n",
    "<cite>Шутка из интернетов (не шутка)</cite>. [Вот так](https://www.ex-parrot.com/~pdw/Mail-RFC822-Address.html) может выглядеть страшная регулярка.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JOfSwksmwPDw"
   },
   "source": [
    "Основы синтаксиса регулярных выражений"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hVqMlffSwPDx"
   },
   "source": [
    "<table>\n",
    "<tbody>\n",
    "<tr>\n",
    "<td width=\"20%\"><b>Последовательность</b></td>\n",
    "<td width=\"60%\"><b>Описание</b></td>\n",
    "<td width=\"20%\"><b>Аналог с []</b></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>\\d</td>\n",
    "<td>Любая цифра</td>\n",
    "<td>[0-9]</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>\\D</td>\n",
    "<td>Всё что угодно, кроме цифры</td>\n",
    "<td>[^0-9]</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>\\s</td>\n",
    "<td>Любой пробельный символ</td>\n",
    "<td>[ \\t\\n\\r\\f\\v]</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>\\S</td>\n",
    "<td>Любой непробельный символ</td>\n",
    "<td>[^ \\t\\n\\r\\f\\v]</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>\\w</td>\n",
    "<td>Любая буква, цифра, знак подчёркивания</td>\n",
    "<td>[a-zA-Z0-9_]</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>\\W</td>\n",
    "<td>Всё что угодно, кроме букв, цифр и знака подчёркивания</td>\n",
    "<td>[^a-zA-Z0-9_]</td>\n",
    "</tr>\n",
    "</tbody>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "m-f9dwO1wPDx"
   },
   "source": [
    "<table>\n",
    "<tbody>\n",
    "<tr>\n",
    "<td width=\"10%\"><b>Символ</b></td>\n",
    "<td width=\"50%\"><b>Пояснение</b></td>\n",
    "<td width=\"20%\"><b>Пример выражения</b></td>\n",
    "<td width=\"20%\"><b>Пример строки</b></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>.</td>\n",
    "<td>Любой символ</td>\n",
    "<td>...</td>\n",
    "<td>A!#</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>*</td>\n",
    "<td>Ноль и более&nbsp;совпадений с выражением, заданным в качестве образца&nbsp;</td>\n",
    "<td>(123)*</td>\n",
    "<td>123123123</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>+</td>\n",
    "<td>Одно и более&nbsp;совпадений с выражением, заданным в качестве образца&nbsp;</td>\n",
    "<td>(Ура!)+</td>\n",
    "<td>Ура!Ура!</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>?</td>\n",
    "<td>Ноль или одно&nbsp;совпадение с выражением, заданным в качестве образца&nbsp;</td>\n",
    "<td>(один)?</td>\n",
    "<td>один</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>[ ]</td>\n",
    "<td>Совпадение с любым из символов, заключённым в скобки</td>\n",
    "<td>[a-z]</td>\n",
    "<td>b</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>[^ ]</td>\n",
    "<td>Совпадение с любым из символов, отсутствующим в скобках</td>\n",
    "<td>[^a-z]</td>\n",
    "<td>5</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>\\</td>\n",
    "<td>Экранирует специальные символы (т.е. позволяет использовать символы типа '.', '*', '?' в роли обычных элементов строки)</td>\n",
    "<td>\\*</td>\n",
    "<td>*</td>\n",
    "</tr>\n",
    "</tbody>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LrYMvaQkwPDy"
   },
   "source": [
    "Квантификаторы  \n",
    "Квантификатор после символа или группы определяет, сколько раз предшествующее выражение может встречаться.\n",
    "\n",
    "    {n,m}        общее выражение, повторений может быть от n до m включительно.\n",
    "    {n,}        общее выражение, n и более повторений.\n",
    "    {,m}        общее выражение, не более m повторений.\n",
    "    {n}        общее выражение, ровно n повторений"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "Ld5A8OoLwPDy"
   },
   "outputs": [],
   "source": [
    "# импортируем модуль для работы с регулярками в python\n",
    "import re"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MsJruxlEwPDy"
   },
   "source": [
    "**raw string** – подавляет значение escape-последовательностей, обозначается префиксом r перед обычной строкой. \n",
    "Настоятельно рекомендуется использовать всегда при работе с регулярными выражениями для избежания проблем."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YExnzPsuJ8dL"
   },
   "source": [
    "Функция `re.findall(pattern, string)` – ищет во всем тексте, возвращает список всех найденных совпадений"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cgmYzR4WwPDz"
   },
   "source": [
    "Найдем хэштеги в твите"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "zem_a2I4wPDz"
   },
   "outputs": [],
   "source": [
    "# найдем хештеги в тексте\n",
    "tweet = 'когда #эпидемия, то обязательно #оставайсядома'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "iseEgiJSwPDz",
    "outputId": "b304204c-a48e-4508-fa68-421d55c7f656"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['#эпидемия', '#оставайсядома']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.findall(r'#\\w+', tweet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yufSrTvkHwdo"
   },
   "source": [
    "Вытащим номера телефонов и текста"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "CJPTRo9EwPDz",
    "outputId": "5f0e361e-39e3-4a9e-802a-6b5a99c9e519"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['8-943-342-23-32', '8-323-432-23-67']"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "phone_numbers = 'Мария: 8-943-342-23-32 Александр: 8-323-432-23-67'\n",
    "\n",
    "phone_pattern = r'\\d-\\d{3}-\\d{3}-\\d{2}-\\d{2}'\n",
    "re.findall(phone_pattern, phone_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "c8DfxgFNH1RX"
   },
   "source": [
    "[] - найдем слово во всем склонениях\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "MPp5loWIwPD0",
    "outputId": "2ef29489-75a8-414b-ae10-e337728d7e6c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['регулярные выражения', 'регулярное выражение', 'регулярных выражений']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = \"\"\"Что такое регулярные выражения и как их использовать? \n",
    "Говоря простым языком, регулярное выражение — это последовательность символов, используемая для поиска и замены текста в строке или файле. Как уже было упомянуто,\n",
    "их поддерживает множество языков общего назначения: Python, Perl, R.\n",
    "Так что изучение регулярных выражений рано или поздно пригодится.\"\"\"\n",
    "pattern = 'регулярн[а-я]+ выражен[а-я]+'\n",
    "re.findall(pattern, text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DQgnIgafK85c"
   },
   "source": [
    "Функция `re.sub(pattern, repl, string)` – ищет шаблон в строке и заменяет его на указанную подстроку."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0EgIDMFQwPD1"
   },
   "source": [
    "Простой способ удалить все служебные символы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "I8PfgKZVwPD1",
    "outputId": "32a1eaac-6bfe-4bcc-fbd8-572b3833fb5f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Что такое регулярные выражения и как их использовать \n",
      "Говоря простым языком регулярное выражение  это последовательность символов используемая для поиска и замены текста в строке или файле Как уже было упомянуто\n",
      "их поддерживает множество языков общего назначения Python Perl R\n",
      "Так что изучение регулярных выражений рано или поздно пригодится\n"
     ]
    }
   ],
   "source": [
    "text = \"\"\"Что такое регулярные выражения и как их использовать? \n",
    "Говоря простым языком, регулярное выражение — это последовательность символов, используемая для поиска и замены текста в строке или файле. Как уже было упомянуто,\n",
    "их поддерживает множество языков общего назначения: Python, Perl, R.\n",
    "Так что изучение регулярных выражений рано или поздно пригодится.\"\"\"\n",
    "\n",
    "print(re.sub(r'[^\\w\\s]', '', text))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fq2RAOdcwPD0"
   },
   "source": [
    "Произведем замену \"Регулярные выражения\" во всех формах на \"regex\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "HCekNfNGwPD0"
   },
   "outputs": [],
   "source": [
    "text = \"\"\"Что такое регулярные выражения и как их использовать? \n",
    "Говоря простым языком, регулярное выражение — это последовательность символов, используемая для поиска и замены текста в строке или файле. Как уже было упомянуто,\n",
    "их поддерживает множество языков общего назначения: Python, Perl, R.\n",
    "Так что изучение регулярных выражений рано или поздно пригодится.\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "tORUuPGHIA3u",
    "outputId": "49631134-8c64-48ec-f223-641926de3c53"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Что такое regex и как их использовать? \n",
      "Говоря простым языком, regex — это последовательность символов, используемая для поиска и замены текста в строке или файле. Как уже было упомянуто,\n",
      "их поддерживает множество языков общего назначения: Python, Perl, R.\n",
      "Так что изучение regex рано или поздно пригодится.\n"
     ]
    }
   ],
   "source": [
    "print(re.sub(r'регулярн[а-я]+ выражен[а-я]+', 'regex', text))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gmOZp2v2Lk4f"
   },
   "source": [
    "Функция `re.split(pattern, string)` – разделяет строку по заданному шаблону\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "TiaeuW0HLlMp",
    "outputId": "33bd8c9d-833a-43fb-c31f-a50bb650ef02"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Столбец1', 'Столбец2', 'Столбец3', 'Столбец4', 'Столбец5']"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "columns = 'Столбец1,Столбец2;Столбец3, Столбец4; Столбец5'\n",
    "re.split(r'[,;]\\s?', columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wdncyUbvwPD1"
   },
   "source": [
    "Часть шаблона можно заключить в скобки (...). Это называется «скобочная группа».\n",
    "Это позволяет:  \n",
    "- поместить часть шаблона в отдельную структуру (группу);\n",
    "- если установить квантификатор после скобок, то он будет применяться ко всему содержимому скобки, а не к одному символу.\n",
    "\n",
    "При наличии подгрупп в шаблоне можно ссылаться на них через их порядковый номер при помощи \\1, \\2, \\3, …  \n",
    "\n",
    "Группам можно давать собственные имена при помощи (?P<имя>...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_5UjJOdNwPD1"
   },
   "source": [
    "Выделим группы символов из посадочного талона, где:\n",
    "- первые 2 символа - это авиакомпания;\n",
    "- 4 следующие символа - номер рейса;\n",
    "- 3 следующих символа - аэропорт отправления;\n",
    "- 3 следюущих - аэропорт прибытия;\n",
    "- оставшиеся - дата рейса.\n",
    "\n",
    "Предполагаем, что все буквы всегда в верхнем регистре"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tXhYp4PywPD2"
   },
   "outputs": [],
   "source": [
    "flight = \"\"\"\n",
    "Boarding pass: LA4214 AER-CDB 06NOV\n",
    "Boarding pass: LA4215 AER-CDB 07NOV\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Nh5fzDHF0qvT"
   },
   "source": [
    "Функция `re.search(pattern, string)` – ищет шаблон по всей строке, но только первое вхождение. Возвращает match-объект"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "EOXGsViMwPD2",
    "outputId": "a759da01-139a-4660-abb2-590adf4f186f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LA4214 AER-CDB 06NOV\n"
     ]
    }
   ],
   "source": [
    "regex_flight = r'([A-Z]{2})(\\d{4})\\s([A-Z]{3})-([A-Z]{3})\\s(\\d{2}[A-Z]{3})'\n",
    "\n",
    "flight_match_result = re.search(regex_flight, flight)\n",
    "# print(flight_match_result)\n",
    "print(flight_match_result.group(1))\n",
    "# print(flight_match_result.start())\n",
    "# print(flight_match_result.end())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "siGiRo7R30m4"
   },
   "source": [
    "А как отработает findall?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "3ty5aQva32uy",
    "outputId": "e582236b-12b9-4887-ad21-2c5763dab34b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('LA', '4214', 'AER', 'CDB', '06NOV'), ('LA', '4215', 'AER', 'CDB', '07NOV')]\n"
     ]
    }
   ],
   "source": [
    "regex_flight = r'([A-Z]{2})(\\d{4})\\s([A-Z]{3})-([A-Z]{3})\\s(\\d{2}[A-Z]{3})'\n",
    "\n",
    "flight_match_result = re.findall(regex_flight, flight)\n",
    "print(flight_match_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "H3_UNBKLewqf"
   },
   "source": [
    "Посчитаем количество лайков/репостов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RBGewGNf_hzY"
   },
   "outputs": [],
   "source": [
    "messages = ['Опять дождь! Лайков: 2', 'Крутой был концерт 21 августа! Лайков: 28, Репостов: 22']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "gQfec0rL_hzY",
    "outputId": "421afe6b-d0eb-40db-df62-1bf11bd0b07a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(13, 22), match='Лайков: 2'>\n",
      "None\n",
      "<re.Match object; span=(31, 41), match='Лайков: 28'>\n",
      "<re.Match object; span=(43, 55), match='Репостов: 22'>\n",
      "30\n",
      "22\n"
     ]
    }
   ],
   "source": [
    "likes = 0\n",
    "reposts = 0\n",
    "for msg in messages:\n",
    "    likes_pattern = re.search(r'Лайков:\\s(\\d+)', msg)\n",
    "    print(likes_pattern)\n",
    "    repost_pattern = re.search(r'Репостов:\\s(\\d+)', msg)\n",
    "    print(repost_pattern)\n",
    "\n",
    "    if likes_pattern: likes += int(likes_pattern.group(1))\n",
    "    if repost_pattern: reposts += int(repost_pattern.group(1))\n",
    "\n",
    "print(likes)\n",
    "print(reposts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NyU0lIob3JDE"
   },
   "source": [
    "Функция `re.match(pattern, string)` – ищет по заданному шаблону в начале строки. Возвращает match-объект"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3j5nDFB13bQ4"
   },
   "source": [
    "Как нам найти все изображения в потенциально огромном списке файлов буквально в пару строк кода? За изображения будем считать файлы с расширениями jpg, png и gif.\n",
    "\n",
    "Для каждого подходящего файла будем выводить фразу \n",
    "`Изображение найдено: название файла`, \n",
    "а если файл не подходит, то `\"Название файла\" не является изображением`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sDnzyZU_3h6h"
   },
   "outputs": [],
   "source": [
    "file_name_list = ['my.profile', 'conspect.doc', 'my_photo.jpg', 'error-jpg', 'img0912.png', 'index.html', 'favicon.gif', 'img_copy.jpg.tmp']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "mTIzYuG_3jOH",
    "outputId": "276d5478-a027-4ba5-c76f-eec63174ace6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my.profile не является изображением\n",
      "conspect.doc не является изображением\n",
      "Изображение найдено: my_photo.jpg\n",
      "error-jpg не является изображением\n",
      "Изображение найдено: img0912.png\n",
      "index.html не является изображением\n",
      "Изображение найдено: favicon.gif\n",
      "img_copy.jpg.tmp не является изображением\n"
     ]
    }
   ],
   "source": [
    "for file_ in file_name_list:\n",
    "    pattern = r'\\w+\\.(jpg|png|gif)$'\n",
    "    if re.match(pattern, file_):\n",
    "        print(f'Изображение найдено: {file_}')\n",
    "    else:\n",
    "        print(f'{file_} не является изображением')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0G3QrUxLwPD2"
   },
   "source": [
    "Переведем даты к другому формату при помощи групп"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "id": "AoOarZ8rwPD2",
    "outputId": "a222541b-03ad-4976-e002-a96e65ed0e2f"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      },
      "text/plain": [
       "'some text 30.08.1991 some text'"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "date = 'some text 08/30/1991 some text '\n",
    "re.sub(r'(\\d\\d)/(\\d\\d)/(\\d{4})', r'\\2.\\1.\\3', date)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HsjnmSHn_ehw"
   },
   "source": [
    "Удалим все последовательные повторы слов из текста"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kA1FpojA_h5k"
   },
   "outputs": [],
   "source": [
    "some_string = 'Напишите код, который будет будет будет будет удалять все все все все последовательные повторы слов из из из из заданной строки строки при помощи регулярных выражений.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "id": "l5m2unv5AKoE",
    "outputId": "342fa4b3-cc1a-412a-fd3f-5442bf2c2d23"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      },
      "text/plain": [
       "'Напишите код, который будет удалять все последовательные повторы слов из заданной строки при помощи регулярных выражений.'"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.sub(r'(\\w+)(\\s\\1)+', r'\\1', some_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pPe1N0HawPD3"
   },
   "source": [
    "[Документация по регулярным выражениям](https://docs.python.org/3/library/re.html)  \n",
    "[Тестер регулярных выражений](https://regex101.com/)  \n",
    "https://ihateregex.io  \n",
    "https://regexcrossword.com/howtoplay"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4bInRY3OHWNB"
   },
   "source": [
    "Регулярные\n",
    "выражения\n",
    "Сборник рецептов\n",
    "2015\n",
    "Ян Гойвертс,\n",
    "Стивен\n",
    "Левитан"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}