Lessons/Структуры данных/2. Структуры данных.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 style='text-align: center;'> Структуры данных </h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Эпиграф**\n",
    "\n",
    "*Соня меж тем закрыла глаза и задремала. Но тут Болванщик ее ущипнул, она взвизгнула и проснулась.*\n",
    "\n",
    "*– Начинается на М, – продолжала она. – Они рисовали мышеловки, месяц, математику, множество...*\n",
    "\n",
    "*Ты когда-нибудь видела, как рисуют множество?*\n",
    "\n",
    "*– Множество чего? – спросила Алиса.*\n",
    "\n",
    "*– Ничего, – отвечала Соня. – Просто множество!*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Структуры данных\n",
    "\n",
    "Вы уже знаете, что данные бывают разных типов. Кроме того, они могут быть по-разному организованы. То, в каком виде хранится некоторый набор данных -- это и есть их структура. Мы рассмотрим **списки**, **кортежи**, **множества** и **словари**.\n",
    "\n",
    "### Списки\n",
    "\n",
    "**Список**, или **массив** (list) -- это такая структура данных, где все элементы имеют порядковый номер (**индекс**), по которому их можно вызвать. Элементы могут повторяться (т.е. в ячейках с разными индексами могут быть записаны переменные с одинаковым значением / одинаковые константы). В списке могут храниться данные разных типов. Записывается в [ ]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4.89, 5, 'spam', True, 'spam', 'hello']\n"
     ]
    }
   ],
   "source": [
    "# создать список можно так\n",
    "\n",
    "a = 5\n",
    "b = \"hello\"\n",
    "\n",
    "my_list = [4.89, a, \"spam\", True, \"spam\", b]\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['The', 'cat', 'is', 'on', 'the', 'mat']\n",
      "['T', 'h', 'e', ' ', 'c', 'a', 't', ' ', 'i', 's', ' ', 'o', 'n', ' ', 't', 'h', 'e', ' ', 'm', 'a', 't']\n"
     ]
    }
   ],
   "source": [
    "# а можно так\n",
    "\n",
    "sentence = \"The cat is on the mat\"\n",
    "letters = list(sentence)  # разбивает строку на минимальные элементы, т.е. посимвольно\n",
    "words = sentence.split()  # разбивает строку на слова по пробелам\n",
    "\n",
    "print(words)\n",
    "print(letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`list()` принимает на вход только один аргумент. Этот аргумент должен быть итерируемым (строка или любая структура данных), т.е. из числа список сделать не получится!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'int' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-14-60ecfa1cf9e6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnumbers\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m123\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'int' object is not iterable"
     ]
    }
   ],
   "source": [
    "numbers = list(123)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно также создать пустой список."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "new_list = []\n",
    "print(new_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Списки можно складывать."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['The', 'cat', 'is', 'on', 'the', 'mat', 'It', 'is', 'sleeping']\n"
     ]
    }
   ],
   "source": [
    "more_words = words + [\"It\", \"is\", \"sleeping\"]\n",
    "print(more_words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как и с числами, результат сложения можно записывать в ту же самую переменную."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "['a', 'o', 'u', 'e', 'i']\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "x += 3\n",
    "print(x)\n",
    "\n",
    "vowels = ['a', 'o', 'u']\n",
    "vowels += ['e', 'i']\n",
    "print(vowels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А еще можно просто добавить элемент в конец списка. Это называется `append()` и пишется через точку после названия списка. Вот так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'o', 'u', 'e', 'i', 'æ']\n"
     ]
    }
   ],
   "source": [
    "vowels.append('æ')\n",
    "print(vowels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Раз все элементы списка имеют порядковые номера, значит можно вызвать элемент по номеру. **NB!** Нумерация начинается с нуля!!! Можно считать элементы не только с начала, но и с конца. В таком случае нумерация начинается с&nbsp; -1.\n",
    "\n",
    "Чтобы вызвать элемент по его порядковому номеру, или индексу, нужно записать этот индекс в [ ] после названия списка."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "æ\n"
     ]
    }
   ],
   "source": [
    "print(vowels[0])  # первый элемент списка\n",
    "print(vowels[-1]) # последний элемент списка"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Кроме того, можно вызывать сразу несколько элементов, сделав т.н. **срез** (slice)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['o', 'u', 'e', 'i', 'æ']\n",
      "['a', 'o', 'u', 'e']\n",
      "['o', 'u']\n"
     ]
    }
   ],
   "source": [
    "print(vowels[1:])  # все элементы, начиная со 2-го (включительно)\n",
    "print(vowels[:-2]) # все элементы до предпоследнего (не включая его)\n",
    "print(vowels[1:3]) # элементы от 2 до 4 (включая 2 и не включая 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Кортежи\n",
    "\n",
    "**Кортеж** (tuple) -- это тот же массив с проиндексированными элементами, только неизменяемый. Создать его тоже можно разными способами. Элементами могут быть данные любого типа. Записываются кортежи в ( )."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "()\n",
      "('brother', 'sister')\n",
      "('the', 'cat', 'is', 'on', 'the', 'mat')\n",
      "('t', 'h', 'e', ' ', 'c', 'a', 't', ' ', 'i', 's', ' ', 'o', 'n', ' ', 't', 'h', 'e', ' ', 'm', 'a', 't')\n"
     ]
    }
   ],
   "source": [
    "# пустой кортеж\n",
    "new_tuple = ()\n",
    "print(new_tuple)\n",
    "\n",
    "# непустой кортеж\n",
    "siblings = ('brother', 'sister')\n",
    "print(siblings)\n",
    "\n",
    "# кортеж из списка\n",
    "words = tuple(words)\n",
    "print(words)\n",
    "\n",
    "# кортеж из строки\n",
    "letters = tuple(sentence) # строка разбивается на минимальные единицы, т.е. посимвольно\n",
    "print(letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Кортежи, как и списки, поддерживают операции сложения и умножения, но просто добавить элемент в кортеж нельзя!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('The', 'cat', 'is', 'on', 'the', 'mat', 'brother', 'sister')\n",
      "('brother', 'sister', 'brother', 'sister', 'brother', 'sister')\n"
     ]
    }
   ],
   "source": [
    "words += siblings # прибавляем siblings к words и записываем результат в words\n",
    "print(words)\n",
    "\n",
    "big_family = siblings * 3\n",
    "print(big_family)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Элемент(ы) кортежа можно вызвать по индексу точно так же, как элементы списка."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The\n",
      "sister\n",
      "('is', 'on', 'the')\n"
     ]
    }
   ],
   "source": [
    "print(words[0])   # первый элемент кортежа\n",
    "print(words[-1])  # последний элемент кортежа\n",
    "print(words[2:5]) # элементы кортежа со 2 по 5 (включая 2 и не включая 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Множества\n",
    "\n",
    "**Множество** (set) -- это структура данных, чем-то похожая и на массив, и на словарь, но от них отличающаяся.\n",
    "\n",
    "Как и массивы, множества содержат элементы. Но в отличие от массивов, где элементы упорядочены, в множестве они идут в \"произвольном\" порядке (для компьютера он, конечно, не произвольный, а обусловленный рядом технических причин, для человека не очевидных).\n",
    "\n",
    "На словари множества похожи тем, что, как и ключи в словарях, элементы множеств неупорядочены и поэтому должны быть уникальны.\n",
    "\n",
    "Чем хороши множества? Во-первых, поиск в множестве происходит быстрее, чем в массиве. Если вам нужно собрать какие-то данные, а потом проверять, есть ли в этих данных что-то, то целесообразно использовать именно множества. Во-вторых, преобразование в множества помогают быстро превратить набор данных в набор уникальных элементов."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'on', 'the', 'is', 'mat', 'cat'}\n",
      "{'elephant', 'fox', 'cat', 'dog', 'crocodile'}\n"
     ]
    }
   ],
   "source": [
    "# создаем множество из списка (массива)\n",
    "\n",
    "sentence = \"the cat is on the mat\"\n",
    "words = set(sentence.split())  # превращаем список, который возвращает split(), в массив\n",
    "animals = set(['cat', 'dog', 'elephant', 'crocodile', 'fox', 'cat', 'elephant'])\n",
    "\n",
    "print(words)\n",
    "print(animals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'c', 'o', 'a', 'n', 'h', ' ', 's', 't', 'i', 'm', 'e'}\n"
     ]
    }
   ],
   "source": [
    "# создаем множество из строки\n",
    "\n",
    "letters = set(sentence)  # разбивает строку на минимальные элементы, т.е. посимвольно\n",
    "print(letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обратите внимание, что все элементы получившихся множеств уникальны! Если вам нужно избавиться от повторов в данных, то самое простое решение -- это превратить их в множество.\n",
    "\n",
    "Множества нельзя складывать, зато можно добавлять в них элементы -- это делается функцией `add()`, которая тоже пишется через точку после названия множества."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'elephant', 'tiger', 'fox', 'cat', 'dog', 'crocodile'}\n"
     ]
    }
   ],
   "source": [
    "animals.add('tiger')\n",
    "print(animals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Пустое множество создать тоже можно."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set()\n"
     ]
    }
   ],
   "source": [
    "new_set = set() # обратите внимание, что просто скобочек в данном случае недостаточно!\n",
    "print(new_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Множества поддерживают разные специальные операции, которых нельзя так же просто осуществить с другими структурами данных."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6, 7, 8, 9}\n",
      "{4, 5, 6}\n",
      "{1, 2, 3}\n",
      "{1, 2, 3, 7, 8, 9}\n"
     ]
    }
   ],
   "source": [
    "a = set([1, 2, 3, 4, 5, 6])\n",
    "b = set([4, 5, 6, 7, 8, 9])\n",
    "\n",
    "# объединение\n",
    "c = a | b\n",
    "print(c)\n",
    "\n",
    "# пересечение\n",
    "c = a & b\n",
    "print(c)\n",
    "\n",
    "# разность\n",
    "c = a - b\n",
    "print(c)\n",
    "\n",
    "# симметрическая разность, то есть элементы, входящие в a или в b, но не в оба множества одновременно\n",
    "c = a ^ b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Словари\n",
    "\n",
    "**Словарь** (ассоциативный массив) -- это такая структура данных, где объекты хранятся в неупорядоченном виде в парах \"ключ : значение\" и доступны по ключу. \n",
    "\n",
    "Если в массиве индексы объектов, по которым можно получить к ним доступ, создаются без участия человека, то в словаре вы сами выбираете ключ.\n",
    "\n",
    "Создать пустой словарь можно так:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "# с помощью скобочек, как список или кортеж\n",
    "d = {}\n",
    "print(type(d))\n",
    "\n",
    "# с помощью соответствующей функции, как любую структуру данных\n",
    "d = dict()\n",
    "print(type(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А теперь создадим словарь с данными. Это тоже можно сделать разными способами:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1, 2: 4, 3: 9, 4: 16}\n",
      "{'Russia': 'Moscow', 'France': 'Paris'}\n"
     ]
    }
   ],
   "source": [
    "# скобочки\n",
    "squared = {1:1, 2:4, 3:9, 4:16}\n",
    "print(squared)\n",
    "\n",
    "# функция dict()\n",
    "capitals = dict(Russia = \"Moscow\", France = \"Paris\")\n",
    "print(capitals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NB!** *Ключи (keys)* в словаре должны быть уникальны, как и индексы в массиве, а вот *значения (values)* могут повторяться."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 'vowel', 'b': 'consonant', 'c': 'consonant'}\n",
      "{'uneven': 3, 'even': 4}\n"
     ]
    }
   ],
   "source": [
    "# так можно\n",
    "sounds = {\"a\":\"vowel\", \"b\":\"consonant\", \"c\":\"consonant\"}\n",
    "print(sounds)\n",
    "\n",
    "# а так нельзя (проанализируйте результат)\n",
    "numbers = {\"uneven\":1, \"even\":2, \"uneven\":3, \"even\":4}\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NB!** В качестве значения может выступать любой тип или структура данных. Всё, что угодно и какой угодно сложности. Ключом же может быть только:\n",
    "\n",
    "* целое число (int)\n",
    "* дробное число (float)\n",
    "* строка (str)\n",
    "* кортеж (tuple)\n",
    "\n",
    "Все это *неизменяемые типы данных* (просто запомните формулировку)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Europe': {'France': ('Paris', 'French'), 'Germany': ('Berlin', 'German')}, 'Asia': {'China': ('Beijing', 'Chinese'), 'Japan': ('Tokyo', 'Japanese')}}\n"
     ]
    }
   ],
   "source": [
    "# это большой сложный словарь, и это нормально :)\n",
    "world = {\"Europe\":{\"France\":(\"Paris\", \"French\"), \"Germany\":(\"Berlin\", \"German\")}, \"Asia\": {\"China\":(\"Beijing\", \"Chinese\"), \"Japan\":(\"Tokyo\", \"Japanese\")}}\n",
    "print(world)\n",
    "\n",
    "# а вот так нельзя\n",
    "langs = {[\"Danish, German, English\"]: \"Germanic\", [\"Irish\", \"Welsh\"]: \"Celtic\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Добавление и удаление элементов\n",
    "\n",
    "Чтобы добавить элемент в словарь нужно указать новый ключ и значение."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 'vowel', 'b': 'consonant', 'c': 'consonant', 'd': 'consonant', 'e': 'vowel', 'z': 'consonant'}\n"
     ]
    }
   ],
   "source": [
    "# добавим новые пары \"ключ : значение\" в существующий словарь sounds\n",
    "\n",
    "sounds[\"d\"] = \"consonant\"\n",
    "sounds[\"e\"] = \"vowel\"\n",
    "sounds[\"z\"] = \"consonant\"\n",
    "\n",
    "print(sounds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Удалить элемент можно с помощью команды `del()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'b': 'consonant', 'c': 'consonant', 'e': 'vowel', 'z': 'consonant'}\n"
     ]
    }
   ],
   "source": [
    "del sounds[\"a\"], sounds[\"d\"] # словарь[ключ]\n",
    "print(sounds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А вот так можно достать элемент из словаря по ключу."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Paris'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# так-так, что у нас там столица Франции?\n",
    "capitals[\"France\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Иногда бывает полезно проверить наличие ключа в словаре. Это можно сделать с помощью уже знакомого нам оператора `in`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"Russia\" in capitals)\n",
    "print(\"Italy\" in capitals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Некоторые методы словарей\n",
    "\n",
    "* `keys()` -- достаем из словаря все ключи"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['Russia', 'France'])\n"
     ]
    }
   ],
   "source": [
    "print(capitals.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `values()` -- достаем из словаря все значения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values(['Moscow', 'Paris'])\n"
     ]
    }
   ],
   "source": [
    "print(capitals.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `items()` -- достаем из словаря все пары ключей со значениями"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('Russia', 'Moscow'), ('France', 'Paris')])\n"
     ]
    }
   ],
   "source": [
    "print(capitals.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Эти три метода очень важны для написания циклов.\n",
    "\n",
    "Кроме того, можно скопировать словарь (`copy()`), обновить его (`update()`) и удалить все его содержимое (`clear()`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Russia': 'Moscow', 'France': 'Paris'}\n",
      "{'Russia': 'Saint-Petersburg', 'France': 'Paris', 'Turkey': 'Istanbul'}\n",
      "{}\n"
     ]
    }
   ],
   "source": [
    "# копируем словарь\n",
    "\n",
    "old_capitals = capitals.copy()\n",
    "print(old_capitals)\n",
    "\n",
    "# обновляем данные на основании другого словаря; проанализируйте происходящее\n",
    "old_capitals.update({\"Russia\":\"Saint-Petersburg\", \"Turkey\": \"Istanbul\"})\n",
    "print(old_capitals)\n",
    "\n",
    "# очищаем словарь\n",
    "old_capitals.clear()\n",
    "print(old_capitals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### get()\n",
    "\n",
    "Еще одна полезная функция для работы со словарями -- `get()`. Если ключ есть в словаре, то метод возвращает значение, соответствующее этому ключу. Если же его нет, то в словарь добавляется этот ключ и значение, указанное во втором параметре (он, к слову, необязателен). Проще говоря, питон выполняет такую команду: *\"если ключ есть, то дай мне его значение, а если ключа нет, то добавь его в словарь\".* Например:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1992"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# словарь с годами рождения\n",
    "birthdays = {\"Вася\": 1991, \"Маша\": 1992, \"Петя\": 1992}\n",
    "\n",
    "# ключ есть в словаре\n",
    "birthdays.get(\"Петя\")  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1994"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ключа нет в словаре; если не указать 2-ой аргумент, вернется None\n",
    "print(birthdays.get(\"Иннокентий\"))\n",
    "\n",
    "# если указать второй аргумент, то вернется второй аргумент\n",
    "birthdays.get(\"Иннокентий\", 1994)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Добавить новую запись в словарь с помощью `get()` можно так."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Введите имя: Иннокентий\n",
      "Введите год рождения: 1994\n",
      "{'Вася': 1991, 'Маша': 1992, 'Петя': 1992, 'Иннокентий': 1994}\n"
     ]
    }
   ],
   "source": [
    "name = input(\"Введите имя: \")\n",
    "\n",
    "birthdays[name] = birthdays.get(name, int(input(\"Введите год рождения: \")))\n",
    "\n",
    "print(birthdays)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Задание №1\n",
    "\n",
    "1. Найдите два любых стихотворения разных авторов одной эпохи (не очень маленькие, минимум строк 20-30) и сохраните в разные файлы.\n",
    "2. Откройте и прочитайте файлы, преобразуйте тексты в множества слов.\n",
    "3. Найдите пересечения этих множеств, то есть какие словоформы являются общими для обоих стихотворений?\n",
    "4. Найдите симметрическую разность этих множеств, то есть какие словоформы являются уникальными для каждого из стихотворений?\n",
    "\n",
    "\n",
    "##Задание №2\n",
    "\n",
    "1. Напишите функцию, которая принимает на вход имя (строку) и словарь. В словаре должны храниться имена (ключи) и номера телефонов (значения). Имена не должны повторяться, а в номерах телефонов должны быть только цифры!\n",
    "2. Функция должна проверять, есть ли имя в словаре, и если есть, то возвращать номер телефона этого человека.\n",
    "3. Если имени нет в словаре, программа должна написать, что такого имени нет в телефонной книге, предложить ввести номер телефона через `input()`, добавить новую запись в словарь и вернуть словарь."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Appendix 1. Некоторые встроенные функции\n",
    "\n",
    "### len()\n",
    "\n",
    "С помощью `len()` можно узнать длину выражения в скобках. Аргументом этой функции может быть строка или любая структура данных."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n",
      "6\n",
      "6\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# строка\n",
    "sentence = \"the cat is on the mat\"\n",
    "print(len(sentence)) # количество символов в строке\n",
    "\n",
    "# список\n",
    "words = sentence.split()\n",
    "print(len(words)) # количество элементов в списке\n",
    "\n",
    "# кортеж\n",
    "words_tup = tuple(words)\n",
    "print(len(words_tup)) # количество элементов в кортеже\n",
    "\n",
    "# множество\n",
    "words_set = set(words)\n",
    "print(len(words_set)) # количество элементов в множестве"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С числовыми данными такого сделать не получится!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "object of type 'int' has no len()",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-29-2a603e6ce0dc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m34\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: object of type 'int' has no len()"
     ]
    }
   ],
   "source": [
    "x = 34\n",
    "print(len(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### sum()\n",
    "\n",
    "Эта функция принимает на вход один аргумент -- какую либо структуру данных, внутри которой лежат целые и/или дробные числа, и складывает их."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "78\n",
      "89.9\n",
      "915\n"
     ]
    }
   ],
   "source": [
    "# сумма чисел в кортеже\n",
    "print(sum((5, 8, 56, 9))) # давайте посчитаем скобки!\n",
    "\n",
    "# сумма чисел в списке\n",
    "print(sum([78, 4, 7.9])) # внутри могут быть и целые, и дробные числа\n",
    "\n",
    "# сумма чисел в множестве\n",
    "my_set = set([7, 34, 874])  # здесь список превращается в множество\n",
    "print(sum(my_set))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если внутри кортежа, списка или множества **не** числовые даные, то ничего не получится!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-35-f2373e20e81b>\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[1;33m(\u001b[0m\u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'cat'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'dog'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'elephant'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "print(sum(['cat', 'dog', 'elephant']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Наверное, вы уже обратили внимание на то, что аргументом функции может быть другая функция, как в некоторых из приведенных выше примеров."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "89.9\n",
      "21\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# sum() -- аргумент print(), список [78, 4, 7.9] -- аргумент sum()\n",
    "print(sum([78, 4, 7.9]))  \n",
    "\n",
    "# len() -- аргумент print(), переменная sentence -- аргумент len()\n",
    "print(len(sentence))\n",
    "\n",
    "# len() -- аргумент print(), константа \"cat\" -- аргумент len()\n",
    "print(len(\"cat\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Это называется **вложенностью** и очень удобно, когда не хочется плодить лишние переменные. Однако лучше ею не злоупотреблять! Вот такое выражение прекрасно работает, однако человеку его понять достаточно сложно (а в питоне, как мы помним, понятность для человека -- одно из важнейших правил написания кода)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n"
     ]
    }
   ],
   "source": [
    "print(float(len(set(('cat', 'dog', 'cat')))))  # что тут произошло?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### count()\n",
    "\n",
    "`count()` -- это метод, позволяющий считать количество вхождений указанного аргумента в строке, в списке или в кортеже. Поскольку это метод, пишется он через точку после константы/переменной."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# в строке\n",
    "print(\"the cat is on the mat\".count(\"the\"))\n",
    "\n",
    "# в кортеже\n",
    "print((2, 2, 3, 2, 2, 8).count(2))\n",
    "\n",
    "# в списке\n",
    "print([True, False, False, True, True].count(True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Множества - особенная структура данных, чем-то похожая и на массив, и на словарь, но от них отличающаяся.\n",
    "\n",
    "Как и массивы, множества содержат элементы. Но в отличие от массивов, где элементы упорядочены, в множестве они идут в \"произвольном\" порядке (для компьютера он, конечно, не произвольный, а обусловленный рядом технических причин, для человека не очевидных).\n",
    "\n",
    "На словари множества похожи тем, что, как и ключи в словарях, элементы множеств должны быть уникальны, и не следуют в фиксированном порядке. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "# вот так можно превратить массив в множство:\n",
    "\n",
    "a = [1, 2, 3, 1, 2, 3]\n",
    "s = set(a)\n",
    "print (s)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}