sem04_lists_while/sem_03_memory.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "occasional-flour",
   "metadata": {},
   "source": [
    "## Семинар №3: Как python работает с памятью. Изменяемые и неизменяемые объекты. Списки, строки и кортежи."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "billion-cement",
   "metadata": {},
   "source": [
    "<img src=\"images/oooh.jpg\" width=\"500\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "blond-pharmaceutical",
   "metadata": {},
   "source": [
    "### История №1: об объектах в python\n",
    "\n",
    "Мы с вами уже познакомились с простейшими объектами в python. Вспомним их: \n",
    "\n",
    "* `int` - целое число (примеры: 5, 0, -1) \n",
    "* `float` - вещественное число (примеры: 2.3, 4.0)\n",
    "* `str` - строка (примеры: 'HSE', 'Hello world!')\n",
    "* `bool` - булевский оператор (примеры: True, False)\n",
    "* `None` - отсутствие значения\n",
    "\n",
    "Очень важно всегда понимать, с каким именно объектом в питоне вы работаете, так как, во-первых, _каждый объект имеет свой уникальный набор возможностей_ (методов и функций), а во-вторых, на первый взгляд _один и тот же метод может работать по-разному в зависимости от типа объекта_, например сложение `+`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "heard-enemy",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# сложение с int / float\n",
    "1 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "equivalent-infrastructure",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'12 Друзей Оушена'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# сложение с str\n",
    "'1' + '2' + ' Друзей Оушена'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "identical-serial",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# сложение с bool\n",
    "# True: 1, False: 0\n",
    "True + False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "yellow-postage",
   "metadata": {},
   "source": [
    "Помимо перечисленных в питоне есть более сложные объекты. Например, **списки** (они же массивы). Списки позволяют нам хранить несколько _каких угодно_ объектов в одном месте. В питоне список реализуется с помощью квадратных скобок `[ ]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "vanilla-morning",
   "metadata": {},
   "outputs": [],
   "source": [
    "# создали список и накидали туда кучу всего:\n",
    "l = [1, 12, -1, 2.0, 'hello', True, [10, 4], 1000]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cordless-cruise",
   "metadata": {},
   "source": [
    "Каждый элемент из списке имеет свой уникальный **индекс** - число от 0 до длины списка. Благодаря индексам мы можем получать отдельные элементы и наборы элементов из списка. Такая процедура называется **индексированием** (либо по-простому срезами). Главное запомнить, что **отсчет элементов начинается с нуля**!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "gorgeous-opera",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# достали 1ый элемент (он же нулевой)\n",
    "l[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "affiliated-alcohol",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# достали последний элемент\n",
    "l[len(l)-1]\n",
    "\n",
    "# можно по проще\n",
    "l[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "vocational-bailey",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1, 2.0, 'hello']"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# достали с 2го по 5 (верхняя граница не входит)\n",
    "l[2:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "arabic-translator",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, -1, 'hello', [10, 4]]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# достали элементы на четных местах \n",
    "l[::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "abstract-minutes",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1000, [10, 4], True, 'hello', 2.0, -1, 12, 1]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# развернули список\n",
    "l[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "touched-pregnancy",
   "metadata": {},
   "source": [
    "Также у списков, как у объектов, есть куча **методов**, помогающие с ними работать. Одним из самых популярных таких методов, является `.append()`, позволяющий добавлять элемент в конец списка. \n",
    "\n",
    "Метод `.append()` при вызове **изменяет** сам список, то есть запись типа:\n",
    "```python\n",
    "l = l.append(10)\n",
    "```\n",
    "не имеет смысла!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "altered-onion",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 12, -1, 2.0, 'hello', True, [10, 4], 1000]\n",
      "[1, 12, -1, 2.0, 'hello', True, [10, 4], 1000, 10]\n"
     ]
    }
   ],
   "source": [
    "print(l) # смотрим на список до изменения\n",
    "l.append(10) # добавили элемент и заодно изменили список\n",
    "print(l) # смотрим на список после изменения"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "painted-winner",
   "metadata": {},
   "source": [
    "Есть много других полезных методов, перечисленных ниже:\n",
    "\n",
    "* `.append(x)` - добавляет элемент $x$ в конец списка\n",
    "* `.prepend(x)` - добавляет элемент $x$ в начало списка\n",
    "* `.extend(L)` - расширяет список, добавляя в конец все элементы списка L\n",
    "* `.remove(x)` - удаляет первый элемент в списке, имеющий значение x\n",
    "* `.pop(i)` - удаляет i-ый элемент и возвращает его \n",
    "* `del lst[i]` - удаляет i-ый элемент из списка\n",
    "* `.sort()` - сортирует список\n",
    "* `.reverse()` - разворачивает список"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "liberal-psychology",
   "metadata": {},
   "source": [
    "Также **полезные методы есть и для строк**: \n",
    "\n",
    "* `.find(str)` - поиск подстроки str в строке. Возвращает номер **первого** вхождения\n",
    "* `.rfind(str)` - поиск подстроки str в строке. Возвращает номер **последнего** вхождения\n",
    "* `.replace(шаблон, замена)` - замена шаблона\n",
    "* `.split(символ разделителя)` - разбиение строки по разделителю\n",
    "* `'разделитель'.join(список)` - сборка строки из списка с разделителем\n",
    "* `.strip()` - удаление пробельных символов в начале и в конце строки\n",
    "* `.isdigit()` - состоит ли строка из цифр\n",
    "* `.isalpha()` - состоит ли строка из букв\n",
    "* `.isalnum()` - состоит ли строка из цифр или букв\n",
    "* `.islower()` - состоит ли строка из символов в нижнем регистре\n",
    "* `.isupper()` - состоит ли строка из символов в верхнем регистре\n",
    "* `.isspace()` - состоит ли строка из разных пробельных символов\n",
    "* `.istitle()` - начинаются ли слова в строке с заглавной буквы\n",
    "* `.upper()` - преобразование строки к верхнему регистру\n",
    "* `.lower()` - преобразование строки к нижнему регистру\n",
    "* `.title()` - преобразование первой буквы каждого слова в верхний регистр, а все остальные в нижний\n",
    "* `.capitalize()` - преобразование первого символа строки в верхний регистр, а все остальные в нижний\n",
    "* `.startswith(str)` - начинается ли строка с шаблона str\n",
    "* `.endswith(str)` - заканчивается ли строка шаблоном str \n",
    "* `.count(str)` - считает вхождение паттерна str в строку "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "boxed-stockholm",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Танцевальная битва? Что ж, чудесно', ' Раз у вас танцевальная битва, значит, сегодня я тебя затанцую до смерти!']\n",
      "\n",
      "Танцевальная битва? Что ж, чудесно. Раз у вас танцевальная битва, значит, сегодня я тебя затанцую до смерти!\n"
     ]
    }
   ],
   "source": [
    "s = \"Танцевальная битва? Что ж, чудесно. Раз у вас танцевальная битва, значит, сегодня я тебя затанцую до смерти!\"\n",
    "\n",
    "lst = s.split('.') # разбили на предложения по разделителю точки => получили список\n",
    "print(lst)\n",
    "print()\n",
    "\n",
    "s_new = '.'.join(lst) # собрали из списка обратно строку\n",
    "print(s_new)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "extreme-cleaners",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# считаем кол-во вхождений подстроки\n",
    "s = 'ding ding dong ding ding dong'\n",
    "\n",
    "s.count('ding')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lesbian-desperate",
   "metadata": {},
   "source": [
    "### История №2: о работе python с памятью; изменяемые и неизменяемые объекты"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "touched-olive",
   "metadata": {},
   "source": [
    "Как мы с вами до этого определелили: все в python является объектом. Объекты можно разделять по разным классификациям. Рассмотрим одну из них: так, все объекты делятся на **изменяемые** и **неизменяемые**. Давайте разберемся, что это значит.  \n",
    "\n",
    "\n",
    "Представим себе огромный комод с кучей ящиком в нем. Комод $-$ **память вашего компьютера**, а ящик $-$ **ячейка памяти**. \n",
    "\n",
    "<img src=\"images/comod.jpg\" width=\"400\">\n",
    "\n",
    "Когда вы инициализируете и сохраняете какой-либо объект в питоне (например, закидываете его в переменную), то один из ящиков вашего чудо-комода открывается, и в него кладется ваш объект:\n",
    "\n",
    "<img src=\"images/comod_open.jpg\" width=\"400\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ranking-configuration",
   "metadata": {},
   "source": [
    "Теперь давайте попробуем создать и сохранить объект числа $5$ в переменную $a$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "rotary-theorem",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "raising-middle",
   "metadata": {},
   "source": [
    "На этом этапе один из ваших ящиков в комоде открылся, и в него сохранилось число $5$. Также стоит отметить, что все ящики пронумерованны, а номер ящика можно узнать с помощью функции `id()`. Это называется **адресом в памяти**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "southwest-atlantic",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4486367664"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "legislative-vanilla",
   "metadata": {},
   "source": [
    "Либо в более каноничном виде:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "elect-engineering",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0x10b6889b0'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hex(id(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "operating-intranet",
   "metadata": {},
   "source": [
    "Отлично! Теперь попробуем _изменить_ нашу переменную $a$, добавив единицу, а затем посмотрим снова на адрес в памяти: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "widespread-poland",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "4486367696\n"
     ]
    }
   ],
   "source": [
    "a += 1\n",
    "print(a)\n",
    "print(id(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "enabling-apparel",
   "metadata": {},
   "source": [
    "Видим, что **адрес поменялся**! Это означает, что после того как мы добавили к  $5$  единицу, наш объект $a$ (то есть $5$) _не перезаписался_. Напротив, _создался новый объект_, для которого был выделен отдельный ящик.\n",
    "\n",
    "А что тогда произошло с тем объектом $5$, который лежал у нас в $a$ до этого? - про него все забыли! Для этого в python есть специальный автоматический **сборщик мусора**, который позволяет очищать память. Про него подробнее можно почитать [тут](https://zen.yandex.ru/media/id/5b7ae22633ef9b00a8cc79f3/kak-rabotaet-sborscik-musora-v-python-5e3e703747cdf92c08fe4ba3). "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dramatic-customs",
   "metadata": {},
   "source": [
    "Такс, а теперь наконец попробуем проделать ту же операцию со списком:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "ordinary-gathering",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "До: 4609394048\n",
      "После: 4609394048\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3, 4]\n",
    "\n",
    "print(f'До: {id(x)}')\n",
    "\n",
    "x.append(100)\n",
    "\n",
    "print(f'После: {id(x)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "japanese-robin",
   "metadata": {},
   "source": [
    "Ага, видим, что с массивами ситуация противоположная. Здесь **номер ящика наоборот не поменялся**. \n",
    "\n",
    "Если по-простому, то это значит, что мы не выделили отдельный ящик под новый список с элементом 100 в конце, мы **изменили** тот же самый список, что был до этого, и он продолжил лежать в том же ящике, где лежал до этого! \n",
    "\n",
    "Так вот, объекты в питоне, которые мы можем изменять таким образом, называются **изменяемыми** объектами, а те, что не можем (как с примером про число 5 выше) $-$ **неизменяемыми**\n",
    "\n",
    "**Еще один пример:**\n",
    "\n",
    "Проделаем следующую процедуру:\n",
    "* сохраним в переменной $a$ объект\n",
    "* затем в другую переменную $b$ сохраним переменную, иницализированную на предыд. шаге, $b = a$\n",
    "* изменим переменную $a$ и посмотрим, что произошло с переменной $b$\n",
    "\n",
    "Процедуру выше запустим для неизменяемого объекта (`int`) и для изменяемого (`list`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "neural-microphone",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "До изменения a\n",
      "a = 5 и id(a) = 4486367664\n",
      "b = 5 и id(b) = 4486367664\n",
      "\n",
      "После изменения a\n",
      "a = 6 и id(a) = 4486367696\n",
      "b = 5 и id(b) = 4486367664\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = a\n",
    "\n",
    "print('До изменения a')\n",
    "print(f'a = {a} и id(a) = {id(a)}')\n",
    "print(f'b = {b} и id(b) = {id(b)}')\n",
    "print()\n",
    "\n",
    "a += 1\n",
    "\n",
    "print('После изменения a')\n",
    "print(f'a = {a} и id(a) = {id(a)}')\n",
    "print(f'b = {b} и id(b) = {id(b)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "fluid-harvard",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "До изменения l\n",
      "l = [1, 2, 3] и id(l) = 4610136512\n",
      "l2 = [1, 2, 3] и id(l2) = 4610136512\n",
      "\n",
      "После изменения l\n",
      "l = [1, 2, 3, 100] и id(l) = 4610136512\n",
      "l2 = [1, 2, 3, 100] и id(l2) = 4610136512\n"
     ]
    }
   ],
   "source": [
    "l = [1, 2, 3]\n",
    "l2 = l\n",
    "\n",
    "print('До изменения l')\n",
    "print(f'l = {l} и id(l) = {id(l)}')\n",
    "print(f'l2 = {l2} и id(l2) = {id(l2)}')\n",
    "print()\n",
    "\n",
    "l.append(100)\n",
    "\n",
    "print('После изменения l')\n",
    "print(f'l = {l} и id(l) = {id(l)}')\n",
    "print(f'l2 = {l2} и id(l2) = {id(l2)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "backed-medicine",
   "metadata": {},
   "source": [
    "Видим, что в первом случае (когда в $a$ лежал `int`) переменная $b$ не изменилась, а в случае со списком, изменились обе переменные. Почему?\n",
    "\n",
    "Так произошло, так как в первом случае python на самом деле не изменяет объект $a$, а записывает в переменную новый объект $6$. Так как в переменной $b$ продолжает лежать предыдущий объект $5$, переменная $b$ не изменяется. Помним6 что `int` - неизменяемый объект!\n",
    "\n",
    "Во втором же случае `list` является изменяемым объектом, поэтому изменяя объект в одном месте (в переменной $a$) мы также изменяем его и в другом (в переменной $b$), так как мы в этом случае изменяем сам объект, а не перезаписываем переменные новыми объектами. \n",
    "\n",
    "------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "simplified-navigator",
   "metadata": {},
   "source": [
    "**Шпаргалка:**\n",
    "\n",
    "* Неизменяемые: `int`, `float`, `str`, `bool`, `tuple`, `frozen set`\n",
    "* Изменяемые: `list`, `set`, `dict`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "empirical-prince",
   "metadata": {},
   "source": [
    "Не все объекты, перечисленные выше, вы пока еще знаете. О таких объектах, как множества (`set`) и словари (`dict`), мы поговорим на следующем семинаре, а сейчас познакомимся с кортежами (`tuple`).\n",
    "\n",
    "**Кортеж** задается с помощью круглых скобок `( )` и представляет собой ничто иное, как просто список, который нельзя изменить:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "constant-bandwidth",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_first_tuple = (1, -100, 'Привет')\n",
    "\n",
    "type(my_first_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "unnecessary-procurement",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' 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-45-212491e7e591>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# изменить не можем!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmy_first_tuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# изменить не можем!\n",
    "my_first_tuple[0] = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "innovative-equilibrium",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1,)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# если хотим создать один объект в кортеже, то нужна запятая. Иначе преобразует в int\n",
    "tup = (1, )\n",
    "tup"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "wrong-spider",
   "metadata": {},
   "source": [
    "### Задача №1: Строка-палиндром\n",
    "\n",
    "Дана строка, нужно проверить является ли она палиндромом. Строка является палиндромом, если одинаково читается в обоих направлениях (слева направо и справа налево). Для простоты будем считать, что знаков препинания в строке нет.\n",
    "\n",
    "_Пример палиндрома:_ `'Murder for a jar of red rum'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "quick-community",
   "metadata": {},
   "outputs": [],
   "source": [
    "### Ваш код"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "concrete-marathon",
   "metadata": {},
   "source": [
    "### Задача №2: Середина предложения\n",
    "\n",
    "Дано предложение, нужно найти слово посередине. Для простоты будем считать, что знаков препинания в строке нет.\n",
    "\n",
    "_Пример:_ `'Luke I am your father'` $\\rightarrow$ `am`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "turkish-strength",
   "metadata": {},
   "outputs": [],
   "source": [
    "### Ваш код"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "indoor-weather",
   "metadata": {},
   "source": [
    "### Задача №3: Удаление гласных \n",
    "Дана строка, нужно удалить все гласные из этой строки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "specific-contribution",
   "metadata": {},
   "outputs": [],
   "source": [
    "### Ваш код"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.2"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}