sem04_lists_while/sem04_ecstat_group3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "35945c35",
   "metadata": {},
   "source": [
    "# Программирование на Python \n",
    "\n",
    "# Цикл `for`. Списки и кортежи. Списковые включения. Функция `map()`.\n",
    "\n",
    "\n",
    "*Автор: Паршина Анастасия, НИУ ВШЭ (tg: @aaparshina)*\n",
    "\n",
    "*Дополнила: Капустина Лика, НИУ ВШЭ (tg: @lika_kapustina)*\n",
    "\n",
    "## Содержание\n",
    "\n",
    "\n",
    "1. [Типы данных — часть 3. Списки и кортежи](#par1)\n",
    "2. [Методы строк (`.join()` и `.split()`)](#par2)\n",
    "2. [Цикл `for` и функция `range()`](#par3)\n",
    "3. [Списковые включения](#par4)\n",
    "4. [И напоследок про `map()`](#par5)\n",
    "5. [PS: методы списков](#par6)\n",
    "6. [Дополнительные материалы](#parlast)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fb2d768",
   "metadata": {},
   "source": [
    "## Типы данных — часть 3. Списки и кортежи <a name=\"par1\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5ef26b0",
   "metadata": {},
   "source": [
    "Ранее мы уже обсуждали списки и кортежи в разговоре о типах данных. Тогда основное отличие заключалось в том, что списки — это изменяемый тип данных, а кортежи — неизменяемый. Проверить, что кортежи нельзя изменить, очень просто: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "996cba04",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1, 2, 3)[0] # индексация работает "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "df9b2020",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_4740/3881503125.py\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0\u001b[0m \u001b[1;31m# а вот попытка изменить кортеж (заменить его элемент) выдает ошибку\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "(1, 2, 3)[0] = 0 # а вот попытка изменить кортеж (заменить его элемент) выдает ошибку"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "390be1d0",
   "metadata": {},
   "source": [
    "Синтаксис словаря (на английскойм – *tuple*) выглядит так, а для его создания вам нужно использовать круглые скобки:\n",
    "\n",
    "```my_tuple = (1, 2, 3, 4, 5)```\n",
    "\n",
    "Вы можете также создать кортеж с помощью функции `tuple()`:\n",
    "\n",
    "```tuple([1, 2, 3, 4, 5])  # создаем кортеж из списка```\n",
    "\n",
    "Оба типа данных представляют собой последовательности, однако кортеж — это неизменяемый и более быстрый аналог списка. Он защищает хранимые данные от непреднамеренных изменений и может использоваться в качестве ключа в словарях. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "59b09a51",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1, 2, 3, 4)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple(range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e825018c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.004867700000204422\n",
      "0.01293020000002798\n"
     ]
    }
   ],
   "source": [
    "import timeit # импортируем модуль timeit\n",
    "\n",
    "# измеряет, за сколько секунд запустится этот код number раз\n",
    "print(timeit.timeit('x = (1,2,3,4,5,6,7,8,9)', number=100000)) # когда создаем кортеж\n",
    "print(timeit.timeit('x = [1,2,3,4,5,6,7,8,9]', number=100000)) # когда создаем список"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1df2f336",
   "metadata": {},
   "source": [
    "Также, если функция возвращает несколько значений, то делает она это в виде кортежа. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "a08bbb3c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.33999999999999986, 2.0)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math     # импортируем модуль math\n",
    "math.modf(2.34) # к слову, как вы думаете, что делает эта функция?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "ed891c80",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function modf in module math:\n",
      "\n",
      "modf(x, /)\n",
      "    Return the fractional and integer parts of x.\n",
      "    \n",
      "    Both results carry the sign of x and are floats.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(math.modf)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77045889",
   "metadata": {},
   "source": [
    "Методы `.index()`, `.count()` и функция `len()` работают как с кортежами, так и со списками. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "85698505",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "A = (1, 2, 4) # создаем кортеж A\n",
    "\n",
    "print(len(A)) # длина кортежа A\n",
    "print(A.count(1)) # сколько раз число 1 встречается в кортеже A\n",
    "print(A.index(1)) # возвращает индекс целого числа 1 в кортеже A"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5923d468",
   "metadata": {},
   "source": [
    "## Методы строк (`.join()` и `.split()`) <a name=\"par2\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e651a63",
   "metadata": {},
   "source": [
    "Со списками работает больше методов, все их обсудим в следующий раз. Пока остановимся только на двух, которые на данный момент могут представлять интерес, они оба имеют оношение к спискам, однако являются методами строк. Речь идет про `.join()` и `split()`. \n",
    "\n",
    "Чтобы создать список, нужно использовать квадратные скобки и поместить внутрь какие-то значения:\n",
    "\n",
    "```products = [\"яблоки\", \"бананы\", \"апельсины\"]```\n",
    "\n",
    "```numbers = [1, 2, 3]```\n",
    "\n",
    "Вы можете также создать список из кортежа с помощью функции `list()`. Например:\n",
    "\n",
    "```numbers = list((1, 2, 3)) # результат - [1, 2, 3]```\n",
    "\n",
    "Можно создать список из строки. Например:\n",
    "\n",
    "```list('abcde') # ['a', 'b', 'c', 'd', 'e']```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "d6d1d279",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ace'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string = 'abcde'\n",
    "string[0:5:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b94ec599",
   "metadata": {},
   "source": [
    "Метод `.join()` из списка <b>строк</b> делает строку. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "feaf843a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'яблоки, бананы, апельсины, 2'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "products = [\"яблоки\", \"бананы\", \"апельсины\", '2'] # внутри списка products только строки\n",
    "', '.join(products) # объединяем эти строки в списке в одну большую строку"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b33b5d7",
   "metadata": {},
   "source": [
    "Фактически метод применяется к строке `', '` и говорит — используй эту строку в качестве разделителя между другими строками нашего списка."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "eb832184",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "sequence item 1: expected str instance, int found",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [7]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m, \u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mjoin\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mяблоки\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m111\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mапельсины\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: sequence item 1: expected str instance, int found"
     ]
    }
   ],
   "source": [
    "', '.join([\"яблоки\", 111, \"апельсины\"]) # ошибка TypeError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "02862edd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, man. Nice weather\n"
     ]
    }
   ],
   "source": [
    "user_string = input()\n",
    "list_of_user_text = user_string.split(' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "fa44daa4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello,', 'man.', 'Nice', 'weather']"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_of_user_text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b236a9d",
   "metadata": {},
   "source": [
    "Если же мы попытаемся объединить так список, состоящий не только из строк, то программа выдаст уже известную нам ошибку."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f81fe093",
   "metadata": {},
   "source": [
    "У этого метода есть еще пара нюансов, которые стоит запомнить. Помните про форматирование строки и f-строки? Попробуем подставить в такую запись `.join()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "60f61551",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "f-string: expecting '}' (Temp/ipykernel_4740/3840483201.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"C:\\Users\\Yuriy\\AppData\\Local\\Temp/ipykernel_4740/3840483201.py\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    print(f'В магазине надо купить: {', '.join(products)}') # внутри одинарные кавычки\u001b[0m\n\u001b[1;37m                                      ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m f-string: expecting '}'\n"
     ]
    }
   ],
   "source": [
    "print(f'В магазине надо купить: {', '.join(products)}') # внутри одинарные кавычки"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62f25b55",
   "metadata": {},
   "source": [
    "Это тот случай, где кавычки важны! Обратите внимание ошибка возникла потому, что f-строка подумала, что она заканчивается вот здесь `В магазине надо купить: {'` и при этом не нашла закрывающуюся скобочку `}`. Как решить проблему? Например, использовать в `.join()` двойные кавычки."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "cd0f6519",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "В магазине надо купить: яблоки, бананы, апельсины\n"
     ]
    }
   ],
   "source": [
    "print(f'В магазине надо купить: {\", \".join(products)}') # внутри двойные кавычки"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65dd8262",
   "metadata": {},
   "source": [
    "И второй нюанс в том, что визуально может быть похоже следующее: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "92c191ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "яблоки, бананы, апельсины\n",
      "яблоки, бананы, апельсины\n"
     ]
    }
   ],
   "source": [
    "print(\", \".join(products))   # печатаем строку\n",
    "print(*products, sep = ', ') # распаковываем список"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4269a86c",
   "metadata": {},
   "source": [
    "В первом случае у нас создается строка, во втором — мы просто распаковываем имеющийся список."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9936193",
   "metadata": {},
   "source": [
    "Метод `split()` работает в обратную сторону — он буквально разделит нашу строку, и по умолчанию сделает это по пробелам."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "679ca8b2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1258   1638        1729   982\n",
      "['1258', '1638', '1729', '982']\n"
     ]
    }
   ],
   "source": [
    "years = input()        # вводим какое-то значение\n",
    "years = years.split()  # разбиваем строку (по умолчанию - по пробелу)\n",
    "print(years)           # печатаем получившийся результат"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c412485a",
   "metadata": {},
   "source": [
    "Во-первых, обращаем внимание, что убираются все пробелы между символами. \n",
    "\n",
    "Во-вторых, это все можно было записать в одну строку вот так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e12e6191",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1258   1638        1729   982\n",
      "['1258', '1638', '1729', '982']\n"
     ]
    }
   ],
   "source": [
    "print(input().split()) # только тут у нас не создается переменная"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "93bfc69f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1258   1638        1729   982\n",
      "['1258   1638        1729   982']\n"
     ]
    }
   ],
   "source": [
    "print(input().split(', ')) # а еще можно использовать другое разделитель - например, запятую с пробелом"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34da6d5d",
   "metadata": {},
   "source": [
    "Если тоже самое «разделить» по запятой с пробелом, то получится список, состоящий из одной строки. Однако, если бы в ней были `, `, то наш метод также бы разделил по ним строку. \n",
    "\n",
    "Вернемся к нашему списку `years` и попробуем вытащить оттуда максимальное значение:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "ba5790fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1258', '1638', '1729', '982']\n"
     ]
    }
   ],
   "source": [
    "print(years)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "689acac2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1258'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(years)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "217c15c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'982'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(years)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "2928b96f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1258, 1638, 1729, 982]\n"
     ]
    }
   ],
   "source": [
    "for index in range(len(years)):\n",
    "    years[index] = int(years[index])\n",
    "print(years)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "fe8ed7c5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1729"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(years)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "e5268fdd",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'>' not supported between instances of 'str' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_4740/396229011.py\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;34m'10'\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: '>' not supported between instances of 'str' and 'int'"
     ]
    }
   ],
   "source": [
    "'10' > 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "df3c0ca7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'10' > '5'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "39cbe014",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 > 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "9703ec40",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1258, 1638, 1729, 982]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(int, years))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "15d1d4d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class map in module builtins:\n",
      "\n",
      "class map(object)\n",
      " |  map(func, *iterables) --> map object\n",
      " |  \n",
      " |  Make an iterator that computes the function using arguments from\n",
      " |  each of the iterables.  Stops when the shortest iterable is exhausted.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __next__(self, /)\n",
      " |      Implement next(self).\n",
      " |  \n",
      " |  __reduce__(...)\n",
      " |      Return state information for pickling.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(map)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5fbef4a",
   "metadata": {},
   "source": [
    "Ой, что-то пошло не так. Это связано с тем, что было вытащено максимальное/первое значение по алфавиту, ведь мы работаем со строками. Нужно попробовать переделать наш список в список целых чисел. Быстрее всего это сделать с помощью функции `map()`, однако сначала рассмотрим, как будет работать цикл `for`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a0da71e",
   "metadata": {},
   "source": [
    "<center><b><font size=4>Задача №1</font></b></center>\n",
    "\n",
    "**Напишите программу, которая будет спрашивать у пользователя фамилии друзей, с которыми он общался за последнюю неделю и выводит справочную информацию о ваших друзьях:**\n",
    "\n",
    "* Информация считывается с помощью функции `input()`;\n",
    "\n",
    "* Отсортировать значения вы можете с помощью функции `sorted()`;\n",
    "\n",
    "* Фамилии ваших друзей будут разделены запятой с пробелом;\n",
    "\n",
    "* Гарантируется, что будут введены только строки.\n",
    "\n",
    "**Ориентируйтесь на тесты ниже:**\n",
    "<center> \n",
    "    <table>\n",
    "        <tr>\n",
    "            <th><center>Ввод</center></th>\n",
    "            <th><center>Результат</center></th>\n",
    "        </tr> \n",
    "        <tr><td><p>Музыка, Морозов, Егерева</p></td>\n",
    "            <td><p>За последнюю неделю вы общались с 3 друзьями.</p>\n",
    "<p>Отсортированный список ваших друзей: ['Егерева', 'Морозов', 'Музыка']</p></td></tr>\n",
    "        <tr><td>Федоров, Смирнов, Иванов, Потапов, Кузнецов</td>\n",
    "            <td><p>За последнюю неделю вы общались с 5 друзьями.</p>\n",
    "                <p>Отсортированный список ваших друзей: ['Иванов', 'Кузнецов', 'Потапов', 'Смирнов', 'Федоров'</p></td></tr>\n",
    "        <tr><td>        \n",
    "            <p>Сато, Като, Ёсида, Исикава, Ито, Оота</p></td>\n",
    "            <td><p>За последнюю неделю вы общались с 6 друзьями.</p>\n",
    "<p>Отсортированный список ваших друзей: ['Ёсида', 'Исикава', 'Ито', 'Като', 'Оота', 'Сато']</p></td></tr>\n",
    "    </table>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "f888f2d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Федоров, Смирнов, Иванов, Потапов, Кузнецов\n",
      "За последнюю неделю вы общались с 5 друзьями.\n",
      "Отсортированный список ваших друзей: ['Иванов', 'Кузнецов', 'Потапов', 'Смирнов', 'Федоров']\n"
     ]
    }
   ],
   "source": [
    "#YOUR CODE HERE\n",
    "friends_list = input().split(', ')\n",
    "count_of_friends = len(friends_list)\n",
    "# friends_list = sorted(friends_list, reverse=True)\n",
    "friends_list.sort()\n",
    "print(f'За последнюю неделю вы общались с {count_of_friends} друзьями.\\nОтсортированный список ваших друзей: {friends_list}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b1eca36",
   "metadata": {},
   "source": [
    "## Цикл `for` и функция `range()` <a name=\"par3\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "821ae173",
   "metadata": {},
   "source": [
    "Цикл `for` буквально можно воспринимать следующим образом `для каждого элемента последовательности сделай что-то`. Под последовательностью здесь понимается <b>итерируемый объект</b> т.е. буквально тот, который вы можете растащить на части (например, строку можно раcтащить на символы, список — на элементы списка, кортеж — на элементы кортежа, словарь — на пары ключ-значение). \n",
    "\n",
    "Небольшое уточнение — разница между последовательностями и итерируемымыи объектами заключается в том, что в последовательностях элементы упорядочены.\n",
    "\n",
    "Попробуем перебрать все элементы нашего списка `years` и напечатать каждый."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "613ec62b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1258\n",
      "1638\n",
      "1729\n",
      "982\n"
     ]
    }
   ],
   "source": [
    "years = ['1258', '1658', '1729', '982'] # создаем список years\n",
    "\n",
    "for y in years: # для каждого элемента в years\n",
    "    print(y) # печатаем этот элемент"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e757270",
   "metadata": {},
   "source": [
    "Разберемся с тем, что только что произошло. \n",
    "\n",
    "Во-первых, у нас прошло четыре <b>итерации</b> цикла, то есть четыре повторения цикла (это слово я еще при обсуждении цикла `while` вам говорила. Воспринимается это так: \n",
    "\n",
    "<i>Итерация №1</i>\n",
    "\n",
    "    y = '1258'\n",
    "    print(y) # 1258\n",
    "    \n",
    "<i>Итерация №2</i>\n",
    "\n",
    "    y = '1638'\n",
    "    print(y) # 1638\n",
    "    \n",
    "<i>Итерация №3</i>\n",
    "\n",
    "    y = '1729'\n",
    "    print(y) # 1729\n",
    "    \n",
    "<i>Итерация №4</i>\n",
    "\n",
    "    y = '982'\n",
    "    print(y) # 982\n",
    "    \n",
    "Во-вторых, подумайте, что сейчас хранится в переменной `y`?    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "0d3430f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "982\n"
     ]
    }
   ],
   "source": [
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ef9a7cf",
   "metadata": {},
   "source": [
    "В нашей переменной сохранилось именно последнее значение, которое она приняла в цикле. Фактически нам это не особо важно: сама переменная важна лишь внутри самого цикла, она там создается, потом с ней что-то происходит (в нашем случае мы ее печатаем), и затем мы о ней забываем. \n",
    "\n",
    "Доказать, что это буквально новая переменная, а не элемент списка, можно следующим образом.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "0424a2c4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1258', '1638', '1729', '982']\n",
      "12581\n",
      "16381\n",
      "17291\n",
      "9821\n",
      "['1258', '1638', '1729', '982']\n"
     ]
    }
   ],
   "source": [
    "print(years) # печатаем список\n",
    "\n",
    "for y in years: # печатаем\n",
    "    y = y + '1'\n",
    "    print(y)\n",
    "    \n",
    "print(years)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bfd53f0",
   "metadata": {},
   "source": [
    "Обратите внимание, что элементы списка не изменились. В цикле менялась только переменная `y`, там же она печаталась, а потом принимала новое значение. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ad4ea71",
   "metadata": {},
   "source": [
    "В-третьих, как цикл понимает, что пора остановиться? Ведь мы не прописываем никакое условие и не прописываем `break`. Сейчас будет сложно. \n",
    "\n",
    "У итерируемых объектов есть итератор. Мы можем сказать, что **итератор — это объект, позволяющий реализовать поток данных и предлагающий возможность двигаться по нему.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "8aa7dae4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<list_iterator object at 0x7f7bd8069340>\n"
     ]
    }
   ],
   "source": [
    "years_iterator = iter(years)\n",
    "print(years_iterator)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09a5b4dc",
   "metadata": {},
   "source": [
    "Для реализации протокола итератора изпользуется встроенная функция `next()`. По сути, это инструмент для прохода по потоку данных, в нашем случае — по всем элементам списка. \n",
    "\n",
    "Когда мы дойдем до конца, она вызовет специальное исключение `StopIteration`, сигнализирующее о том, что итератор исчерпал все доступные ему значения."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "420b322d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1258\n",
      "1638\n",
      "1729\n",
      "982\n"
     ]
    },
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/lj/_28hw2ts0ys306v1sq_8mxzh0000gn/T/ipykernel_45177/3610752718.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0myears_iterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# третий элемент списка\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0myears_iterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# последний элемент списка\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0myears_iterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# упс, элемент списка кончились\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "print(next(years_iterator)) # первый элемент списка \n",
    "print(next(years_iterator)) # второй элемент списка\n",
    "print(next(years_iterator)) # третий элемент списка\n",
    "print(next(years_iterator)) # последний элемент списка\n",
    "print(next(years_iterator)) # упс, элемент списка кончились"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2cd890d",
   "metadata": {},
   "source": [
    "Собственно, цикл `for` умеет ловить это исключение и останавливаться. \n",
    "\n",
    "По сути, цикл `for` — красивая «обертка» вот этого: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "ad372237",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1258\n",
      "1638\n",
      "1729\n",
      "982\n"
     ]
    }
   ],
   "source": [
    "years_iterator = iter(years)\n",
    "running = True\n",
    "\n",
    "while running:\n",
    "    try:\n",
    "        year = next(years_iterator)\n",
    "        print(year)\n",
    "    except StopIteration:\n",
    "        running = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "553a935f",
   "metadata": {},
   "outputs": [],
   "source": [
    "for year in years:\n",
    "    print(year)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e37be425",
   "metadata": {},
   "source": [
    "**Теперь, когда мы, вроде как, поняли, что лежит внутри цикла `for`, подумаем, а как в итоге заменить элементы списка.**\n",
    "\n",
    "В этом нам поможет индексация. Как создать набор индексов? Тут есть два способа: \n",
    "\n",
    "1. функция `range()`\n",
    "2. функция `enumerate()`\n",
    "\n",
    "Первая универсальнее, так как буквально создает диапазон значений от и до (даже может сделать его с определенным шагом). При работе с ней нужно запомнить следующее: \n",
    "\n",
    "   `range(START, STOP, STEP)`\n",
    "   \n",
    "   + `START` — начало нашего диапазона\n",
    "   + `STOP` — конец нашего диапазона (не включается!)\n",
    "   + `STEP` — шаг, с которым мы идем "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "5850adb8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# например, сделаем диапазон целых чисел от 1 до 10 с шагом 2 \n",
    "# то есть возьем все нечетные числа от 1 до 10\n",
    "for i in range(1, 11, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "37615c4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# значения, которые можно подставить вместо «индексов» можно создать так: \n",
    "for i in range(len(years)):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cdc16c4",
   "metadata": {},
   "source": [
    "В примере выше важно следующее: \n",
    "+ по умолчанию в значение `START` подставляется `0`;\n",
    "+ как раз тут важно, что последнее значение (`4`) не включается — если бы включалось, то подставив его вместо индекса в список `years`, мы бы получили ошибку `IndexError`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "5086d23b",
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[0;32mIn [34]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43myears\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m]\u001b[49m)\n",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "print(years[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c69a0d9",
   "metadata": {},
   "source": [
    "Функция `enumerate()` вернет нам пару индекс-элемент, впредставленную в виде кортежа. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "7797de63",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1258, 1638, 1729, 982]"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "years"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "d0540be9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, '1258')\n",
      "Индексу 0 соответствует элемент 1258\n",
      "(1, '1638')\n",
      "Индексу 1 соответствует элемент 1638\n",
      "(2, '1729')\n",
      "Индексу 2 соответствует элемент 1729\n",
      "(3, '982')\n",
      "Индексу 3 соответствует элемент 982\n"
     ]
    }
   ],
   "source": [
    "for i in enumerate(years):\n",
    "    print(i)\n",
    "    print(f'Индексу {i[0]} соответствует элемент {i[1]}') # так можно разбить эту пару"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c892dbc",
   "metadata": {},
   "source": [
    "Вернемся к идее поменять строки на целые числа в нашем списке `years`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "6eab206b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1258', '1638', '1729', '982']\n",
      "[1258, 1638, 1729, 982]\n"
     ]
    }
   ],
   "source": [
    "print(years)\n",
    "\n",
    "for i in range(len(years)):\n",
    "    years[i] = int(years[i])\n",
    "\n",
    "print(years)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "642481e9",
   "metadata": {},
   "source": [
    "В цикле у нас создается переменная `i`, однако она используется для обращения к объектам списка, которые мы непосредственно изменяем. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19d82c49",
   "metadata": {},
   "source": [
    "<center><b><font size=4>Задача №2</font></b></center>\n",
    "\n",
    "**Используйте функцию `range()`, превратите последовательность в список с помощью функции `list()` и напечатайте:**\n",
    "\n",
    "* Список от 1 до 5 включительно: `[1, 2, 3, 4, 5]`;\n",
    "* Список от 8 до 12 невключительно: `[8, 9, 10, 11]`;\n",
    "* Список от 1 до 10 включительно только с нечетными числами: ```[1, 3, 5, 7, 9]```;\n",
    "* Список от 1 до 10 включительно только с четными числами: `[2, 4, 6, 8, 10]`;\n",
    "* Список от 100 до 130 включительно с шагом `3`: `[100, 103, 106, 109, 112, 115, 118, 121, 124, 127, 130]`.\n",
    "\n",
    "\n",
    "*Подсказки:*\n",
    "* Чтобы вывести четные и нечетные числа или последовательности с определенным шагом, пользуйтесь третьим аргументом функции `range()`;\n",
    "* Чтобы получить справку по функции, пользуйтесь функцией `help()` или запросите справку с помощью `Shift + Tab`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "3b233d0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# YOUR CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e61cf44",
   "metadata": {},
   "source": [
    "## Списковые включения (=list comprehension) <a name=\"par4\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2629df0a",
   "metadata": {},
   "source": [
    "Если мы не хотим изменять текущий список, а хотим сохранить значения в новый, то это можно сделать так: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "89c7f798",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1258   1638        1729   982\n",
      "['1258', '1638', '1729', '982']\n",
      "[1258, 1638, 1729, 982]\n"
     ]
    }
   ],
   "source": [
    "years = input().split()\n",
    "\n",
    "int_years = []\n",
    "\n",
    "for i in range(len(years)):\n",
    "    int_years.append(int(years[i]))\n",
    "    \n",
    "print(years)\n",
    "print(int_years)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "377ba14e",
   "metadata": {},
   "source": [
    "Да, уже выглядит сложнее. Здесь мы создаем пустой список, в который складываем наши новые объекты. Метод `.append()` мы уже встречали (он в конец списка добавляет новые значения). Более подробно о методах поговорим в следующий раз!\n",
    "\n",
    "Код безумно длинный (да-да!). Его можно записать в одну строчку, используя списковые включения."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "1407faef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1258, 1638, 1729, 982]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[int(years[i]) for i in range(len(years))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "c715eaea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1258, 1638, 1729, 982]\n"
     ]
    }
   ],
   "source": [
    "int_years_2 = [int(years[i]) for i in range(len(years))]\n",
    "print(int_years_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9147964",
   "metadata": {},
   "source": [
    "Мы буквально создаем пустой список, говорим, положи туда `int(years[i])`, а потом указываем, откуда это `i` берется.\n",
    "\n",
    "Списковые включения достаточно короткая конструкция. Максимум — можно добавить в него условие. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "53662aae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# вот так добавляется просто if\n",
    "even_numbers = [i for i in range(1, 11) if i%2 == 0]\n",
    "print(even_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "9472508d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1 - нечетное', 2, '3 - нечетное', 4, '5 - нечетное', 6, '7 - нечетное', 8, '9 - нечетное', 10]\n"
     ]
    }
   ],
   "source": [
    "# а вот так if-else \n",
    "even_numbers = [i if i%2 == 0 else f'{i} - нечетное' for i in range(1, 11)]\n",
    "print(even_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11c76914",
   "metadata": {},
   "source": [
    "Конструкцию с `elif` вы туда не запишете.\n",
    "\n",
    "Сделать списковое включение в списковом включении, конечно, можно... главное, не запутайтесь :) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "849c9eab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 16, 81, 256, 625, 1296, 2401, 4096, 6561]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i**2 for i in [i**2 for i in range(10)]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0b6c4e3",
   "metadata": {},
   "source": [
    "<center><b><font size=4>Задача №3</font></b></center>\n",
    "\n",
    "**Напишите функцию, которая принимает на вход список с фамилиями студентов, и возвращает информацию о разделении студентов на варианты для написания работы в классе**\n",
    "\n",
    "* На вход подается строка с фамилиями студентов, записанных через запятую с пробелом;\n",
    "* Вы считываете эту строку с помощью `input()`;\n",
    "* **Если фамилия студента первая, третья, пятая и др.** в считанной строке – студент будет писать первый вариант.\n",
    "* **Если фамилия студента вторая, четвертая, шестая и др.** в считанной строке – студент будет писать второй вариант.\n",
    "\n",
    "*Подсказки:*\n",
    "* Чтобы вызвать индекс элемента и сам элемент, используйте функцию `enumerate`;\n",
    "* *Альтернатива:* Чтобы пройтись по всем элементам списка, используйте запись `for i in range(len(my_list)` и обращайтесь к элементам по индексам (`my_list[i]`);\n",
    "* Чтобы склеить список в одну строку, используйте метод `.join()`.\n",
    "\n",
    "**Ориентируйтесь на тесты ниже:**\n",
    "<center> \n",
    "    <table>\n",
    "        <tr>\n",
    "            <th><center>Ввод</center></th>\n",
    "            <th><center>Результат</center></th>\n",
    "        </tr> \n",
    "        <tr><td><p>Музыка, Морозов, Егерева</p></td>\n",
    "            <td><p>Задания первого варианта выполняют: Музыка, Егерева</p>\n",
    "                <p>Задания второго варианта выполняют: Морозов</p></td></tr>\n",
    "        <tr><td>Федоров, Смирнов, Иванов, Потапов, Кузнецов</td>\n",
    "            <td><p>Задания первого варианта выполняют: Федоров, Иванов, Кузнецов</p>\n",
    "                <p>Задания второго варианта выполняют: Смирнов, Потапов</p></td></tr>\n",
    "        <tr><td>        \n",
    "            <p>Сато, Като, Ёсида, Исикава, Ито, Оота</p></td>\n",
    "            <td><p>Задания первого варианта выполняют: Сато, Ёсида, Ито</p>\n",
    "<p>Задания второго варианта выполняют: Като, Исикава, Оота</p></td></tr>\n",
    "    </table>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "f3cde539",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Федоров, Смирнов, Иванов, Потапов, Кузнецов\n",
      "Задания первого варианта выполняют: Федоров, Иванов, Кузнецов\n",
      "Задания второго варианта выполняют: Смирнов, Потапов\n"
     ]
    }
   ],
   "source": [
    "# YOUR CODE HERE\n",
    "list_of_people = input().split(', ')\n",
    "\n",
    "first_list = []\n",
    "second_list = []\n",
    "\n",
    "for ind, person in enumerate(list_of_people):\n",
    "    if ind % 2 == 0:\n",
    "        first_list.append(person)\n",
    "    else:\n",
    "        second_list.append(person)\n",
    "\n",
    "first_string = ', '.join(first_list)\n",
    "second_string = ', '.join(second_list)\n",
    "\n",
    "print(f'Задания первого варианта выполняют: {first_string}\\nЗадания второго варианта выполняют: {second_string}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "bb934c2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Федоров, Смирнов, Иванов, Потапов, Кузнецов\n",
      "Задания первого варианта выполняют: Федоров, Иванов, Кузнецов\n",
      "Задания второго варианта выполняют: Смирнов, Потапов\n"
     ]
    }
   ],
   "source": [
    "# YOUR CODE HERE\n",
    "list_of_people = input().split(', ')\n",
    "\n",
    "first_list = []\n",
    "second_list = []\n",
    "\n",
    "for ind, person in enumerate(list_of_people):\n",
    "    if ind % 2 == 0:\n",
    "        first_list.append(person)\n",
    "    else:\n",
    "        second_list.append(person)\n",
    "\n",
    "print(f'Задания первого варианта выполняют: {\", \".join(first_list)}\\nЗадания второго варианта выполняют: {\", \".join(second_list)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef81fdbe",
   "metadata": {},
   "source": [
    "# Отстановились здесь"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "644395e5",
   "metadata": {},
   "source": [
    "## И напоследок про `map()` <a name=\"par5\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7fb6677",
   "metadata": {},
   "source": [
    "Вспомним про наш список `years`. Преобразовать все в целые числа можно еще и так: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "e9643e6a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1258', '1638', '1729', '982']\n",
      "[1258, 1638, 1729, 982]\n"
     ]
    }
   ],
   "source": [
    "int_years_3 = list(map(int, years))\n",
    "print(years)\n",
    "print(int_years_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8f5ab06",
   "metadata": {},
   "source": [
    "Что тут произошло? Функция `map()` буквально говорит: возьми функцию `int()` и примени ее ко всем элементам нашего списка. Возвращает нам объект типа `map`, который потом мы уже преобразовываем в список с помощью функции `list()`.\n",
    "\n",
    "Функция `map()` может работать не только с встроенными функциями, но и с любыми другими, даже написанными именно нами."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "d7ba1e3b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1258, 1638, 1729, 982]\n",
      "[35.4682957019364, 40.47221268969612, 41.58124577258358, 31.336879231984796]\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt\n",
    "\n",
    "sqrt_years = list(map(sqrt, int_years_3))\n",
    "\n",
    "print(int_years_3)\n",
    "print(sqrt_years)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25c3b083",
   "metadata": {},
   "source": [
    "Например, возьмем квадратный корень из всех наших значений. \n",
    "\n",
    "В заключении скажем, что есть еще нечто, называемое безымянными функциями `lambda`, которые также работают с `map()`, но о них мы поговорим чуть позже, при обсуждении функций. Не переживаем, если все, что написано ниже, буде непонятно!! Мы разберемся со всем!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "e715c1e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1258, 1638, 1729, 982]\n",
      "[1259, 1639, 1730, 983]\n"
     ]
    }
   ],
   "source": [
    "plus_one_years = list(map(lambda x: x + 1, int_years_3))\n",
    "\n",
    "print(int_years_3)\n",
    "print(plus_one_years)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "539ce6fb",
   "metadata": {},
   "source": [
    "А и началось же все с того, что мы хотели максимальный год достать. Вот он: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "c9d7b483",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1729\n"
     ]
    }
   ],
   "source": [
    "print(max(int_years))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4dcdaaa",
   "metadata": {},
   "source": [
    "## PS: методы списков <a name=\"par6\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b9dc3b2",
   "metadata": {},
   "source": [
    "Сейчас перечислим те методы, которые были упомянуты в онлайн-курсе, и методы, которые есть еще. И коротко о том, как они работают. \n",
    "\n",
    "|Есть в онлайн-курсе | Все остальное |\n",
    "|:--------------:|:-----:|\n",
    "| `.append()` |  `.extend()` |\n",
    "| `.count()`      |  `.insert()` |\n",
    "| `.remove()`      |  `.pop()` |\n",
    "| `.index()`      |  `.sort()` |\n",
    "|     |  `.reverse()` |\n",
    "|     |  `.copy()` |\n",
    "|     |  `.clear()` |\n",
    "\n",
    "Почти все они <u>изменяют исходный список</u>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "93369786",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "# Метод .extend() добавляет в конец списка А все элементы списка B\n",
    "\n",
    "A = [1, 2, 3, 4]\n",
    "B = [5, 6, 7, 8]\n",
    "\n",
    "A.extend(B)\n",
    "\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "354212f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 'new', 3, 4]\n"
     ]
    }
   ],
   "source": [
    "# Метод .insert() добавляет в список А на место определенного индекса (2) новый элемент (строку 'new')\n",
    "\n",
    "A = [1, 2, 3, 4]\n",
    "\n",
    "A.insert(2, 'new')\n",
    "\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "d60548dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "[1, 2, 4]\n"
     ]
    }
   ],
   "source": [
    "# Метод .pop() удаляет i-ый (2) элемент из списка А и возвращает его. \n",
    "# Если индекс не указан, удаляется последний элемент\n",
    "\n",
    "A = [1, 2, 3, 4]\n",
    "\n",
    "get_element = A.pop(2)\n",
    "\n",
    "print(get_element)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "0ebef480",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[8, 7, 6, 5]\n"
     ]
    }
   ],
   "source": [
    "# Метод .sort() сортирует список А\n",
    "# Метод .reverse() разворачивает список В\n",
    "\n",
    "A = [1, 2, 3, 4]\n",
    "B = [5, 6, 7, 8]\n",
    "\n",
    "A.sort()\n",
    "B.reverse()\n",
    "\n",
    "print(A)\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "1a98d5e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "# Метод .copy() создает копию списка A\n",
    "# Метод .clear() очищает список А\n",
    "\n",
    "A = [1, 2, 3, 4]\n",
    "\n",
    "B = A.copy()\n",
    "A.clear()\n",
    "\n",
    "print(A) # будет пустым\n",
    "print(B) # а тут лежит копия"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "57593b08-fed0-469f-a1f6-173152d3cf0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "# Что будет, если не создавать копию?\n",
    "\n",
    "A = [1, 2, 3, 4]\n",
    "\n",
    "B = A\n",
    "A.clear()\n",
    "\n",
    "print(A)\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b811c0c-1dea-47c4-adbe-f6374d89b73f",
   "metadata": {},
   "source": [
    "__Но иногда для корректной работы просто copy недостаточно, тогда используем deepcopy__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4961ab8b-cba8-4e88-a555-e85874b0ba46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, [5, 6, 7, 8]]\n",
      "[1, 2, 3, 4, [5, 6, 7, 8]]\n"
     ]
    }
   ],
   "source": [
    "A = [1, 2, 3, 4, [5, 6, 7]]\n",
    "\n",
    "B = A.copy()\n",
    "A[-1].append(8)\n",
    "\n",
    "print(A) #[1, 2, 3, 4, [5, 6, 7, 8]]\n",
    "print(B) #[1, 2, 3, 4, [5, 6, 7]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c99481f0-b4a4-4af2-8e70-dc8f53241b74",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "<details> \n",
    "  <summary>Как думаете почему так происходит? </summary>\n",
    " Вспомним, что список это контейнер, который содержит в себе объекты. А точнее, ссылки на объекты. Потому когда мы делаем простую копию, мы создаем новый контейнер, но объекты (ссылки на них) остаются от оригинала. То есть если в списке содержался другой контейнер, к примеру опять же список, то при его изменение поменяется так и копия. Поскольку её элемент указывает на этот же вложенный список.t \n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3bab29c7-f59a-448d-a616-dac9e15f6e5e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, [5, 6, 7, 8]]\n",
      "[1, 2, 3, 4, [5, 6, 7]]\n"
     ]
    }
   ],
   "source": [
    "from copy import deepcopy\n",
    "\n",
    "A = [1, 2, 3, 4, [5, 6, 7]]\n",
    "\n",
    "B = deepcopy(A)\n",
    "A[-1].append(8)\n",
    "\n",
    "print(A)\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d573e37-f2d1-4570-b69b-4856f261be38",
   "metadata": {},
   "source": [
    "Разница между **поверхностным** и **глубоким** копированием существенна только для **составных** объектов, содержащих изменяемые объекты (например, список списков, или словарь, в качестве значений которого - списки или словари):\n",
    "\n",
    "* Поверхностная копия `.copy` создает новый составной объект, и затем (по мере возможности) вставляет в него ссылки на объекты, находящиеся в оригинале.\n",
    "* Глубокая копия   `deepcopy()` создает новый составной объект, и затем рекурсивно вставляет в него копии объектов, находящихся в оригинале."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "441e623a",
   "metadata": {},
   "source": [
    "Не путайте списки с массивами (если кто-то встречался с таким словом). Массивы ограничены тем, что содержат в себе только один тип данных за раз, а в списках может быть сразу несколько. Возможно, чуть позже будет отдельный конспект именно по массивам. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1da590d",
   "metadata": {},
   "source": [
    "## Дополнительные материалы <a name=\"parlast\"></a>\n",
    "\n",
    "+ Документация Python [Built-in Types](https://docs.python.org/3/library/stdtypes.html)\n",
    "+ Документация Python [More Control Flow Tools](https://docs.python.org/3/tutorial/controlflow.html)\n",
    "+ Щуров И.В., Тамбовцева А.А., Жучкова С.В. —  курс «Основы программирования в Python» ([ссылка на курс](https://allatambov.github.io/pypolit/pypolit.html))\n",
    "+ Статья на Хабр. [Понимание итераторов в Python](https://habr.com/ru/post/488112/)\n",
    "+ [Цикл `for` в Python - как работает, синтаксис, примеры](https://pythonchik.ru/osnovy/cikl-for-v-python)\n",
    "+ [Как работает функция `enumerate()` в Python?](https://pythonist.ru/kak-rabotaet-funkcziya-enumerate-v-python/)\n",
    "+ Python для начинающих. [Про `try-except`](https://pythonworld.ru/tipy-dannyx-v-python/isklyucheniya-v-python-konstrukciya-try-except-dlya-obrabotki-isklyuchenij.html)\n",
    "+ Python для начинающих. [Все методы списков с примерами](https://pythonworld.ru/tipy-dannyx-v-python/spiski-list-funkcii-i-metody-spiskov.html)"
   ]
  }
 ],
 "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}