python test geekbrains medium.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Тест geekbrains \n",
    "# Python. Уровень сложности <font color=blue><b>средний</b></font>\n",
    "### Задание 1\n",
    "Что будет выведено в консоль в результате выполнения следующего кода?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вызов __getattr__(foo)\n",
      "Значение для foo\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "class Slack:\n",
    "    def __init__(self):\n",
    "        self.exists = True\n",
    "        \n",
    "    def __getattr__(self, name):\n",
    "        print('Вызов __getattr__({})'.format(name))\n",
    "        value = 'Значение для {}'.format(name)\n",
    "        setattr(self, name, value)\n",
    "        return value\n",
    "    \n",
    "data = Slack()  \n",
    "print(data.foo)\n",
    "data.foo = 13\n",
    "print(data.foo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вызов __getattribute__(foo)\n",
      "Значение для foo\n",
      "Вызов __getattribute__(foo)\n",
      "Значение для foo\n"
     ]
    }
   ],
   "source": [
    "# getattribute страшный метод - рекурсия за рекурсией рекурсией погоняет\n",
    "class Slack:\n",
    "    def __init__(self):\n",
    "        self.exists = True\n",
    "        \n",
    "    def __getattribute__(self, name):\n",
    "        print('Вызов __getattribute__({})'.format(name))\n",
    "        value = 'Значение для {}'.format(name)\n",
    "        setattr(self, name, value)\n",
    "        return value\n",
    "    \n",
    "data = Slack()  \n",
    "print(data.foo)\n",
    "data.foo = 13\n",
    "print(data.foo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A key difference between `__getattr__` and `__getattribute__` is that `__getattr__` is only invoked if the attribute wasn't found the usual ways. It's good for implementing a fallback for missing attributes, and is probably the one of two you want.\n",
    "\n",
    "`__getattribute__` is invoked before looking at the actual attributes on the object, and so can be tricky to implement correctly. You can end up in infinite recursions very easily.\n",
    "\n",
    "New-style classes derive from object, old-style classes are those in Python 2.x with no explicit base class. But the distinction between old-style and new-style classes is not the important one when choosing between `__getattr__` and `__getattribute__`.\n",
    "\n",
    "You almost certainly want `__getattr__`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "class Slack:\n",
    "    def __init__(self):\n",
    "        self.foo = -1\n",
    "\n",
    "    def __getattr__(self, name):\n",
    "        setattr(self, name, 1)\n",
    "        return 11\n",
    "\n",
    "    def __getattribute__(self, name):\n",
    "        return super(Slack, self).__getattribute__(name) + 1\n",
    "\n",
    "    def __setattr__(self, name, value=0):\n",
    "        super().__setattr__(name, value)\n",
    "\n",
    "data = Slack()\n",
    "data.foo    += 1\n",
    "print(data.foo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При доступе к атрибуту объекта на чтение происходит вызов метода:\n",
    "\n",
    "Ответ: `__getattribute__`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 2\n",
    "Укажите способ защиты от SQL-инъекции в данном коде:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = input(\"Укажите артикул товара: \")\n",
    "curr = conn.cursor()\n",
    "curr.execute(\"SELECT * FROM GOOD WHERE art_num = %d\" % num)\n",
    "res = curr.fetchall()\n",
    "print(res)\n",
    "conn.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "- Делать запрос только строго определенных столбцов таблицы, избегать симовола *;\n",
    "- В данном коде нет SQL-инъекции;\n",
    "- Исключить ввод данных пользователя;\n",
    "- <font color=red>Невозможно защититься от SQL-инъекции в данном коде;</font>\n",
    "- <font color=green>Использовать параметрозованный запрос, параметры передавать второым аргументом функции exec?</font>\n",
    "- Выполнить проверку введенных данных на принадлежность типу int."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = input(\"Укажите артикул товара: \")  #1\n",
    "curr = conn.cursor()  # 2\n",
    "curr.execute(\"SELECT GOOD WHERE art_num = {}\".format(num)) #3\n",
    "res = curr.fetchall()  #4\n",
    "print(res) #5\n",
    "conn.close()     #6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=red>В данном коде нет проблем</font><br>\n",
    "Не выполнена обработка исключений блоком try..except<br>\n",
    "<font color=green>Возможна SQL-инъекция в строке 3</font><br>\n",
    "<font color=red>не выполнено приведение к целому числу в строке 1</font><br>\n",
    "<font color=red>Не выполнено подтверждение (commit) транзакции перед строкой 6</font><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 3\n",
    "Укажите последовательность вызова методов класса Stranger в след. коде:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z \n",
      "__mul__\n",
      "<class '__main__.Stranger'><class '__main__.Stranger'><class '__main__.Stranger'><class '__main__.Stranger'><class '__main__.Stranger'><class '__main__.Stranger'><class '__main__.Stranger'><class '__main__.Stranger'><class '__main__.Stranger'>\n"
     ]
    }
   ],
   "source": [
    "class Stranger:\n",
    "    def __init__(self, x):\n",
    "        print(\"__init__\")\n",
    "        self.x = x\n",
    "\n",
    "    @classmethod\n",
    "    def __str__(self):\n",
    "        print(\"__str__\")\n",
    "        return str(self.x)\n",
    "\n",
    "    @classmethod\n",
    "    def __mul__(self, n=5):\n",
    "        print(\"__mul__\")\n",
    "        return str(self) * n\n",
    "\n",
    "    def z(self, n=7):\n",
    "        print(\"z \")\n",
    "        return self * n\n",
    "\n",
    "\n",
    "s = Stranger.__new__(Stranger)  # create a new obj with type Stranger\n",
    "setattr(s, 'x', 11)             # call __setattr__ method\n",
    "print(s.z(9))                   # call z() method that call __mul__ method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-<font color=green> z, __mul__  </font>\n",
    "- (no)z, __mul__, __str__\n",
    "- __init__, z, __mul__\n",
    "- __init__, z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__init__\n",
      "Help on built-in function __new__:\n",
      "\n",
      "__new__(*args, **kwargs) method of builtins.type instance\n",
      "    Create and return a new object.  See help(type) for accurate signature.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Stranger(2).__new__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "init\n",
      "static\n",
      "63\n"
     ]
    }
   ],
   "source": [
    "class Stranger:\n",
    "    def __init__(self, x):\n",
    "        print(\"init\")\n",
    "        self.x = x\n",
    "\n",
    "    def __str__(self):\n",
    "        print(\"str\")\n",
    "        return str(self.x)\n",
    "\n",
    "    def __mul__(self, n=5):\n",
    "        print(\"mul\")\n",
    "        return str(self) * n\n",
    "\n",
    "    @staticmethod\n",
    "    def z(self, n=7):\n",
    "        print(\"static\")\n",
    "        return self * n\n",
    "\n",
    "\n",
    "s = Stranger(3)\n",
    "print(s.z(9))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 4\n",
    "Что будет выведено в консоль в результате следующего кода:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "E\n",
      "C\n"
     ]
    }
   ],
   "source": [
    "class A(object):\n",
    "    def __init__(self):\n",
    "        print(\"A\")\n",
    "    \n",
    "class B(object):\n",
    "    def __init__(self):\n",
    "        print(\"B\")\n",
    "        super().__init__()\n",
    "        \n",
    "class C(A, B):\n",
    "    def __init__(self):\n",
    "        print(\"C\")   # FINISH!\n",
    "        \n",
    "class D(A, B):\n",
    "    def __init__(self):\n",
    "        print(\"D\")\n",
    "        super().__init__()\n",
    "        \n",
    "class E(C, D):\n",
    "    def __init__(self):\n",
    "        print(\"E\")\n",
    "        super().__init__()\n",
    "        \n",
    "e = E()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[__main__.E, __main__.C, __main__.D, __main__.A, __main__.B, object]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E.mro()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 5\n",
    "#### Укажите назначение метаклассов в Python:\n",
    "\n",
    "Проверка наличия требуемых атрибутов и методов у дочерних классов\n",
    "\n",
    "Управление доступом к ресурсам\n",
    "\n",
    "Управление доступом к атрибутам класса\n",
    "\n",
    "<font color=green>Управление созданием новых классов</font>\n",
    "\n",
    "<font color=red>Изменение/дополнение поведения функции/класса</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 6\n",
    "Укажите результат выполнения кода:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'NoneType' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-17-19389fb458f8>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0ms\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"str to int\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0ms\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msplit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minsert\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"zzz\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\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[1;31mTypeError\u001b[0m: 'NoneType' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "s = \"str to int\"\n",
    "x = s.split().insert(0, \"zzz\")  # insert() doesn't return a list!\n",
    "print(x[0])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=green>Данный код не будет выполнен</font><br>\n",
    "to<br>\n",
    "str<br>\n",
    "int<br>\n",
    "<font color=red>zzz</font><br>\n",
    "zzztr<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 7???\n",
    "Имеется функция Insert_data и тест для этой функции. Укажите параметры теста, которые необходимо добавить к данному тесту\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def insert_data(line, paste):\n",
    "    '''Заменяет первое хождение подстроки, \n",
    "    обрамлённой тегами -, в строке line на строку paste.\n",
    "    Вложенные теги не учитываются.\n",
    "    Замена производится вместе с тегами.\n",
    "    '''\n",
    "    res = line\n",
    "    start = line.find('')\n",
    "    end = line.find('')\n",
    "    if -1 < start < end:\n",
    "        res = line[:start] + paste + line[end+5:]\n",
    "    return res\n",
    "\n",
    "import pytest\n",
    "\n",
    "@pytest.mark.parametrize('line, paste, res', [\n",
    "                         ('', '', ''),\n",
    "                         ('Some text to be replaced ', 'zzz', 'Some text zzz'),\n",
    "                         ('Some text.', 'zzz', 'Some text.'),\n",
    "                         ('Some text ', 'zzz', 'Some text zzz'),\n",
    "                         ('Some text', 'zzz', 'zzz'),\n",
    "                         ('Some text', 'zzz', 'Some text'),\n",
    "                         ('Some text', 'zzz', 'Some text'),\n",
    "                         ])\n",
    "def test_insert(line, paste, res):\n",
    "    assert insert_data(line, paste) == res\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'insert_data' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-82-1303753ec4f6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0minsert_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Some text to be replaced \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"zzz\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'insert_data' is not defined"
     ]
    }
   ],
   "source": [
    "insert_data(\"Some text to be replaced \", \"zzz\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def insert_data(line, paste):\n",
    "    '''Заменяет первое хождение подстроки, \n",
    "    обрамлённой тегами -, в строке line на строку paste.\n",
    "    Вложенные теги не учитываются.\n",
    "    Замена производится вместе с тегами.\n",
    "    '''\n",
    "    res = line\n",
    "    start = line.find('<START>')\n",
    "    end = line.find('<END>')\n",
    "    if -1 < start < end:\n",
    "        res = line[:start] + paste + line[end + 5:]\n",
    "    return res\n",
    "\n",
    "\n",
    "import pytest\n",
    "\n",
    "\n",
    "@pytest.mark.parametrize('line, paste, res', [\n",
    "    ('', '', ''),\n",
    "    ('Some text <START> to be replaced <END>', 'zzz', 'Some text zzz'),\n",
    "    ('Some text.', 'zzz', 'Some text.'),\n",
    "    ('Some text <START><END>', 'zzz', 'Some text zzz'),\n",
    "    ('<START>Some text<END>', 'zzz', 'zzz'),\n",
    "    ('Some text', 'zzz', 'Some text'),\n",
    "    # (\"Some text <START> to be replaced <END>!\", \"\", \"Some text!\"),\n",
    "    (\"\", \"zzz\", \"\"),\n",
    "    # (\"Some text <END> xxx <START>\", \"zzz\", \"Some txt zzz\"),\n",
    "    (\"Some text <END> xxx <START>\", \"zzz\", \"Some text <END> xxx <START>\"),\n",
    "    # (\"Some text <START> to be <END> replaced <END>\", \"zzz\", \"Some text zzz\"),\n",
    "\n",
    "])\n",
    "def test_insert(line, paste, res):\n",
    "    assert insert_data(line, paste) == res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### код отображается без тегов - попробовать в другом браузере, и пробовать ответ\n",
    "<font color=red>\"Приведенных параметров достаточно для тестирования данной функции\"</font>\n",
    "\n",
    "Ответ: ('Some text <START> to be <END> replaced <END>', 'zzz', 'Some text zzz') НЕВЕРЕН!!!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 8\n",
    "#### Укажите назначение дескрипторов в  Python\n",
    "\n",
    "Управление создание новых классов<br>\n",
    "<font color=green>Управление доступом к атрибутам класса</font><br>\n",
    "Проверка наличия требуемых атрибутов и методов у дочерних классов<br>\n",
    "Управление доступом к ресурсам<br>\n",
    "Изменение/дополнение поведения функции/класса<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 9\n",
    "Укажите что нужно выполнить, чтобы данных код выполнился:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Can't instantiate abstract class Zebrok with abstract methods drum",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-24-a0f6d6e6c2b0>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     19\u001b[0m \u001b[1;31m#         pass\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     20\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 21\u001b[1;33m \u001b[0mz\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mZebrok\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;32m     22\u001b[0m \u001b[0mz\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplan\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[0;32m     23\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: Can't instantiate abstract class Zebrok with abstract methods drum"
     ]
    }
   ],
   "source": [
    "import abc\n",
    "class Zebra(abc.ABC):\n",
    "    @abc.abstractmethod\n",
    "    def plan(self):\n",
    "        print('abc plan')\n",
    "    \n",
    "    @abc.abstractmethod\n",
    "    def drum(self):\n",
    "        print('abc drum')\n",
    "    \n",
    "class Zebrok(Zebra):\n",
    "    def __init__(self):\n",
    "        self.age = 17\n",
    "\n",
    "    def plan(self):\n",
    "        print(\"Great Plan\")\n",
    "\n",
    "#     def drum(self):\n",
    "#         pass\n",
    "    \n",
    "z = Zebrok()\n",
    "z.plan()\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=green>Реализовать метод drum в классе Zebrok</font><br>\n",
    "Класс Zebrock должен дополнительно наследоваться от класса abc.ABC<br>\n",
    "Ничего не нужно делать, код является рабочим<br>\n",
    "Объект z должен быть экземпляром класса Zebra, а не Zebrok<br>\n",
    "Реализовать метод __init__ в классе Zebra<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Can't instantiate abstract class Zebrok with abstract methods drum",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-83-2630393ce011>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     18\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 20\u001b[0;31m \u001b[0mz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mZebrok\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[1;32m     21\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplan\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;31mTypeError\u001b[0m: Can't instantiate abstract class Zebrok with abstract methods drum"
     ]
    }
   ],
   "source": [
    "import abc\n",
    "\n",
    "class Zebra(abc.ABC):\n",
    "    @abc.abstractmethod\n",
    "    def plan(self):\n",
    "        print(\"abc plan\")\n",
    "\n",
    "    @abc.abstractmethod\n",
    "    def drum(self):\n",
    "        print(\"abc drum\")\n",
    "\n",
    "class Zebrok(Zebra):\n",
    "    def __init__(self):\n",
    "        self.age = 17\n",
    "\n",
    "    def plan(self):\n",
    "        print(\"Great Plan\")\n",
    "\n",
    "\n",
    "z = Zebrok()\n",
    "z.plan()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ответ: Код не будет выполнен"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 10\n",
    "Что будет выведено в консоль в результате следующего кода:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "x = 13\n",
    "class C:\n",
    "    x = 2\n",
    "    print(x)  # выведет 2 при инициализации класса\n",
    "    \n",
    "    \n",
    "    def m(self):\n",
    "        print(x)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "i = C()\n",
    "i.m()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "i = C()\n",
    "i.m()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "k=C()\n",
    "k.m()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 11\n",
    "Какое значение будет храниться в переменной x в результате работы следующего кода?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def make_averager():\n",
    "    count = 0\n",
    "    total = 0\n",
    "    def averager(new_value):\n",
    "        nonlocal count, total\n",
    "        count += 1\n",
    "        total += new_value\n",
    "        return total / count\n",
    "    return averager\n",
    "\n",
    "avg = make_averager()\n",
    "for i in range(4):\n",
    "    x = avg(i)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 12\n",
    "Что будет выведено в консоль в результате следующего кода:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "class Stranger:\n",
    "    def __init__(self, x):\n",
    "        self.x = x\n",
    "        \n",
    "    def __str__(self):\n",
    "        return str(self.x)\n",
    "    \n",
    "    def __call__(self, n=5):\n",
    "        return self.x * n\n",
    "    \n",
    "    @classmethod\n",
    "    def z(self, n=7):\n",
    "        return self(n)\n",
    "    \n",
    "s = Stranger(3)\n",
    "print(s.z())\n",
    "#  в методе z() вызывается конструктор, а не call() Т.к. z это метод КЛАССА, значит self=Stranger\n",
    "# а не объект Stranger!!!!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 13???\n",
    "Укажите аналог следующего кода без оператора with\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with sqlite3.connect(\"db.sqlite3\") as conn:\n",
    "    cur = conn.cursor()\n",
    "    cur.execute(\"insert into info(data) values ('orbit')\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Connection objects can be used as context managers that automatically commit or rollback transactions. In the event of an exception, the transaction is rolled back; otherwise, the transaction is committed\n",
    "Поэтому эквивалент должен вызывать в случает исключения rollback(), в случае успеха - commit(), и finally - close()\n",
    ":\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Этот вариант НЕВЕРНЫЙ!!!!\n",
    "con = sqlite3.connect(\"db.sqlite3\")\n",
    "try:\n",
    "    cur = con.cursor()\n",
    "    cur.execute(\"insert into info(data) values ('orbit')\")\n",
    "except:\n",
    "    con.rollback()\n",
    "else:\n",
    "    con.commit()\n",
    "# finally:\n",
    "#     con.close()\n",
    "# Т.к. такого варианта нет - НИ один из вариантов!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 14\n",
    "Укажите назначение декоратора r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def r(obj):\n",
    "    a = obj.a = {}\n",
    "    def rr(*ar, **kwar):\n",
    "        y = str(ar) + str(kwar)\n",
    "        if y not in a:\n",
    "            a[y] = obj(*ar, **kwar)\n",
    "            return a[y]\n",
    "    return rr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Запоминание результатов вызова декорируемой функции/объекта"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 15\n",
    "Какие методы реализуют программный интерфейс менеджера контекста для оператора with?\n",
    "\n",
    "`__enter__, __exit__`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 16?\n",
    "Укажите результат выполенния теста и причину такого результата:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "def gray_rabbit_divider(x):\n",
    "    if x > 1:\n",
    "        return 10/x\n",
    "    elif x == 1:\n",
    "        raise ValueError\n",
    "    elif x == 0:\n",
    "        raise ZeroDivisionError\n",
    "    else:\n",
    "        pass\n",
    "    \n",
    "class BigTest(unittest.TestCase):\n",
    "    def test_me(self):\n",
    "        with self.assertRaises(ZeroDivisionError):\n",
    "            for x in range(6, -1, -2):\n",
    "                gray_rabbit_divider(x)\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    unittest.main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Тест не будет пройден, так как тестируемая функция создает исключение ValueError, которое не учитывается тестом<br>\n",
    "<font color=red>Тест успешно выполнится, так как тестируемая функция создаёт ожидаемоe исключение ZeroDivisionError</font><br>\n",
    "Тест не будет пройден так как тестируемая функция создает требуемое исключение не для любых входных данных<br>\n",
    "Тест успешно выполнится, так как тестируемая функция не создает ожидаемое исключение ZeroDivisionError<br>\n",
    "Тест не будет пройедн, так как тестируемая функция не создаёт исключение ZeroDivisionError<br>\n",
    "<font color=green>Тест успешно выполнится, так как тест не отражает полноты входных данных для тестируемой функции</font><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 17\n",
    "Укажите верный способ использования класса TestDescriptor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TestDescriptor():\n",
    "    def __init__(self, initial_value=None, name=\"значение\"):\n",
    "        self.var_name = name\n",
    "        self.value = initial_value\n",
    "        \n",
    "    def __get__(self, obj, objtype):\n",
    "        print(\"Получение\", self.var_name)\n",
    "        return self.value\n",
    "    \n",
    "    def __set__(self, obj, value):\n",
    "        msg = \"Установка {name} равным {value}\"\n",
    "        print(msg.format(name=self.var_name, value=value))\n",
    "        self.value = value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ответ НЕВЕРНЫЙ!!!!!\n",
    "class MyClass():\n",
    "    desc = TestDescriptor(initial_value='z', name='desc')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass():\n",
    "     desc = TestDescriptor(initial_value='z', name='desc')\n",
    "        \n",
    "# AND\n",
    "class MyClass():\n",
    "    def __init__(self):\n",
    "        self.desc = TestDescriptor(initial_value='z', name='desc')\n",
    "# НЕВЕРНО!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 18\n",
    "Укажите общую схему работы (последовательность функций/методов) работы с сокетом на стороне TCP-сервера\n",
    "\n",
    "socket(), bind(), listen(), accept(), recv()/send(), close()\n",
    "\n",
    "__клиента__?: socket(), connect(), sendall(), recv(), close()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 19\n",
    "Что проверяет тест BigTest?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "def white_rabbit_divider(x):\n",
    "    return 10 / x\n",
    "class BigTest(unittest.TestCase):\n",
    "    def test_me(self):\n",
    "        with self.asserNotRaises(ZeroDivision):\n",
    "            for x in range(5):\n",
    "                white_rabbit_divider(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ничего не проверяет - клас unittest.TestCase не содержит применяемой здесь функции проверки.\n",
    "Нет ни метода assetNotRaises ни исключения ZeroDivision"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 20\n",
    "Какие числа не будут выведены в консоль в резлуьтате работы кода?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14\n",
      "14\n",
      "14\n",
      "14\n"
     ]
    }
   ],
   "source": [
    "# Помему-то функции оперируют текущим значением i, которое после инициализации равно 13\n",
    "# Поэтому все функции вовращают 13 + х!!!\n",
    "def create_adders():\n",
    "    adders = []\n",
    "    for i in range(10, 14):\n",
    "        def adder(x):\n",
    "            return i + x\n",
    "        adders.append(adder)\n",
    "    return adders\n",
    "\n",
    "for adder in create_adders():\n",
    "    print(adder(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Задание 21\n",
    "Назначение менеджера контекста:\n",
    "управление доступом к ресурсам"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 22\n",
    "Укажите позицию в коде, когда будет срабатывать функционал метакласса Checker:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Checker(type):\n",
    "    def __new__(cls, name, bases, cls_dict):\n",
    "        return super().__new__(cls, name, bases, cls_dict)\n",
    "    \n",
    "class Experiment(metaclass=Checker):  # 1\n",
    "    counter = 0\n",
    "                                      # 2  \n",
    "    def __init__(self):                \n",
    "        self.state = 0                # 3 (no)\n",
    "        \n",
    "    def start(self):\n",
    "        self.state = 1\n",
    "                                      # 4   \n",
    "exp = Experiment()                    # 5 \n",
    "exp.start()                           # 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=red>наверно в 1 при инициалзации класса, метаклассом которого является Checker?</font><br>\n",
    "<font color=red>1</font><br>\n",
    "<font color=red>3</font><br>\n",
    "<font color=red>5</font><br>\n",
    "Пробуем 3 - инициализация класса"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 23\n",
    "Укажите проблему в данном коде:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = input(\"Укажите артикул товара: \")  #1\n",
    "curr = conn.cursor()  # 2\n",
    "curr.execute(\"SELECT GOOD WHERE art_num = {}\".format(num)) #3\n",
    "res = curr.fetchall()  #4\n",
    "print(res) #5\n",
    "conn.close()     #6\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 24\n",
    "Укажите что будет выведено в консоль в результате работы кода:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "class TrickyManager:\n",
    "    def __init__(self, lst):\n",
    "        self.worklist = lst\n",
    "        \n",
    "    def __enter__(self):\n",
    "        __builtins__.print = lambda x, f=open('trace.log', 'a'), \\\n",
    "        end='\\n': f.write(str(x))\n",
    "        return \"T-R-I-C-K-Y\"\n",
    "    \n",
    "    def __exit__(self, exc_type, exc_value, trace):\n",
    "        return True\n",
    "    \n",
    "with TrickyManager([1,2,3,4,5]) as t:\n",
    "    for c in t:\n",
    "        print(c, end=' ')\n",
    "    \n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "в консоль НИЧЕГО - print(t) вне менеджера контекста, а print(c...) пишет в 'trace.log'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 25\n",
    "Чему будет равно значение переменной global_resource в результате выполнения следующего кода?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "from threading import Thread, Lock\n",
    "\n",
    "COUNT = 1000000\n",
    "resource_lock = Lock()\n",
    "global_resource = 0\n",
    "\n",
    "def producer():\n",
    "    global global_resource\n",
    "    for i in range(COUNT):\n",
    "        global_resource += 1\n",
    "        \n",
    "def consumer():\n",
    "    global global_resource\n",
    "    for i in range(COUNT):\n",
    "        global_resource -= 1\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    t1 = Thread(target=producer)\n",
    "    t2 = Thread(target=consumer)\n",
    "    t1.start()\n",
    "    t2.start()\n",
    "    print(global_resource)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Значение не может быть строго определено, так как глобальная переменная изменяется в двух потоках без блокировок <br>\n",
    "Значение не может быть строго определено, так как не выоплняется присоединение к потокам методом join() <br>\n",
    "<font color=green>Значение не может быть строго определено, так как неизвествен момент завершения потоков - дочерние потоки завершатся вместе с основным потомом.</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter 1\n",
      "enter 2\n",
      "exit 2\n",
      "exit 1locked\n",
      "finish\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Что будет выведено в консоль в результате работы следующего кода:\n",
    "from threading import Thread, Lock\n",
    "\n",
    "d = Lock()\n",
    "def t_1(done):\n",
    "    print(\"enter 1\")\n",
    "    done.acquire()\n",
    "    done.acquire()\n",
    "    print(\"exit 1\")\n",
    "\n",
    "def t_2(done):\n",
    "    print(\"enter 2\")\n",
    "    done.release()\n",
    "    print(\"exit 2\")\n",
    "\n",
    "task1 = Thread(target=t_1, args=(d, ))\n",
    "task1.start()\n",
    "\n",
    "task2 = Thread(target=t_2, args=(d, ))\n",
    "task2.start()\n",
    "\n",
    "if d.acquire(False):\n",
    "    print(\"unlocked\")\n",
    "else:\n",
    "    print(\"locked\")\n",
    "\n",
    "    \n",
    "print(\"finish\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Результат выполнения разный (в данной версии питона), поэтому пробуем вариант:\n",
    "Выполнение данного кода невозможно, так как поток task2 не сможет освободить мьютекс, занятый потокм task1<br>\n",
    "\n",
    "---\n",
    "<font color=green>\n",
    "enter 1<br>\n",
    "enter 2<br>\n",
    "exit 2<br>\n",
    "exit 1<br>\n",
    "locked<br>\n",
    "</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 26\n",
    "Какой класс является базовым для класса А?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    pass\n",
    "# object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 27\n",
    "Метаклассы: https://habr.com/ru/post/145835/\n",
    "\n",
    "Что не так в коде ниже:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Z(type):                                   #1 \n",
    "    def __init__(self, clsname, bases, clsdict): #2\n",
    "        print(\"I am a metaclass\")                #3 \n",
    "        return type(clsname, bases, clsdict)     #4\n",
    "                                                 #5\n",
    "__metaclass__ = Z                                #6\n",
    "                                                 #7\n",
    "class A:                                         #8\n",
    "    def __init__(self):\n",
    "        self.x = B.x + 7                         #10\n",
    "        \n",
    "    def __call__(self):\n",
    "        return B()                               #13\n",
    "    \n",
    "class B():\n",
    "    x = 13\n",
    "    \n",
    "a = A()\n",
    "b = a()                                           #19\n",
    "print(a.x)\n",
    "print(b.x)                                        #21 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. (проверено)<font color=red>Строка 21 - обращение к атрибуту класса должно осуществляться по имени класса, то есть должно быть \"print(B.x)\".</font> Объекты класса разделяют и атрибуты класса<br>\n",
    "2. ?<font color=red>Строка 10 - обращение к ещё не существующему классу В.</font> Класс В имеет свой атрибут х=13, так что норм<br>\n",
    "3. ?<font color=red>Строка 13 - обращение к ещё не существующему классу В.</font> Классы определены до выполнения кода<br>\n",
    "4. ?<font color=red>Строка 4 - метод __init__ должен вернуть None. </font> нет, должен вернуть type - метод создания классов или его производные<br>\n",
    "5. (проверено)<font color=red>В представленном коде нет проблем.</font><br>\n",
    "6. ?<font color=red>Строка 19 - опечатка, должно быть \"b = B(). </font>В А определен метод call, так что норм<br>\n",
    "7.(проверено) <font color=red>Строка 6 - глобальная переменная __metaclass__ актуальна только для Pyhton 2.</font> __metaclass__ на уровне модуля сообщает о необходимости применения метакласса ко всем классам модуля. Работает и в Python3 но альтернатива - использование metaclass= в определении класса<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['x']"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Список атбибутов объекта класса а:\n",
    "[a for a in dir(b) if not a.startswith(\"__\") ] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 28\n",
    "Укажите порядок разрешения методов для класса Z\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[__main__.Z, __main__.X, __main__.Y, __main__.Base, object]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Base:\n",
    "    def __init__(self):\n",
    "        pass\n",
    "    \n",
    "class X(Base):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "class Y(Base):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "class Z(X, Y):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "Z.mro()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Z, object, Base, Y, X<br>\n",
    "Z, Y, X, Base, object<br>\n",
    "object, Base, X, Y, Z<br>\n",
    "<font color=green>Z, X, Y, Base, object</font><br>\n",
    "Z, X, Y, Base<br>\n",
    "Z, Base, X, Y<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 29\n",
    "Укажите порядок выполнения методов в следующем коде:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CheckCount(type):\n",
    "    def __init__(self, *args, **kwargs):  # 1\n",
    "        print(\"1\")\n",
    "        self.count = 0\n",
    "        super().__init__(*args, **kwargs)\n",
    "\n",
    "    def __call__(self, *args, **kwargs):  # 2\n",
    "        print(\"2\")\n",
    "        if self.count < 5:\n",
    "            self.count += 1\n",
    "            return super().__call__(*args, **kwargs)\n",
    "        else:\n",
    "            return None\n",
    "\n",
    "\n",
    "class SpaceX(metaclass=CheckCount):\n",
    "    def __init__(self):  # 3\n",
    "        print(\"3 Run To Space\")\n",
    "\n",
    "    def __call__(self):  # 4\n",
    "        print(\"4 Yes, I Can!\")\n",
    "\n",
    "\n",
    "x = SpaceX()\n",
    "x() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=green>1, 2, 3, 4</font> <br>\n",
    "Данный код не работает<br>\n",
    "2, 3, 1, 4<br>\n",
    "1, 3, 2, 4<br>\n",
    "1, 3, 4, 2<br>\n",
    "2, 1, 3, 4<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 30\n",
    "Что будет выведено в консоль в результате следующего кода:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[15, 30]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def make_multiplier_of(n):\n",
    "    lst = []\n",
    "    def multiplier(x, final=False):\n",
    "        lst.append(x * n)\n",
    "        if final:\n",
    "            print(lst)\n",
    "        return x * n\n",
    "    return multiplier\n",
    "\n",
    "times3 = make_multiplier_of(3)\n",
    "times5 = make_multiplier_of(5)\n",
    "\n",
    "times3(9)\n",
    "times5(3)\n",
    "times5(times3(2), True)\n",
    "#         Выводит только метод с True, причем выводится список резултатов выполнения\n",
    "# именно метода с True, т.е. times5, который верул 15 и 30 (6*5 = times3(2) * 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[15, 30, 20]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "times5(4, True)  # выведет ещё одно значение 20, полученное вызовом функции times5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 31\n",
    "Укажите код TCP-Клиента, соответствующего данному серверу:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from socket import *\n",
    "import time\n",
    "\n",
    "s = socket(AF_INET, SOCK_STREAM)\n",
    "s.bind(('', 8888))\n",
    "s.listen(5)\n",
    "\n",
    "while True:\n",
    "    client, addr = s.accept()\n",
    "    print(\"Получен запрос на соединение с %s\" % str(addr))\n",
    "    timestr = time.strftime(\"%Y.%m.%d %H:%M:%S\", time.localtime())\n",
    "    client.send(timestr.encode(\"ascii\"))\n",
    "    client.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=red>Ни один из вариантов</font>\n",
    "\n",
    "---\n",
    "```\n",
    "s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n",
    "s.connect((\"localhost\", 7888))\n",
    "tm = s.recv()    # TypeError: recv() takes at least 1 argument (0 given)\n",
    "s.close()\n",
    "print(f\"Текущее время: {tm.decode('ascii')}\")\n",
    "```\n",
    "---\n",
    "```\n",
    "s = socket.socket()\n",
    "s.connect((\"localhost\", 7888))\n",
    "tm = s.recv(1024)\n",
    "s.close()\n",
    "print(f\"Текущее время: {tm}\")\n",
    "\n",
    "\n",
    "```\n",
    "?Ответ: `Текущее время: b'2019.08.25 14:32:17'` (в виде байтов)\n",
    "\n",
    "---\n",
    "\n",
    "```\n",
    "s = socket.socket(socket.AF_INET)\n",
    "s.connect((\"localhost\", 7888))\n",
    "tm = s.recv(20)\n",
    "timeonly = tm.split(' ')[1]   # attempt to split bytes by str separator!!!\n",
    "s.close()\n",
    "print(f\"Текущее время: {timeonly}\")\n",
    "```\n",
    "---\n",
    "```\n",
    "s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\n",
    "s.connect((\"localhost\", 7888))\n",
    "tm = s.recv(19)\n",
    "s.close()\n",
    "print(f\"Текущее время: {tm.decode('ascii')}\")\n",
    "\n",
    "\n",
    "```\n",
    "Не тот тип сокета - SOCK_DGRAM вместо SOCK_STREAM - `ответа нет`!!!!\n",
    "\n",
    "---\n",
    "<font color=red>НЕТ</font>\n",
    "```\n",
    "s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n",
    "s.connect((\"\", 7888))\n",
    "tm = s.recv(1024)\n",
    "s.close()\n",
    "print(\"Текущее время: %s \" % tm.decode('ascii'))\n",
    "\n",
    "\n",
    "```\n",
    "Ответ: `Текущее время: 2019.08.25 14:38:25 `"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from socket import *\n",
    "import time\n",
    "\n",
    "s = socket(AF_INET, SOCK_STREAM)\n",
    "s.bind(('', 8888))\n",
    "s.listen(5)\n",
    "\n",
    "while True:\n",
    "    client, addr = s.accept()\n",
    "    print(\"Получен запрос на соединение с %s\" % str(addr))\n",
    "    tm = time.localtime()\n",
    "    datestr = time.strftime(\"%Y.%m.%d\", tm)\n",
    "    client.send(datestr.encode(\"ascii\"))\n",
    "    timestr = time.strftime(\"%H:%M:%S\", tm)\n",
    "    client.send(timestr.encode(\"ascii\") + \"\\n\")\n",
    "    client.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "No:\n",
    "import socket\n",
    "s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n",
    "s.connect((\"\", 8888))\n",
    "tm = s.recv(1024)\n",
    "s.close()\n",
    "print(\"Текущее время %s\" % tm.decode('ascii'))\n",
    "\n",
    "---\n",
    "Try:\n",
    "import socket\n",
    "s = socket.socket()\n",
    "s.connect((\"localhost\", 8888))\n",
    "tm = s.recv(1024)\n",
    "s.close()\n",
    "print(\"Текущее время: {}\".format(tm))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 32\n",
    "Укажите корректный способ обращения к сопрограмма df и pp в коде ниже, чтобы в консоль выдалиьс целочисленные данные"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def producer(dsta, next_task):\n",
    "    tokens = data.split(\";\")\n",
    "    for token in tokens:\n",
    "        next_task.send(token)\n",
    "    next_task.close()\n",
    "\n",
    "def df(tf=int, next_task=None):\n",
    "    try:\n",
    "        while True:\n",
    "            token = (yield)\n",
    "            try:\n",
    "                token = tf(token)\n",
    "            except:\n",
    "                pass\n",
    "            else:\n",
    "                next_task.send(token)\n",
    "    except GeneratorExit:\n",
    "        pass\n",
    "\n",
    "def pp():\n",
    "    try:\n",
    "        while True:\n",
    "            token = (yield)\n",
    "            print(\"->\", token)\n",
    "    except GeneratorExit:\n",
    "        pass\n",
    "\n",
    "data = \"Moscow;1147;-4\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "dt = df(next_task=pp)\n",
    "producer(data, dt)\n",
    "```\n",
    "TypeError: can't send non-None value to a just-started generator\n",
    "\n",
    "---\n",
    "```\n",
    "pt = pp()\n",
    "next(pt)\n",
    "dt = df(next_task=pt)\n",
    "next(dt)\n",
    "producer(data, dt)\n",
    "```\n",
    "<font color=green>\n",
    "-> 1147\n",
    "-> -4\n",
    "</font>\n",
    "\n",
    "---\n",
    "```\n",
    "pt = pp()\n",
    "next(pt)\n",
    "dt = df(pt)\n",
    "next(dt)\n",
    "producer(data, dt)\n",
    "```\n",
    "None\n",
    "\n",
    "---\n",
    "```\n",
    "pt = pp()\n",
    "dt=df(next_task=pt)\n",
    "producer(data, dt)\n",
    "```\n",
    "TypeError: can't send non-None value to a just-started generator\n",
    "\n",
    "---\n",
    "```\n",
    "dt = df()\n",
    "producer(data, dt)\n",
    "```\n",
    "TypeError: can't send non-None value to a just-started generator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 33\n",
    "Укажите проблему в реализации дескриптора атрибутов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Grade:\n",
    "    def __init__(self):\n",
    "        self._values = {}\n",
    "        \n",
    "    def __get__(self, instance, instance_type):\n",
    "        if instance is None:\n",
    "            return self\n",
    "        return self._values.get(instance, 1)\n",
    "    \n",
    "    def __set__(self, instance, value):\n",
    "        if not (1 <= value <=5):\n",
    "            raise ValueError(\"Оценка должна быть от 1 до 5\")\n",
    "        self._values[instance] = value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ответ: <font color=green>Для хранение данных внутри дескриптора используется словарь, что будет приводить к утечкам памяти.</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 34\n",
    "Что будет выведено в консоль в результате следующего кода:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.B'>\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    pass\n",
    "class B(A):\n",
    "    pass\n",
    "class C(A):\n",
    "    pass\n",
    "\n",
    "print(B.__bases__[0].__subclasses__()[0])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 35\n",
    "Что будет выведено в консоль в результате следующего кода:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class A\n",
      "Deco\n",
      "Create Work\n",
      "__init__\n"
     ]
    }
   ],
   "source": [
    "def usefull(cls):\n",
    "    print(\"Deco\")\n",
    "    return cls\n",
    "\n",
    "@usefull\n",
    "class A:\n",
    "    print(\"Class A\")\n",
    "    def __init__(self, x):\n",
    "        self.x = x\n",
    "        print(\"__init__\")\n",
    "        \n",
    "print(\"Create Work\")\n",
    "a = A(13)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Deco for class <class '__main__.A'>\n"
     ]
    }
   ],
   "source": [
    "# Исправьте ошибку в следующем коде\n",
    "\n",
    "def usefull(cls):\n",
    "    print(\"Deco for class\", cls)\n",
    "\n",
    "    return True if cls._z > 10 else False\n",
    "\n",
    "\n",
    "@usefull\n",
    "class A:\n",
    "    _z = 333\n",
    "\n",
    "    def __init__(self, x):\n",
    "        self.x = x\n",
    "        print(\"__init__\")\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ответ: <font color=green>Декоратор usefull Должен возвращать класс.</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 36\n",
    "Что будет выведено в консоль в результате следующего кода:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "def simple(x):\n",
    "    print(x)\n",
    "    y = yield x * 2\n",
    "    print(y)\n",
    "    z = yield y + x\n",
    "    print(z)\n",
    "    \n",
    "s = simple(2)\n",
    "next(s)\n",
    "print(s.send(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = simple(2)\n",
    "next(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "print(s.send(3))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 37\n",
    "Что будет выведено в консоль в результате следующего кода:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To be decorated func_1\n",
      "Decorator example\n",
      "func_1\n",
      "function_1\n"
     ]
    }
   ],
   "source": [
    "def deco(func):\n",
    "    print(\"To be decorated {}\".format(func.__name__))\n",
    "    def call(*args, **kwargs):\n",
    "        print(func.__name__)\n",
    "        return func(*args, **kwargs)\n",
    "    return call\n",
    "\n",
    "@deco \n",
    "def func_1():\n",
    "    print(\"function_1\")\n",
    "\n",
    "print(\"Decorator example\")\n",
    "func_1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 38\n",
    "Что нужно исправить , чтобы код ниже стал рабочим?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вызов __getattr__(foo)\n",
      "foo:  Значение для foo\n"
     ]
    }
   ],
   "source": [
    "class SlackBase:\n",
    "    def __init__(self):\n",
    "        self.exists = True\n",
    "    def __getattr__(self, name):\n",
    "        value = \"Значение для {}\".format(name)\n",
    "        setattr(self, name, value)\n",
    "        return value\n",
    "\n",
    "class LogSlack(SlackBase):\n",
    "    def __getattr__(self, name):\n",
    "        print(\"Вызов __getattr__({})\".format(name))\n",
    "#         return getattr(self, name)\n",
    "        return super().__getattr__(name)\n",
    "    \n",
    "data = LogSlack()\n",
    "print(\"foo: \", data.foo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Answer: <font color=green>В методе `__getattr__` класса LogSlack необходимо вернуть атрибут использованием функции `super(): return super().__getattr__(name)`</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 39\n",
    "Что будет выведено в консоль в результате следующего кода:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30, 30\n"
     ]
    }
   ],
   "source": [
    "# Та же ерунда со значением x - используется текущее значение, т.е. 20!!!!!!\n",
    "x = 10\n",
    "a = lambda y: x+y\n",
    "x = 20\n",
    "b = lambda y: x + y\n",
    "\n",
    "print(\"{}, {}\".format(a(10), b(10)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 40\n",
    "Укажите, когда будте выполнен код метода `__reduce__`, реализованный в коде?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SomeSecret:\n",
    "    def __reduce__(self):\n",
    "        import os\n",
    "        os.system(\"echo You've been hacked\")\n",
    "# Ответ: При распаковке Picle-объекта\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 41\n",
    "Чем будет являться переменная х после выполнения следующего кода:\n",
    "\n",
    "- классом **megatron**\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.megatron"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class A:\n",
    "    pass\n",
    "\n",
    "x = type('megatron', (A, ), {'zzz':33, 'xxx':'tu-tu'})\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 42\n",
    "Что будет выведено в консоль в результате следующего кода:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'object'>\n"
     ]
    }
   ],
   "source": [
    "print(type.__class__.__base__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'object'>\n"
     ]
    }
   ],
   "source": [
    "print(().__class__.__base__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 43\n",
    "Укажите ошибку в коде\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "\n",
    "def sleep(timeout=1):\n",
    "    def deco(func, state=True):\n",
    "        def call(*args):\n",
    "            print(func.__name__, \"wait...\")\n",
    "            time.sleep(timeout)\n",
    "            return func(*args)\n",
    "\n",
    "        if state:\n",
    "            return call\n",
    "        else:\n",
    "            return func\n",
    "    return deco\n",
    "\n",
    "# @sleep  - в оригинальном задании\n",
    "@sleep(10)\n",
    "def func_1():\n",
    "    print(\"function 1\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "func_1 wait...\n",
      "function 1\n"
     ]
    }
   ],
   "source": [
    "func_1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "?Ответ:  Неправильное обращение к декоратору с параметрами"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 44\n",
    "Укажите назначение функции **mrf**\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sqlite3\n",
    "\n",
    "def mrf(cursor, row):\n",
    "    if len(cursor.description) == 1:\n",
    "        return row[0]\n",
    "    return row\n",
    "\n",
    "\n",
    "con = sqlite3.connect(\"db.sqlite3\")\n",
    "con.row_factory = mrf\n",
    "cur = con.cursor()\n",
    "cur.execute(\"select * from USER\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ответ: Функция mrf осуществляет обработку одной строки результата выборки. Если строка выборки содержит только один столбец, то после работы функции mrf результат будет содержать простой список значений столбца, а не список кортежей"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 45\n",
    "Укажите, какое поведение будет обеспечивать метакласс Secret, описанный в следующем коде:\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Secret(type):\n",
    "    def __new__(cls, name, bases, clsdict):\n",
    "        clsdict[\"SECRET\"] = name[::-1]\n",
    "        res = type.__new__(cls, name, bases, clsdict)\n",
    "        return res\n",
    "    \n",
    "class JamesBond(metaclass=Secret):\n",
    "    def __init__(self, number):\n",
    "        self.number = number * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ответ: В подконтрольном классе будет создан атрибут SECREТ, в который будет помещено имя данного класса, записанное от конца к началу."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 46\n",
    "Укажите особенности данного кода:\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> 2\n",
      "Unknown key. Try again!\n"
     ]
    }
   ],
   "source": [
    "args = input(\"> \").split()\n",
    "if args[0] == \"help\":\n",
    "    print(\"this is calculator application.\")\n",
    "    print(\"Usage: ...\")\n",
    "elif args[0] == \"calc\":\n",
    "    x = eval(''.join(args[1:]))\n",
    "elif args[0] == \"db\":\n",
    "    # TODO: search in database\n",
    "    sql_query = \"\"\n",
    "else:\n",
    "    print(\"Unknown key. Try again!\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ответ: Код уязвим к инхекции кода - пользователь может выполнить любой Python-код"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 47\n",
    "Какое число будет записано последним в файл numbers.txt в результате работы следующего кода?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n",
      "12\n",
      "14\n",
      "16\n",
      "18\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "from threading import Thread\n",
    "import time\n",
    "\n",
    "counter = 0\n",
    "def just_print():\n",
    "    with open(\"numbers.txt\", \"w\") as f:\n",
    "        global counter\n",
    "        for i in range(10000):\n",
    "            # f.write(str(i) + \"\\n\")\n",
    "            counter += 1\n",
    "\n",
    "\n",
    "t1 = Thread(target=just_print)\n",
    "t1.daemon = True\n",
    "t1.start()\n",
    "\n",
    "for i in range(10):\n",
    "    print(i * 2)\n",
    "# time.sleep(1)\n",
    "print(counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "?Ответ: Ни одно число не будет записано в файл -  основной поток завершится раньше открытия файла"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 48\n",
    "Что выполняет оператор yield в строке 4?\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def zorro():\n",
    "    print(\"Готов к работе\")\n",
    "    while True:\n",
    "        n = yield 42            #4\n",
    "        print(\"n = %s\" % n)     #5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = zorro()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n = None\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=gree>Оператор yield приостанавливает работу ф-ии zorro</font><br>\n",
    "Оператор yield переводит ф-ию zorro в новый поток<br>\n",
    "<font color=gree>Оператор yield получает от вызывающей стороны значение и заносит его в переменную n</font><br>\n",
    "    <font color=gree>Оператор yield возвращает вызывающей стороне значение 42</font><br>\n",
    "Оператор yield инициирует исключение StopIteration со значением 42<br>\n",
    "Оператор yield инициирует исключение GeneratorExit при получении значение 42 от вызывающей стороны<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 49\n",
    "Укажите, когда будте выполнен код метода `__reduce__`, реализованный в коде?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 7 13\n"
     ]
    }
   ],
   "source": [
    "class Miracle:\n",
    "    __slots__ = ('x', 'y', '__dict__')  # Добавлен __dict__ !!!!!\n",
    "    xx = 10\n",
    "\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        self.y = 11\n",
    "\n",
    "m = Miracle()\n",
    "m.x = 100\n",
    "m.y = 7\n",
    "m.z = 13\n",
    "print(m.x, m.y, m.z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 50\n",
    "Имеется код эхо-сервера, реализованного с использованием модуля socketserver. Укажите соответствующий ему код сервера, реализованного с использованием модуля socket\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from socketserver import BaseRequestHandler, TCPServer\n",
    "\n",
    "class EchoHandler(BaseRequestHandler):\n",
    "    def handle(self):\n",
    "        print(\"Address:\", self.client_address)\n",
    "        while True:\n",
    "            msg = self.request.recv(8192)\n",
    "            if no msg: break\n",
    "                self.request.send(msg)\n",
    "                \n",
    "if __name__ == \"__main__\":\n",
    "    TCPServer.allow_reuse_address = True\n",
    "    serv = TCPServer((\"\", 9999), EchoHandler)\n",
    "    serv.serve_forever()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ANSWER: !!!\n",
    "from socket import socket, AF_INET, SOCK_STREAM\n",
    "\n",
    "def echo_handler(addr, sock):\n",
    "    print(\"Address: {}\").format(addr)\n",
    "    while True:\n",
    "        msg = client_sock.recv(8192)\n",
    "        if not msg: break\n",
    "        client_sock.sendall(msg)\n",
    "    client_sock.close()\n",
    "    \n",
    "def echo_server(addr, backlog=5):\n",
    "    sock = socket(AF_INET, SOCK_STREAM)\n",
    "    sock.setsockopt(socket.SQL_SOCKET, socket.SO_REUSEADDR, True)\n",
    "    sock.bind(addr)\n",
    "    sock.listen(backlog)\n",
    "    while True:\n",
    "        _sock, _addr = sock.accept()\n",
    "        echo_handler(_addr, _sock)\n",
    "        \n",
    "if __name__ == \"__main__\":\n",
    "    echo_server((\"\", 9999))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 51?\n",
    "Объекты каких типов могут быть ключами словаря класса WeakKeyDictionary?\n",
    "\n",
    "\n",
    "**class WeakKeyDictionary([dict])**\n",
    "\n",
    "Создает словарь, в котором ключи представлены слабыми ссылками. Когда количество обычных ссылок на объект ключа становится равным нулю, соответствующий элемент словаря автоматически удаляется. Поскольку слабые ссылки могут создаваться только для объектов определенных типов, существует большое число ограничений на допустимые типы объектов ключей. В частности, встроенные строки не могут использоваться в качестве ключей со слабыми ссылками. Однако экземпляры пользовательских классов, объявляющих метод __hash__(), могут играть роль ключей.\n",
    "\n",
    "Parameters:\tdict (dict) – словарь, элементы которого добавляются в возвращаемый объект типа WeakKeyDictionary.\n",
    "iterkeyrefs()\n",
    "Возвращает слабые ссылки на ключи.\n",
    "\n",
    "keyrefs()\n",
    "Возвращает слабые ссылки на ключи."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=red>Строки</font><br>\n",
    "<font color=green>Неизменяемые множества (frozenset)</font><br>\n",
    "<font color=red>Целые числа (int)</font><br>\n",
    "<font color=red>Кортежи (tuple)</font><br>\n",
    "<font color=green>Пользовательские классы, поддерживающие хеширование</font><br>\n",
    "Никакие из представленных<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 52\n",
    "Какое число будет записано последним в файл numbers.txt в результате работы следующего кода?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "222\n"
     ]
    }
   ],
   "source": [
    "class Parent():\n",
    "    x = 1\n",
    "    y = 2\n",
    "\n",
    "class Child(Parent):\n",
    "    x = 111\n",
    "    y = 222\n",
    "\n",
    "    def mix(Parent):\n",
    "        return  Parent.y\n",
    "\n",
    "\n",
    "c = Child()\n",
    "print(c.mix())\n",
    "# Ответ 222 НЕВЕРЕН!!!!!!!!!!\n",
    "# Пробовать ответ 2??????"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 53\n",
    "В чем смысл использования mock-объектов в модульных тестах?\n",
    "\n",
    "<font color=green>Применение mock-объекта позволяет концентрироваться на тестировании кода конкретной функции/метода, изолируя код от посторонних функций/объектов</font>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 54\n",
    "Укажите, что нужно подставить в код вместо звёздочек (`***`), чтобы вывести переменную call_count?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I can multilply 13 and 0. The result is 0\n",
      "I can multilply 13 and 1. The result is 13\n",
      "Muller was called 2 times\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "def make_closure(x):\n",
    "    call_count = 0\n",
    "\n",
    "    def inner_func(y):\n",
    "        nonlocal  call_count\n",
    "        call_count += 1\n",
    "        res = x * y\n",
    "        print(\"I can multilply {} and {}. The result is {}\".format(x, y, res))\n",
    "        return  res\n",
    "\n",
    "    return inner_func\n",
    "\n",
    "muller = make_closure(13)\n",
    "\n",
    "for i in range(randint(1,10)):\n",
    "    muller(i)\n",
    "\n",
    "#     closure - позволяет получить значение nonlocal переменных вложенных функций\n",
    "print(\"Muller was called {} times\".format(muller.__closure__[0].cell_contents))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(muller.__closure__[0].cell_contents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "print(muller.__closure__[1].cell_contents)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 55\n",
    "Укажите корректный способ работы с функцией something\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-76-3362b8f516f0>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-76-3362b8f516f0>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    while True\u001b[0m\n\u001b[0m              ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "def something():\n",
    "    while True\n",
    "    n = yield\n",
    "    print(\"Обработать %s?\" % n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ответ: <font color=green>Создать объект-генератор: r = something();\n",
    "Выполнить инициализацию функцией next(): next(r);\n",
    "   Передавать значения в генератор через метод send(): r.send(13).\n",
    "    \n",
    "</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 56\n",
    "Почему тест test_log завершается с ошибкой?\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "from unittest.mock import patch\n",
    "from io import StringIO\n",
    "\n",
    "def summ(a, b):\n",
    "    print(\"summ({}, {})\".format(a, b))\n",
    "    res = a + b\n",
    "    return res\n",
    "\n",
    "class MainTest(unittest.TestCase):\n",
    "    @patch(\"sys.stdout\", new_callable=StringIO)\n",
    "    def test_log(self, mock_stdout):\n",
    "        summ(1, 3)\n",
    "        self.assertEqual(mock_stdout.getvalue(), \"summ(1, 3)\")\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    unittest.main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=red>В тесте, в качестве ожидаемого результата, указано неправильное значение</font><br>\n",
    "?<font color=red>Неправильное использование StrintIO</font><br>\n",
    "?<font color=green>Класс StrintIO вносит изменения в данные, которые ему передаются</font><br>\n",
    "?<font color=red>Неправильное использование mock-объекта</font><br>\n",
    "<font color=red>Для корректного тестирования метод test_log должен быть вызван явно</font><br>\n",
    "<font color=red>Тест выполняется успешно, нет проблем</font><br>\n",
    "<font color=red>Метод test_log не выполняет проверку действительного результата функции summ</font><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 57\n",
    "Что будет записано в файл crypto.log в результате работы следующего кода?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "logging.basicConfig(\n",
    "    filename=\"crypto.log\",\n",
    "    format=\"%(name)s %(levelname)s %(funcName)s %(message)s\",\n",
    "    level = logging.WARNING,\n",
    ")\n",
    "\n",
    "def func_z(names):\n",
    "    logging.info(\"Получение имён из строки {}\".format(names))\n",
    "    res = None\n",
    "    try:\n",
    "        res = names.split(\";\")\n",
    "    except:\n",
    "        logging.critical(\"Проблема выполнения split для {}\".format(names))\n",
    "    finally:\n",
    "        logging.info(\"Результат: {}\".format(res))\n",
    "    return res\n",
    "\n",
    "def main():\n",
    "    logging.debug(\"Старт программы\")\n",
    "    test_data = [\"Eni;Beni;Lapa\", \"\", None]\n",
    "    for data in test_data:\n",
    "        names = func_z(data)\n",
    "        if not names:\n",
    "            logging.warning(\"Пустой результат\")\n",
    "        print(names)\n",
    "        logging.debug(\"Завершение программы\")\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Content of \"crypto.log\"\n",
    "```\n",
    "root CRITICAL func_z Проблема выполнения split для None\n",
    "root WARNING main Пустой результат\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 58\n",
    "Что Вы можете сказать о представленном коде (предполагается, что файл payload.bin располагается в директироии с данным скриптом и имеет не нулевой размер)\n",
    "?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "psyload = open(\"psyload.bin\", \"rb\").read()\n",
    "my_object = pickle.loads(psyload)\n",
    "print(my_object).__class__.subclasses__())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ответ: Код содержит уязвимость внедрения кода через функцию pickle.loads"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 59\n",
    "Укажите назначение переменной X в следующем коде. Здесь переменная db_engine может быть любым коннектором к базе данных.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y = {\"quark\": \"?\", \"numeric\": \":1\", \"format\": \"%s\"}\n",
    "X = Y[db_engine.paramstyle]\n",
    "\n",
    "def query(cur, arg):\n",
    "    sql = \"SELECT * FROM USER WHERE NAME = %s\" % X\n",
    "    cur.execute(sql, arg)\n",
    "    return cur.fetchall()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Задаёт строку подстановки для Null-Значений<br>\n",
    "<font color=red>Задаёт формат данных в запросе</font><br>\n",
    "Задаёт способ сортировки значений выборки<br>\n",
    "Задаёт значение для выборки из таблицы<br>\n",
    "?Задаёт строку подстановки в запросах в зависимости от используемой СУБД<br>\n",
    "Переменная Х не передаётся в функцию, поэтому ни на что не влияет<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 60\n",
    "Какие изменения необходимо внести в код, чтобы программа завершалась корректно?\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recieved:  Simple\n",
      "Recieved:  Data\n",
      "Done\n"
     ]
    }
   ],
   "source": [
    "from threading import Thread\n",
    "from queue import Queue\n",
    "\n",
    "\n",
    "class Worker:\n",
    "    def __init__(self):\n",
    "        self.input_queue = Queue()\n",
    "\n",
    "    def send(self, value):\n",
    "        self.input_queue.put(value)\n",
    "\n",
    "    def close(self):\n",
    "        self.input_queue.put(None)\n",
    "        self.input_queue.join()\n",
    "\n",
    "    def __call__(self):\n",
    "        while True:\n",
    "            item = self.input_queue.get()   # 17\n",
    "            self.input_queue.task_done()\n",
    "            if item is None:                # 18\n",
    "                break\n",
    "            print(\"Recieved: \", item)\n",
    "        return\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    worker = Worker()\n",
    "    work = Thread(target=worker)\n",
    "    work.start()\n",
    "    worker.send(\"Simple\")\n",
    "    worker.send(\"Data\")\n",
    "    worker.close()\n",
    "    print(\"Done\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ответ: После 17-й строки необходимо добавить self.input_queue.task_done()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 61\n",
    "Укажите, что нужно исправить в коде, чтобы в результате получилось:\n",
    "5\n",
    "10\n",
    "15\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "10\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "def create_dividers():\n",
    "    divs = []\n",
    "    for i in range(1, 4):\n",
    "        def divider(x, i = i):   # 4\n",
    "            return i * x\n",
    "        divs.append(divider)\n",
    "    return divs\n",
    "\n",
    "for div in create_dividers():\n",
    "    print(div(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ответ:\n",
    "\n",
    "Изменить строку 4 на:\n",
    "\n",
    "def divider(x, i=i):  # 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 62\n",
    "Укажите, почему не все тесты выполняются успешно для функции calc_tax_summ?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_tax_summ(summ, tax):\n",
    "    '''Функция вычисления суммы включенного налога\n",
    "    принимает стоимость товара и налоговую ставку в процентах.\n",
    "    Возвращает сумму налога, включенного в стоимость товара\n",
    "    >>> calc_tax_summ(1, 100)  # Test 1.\n",
    "    0.5\n",
    "    >>> calc_tax_summ(0, -100)  # Test 2.\n",
    "    0.0\n",
    "    >>> calc_tax_summ(299, 18)  # Test 3.\n",
    "    45.61\n",
    "    >>> calc_tax_summ(37.09, 18)  # Test 4.\n",
    "    5.66\n",
    "    '''\n",
    "    res = 0.0\n",
    "    if 0<= tax <= 100:\n",
    "        cost = summ /(1 + tax / 100)\n",
    "        res = summ - cost\n",
    "    return  round(res, 2)\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    import doctest\n",
    "    print(\"test started\")\n",
    "    doctest.testmod()\n",
    "    print(\"test finished\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "?Все тесы выполняются успешно\n",
    "\n",
    "<font color=red>В док-тестах указаны лишние строки-комментарии</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 63\n",
    "Укажите формат строки логиирования (строка 5), чтобы строки лога выглядели следующим образом\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging  #1\n",
    "                #2\n",
    "logger = logging.getLogger(\"DOCTOR\")   #3\n",
    "logger.setLevel(logging.DEBUG)         #4\n",
    "# formatter = logging.Formatter(\"%(asctime)s - %(name)s - %(levelname)s - %(message)s\")      #5\n",
    "# formatter = logging.Formatter(\"%(created)s - %(name)s - %(levelname)s - %(message)s\")      #5\n",
    "# formatter = logging.Formatter(\"%(created)s - %(name)s - %(levelname)s - %(funcName)s\")      #5\n",
    "# formatter = logging.Formatter(\"%(asctime)s - %(levelname)s - %(name)s - %s\")             #5\n",
    "# formatter = logging.Formatter(\"%(asctime)s - %(name)s - %(levelname)s - %(module)s\")      #5\n",
    "formatter = logging.Formatter(\"%(asctime)s - %(name)s - %(levelname)s - %(message)s\")      #5\n",
    "\n",
    "fh = logging.FileHandler(\"main.log\", encoding=\"utf-8\")  #6\n",
    "fh.setLevel(logging.DEBUG)             #7\n",
    "fh.setFormatter(formatter)          #8\n",
    "logger.addHandler(fh)               #9\n",
    "\n",
    "\n",
    "logger.info(\"info\")\n",
    "logger.debug(\"debug\")\n",
    "logger.warning(\"warning\")\n",
    "\n",
    "def f():\n",
    "    logger.info(f\"info in func {f.__name__}\")\n",
    "\n",
    "f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Log file:\n",
    "```\n",
    "2019-08-26 21:35:26,932 - DOCTOR - DEBUG - debug\n",
    "2019-08-26 21:35:26,932 - DOCTOR - WARNING - warning\n",
    "2019-08-26 21:35:26,933 - DOCTOR - INFO - info in func f\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "?\"%(asctime)s - %(name)s - %(levelname)s - %(message)s\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 64\n",
    "Укажите верные утверждения о глобальной блокировке интерпретатора GIL в Python\n",
    "- GIL снижает эффективность программы, использующей параллельные потоки\n",
    "- GIL не снижает эффективности использования операций ввода-вывода\n",
    "- Некоторые реализации интерпретаторов Python (Jython, IronPython) не используют GIL\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 47\n",
    "Какое число будет записано последним в файл numbers.txt в результате работы следующего кода?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 47\n",
    "Какое число будет записано последним в файл numbers.txt в результате работы следующего кода?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 47\n",
    "Какое число будет записано последним в файл numbers.txt в результате работы следующего кода?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 47\n",
    "Какое число будет записано последним в файл numbers.txt в результате работы следующего кода?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 47\n",
    "Какое число будет записано последним в файл numbers.txt в результате работы следующего кода?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 47\n",
    "Какое число будет записано последним в файл numbers.txt в результате работы следующего кода?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 47\n",
    "Какое число будет записано последним в файл numbers.txt в результате работы следующего кода?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 47\n",
    "Какое число будет записано последним в файл numbers.txt в результате работы следующего кода?\n",
    "\n"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}