{"draftJsState":{"blocks":[{"data":{"image":{"id":"63ee8d17e50f1863de842a82"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"atomic:image","key":"dojag"},{"data":{},"depth":0,"entityRanges":[{"key":0,"length":22,"offset":10}],"inlineStyleRanges":[],"text":"Источник: Nuances of Programming","type":"unstyled","key":"7c0f4"},{"data":{},"depth":0,"entityRanges":[{"key":1,"length":109,"offset":0}],"inlineStyleRanges":[{"length":54,"offset":0,"style":"BOLD"}],"text":"Курс SkillFactory Универсальный разработчик на Python: как стать программистом, незаменимым в новых условиях.","type":"unstyled","key":"505es"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Python позволяет разными способами задавать вопросы о коде. В распоряжении программистов находятся соответствующие инструменты, помогающие найти необходимые ответы. Среди них базовая функция help(), встроенные функции вроде dir() и усложненные методы модуля inspect.","type":"unstyled","key":"cb4rr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Из материала статьи вы узнаете, на какие вопросы о коде может ответить Python и как он помогает во время сеансов отладки, работы с аннотациями типов, валидации входных данных и т.д.","type":"unstyled","key":"2fmqh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Встроенные функции","type":"header-three","key":"n5rl"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Python предлагает несколько категорий инструментов/функций для интроспекции. Начнем с рассмотрения наиболее базовых из них, а именно со встроенных функций.","type":"unstyled","key":"9l297"},{"data":{},"depth":0,"entityRanges":[{"key":2,"length":18,"offset":30}],"inlineStyleRanges":[],"text":"Python включает базовый набор встроенных функций, большинство из которых хорошо знакомы программистам: len(), range() и print(). Однако есть ряд малоизвестных функций, которые помогают отвечать на вопросы о коде:","type":"unstyled","key":"c2tv0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"if \"some_var\" in locals():\n ... # some_var существует\n\nif \"some_var\" in globals():\n ... # some_var существует \n\nif hasattr(instance, \"some_class_attr\"):\n ... # instance.some_class_attr существует","type":"blockquote","key":"ah5hp"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"locals(), globals() и hasattr() позволяют определить наличие локальной/глобальной переменной и экземпляра класса.","type":"unstyled","key":"5b0r4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Кроме того, с помощью встроенных функций можно проверить, является ли переменная функцией:","type":"unstyled","key":"d32l"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"print(callable(some_func))\n# True\n\n# В случае с версией, предшествующей Python 3.2\nprint(hasattr(some_func, \"__call__\"))\n# True\n\n# Внимание!\nprint(inspect.isfunction(sum))\n# False","type":"blockquote","key":"blr1f"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Такую проверку можно осуществить двумя способами. Лучшего всего воспользоваться callable(). Однако если вы работаете с Python 3.1, то наличие атрибута __call__ устанавливается с помощью функции hasattr. Второй способ подразумевает привлечение isfunction() из модуля inspect. Однако будьте внимательны при работе с данной функцией. Дело в том, что она возвращает False для встроенных функций, таких как sum, len и range, по причине их реализации на языке C, поэтому они не являются функциями Python.","type":"unstyled","key":"8397e"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Помимо предложенных вариантов, можно также установить, является ли переменная списком (последовательностью) или скалярной величиной:","type":"unstyled","key":"8satn"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"import collections.abc\n\n# Работает со встроенными типами, но включает строки. Не подходит для массивов NumPy:\nprint(isinstance([1, 2, 3], collections.abc.Sequence)) # True\nprint(isinstance(np.array([1, 2, 3]), collections.abc.Sequence)) # False - wrong\nprint(isinstance(\"1234\", collections.abc.Sequence)) # True - wrong\n\n# Работает также для массивов NumPy, но возвращает True для словарей\nprint(hasattr([1, 2, 3], \"__len__\")) # True\nprint(hasattr(np.array([1, 2, 3]), \"__len__\")) # True\nprint(hasattr({\"a\": 1}, \"__len__\")) # True - wrong (?)\n\nprint(isinstance([1, 2, 3], (collections.abc.Sequence, np.ndarray))) # True\nprint(isinstance(np.array([1, 2, 3]), (collections.abc.Sequence, np.ndarray))) # True\nprint(isinstance(\"1234\", (collections.abc.Sequence, np.ndarray))) # True - wrong","type":"blockquote","key":"2qofk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Напрашивается очевидное решение в виде функции isinstance, позволяющей проверить, является ли переменная экземпляром абстрактного класса Sequence. Однако этот вариант не работает в случае с невстроенными типами, такими как массивы NumPy. К тому же, данный подход рассматривает строки как последовательность, что приемлемо, но нежелательно. Альтернативное решение — функция hasattr, которая устанавливает наличие у переменной атрибута __len__. Этот подход работает для массивов NumPy, но также возвращает True для словарей. Третий способ заключается в передаче кортежа типов в isinstance для настройки требуемого поведения.","type":"unstyled","key":"bjq6o"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Вы уже знаете, как работает globals() для проверки наличия переменной. Помимо этого, она используется для вызова функции по строке:","type":"unstyled","key":"d2ud6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"def some_func():\n print(\"Call me!\")\n\nfunc_name = \"some_func\"\n\nglobals()[func_name]()\n# Call me!","type":"blockquote","key":"vvek"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Аналогичная стратегия действует и для атрибутов объекта (класса) с помощью getattr(instance, \"func_name\")().","type":"unstyled","key":"cvk80"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Последний пример со встроенными функциями иллюстрирует применение locals(). Допустим, у нас есть функция, принимающая множество аргументов, все из которых необходимо передать в другую функцию. При этом вы не расположены прописывать их все. В таком случае на помощь приходит locals() с оператором деструктуризации **:","type":"unstyled","key":"7lcj5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"def func(a, b, c, d, e):\n other_func(**locals())\n\ndef other_func(a, b, c, d, e):\n print(a, b, c, d, e)\n\nfunc(1, 2, 3, 4, 5)\n# Prints: 1 2 3 4 5","type":"blockquote","key":"3pau1"},{"data":{},"depth":0,"entityRanges":[{"key":3,"length":12,"offset":249}],"inlineStyleRanges":[],"text":"В данном разделе мы рассмотрели возможности встроенных функций, однако спектр их действия не ограничивается представленными примерами . Для полной картины рекомендую самостоятельно изучить еще несколько функций, например dir() и vars(), опираясь на документацию.","type":"unstyled","key":"ediq9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Атрибуты объектов","type":"header-three","key":"flqda"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Если вышеперечисленные встроенные функции не дают всех требуемых ответов, продолжим изучение и познакомимся с другими способами. Каждый объект в Python обладает довольно обширным набором атрибутов, сообщающих более подробные сведения о конкретных объектах.","type":"unstyled","key":"5vsmi"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"По сути, речь идет о значениях, применяемых для создания вывода help(object). Все, что в нем содержится, извлекается из атрибута object. Так, вывод help(object) может включать строки документации объекта (.__doc__), исходный код функции (.__code__) и информацию о трассировке/стеке, например .tb_frame.","type":"unstyled","key":"62van"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Однако вариант с атрибутами не самый лучший. Рассмотрим более интересный способ в виде модуля inspect.","type":"unstyled","key":"4vh96"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Модуль Inspect","type":"header-three","key":"546ea"},{"data":{},"depth":0,"entityRanges":[{"key":4,"length":6,"offset":62}],"inlineStyleRanges":[],"text":"Модуль inspect задействует все вышеуказанные атрибуты (и даже больше), позволяя более эффективно осуществлять интроспекцию кода.","type":"unstyled","key":"d39dj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Возможно, вам уже доводилось работать со встроенным методом dir() для получения всех атрибутов объекта. Модуль inspect предоставляет аналогичный вариант с именем getmembers():","type":"unstyled","key":"5bjkh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"import inspect\n\nprint(inspect.getmembers(SomeClass))\n\n# [('__class__', ),\n# ('__delattr__', ),\n# ('__dict__', mappingproxy({...})),\n# ...,\n# ('__init__', ), ('__repr__', ),\n# ('__weakref__', ..., ('some_func', )]\n\nmethods = inspect.getmembers(SomeClass, lambda attr: not(inspect.ismethod(attr))) # Нет атрибутов\nmethods_filtered = [m for m in methods if not(m[0].startswith(\"__\") and m[0].endswith(\"__\"))]\n# [('some_func', ), ...]\n\nattributes = inspect.getmembers(SomeClass, lambda attr: not(inspect.isroutine(attr))) # Нет функций \nattrs_filtered = [a for a in attributes if not(a[0].startswith(\"__\") and a[0].endswith(\"__\"))]\n# [('some_var', 'value'), ...]","type":"blockquote","key":"22fef"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Преимущество метода inspect.getmembers() состоит в том, что он предоставляет второй аргумент, который можно использовать для фильтрации атрибутов. В данном примере он соответственно фильтрует атрибуты переменных и функции.","type":"unstyled","key":"32fu"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Модуль inspect также отлично подходит для отладки. Например, он задействуется для отладки состояния генератора:","type":"unstyled","key":"efjsl"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"import inspect\n\ndef some_gen():\n yield 1\n\nprint(inspect.isgeneratorfunction(some_gen))\n# True\n\ngen = some_gen()\nprint(inspect.getgeneratorstate(gen))\n# GEN_CREATED\n\nnext(gen)\nprint(inspect.getgeneratorstate(gen))\n# GEN_SUSPENDED\n\ntry:\n next(gen)\nexcept StopIteration:\n pass\nprint(inspect.getgeneratorstate(gen))\n# GEN_CLOSED","type":"blockquote","key":"5lacr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Здесь мы определяем фиктивный генератор, помещая yield в тело функции. Затем с помощью isgeneratorfunction() убеждаемся, действительно ли это генератор. Кроме того, проверяем его состояние посредством isgeneratorfunction(), которая возвращает GEN_CREATED (в процессе выполнения), GEN_RUNNING, GEN_SUSPENDED (ожидание в инструкции yield) или GEN_CLOSED (завершено).","type":"unstyled","key":"cu580"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"inspect.signature помогает в отладке элементов, связанных с сигнатурой функции, таких как изменяемые аргументы по умолчанию:","type":"unstyled","key":"ej13u"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"def some_func(var_with_default=[]):\n var_with_default.append(\"value\")\n\nprint(inspect.signature(some_func))\n# (var_with_default=[])\n\nsome_func()\nsome_func()\nsome_func()\n\nprint(inspect.signature(some_func))\n# (var_with_default=['value', 'value', 'value'])","type":"blockquote","key":"2iq26"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Как известно, не следует использовать изменяемые типы для аргументов по умолчанию, такие как list, поскольку они будут изменяться при каждом выполнении функции. Проверка сигнатуры функции с помощью inspect.signature() проясняет все, что нужно узнать.","type":"unstyled","key":"etq7i"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В продолжении темы аргументов по умолчанию отметим возможность применения signature() для их чтения:","type":"unstyled","key":"e0bj6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"def some_func(some_arg=42):\n ...\n\nsignature = inspect.signature(some_func)\nprint({\n k: v.default\n for k, v in signature.parameters.items()\n if v.default is not inspect.Parameter.empty\n})\n# {'some_arg': 42}\n\n# Если вы знаете имя аргумента:\nprint(inspect.signature(some_func).parameters[\"some_arg\"].default)\n# 42","type":"blockquote","key":"59f6m"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Вы можете воспользоваться signature() при намерении передать значения по умолчанию одной функции другой. Как видно из предыдущего примера, вы либо перебираете все аргументы и выбираете те, у которых непустое значение по умолчанию, либо, зная имя аргумента, запрашиваете его напрямую.","type":"unstyled","key":"7f7pd"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Усложненные случаи с функцией signature() включают внедрение дополнительных аргументов в функцию с помощью декоратора:","type":"unstyled","key":"1a2v2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"from functools import wraps\nimport inspect\n\ndef optional_debug(fn):\n if \"debug\" in inspect.signature(fn).parameters:\n raise TypeError('\"debug\" argument already defined')\n\n @wraps(fn)\n def wrapper(*args, debug=False, **kwargs):\n if debug:\n print(\"Calling\", fn.__name__)\n return fn(*args, **kwargs)\n\n sig = inspect.signature(fn)\n params = list(sig.parameters.values())\n params.append(inspect.Parameter(\"debug\",\n inspect.Parameter.KEYWORD_ONLY,\n default=False))\n wrapper.__signature__ = sig.replace(parameters=params)\n return wrapper\n\n@optional_debug\ndef func(x):\n return x\n\nprint(inspect.signature(func))\n# (x, *, debug=False)\n\nfunc(42, debug=True)\n# Prints: Calling func","type":"blockquote","key":"433l4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Данный фрагмент кода определяет декоратор с именем optional_debug, который внедряет аргумент debug при применении к функции. Для этого он сначала просматривает сигнатуру функции и проверяет наличие аргумента debug. В случае его отсутствия он заменяет исходную сигнатуру функции на новую с добавлением аргумента, содержащего только ключевое слово.","type":"unstyled","key":"24rpk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Допустим, у вас есть функция, которая объявляет только *args и **kwargs для аргументов. Указанная особенность делает ее “универсальной”, но сильно усложняет проверку параметров. Эта проблема решается с помощью Signature и классов Parameter из модуля inspect:","type":"unstyled","key":"cl5mh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"from inspect import Signature, Parameter\n\nparams = [Parameter(\"first\", Parameter.POSITIONAL_ONLY),\n Parameter(\"second\", Parameter.POSITIONAL_OR_KEYWORD),\n Parameter(\"third\", Parameter.KEYWORD_ONLY, default=\"default_value\")]\n\n# Options:\n# POSITIONAL_ONLY (ones before \"/\")\n# POSITIONAL_OR_KEYWORD\n# VAR_POSITIONAL (\"*args\")\n# KEYWORD_ONLY (ones after a \"*\" or \"*args\")\n# VAR_KEYWORD (\"**kwargs\")\n\nsig = Signature(params)\nprint(sig)\n# (first, /, second, *, third=None)\n\ndef func(*args, **kwargs):\n bound_values = sig.bind(*args, **kwargs)\n for name, value in bound_values.arguments.items():\n print(name, value)\n\nfunc(10, \"value\")\n# first 10\n# second value\n\n# func(second=\"value\", third=\"another\")\n# TypeError: missing a required argument: 'first'","type":"blockquote","key":"6b3qv"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Сначала мы определяем ожидаемые параметры (params) посредством класса Parameter, указывая их тип и значения по умолчанию, после чего создаем из них сигнатуру. Внутри “универсальной” функции применяем метод сигнатуры bind для привязки предоставленных *args и **kwargs к подготовленной сигнатуре. Если параметры не соответствуют сигнатуре, получаем исключение. Если все в порядке, то получаем доступ к привязанному параметру, используя возвращаемое значение метода bind.","type":"unstyled","key":"791hr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Данное решение подходит для валидации параметров внутри базовой функции. А что если нужно проверить, получает ли генератор все необходимые параметры из декорированной функции?","type":"unstyled","key":"7gpaa"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"import functools\nimport inspect\n\ndef login_required(fn):\n\n @functools.wraps(fn)\n def wrapper(*args, **kwargs):\n func_args = inspect.Signature.from_callable(fn).parameters\n if \"username\" not in func_args:\n raise Exception(\"Missing username argument\")\n\n # ... Выполнение логики аутентификации\n\n return fn(*args, **kwargs)\n return wrapper\n\n@login_required\ndef handler(username):\n ...\n\nhandler() # Аргумент не предоставлен...\n# TypeError: handler() missing 1 required positional argument: 'username'","type":"blockquote","key":"2kk4o"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Этот фрагмент кода показывает реализацию декоратора аутентификации, который предполагает передачу параметра username в декорированную функцию. Для проверки наличия параметра задействуется метод from_callable() класса Signature, который извлекает предоставленные параметры из функции. Затем перед выполнением какой-либо фактической логики мы смотрим, находится ли username в возвращаемом кортеже.","type":"unstyled","key":"3m6a2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"От рассмотрения inspect.signature переходим к изучению других возможностей модуля inspect, а именно к интроспекции файлов исходного кода:","type":"unstyled","key":"8j3l1"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"from pathlib import Path\n\nimport datetime\n\nprint(Path(inspect.getfile(some_func)).resolve())\n# /home/martin/.../examples.py\n\nprint(Path(inspect.getfile(datetime.date)).resolve())\n# /usr/lib/python3.8/datetime.py","type":"blockquote","key":"8a766"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Здесь мы просто ищем местоположение (файл) функции some_func с помощью getfile. Этот же прием работает и для встроенных функций/объектов, как показано выше на примере datetime.date.","type":"unstyled","key":"do4hr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Модуль inspect также включает вспомогательные функции для работы с трассировкой. Например, его можно задействовать для поиска исходного файла и строки, выполняемой в текущий момент:","type":"unstyled","key":"ak91f"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"from inspect import currentframe, getframeinfo, stack\n\nframe_info = getframeinfo(currentframe())\nframe_info = getframeinfo(stack()[0][0]) # Same as above\n\nprint(f\"{frame_info.filename}: {frame_info.lineno}\")\n# examples.py: 235\n\ndef some_func():\n # Эквивалент \"getframeinfo(stack()[1][0]).lineno\"\n frame = currentframe()\n print(f\"Line: {frame.f_back.f_lineno}\") # <- Line 243\n\nsome_func() # <- Line 245\n# Prints: \"Line: 245\"","type":"blockquote","key":"eraej"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Эта задача решается двумя способами, самый простой из которых предполагает применение getframeinfo(currentframe()). Однако доступ к стековым фреймам можно получить и через функцию stack(). В этом случае потребуется проиндексировать стек для поиска нужного фрейма.","type":"unstyled","key":"1767c"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Согласно второму способу вы напрямую используете currentframe() и обращаетесь к f_back и f_lineno, чтобы найти соответственно нужный фрейм и строку.","type":"unstyled","key":"frvji"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Вспомогательные функции трассировки также помогают получить доступ к вызывающему объекту:","type":"unstyled","key":"egbae"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"class SomeClass:\n\n def some_func(self):\n some_other_class = SomeOtherClass()\n some_other_class.some_other_func()\n\nclass SomeOtherClass:\n\n def some_other_func(self):\n import inspect\n print(inspect.currentframe().f_back.f_locals[\"self\"])\n\nsome_class = SomeClass()\nsome_class.some_func()\n# <__main__.SomeClass object at 0x7f341fe173d0>","type":"blockquote","key":"1v1ls"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"С этой целью мы привлекаем к работе функцию inspect.currentframe().f_back.f_locals['self'], которая обеспечивает доступ к “родительскому” объекту. Такое решение работает только для отладки. Если требуется доступ к вызывающему объекту, то мы не перемещаемся по стеку, а передаем его в функцию в качестве аргумента.","type":"unstyled","key":"22gk1"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В завершение статьи обратим внимание еще на один немаловажный момент. Если вы задействуете подсказки типов в коде, то наверняка знакомы с функцией typing.get_type_hints, которая помогает проверять подсказки типов. Однако эта функция часто выбрасывает ошибку NameError (особенно при вызове для класса). Вот почему при работе с Python 3.10 следует переключиться на функцию inspect.get_annotations, которая обрабатывает разные пограничные случаи:","type":"unstyled","key":"7uo24"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"import pytest\n\nhelp(pytest.exit)\n# Справка по выходу из функции в модуле _pytest.outcomes:\n# exit(reason: str = '', returncode: Optional[int] = None, *, msg: Optional[str] = None) -> 'NoReturn'\n# Тестирование выхода.\n# ...\n\ninspect.get_annotations(pytest.exit)\n# {'reason': , 'returncode': typing.Optional[int], 'msg': typing.Optional[str], 'return': 'NoReturn'}","type":"blockquote","key":"1mas4"},{"data":{},"depth":0,"entityRanges":[{"key":5,"length":12,"offset":101}],"inlineStyleRanges":[],"text":"Более подробная информация о доступе к аннотациям в Python 3.1 и последующих версиях предоставлена в документации.","type":"unstyled","key":"ji00"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Заключение","type":"header-three","key":"ff4sp"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Как видим, под рукой программистов предостаточно инструментов для интроспекции и анализа кода Python. Некоторые из них сложны для понимания и, возможно, так и останутся невостребованными. Однако не помешает знать об их существовании, особенно о тех, которые могут пригодится для отладки.","type":"unstyled","key":"517rj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Если перечисленных в статье вариантов недостаточно или нужна более углубленная информация по данной теме, то поизучайте модуль ast, предназначенный для обхода и проверки синтаксического дерева, и модуль dis для дизассемблирования байт-кода Python.","type":"unstyled","key":"6g2mn"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Читайте также:","type":"unstyled","key":"802jt"},{"data":{},"depth":0,"entityRanges":[{"key":6,"length":61,"offset":0}],"inlineStyleRanges":[],"text":"Python: статические методы, методы класса и экземпляра класса","type":"unordered-list-item","key":"vl49"},{"data":{},"depth":0,"entityRanges":[{"key":7,"length":80,"offset":0}],"inlineStyleRanges":[],"text":"10 простых сниппетов Python для веб-разработки, автоматизации и обработки данных","type":"unordered-list-item","key":"8o1b4"},{"data":{},"depth":0,"entityRanges":[{"key":8,"length":34,"offset":0}],"inlineStyleRanges":[],"text":"Как изменить PYTHONPATH на Windows","type":"unordered-list-item","key":"93u60"},{"data":{},"depth":0,"entityRanges":[{"key":9,"length":8,"offset":14},{"key":10,"length":2,"offset":24}],"inlineStyleRanges":[],"text":"Читайте нас в Telegram, VK","type":"unstyled","key":"f7ktn"},{"data":{},"depth":0,"entityRanges":[{"key":11,"length":12,"offset":15},{"key":12,"length":52,"offset":29}],"inlineStyleRanges":[{"length":14,"offset":0,"style":"ITALIC"}],"text":"Перевод статьи Martin Heinz: All the Ways To Introspect Python Objects at Runtime","type":"unstyled","key":"dqall"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"marker","key":"O7nWBl0a0yZEP9fHhcrh"}],"entityMap":{"11":{"data":{"href":"https://medium.com/@martin.heinz?source=post_page-----80e6991b4cc6--------------------------------","url":"https://medium.com/@martin.heinz?source=post_page-----80e6991b4cc6--------------------------------"},"mutability":"MUTABLE","type":"LINK"},"12":{"data":{"href":"https://betterprogramming.pub/all-the-ways-to-introspect-python-objects-at-runtime-80e6991b4cc6","url":"https://betterprogramming.pub/all-the-ways-to-introspect-python-objects-at-runtime-80e6991b4cc6"},"mutability":"MUTABLE","type":"LINK"},"0":{"data":{"url":"https://nuancesprog.ru/p/16914/"},"mutability":"MUTABLE","type":"LINK"},"1":{"data":{"url":"https://aflink.ru/g/os57fawizi1470bcbdb40da0172cef7bb740022a/?erid=LatgBV3Ep"},"mutability":"MUTABLE","type":"LINK"},"2":{"data":{"href":"https://docs.python.org/3/library/functions.html","url":"https://docs.python.org/3/library/functions.html"},"mutability":"MUTABLE","type":"LINK"},"3":{"data":{"href":"https://docs.python.org/3/library/functions.html","url":"https://docs.python.org/3/library/functions.html"},"mutability":"MUTABLE","type":"LINK"},"4":{"data":{"href":"https://docs.python.org/3/library/inspect.html#types-and-members","url":"https://docs.python.org/3/library/inspect.html#types-and-members"},"mutability":"MUTABLE","type":"LINK"},"5":{"data":{"href":"https://docs.python.org/3.10/howto/annotations.html#annotations-howto","url":"https://docs.python.org/3.10/howto/annotations.html#annotations-howto"},"mutability":"MUTABLE","type":"LINK"},"6":{"data":{"href":"https://nuancesprog.ru/p/4398/","url":"https://nuancesprog.ru/p/4398/"},"mutability":"MUTABLE","type":"LINK"},"7":{"data":{"href":"https://nuancesprog.ru/p/16859/","url":"https://nuancesprog.ru/p/16859/"},"mutability":"MUTABLE","type":"LINK"},"8":{"data":{"href":"https://nuancesprog.ru/p/4199/","url":"https://nuancesprog.ru/p/4199/"},"mutability":"MUTABLE","type":"LINK"},"9":{"data":{"href":"https://t.me/nuancesprog","url":"https://t.me/nuancesprog"},"mutability":"MUTABLE","type":"LINK"},"10":{"data":{"href":"https://vk.com/nuancesprog","url":"https://vk.com/nuancesprog"},"mutability":"MUTABLE","type":"LINK"}}},"mentions":[]}