eval_func/eval_func.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Динамическое исполнение выражений в Python: eval()\n",
    "\n",
    "Из этого руководства вы узнаете, как в Python работает встроенная функция `eval()`, а также о том, как безопасно и эффективно использовать ее в своих программах.\n",
    "\n",
    "Данная статья является незначительно сокращенным переводом анлоязычной публикации [Python eval(): Evaluate Expressions Dynamically](https://realpython.com/python-eval-function/). Перевод на русский язык подготовлен для сайта [Библиотеки программиста](https://proglib.io/).\n",
    "\n",
    "Функция `eval()` полезна, когда вы пытаетесь динамически выполнять выражения Python из какого-либо ввода, представленного в виде строки или объекта скомпилированного кода.\n",
    "\n",
    "Хотя функция `eval()` – невероятно полезный инструмент, то, что она может выполнять программный код, имеет важные последствия для безопасности, которые следует учитывать перед ее использованием. \n",
    "\n",
    "Из этого руководства вы узнаете:\n",
    "- Как работает `eval()`\n",
    "- Как использовать `eval()` для динамического выполнения кода\n",
    "- Как минимизировать риски безопасности, связанные с использованием `eval()`\n",
    "\n",
    "# Разбираемся в том, как работает eval()\n",
    "\n",
    "Вы можете использовать встроенyю функцию `eval()` для динамического исполнения выражений из ввода на основе строки или скомпилированного кода. Если вы передаете  в `eval()` строку, то функция анализирует ее, компилирует в [байт-код](https://docs.python.org/3/glossary.html#term-bytecode) и выполняет как выражение Python.\n",
    "\n",
    "Если вы передаете `eval()` объект скомпилированного кода, то функция сразу переходит к выполнению. Это очень удобно, если вы вызываете `eval()` несколько раз с одним и тем же вводом.\n",
    "\n",
    "Сигнатура `eval()` определена следующим образом:\n",
    "\n",
    "```\n",
    "eval(expression[, globals[, locals]])\n",
    "```\n",
    "\n",
    "Первый аргумент `expression` содержит выражение, которое необходимо выполнить. Функция также принимает два необязательных аргумента `globals` и `locals`, о которых мы поговорим в соответствующих разделах. Начнём по порядку с аргумента `expression`.\n",
    "\n",
    "**Примечание**: Для динамического выполнения кода можно также использовать функцию `exec()`. Основное различие между `eval()` и `exec()` состоит в том, что `eval()` может выполнять лишь выражения, тогда как функции `exec()` можно «скормить» любой фрагмент кода Python.\n",
    "\n",
    "# Первый аргумент: `expression`\n",
    "\n",
    "Когда мы вызываем `eval()`, содержание `expression` воспринимается, как выражение Python. Посмотрите на следующие примеры, принимающие строковый ввод:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"2 ** 8\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"1024 + 1024\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"sum([8, 16, 32])\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"x * 2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При вызове `eval()` со строковым выражением в качестве аргумента, функция возвращает значение, полученное в результате оценки входной строки. По умолчанию `eval()` имеет доступ к глобальным именам, таким как `x` в приведенном выше примере.\n",
    "\n",
    "Чтобы оценить строковое выражение, `eval()` выполняет следующую последовательность действий:\n",
    "- Парсинг выражения.\n",
    "- Компилирование в байт-код.\n",
    "- Выполнение кода выражения Python.\n",
    "- Возвращение результата.\n",
    "\n",
    "Имя аргумента `expression` подчеркивает, что функция работает только с выражениями, но не составными конструкциями. При попытке передачи блока кода вместо выражения будет получено исключение `SyntaxError`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"if x: print(x)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Таким образом, в `eval()` нельзя передать конструкции  c `if`, `import`, `def` или `class`, с циклами `for`, `while`. Однако ключевое слово `for` может использоваться в `eval` в случае выражений для генераторов списков.\n",
    "\n",
    "По той же причине в `eval()` запрещены операции присваивания:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "eval(\"pi = 3.1416\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`SyntaxError` также возвращается в случаях, когда `eval()` не удается распарсить выражение из-за ошибки в записи:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"5 + 7 *\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В `eval()` также можно передавать объекты кода ([code objects](https://docs.python.org/3/library/stdtypes.html#code-objects)). Чтобы скомпилировать код, который вы собираетесь передать `eval()`, можно использовать [`compile()`](https://docs.python.org/3/library/functions.html#compile). Это встроенная функция, которая может компилировать строку в объект кода или [AST-объект](https://docs.python.org/3/library/ast.html#ast.AST). \n",
    "\n",
    "Детали того, как использовать `compile()`, выходят за рамки этого руководства, но здесь мы кратко рассмотрим первые три обязательных аргумента:\n",
    "\n",
    "1. `source` содержит исходный код, который необходимо скомпилировать. Этот аргумент принимает обычные строки, байтовые строки и объекты AST.\n",
    "2. `filename` определяет файл, из которого прочитан код. Если используется строчный ввод, значение аргумента должно быть `\"<string>\"`.\n",
    "3. `mode` указывает, какой тип объекта кода мы хотим получить. Если нужно обработать код с помощью `eval()`, в качестве значения аргумента указывается `\"eval\"`.\n",
    "\n",
    "**Примечание**: для лучшего ознакомления воспользуйтесь [официальной документацией функции `compile()`](https://docs.python.org/3/library/functions.html#compile).\n",
    "\n",
    "Таким образом, вы можете использовать `compile()` для предоставления объектов кода в `eval()` вместо обычных строк:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "code = compile(\"5 + 4\", \"<string>\", \"eval\")\n",
    "eval(code)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "code = compile(\"4 / 3 * math.pi * math.pow(25, 3)\", \"<string>\", \"eval\")\n",
    "eval(code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Использование объектов кода полезно при многократном вызове. Если вы предварительно скомпилируете входное выражение, то последующие вызовы `eval()` будут выполняться быстрее, так как не будут повторяться шаги синтаксического анализа и компиляции.\n",
    "\n",
    "# Второй аргумент: `globals`\n",
    "\n",
    "Аргумент `globals` опционален. Он содержит словарь, обеспечивающий доступ `eval()` к глобальному пространству имен. С помощью глобальных переменных вы можете указать `eval()`, какие глобальные имена использовать при выполнении выражения.\n",
    "\n",
    "Глобальные имена – это все те имена, которые доступны в текущей глобальной области или пространстве имен. Вы можете получить к ним доступ из любого места в вашем коде.\n",
    "\n",
    "Все имена, переданные глобальным переменным в словаре, будут доступны `eval()` во время выполнения."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 100  # Глобальная переменная\n",
    "eval(\"x + 100\", {\"x\": x})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 200  # Другая глобальная переменная\n",
    "eval(\"x + y\", {\"x\": x})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Любые глобальные имена, определенные вне пользовательского словаря `globals`, не будут доступны изнутри `eval()`, будет вызвано `NameError`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"x + y\", {\"x\": x, \"y\": y})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вы также можете указать имена, которых нет в текущей глобальной области видимости. Чтобы это работало, нужно указать конкретное значение для каждого имени. Тогда `eval()` будет интерпретировать эти имена, как если бы это были глобальные переменные:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"x + y + z\", {\"x\": x, \"y\": y, \"z\": 300})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z  # самой переменной нет в глобальной области видимости"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если вы предоставите `eval()` пользовательский словарь, который не содержит значения для ключа `\"__builtins__\"`, то ссылка на словарь встроенных функций всё равно будет автоматически добавлена к ключу `\"__builtins__\"`, прежде чем выражение будет проанализировано. Это гарантирует, что `eval()` имеет полный доступ ко всем встроенным именам Python при оценке выражения."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"sum([2, 2, 2])\", {})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"min([1, 2, 3])\", {})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"pow(10, 2)\", {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Несмотря на переданный пустой словарь (`{}`), `eval()` имеет доступ к встроенным функциям.\n",
    "\n",
    "При вызове `eval()` без передачи пользовательского словаря в глобальные переменные аргумент по умолчанию будет использовать словарь, возвращаемый `globals()` в среде, где вызывается `eval()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "x = 100  # Глобальная переменная\n",
    "y = 200  # Другая глобальная переменная\n",
    "eval(\"x + y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Таким образом, передача словаря в аргументе `globals` служит как способ намеренно ограничить область видимость имен для функции `eval()`.\n",
    "\n",
    "# Третий аргумент: `locals`\n",
    "\n",
    "Аргумент `locals` также является необязательным аргуменом. В этом случае словарь содержит переменные, которые `eval()` использует в качестве локальных имен при оценке выражения.\n",
    "\n",
    "Локальными называются те имена (переменные, функции, классы и т.д.), которые вы определяете внутри данной функции. Локальные имена видны только изнутри включающей функции."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"x + 100\", {}, {\"x\": 100})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "eval(\"x + y\", {}, {\"x\": 100})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обратите внимание, что для передачи словаря `locals` сначала необходимо предоставить словарь для `globals`. Передача по ключу в случае `eval()` не работает:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"x + 100\", locals={\"x\": 100})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Главное практическое различие между `globals` и `locals` заключается в том, что Python автоматически вставит ключ `\"__builtins__\"` в `globals`, если этот ключ еще не существует. Cловарь `locals` остается неизменным во время выполнения `eval()`.\n",
    "\n",
    "# Выполнение выражений с `eval()`\n",
    "\n",
    "Функция `eval()` используется, когда нужно динамически изменять выражения, а применение других техник и инструментов Python требует избыточных усилий. В этом разделе мы обсудим, как использовать `eval()` для булевых, математических и прочих выражений Python.\n",
    "\n",
    "## Булевы выражения\n",
    "\n",
    "Булевы выражения – это выражения Python, которые возвращают логическое значение (`True` или `False`). Обычно они используются в операторе `if` для проверки, является ли какое-либо условие истинным или ложным:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 100\n",
    "y = 100\n",
    "eval(\"x != y\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"x < 200 and y > 100\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"x is y\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"x in {50, 100, 150, 200}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Зачем же может потребоваться использовать `eval()` вместо непосредственного применения логического выражения? Предположим, нам нужно реализовать условный оператор, но вы хотите на лету менять условие:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(a, b, condition):\n",
    "    if eval(condition):\n",
    "        return a + b\n",
    "    return a - b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func(2, 4, \"a > b\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func(2, 4, \"a < b\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func(2, 2, \"a is b\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Внутри `func()` для оценки предоставленного условия используется функция `eval()`, возвращающая `a + b` или `a - b` в соответствии с результатом оценки.\n",
    "\n",
    "Теперь представьте, как бы вы реализовали то же поведение без `eval()` для обработки любого логического выражения.\n",
    "\n",
    "## Математические выражения\n",
    "\n",
    "Один из распространенных вариантов использования `eval()` в Python – оценка математических выражений из строкового ввода. Например, если вы хотите создать калькулятор на Python, вы можете использовать `eval()`, чтобы оценить вводимые пользователем данные и вернуть результат вычислений:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"5 + 7\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"(5 + 7) / 2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import math\n",
    "eval(\"math.sqrt(math.pow(10, 2) + math.pow(15, 2))\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Выражения общего вида\n",
    "\n",
    "Вы можете использовать `eval()` и с более сложными выражениями Python, включающими вызовы функций, создание объектов, доступ к атрибутам и т. д.\n",
    "\n",
    "Например, можно вызвать встроенную функцию или функцию, импортированную с помощью стандартного или стороннего модуля. В следующих примерах `eval()` используется для запуска различных системных команд. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import subprocess\n",
    "# Запуск команды echo\n",
    "eval(\"subprocess.getoutput('echo Hello, World')\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Запуск Firefox (если он установлен)\n",
    "eval(\"subprocess.getoutput('firefox')\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Таким образом, можно передавать команды через какой-либо строковый интерфейс (например, форму в браузере) и выполнять код Python.\n",
    "\n",
    "Однако по этой же причине `eval()` может подвергнуть нас серьезным угрозам безопасности, например, позволит злоумышленнику запускать системные команды или выполнять кода на нашем компьютере. В следующем разделе мы обсудим способы устранения угроз безопасности, связанных с `eval()`.\n",
    "\n",
    "# Минимизация проблем безопасности, связанных с `eval()`\n",
    "\n",
    "В связи с проблемами безопасности обычно рекомендуется по возможности не использовать `eval()`. Но если вы решили, что функция необходима, простое практическое правило состоит в том, чтобы никогда не использовать ее для любого ввода, которому нельзя доверять. Сложность в том, чтобы выяснить, каким видам ввода доверять *можно*.\n",
    "\n",
    "В качестве примера того, как безответственное использование `eval()` может сделать ваш код небезопасным, предположим, что вы хотите создать онлайн-сервис для оценки произвольных выражений Python. Ваш пользователь вводит выражения и нажимает кнопку «Выполнить». Приложение получает пользовательский ввод и передает его для выполнения в `eval()` .\n",
    "\n",
    "Если вы используете Linux и приложения имеет необходимые разрешения, то злонамеренный пользователь может ввести опасную строку, подобную следующей:\n",
    "\n",
    "```\n",
    "\"__import__('subprocess').getoutput('rm –rf *')\"\n",
    "```\n",
    "Выполнение выражения удалит все файлы в текущей директории.\n",
    "\n",
    "**Примечание**: `__import__()` – это встроенная функция, которая принимает имя модуля в виде строки и возвращает ссылку на объект модуля. `__import__()` - это функция, которая полностью отличается от оператора `import`. Как мы упоминали выше, вы не можете вызвать оператор импорта с помощью `eval()`.\n",
    "\n",
    "## Ограничение `globals` и `locals`\n",
    "\n",
    "Вы можете ограничить среду выполнения `eval()`, задавая собственные словари аргументам `globals` и `locals`. Например, пустые словари для обоих аргументов, чтобы `eval()` не мог получить доступ к именам в текущей области или пространстве имен вызывающей стороны:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 100\n",
    "eval(\"x * 5\", {}, {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "К сожалению, это ограничение не устраняет другие проблемы безопасности, связанные с использованием `eval()`, поскольку остается доступ ко всем встроенным именам и функциям Python.\n",
    "\n",
    "## Ограничение `__builtins__`\n",
    "\n",
    "Как мы видели ранее, `eval()` автоматически вставляет ссылку на словарь `__builitins__` в `globals` перед синтаксическим анализом выражения. Злоумышленник может использовать это поведение, используя встроенную функцию `__import __()`, чтобы получить доступ к стандартной библиотеке или любому стороннему модулю, установленному в системе:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"__import__('math').sqrt(25)\", {}, {})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"__import__('subprocess').getoutput('echo Hello, World')\", {}, {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтобы минимизировать риски, можно переопределить `__builtins__` в `globals`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(\"__import__('math').sqrt(25)\", {\"__builtins__\": {}}, {})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ограничение имён во входных данных\n",
    "\n",
    "Однако даже после таких ухищрений Python останется уязвим. Например, можно получить доступ к объекту класса, используя литерал типа, например `\"\"`, `[]`, `{}` или `()`, а также некоторые специальные атрибуты:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\".__class__.__base__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[].__class__.__base__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Получив доступ к объекту, можно использовать специальный метод `.__subclasses__()`, чтобы получить доступ ко всем классам, которые наследованы объектом. Вот как это работает:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for sub_class in ().__class__.__base__.__subclasses__():\n",
    "    print(sub_class.__name__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Этот код напечатает большой список классов. Некоторые из этих классов довольно мощные и могут быть чрезвычайно опасны в чужих руках. Это открывает еще одну важную дыру в безопасности, которую вы не сможете закрыть, просто ограничивая окружение `eval()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_string = \"\"\"[\n",
    "    c for c in ().__class__.__base__.__subclasses__()\n",
    "    if c.__name__ == \"range\"\n",
    "    ][0](10)\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(eval(input_string, {\"__builtins__\": {}}, {}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Генератор списка в приведенном коде фильтрует классы, которые наследуются от объекта, чтобы вернуть список, содержащий класс `range`. Ему в этом списке соответствует индекс 0. Далее `range` вызывается для создания соответствующего объекта. Это хитрый способ обойти исключение `TypeError`, вызываемое в результате ограничения `\"__builtins__\"`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(eval(range(10), {\"__builtins__\": {}}, {}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Возможное решение этой уязвимости состоит в том, чтобы ограничить использование имен во входных данных  набором безопасных имен либо исключить всякое использование любых имен.\n",
    "\n",
    "Чтобы реализовать эту технику, необходимо выполнить следующие шаги:\n",
    "1. Создать словарь, содержащий имена, которые могут использоваться в `eval()`.\n",
    "2. Скомпилировать входную строку в байт-код, используя `compile()` в режиме `eval`.\n",
    "3. Проверить `.co_names` в объекте байт-кода, чтобы убедиться, что он содержит только разрешенные имена.\n",
    "4. Вызвать исключение `NameError`, если пользователь пытается использовать недопустимое имя.\n",
    "\n",
    "Взглянем на следующую функцию, в которой реализованы все эти шаги:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eval_expression(input_string):\n",
    "    allowed_names = {\"sum\": sum}\n",
    "    code = compile(input_string, \"<string>\", \"eval\")\n",
    "    for name in code.co_names:\n",
    "        if name not in allowed_names:\n",
    "            raise NameError(f\"Использование {name} не разрешено.\")\n",
    "    return eval(code, {\"__builtins__\": {}}, allowed_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Эта функция ограничивает имена, которые можно использовать в `eval()`, именами в словаре `allowed_names`. Для этого функция использует `.co_names` – атрибут объекта кода, содержащий кортеж имен в объекте кода.\n",
    "\n",
    "Следующие примеры показывают, как написанная нами функция `eval_expression()` работает на практике:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval_expression(\"3 + 4 * 5 + 25 / 2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval_expression(\"sum([1, 2, 3])\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval_expression(\"pow(10, 2)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если нужно полностью запретить использование имен, достаточно переписать `eval_expression()` следующим образом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eval_expression(input_string):\n",
    "    code = compile(input_string, \"<string>\", \"eval\")\n",
    "    if code.co_names:\n",
    "        raise NameError(f\"Использование имён запрещено.\")\n",
    "    return eval(code, {\"__builtins__\": {}}, {})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval_expression(\"3 + 4 * 5 + 25 / 2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "eval_expression(\"sum([1, 2, 3])\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ограничение входных данных до литералов\n",
    "\n",
    "Типичный пример использования `eval()` в Python – это выполнение выражений, содержащих стандартные литералы Python. Задача настолько распространенная, что стандартная библиотека предоставляет соответствующую функцию `literal_eval()`. Функция не поддерживает операторы, но работает со списками, кортежами, числами, строками и т. д.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ast import literal_eval\n",
    "literal_eval(\"15.02\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "literal_eval(\"[1, 15]\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "literal_eval(\"{'one': 1, 'two': 2}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "literal_eval(\"sum([1, 15]) + 5 + 8 * 2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Использование `eval()` совместно с `input()`\n",
    "\n",
    "В Python 3.x встроенная функция `input()` читает пользовательский ввод из командной строки, преобразует его в строку, удаляет завершающий символ новой строки и возвращает результат вызывающей стороне. Поскольку результатом `input()` является строка, ее можно передать в `eval()` и выполнить как выражение Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval(input(\"Введите математическое выражение: \"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Это распространенный вариант использования `eval()`. Он также эмулирует поведеие `input()` в версиях Python 2.x, где функции можно было передать строковое выражение для выполнения (впоследствии от этого отказались из соображений безопасности).\n",
    "\n",
    "# Построим обработчик математических выражений\n",
    "\n",
    "Итак, мы узнали, как работает `eval()` в Python и как использовать его на практике. Мы также выяснили, что `eval()` имеет важные последствия для безопасности и что обычно считается хорошей практикой избегать использования `eval()` в коде. Однако в некоторых ситуациях `eval()` может сэкономить много времени и усилий.\n",
    "\n",
    "В этом разделе вы напишем приложение для оценки математических выражений на лету. Без использования `eval()`, нам потребовалось бы выполнить следующие шаги:\n",
    "\n",
    "1. Распарсить входное выражение.\n",
    "2. Преобразовать компоненты выражения в объекты Python (числа, операторы, функции).\n",
    "3. Объединить всё в исполняемое выражение.\n",
    "4. Проверить валидность выражения для Python.\n",
    "5. Выполнить итоговое выражение и вернуть результат вычислений.\n",
    "\n",
    "Это потребовало бы большой работы, учитывая  разнообразие возможных выражений, которые Python может обрабатывать. К счастью, теперь мы знаем о функции `eval()`.\n",
    "\n",
    "Всё приложение будет храниться в скрипте `mathrepl.py`. Постепенно мы его заполним необходимым содержимым. Начнем со следующего кода:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "__version__ = \"1.0\"\n",
    "\n",
    "ALLOWED_NAMES = {\n",
    "    k: v for k, v in math.__dict__.items() if not k.startswith(\"__\")\n",
    "}\n",
    "\n",
    "PS1 = \"mr>>\"\n",
    "\n",
    "WELCOME = f\"\"\"\n",
    "MathREPL {__version__} - обработчик математических выражений на Python!\n",
    "Введите математическое выражение после приглашения \"{PS1}\".\n",
    "Для дополнительной информации используйте команду help.\n",
    "Чтобы выйти, наберите quit или exit.\n",
    "\"\"\"\n",
    "\n",
    "USAGE = f\"\"\"\n",
    "Соберите математическое выражение из чисел и операторов.\n",
    "Можно использовать любые из следующих функций и констант:\n",
    "\n",
    "{', '.join(ALLOWED_NAMES.keys())}\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Модуль `math` мы используем для того, чтобы определить все доступные имена. Три строковые константы используются для вывода строк в интерфейсе программы. Напишем ключевую функцию нашей программы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(expression):\n",
    "    \"\"\"Вычисляет математическое выражение.\"\"\"\n",
    "    # Компиляция выражения в байт-код\n",
    "    code = compile(expression, \"<string>\", \"eval\")\n",
    "\n",
    "    # Валидация доступных имен\n",
    "    for name in code.co_names:\n",
    "        if name not in ALLOWED_NAMES:\n",
    "            raise NameError(f\"The use of '{name}' is not allowed\")\n",
    "\n",
    "    return eval(code, {\"__builtins__\": {}}, ALLOWED_NAMES)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Осталось лишь написать код для взаимодействия с пользователем. В функции  `main()` мы определяем основной цикл программы для чтения введенных данных и расчета математических выражений, введенных пользователем:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    \"\"\"Читает и рассчитывает введенное выражение\"\"\"\n",
    "    print(WELCOME)\n",
    "    while True:\n",
    "        # Читаем пользовательский ввод\n",
    "        try:\n",
    "            expression = input(f\"{PS1} \")\n",
    "        except (KeyboardInterrupt, EOFError):\n",
    "            raise SystemExit()\n",
    "\n",
    "        # Поддержка специальных команд\n",
    "        if expression.lower() == \"help\":\n",
    "            print(USAGE)\n",
    "            continue\n",
    "        if expression.lower() in {\"quit\", \"exit\"}:\n",
    "            raise SystemExit()\n",
    "\n",
    "        # Вычисление выражения и обработка ошибок\n",
    "        try:\n",
    "            result = evaluate(expression)\n",
    "        except SyntaxError:\n",
    "            # Некорректное выражение\n",
    "            print(\"Вы ввели некорректное выражение.\")\n",
    "            continue\n",
    "        except (NameError, ValueError) as err:\n",
    "            # Если пользователь попытался использовать неразрешенное имя\n",
    "            # или неверное значение в переданной функции\n",
    "            print(err)\n",
    "            continue\n",
    "\n",
    "        # Выводим результат, если не было ошибок\n",
    "        print(f\"Результат: {result}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Проверим результат нашей работы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%run -i mathrepl.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вот и всё – наш обработчик математических выражений готов! В случае ошибок при вводе или  математически некорректных выражений мы получаем необходимое пояснение. Для самой обработки введенных данных потребовалось лишь несколько строк и функция `eval()`. \n",
    "\n",
    "# Заключение\n",
    "Итак, вы можете использовать `eval()` для выполнения выражений Python из строкового или кодового ввода. Эта встроенная функция полезна, когда вы пытаетесь динамически обновлять выражения Python и хотите избежать проблем с созданием собственного обработчика выражений. Однако пользоваться ей стоит с осторожностью."
   ]
  },
  {
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}