python_pd/04_functions/04_legb.ipynb

{
 "metadata": {
  "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.9.0"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.9.0 64-bit ('.venv': venv)"
  },
  "interpreter": {
   "hash": "178cad48488a45b94c2e1acb3bfd8ec03d0e926b0801a270a439a0363b59c19a"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Пространства имен\n",
    "\n",
    "Пространство имен (```namespace```) это множество связей между идентификаторами и объектами (отображение). В Python пространства имен реализованы в виде словарей. Например, множество встроенных имен, глобальные имена, локальные имена и т.д. Важным аспектом, который необходимо знать о пространствах имен – это то, что нет абсолютно никакой связи между именами в разных пространствах имен. Например, два разных модуля (файла), представляющие два разных пространства имен, могут определять функцию ```maximize``` без каких-либо проблем, так как пользователь будет использовать имена модулей в качестве префиксов (не обязательно).\n",
    "\n",
    "В Python идентификаторы имён пространств сами ассоциированы с соответствующими пространствами. Поэтому они могут вкладываться друг в друга, формируя дерево пространств имён. Такое представление основывается на вложенных словарях. Корень такого дерева называется глобальным пространством имён.\n",
    "\n",
    "Ниже приведен простейший пример такой реализации. Словарь ```gl``` представляет собой глобальную область видимости. Она содержит два имени: переменную ```foo``` со значением ```1``` и функцию ```bar```, которая в свою очередь тоже является пространством имен и содержит три переменные ```a```, ```b``` и ```res```."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "gl = {\r\n",
    "    'foo': 1,\r\n",
    "    'bar': {\r\n",
    "        'a': 2,\r\n",
    "        'b': 3,\r\n",
    "        'res': 5,\r\n",
    "    }\r\n",
    "}"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Пространства имен создаются в различные моменты и имеют разное время жизни. Пространство имён, содержащее встроенные имена, создаётся при запуске интерпретатора и не удаляется никогда. Глобальное пространство имён модуля создаётся при чтении определения модуля и обычно не удаляются до выхода из интерпретатора.\r\n",
    "\r\n",
    "Локальное пространство имён функции создаётся при её вызове и удаляется, когда функция возвращает значение либо порождает исключение, внутри неё не перехваченное. Конечно же, рекурсивные порождения имеют свои пространства имён каждое.\r\n",
    "\r\n",
    "# Области видимости\r\n",
    "\r\n",
    "Область видимости (```scope```) — это текстовая область в программе на Python, в которой прямым образом доступно соответствующее пространство имён. Под этим подразумевается, что указание явной ссылки на имя говорит интерпретатору искать это имя в пространстве имён.\r\n",
    "\r\n",
    "В Python существует четыре области видимости (от большего к меньшему):\r\n",
    "- встроенная (```built-in namespace```);\r\n",
    "- глобальная (```global namespace```);\r\n",
    "- объемлющая (```enclosing namespace```);\r\n",
    "- локальная (```local namespace```).\r\n",
    "\r\n",
    "<img src=\"image/legb.png\">\r\n",
    "\r\n",
    "Это правило сокращенно называется **LEGB** и он в некотором роде отличается от подходов в других языках, например C/C++. Согласно **LEGB** поиск имен в Python происходит в следующем порядке: ```local``` → ```enclosing``` → ```global``` → ```built-in```, т.е. от меньшего к большему.\r\n",
    "\r\n",
    "Несмотря на то, что области видимости определяются статически, используются они динамически. В любой момент во время выполнения существует как минимум три вложенных области видимости (локальная, глобальная и встроенная). Их пространства имён доступны прямым образом: самая внутренняя область видимости (по ней поиск осуществляется в первую очередь) содержит локальные имена; область видимости среднего уровня, по ней следующей проходит поиск и она содержит глобальные имена текущего модуля; и самая внешняя область видимости (заключительный поиск) — это пространство имён, содержащее встроенные имена.\r\n",
    "\r\n",
    "Важно осознавать, что области видимости ограничиваются на текстовом уровне: глобальная область видимости функции, определённая в модуле, является пространством имён этого модуля, независимо от того, откуда или по какому псевдониму была эта функция вызвана. С другой стороны, фактический поиск имён осуществляется динамически, во время выполнения.\r\n",
    "\r\n",
    "## Встроенная область видимости (```built-in namespace```)\r\n",
    "\r\n",
    "Встроенная область видимость включает зарезервированные имена, например, ```print```, ```min```, ```open```, ```dir``` и др. Все эти имена собраны в специальном модуле под названием ```__builtins__```. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "source": [
    "print(f'{dir(__builtins__)}')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__IPYTHON__', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'display', 'divmod', 'enumerate', 'eval', 'exec', 'filter', 'float', 'format', 'frozenset', 'get_ipython', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Так как ```__builtins__``` является модулем, то в него можно динамически добавлять новые встроенные имена и таким образом влиять на встроенную область видимости. Однако, эти изменения будут сохранены только до перезапуска интерпретатора. Конечно, изменять встроенную область видимости не рекомендуется во избежание непредвиденного поведения."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "__builtins__.foo = 42\r\n",
    "print(f'{foo = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "foo = 42\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Глобальная область видимости (```global namespace```)\n",
    "\n",
    "Глобальная область видимости - вторая по размеру область видимости в Python. Глобальная область видимости включает в себя имена, определенные на верхнем уровне модуля (файла) или объявленные с помощью оператора ```global```. Для просмотра глобальных переменных, объявленных на текущий момент (пространство имен), можно с помощью встроенной функции ```globals()```. Она позволяет получить словарь, соответствующий глобальному пространству имен. Ключи этого словаря будут соответствовать именам, а значения - объектам, с которыми эти имена связаны. Этот словарь можно изменять в процессе выполнения, динамически добавляя новые имена."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "source": [
    "print(f'{globals() = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "globals() = {'__name__': '__main__', '__doc__': 'Automatically created module for IPython interactive environment', '__package__': None, '__loader__': None, '__spec__': None, '__builtin__': <module 'builtins' (built-in)>, '__builtins__': <module 'builtins' (built-in)>, '_ih': ['', \"print(f'{dir(__builtins__)}')\", \"__builtins__.foo = 42\\nprint(f'{foo = }')\", \"print(f'{globals() = }')\"], '_oh': {}, '_dh': ['c:\\\\projects\\\\python\\\\programming_basics_course\\\\python_pd\\\\04_functions', 'c:\\\\projects\\\\python\\\\programming_basics_course'], 'In': ['', \"print(f'{dir(__builtins__)}')\", \"__builtins__.foo = 42\\nprint(f'{foo = }')\", \"print(f'{globals() = }')\"], 'Out': {}, 'get_ipython': <bound method InteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x0000014BE261EE50>>, 'exit': <IPython.core.autocall.ZMQExitAutocall object at 0x0000014BE25C7850>, 'quit': <IPython.core.autocall.ZMQExitAutocall object at 0x0000014BE25C7850>, '_': '', '__': '', '___': '', 'os': <module 'os' from 'C:\\\\Python39\\\\lib\\\\os.py'>, 'sys': <module 'sys' (built-in)>, '_i': \"__builtins__.foo = 42\\nprint(f'{foo = }')\", '_ii': \"print(f'{dir(__builtins__)}')\", '_iii': '', '_i1': \"print(f'{dir(__builtins__)}')\", '_i2': \"__builtins__.foo = 42\\nprint(f'{foo = }')\", '_i3': \"print(f'{globals() = }')\"}\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "source": [
    "xs = [1, 2, 3]\r\n",
    "for i, x in enumerate(xs):\r\n",
    "    globals()[chr(ord('a') + i)] = x\r\n",
    "\r\n",
    "print(f'{a = }, {b = }, {c = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1, b = 2, c = 3\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Локальная область видимости (```local namespace```)\n",
    "\n",
    "Локальная область видимости образуется при объявлении функции (```def``` или ```lambda```). К ней относятся все переменные кроме объявленных глобально. Она может не существовать, если в модуле нет функций.\n",
    "\n",
    "Помимо функции ```globals``` существует функция ```locals```. Она возвращает словарь, соответствующий локальному пространству имен. Стоит отметить, что результат вызова функции ```locals``` будет зависеть от места ее вызова. Так если ```locals``` вызвать из глобальной области видимости, то результат совпадет с результатом вызова ```globals```."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "source": [
    "print(f'{locals() = }')  # тоже, что и globals()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "locals() = {'__name__': '__main__', '__doc__': 'Automatically created module for IPython interactive environment', '__package__': None, '__loader__': None, '__spec__': None, '__builtin__': <module 'builtins' (built-in)>, '__builtins__': <module 'builtins' (built-in)>, '_ih': ['', \"print(f'{dir(__builtins__)}')\", \"__builtins__.foo = 42\\nprint(f'{foo = }')\", \"print(f'{globals() = }')\", \"xs = [1, 2, 3]\\nfor i, x in enumerate(xs):\\n    globals()[chr(ord('a') + i)] = x\\n\\nprint(f'{a = }, {b = }, {c = }')\", \"print(f'{locals() = }')  # тоже, что и globals()\"], '_oh': {}, '_dh': ['c:\\\\projects\\\\python\\\\programming_basics_course\\\\python_pd\\\\04_functions', 'c:\\\\projects\\\\python\\\\programming_basics_course'], 'In': ['', \"print(f'{dir(__builtins__)}')\", \"__builtins__.foo = 42\\nprint(f'{foo = }')\", \"print(f'{globals() = }')\", \"xs = [1, 2, 3]\\nfor i, x in enumerate(xs):\\n    globals()[chr(ord('a') + i)] = x\\n\\nprint(f'{a = }, {b = }, {c = }')\", \"print(f'{locals() = }')  # тоже, что и globals()\"], 'Out': {}, 'get_ipython': <bound method InteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x0000014BE261EE50>>, 'exit': <IPython.core.autocall.ZMQExitAutocall object at 0x0000014BE25C7850>, 'quit': <IPython.core.autocall.ZMQExitAutocall object at 0x0000014BE25C7850>, '_': '', '__': '', '___': '', 'os': <module 'os' from 'C:\\\\Python39\\\\lib\\\\os.py'>, 'sys': <module 'sys' (built-in)>, '_i': \"xs = [1, 2, 3]\\nfor i, x in enumerate(xs):\\n    globals()[chr(ord('a') + i)] = x\\n\\nprint(f'{a = }, {b = }, {c = }')\", '_ii': \"print(f'{globals() = }')\", '_iii': \"__builtins__.foo = 42\\nprint(f'{foo = }')\", '_i1': \"print(f'{dir(__builtins__)}')\", '_i2': \"__builtins__.foo = 42\\nprint(f'{foo = }')\", '_i3': \"print(f'{globals() = }')\", '_i4': \"xs = [1, 2, 3]\\nfor i, x in enumerate(xs):\\n    globals()[chr(ord('a') + i)] = x\\n\\nprint(f'{a = }, {b = }, {c = }')\", 'xs': [1, 2, 3], 'i': 2, 'x': 3, 'a': 1, 'b': 2, 'c': 3, '_i5': \"print(f'{locals() = }')  # тоже, что и globals()\"}\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Здесь переменная ```a``` находится в локальной области видимости. При доступе к этой переменной извне функции ```foo``` (при условии отсутствия там переменной с таким же именем) появиться исключение ```NameError```.\n",
    "\n",
    "Все переменные, которые объявлены внутри функции ```foo```, называются локальными переменными этой функции. Также говорят, что эти переменные находятся в локальном пространстве имен этой функции."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "source": [
    "def foo():\r\n",
    "    a = 42  # локальная переменная\r\n",
    "    print(f'{a = }')\r\n",
    "    print(f'{locals() = }')\r\n",
    "\r\n",
    "foo()\r\n",
    "print(f'{a = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 42\n",
      "locals() = {'a': 42}\n",
      "a = 1\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Локальные переменные обладают следующими свойствами:\n",
    "- существуют только во время работы функции. После прекращения работы функции, эти переменные будут удалены и при следующем вызове этой функции, они опять будут созданы;\n",
    "- имена локальных переменных функции, никак не конфликтуют с именами переменных в других областях видимости (но не совсем)."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "source": [
    "def foo():\r\n",
    "    a = 42  # локальная переменная функции foo\r\n",
    "    print(f'foo: {a = }')\r\n",
    "    print(f'foo: {locals() = }')\r\n",
    "\r\n",
    "def bar():\r\n",
    "    a = 196  # локальная переменная функции bar\r\n",
    "    print(f'bar: {a = }')\r\n",
    "    print(f'bar: {locals() = }')\r\n",
    "\r\n",
    "foo()  # у двух функций разные области видимости\r\n",
    "bar()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "foo: a = 42\n",
      "foo: locals() = {'a': 42}\n",
      "bar: a = 196\n",
      "bar: locals() = {'a': 196}\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "В локальной области видимости может находиться переменная с тем же именем, что и переменная в глобальной области видимости. Эти переменные будут разными. Переменная в локальной области видимости \"перекроет\" глобальную переменную с тем же именем."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "source": [
    "a = 0\r\n",
    "\r\n",
    "def foo():\r\n",
    "    a = 8  # локальная переменная перекрывает глобальную\r\n",
    "    print(f'foo: {a = }')\r\n",
    "    print(f'foo: {locals() = }')\r\n",
    "    print(f'foo: {globals()[\"a\"] = }')  # глобальная переменная не затронута\r\n",
    "\r\n",
    "foo()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "foo: a = 8\n",
      "foo: locals() = {'a': 8}\n",
      "foo: globals()[\"a\"] = 0\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Объемлющая область видимости (```enclosing namespace```)\n",
    "\n",
    "Объемлющая область видимости появляется в случае объявления функции внутри другой функции. В этом случае *для вложенной функции* область видимости внешней функции будет объемлющей. \n",
    "\n",
    "<img src=\"image/enclosing.png\">\n",
    "\n",
    "Объемлющая область видимости не существует, если нет вложенных функций или локальных областей видимости. \n",
    "\n",
    "В данном случае переменные ```a``` и ```c```, объявленные в области видимости функции ```foo``` со значениями ```'ab'``` и ```5``` не будет изменены во вложенной функции ```bar```. Вместо этого в функции ```bar``` произойдет создание новых переменных с такими же именами."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "source": [
    "def foo(a, b):\r\n",
    "    # функция foo имеет локальные имена:\r\n",
    "    # a, b, c, d, bar\r\n",
    "    c = 5\r\n",
    "    d = a + 2 * b\r\n",
    "    print(f'foo: {a = }, {b = }, {c = }, {d = }')\r\n",
    "    def bar():\r\n",
    "        # функция bar имеет локальные имена: a\r\n",
    "        # имена из объемлющей области: b, c, d\r\n",
    "        a = 15\r\n",
    "        c = a / 5\r\n",
    "        print(f'bar: {a = }, {b = }, {c = }, {d = }')\r\n",
    "    return bar\r\n",
    "\r\n",
    "f = foo('ab', 'cd')\r\n",
    "f()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "foo: a = 'ab', b = 'cd', c = 5, d = 'abcdcd'\n",
      "bar: a = 15, b = 'cd', c = 3.0, d = 'abcdcd'\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Другим похожим примером можно привести создание переменных внутри циклов или условий и использование их во внешних блоках. В этом заключается основное отличие правила **LEGB** от других языков программирования.\n",
    "\n",
    "Пример ниже демонстрирует это. В данном случае происходит создание переменной внутри оператора ветвления и при выходе из него переменная не удаляется, что позволяет использовать ее во внешнем блоке. Это прямой путь выстрелить себе в ногу, так как в случае, если условие ```a > 0``` не выполниться переменная ```b``` не будет определена. Необходимо добавить ветку ```else```, либо объявить ```b``` до оператора ```if```."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "source": [
    "def foo(a):\r\n",
    "    if a > 0:\r\n",
    "        b = 5\r\n",
    "    print(f'{a = }, {b = }')\r\n",
    "\r\n",
    "foo(1)\r\n",
    "foo(0)  # UnboundLocalError"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1, b = 5\n"
     ]
    },
    {
     "output_type": "error",
     "ename": "UnboundLocalError",
     "evalue": "local variable 'b' referenced before assignment",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-10-16058690c8d3>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[0mfoo\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0mfoo\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# UnboundLocalError\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-10-16058690c8d3>\u001b[0m in \u001b[0;36mfoo\u001b[1;34m(a)\u001b[0m\n\u001b[0;32m      2\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0ma\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[0m\n\u001b[0;32m      3\u001b[0m         \u001b[0mb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'{a = }, {b = }'\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      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[0mfoo\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mUnboundLocalError\u001b[0m: local variable 'b' referenced before assignment"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Плохой практикой является использование переменных цикла извне. Например:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "source": [
    "def foo():\r\n",
    "    for i in range(4):\r\n",
    "        pass\r\n",
    "    print(f'{i = }')\r\n",
    "\r\n",
    "foo()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "i = 3\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Порядок поиска имен\n",
    "\n",
    "Порядок поиска имен переменных следует правилу **LEGB**. Оно довольно простое. Поиск происходит в порядке от меньшего к большему, т.е. от локального пространства имен к встроенному. Если имя не найдено в локальной области видимости интерпретатор поднимается на уровень выше и так пока имя не будет найдено, если его нет, то возникает исключение ```NameError```."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "source": [
    "a = 'global'\r\n",
    "def foo():\r\n",
    "    def bar():\r\n",
    "        print(f'bar: {a = }')\r\n",
    "    return bar\r\n",
    "\r\n",
    "f = foo()\r\n",
    "f()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "bar: a = 'global'\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Как уже говорилось выше переменную можно \"перекрыть\" другой переменной с таким же именем. Это никак не повлияет на переменную, находящуюся на более высоком уровне. Однако, не стоит злоупотреблять этим приемом. Можно легко допустить ошибку."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "source": [
    "a = 'global'\r\n",
    "def foo():\r\n",
    "    a = 'enclosing'\r\n",
    "    def bar():\r\n",
    "        print(f'bar: {a = }')\r\n",
    "    return bar\r\n",
    "\r\n",
    "f = foo()\r\n",
    "f()\r\n",
    "print(f'global: {a = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "bar: a = 'enclosing'\n",
      "global: a = 'global'\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Операторы ```global``` и ```nonlocal```\n",
    "\n",
    "Мы уже убедились, что можно без особых проблем использовать и \"загораживать\" переменные, находящиеся на более высоких уровнях областей видимости.\n",
    "\n",
    "Возникает очевидный вопрос: каким образом \"достучатся\" до \"перекрытого\" значения? Python позволяет явно обратиться к имени, используя операторы ```global``` и ```nonlocal```, которые указывают уровень области видимости. ```global``` указывает на глобальную область видимости, а ```nonlocal``` - на объемлющую."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "source": [
    "a = 'global'\r\n",
    "def foo():\r\n",
    "    a = 'enclosing'\r\n",
    "    def bar():\r\n",
    "        global a  # явно указано, что будет использоваться глобальное значение\r\n",
    "        print(f'bar: {a = }')\r\n",
    "    return bar\r\n",
    "\r\n",
    "f = foo()\r\n",
    "f()\r\n",
    "print(f'global: {a = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "bar: a = 'global'\n",
      "global: a = 'global'\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "source": [
    "a = 'global'\r\n",
    "def foo():\r\n",
    "    a = 'enclosing'\r\n",
    "    def bar():\r\n",
    "        nonlocal a\r\n",
    "        print(f'bar: {a = }')\r\n",
    "    return bar\r\n",
    "\r\n",
    "f = foo()\r\n",
    "f()\r\n",
    "print(f'global: {a = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "bar: a = 'enclosing'\n",
      "global: a = 'global'\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Все, что было рассмотрено до этого относилось к использованию переменных для получения их значений, т.е. для чтения. Что будет если нужно модифицировать значение переменной, лежащей на более высоком уровне. Ранее мы убедились, что просто так этого сделать нельзя. При попытке присвоить новое значение произойдет создание переменной с таким же именем в соответствующем пространстве имен, оставляя идентично названную вовне переменную без изменений. Для изменения привязки переменных и соответственно возможности изменять значения переменных во внешних пространствах имен существуют операторы ```global``` и ```nonlocal```.\n",
    "\n",
    "Убедимся, что изменение переменных в других областях видимости недопустимо."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "source": [
    "a = 0\r\n",
    "\r\n",
    "def foo():\r\n",
    "    a += 1  # a = a + 1, UnboundLocalError\r\n",
    "    print(f'{a = }')\r\n",
    "\r\n",
    "foo()"
   ],
   "outputs": [
    {
     "output_type": "error",
     "ename": "UnboundLocalError",
     "evalue": "local variable 'a' referenced before assignment",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-16-3f762f938d56>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      5\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'{a = }'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0mfoo\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;32m<ipython-input-16-3f762f938d56>\u001b[0m in \u001b[0;36mfoo\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mfoo\u001b[0m\u001b[1;33m(\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[1;32m----> 4\u001b[1;33m     \u001b[0ma\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[1;36m1\u001b[0m  \u001b[1;31m# a = a + 1, UnboundLocalError\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'{a = }'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mUnboundLocalError\u001b[0m: local variable 'a' referenced before assignment"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Это правило действует только на неизменяемые типы данных. Изменяемые типы, или изменение значений с помощью методов работает корректно."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "source": [
    "xs = [1, 2, 3]\r\n",
    "\r\n",
    "def foo():\r\n",
    "    xs.append(4)\r\n",
    "\r\n",
    "foo()\r\n",
    "print(f'{xs = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "xs = [1, 2, 3, 4]\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "source": [
    "xs = [1, 2, 3]\r\n",
    "\r\n",
    "def foo():\r\n",
    "    xs += [4]  # UnboundLocalError\r\n",
    "\r\n",
    "foo()\r\n",
    "print(f'{xs = }')"
   ],
   "outputs": [
    {
     "output_type": "error",
     "ename": "UnboundLocalError",
     "evalue": "local variable 'xs' referenced before assignment",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-18-71fea7b04efa>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[0mxs\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m]\u001b[0m  \u001b[1;31m# UnboundLocalError\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mfoo\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      7\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'{xs = }'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-18-71fea7b04efa>\u001b[0m in \u001b[0;36mfoo\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mfoo\u001b[0m\u001b[1;33m(\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[1;32m----> 4\u001b[1;33m     \u001b[0mxs\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m]\u001b[0m  \u001b[1;31m# UnboundLocalError\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[0mfoo\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[1;31mUnboundLocalError\u001b[0m: local variable 'xs' referenced before assignment"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "В этом примере для добавления элемента, в отличие от предыдущего, используется оператор ```+=```, который представляет собой сокращение для ```xs = xs + [4]```. В связи с этим интерпретатор определяя, что происходит присвоение значения, предполагает, что действие происходит в локальной области. Однако значение, которое присваивается ```xs``` основывается на самим ```xs```, которое не определено в локальной области видимости.\n",
    "\n",
    "Чтобы сделать такое редактирование возможным используются операторы ```global``` и ```nonlocal```.\n",
    "\n",
    "Переменная, объявленная как ```nonlocal```, появляется в соответствующем вложенном пространстве имен. Стоит отметить, что оператор помечает переменных как привязанные к объемлющей области видимости, т.е. указывает, что их переназначения должны происходить не в локальном пространстве имен."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "source": [
    "def foo():\r\n",
    "    a = 'enclosing'\r\n",
    "    def bar():\r\n",
    "        # изменение значения в объемлючей области видимости\r\n",
    "        nonlocal a\r\n",
    "        a = 'qwe'\r\n",
    "        # имя 'a' появилось в локальной области видимости\r\n",
    "        print(f'bar: {locals() = }')\r\n",
    "        print(f'bar: {a = }')\r\n",
    "    bar()\r\n",
    "    print(f'foo: {a = }')  # значение уже изменено\r\n",
    "\r\n",
    "foo()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "bar: locals() = {'a': 'qwe'}\n",
      "bar: a = 'qwe'\n",
      "foo: a = 'qwe'\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Стоит помнить, что при использовании оператора ```nonlocal``` для какой-либо переменной, она должна существовать в объемлющей области видимости, иначе появиться исключение ```SyntaxError```.\n",
    "\n",
    "Оператор ```global``` можно использовать для того, чтобы объявить определённые переменные как привязанные к глобальной области видимости."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "source": [
    "a = 0\r\n",
    "\r\n",
    "def foo():\r\n",
    "    global a\r\n",
    "    a += 1\r\n",
    "    print(f'foo: {a = }')\r\n",
    "\r\n",
    "print(f'global: {a = }')\r\n",
    "foo()\r\n",
    "print(f'global: {a = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "global: a = 0\n",
      "foo: a = 1\n",
      "global: a = 1\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Кроме непосредственного использования глобальной переменной, с помощью оператора ```global``` можно их создавать."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "source": [
    "def foo():\r\n",
    "    global bar\r\n",
    "    bar = 'qwe'\r\n",
    "\r\n",
    "foo()\r\n",
    "print(f'{bar = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "bar = 'qwe'\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "В результате, если в данной области не включены операторы ```global``` или ```nonlocal``` — присваивания именам всегда происходят в самой внутренней области видимости. Присваивания не копируют данных, а лишь связывают имена с объектами. Тоже самое верно и для удаления. Оператор ```del``` удаляет связь из пространства имён, на которое ссылается локальная область видимости. В действительности, все операции, вводящие новые имена, используют локальную область видимости: в частности, операторы импорта и описаний функций связывают имя модуля или функции в локальной области видимости соответственно.\n",
    "\n",
    "Использование ```global``` особенно порочно. Лучше использовать другие механизмы для доступа и изменения таких объектов."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Полезные ссылки\n",
    "\n",
    "- [Namespaces and Scope in Python](https://realpython.com/python-namespaces-scope/)"
   ],
   "metadata": {}
  }
 ]
}