01_Начало.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [Программирование на Python (SCS)](https://compscicenter.ru/courses/python/2015-autumn/classes/)\n",
    "\n",
    "\n",
    "# §I. Типы данных"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. None\n",
    "\n",
    "`None` - это объект, и имеет свой тип, а так же это это [Singleton](https://en.wikipedia.org/wiki/Singleton_pattern):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "print(type(None))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Логический тип \n",
    "\n",
    "* Все логические операции леневые\n",
    "* Логические типы наследуются от целочисленного"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "print(type(False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "issubclass(bool, int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False + True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Числовые типы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "print(type(42))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(type(42.0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "print(type(42j))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Деление int на int это float. 16 / 3 = 5.333333333333333\n",
      "Целочисленное деление это '//'. 16 // 3 = 5\n",
      "Для получение остатка от деления используйте '%'. 16 % 3 = 1\n"
     ]
    }
   ],
   "source": [
    "# Важно помнить, что:\n",
    "print(f\"Деление int на int это float. 16 / 3 = {16 / 3}\")\n",
    "print(f\"Целочисленное деление это '//'. 16 // 3 = {16 // 3}\")\n",
    "print(f\"Для получение остатка от деления используйте '%'. 16 % 3 = {16 % 3}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Байтовая строка\n",
    "* байтовые строки можно декодировать в выбранной кодировке"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "string = b'foo bar'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "string=b'foo bar' и имеет тип <class 'bytes'>\n"
     ]
    }
   ],
   "source": [
    "print(f\"string={string} и имеет тип {type(string)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "string=foo bar и имеет тип <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(f\"string={string.decode('utf-8')} и имеет тип {type(string.decode('utf-8'))}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Строки\n",
    "\n",
    "### 5.1. Символьная строка (сырая строка)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "string = r'Это сырая строка содержащая \\t странный символ, и еще этот \\n !'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "string='Это сырая строка содержащая \\t странный символ, и еще этот \\n !' и имеет тип <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(f\"string='{string}' и имеет тип {type(string)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Её отличие от обычной строки заключаеться в том, что все [управляющие символы](https://en.wikipedia.org/wiki/Control_character) в ней экронированы.\n",
    "\n",
    "### 5.2. Обычная строка"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "string = 'Это сырая строка содержащая \\t странный символ, и еще этот \\n !'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "string='Это сырая строка содержащая \t странный символ, и еще этот \n",
      " !' и имеет тип <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(f\"string='{string}' и имеет тип {type(string)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.3. Форматированная строка\n",
    "имеет возможность выполнять код в нутри себя"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "string = f'Сумма 2 + 2 = {2 + 2}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Сумма 2 + 2 = 4'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "string='Сумма 2 + 2 = 4' и имеет тип <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(f\"string='{string}' и имеет тип {type(string)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Для небольшого удобства введем функцию. Пока мы не будем вдоваться в подробноси её действия,\n",
    "# но она нам поможет видить методы которые нам доступны для действия с объектами.\n",
    "def get_method(method: type) -> str:\n",
    "    \"\"\" Возвращает список всех доступных методов у объекта.\n",
    "    \"\"\"\n",
    "    return \"\\n\".join(tuple(method for method in dir(method) if method[0] != '_' ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bit_length\n",
      "conjugate\n",
      "denominator\n",
      "from_bytes\n",
      "imag\n",
      "numerator\n",
      "real\n",
      "to_bytes\n"
     ]
    }
   ],
   "source": [
    "# Список доступных методов у объекта тип:\n",
    "# int\n",
    "print(get_method(int))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "as_integer_ratio\n",
      "conjugate\n",
      "fromhex\n",
      "hex\n",
      "imag\n",
      "is_integer\n",
      "real\n"
     ]
    }
   ],
   "source": [
    "# float\n",
    "print(get_method(float))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "conjugate\n",
      "imag\n",
      "real\n"
     ]
    }
   ],
   "source": [
    "# complex\n",
    "print(get_method(complex))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "capitalize\n",
      "casefold\n",
      "center\n",
      "count\n",
      "encode\n",
      "endswith\n",
      "expandtabs\n",
      "find\n",
      "format\n",
      "format_map\n",
      "index\n",
      "isalnum\n",
      "isalpha\n",
      "isdecimal\n",
      "isdigit\n",
      "isidentifier\n",
      "islower\n",
      "isnumeric\n",
      "isprintable\n",
      "isspace\n",
      "istitle\n",
      "isupper\n",
      "join\n",
      "ljust\n",
      "lower\n",
      "lstrip\n",
      "maketrans\n",
      "partition\n",
      "replace\n",
      "rfind\n",
      "rindex\n",
      "rjust\n",
      "rpartition\n",
      "rsplit\n",
      "rstrip\n",
      "split\n",
      "splitlines\n",
      "startswith\n",
      "strip\n",
      "swapcase\n",
      "title\n",
      "translate\n",
      "upper\n",
      "zfill\n"
     ]
    }
   ],
   "source": [
    "# str\n",
    "print(get_method(str))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Для всех`(???)` индексируемых* типов можно использовать срезы. \n",
    "\n",
    "к `индексируемые` типам можно отнести - `string`, `list` и `tuple`.\n",
    "\n",
    "`item[START:STOP:STEP]` - берёт срез от номера `START`, до `STOP` (_не включая его_), с шагом `STEP`. По умолчанию `START = 0`, `STOP = длине объекта`, `STEP = 1`. Соответственно, какие-нибудь (а возможно, и все) параметры могут быть опущены.\n",
    "\n",
    "*Следует помнить, что в `Python` индексация циклична*\n",
    "\n",
    "|'S'|'t'|'r'|'i'|'n'|'g'|\n",
    "|:-:|:-:|:-:|:-:|:-:|:-:|\n",
    "| 0 | 1 | 2 | 3 | 4 | 5 |\n",
    "| -6| -5| -4| -3| -2| -1|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Список"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Список в `Python` - это изменяемая коллекция произвоньных типов."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "# Самый простой способ создать список это использовать создание объекта типа list\n",
    "new_list = list('String') # Создаем список из символьной строки. Можно создать пустой список `new_list = list()`\n",
    "# проверим...\n",
    "print(type(new_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'g'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# К элементу списка можно обратится по индексу\n",
    "new_list[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "с индектом '0' new_list[0]=S, а так же от '-6' new_list[-6]=S\n"
     ]
    }
   ],
   "source": [
    "print(f\"с индектом '0' new_list[0]={new_list[0]}, а так же от '-6' new_list[-6]={new_list[-6]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "с индектом '3' new_list[3]=i, а так же от '-3' new_list[-3]=i\n"
     ]
    }
   ],
   "source": [
    "print(f\"с индектом '3' new_list[3]={new_list[3]}, а так же от '-3' new_list[-3]={new_list[-3]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "append\n",
      "clear\n",
      "copy\n",
      "count\n",
      "extend\n",
      "index\n",
      "insert\n",
      "pop\n",
      "remove\n",
      "reverse\n",
      "sort\n"
     ]
    }
   ],
   "source": [
    "# Выведем доступные методы действия с объектом list\n",
    "print(get_method(list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']\n"
     ]
    }
   ],
   "source": [
    "# А еще списки можно складывать между собой\n",
    "hello = ['H', 'e', 'l', 'l', 'o']\n",
    "space = [' ']\n",
    "world = ['w', 'o', 'r', 'l', 'd']\n",
    "result = hello + space + world\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['H', 'e', 'l', 'l', 'o', ' ', ' ', ' ', ' ', ' ', 'w', 'o', 'r', 'l', 'd']\n"
     ]
    }
   ],
   "source": [
    "# и умножать список на число\n",
    "result = hello + space * 5 + world\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['H', 'e', 'l', 'l', 'o', '*', '*', '*', '*', '*', 'w', 'o', 'r', 'l', 'd']\n"
     ]
    }
   ],
   "source": [
    "# Изменение значения по индексу\n",
    "space[0] = '*'\n",
    "result = hello + space * 5 + world\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Кортеж\n",
    "\n",
    "Кортеж, по сути - неизменяемый список.\n",
    "\n",
    "Зачем нужны кортежи, если есть списки?\n",
    "* Защита от дурака. То есть кортеж защищен от изменений, как намеренных (что плохо), так и случайных (что хорошо).\n",
    "* Меньший размер. Дабы не быть голословным:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "объем занимаемой памяти a = 72 c типом <class 'tuple'>, а list = 88 c c типом <class 'list'>\n"
     ]
    }
   ],
   "source": [
    "a = (1, 2, 3, 4, 5, 6)\n",
    "b = [1, 2, 3, 4, 5, 6]\n",
    "print(f\"объем занимаемой памяти a = {a.__sizeof__()} c типом {type(a)}, а list = {b.__sizeof__()} c c типом {type(b)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count\n",
      "index\n"
     ]
    }
   ],
   "source": [
    "# Методы у tuple\n",
    "print(get_method(tuple))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-34-b2d1eea55f3b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Защита от \"дурака\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# Защита от \"дурака\"\n",
    "a[3] = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Множества\n",
    "\n",
    "**Множество** (_Set_) — это «мешок», содержащий неупорядоченные уникальные значения. Одно множество может содержать значения любых типов. Если у вас есть два множества, вы можете совершать над ними любые стандартные перации, например: объединение, пересечение и разность."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "add\n",
      "clear\n",
      "copy\n",
      "difference\n",
      "difference_update\n",
      "discard\n",
      "intersection\n",
      "intersection_update\n",
      "isdisjoint\n",
      "issubset\n",
      "issuperset\n",
      "pop\n",
      "remove\n",
      "symmetric_difference\n",
      "symmetric_difference_update\n",
      "union\n",
      "update\n"
     ]
    }
   ],
   "source": [
    "# Создать пустое множество можно так\n",
    "a = set()\n",
    "# методы у `set`\n",
    "print(get_method(set))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " a - это <class 'set'> и состоит из:{1, 2, 3, 4, 5}\n",
      " b - это <class 'set'> и состоит из:{5, 6, 7, 8, 9}\n"
     ]
    }
   ],
   "source": [
    "a = set([1, 2, 3, 4, 5, 5])\n",
    "b = set([5, 5 ,6, 7, 8, 9])\n",
    "c = set([3, 6, 9])\n",
    "\n",
    "print(f\" a - это {type(a)} и состоит из:{a}\")\n",
    "print(f\" b - это {type(b)} и состоит из:{b}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{5}"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# пересечение нескольких множеств\n",
    "a & b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7, 8, 9}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# объединение нескольких множеств\n",
    "a | b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 6, 7, 8, 9}"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# множество из элементов, встречающихся в одном множестве, но не встречающиеся в обоих\n",
    "a ^ b\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 6, 7, 8, 9}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.symmetric_difference(b)  # = ^"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{5}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.union(b, c) - a.symmetric_difference(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# множество из всех элементов 'a', не принадлежащие ни одному из 'b'\n",
    "a - b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{6, 7, 8, 9}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# множество из всех элементов 'b', не принадлежащие ни одному из 'a'\n",
    "b - a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. Словарь\n",
    "\n",
    "Словарь - неупорядоченные коллекции произвольных объектов с доступом по ключу. Их иногда ещё называют ассоциативными массивами или хеш-таблицами."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Это словарь:{'language': 'Python', 'version': '3.6'}\n",
      "Это его ключи dict_keys(['language', 'version'])\n",
      "Это его значения dict_values(['Python', '3.6'])\n",
      "А еще можно обратиться так my_dict['language'] и получить значение Python\n"
     ]
    }
   ],
   "source": [
    "# Словари — неупорядоченные наборы пар вида ключ-значение.\"\n",
    "my_dict = {'language': 'Python', 'version': '3.6'}\n",
    "print(f\"Это словарь:{my_dict}\")\n",
    "print(f\"Это его ключи {my_dict.keys()}\")\n",
    "print(f\"Это его значения {my_dict.values()}\")\n",
    "print(f\"А еще можно обратиться так my_dict['language'] и получить значение {my_dict['language']}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_dict.keys():dict_keys(['language', 'version']) и имеет тип:<class 'dict_keys'>\n",
      "my_dict.values():dict_values(['Python', '3.6']) и имеет тип:<class 'dict_values'>\n",
      "my_dict.items():dict_items([('language', 'Python'), ('version', '3.6')]) и имеет тип:<class 'dict_items'>\n"
     ]
    }
   ],
   "source": [
    "# с каждым словарём связаны три коллекции:\n",
    "# dict.keys() – реализует интерфейс множества\n",
    "print(f\"my_dict.keys():{my_dict.keys()} и имеет тип:{type(my_dict.keys())}\")\n",
    "# dict.values()\n",
    "print(f\"my_dict.values():{my_dict.values()} и имеет тип:{type(my_dict.values())}\")\n",
    "# dict.items()\n",
    "print(f\"my_dict.items():{my_dict.items()} и имеет тип:{type(my_dict.items())}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# конструкции in dict и not in dict проверяют наличие или отсутствие ключа в словаре\n",
    "\"version\" in my_dict.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(\"Python\") not in my_dict.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Встроенные типы можно разделить на две группы\n",
    "\n",
    "**mutable** and **immutable** types (__изменяемые и неизменяемые типы__)\n",
    "\n",
    "**mutable** (изменяемые)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The following are some mutable objects:\n",
    "# list\n",
    "# dict\n",
    "# set\n",
    "# bytearray\n",
    "# user-defined classes (unless specifically made immutable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**immutable** (неизменяемые)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The following are some immutable objects:\n",
    "# int\n",
    "# float\n",
    "# decimal\n",
    "# bool\n",
    "# string\n",
    "# tuple\n",
    "# range\n",
    "# bytes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Первый адрес 1420648736 второй адрес 1420648768.\n",
      "Адреса одинаковые? False\n"
     ]
    }
   ],
   "source": [
    "# Создаем переменную\n",
    "a = 5\n",
    "# Получаем адрес переменной\n",
    "first_adr = id(a)\n",
    "# изменяем значение переменной\n",
    "a = 6\n",
    "# Получаем адрес переменной\n",
    "last_adr = id(a)\n",
    "# Проверим, что у нас получилось\n",
    "print(f\"Первый адрес {first_adr} второй адрес {last_adr}.\")\n",
    "print(f\"Адреса одинаковые? {first_adr == last_adr}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Первый адрес 1973425120328 второй адрес 1973425120328.\n",
      "Адреса одинаковые? True\n"
     ]
    }
   ],
   "source": [
    "# Создаем список\n",
    "a = [5, 7 , 13]\n",
    "# Получаем адрес переменной\n",
    "first_adr = id(a)\n",
    "# изменяем значение в листе\n",
    "a[1] = 6\n",
    "# Получаем адрес переменной\n",
    "last_adr = id(a)\n",
    "# Проверим, что у нас получилось\n",
    "print(f\"Первый адрес {first_adr} второй адрес {last_adr}.\")\n",
    "print(f\"Адреса одинаковые? {first_adr == last_adr}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Что мы получили?\n",
    "Данный результат ознаечает, что при использование **immutable (неизменяемые)** мы всегда получаем новый объект, а при использование **mutable (изменяемые)** объект остается тот же самый, если он умещаеться в выделенный диапазон памяти."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Управляющие конструкции"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### if ... elif ... else ...\n",
    "\n",
    "**Условная инструкция `if`-`elif`-`else`** (её ещё иногда называют оператором ветвления) - основной инструмент выбора в Python. Проще говоря, она выбирает, какое действие следует выполнить, в зависимости от значения переменных в момент проверки условия."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buzz\n"
     ]
    }
   ],
   "source": [
    "x = 42\n",
    "if x % 5 == 0:\n",
    "    print(\"fizz\")\n",
    "elif x % 3 == 0:\n",
    "    print(\"buzz\")\n",
    "else:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Тернарный оператор\n",
    "\n",
    "Мотивация для такого решание оисана в [PEP-308](https://www.python.org/dev/peps/pep-0308/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'even'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"even\" if x % 2 == 0 else \"odd\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Операторы цикла\n",
    "\n",
    "`while` и `for`\n",
    "\n",
    "`While` - один из самых универсальных циклов в Python, поэтому довольно медленный. Выполняет тело цикла до тех пор, пока условие цикла истинно."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 10:\n",
    "    i +=1\n",
    "\n",
    "i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`for` уже чуточку сложнее, чуть менее универсальный, но выполняется гораздо быстрее цикла `while`. Этот цикл проходится по любому итерируемому объекту (например строке или списку), и во время каждого прохода выполняет тело цикла."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum = 0\n",
    "for i in range(1, 5):\n",
    "    sum += i*i\n",
    "\n",
    "sum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Оператор `continue` начинает следующий проход цикла, минуя оставшееся тело цикла (`for` или `while`).\n",
    "\n",
    "Оператор `break` досрочно прерывает цикл."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Волшебное слово** `else`\n",
    "\n",
    "Слово `else`, примененное в цикле `for` или `while`, проверяет, был ли произведен выход из цикла инструкцией `break`, или же \"естественным\" образом. Блок инструкций внутри `else` выполнится только в том случае, если выход из цикла произошел без помощи `break`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "What on earth is this\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i:\n",
    "    print(i)\n",
    "    i -= 1\n",
    "else:\n",
    "    print(\"What on earth is this\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Функция `range`\n",
    "\n",
    "`range(lower_bound, upper_bound, step_size)`\n",
    "\n",
    "Разница `range` и `xrange`\n",
    "\n",
    "**Python 2.7.x:**\n",
    "\n",
    "`range()` -> return list    \n",
    "`xrange()` -> return xrange    \n",
    "\n",
    "**Python 3.x:**\n",
    "\n",
    "`range()` -> return class 'range'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'range'>\n",
      "0\n",
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "print(type(range(10)))\n",
    "# Функция range – возвращает специальный объект – итератор – реализующий полуоткрытый интервал.\n",
    "for i in range(0, 6, 2):\n",
    "   print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "2\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "# Функция reversed – возвращает обратный итератор, работает даже со строками.\n",
    "\n",
    "for i in reversed(range(0, 6, 2)):\n",
    "   print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Zen of Python, by Tim Peters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}