sem05_set_dict/sem05_set_dict.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "92258638",
   "metadata": {},
   "source": [
    "# Программирование на Python \n",
    "\n",
    "# Множества и словари.\n",
    "\n",
    "\n",
    "*Автор: Паршина Анастасия, НИУ ВШЭ (tg: @aaparshina)*\n",
    "\n",
    "*Дополнила: Капустина Лика, НИУ ВШЭ (tg: @lika_kapustina)*\n",
    "\n",
    "\n",
    "## Содержание\n",
    "\n",
    "\n",
    "1. [Типы данных — часть 4.1 Множества](#par1)\n",
    "    1. [Создание множеств](#par1.1)\n",
    "    2. [Методы изменения множеств](#par1.2)\n",
    "    3. [Операции для работы с множествами](#par1.3)\n",
    "    4. [Неизменяемое множество](#par1.4)\n",
    "2. [Типы данных — часть 4.2 Словари](#par2)\n",
    "    1. [Создание словаря, ключи и значения](#par2.1)\n",
    "    2. [Методы работы со словарями](#par2.2)\n",
    "3. [Дополнительные материалы](#parlast)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ba3ca3b",
   "metadata": {},
   "source": [
    "Сегодня у нас будет очень много фигурных скобочек `{}`. Визуально вы можете их встретить при работе с множествами и со словарями, однако важно помнить, что это два разных типа данных. Сначала разберемся с множествами.\n",
    "\n",
    "## Типы данных — часть 4.1 Множества <a name=\"par1\"></a>\n",
    "\n",
    "В истории с множествами важно помнить, что сами по себе (`set`) они изменяемы — например, позволяют добавлять в себя элементы или, наоброт, убирать их, однако сужествует и неизменяемое множество (`frozenset`). Сначала обговорим первое, а потом пару слов скажем о втором.\n",
    "\n",
    "### Создание множеств <a name=\"par1.1\"></a>\n",
    "\n",
    "Способов создать множество два:\n",
    "1. через функцию `set()`; \n",
    "2. через фигруные скобки;\n",
    "3. через set comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a5706799",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'e', 'y', 't', 'r', 'w', 'q'}\n"
     ]
    }
   ],
   "source": [
    "A = set('qwerty')\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "698d7fde",
   "metadata": {},
   "source": [
    "Первый на вход обязательно принимает итерируемый объект. Убедимся в этом, скормив ему целое число:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "27cb992d",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'int' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [2]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m A \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mset\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m12\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(A)\n",
      "\u001b[0;31mTypeError\u001b[0m: 'int' object is not iterable"
     ]
    }
   ],
   "source": [
    "A = set(12)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7420288d",
   "metadata": {},
   "source": [
    "Обратим внимание, что просто фиругные скобки принимают любые <u>неизменяемые</u> объекты.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "440bcb30",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{True, 12, 12.4, 'qwerty'}\n"
     ]
    }
   ],
   "source": [
    "B = {'qwerty', 12, True, 12.4}\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcf46e33",
   "metadata": {},
   "source": [
    "Если мы попробуем тоже самое сделать с именяемыми объектами (например, списками или множествами), то увидим ошибку: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0e079bbf",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [4]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m B \u001b[38;5;241m=\u001b[39m {[\u001b[38;5;241m1\u001b[39m,\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m2\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;241m3\u001b[39m]}\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(B)\n",
      "\u001b[0;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "B = {[1,'2', 3]}\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "672187ef",
   "metadata": {},
   "source": [
    "И последний вариант: помните list comprehension (списковые включения)? С множествами это также возможно, но через, очевидно, фигурные скобки, это еще называют абстракцией множеств: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a62e4a55",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 2, 4, 6, 8}\n"
     ]
    }
   ],
   "source": [
    "even = {i for i in range(10) if i%2 == 0}\n",
    "print(even)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5fec42e",
   "metadata": {},
   "source": [
    "Если же мы хотим создать пустое множество, то важно помнить, что фигурными скобками это сделать не получится: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3f11c28f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{} <class 'dict'>\n",
      "set() <class 'set'>\n"
     ]
    }
   ],
   "source": [
    "C = {}\n",
    "print(C, type(C))\n",
    "\n",
    "D = set()\n",
    "print(D, type(D))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9175ad7",
   "metadata": {},
   "source": [
    "В первом случае у нас получился словарь, о них мы поговорим чуть ниже. \n",
    "\n",
    "Что еще важно знать о множествах? Элементы в них не упорядочены. А при попытке запихнуть в них повторяющиеся элементы, останется только один уникальный. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "393f1b87",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{9, 2, 3, 5}\n"
     ]
    }
   ],
   "source": [
    "E = {3, 5, 9, 2, 3}\n",
    "print(E)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "162c26ab",
   "metadata": {},
   "source": [
    "Как следствие, раз элементы не упорядочены, то и обратиться к ним по индексам нельзя. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9b72f69c",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'set' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [8]\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[43mE\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m)\n",
      "\u001b[0;31mTypeError\u001b[0m: 'set' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "print(E[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc5bd553",
   "metadata": {},
   "source": [
    "### Методы изменения множеств <a name=\"par1.2\"></a>\n",
    "\n",
    "+ Сначала обсудим разницу между `.add()` и `.update()`. Оба они добавляют элементы в множество, однако второй работает с итерируемыми объектами. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7fe8fd90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'груши', 'апельсины', 'бананы', 'яблоки'}\n"
     ]
    }
   ],
   "source": [
    "products = {'яблоки', 'апельсины', 'груши'}\n",
    "products.add('бананы')\n",
    "print(products)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d0bcacf7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'груши', 'апельсины', 'бананы', 'киви', 'яблоки', 'виноград'}\n"
     ]
    }
   ],
   "source": [
    "products.update(['киви', 'виноград'])\n",
    "print(products)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f32f09e",
   "metadata": {},
   "source": [
    "Проверьте сами, что наоборот они работать не будут. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41bc8c25",
   "metadata": {},
   "source": [
    "+ Для удаления конкретного элемента из множества используется `.remove()`, а если нужно удалить сразу несколько элементов — `.difference_update()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "5888cc91",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'груши', 'бананы', 'киви', 'яблоки', 'виноград'}\n"
     ]
    }
   ],
   "source": [
    "products.remove('апельсины')\n",
    "print(products)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b5d4b5a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'бананы', 'киви', 'виноград'}\n"
     ]
    }
   ],
   "source": [
    "products.difference_update(['груши', 'яблоки'])\n",
    "print(products)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3eae4c66",
   "metadata": {},
   "source": [
    "Важно! Если мы попробуем удалить объект, которого в множестве уже нет, то будет выдана ошибка: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6dd01ca8",
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'апельсины'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "Input \u001b[0;32mIn [13]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mproducts\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mremove\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\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(products)\n",
      "\u001b[0;31mKeyError\u001b[0m: 'апельсины'"
     ]
    }
   ],
   "source": [
    "products.remove('апельсины')\n",
    "print(products)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1c548cb",
   "metadata": {},
   "source": [
    "Чтобы избежать ее, можно пользоваться методом `.discard()` — он не будет возвращать ошибку."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "e4181416",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'бананы', 'киви', 'виноград'}\n"
     ]
    }
   ],
   "source": [
    "products.discard('апельсины')\n",
    "print(products)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37652c60",
   "metadata": {},
   "source": [
    "И последний метод, который изменяет само множество, — `.pop()`. Он вытаскивает элемент рандомно, при этом дает возможность сохранить его в переменную:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8eee700e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "бананы {'киви', 'виноград'}\n"
     ]
    }
   ],
   "source": [
    "get_product = products.pop()\n",
    "print(get_product, products)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b737e52",
   "metadata": {},
   "source": [
    "Проверьте — какую ошибку выдает метод, если работает с пустым множеством? "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "817a968d",
   "metadata": {},
   "source": [
    "<center><b><font size=4>Задача №1</font></b></center>\n",
    "\n",
    "**Иван хочет понять, какие еще предметы он может включить в свой учебный план. Напишите программу, которая принимает на вход строку с названиями предметов в его учебном плане, название нового предмета который Иван хочет включить в УП, и выводит информацию о том можно ли его включить в УП и названия курсов Ивана в УП:**\n",
    "\n",
    "* Сперва программа принимает на вход перечисленные через запятую с точкой и пробелом **названия курсов в учебном плане** и **преобразует эту строку в множество `set`**;\n",
    "* Далее программа принимает на вход **название курса, который студент хочет включить в учебный план**;\n",
    "* Если этот курс **уже включен в учебный план**, программа печатает `Вы уже изучали этот предмет`;\n",
    "* Если этот курс **еще не включен в учебный план**, программа печатает `Вы еще не изучали этот предмет` и **добавляет новое значение в множество**.\n",
    "\n",
    "* В конце программа выводит **отсортированный в алфавитном порядке список предметов в учебном плане**.\n",
    "\n",
    "\n",
    "\n",
    "* *Обратите внимание: Названия предметов перечислены через точку с запятой и пробел*;\n",
    "* <font color='orange'>Использование множеств и методов множеств при решении этой задачи является обязательным. </font>\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>Анализ данных; Категории политической науки; Python; R; ТВиМС; Регрессионный анализ</p>\n",
    "                <p>ТВиМС</p></td>\n",
    "            <td><p>Вы уже изучали этот предмет</p>\n",
    "                <p>['Python', 'R', 'Анализ данных', 'Категории политической науки', 'Регрессионный анализ', 'ТВиМС']</p></td></tr>\n",
    "        <tr><td><p>Python; Python; Python; История политических учений</p>\n",
    "                <p>R</p></td>\n",
    "            <td><p>Вы еще не изучали этот предмет</p>\n",
    "                <p>['Python', 'R', 'История политических учений']</p></td></tr>\n",
    "        <tr><td>        \n",
    "            <p>История России; Новейшая история; КПН; ИПУ; История России; Python</p>\n",
    "            <p>Python</p></td>\n",
    "            <td><p>Вы уже изучали этот предмет</p>\n",
    "<p>['Python', 'ИПУ', 'История России', 'КПН', 'Новейшая история']</p></td></tr>\n",
    "    </table>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9cca8144",
   "metadata": {},
   "outputs": [],
   "source": [
    "# YOUR CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33e42d6e",
   "metadata": {},
   "source": [
    "### Операции для работы с множествами <a name=\"par1.3\"></a>\n",
    "\n",
    "Важно! Операции для работы с множествами множество не изменяют, а буквально создают новый объект.\n",
    "\n",
    "**Здесь и далее мы будем говорить про разные методы и использовать такие термины, как `intersection`, `symmetric_difference`, `difference`, `union`. Чтобы не запутаться и разобраться в том, что возвращают определенные операции работы с множествами, смотрите на это изображение:**\n",
    "\n",
    "![пик](https://www.learnbyexample.org/wp-content/uploads/python/Python-Set-Operatioons.png)\n",
    "\n",
    "Предположим, у нас есть множество респондентов, которые любят кофе, и множество респондентов, которые любят чай. \n",
    "\n",
    "Вопрос — кто из них любит и то, и то?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "a3373fd5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Дима', 'Рита'}\n",
      "{'Дима', 'Рита'}\n"
     ]
    }
   ],
   "source": [
    "# Пересечение множеств\n",
    "\n",
    "coffee = {'Влад', 'Катя', 'Рита', 'Дима'}\n",
    "tea = {'Рита', 'Дима', 'Настя', 'Максим'}\n",
    "\n",
    "print(coffee.intersection(tea))\n",
    "print(coffee & tea)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d97c237",
   "metadata": {},
   "source": [
    "Вопрос — кто из них любит что-то одно (т.е. не находится на пересечении)? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9841ce20",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Максим', 'Катя', 'Настя', 'Влад'}\n",
      "{'Максим', 'Катя', 'Настя', 'Влад'}\n"
     ]
    }
   ],
   "source": [
    "# Симметрическая разность множеств\n",
    "coffee = {'Влад', 'Катя', 'Рита', 'Дима'}\n",
    "tea = {'Рита', 'Дима', 'Настя', 'Максим'}\n",
    "\n",
    "print(coffee.symmetric_difference(tea))\n",
    "print(coffee ^ tea)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a360563",
   "metadata": {},
   "source": [
    "Вопрос — кто любит только кофе?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "116c2348",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Катя', 'Влад'}\n",
      "{'Катя', 'Влад'}\n"
     ]
    }
   ],
   "source": [
    "# Разность множеств coffee и tea\n",
    "coffee = {'Влад', 'Катя', 'Рита', 'Дима'}\n",
    "tea = {'Рита', 'Дима', 'Настя', 'Максим'}\n",
    "\n",
    "print(coffee.difference(tea))\n",
    "print(coffee - tea)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97f67e1c",
   "metadata": {},
   "source": [
    "Вопрос — кто любит только чай?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "127cd82e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Максим', 'Настя'}\n",
      "{'Максим', 'Настя'}\n"
     ]
    }
   ],
   "source": [
    "# Разность множеств tea и coffee\n",
    "coffee = {'Влад', 'Катя', 'Рита', 'Дима'}\n",
    "tea = {'Рита', 'Дима', 'Настя', 'Максим'}\n",
    "\n",
    "print(tea.difference(coffee))\n",
    "print(tea - coffee)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "306ed796",
   "metadata": {},
   "source": [
    "Вопрос — сколько у нас всего респондентов?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "0347066b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Дима', 'Рита', 'Максим', 'Катя', 'Настя', 'Влад'}\n",
      "{'Дима', 'Рита', 'Максим', 'Катя', 'Настя', 'Влад'}\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# Объединение множеств\n",
    "coffee = {'Влад', 'Катя', 'Рита', 'Дима'}\n",
    "tea = {'Рита', 'Дима', 'Настя', 'Максим'}\n",
    "\n",
    "print(coffee.union(tea))\n",
    "print(coffee | tea)\n",
    "print(len(coffee.union(tea)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cc9051d",
   "metadata": {},
   "source": [
    "С основным разобрались. Теперь не основное, но важное. \n",
    "\n",
    "Те же самые команды, НО с добавлением к ним `_update()` меняют множество! Приведем пример с `intersection_update()`, а остальное проверьте сами!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "86adda35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Дима', 'Катя', 'Рита', 'Влад'}\n",
      "{'Максим', 'Дима', 'Рита', 'Настя'}\n",
      "{'Дима', 'Рита'}\n",
      "{'Максим', 'Дима', 'Рита', 'Настя'}\n"
     ]
    }
   ],
   "source": [
    "coffee = {'Влад', 'Катя', 'Рита', 'Дима'}\n",
    "tea = {'Рита', 'Дима', 'Настя', 'Максим'}\n",
    "\n",
    "# Пересечение множеств coffee и tea\n",
    "\n",
    "print(coffee)\n",
    "print(tea)\n",
    "\n",
    "coffee.intersection_update(tea)\n",
    "\n",
    "print('Посмотрим, что изменилось после использования coffee.intersection_update(tea): ')\n",
    "print(coffee) # сюда сохранилось пересечение множеств! \n",
    "print(tea)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "cd17132b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Дима', 'Катя', 'Рита', 'Влад'}\n",
      "{'Максим', 'Дима', 'Рита', 'Настя'}\n",
      "{'Дима', 'Рита'}\n",
      "{'Максим', 'Дима', 'Рита', 'Настя'}\n"
     ]
    }
   ],
   "source": [
    "coffee = {'Влад', 'Катя', 'Рита', 'Дима'}\n",
    "tea = {'Рита', 'Дима', 'Настя', 'Максим'}\n",
    "\n",
    "# Пересечение множеств coffee и tea\n",
    "\n",
    "print(coffee)\n",
    "print(tea)\n",
    "\n",
    "coffee &= tea # тоже самое \n",
    "\n",
    "print(coffee) # сюда сохранилось пересечение множеств! \n",
    "print(tea)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d5b27e5",
   "metadata": {},
   "source": [
    "Осталось три метода — `.issubset()`, `.issuperset()` и `.isdisjoint()`. \n",
    "\n",
    "+ `.issubset()` проверяет, что множество является <i>подмножеством</i> другого множества\n",
    "+ `.issuperset()` проверяет, что множество является <i>надмножеством</i> другого множества\n",
    "+ `.isdisjoint()` проверяет, что у множеств нет пересекающихся элементов\n",
    "\n",
    "Все три метода выдают либо `False`, либо `True`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29c8fb6b",
   "metadata": {},
   "source": [
    "<center><b><font size=4>Задача №2</font></b></center>\n",
    "\n",
    "**Напишите программу, которая печатает вам информацию о студентах и курсах по выбору, на которые они записались:**\n",
    "\n",
    "\n",
    "**Заранее созданы строки с именами:**\n",
    "* `students_1` – студенты, которые выбрали КПВ \"Ислам и политика\"\n",
    "* `students_2` – студенты, которые выбрали КПВ \"Политическая система США\"\n",
    "* `students_3` – студенты, которые выбрали КПВ \"Web-scraping\"\n",
    "\n",
    "**Напечатайте следующую информацию:**\n",
    "\n",
    "* Имена студентов, которые **пошли на курс \"Ислам и политика\" и пошли на курс \"Полит. система США\"**;\n",
    "* Имена студентов, которые **пошли на курс \"Ислам и политика\", но не пошли на курс \"Полит.система США\"**;\n",
    "* Имена студентов, которые **пошли на курс \"Web-Scraping\", но не пошли на другие два курса**.\n",
    "\n",
    "<font color='orange'>Использование методов множеств обязательно.</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0d4abc18",
   "metadata": {},
   "outputs": [],
   "source": [
    "students_1 = 'Аня Даша Глаша Наташа Марина Ирина' # выбрали КПВ \"Ислам и политика\"\n",
    "students_2 = 'Даша Глаша Марина'                  # выбрали КПВ \"Политическая система США\"\n",
    "students_3 = 'Ирина Наташа Аня Даша Глафира Зина' # выбрали КПВ \"Web-scraping\"\n",
    "\n",
    "\n",
    "# YOUR CODE HERE\n",
    "\n",
    "print(f'На курс \"Ислам и Политика\" и курс \"Полит. система США\" пошли: {# YOUR CODE HERE}')\n",
    "print(f'Выбрали курс \"Ислам и политика\", но не выбрали курс \"Полит. система США\": {# YOUR CODE HERE}')\n",
    "print(f'Пошли на курс \"Web-scraping\", но не пошли на остальные курсы: {# YOUR CODE HERE}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a88d8a8",
   "metadata": {},
   "source": [
    "### Неизменяемое множество <a name=\"par1.4\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1f1cde0",
   "metadata": {},
   "source": [
    "Очевидно, что любые методы, которые могут изменять множество, тут не работают. Конец. \n",
    "\n",
    "Ладно, все-таки сделаем одно такое множество и покажем, что с ним работает."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "7ef2743f",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "frozenset expected at most 1 argument, got 3",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [23]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m X \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mfrozenset\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: frozenset expected at most 1 argument, got 3"
     ]
    }
   ],
   "source": [
    "X = frozenset(1, 2, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99594b46",
   "metadata": {},
   "source": [
    "Ой, что-то пошло не так. Помним, что эта функция, аналогично функции `set()` работает только с итерируемыми объектами!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "7d497b6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "frozenset({2, 3, 6, '10', '7', '8'})\n",
      "frozenset({2, 3, 4, '6', 8, '3'})\n"
     ]
    }
   ],
   "source": [
    "X = frozenset(['10', 2, 3, '8', 6, '7'])\n",
    "Y = frozenset((3, 4, '6', 2, '3', 8))\n",
    "print(X)\n",
    "print(Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59768b3e",
   "metadata": {},
   "source": [
    "Вот все, что работает:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "b9a6f477",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "У множеств нет общих элементов (True/False): False\n",
      "Множество Х является подмножеством Y (True/False): False\n",
      "Множество Х является надмножеством Y (True/False): False\n",
      "Пересечение множеств Х и Y: frozenset({2, 3})\n",
      "Объединение множеств Х и Y: frozenset({2, 3, 4, '6', 6, 8, '3', '10', '7', '8'})\n",
      "Симметрическая разность множеств Х и Y: frozenset({4, '6', 6, 8, '3', '10', '8', '7'})\n",
      "Разность множеств Х и Y: frozenset({'10', '7', '8', 6})\n",
      "Разность множеств Y и X: frozenset({8, '6', 4, '3'})\n"
     ]
    }
   ],
   "source": [
    "print(f'У множеств нет общих элементов (True/False): {X.isdisjoint(Y)}')\n",
    "\n",
    "print(f'Множество Х является подмножеством Y (True/False): {X.isdisjoint(Y)}')\n",
    "\n",
    "print(f'Множество Х является надмножеством Y (True/False): {X.issuperset(Y)}')\n",
    "\n",
    "print(f'Пересечение множеств Х и Y: {X.intersection(Y)}') \n",
    "\n",
    "print(f'Объединение множеств Х и Y: {X.union(Y)}') \n",
    "\n",
    "print(f'Симметрическая разность множеств Х и Y: {X.symmetric_difference(Y)}')\n",
    "\n",
    "print(f'Разность множеств Х и Y: {X.difference(Y)}') \n",
    "\n",
    "print(f'Разность множеств Y и X: {Y.difference(X)}') "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "054622e2",
   "metadata": {},
   "source": [
    "## Типы данных — часть 4.2 Словари <a name=\"par2\"></a>\n",
    "\n",
    "Со словарями мы столкнулись в самом начале, сейчас разберемся подробнее. \n",
    "\n",
    "### Создание словаря, ключи и значения <a name=\"par2.1\"></a>\n",
    "\n",
    "Самое важное (что бы для вас сейчас это ни значило): начиная с Python 3.7 словари стали упорядоченными!\n",
    "\n",
    "Словарь можно создать четырьмя способами: \n",
    "\n",
    "1. Фигурными скобками (это уже было выше)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "1250b028",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{} <class 'dict'>\n",
      "{'Математика': [3, 5, 2, 3, 5], 'Русский язык': [2, 4, 1, 5, 3]} <class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "new_dict1 = {}\n",
    "print(new_dict1, type(new_dict1))\n",
    "\n",
    "new_dict1 = {'Математика' : [3, 5, 2, 3, 5], 'Русский язык' : [2, 4, 1, 5, 3]}\n",
    "print(new_dict1, type(new_dict1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6822b51d",
   "metadata": {},
   "source": [
    "При таком создании словаря обратите внимание на тип записи: `ключ : значение`!\n",
    "\n",
    "Далее логичный вопрос: что может быть ключом словаря, а что — значением?\n",
    "\n",
    "| Ключ / неизменяемый тип |\n",
    "|:---:|\n",
    "| числа      | \n",
    "| строки       |\n",
    "| кортежи       |\n",
    "| логический тип      | \n",
    "| frozenset      | \n",
    "\n",
    "\n",
    "Значением может быть любой тип данных. \n",
    "\n",
    "Попытка создания словаря, где ключ представлен изменяемым типом, приведет к ошибке: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "c952f109",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [38]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m {[\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m] : \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m1\u001b[39m\u001b[38;5;124m'\u001b[39m}\n",
      "\u001b[0;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "# ключ — список, значение — строка\n",
    "new_dict_try = {[1, 2] : '1'}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad756b98",
   "metadata": {},
   "source": [
    "Если очень упрощать, то ошибка как раз и ругается на то, что список — объект изменяемый.\n",
    "\n",
    "2. Также создать словарь можно с помощью функции `dict()`, однако вместо двоеточия там будет знак равно."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "22e69781",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{} <class 'dict'>\n",
      "{'Математика': [3, 5, 2, 3, 5], 'Русский_язык': [2, 4, 1, 5, 3]} <class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "new_dict2 = dict()\n",
    "print(new_dict2, type(new_dict2))\n",
    "\n",
    "new_dict2 = dict(Математика = [3, 5, 2, 3, 5], Русский_язык = [2, 4, 1, 5, 3])\n",
    "print(new_dict2, type(new_dict2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc052f24",
   "metadata": {},
   "source": [
    "Надесь, вы обратили внимание, что ключи словаря в такой вариации его создания записываются без кавычек, однако они должны быть целыми (то есть, если написать `Русский_язык` раздельно (`Русский язык`), то будет ошибка). \n",
    "\n",
    "3. Можно создать словарь с помощью метода `.fromkeys()`. В качетстве значения он всем ключам подставляет одно единственное (которое мы укажем)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "466a7d94",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Математика': 0, 'Русский_язык': 0}\n"
     ]
    }
   ],
   "source": [
    "new_dict3 = dict.fromkeys(['Математика', 'Русский_язык'], 0)\n",
    "print(new_dict3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfbcc9ca",
   "metadata": {},
   "source": [
    "4. Функция `zip()` может создать словарь из двух итерируемых объектов. Например, их двух списоков: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "1d061ceb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Математика': [3, 5, 2, 3, 5], 'Русский язык': [2, 4, 1, 5, 3]}\n"
     ]
    }
   ],
   "source": [
    "new_dict4 = dict(zip(['Математика', 'Русский язык'], [[3, 5, 2, 3, 5], [2, 4, 1, 5, 3]]))\n",
    "print(new_dict4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73e8235f",
   "metadata": {},
   "source": [
    "Очень хочу, чтобы вы внимательно посмотрели на все скобки выше и разобрались с тем, почему их так много!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa30d837",
   "metadata": {},
   "source": [
    "### Методы словарей <a name=\"par2.2\"></a>\n",
    "\n",
    "|Есть в онлайн-курсе | Все остальное |\n",
    "|:--------------:|:-----:|\n",
    "| `.keys()` |  `.get()` |\n",
    "| `.values()`      |  `.update()` |\n",
    "| `.items()`      |  `.pop()` |\n",
    "|       |  `.popitem()` |\n",
    "|     |  `.setdefault()` |\n",
    "|     |  `.fromkeys()` |\n",
    "|     |  `.copy()` |\n",
    "|     |  `.clear()` |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "869b3c0f",
   "metadata": {},
   "source": [
    "На что стоит обратить внимание: скорее всего, вам всегда пригодится метод `.items()`, поэтому с ним нужно очень хорошо разобраться! \n",
    "\n",
    "Метод возвращает <u>пары ключ-значение</u> в виде кортежей:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "17e0618a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Математика', [3, 5, 2, 3, 5])\n",
      "('Русский язык', [2, 4, 1, 5, 3])\n"
     ]
    }
   ],
   "source": [
    "for pair in new_dict4.items():\n",
    "    print(pair)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94f6f2f5",
   "metadata": {},
   "source": [
    "Но мы же можем еще эти кортежи «распаковать», то есть в одну переменную сохранить ключ, а в другую — значение. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "9b89ad20",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ключ Математика, значение [3, 5, 2, 3, 5]\n",
      "Ключ Русский язык, значение [2, 4, 1, 5, 3]\n"
     ]
    }
   ],
   "source": [
    "for key, value in new_dict4.items():\n",
    "    print(f'Ключ {key}, значение {value}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed6495f4",
   "metadata": {},
   "source": [
    "Давайте я добавлю в наш словарь еще несколько пар ключ-значение и попробуем выполнить с ними какую-нибудь задачку. К слову, обратите внимание, как в словарь добавлять новые данные. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "43a35e90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Математика': [3, 5, 2, 3, 5], 'Русский язык': [2, 4, 1, 5, 3], 'Английский язык': [2, 4, 5, 2, 4], 'История': [1, 2, 5, 5, 5], 'Биология': [2, 2, 2, 2, 4]}\n"
     ]
    }
   ],
   "source": [
    "new_dict4['Английский язык'] = [2, 4, 5, 2, 4]\n",
    "new_dict4['История'] = [1, 2, 5, 5, 5]\n",
    "new_dict4['Биология'] = [2, 2, 2, 2, 4]\n",
    "\n",
    "print(new_dict4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d02f7b4c",
   "metadata": {},
   "source": [
    "Предположим, что это оценки студента по соответсвующим предметам. По какому предмету в среднем оценки самые лучшие? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "d0a94ca0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Математика': 3.6, 'Русский язык': 3.0, 'Английский язык': 3.4, 'История': 3.6, 'Биология': 2.4}\n"
     ]
    }
   ],
   "source": [
    "new_dict4_av = {}\n",
    "for subject, marks in new_dict4.items():\n",
    "    new_dict4_av[subject] = sum(marks)/len(marks)\n",
    "    \n",
    "print(new_dict4_av)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61c8c593",
   "metadata": {},
   "source": [
    "И тут мы сталкиваемся с вопросом — как отсортировать словарь по значениям? Если вы погуглите этот вопрос, то получите очень много ответов. Из них самым понятным мне кажется вот этот: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "71019a99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(3.6, 'Математика'), (3.0, 'Русский язык'), (3.4, 'Английский язык'), (3.6, 'История'), (2.4, 'Биология')]\n"
     ]
    }
   ],
   "source": [
    "res = [(value, key) for key, value in new_dict4_av.items()]\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dffba6c",
   "metadata": {},
   "source": [
    "Что произошло? Буквально создали пустой список, далее положили в него кортеж `(значение, ключ)`, а потом сказали, откуда эту пару брать — из пары `ключ, значение` в нашем словаре. Иными словами поменяли их местами. \n",
    "\n",
    "Теперь к списку можно спокойно применить функцию `sorted()` и по умолчанию она отсортирует от меньшего к большему. Если хотим в обратном порядке, то также нужно будет прописать `reverse = True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "b1d81e68",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(3.6, 'Математика'), (3.6, 'История'), (3.4, 'Английский язык'), (3.0, 'Русский язык'), (2.4, 'Биология')]\n"
     ]
    }
   ],
   "source": [
    "res = sorted(res, reverse = True)\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcbc2f61",
   "metadata": {},
   "source": [
    "Если у нас одно максимальное значение, то все просто — печатаем первый элемент нашего списка `res`. Если их несколько, то печатаем все элементы, где значения совпадают с максимальным:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "472bfb70",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Лучший средний балл (3.6) по предметам: Математика, История\n"
     ]
    }
   ],
   "source": [
    "best = []\n",
    "for pair in res:\n",
    "    if pair[0] == max(new_dict4_av.values()):\n",
    "        best.append(pair[1])\n",
    "        \n",
    "print(f'Лучший средний балл ({max(new_dict4_av.values())}) \\\n",
    "по предметам: {\", \".join(best)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7a024cf",
   "metadata": {},
   "source": [
    "<center><b><font size=4>Задача №3</font></b></center>\n",
    "\n",
    "**Вам передан список с абитуриентами `abiturients` и их баллами по математике, русскому языку и обществознанию соответственно. Напишите программу, которая принимает на вход целое число (от `0` до `100`) и название предмета (`математика`, `русский язык`, `обществознание`) и выводит отсортированный список имен студентов, которые набрали столько же или более баллов за вступительный экзамен по этому предмету**\n",
    "\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>90</p>\n",
    "                <p>математика</p></td>\n",
    "            <td>\n",
    "                <p>['Александров Александр', 'Иванов Иван', 'Сергеев Сергей', 'Федоров Федор']</p></td></tr>\n",
    "        <tr><td><p>73</p>\n",
    "                <p>обществознание</p></td>\n",
    "            <td><p>['Александров Александр', 'Иванов Иван']</p></td></tr>\n",
    "        <tr><td>        \n",
    "            <p>100</p>\n",
    "            <p>русский язык</p></td>\n",
    "            <td><p>[]</p></td></tr>\n",
    "    </table>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "a4beb2dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "abiturients = {'Иванов Иван': [90, 84, 95],\n",
    "           'Федоров Федор': [100, 70, 65],\n",
    "           'Сергеев Сергей': [90, 83, 72],\n",
    "           'Александров Александр': [100, 60, 80],\n",
    "           'Федотов Федот': [60, 75, 60],}\n",
    "\n",
    "# YOUR CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "040b0d05",
   "metadata": {},
   "source": [
    "Подумайте, как тут работает `\\`.\n",
    "\n",
    "А теперь обсудим остальные методы (из них стоит обратить внимание на `.get()` и `.setgefault()`): "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "8ca378fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ой, оценок по такому предмету нет'"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# .get()\n",
    "## возвращает значение ключа, а если его нет, то возвращает то, что мы напишем\n",
    "\n",
    "new_dict4_av.get('Химия', 'Ой, оценок по такому предмету нет')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "695cb80d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Математика': 3.6, 'Английский язык': 3.4, 'История': 3.6, 'Биология': 2.4, 'Химия': 3.2, 'ОБЖ': 5.0, 'Физика': 2.7}\n"
     ]
    }
   ],
   "source": [
    "# .setdefault()\n",
    "## возвращает значение ключа, а если его нет, то создает ключ с указанным значением \n",
    "\n",
    "new_dict4_av.setdefault('Физика', 2.7)\n",
    "print(new_dict4_av)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "256357f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Математика': 3.6, 'Русский язык': 3.0, 'Английский язык': 3.4, 'История': 3.6, 'Биология': 2.4, 'Химия': 3.2, 'ОБЖ': 5.0}\n"
     ]
    }
   ],
   "source": [
    "# .update()\n",
    "## добавляет пары ключ-значение в словарь\n",
    "\n",
    "new_dict4_av.update({'Химия' : 3.2, 'ОБЖ' : 5.0})\n",
    "\n",
    "print(new_dict4_av)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "69b5ab35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n",
      "{'Математика': 3.6, 'Английский язык': 3.4, 'История': 3.6, 'Биология': 2.4, 'Химия': 3.2, 'ОБЖ': 5.0}\n"
     ]
    }
   ],
   "source": [
    "# .pop()\n",
    "## удаляет ключ и возвращает значение\n",
    "\n",
    "rus_av = new_dict4_av.pop('Русский язык')\n",
    "\n",
    "print(rus_av)\n",
    "print(new_dict4_av)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "817dea6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# .popitem()\n",
    "## удаляет и возвращает пару ключ-значение\n",
    "\n",
    "hist_av = new_dict4_av.popitem('История')\n",
    "\n",
    "print(rus_av)\n",
    "print(new_dict4_av)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbe9460d",
   "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/516858/)\n",
    "+ Python для начинающих. [Работа со словарями и методы словарей](https://pythonworld.ru/tipy-dannyx-v-python/slovari-dict-funkcii-i-metody-slovarej.html)\n",
    "+ Статья на Хабр. [Что такое API?](https://habr.com/ru/post/464261/)\n",
    "+ [Инструкция](https://sphenoid-aluminum-1ba.notion.site/API-YouTube-a1e2552472c246d295b6f1d1dbce5dcb) по получению ключа API YouTube\n",
    "+ Официальная [документация](https://developers.google.com/youtube/v3/docs) к API YouTube\n",
    "+ Статья на Хабр. [Что такое JSON](https://habr.com/ru/post/554274/)"
   ]
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}