sem05_dict/sem05_set_dict_tutorial_part1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Неструктурированные типы данных: множества\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ноутбук основан на материалах курса [Python как иностранный](https://online.hse.ru/course/view.php?id=5261)\n",
    "\n",
    "Дополнительно нужно разобрать краткий конспект и задачи [тут](https://github.com/hse-econ-data-science/dap_2022-23/blob/main/sem05_dict/sem05_set_dict.ipynb), а также прорешать рекомендованные задачи из [яндекс-контеста](https://github.com/hse-econ-data-science/dap_2022-23/tree/main/sem05_dict)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uyDM4m4ERUha"
   },
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "Мы с вами уже знакомы с тремя типами данных, которые помогают нам хранить наши элементы в определенном порядке, — это списки, кортежи и строки. Такие типы данных мы называли последовательностями и мы могли обратиться к их элементам по индексу. \n",
    "\n",
    "Теперь мы поговорим с вами о таких структурах, в которых элементы не закреплены за определенными индексами. Такие типы данных называются ***неупорядоченными*** *или* ***коллекциями***. Первые из них — **множества**.\n",
    "\n",
    "С множествами вы могли уже встречаться в математике или логике. **Множества**, как кортежи и списки, могут хранить внутри себя разное количество элементы, но их главные отличия в следующем:\n",
    "\n",
    "1. *Элементы внутри множества могут быть только уникальными*, когда в списках и кортежах они могут повторяться.\n",
    "2. К элементам внутри множества *нельзя обратиться по индексу*.\n",
    "\n",
    "Множество в Python можно задать с помощью фигурных скобок, внутри которых перечисляются элементы множества.\n",
    "\n",
    "В Python множества называются  `set`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ovnFOE5PbBN4"
   },
   "source": [
    "Внутри множества могут храниться любые неизменяемые типы данных в любых комбинациях. Таким образом, из известных нам типов множества могут содержать целые и вещественные числа, строки, логические переменные и кортежи."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 1106,
     "status": "ok",
     "timestamp": 1601837428219,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "RUU46D7jbT42",
    "outputId": "92d49743-8acf-4fae-dc04-1fff61765411"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{True, 5, 5.4, (2, 1), 'хлеб'}\n",
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "mixed_set = {'хлеб', True, 5.4, 5, (2,1)}\n",
    "print(mixed_set)\n",
    "print(type(mixed_set)) # Проверим, как Python видит тип такого объекта"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PBJeC7RV-zND"
   },
   "source": [
    "Но множество, может хранить только уникальные объекты."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "executionInfo": {
     "elapsed": 694,
     "status": "ok",
     "timestamp": 1601837929581,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "hVyVW2kyRFKr",
    "outputId": "13723dc8-f07e-4bc7-aa44-5397220db297"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'корм для рыбок', 'молоко', 'хлеб'}\n"
     ]
    }
   ],
   "source": [
    "shopping_set = {'хлеб', 'молоко', 'молоко', 'корм для рыбок'}  \n",
    "# Обратите внимание, что при определении множества мы написали \"молоко\" два раза\n",
    "\n",
    "print(shopping_set)        \n",
    "# А когда выводим наше множество, то видим, что \"молоко\" записалось только один раз"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GmBofZPZWnvV"
   },
   "source": [
    "Можно заметить, что порядок элементов в выводе отличается от того, который мы определили при создании множества. Более того, если вы запустите этот код у себя на компьютере, порядок элементов вашего множества может быть совсем другим. Не удивляйтесь, это связано как раз с *неупорядоченностью* этого типа данных и тем, что за элементами не закреплены конкретные места внутри множества.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZjkgGBXBA0ro"
   },
   "source": [
    "## Основные операции с множествами"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uTjjmxjy7mDE"
   },
   "source": [
    "Давайте попробуем обратиться к элементу множества по индексу:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 165
    },
    "executionInfo": {
     "elapsed": 734,
     "status": "error",
     "timestamp": 1601222044722,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "toxPjalIRQOp",
    "outputId": "d7571edc-831b-49d5-a4c5-7ab80aa67d99"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "ignored",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-47-c0ef95da5160>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mshopping_set\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'set' object does not support indexing"
     ]
    }
   ],
   "source": [
    "shopping_set[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qkcxGhG0RPXx"
   },
   "source": [
    "Действительно получили ошибку `'set' object does not support indexing` — объект типа `set` не поддерживает обращение по индексу.\n",
    "\n",
    "Как же нам обратиться к элементам множества, если у них нет индекса? Например, их можно перебрать с помощью цикла `for`, как строки, списки и кортежи:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "executionInfo": {
     "elapsed": 895,
     "status": "ok",
     "timestamp": 1601208383117,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "hRB0_jotW3Y5",
    "outputId": "970b168b-ee36-4313-f881-3288fe4c7d0e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "В нашем множестве есть молоко.\n",
      "В нашем множестве есть корм для рыбок.\n",
      "В нашем множестве есть хлеб.\n"
     ]
    }
   ],
   "source": [
    "shopping_set = {'хлеб', 'молоко', 'молоко', 'корм для рыбок'}\n",
    "\n",
    "for elem in shopping_set:\n",
    "    print(f'В нашем множестве есть {elem}.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Tc95A0MCLJ1k"
   },
   "source": [
    "Проверка на наличие элемента с помощью оператора `in` со множеством тоже работает."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 745,
     "status": "ok",
     "timestamp": 1601208443178,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "OXrktCkJaSir",
    "outputId": "adb2d1bf-129c-48d3-d8e6-961b491c5b25"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "pets_set =  {'собака', 'кошка', 'хомячок', 'рыбка', 'морская свинка'} \n",
    "# Множество домашних животных, которых мы хотим завести\n",
    "\n",
    "print('собака' in pets_set)  # Проверяем, входит ли в него собака\n",
    "print('питон' in pets_set)   # Проверяем, входит ли в него питон"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "f3pDbCE_buqn"
   },
   "source": [
    "Еще из-за особенностей хранения множеств в памяти компьютера, проверка на наличие/отсутствие элемента `in / not in`, выполняется быстрее, чем со списками или кортежами. Поэтому, если в вашей программе вам нужно проверять, принадлежит ли элемент некоторой последовательности, а эта последовательность довольно большая, то использование множеств ускорит ее выполнение."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ixcu-nAbA9QL"
   },
   "source": [
    "C множествами работает функция `len()`, показывающая количество элементов внутри сложной структуры."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "executionInfo": {
     "elapsed": 655,
     "status": "ok",
     "timestamp": 1601838546934,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "x1UGRZ-tA-6b",
    "outputId": "f8831d93-09e9-4b72-82b8-01f1396b320c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "В множестве pets_set 5 животных.\n"
     ]
    }
   ],
   "source": [
    "pets_set =  {'собака', 'кошка', 'хомячок', 'рыбка', 'морская свинка'} \n",
    "print(f'В множестве pets_set {len(pets_set)} животных.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aC_3qf_Q88bp"
   },
   "source": [
    "## Как создать множество"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8-G4q71eUSI7"
   },
   "source": [
    "Создать пустое множество можно с помощью функции `set()`.\n",
    "\n",
    "Обратите внимание, что создать пустое множество с помощью пустых фигурных скобок `{}` по аналогии с тем, как мы создавали пустой список с помощью пустых квадратных скобок `[]`, нельзя. Так мы создаем другую структуру — словарь, о которой поговорим позже."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 86
    },
    "executionInfo": {
     "elapsed": 831,
     "status": "ok",
     "timestamp": 1601206601227,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "JeB57GhsUEX7",
    "outputId": "0720f044-8785-4028-8d1d-3806a3bccf43"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set()\n",
      "<class 'set'>\n",
      "{}\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "empty_set = set()      # Создаем пустое множество\n",
    "print(empty_set)\n",
    "print(type(empty_set))\n",
    "\n",
    "empty_something = {}   # А такой синтаксис создаст пустой словарь — `dict`, но о них позже\n",
    "print(empty_something)\n",
    "print(type(empty_something))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qN6UdjpYnBFi"
   },
   "source": [
    "С помощью функции `set()` можно превратить любую последовательность в множество."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 74
    },
    "id": "IeFCm3g_nHZp",
    "outputId": "51c78e93-1a17-419c-dbb8-7f33760c12dd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'хлеб', 'молоко', 'корм для рыбок'}\n"
     ]
    }
   ],
   "source": [
    "shopping_list = ['хлеб', 'молоко', 'молоко', 'корм для рыбок'] \n",
    "shopping_set = set(shopping_list)  # Превращаем список в множество (работает и для кортежа!)\n",
    "print(shopping_set)                # Получаем множество уникальных элементов списка"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 7836,
     "status": "ok",
     "timestamp": 1601838564495,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "k1K0HGBZBJ9n",
    "outputId": "f69c6407-86ec-4cce-e993-bfa4653a3e7a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Введите через пробел названия животных, которых вы хотите завести? собака кошка ужик\n",
      "{'ужик', 'кошка', 'собака'}\n"
     ]
    }
   ],
   "source": [
    "# Мы можем считать множество с клавиатуры, превратив список, \n",
    "# который мы получаем в результате работы метода `.split()`, в множество\n",
    "pets_set = set(input('Введите через пробел названия животных, которых вы хотите завести? ').split())\n",
    "print(pets_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "o6f8LUT3XHv0"
   },
   "source": [
    "Создать множество из списка или другой последовательности — самый простой способ посчитать количество уникальных элементов в них. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "executionInfo": {
     "elapsed": 757,
     "status": "ok",
     "timestamp": 1601207066376,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "ATrdJ8heU-KY",
    "outputId": "b5e71590-2554-4cbe-afb9-eb90f891482c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Список покупок: хлеб молоко молоко корм для рыбок\n",
      "Множество покупок: молоко корм для рыбок хлеб\n",
      "В списке покупок 4 пункта, но только 3 из них уникальны.\n"
     ]
    }
   ],
   "source": [
    "shopping_list = ['хлеб', 'молоко', 'молоко', 'корм для рыбок']\n",
    "shopping_set = set(shopping_list)          # Превращаем список в множество, с помощью функции set()\n",
    "\n",
    "print('Список покупок:', *shopping_list)\n",
    "print('Множество покупок:', *shopping_set) # С множествами тоже работает распаковка через *\n",
    "\n",
    "print(f'В списке покупок {len(shopping_list)} пункта, но только {len(shopping_set)} из них уникальны.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ERvCJpsmyWrB"
   },
   "source": [
    "Множество можно сделать и из строки. В этом случае, мы получим множество символов строки, потому что, с точки зрения Python, элементом строки будет ее символ. Давайте проверим, сколько уникальных букв в скороговорке."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "executionInfo": {
     "elapsed": 866,
     "status": "ok",
     "timestamp": 1601230761212,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "grSsX63PYJCR",
    "outputId": "02aca422-d50f-4bcc-b61c-aabd8653884d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Скороговорка: Карл у Клары украл кораллы\n",
      "Множество букв в скороговорке: о, а, л, у, ы, к, р\n",
      "В нашей скороговорке 22 буквы, но только 7 из них уникальны.\n"
     ]
    }
   ],
   "source": [
    "twister = 'Карл у Клары украл кораллы'\n",
    "twister_letters = twister.replace(' ', '').lower()  # Приводим нашу строку к нижнему регистру и очищаем от пробелов\n",
    "\n",
    "twister_set = set(twister_letters)                  # Превращаем нашу очищенную строку в множество\n",
    "\n",
    "print('Скороговорка:', twister)\n",
    "print('Множество букв в скороговорке:', ', '.join(twister_set)) # И метод строк .join() тоже работает \n",
    "                                                                # с множеством, состоящим из строк\n",
    "\n",
    "print(f'В нашей скороговорке {len(twister_letters)} буквы, но только {len(twister_set)} из них уникальны.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GENzzU0rdTP7"
   },
   "source": [
    "## Методы множеств\n",
    "\n",
    "У множеств есть свои методы. Самые важные для нас это `.add()`, который позволяет добавить элемент в множество, и `.remove()`, который элемент удалит."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 729,
     "status": "ok",
     "timestamp": 1601208860737,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "-oxj9gJ8ca-h",
    "outputId": "037c0562-0146-4320-d1e5-2009052e0289"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Животные, которых хотим завести: морская свинка, кошка, собака, хомячок, рыбка, питон\n",
      "Животные, которых хотим завести: кошка, собака, рыбка, питон\n"
     ]
    }
   ],
   "source": [
    "pets_set =  {'собака', 'кошка', 'хомячок', 'рыбка', 'морская свинка'}\n",
    "pets_set.add('питон')  # Решили добавить питона во множество животных, которых хотим завести\n",
    "\n",
    "print('Животные, которых хотим завести:', ', '.join(pets_set))  # Выведем обновленное множество\n",
    "\n",
    "# Начали переживать, что питон съест хомячка и морскую свинку и решили их не заводить\n",
    "pets_set.remove('хомячок')        # Удаляем хомяка из множества\n",
    "pets_set.remove('морская свинка') # Удаляем морскую свинку из множества\n",
    "\n",
    "print('Животные, которых хотим завести:', ', '.join(pets_set))  # Выведем итоговое множество"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GDaMPlFoyq3I"
   },
   "source": [
    "Подробнее про методы множеств можно почитать в [документации](https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "uxzU7kAiIrMQ"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4yef-bLboqId"
   },
   "source": [
    "# Операции над множествами\n",
    "\n",
    "## Операции над множествам\n",
    "\n",
    "Еще одно очень полезное свойство множеств в Python — возможность выполнять операции над множествами, которые вам могут быть знакомы из математики или логики. Это операции *объединения*, *пересечения* и *разности*. \n",
    "\n",
    "Например, с их помощью мы можем решить следующие задачи:\n",
    "* получим список всех студентов, которые записались хотя бы на один из трех курсов по выбору (*объединение множеств студентов, записавшихся на каждый из курсов*);\n",
    "* выберем время для консультации, которое удобно всем студентам (*пересечение множеств временных интервалов, которые указал каждый студент как удобные*);\n",
    "* получим перечень продуктов, которые нужно докупить, чтобы приготовить шоколадный торт (*разность продуктов, перечисленных в рецепте, и тех, которые есть дома*).\n",
    "\n",
    "Давайте разбираться, как эти операции реализованы в Python.\n",
    "\n",
    "Представим, что вы и ваш друг снимаете квартиру, и вы решили завести домашнее животное. Хозяева согласны, но только одно! Каждый из вас составил список животных, на которых он согласен. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 710,
     "status": "ok",
     "timestamp": 1601759157999,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "S3OoyMDnSDLl",
    "outputId": "59d18ffc-244a-4c26-fe11-32b76a62d419"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Животные, которых хочу завести я: ужик кошка шиншилла рыбка\n",
      "Животные, которых хочет завести мой друг: ужик питон собака кошка хамелеон\n"
     ]
    }
   ],
   "source": [
    "my_pets_list = {'кошка', 'рыбка', 'шиншилла', 'ужик'}\n",
    "friend_pets_list = {'собака', 'питон', 'ужик', 'кошка', 'хамелеон'}\n",
    "\n",
    "print(f'Животные, которых хочу завести я:', *my_pets_list)\n",
    "print(f'Животные, которых хочет завести мой друг:', *friend_pets_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WjWtOvf5T9FA"
   },
   "source": [
    "Множества удобно представлять в виде диаграмм Эйлера — Венна, и мы тоже будем ими пользоваться.  \n",
    "\n",
    "<img src='https://github.com/rogovich/Data/blob/master/img/eiler_1.png?raw=true' width=\"300\">\n",
    "\n",
    "\n",
    "\n",
    "* Зеленый круг — животные, которых хотите завести вы. \n",
    "* Оранжевый круг — животные, которых хочет завести ваш друг.\n",
    "* Голубая область на пересечении кругов — животные, которых хотите завести вы оба."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KNCAm84ZpdSN"
   },
   "source": [
    "## Объединение\n",
    "\n",
    "Операция *объединения* множеств A и B создает множество, содержащее все уникальные элементы входящие в оба множества.\n",
    "\n",
    "<img src='https://github.com/rogovich/Data/blob/master/img/eiler_2.png?raw=true' width=\"300\">\n",
    "\n",
    "В нашем примере объединением будет список всех животных, которых хотя бы кто-то из вас не против завести\n",
    "\n",
    "В Python объедение множеств можно получить двумя способами\n",
    "* `A | B` — с помощью оператора объединения `|` (вертикальная черта)\n",
    "* `A.union(B)` — с помощью метода множеств `.union()`, который вызывается от одного множества и берет аргументом второе.\n",
    "\n",
    "Какой бы способ вы ни использовали, для операции объединения порядок множеств не важен. Так, результат объединения `A | B` совпадёт с результатом объединения `B | A`.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 744,
     "status": "ok",
     "timestamp": 1601761421149,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "HDzSOTjAoYsd",
    "outputId": "6d7a1526-0b37-4151-c92d-1a83c3fc904c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Животные, которых мы не против завести: {'ужик', 'питон', 'рыбка', 'собака', 'кошка', 'хамелеон', 'шиншилла'}\n",
      "Животные, которых мы не против завести: {'ужик', 'питон', 'рыбка', 'собака', 'кошка', 'хамелеон', 'шиншилла'}\n"
     ]
    }
   ],
   "source": [
    "my_pets_list = {'кошка', 'рыбка', 'шиншилла', 'ужик'}\n",
    "friend_pets_list = {'собака', 'питон', 'ужик', 'кошка', 'хамелеон'}\n",
    "\n",
    "# Находим объединение с помощью оператора `|`\n",
    "print(f'Животные, которых мы не против завести: {my_pets_list | friend_pets_list}')\n",
    "\n",
    "# Находим объединение с помощью метода `.union()`\n",
    "print(f'Животные, которых мы не против завести: {my_pets_list.union(friend_pets_list)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "J1Ynb-cesUDh"
   },
   "source": [
    "## Пересечение\n",
    "\n",
    "Операция *пересечения* множеств A и B создает множество, содержащее только те элементы, которые одновременно входят и в A, и в B.\n",
    "\n",
    "В нашем примере пересечением будут те животные, которых одновременно хотите завести и вы, и ваш друг — голубая область на рисунке.\n",
    "\n",
    "<img src='https://github.com/rogovich/Data/blob/master/img/eiler_1.png?raw=true' width=\"300\">\n",
    "\n",
    "В Python пересечение множеств можно получить двумя способами\n",
    "* `A & B` — с помощью оператора пересечения `&` (амперсанд)\n",
    "* `A.intersection(B)` — с помощью метода множеств `.intersection()`, который вызывается от одного множества и берет аргументом второе.\n",
    "\n",
    "Как и в случае с объединением множеств, порядок множеств для операции пересечения не важен.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 656,
     "status": "ok",
     "timestamp": 1601761414291,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "I4jp7Fc9rx5v",
    "outputId": "8b6dbc43-5483-4963-e23d-6c9b6e6eeb82"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Животные, которые нравятся нам обоим: {'ужик', 'кошка'}\n",
      "Животные, которые нравятся нам обоим: {'ужик', 'кошка'}\n"
     ]
    }
   ],
   "source": [
    "my_pets_list = {'кошка', 'рыбка', 'шиншилла', 'ужик'}\n",
    "friend_pets_list = {'собака', 'питон', 'ужик', 'кошка', 'хамелеон'}\n",
    "\n",
    "# Находим пересечение с помощью оператора `&`\n",
    "print(f'Животные, которые нравятся нам обоим: {my_pets_list & friend_pets_list}')\n",
    "\n",
    "# Находим объединение с помощью метода `.intersection()`\n",
    "print(f'Животные, которые нравятся нам обоим: {my_pets_list.intersection(friend_pets_list)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JzEYkU8DvB5g"
   },
   "source": [
    "## Разность \n",
    "\n",
    "Операция *разности* множеств A и B создает множество, содержащее только те элементы, которые входят в A, но не входят в B (или наоборот).\n",
    "\n",
    "В нашем примере результатом разности множеств будет либо множество животных, которые нравятся вам, но не нравятся вашему другу, и наоборот.\n",
    "\n",
    "Животные, которые нравятся мне и не нравятся другу:  \n",
    "<img src='https://github.com/rogovich/Data/blob/master/img/eiler_4.png?raw=true' width=\"300\">\n",
    "\n",
    "Животные, которые нравятся другу и не нравятся мне:  \n",
    "<img src='https://github.com/rogovich/Data/blob/master/img/eiler_3.png?raw=true' width=\"300\">\n",
    "\n",
    "В Python разность множеств можно получить двумя способами\n",
    "* `A - B` — с помощью оператора `-` \n",
    "* `A.difference(B)` — с помощью метода множеств `.difference()`, который вызывается от одного множества и берет аргументом второе.\n",
    "\n",
    "**ВАЖНО!** В отличии от операций объединения и пересечения, для операции разности важен порядок элементов. Так `A - B` вернет множество только тех элементов, которые входят в A, но не входят в B. А `B - A` — наоборот.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 718,
     "status": "ok",
     "timestamp": 1601761695627,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "YUQH3j2QNZe3",
    "outputId": "24bcb89f-6f8e-41f8-cd1e-79ac3e508a68"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Животные, которые нравятся мне, но не нравятся другу: {'шиншилла', 'рыбка'}\n",
      "Животные, которые нравятся другу, но не нравятся мне: {'питон', 'хамелеон', 'собака'}\n"
     ]
    }
   ],
   "source": [
    "my_pets_list = {'кошка', 'рыбка', 'шиншилла', 'ужик'}\n",
    "friend_pets_list = {'собака', 'питон', 'ужик', 'кошка', 'хамелеон'}\n",
    "\n",
    "# Находим разность с помощью оператора `-`\n",
    "print(f'Животные, которые нравятся мне, но не нравятся другу: {my_pets_list - friend_pets_list}')\n",
    "\n",
    "# Находим разность с помощью метода `.difference()`\n",
    "# Обратите внимание, что мы поменяли наши множества местами и результат изменится\n",
    "print(f'Животные, которые нравятся другу, но не нравятся мне: {friend_pets_list.difference(my_pets_list)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5D2CGOAn32pB"
   },
   "source": [
    "## Симметрическая разность\n",
    "\n",
    "Иногда нам нужно найти все элементы, входящие в A или в B, но не в оба из них одновременно.\n",
    "\n",
    "В нашем примере это те животные, которых мы точно не заведем (они не нравятся кому-то из вас, а значит в шорт-лист точно не попадут).\n",
    "\n",
    "<img src='https://github.com/rogovich/Data/blob/master/img/eiler_5.png?raw=true' width=\"300\">\n",
    "\n",
    "Операция, которая возвращает нам такое множество, называется операцией *симметрической разности*.\n",
    "\n",
    "В Python симметрическую разность множеств можно получить двумя способами\n",
    "\n",
    "* `A ^ B` — с помощью оператора `^`\n",
    "* `A.symmetric_difference(B)` — с помощью метода множеств `.symmetric_difference()`, который вызывается от одного множества и берет аргументом второе.\n",
    "\n",
    "Здесь, в отличие от разности, порядок множеств опять не важен."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 662,
     "status": "ok",
     "timestamp": 1601762109185,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "TkOBjFv5NpfI",
    "outputId": "0af4fc5b-3e51-4c72-ecf8-635e2a2b36e1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Этих животных мы точно заводить не будем: {'питон', 'рыбка', 'хамелеон', 'собака', 'шиншилла'}\n",
      "Этих животных мы точно заводить не будем: {'питон', 'рыбка', 'хамелеон', 'собака', 'шиншилла'}\n"
     ]
    }
   ],
   "source": [
    "my_pets_list = {'кошка', 'рыбка', 'шиншилла', 'ужик'}\n",
    "friend_pets_list = {'собака', 'питон', 'ужик', 'кошка', 'хамелеон'}\n",
    "\n",
    "# Находим симметрическую разность с помощью оператора `^`\n",
    "print(f'Этих животных мы точно заводить не будем: {my_pets_list ^ friend_pets_list}')\n",
    "\n",
    "# Находим симметрическую разность с помощью метода `.symmetric_difference()`\n",
    "print(f'Этих животных мы точно заводить не будем: {my_pets_list.symmetric_difference(friend_pets_list)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xj5PYsvH5o90"
   },
   "source": [
    "Если вдруг вам так проще, то симметрическую разность можно представить как разность между объединением и пересечением множеств A и B :) Или как объединение разностей `A - B` и `B - A`.\n",
    "\n",
    "Мы можем выполнять операции над множествами последовательно в одной строке. Операции будут выполняться слева направо, никаких особых приоритетов у операций нет (таких как, например, приоритет умножения над сложением в арифметике). Поэтому не забудьте расставить скобки для определения приоритета операций, если это требуется.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "executionInfo": {
     "elapsed": 686,
     "status": "ok",
     "timestamp": 1601762085392,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "RSeAyBkE4zWh",
    "outputId": "bd3f9cbe-e67c-4b86-845e-afc80fd586c0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Этих животных мы точно заводить не будем: {'питон', 'рыбка', 'собака', 'хамелеон', 'шиншилла'}\n"
     ]
    }
   ],
   "source": [
    "my_pets_list = {'кошка', 'рыбка', 'шиншилла', 'ужик'}\n",
    "friend_pets_list = {'собака', 'питон', 'ужик', 'кошка', 'хамелеон'}\n",
    "\n",
    "# Найдем симметрическую разность, как разность объединения и пересечения двух множеств\n",
    "# Обратите внимание, что сейчас скобки расставлены корректно и порядок действий правильный\n",
    "pets_sym_diff = (my_pets_list | friend_pets_list) - (my_pets_list & friend_pets_list)\n",
    "print(f'Этих животных мы точно заводить не будем: {pets_sym_diff}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qg_V6aQ2YhuU"
   },
   "source": [
    "Давайте разберем по шагам, как сработало наше выражение   \n",
    "`(my_pets_list | friend_pets_list) - (my_pets_list & friend_pets_list)`\n",
    "\n",
    "* Сначала вычислим объединение двух множеств в первых скобках — всех животных, которых хотя бы один из вас не против завести. \n",
    "`my_pets_list | friend_pets_list`  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 810,
     "status": "ok",
     "timestamp": 1601762229740,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "uF5evWUgYudj",
    "outputId": "56a91f24-1f2f-4cac-9b8a-6eeca10b7a25"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Шаг 1. Объединение множеств my_pets_list | friend_pets_list:\n",
      "{'ужик', 'питон', 'рыбка', 'собака', 'кошка', 'хамелеон', 'шиншилла'}\n"
     ]
    }
   ],
   "source": [
    "my_pets_list = {'кошка', 'рыбка', 'шиншилла', 'ужик'}\n",
    "friend_pets_list = {'собака', 'питон', 'ужик', 'кошка', 'хамелеон'}\n",
    "\n",
    "pets_union = my_pets_list | friend_pets_list\n",
    "\n",
    "print(f'Шаг 1. Объединение множеств my_pets_list | friend_pets_list:\\n{pets_union}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0wDgaSR1YzZ4"
   },
   "source": [
    "* Теперь вычислим пересечение двух множеств во вторых скобках — те животные, которые нравятся одновременно вам обоим.\n",
    "`my_pets_list & friend_pets_list`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 86
    },
    "executionInfo": {
     "elapsed": 805,
     "status": "ok",
     "timestamp": 1601846480070,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "PMZgFEh-Y_Vt",
    "outputId": "7c3fc415-de0f-4683-b554-f46b10d2ffaf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Шаг 1. Объединение множеств my_pets_list и friend_pets_list:\n",
      "{'ужик', 'питон', 'рыбка', 'собака', 'кошка', 'хамелеон', 'шиншилла'}\n",
      "Шаг 2. Пересечение множеств my_pets_list и friend_pets_list:\n",
      "{'ужик', 'кошка'}\n"
     ]
    }
   ],
   "source": [
    "my_pets_list = {'кошка', 'рыбка', 'шиншилла', 'ужик'}\n",
    "friend_pets_list = {'собака', 'питон', 'ужик', 'кошка', 'хамелеон'}\n",
    "\n",
    "pets_union = my_pets_list | friend_pets_list\n",
    "\n",
    "print(f'Шаг 1. Объединение множеств my_pets_list и friend_pets_list:\\n{pets_union}')\n",
    "\n",
    "pets_intersection = my_pets_list & friend_pets_list\n",
    "print(f'Шаг 2. Пересечение множеств my_pets_list и friend_pets_list:\\n{pets_intersection}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pyPAtzNiZDf2"
   },
   "source": [
    "* Теперь найдем разность объединения множеств `pets_union` и пересечения множеств `pets_intersection` — животные, которые нравятся хоть кому-то из вас, минус животные, которые нравятся вам обоим одновременно. Это и есть симметрическая разность по определению."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 137
    },
    "executionInfo": {
     "elapsed": 634,
     "status": "ok",
     "timestamp": 1601846589368,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "7g0YmF4_ZObh",
    "outputId": "e5e16842-fb81-41fa-ad8a-721ae3261fb4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Шаг 1. Объединение множеств my_pets_list и friend_pets_list:\n",
      "{'ужик', 'питон', 'рыбка', 'собака', 'кошка', 'хамелеон', 'шиншилла'}\n",
      "Шаг 2. Пересечение множеств my_pets_list и friend_pets_list:\n",
      "{'ужик', 'кошка'}\n",
      "Шаг 3. Симметрическая разность my_pets_list и friend_pets_list:\n",
      "{'питон', 'рыбка', 'собака', 'хамелеон', 'шиншилла'}\n",
      "В симметрической разности этих двух множеств 5 элементов.\n"
     ]
    }
   ],
   "source": [
    "my_pets_list = {'кошка', 'рыбка', 'шиншилла', 'ужик'}\n",
    "friend_pets_list = {'собака', 'питон', 'ужик', 'кошка', 'хамелеон'}\n",
    "\n",
    "pets_union = my_pets_list | friend_pets_list\n",
    "\n",
    "print(f'Шаг 1. Объединение множеств my_pets_list и friend_pets_list:\\n{pets_union}')\n",
    "\n",
    "pets_intersection = my_pets_list & friend_pets_list\n",
    "print(f'Шаг 2. Пересечение множеств my_pets_list и friend_pets_list:\\n{pets_intersection}')\n",
    "\n",
    "pets_sym_diff = pets_union - pets_intersection\n",
    "print(f'Шаг 3. Симметрическая разность my_pets_list и friend_pets_list:', pets_sym_diff, sep='\\n')\n",
    "print(f'В симметрической разности этих двух множеств {len(pets_sym_diff)} элементов.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5Nsvlfw-6h0z"
   },
   "source": [
    "Давайте посмотрим, что получится, если скобки не расставлять и записать все действия подряд:  \n",
    "`my_pets_list | friend_pets_list - my_pets_list & friend_pets_list`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "executionInfo": {
     "elapsed": 699,
     "status": "ok",
     "timestamp": 1601809487867,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "iSkjE9Ke6cgp",
    "outputId": "6bb889ac-d95d-4a21-b575-71439512ee41"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Это НЕ симметрическая разность my_pets_list и friend_pets_list:\n",
      "{'ужик', 'питон', 'кошка', 'рыбка', 'хамелеон', 'собака', 'шиншилла'}\n",
      "В этом множестве 7 элементов\n"
     ]
    }
   ],
   "source": [
    "pets_sym_diff_error = my_pets_list | friend_pets_list - my_pets_list & friend_pets_list\n",
    "print(f'Это НЕ симметрическая разность my_pets_list и friend_pets_list:', pets_sym_diff_error, sep='\\n')\n",
    "print(f'В этом множестве {len(pets_sym_diff_error)} элементов')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FF6dr34UYXNA"
   },
   "source": [
    "Здесь мы сначала нашли объединение ` my_pets_list | friend_pets_list` (как и в правильном порядке действий), потом разность этого пересечения с множеством `my_pets_list` и эту разность пересекли с множеством `friend_pets_list`. Как мы видим, порядок действий нарушился и ответ получился неправильный — симметрическую разность таким образом мы не нашли.\n",
    "\n",
    "Попробуйте разобрать этот код по шагам и посмотреть, какие множества получаются на каждом шаге."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DzwcvgQQfZjZ"
   },
   "source": [
    "## Так кого же заведем?\n",
    "\n",
    "Как вы уже поняли, заводить мы будем кого-то из тех животных, которые попали в пересечение множеств животных, которые нравятся и вам и вашему другу."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "executionInfo": {
     "elapsed": 625,
     "status": "ok",
     "timestamp": 1601846670916,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "VOR3hl_dfnEq",
    "outputId": "ef9e928c-0057-4dcd-8ad1-e00b4662c875"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Будем выбирать из: {'ужик', 'кошка'}\n"
     ]
    }
   ],
   "source": [
    "my_pets_list = {'кошка', 'рыбка', 'шиншилла', 'ужик'}\n",
    "friend_pets_list = {'собака', 'питон', 'ужик', 'кошка', 'хамелеон'}\n",
    "\n",
    "pets_short_list = my_pets_list & friend_pets_list\n",
    "print(f'Будем выбирать из: {pets_short_list}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "96CRZZvMf_m2"
   },
   "source": [
    "Тут ваш друг напомнил вам про такое прекрасное животное как черепашка. Так как черепашки нравятся вам обоим вы немедленно добавили ее в шорт-лист."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "executionInfo": {
     "elapsed": 681,
     "status": "ok",
     "timestamp": 1601846673058,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "YS0BTaOLfzLn",
    "outputId": "29ca790e-d9d6-4390-f1c9-b5ab64808a4e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Будем выбирать из: {'ужик', 'черепашка', 'кошка'}\n"
     ]
    }
   ],
   "source": [
    "pets_short_list.add('черепашка')\n",
    "print(f'Будем выбирать из: {pets_short_list}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "C38jooptgpAX"
   },
   "source": [
    "Вы решили отправить список финалистов на роль вашего нового питомца на утверждение хозяевам квартиры. Они все еще не против животных, но теперь поставили условие, что животное обязательно должно жить в аквариуме или клетке. Никаких кошек!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 86
    },
    "executionInfo": {
     "elapsed": 628,
     "status": "ok",
     "timestamp": 1601846675836,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "z5Xdo-nQgV14",
    "outputId": "2226691a-b384-4ca9-e929-02c2920ef692"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Кто из животных, которые нравятся нам обоим, может жить в клетке:\n",
      "set()\n",
      "Кто из животных, которые нравятся нам обоим, может жить в аквариуме:\n",
      "{'ужик', 'черепашка'}\n"
     ]
    }
   ],
   "source": [
    "pets_cage = {'шиншилла', 'хомячок', 'морская свинка', 'попугайчик', 'канарейка'}\n",
    "pets_aquarium = {'ужик', 'рыбка', 'хамелено', 'питон', 'черепашка', 'улитка'}\n",
    "\n",
    "# В выводе увидим пустое множество, потому что ни одно из наших животных не может жить в клетке\n",
    "print(f'Кто из животных, которые нравятся нам обоим, может жить в клетке:\\n{pets_short_list & pets_cage}') \n",
    "\n",
    "print(f'Кто из животных, которые нравятся нам обоим, может жить в аквариуме:\\n{pets_short_list & pets_aquarium}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rjw7mO8ZiEB9"
   },
   "source": [
    "Ну что ж, покупаем аквариум и выбираем из двух вариантов: ужик или черепашка."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 3935,
     "status": "ok",
     "timestamp": 1601763714468,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "R6ofrHmHhzVD",
    "outputId": "836fd181-1366-49c3-9d1d-76fc31d16ec0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ну что, кто здесь лишний? черепашка\n",
      "Решено! Наше домашнее животное — ужик\n"
     ]
    }
   ],
   "source": [
    "# Пересечение множеств животных из нашего шорт-листа и животных, которые могут жить в аквариуме, — \n",
    "# итоговое множество, из которого будем выбирать\n",
    "pets_final = pets_short_list & pets_aquarium  \n",
    "\n",
    "pet = input('Ну что, кто здесь лишний? ')\n",
    "pets_final.remove(pet) # Удалим введенное животное из множества финалистов\n",
    "\n",
    "print('Решено! Наше домашнее животное —', *pets_final)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kBtO_thhIuD7"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "C0Axwut1I651"
   },
   "source": [
    "# Словари\n",
    "Очень часто мы храним информацию парами: логин и пароль, имя человека с его номером телефона, слово и его перевод. В таких данных удобно искать соответствия: например, так мы используем словарь, чтобы найти перевод какого-то слова на другой язык."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pQD1utaE0jW3"
   },
   "source": [
    "Давайте попробуем написать программу-словарь: чтобы человек вводил слово на английском языке, а программа ему выдавала — на русском. \n",
    "Для этого:\n",
    "1. Создадим два списка и договоримся, что слова с одинаковыми индексами являются переводами друг для друга.\n",
    "2. Заполним эти списки словами на двух языках.\n",
    "3. Узнаем, перевод какого слова нужен.\n",
    "4. Пройдёмся по всем словам в списке английских слов.\n",
    "    * Если мы нашли слово, перевод которого требуется\n",
    "        * Выведем перевод на экран.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 53
    },
    "executionInfo": {
     "elapsed": 6036,
     "status": "ok",
     "timestamp": 1600359281458,
     "user": {
      "displayName": "Дмитрий Широков",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gj5ZAs-5dMegnzmhLzTxoLXJmKnF6n7i3ZxETt9Vw=s64",
      "userId": "13642431705883450455"
     },
     "user_tz": -180
    },
    "id": "ubd-y3ut1B72",
    "outputId": "784739b7-8a29-4558-fd8e-652936a38bd3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Перевод какого английского слова вам нужен? world\n",
      "Перевод слова world на русский: мир.\n"
     ]
    }
   ],
   "source": [
    "eng = ['apple', 'hello', 'world']\n",
    "rus = ['яблоко', 'привет', 'мир']\n",
    "\n",
    "word = input('Перевод какого английского слова вам нужен? ')\n",
    "for i in range(len(eng)):\n",
    "    if eng[i] == word:\n",
    "        print(f'Перевод слова {word} на русский: {rus[i]}.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bAK3vsZV2Pjp"
   },
   "source": [
    "*Выглядит сложно.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7V_3mp113c52"
   },
   "source": [
    "Так как задача \"найти информацию по ключевому слову\" встаёт перед программистами очень часто, они придумали для этого специальную строктуру данных — словарь. \n",
    "\n",
    "Словарь, как и множество, является ***коллекцией*** данных, а значит, что в нем данные тоже ***не упорядочены по порядковому индексу***."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KYF8bdu4u-kp"
   },
   "source": [
    "Создать пустой словарь можно или с помощью пустых фигурных скобок `{}` или с помощью функции `dict()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 717,
     "status": "ok",
     "timestamp": 1601229929941,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "pOkNnXIT84GA",
    "outputId": "4e176949-2ca9-4ea1-a402-31b92ac1e74e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "empty_dict_1 = {}           # Пустой словарь\n",
    "empty_dict_2 = dict()       # И еще один пустой словарь\n",
    "print(empty_dict_1)  \n",
    "print(type(empty_dict_2))   # Python видит словарь как тип данных dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pwnltGYPvmUj"
   },
   "source": [
    "Мы уже встречали фигурные скобки, когда говорили о множествах. Как Python не путает эти структуры данных? Когда мы создаем множество, то мы внутри фигурных скобок перечисляем элементы множества через запятую. В словаре информация хранится всегда парами, которые мы задаем через `:`. И уже эти пары мы перечисляем. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 626,
     "status": "ok",
     "timestamp": 1601230194442,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "27mvn8IYv-SF",
    "outputId": "89f93359-8289-47e4-e06d-c6c9a95feece"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "В переменной eng хранится <class 'set'>\n",
      "В переменной eng_rus хранится <class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "eng = {'apple', 'hello', 'world'} # создадим множество\n",
    "eng_rus = {'apple': 'яблоко', 'hello': 'привет', 'world': 'мир'} # создадим словарь\n",
    "\n",
    "# В словаре одним элементом является пара элементов, разделенных `:`\n",
    "\n",
    "print(f'В переменной eng хранится {type(eng)}')\n",
    "print(f'В переменной eng_rus хранится {type(eng_rus)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RYK4tXC6vY-e"
   },
   "source": [
    "Мы уже сказали, что словарь — неупорядоченная структура данных, а значит с ним не работает индексация. Но в отличие от множества, мы все-таки можем обратиться к элементу внутри словаря напрямую.\n",
    "\n",
    "Пара элементов в словаре называется ***парой ключ:значение***. Так элемент, которые идет до `:` — это ключ (например `'apple'` в паре `'apple': 'яблоко'`), а элемент после `:` — значение (например `'яблоко'` в паре `'apple': 'яблоко'`).\n",
    "\n",
    "***И к значению пары мы можем обратиться по его ключу.***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pYi5EoP-9Hlf"
   },
   "source": [
    "Давайте посмотрим, как выглядела бы наша программа для перевода английских слов на русский язык, если бы использовали словарь:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "executionInfo": {
     "elapsed": 776,
     "status": "ok",
     "timestamp": 1601901371328,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "VOxJHvnb2dUD",
    "outputId": "94361c5c-c24a-4d3f-b3c5-e9b5f05ce004"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Перевод слова apple на русский: яблоко.\n"
     ]
    }
   ],
   "source": [
    "eng_rus = {'apple': 'яблоко', 'hello': 'привет', 'world': 'мир'}\n",
    "\n",
    "word = 'apple'             # Перевод какого слова хотим получить\n",
    "translate = eng_rus[word]  # Находим перевод для слова, хранящегося в переменной `word`\n",
    "\n",
    "print(f'Перевод слова {word} на русский: {translate}.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eeSxYwd727qL"
   },
   "source": [
    "\n",
    "\n",
    "Разберём пример выше:\n",
    "1. Мы создаём словарь ``eng_rus``. Словарь оформляется фигурными скобками `{}`, внутри которых указываются *ключи* и, через двоеточие, *значение*. Так в нашем словаре ключи это: `'apple', 'hello', 'world'`, а значения: `'яблоко', 'привет', 'мир''\n",
    "\n",
    "2. Выражением `translate = eng_rus[word]` мы просим компьютер найти в словаре слово ``'apple'``, которое мы сохранили в переменную, и сохранить его перевод в переменную `translate`. Квадратные скобки работают здесь так же, как и в списках и строках, только вместо числа-*индекса* здесь слово-*ключ*.\n",
    "3. В третьей строке мы, как и в прошлом примере, вывели перевод на экран."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FbhyCFwl5J3S"
   },
   "source": [
    "Попробуем вернуть интерактивность в программу — спросим у пользователя, перевод какого слова ему нужен:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 217
    },
    "executionInfo": {
     "elapsed": 2386,
     "status": "error",
     "timestamp": 1601928648845,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "T5Fx3PjR5PMh",
    "outputId": "a447aa24-c6dd-4491-dea4-cbe795aff47d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Перевод какого английского слова вам нужен? 2\n"
     ]
    },
    {
     "ename": "KeyError",
     "evalue": "ignored",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-93a9ce643728>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0meng_rus\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m'apple'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'яблоко'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'hello'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'привет'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'world'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'мир'\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mword\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Перевод какого английского слова вам нужен? '\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf'Перевод слова {word} на русский: {eng_rus[word]}.'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: '2'"
     ]
    }
   ],
   "source": [
    "eng_rus = {'apple': 'яблоко', 'hello': 'привет', 'world': 'мир'}\n",
    "word = input('Перевод какого английского слова вам нужен? ')\n",
    "print(f'Перевод слова {word} на русский: {eng_rus[word]}.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DpjYAyIF6UQ_"
   },
   "source": [
    "Как видно из ошибки выше, если в словаре нет элемента с нужным нам ключом, то возникнет ошибка ``KeyError``, аналогичная ошибке ``IndexError``, которая возникала при отсутствии буквы в строке или элемента в списке (кортеже).\n",
    "\n",
    "Исправим программу так, чтобы компьютер перед попыткой найти перевод для слова проверял, что оно (вместе с переводом) добавлено к словарю:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 7724,
     "status": "ok",
     "timestamp": 1601901790396,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "16zYo6dX6wuh",
    "outputId": "17b096b9-c4ce-46ea-ac87-9547fd01de99"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Перевод какого английского слова вам нужен? translate\n",
      "Перевода для слова translate в нашем словаре нет\n"
     ]
    }
   ],
   "source": [
    "eng_rus = {'apple': 'яблоко', 'hello': 'привет', 'world': 'мир'}\n",
    "word = input('Перевод какого английского слова вам нужен? ')\n",
    "\n",
    "if word in eng_rus:     # Если такой ключ в словаре есть\n",
    "    print(f'Перевод слова {word} на русский: {eng_rus[word]}.')\n",
    "else:\n",
    "    print(f'Перевода для слова {word} в нашем словаре нет')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Q4e0iFDU7OPC"
   },
   "source": [
    "Попробуйте запустить программу выше с каким-нибудь словом, которое является значением в нашем словаре (например, \"яблоко\"). При попытке найти слово, которое является значением в словаре, наша программа тоже будет говорить, что такого слова в словаре нет. При примении операций `in / not in` информация в словаре ищется только по **ключам**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1iVM4sor8JbM"
   },
   "source": [
    "Если нам нужен ещё и русско-английский словарь (для перевода русских слов на английский язык), нам придётся создать ещё один словарь:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 4123,
     "status": "ok",
     "timestamp": 1601901937373,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "Ht1zi7HM8R66",
    "outputId": "cbb94aac-8fbb-4bd6-e0e0-faac92ecbdfe"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Перевод какого слова вам нужен? translate\n",
      "Слова translate в наших словарях нет!\n"
     ]
    }
   ],
   "source": [
    "eng_rus = {'apple': 'яблоко', 'hello': 'привет', 'world': 'мир'}\n",
    "rus_eng = {'яблоко': 'apple', 'привет': 'hello', 'мир': 'world'}\n",
    "\n",
    "word = input('Перевод какого слова вам нужен? ')\n",
    "if word in eng_rus:     # Если такой ключ есть в англо-русском словаре\n",
    "    print(f'Перевод слова {word} на русский: {eng_rus[word]}.')\n",
    "elif word in rus_eng:   # Если такой ключ есть в русско-английском словаре\n",
    "    print(f'Перевод слова {word} на английский: {rus_eng[word]}.')\n",
    "else:\n",
    "    print(f'Слова {word} в наших словарях нет!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Z9oA5Zex_W8v"
   },
   "source": [
    "## Ключи и значения\n",
    "\n",
    "Из-за особенностей хранения словарей в памяти компьютера **ключами** словаря могут быть только неизменяемые типы данных: из знакомых нам это строки, вещественные и целые числа, логические переменные и даже кортежи. Но в наших примерах чаще всего это будут строки и целые числа. \n",
    "\n",
    "Чтобы убедиться, что все эти переменные могут быть ключами, давайте представим такой словарь: ключами будут переменные, а значениями — их определения."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 103
    },
    "executionInfo": {
     "elapsed": 778,
     "status": "ok",
     "timestamp": 1601902021065,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "HuG42uRB_aoH",
    "outputId": "a3f0fd7f-4ff7-49d0-a02d-b4e46ac73fdf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "целое число\n",
      "вещественное число\n",
      "строка\n",
      "кортеж\n",
      "целое число\n"
     ]
    }
   ],
   "source": [
    "types_dict = {True:'логическая переменная', 1:'целое число', \n",
    "              5.3:'вещественное число', 'apple':'строка', (4,3):'кортеж'}\n",
    "print(types_dict[True])     # Печатаем значение ключа True\n",
    "print(types_dict[5.3])      # Печатаем значение ключа 5.3\n",
    "print(types_dict['apple'])  # Печатаем значение ключа 'apple'\n",
    "print(types_dict[(4,3)])    # Печатаем значение ключа (4,3)\n",
    "print(types_dict[1])        # Печатаем значение ключа 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YdwmfmrmA6wx"
   },
   "source": [
    "Обратите внимание, что команда `print(types_dict[1])` не выдала ошибку. Мы говорили о том, что в словарях, как и в множествах, не работает индексация. Но в данном случае `1` это не порядковая позиция элемента, а ключ в словаре. Давайте убедимся, что если мы обратимся к другим порядковым индексам, то получим ошибку. Например, если бы мы работали со списком и в нем бы был элемент под индексом 1, то точно бы был и элемент под индексом 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 165
    },
    "executionInfo": {
     "elapsed": 650,
     "status": "error",
     "timestamp": 1601234968882,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "WYNTXK_HAz1W",
    "outputId": "6d00015f-80c1-4603-e714-5c49032dc1d1"
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "ignored",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-14-a15199ebe5ea>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtypes_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 0"
     ]
    }
   ],
   "source": [
    "print(types_dict[0])   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-K7Y_8acCq3f"
   },
   "source": [
    "Как мы видим, попытка обратиться к элементу, соответствующему нулю, завершилась ошибкой, потому что в нашем словаре нет такого ключа."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_v8wUl7oFeCp"
   },
   "source": [
    "Значениями словаря тоже могут быть не только строки. Например, как словари работают со значениями-числами: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 86
    },
    "executionInfo": {
     "elapsed": 713,
     "status": "ok",
     "timestamp": 1601902097876,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "pAYctatWFjbT",
    "outputId": "03da4686-1fb7-44c6-8c5d-ce58337bdf12"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Температура утром: 10°C.\n",
      "Температура днём: 14.5°C.\n",
      "Температура вечером: 8°C.\n",
      "Температура ночью: 3°C.\n"
     ]
    }
   ],
   "source": [
    "temperature = {'утро': 10, 'день': 14.5, 'вечер': 8, 'ночь': 3}\n",
    "print(f'Температура утром: {temperature[\"утро\"]}°C.')\n",
    "print(f'Температура днём: {temperature[\"день\"]}°C.')\n",
    "print(f'Температура вечером: {temperature[\"вечер\"]}°C.')\n",
    "print(f'Температура ночью: {temperature[\"ночь\"]}°C.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mDEdjFHSIVOe"
   },
   "source": [
    "Значениями могут быть и вещественные числа, и логические переменные, и более сложные типы данных, вроде множеств, списков, кортежей и самих словарей. Такие примеры мы встретим уже совсем скоро."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "N4SCFgRMI3uF"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GeAQ0A8mvTr3"
   },
   "source": [
    "# Добавление элементов в словарь и поиск по словарю\n",
    "\n",
    "Мы научились задавать словарь внутри программы, а теперь давайте научимся добавлять элементы в существующий словарь и перебирать его ключи и значения.\n",
    "\n",
    "Представим, что мы обрабатываем информацию о книгах в библиотеке, и для каждой книги мы знаем её автора. Теперь мы можем хранить такую информацию в словаре, где ключами идут названия книг, а значениями — имена авторов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 632,
     "status": "ok",
     "timestamp": 1601935086161,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "lkculHTRrXFI",
    "outputId": "ed234b06-8e6e-4dee-b28f-243bba7b24b7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Сейчас в библиотеке есть книги: \n",
      "{'Мы': 'Евгений Замятин', '1984': 'Джордж Оруэлл', 'Brave New World': 'Олдос Хаксли'}\n"
     ]
    }
   ],
   "source": [
    "# Словарь, в котором мы для каждой книги помним её автора \n",
    "books = {'Мы': 'Евгений Замятин',\n",
    "         '1984': 'Джордж Оруэлл',\n",
    "         'Brave New World': 'Олдос Хаксли'}\n",
    "\n",
    "print(f'Сейчас в библиотеке есть книги: \\n{books}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rZcTlTKjnBzG"
   },
   "source": [
    "С помощью функции `len()` мы можем узнать количество элементов (пар `ключ:значение` в нашем словаре`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "executionInfo": {
     "elapsed": 688,
     "status": "ok",
     "timestamp": 1601935152016,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "IeGV53YenMU7",
    "outputId": "69571fe8-2479-49bb-876e-3bacb1fe1b49"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Сейчас в библиотеке 3 книги\n"
     ]
    }
   ],
   "source": [
    "books = {'Мы': 'Евгений Замятин',\n",
    "         '1984': 'Джордж Оруэлл',\n",
    "         'Brave New World': 'Олдос Хаксли'}\n",
    "\n",
    "print(f'Сейчас в библиотеке {len(books)} книги')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-va4v6hnwIJM"
   },
   "source": [
    "Мы можем отдельно посмотреть все названия книг, если прочитаем отдельно все ключи нашего слова с помощью метода словарей `.keys()`. Посмотрим, как его видит Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 677,
     "status": "ok",
     "timestamp": 1601935154593,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "ngbvqvz7w1qg",
    "outputId": "9f1a5285-211f-4c15-f541-e4a87db3815c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['Мы', '1984', 'Brave New World'])\n",
      "<class 'dict_keys'>\n"
     ]
    }
   ],
   "source": [
    "print(books.keys())\n",
    "print(type(books.keys()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hpmk_ElPa8WB"
   },
   "source": [
    "Хоть вывод и похож на список, но мы не можем обратиться к какому-либо элементу по его индексу:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 188
    },
    "executionInfo": {
     "elapsed": 755,
     "status": "error",
     "timestamp": 1601224599944,
     "user": {
      "displayName": "Дмитрий Широков",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gj5ZAs-5dMegnzmhLzTxoLXJmKnF6n7i3ZxETt9Vw=s64",
      "userId": "13642431705883450455"
     },
     "user_tz": -180
    },
    "id": "C5MjhIH-bDLD",
    "outputId": "5f006840-4abe-4b01-d0b2-0eba1381f18c"
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "ignored",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-3a4ce9ff35ff>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mtitles\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtitles\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'dict_keys' object does not support indexing"
     ]
    }
   ],
   "source": [
    "titles = books.keys()\n",
    "print(titles[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r-cgdkOtxAEQ"
   },
   "source": [
    "А вот, например, использовать этот объект для того, чтобы напечатать все наши ключи с помощью метода `.join()`, как мы делали со списками, — можем."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "executionInfo": {
     "elapsed": 625,
     "status": "ok",
     "timestamp": 1601935159251,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "1Ib0B7k6xNly",
    "outputId": "1c38ee4c-296b-43ef-d348-e8153ee26da8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "В библиотеке есть книги: Мы, 1984, Brave New World.\n"
     ]
    }
   ],
   "source": [
    "print(f'В библиотеке есть книги: {\", \".join(books.keys())}.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fTvph9o9xuj_"
   },
   "source": [
    "Так же мы можем отдельно посмотреть всех авторов, чьи книги представлены в библиотеке. Для этого мы можем запросить все *значения* нашего словаря, воспользовавшись методом словарей `.values()`. Посмотрим, как результат его работы видит Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "executionInfo": {
     "elapsed": 660,
     "status": "ok",
     "timestamp": 1601935162535,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "MQf-EatMx-nH",
    "outputId": "158c8300-326d-4fea-d185-43a9479d2f17"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict_values'>\n"
     ]
    }
   ],
   "source": [
    "print(type(books.values()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JCujR2OxyCMp"
   },
   "source": [
    "Видим, что этот объект какого-то специального типа, как и `dict_keys`, но напечатать авторов всех наших книг тоже теперь сможем."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "executionInfo": {
     "elapsed": 679,
     "status": "ok",
     "timestamp": 1601935164648,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "WS-YRVZFyKqz",
    "outputId": "70893aa3-4283-45d7-863e-d758b271de48"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "В библиотеке есть книги авторов: Евгений Замятин, Джордж Оруэлл, Олдос Хаксли.\n"
     ]
    }
   ],
   "source": [
    "print(f'В библиотеке есть книги авторов: {\", \".join(books.values())}.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XrxZ9Ej72OJ8"
   },
   "source": [
    "Мы можем перебрать ключи или значения с помощью цикла ``for``, как мы делали раньше, перебирая обычные списки. К счастью, цикл ``for`` умеет перебирать ключи и значения словарей, которые мы можем получить с помощью методов `.values()` и `.keys()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 120
    },
    "executionInfo": {
     "elapsed": 669,
     "status": "ok",
     "timestamp": 1601935169457,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "-Hi2DrXa3BJl",
    "outputId": "8c95f38d-cba8-481a-f2bd-ddf74ed5b693"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "В библиотеке есть книга автора Евгений Замятин.\n",
      "В библиотеке есть книга автора Джордж Оруэлл.\n",
      "В библиотеке есть книга автора Олдос Хаксли.\n",
      "В библиотеке есть книга с названием \"Мы\".\n",
      "В библиотеке есть книга с названием \"1984\".\n",
      "В библиотеке есть книга с названием \"Brave New World\".\n"
     ]
    }
   ],
   "source": [
    "books = {'Мы': 'Евгений Замятин',\n",
    "         '1984': 'Джордж Оруэлл',\n",
    "         'Brave New World': 'Олдос Хаксли'}\n",
    "\n",
    "for author in books.values():   # Просмотрим всех авторов, чьи имена хранятся\n",
    "                                # значениями в нашем словаре\n",
    "    print(f'В библиотеке есть книга автора {author}.')\n",
    "for title in books.keys():      # Просмотрим все книги, чьи названия хранятся\n",
    "                                # ключами в нашем словаре\n",
    "    print(f'В библиотеке есть книга с названием \"{title}\".')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "COkShhuC9RZF"
   },
   "source": [
    "В прошлый раз мы увидели, что, зная ключ, можно найти значение, которое ему соответствует."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "executionInfo": {
     "elapsed": 617,
     "status": "ok",
     "timestamp": 1601935584297,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "JnX6IkwV9XBr",
    "outputId": "1225cd13-4b8d-46ad-aa9e-bb9ea92fe1ba"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Книгу \"Мы\" написал Евгений Замятин.\n"
     ]
    }
   ],
   "source": [
    "title = \"Мы\"\n",
    "print(f'Книгу \"{title}\" написал {books[title]}.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "28wVAjof8pLy"
   },
   "source": [
    "Мы можем перебрать ключи словаря и, прямо как в цикле `for i in range()` для последовательностей, вывести значение для каждого ключа:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "executionInfo": {
     "elapsed": 558,
     "status": "ok",
     "timestamp": 1601935234383,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "6mw2fd5t8zzH",
    "outputId": "abfbcd57-e9f8-4279-d03d-d095551796d4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Евгений Замятин написал \"Мы\".\n",
      "Джордж Оруэлл написал \"1984\".\n",
      "Олдос Хаксли написал \"Brave New World\".\n"
     ]
    }
   ],
   "source": [
    "for title in books.keys():                       # Переберём названия книг, которые хранятся как ключи\n",
    "    print(f'{books[title]} написал \"{title}\".')  # и для каждого названия выведем имя автора, которое \n",
    "                                                 # хранится как значение ключа"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tuF_KsJ9_42s"
   },
   "source": [
    "При переборе ключей словаря через цикл for указание на то, что нужно перебирать именно ключи, можно опустить:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "executionInfo": {
     "elapsed": 720,
     "status": "ok",
     "timestamp": 1601935237494,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "61i3LmF_AEw_",
    "outputId": "41b7105f-2c22-4a87-d70e-144032dd53bb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Евгений Замятин написал \"Мы\".\n",
      "Джордж Оруэлл написал \"1984\".\n",
      "Олдос Хаксли написал \"Brave New World\".\n"
     ]
    }
   ],
   "source": [
    "for title in books:                               # Переберём названия книг, которые хранятся как ключи\n",
    "    print(f'{books[title]} написал \"{title}\".')   # и для каждого названия выведем имя автора, которое \n",
    "                                                  # хранится как значение ключа"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1e1pxcMgE_uw"
   },
   "source": [
    "Как и в случае с операторами `in / not in` цикл `for` обращается только к ключам словаря."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GfwFPEDU-2dt"
   },
   "source": [
    "А вот сделать так, чтобы программа по имени автора выдавала его книгу, немного сложнее. Мы будем так же перебирать ключи в цикле `for` и значение (имя автора), соответствующее каждому из ключей, сравнивать с именем автора, которого мы ищем."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 5910,
     "status": "ok",
     "timestamp": 1601935246796,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "1YQrcUB3-4wR",
    "outputId": "6af43b70-358a-4e35-9faa-8290a7e2e3c5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Введите имя и фамилию автора книги: Евгений Замятин\n",
      "Евгений Замятин написал \"Мы\".\n"
     ]
    }
   ],
   "source": [
    "books = {'Мы': 'Евгений Замятин',\n",
    "         '1984': 'Джордж Оруэлл',\n",
    "         'Brave New World': 'Олдос Хаксли'}\n",
    "\n",
    "search = input('Введите имя и фамилию автора книги: ')\n",
    "for title in books:\n",
    "    if search == books[title]: # Если искомый автор и автор книги совпадают\n",
    "        print(f'{books[title]} написал \"{title}\".')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wO8TmWNp_gJT"
   },
   "source": [
    "Сейчас программа может найти книгу, только если пользователь точно укажет имя и фамилию автора. Переделаем программу так, чтобы она могла искать и по частично указанным фамилии или имени автора. \n",
    "\n",
    "Для этого попросим компьютер искать по значениям ключей с помощью конструкции `in`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 669,
     "status": "ok",
     "timestamp": 1601935639412,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "pyyhbM4hdScN",
    "outputId": "918e8100-6767-4917-b1c6-8c7ac7530154"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "books = {'Мы': 'Евгений Замятин',\n",
    "         '1984': 'Джордж Оруэлл',\n",
    "         'Brave New World': 'Олдос Хаксли'}\n",
    "\n",
    "# Есть ли слово \"Олдос\" в имени автора книги \"Brave New World\"? Да.\n",
    "print('Олдос' in books['Brave New World']) \n",
    "\n",
    "# Есть ли слово \"Олдос\" в имени автора книги \"Мы\"? Нет.\n",
    "print('Олдос' in books['Мы'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "e5HVfUGZdoqZ"
   },
   "source": [
    "Дополним наш пример поиском по части имени автора: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 4795,
     "status": "ok",
     "timestamp": 1601935277769,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "VuKmQ-il_ont",
    "outputId": "d10e4389-ddd2-4cd9-b4cd-f82f6c557cd6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Введите имя или фамилию автора книги: Хаксли\n",
      "Олдос Хаксли написал \"Brave New World\".\n"
     ]
    }
   ],
   "source": [
    "books = {'Мы': 'Евгений Замятин',\n",
    "         '1984': 'Джордж Оруэлл',\n",
    "         'Brave New World': 'Олдос Хаксли'}\n",
    "         \n",
    "search = input('Введите имя или фамилию автора книги: ')\n",
    "for title in books:\n",
    "    if search in books[title]:  # Если часть имени искомого автора содержится в имени автора книги\n",
    "        print(f'{books[title]} написал \"{title}\".')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5L7KVe-bDJec"
   },
   "source": [
    "## Добавление элементов в словарь"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "m0OOjpLfBbgZ"
   },
   "source": [
    "Научимся добавлять элементы в словарь. Чтобы добавить элемент в словарь, достаточно указать новый ключ в квадратных скообках и присвоить ему новое значение, что гораздо проще метода `.append()`, который был нужен при работе со списками:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "executionInfo": {
     "elapsed": 632,
     "status": "ok",
     "timestamp": 1601935310590,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "NTJM68gRBu69",
    "outputId": "63243a76-1642-4be0-9a27-46c4c10581cb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Сейчас словарь пуст: {}\n",
      "Теперь в словаре есть книга: {'Муму': 'Иван Тургенев'}\n"
     ]
    }
   ],
   "source": [
    "books = {}  # Создадим пустой словарь\n",
    "print(f'Сейчас словарь пуст: {books}')\n",
    "\n",
    "# Добавим книгу \"Муму\" за авторством Ивана Тургенева\n",
    "books['Муму'] = 'Иван Тургенев'\n",
    "print(f'Теперь в словаре есть книга: {books}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-OS5LUTdeK1D"
   },
   "source": [
    "Если мы присвоим новое значение уже существующему ключу — значение изменится:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "executionInfo": {
     "elapsed": 617,
     "status": "ok",
     "timestamp": 1601935419706,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "IzHkBk0LeP7H",
    "outputId": "c77d1aeb-e1dd-45a3-f863-78b4e58544d0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Сейчас в словаре одна книга: {'Муму': 'И.С. Тургенев'}\n"
     ]
    }
   ],
   "source": [
    "# Поменяем значение ключа 'Муму' на 'И.С. Тургенев'\n",
    "books['Муму'] = 'И.С. Тургенев'\n",
    "\n",
    "print(f'Сейчас в словаре одна книга: {books}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-_GhW7nGexz3"
   },
   "source": [
    "Это похоже на то, как мы заменяли элемент списка, обращаясь к нему по индексу."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jq4p-oyrF5oL"
   },
   "source": [
    "Конечно же, записывать новые элементы можно и не только в пустой словарь. Давайте добавим еще одну книгу в существующий словарь"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "executionInfo": {
     "elapsed": 646,
     "status": "ok",
     "timestamp": 1601935428176,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "1YcTnX-9GBbE",
    "outputId": "0052309c-52b3-4464-dcaa-e9a434b9062d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Сейчас в словаре две книги: {'Муму': 'И.С. Тургенев', 'Изучаем Python': 'Марк Лутц'}\n"
     ]
    }
   ],
   "source": [
    "# Добавим книгу 'Изучаем Python' Марка Лутца\n",
    "books['Изучаем Python'] = 'Марк Лутц'\n",
    "\n",
    "print(f'Сейчас в словаре две книги: {books}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uSfjWyy2mXsE"
   },
   "source": [
    "Удалить пару `ключ : значение` из словаря можно с помощью специального слова `del` следующим образом:\n",
    "* `del books['Муму']` удалит из словаря ключ `Изучаем Python` и значение, которое ему соответствует."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "executionInfo": {
     "elapsed": 753,
     "status": "ok",
     "timestamp": 1601935445380,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "M4lIiXlgmXCt",
    "outputId": "a4848b54-e68c-4d23-b981-43f54724e497"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Сейчас в словаре одна книга: {'Изучаем Python': 'Марк Лутц'}\n"
     ]
    }
   ],
   "source": [
    "del books['Муму'] \n",
    "print(f'Сейчас в словаре одна книга: {books}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_rNRARMKCP8g"
   },
   "source": [
    "Сделаем пример более интерактивным: научим программу запоминать новые книги и их авторов до тех пор, пока в качестве нового автора человек не напечатает слово \"конец\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 137
    },
    "executionInfo": {
     "elapsed": 11986,
     "status": "ok",
     "timestamp": 1601935470492,
     "user": {
      "displayName": "Tatiana Rogovich",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14Gjj1YqMwkiGsMOcK4XoZPpJp6kCbYZ6EqgvdL3EXA=s64",
      "userId": "08185984249235601298"
     },
     "user_tz": -180
    },
    "id": "sNPjaxixCUzH",
    "outputId": "dae5221b-3f49-40e3-c26d-c0261a79b121"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Укажите новую книгу: Муму\n",
      "Укажите автора книги \"Муму\": Иван Тургенев\n",
      "Укажите новую книгу: конец\n",
      "Евгений Замятин написал \"Мы\".\n",
      "Джордж Оруэлл написал \"1984\".\n",
      "Олдос Хаксли написал \"Brave New World\".\n",
      "Иван Тургенев написал \"Муму\".\n"
     ]
    }
   ],
   "source": [
    "books = {'Мы': 'Евгений Замятин',\n",
    "         '1984': 'Джордж Оруэлл',\n",
    "         'Brave New World': 'Олдос Хаксли'}\n",
    "\n",
    "while True:\n",
    "    new_title = input('Укажите новую книгу: ')\n",
    "    if new_title.lower() == 'конец':    # На момент проверки сделаем все буквы маленькими,\n",
    "        break                           # чтобы не заставлять человека указывать \n",
    "                                        # слово \"конец\" с большой буквы\n",
    "    books[new_title] = input(f'Укажите автора книги \"{new_title}\": ')\n",
    "\n",
    "for title in books:\n",
    "    print(f'{books[title]} написал \"{title}\".')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gLtv-cRSDn8q"
   },
   "source": [
    "Теперь мы умеем перебирать ключи и значения словаря, находить ключ, соответствующий значению словаря, добавлять в словарь новые элементы и изменять существующие. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jTrvOhAnI_SM"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PfnShx0GMKuJ"
   },
   "source": [
    "# Задачи для самопроверки"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zAexG-znNKuC"
   },
   "source": [
    "## 1. Диета\n",
    "Петя решил придерживаться новой диеты — есть на ужин только продукты, названия которых имеют определенную длину и начинаются с определенной буквы. Помогите Пете определить, чем можно поужинать в рамках новой диеты. На вход подается список продуктов через запятую. На выходе программа выдает только те продукты, которые можно есть Пете, а если таких продуктов нет, то пишет \"Нужно идти в магазин.\"\n",
    "\n",
    "ФОРМАТ ВВОДА \n",
    "* Строка с названиями продуктов через запятую и пробел\n",
    "* Буква, с которой должны начинаться названия продуктов\n",
    "* Целое положительное число —  необходимая длина названия продукта\n",
    "* Каждый ввод с новой строки. \n",
    "\n",
    "ФОРМАТ ВЫВОДА \n",
    "* Строка типа \"Сегодня Петя может съесть на ужин следующие продукты:\" и перечисление продуктов через запятую (см. пример), либо строка \"Нужно идти в магазин.\" "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bPlehYty6_si"
   },
   "source": [
    "**Шаг 1**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oE77IJSeaqQ_"
   },
   "source": [
    "Сначала принимаем на вход строку продуктов, с помощью `.split(', ')` получаем список с продуктами. Далее считываем с клавиатуры букву и длину названия продукта. Создаем пустой список, куда будем записывать подходящие продукты. <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "VW3wYdr86-ep",
    "outputId": "68514c97-411d-4d60-fba5-5b8a595c3078"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "арбуз, молоко, малина, миндаль, арахис\n",
      "м\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "products = input().split(', ') # принимаем на вход список продуктов и разделяем его по запятой и пробелу, получаем список\n",
    "letter = input() \n",
    "number = int(input())  \n",
    "products_new = []  # пустой список, куда будем складывать разрешенные продукты"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Bx3HdgSeQRXl"
   },
   "source": [
    "Шаг 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NQZv6Z9IQRND"
   },
   "source": [
    "Чтобы проверить первую букву слова, возьмем его элемент с индексом `[0]`, а чтобы посмотреть длину слова — воспользуемся функцией `len()`. По правилам диеты эти условия должны выполняться одновременно. Проверим условия для всех слов в считанном списке и для наглядности напечатаем подходящие продукты."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "OXxhLm2ZQRHx",
    "outputId": "af1a5bdf-019f-4856-a413-68f9ff06b793"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "молоко\n",
      "мещане\n",
      "магнит\n"
     ]
    }
   ],
   "source": [
    "# далее мы будем проверять, что слово начинается с нужной буквы и имеет разрешенную длину\n",
    "words = ['молоко', 'мещане', 'корова', 'гражданин', 'магнит', 'мешок']\n",
    "for word in words:\n",
    "  if word[0] == letter and len(word) == number: # если первая буква правильная и длина соответствует нужной\n",
    "    print(word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GGkBf0mVQRgu"
   },
   "source": [
    "Работает! Теперь оставляем все то же самое, только не печатаем слова, а добавляем их в наш пустой список."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UJR_fQZwQRcW"
   },
   "outputs": [],
   "source": [
    "for product in products: # для каждого продукта в списке\n",
    "    if product[0] == letter and  len(product) == number: \n",
    "       products_new.append(product) # добавляем продукт в новый список         "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "omurHOzNQu1t"
   },
   "source": [
    "Шаг 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HipMrNiZQvFB"
   },
   "source": [
    "Далее проверяем список на наполняемость: если он пустой, то есть все продукты не удовлетворили условиям, то отправляем Петю в магазин, иначе же выводим список продуктов, объединяя их в строку через запятую с помощью метода `.join()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "4WTncGRjQu8l",
    "outputId": "db99263d-5c47-40be-a666-63759ddb4dd9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Сегодня Петя может съесть на ужин следующие продукты: молоко, малина.\n"
     ]
    }
   ],
   "source": [
    "if len(products_new) == 0:  # проверяем, не оказался ли новый список пустой   \n",
    "     print('Нужно идти в магазин.') \n",
    "else:     \n",
    "   print('Сегодня Петя может съесть на ужин следующие продукты:', ', '.join(products_new) + '.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QVTzXRcAarDI"
   },
   "source": [
    "Итоговое решение"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "cvMcQ7hdarf1"
   },
   "outputs": [],
   "source": [
    "products = input().split(', ') \n",
    "letter = input() \n",
    "number = int(input())  \n",
    "products_new = []  \n",
    "for product in products: \n",
    "    if product[0] == letter and  len(product) == number: \n",
    "       products_new.append(product)          \n",
    "if len(products_new) == 0:     \n",
    "     print('Нужно идти в магазин.') \n",
    "else:     \n",
    "   print('Сегодня Петя может съесть на ужин следующие продукты:', ', '.join(products_new) + '.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5vt5TkkHOM12"
   },
   "source": [
    "## 2. Битва блогеров\n",
    "Блогеры Аня и Ваня решили посоревноваться, кто заработает за два месяца больше денег на рекламе. Каждый раз, когда кто-то продает рекламу, они записывают в специальную тетрадь имя того, кто продал, и стоимость сделки. Помогите ребятам подвести итоги соревнования. \n",
    "\n",
    "ФОРМАТ ВВОДА \n",
    "\n",
    "* С новой строки вводится имя блогера, продавшего рекламу (Аня или Ваня), после через пробел вводится целое число — стоимость рекламы в рублях. \n",
    "* Ввод завершается, когда вводится строка \"КОНЕЦ\". \n",
    "* Гарантируется, что будет введена как минимум одна строка с информацией.\n",
    "* Кто-то из блогеров может не продать рекламу (т.е. информация с его именем не поступит на ввод).\n",
    "\n",
    "ФОРМАТ ВЫВОДА \n",
    "\n",
    "* Имя блогера, который заработал больше.\n",
    "* Если ребята заработали одинаковые суммы, вывести \"Ничья\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "e6H2VWncQe_F"
   },
   "source": [
    "**Шаг 1**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sOI6zqDBQe_S"
   },
   "source": [
    "Создаем переменные-счетчики для Ани и Вани и считываем первую строку с информацией о продажах рекламы."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "JTSk14-VQe_T",
    "outputId": "ea6432a0-277f-4ce0-be64-7430d7777e7b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ваня 200\n"
     ]
    }
   ],
   "source": [
    "anya = 0\n",
    "vanya = 0\n",
    "sale = input() # считываем первую строку"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "izKqMUSsHR8q"
   },
   "source": [
    "Дальше нам нужно будет считывать подобные строки внутри цикла. Будем разбивать их по пробелу, используя метод `.split()`. Далее записываем первый элемент в переменную `name`, а второй — в `total` — будем использовать их для проверки условия и обновления счетчика. Также сумму денег не забудем перевести в `int`. Проверим на примере:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "B0LkW5QzHR2f",
    "outputId": "38bb03c7-8c4b-4da6-dd15-94e21d66491e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ваня 200\n",
      "['Ваня', '200']\n",
      "Ваня\n",
      "200\n"
     ]
    }
   ],
   "source": [
    "print(sale) # печатаем считанную строку\n",
    "print(sale.split()) # превращаем в список из имени и суммы\n",
    "name = sale.split()[0] # сохраняем имя\n",
    "total = int(sale.split()[1]) # сохраняем сумму денег\n",
    "\n",
    "print(name)\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pMPwo6nDHSea"
   },
   "source": [
    "**Шаг 2**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KlMOkyA2HStJ"
   },
   "source": [
    "Делаем цикл `while`, работающий, пока не будет считано слово `КОНЕЦ`. На каждой итерации, используя метод `.split()`, разделяем строку на имя и фамилию (элементы с индексами `[0]` и `[1]`), проверяем, чье это имя, и записываем сумму контракта в переменную-счетчик нужного блогера. Считываем новую строку. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Id-3aikrHSnt",
    "outputId": "e81117ae-d561-48f2-8460-b2a8a2c9153e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Аня 300\n",
      "Ваня 500\n",
      "Ваня 500\n",
      "Аня 2500\n",
      "Ваня 30\n",
      "Аня 4500\n",
      "КОНЕЦ\n"
     ]
    }
   ],
   "source": [
    "while sale != 'КОНЕЦ': # пока последовательность на закончилась словом КОНЕЦ\n",
    "  name = sale.split()[0] # разделяем строку на имя и стоимость рекламы, записываем имя в переменную name\n",
    "  total = int(sale.split()[1]) # делаем то же самое и записываем сумму в переменную total\n",
    "  if name == 'Аня': # в зависимости от имени записываем сумму либо Ане, либо Ване\n",
    "    anya += total\n",
    "  else:\n",
    "    vanya += total\n",
    "  sale = input() # считываем новую строку и переходим к началу цикла"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6N-k0MWBARoy"
   },
   "source": [
    "**Шаг 3**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "X8p-8ClnAR_K"
   },
   "source": [
    "В конце сравнивем переменные-счетчики, и выводим имя победившего блогера, или `Ничья`, если суммы оказались равны. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "1ll7wtafAR2h",
    "outputId": "531f568e-dfba-4d14-fa3a-55fbfcb63737"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Аня\n"
     ]
    }
   ],
   "source": [
    "if anya > vanya: # проверяем, чья сумму больше и выводим результат на экран\n",
    "  print('Аня')\n",
    "elif vanya > anya:\n",
    "  print('Ваня')\n",
    "else:\n",
    "  print('Ничья')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "W8mqLufBQe_W"
   },
   "source": [
    "Итоговое решение"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "X2PNtYhWQe_W"
   },
   "outputs": [],
   "source": [
    "anya = 0\n",
    "vanya = 0\n",
    "sale = input()\n",
    "while sale != 'КОНЕЦ': \n",
    "  name = sale.split()[0] \n",
    "  total = int(sale.split()[1]) \n",
    "  if name == 'Аня': \n",
    "    anya += total\n",
    "  else:\n",
    "    vanya += total\n",
    "  sale = input()\n",
    "\n",
    "if anya > vanya:\n",
    "  print('Аня')\n",
    "elif vanya > anya:\n",
    "  print('Ваня')\n",
    "else:\n",
    "  print('Ничья')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MXOGAFcNQgBw"
   },
   "source": [
    "## 3. Игра в слова\n",
    "Вася и Маша играют в игру: Вася пишет какое-то слово, а затем Маша начинает составлять слова из букв слова Васи. Составьте программу, которая проверяет для какого-либо слова, может ли Маша использовать его в игре. Буквы могут повторяться (например, если Вася написал \"кошмар\", Маша может написать \"мама\" — и \"м\", и \"а\" есть в исходном слове) \n",
    "\n",
    "ФОРМАТ ВВОДА\n",
    "* На первой строке — слово Васи со строчной буквы; \n",
    "* на второй — слово от Маши.\n",
    "\n",
    "ФОРМАТ ВЫВОДА\n",
    "* Если слово Маши можно использовать: \"ДА\".\n",
    "* Если слово нельзя использовать: \"НЕТ\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YYLlUJUzThSp"
   },
   "source": [
    "Шаг 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r1ddDFl5ThSu"
   },
   "source": [
    "Сначала поочередно получаем на вход исходное и составленное слова, превращаем их в множества, передавая в функцию `set()`. Для наглядности напечатаем получившиеся множества. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "5oThki3lThSu",
    "outputId": "fe3d3f70-138b-4818-d308-ef4519c38c59"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "университет\n",
      "версия\n",
      "{'е', 'н', 'р', 'с', 'и', 'у', 'в', 'т'}\n",
      "{'е', 'р', 'с', 'я', 'и', 'в'}\n"
     ]
    }
   ],
   "source": [
    "source_letters = set(input()) # принимаем исходное слово и превращаем его в множество\n",
    "letters_to_check = set(input()) # также поступаем с составленным словом\n",
    "print(source_letters)\n",
    "print(letters_to_check)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cLTVI2BnALo4"
   },
   "source": [
    "Шаг 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U7IAeXiMAL6T"
   },
   "source": [
    "Далее находим разность между множеством букв Машиного слова и множеством букв Васиного слова. Если в этой разнице 0 элементов, значит все буквы Машиного слова входят в множество букв Васиного. Если условие выполняется, то выводим `'ДА'`, иначе выводим `'НЕТ'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "vq700wkNALzb",
    "outputId": "fe740184-0d16-4c93-9831-8b9d70b1871c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'я'}\n",
      "НЕТ\n"
     ]
    }
   ],
   "source": [
    "print(letters_to_check - source_letters) # посмотрим на разность множеств\n",
    "\n",
    "if len(letters_to_check - source_letters) == 0:\n",
    "# то есть все буквы присутствуют в исходном слове\n",
    "    print('ДА')\n",
    "else:\n",
    "    print('НЕТ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KLv2dsiDThSv"
   },
   "source": [
    "Итоговое решение"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "fZ_Xkk9ZThSv",
    "outputId": "2d70ad59-c515-4304-9ee6-37428b97be8f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "инверсия\n",
      "версия\n",
      "ДА\n"
     ]
    }
   ],
   "source": [
    "source_letters = set(input())\n",
    "letters_to_check = set(input())\n",
    "\n",
    "\n",
    "if len(letters_to_check - source_letters) == 0:\n",
    "    print('ДА')\n",
    "else:\n",
    "    print('НЕТ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Czj4lwQGT23m"
   },
   "source": [
    "## 4. Раздача подарков\n",
    "На праздник в детском саду закупили два вида подарков: конфеты и игрушки. Каждому ребёнку должен был достаться один кулёк конфет и одна игрушка, но в суматохе оказалось, что кто-то недополучил свои подарки. Известно, что каждый ребёнок получил хотя бы что-то одно, а некоторые получили и то, и другое. Составьте программу, которая будет определять, какого подарка ребёнку не хватило. Если ребёнок получил оба подарка, программа должна написать \"всё есть\". \n",
    "\n",
    "ФОРМАТ ВВОДА\n",
    "* На первой строке — список детей, получивших кулек конфет (по именам, через запятую и пробел, имена не повторяются); \n",
    "* на второй строке — список детей, получивших игрушку (по именам, через запятую и пробел, имена не повторяются); \n",
    "* на третьей строке — имена детей, подарки которых нужно проверить (по именам, через запятую и пробел, имена не повторяются). Гарантируется, что в списке дети, у которых есть как минимум один подарок; \n",
    "\n",
    "ФОРМАТ ВЫВОДА\n",
    "* Для каждого ребенка вывод на новой строке.\n",
    "* Имя ребёнка, затем пробел, затем недостающий подарок: \"конфеты\"/\"игрушка\"/\"всё есть\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EEf3_6rJU8Qg"
   },
   "source": [
    "Шаг 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OJ6jDpPrU8Qh"
   },
   "source": [
    " Сначала принимаем на вход список детей с конфетами и список детей с игрушками, превращаем их в множества с помощью `.set()`, также принимаем список детей, для которых нужно узнать, все ли подарки они получили. <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "XkzOJ9eoU8Qh",
    "outputId": "3235f274-94b0-46ec-cd91-35a65c108691"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Маша, Петя, Саша\n",
      "Даша, Маша, Катя\n",
      "Петя, Катя, Маша\n",
      "{'Саша', 'Петя', 'Маша'}\n",
      "{'Даша', 'Маша', 'Катя'}\n",
      "['Петя', 'Катя', 'Маша']\n"
     ]
    }
   ],
   "source": [
    "sweets = set(input().split(', ')) # получаем на вход список детей, кому достались конфеты, разделяем и превращаем во множество\n",
    "toys = set(input().split(', ')) # также поступаем с теми, кто получил игрушки\n",
    "children = input().split(', ') # получаем список детей, для которых нужно проверить соответствие подаркам\n",
    "print(sweets)\n",
    "print(toys)\n",
    "print(children)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uBcSCBGuCQxR"
   },
   "source": [
    "**Шаг 2**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1cuqsXdBCQ9M"
   },
   "source": [
    "Находим пересечение множеств игрушек и подарков, чтобы узнать имена детей, получивших оба подарка (делается это с помощью символа `&`). Для наглядности выведем его. Видим, что в объединении оказалась только Маша, так как она единственная, кто присутствует в обоих списках сразу. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "IN67nd2vCQ3v",
    "outputId": "5da8d444-3fa9-43fd-b2b4-b13923f5d5be"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Маша'}\n"
     ]
    }
   ],
   "source": [
    "both_gifts = sweets & toys # находим пересеченеи — тех детей, кто получил оба подарка\n",
    "print(both_gifts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bPpgO2x2CXe0"
   },
   "source": [
    "**Шаг 3**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mH0Fiv0NCXrT"
   },
   "source": [
    "Далее создаем цикл `for`, для каждого ребенка в списке проверяем, есть ли его имя в множестве детей, получивших оба подарка. Если имя есть в этом множестве, то выводим фразу `\"все есть\"`. Иначе проверяем, есть ли ребенок в списке получивших игрушки, если да — то ему нужны `'конфеты'`, иначе — `'игрушка'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "MuyOSN5aCXl2",
    "outputId": "38f248ca-e9bc-488c-87de-7b4f90b7497c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Петя игрушка\n",
      "Катя конфеты\n",
      "Маша всё есть\n"
     ]
    }
   ],
   "source": [
    "for child in children: # для каждого ребенка в списке\n",
    "    if child in both_gifts: # если ребенок есть в объединении множеств \"оба подарка\"\n",
    "        print(child, 'всё есть')\n",
    "    else:\n",
    "        if child in toys: # если только в игрушках\n",
    "            print(child, 'конфеты') # то отдаем конфеты\n",
    "        else:\n",
    "            print(child, 'игрушка') # и наоборот"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tXOj_oRdU8Qj"
   },
   "source": [
    "Итоговое решение"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5YQrNvvxU8Qj"
   },
   "outputs": [],
   "source": [
    "sweets = set(input().split(', ')) \n",
    "toys = set(input().split(', ')) \n",
    "children = input().split(', ')\n",
    "\n",
    "both_gifts = sweets & toys\n",
    "\n",
    "for child in children:\n",
    "    if child in both_gifts:\n",
    "        print(child, 'всё есть')\n",
    "    else:\n",
    "        if child in toys:\n",
    "            print(child, 'конфеты')\n",
    "        else:\n",
    "            print(child, 'игрушка')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TEt26LRRXAJ1"
   },
   "source": [
    "## 5. Покемоны\n",
    "Студент, который начал изучать программирование на Python, но пока не умеет работать со словарями, сохранил в виде списка названия параметров, которые есть у каждого вида покемонов (номер, название, тип, рост, вес). \n",
    "\n",
    "Значения параметров для своего любимого покемона он собирается ввести в том же порядке с клавиатуры. Напишите программу, которая принимает на вход эти значения и выводит словарь pokemon, хранящий информацию о покемоне в удобной форме: элементы списка par_name должны стать ключами, а введенные параметры любимого покемона — соответствующими ключам значениями. \n",
    "\n",
    "ФОРМАТ ВВОДА \n",
    "* Значения параметров покемона из списка par_name в обозначенном порядке. \n",
    "* Каждое значение вводится с новой строки. \n",
    "\n",
    "ФОРМАТ ВЫВОДА\n",
    "* Словарь pokemon, в котором элементы списка par_name стали ключами, а введенные параметры — значениями"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xEIikkfIWILp"
   },
   "source": [
    "Шаг 1\n",
    "Сначала создаем пустой словарь, куда будем добавлять элементы. <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "m7Y_Kh5hWFa3"
   },
   "outputs": [],
   "source": [
    "par_name = ['Номер', 'Имя', 'Тип', 'Рост', 'Вес']\n",
    "\n",
    "pokemon = dict() # создаем пустой словарь"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5Gx0FVKfWYuR"
   },
   "source": [
    "Шаг 2\n",
    "Дальше нам нужно будет создавать в словаре пары ключ-значение. Значение присваивается ключу при обращении `dict[key] = value`, где `dict` - название словаря, `key` — ключ словаря, `value` — значение, которое мы хотим присвоить ключу. Попробуем на примере:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "XeAlLbHgWjI2",
    "outputId": "c218b736-ac8d-4808-beca-ed5cdc884e94"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'ключ': 'значение'}\n"
     ]
    }
   ],
   "source": [
    "test = dict()\n",
    "test['ключ'] = 'значение'\n",
    "print(test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Nzzn7kcDXHTv"
   },
   "source": [
    "Пары для нашего словаря будем создавать внутри цикла — ведь ключи хранятся в списке `par_name`. Запускаем цикл `for`.\n",
    "\n",
    "На каждом шаге наш элемент списка будет становиться новым ключом в словаре. Присваиваем ключу значение — вводим значение с клавиатуры. <br>\n",
    "\n",
    "По завершении работы цикла напечатаем словарь. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "L0v4v5kZXHTv",
    "outputId": "a3e4e075-6fe6-440c-9781-3b3b2b92c332"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "Пикачу\n",
      "электро\n",
      "25\n",
      "10\n",
      "{'Номер': '1', 'Имя': 'Пикачу', 'Тип': 'электро', 'Рост': '25', 'Вес': '10'}\n"
     ]
    }
   ],
   "source": [
    "for param in par_name: # для каждого параметра в списке\n",
    "    pokemon[param] = input() # присваиваем введенное значение ключу в словаре\n",
    "\n",
    "print(pokemon)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XQrHZp_eXHTv"
   },
   "source": [
    "Итоговое решение"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "f5MN5FXMXHTv"
   },
   "outputs": [],
   "source": [
    "par_name = ['Номер', 'Имя', 'Тип', 'Рост', 'Вес']\n",
    "\n",
    "pokemon = dict() \n",
    "\n",
    "for param in par_name: \n",
    "    pokemon[param] = input()\n",
    "\n",
    "print(pokemon)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Множества и словари.ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "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.10.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "288px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}