Вероятно, вам нужен weakref.WeakKeyDictionary. Из документа,

Это можно использовать для связывания дополнительных данных с объектом, принадлежащим другим частям приложения, без добавления атрибутов к этим объектам.

Подобно атрибуту и ​​в отличие от обычного словаря, это позволяет объектам собирать мусор, когда на него нет других ссылок.

Вы бы искали поле с

my_hidden_field[X]

вместо

X._my_hidden_field

Два предостережения: во-первых, поскольку слабый ключ может быть удален в любое время без предупреждения, вам не следует перебирать WeakKeyDictionary. Однако поиск объекта, на который у вас есть ссылка, в порядке. И, во-вторых, вы не можете сделать слабую ссылку для типа объекта, написанного на C, у которого нет слота для него (верно для многих встроенных функций), или типа, написанного на Python, который не допускает атрибут __weakref__ (обычно из-за до __slots__).

Если это проблема, вы можете просто использовать обычный словарь для этих типов, но вам придется очистить его самостоятельно.

Быстрый ответ

Можно ли в Python динамически добавлять атрибуты к встроенным объектам Python?

Нет, причины, о которых вы читали в ссылках, которые вы разместили, остались прежними. Но я придумал рецепт, который, как мне кажется, может стать отправной точкой для твоего трейсера.

Инструментарий с использованием подклассов в сочетании с AST

Прочитав много об этом, я придумал рецепт, который, возможно, не является полным решением, но, похоже, вы можете начать отсюда.

Преимущество этого рецепта в том, что он не использует сторонние библиотеки, все достигается с помощью стандартных (Python 3.5, 3.6, 3.7) библиотек.

Целевой код.

Этот рецепт сделает такой код инструментальным (здесь выполняется простое инструментирование, это всего лишь пример концепции) и выполненным.

# target/target.py

d = {1: 2}
d.update({3: 4})
print(d)                 # Should print "{1: 2, 3: 4}"
print(d.hidden_field)    # Should print "(0, 0)"

Подклассы

Во-первых, мы должны добавить hidden_field ко всему, что мы хотим (этот рецепт был протестирован только со словарями).

Следующий код получает значение, определяет его тип/класс и подкласс, чтобы добавить упомянутый hidden_field.

def instrument_node(value):
    VarType = type(value)
    class AnalyserHelper(VarType):
        def __init__(self, *args, **kwargs):
            self.hidden_field = (0, 0)
            super(AnalyserHelper, self).__init__(*args, **kwargs)
    return AnalyserHelper(value)

с этим на месте вы можете:

d = {1: 2}
d = instrument_node(d) 
d.update({3: 4})
print(d)                 # Do print "{1: 2, 3: 4}"
print(d.hidden_field)    # Do print "(0, 0)"

На данный момент мы уже знаем способ "добавить инструментовку во встроенный словарь" но здесь нет прозрачности.

Измените АСТ.

Следующий шаг — «скрыть» вызов instrument_node, и мы сделаем это с помощью ast. Модуль Python.

Ниже приведен преобразователь узла AST, который берет любой найденный словарь и заключает его в вызов instrument_node:

class AnalyserNodeTransformer(ast.NodeTransformer):
    """Wraps all dicts in a call to instrument_node()"""
    def visit_Dict(self, node):
        return ast.Call(func=ast.Name(id='instrument_node', ctx=ast.Load()),
                        args=[node], keywords=[])
        return node

Собираем все вместе.

С помощью этих инструментов вы можете написать скрипт, который:

1. Прочитайте целевой код.
2. Разобрать программу.
3. Примените изменения AST.
4. Скомпилируйте это.
5. И выполнить его.

import ast
import os
from ast_transformer import AnalyserNodeTransformer

# instrument_node need to be in the namespace here.
from ast_transformer import instrument_node

if __name__ == "__main__":

    target_path = os.path.join(os.path.dirname(__file__), 'target/target.py')

    with open(target_path, 'r') as program:
        # Read and parse the target script.
        tree = ast.parse(program.read())
        # Make transformations.
        tree = AnalyserNodeTransformer().visit(tree)
        # Fix locations.
        ast.fix_missing_locations(tree)
        # Compile and execute.
        compiled = compile(tree, filename='target.py', mode='exec')
        exec(compiled)

Это возьмет наш целевой код, обернет каждый словарь instrument_node() и выполнит результат такого изменения.

Результат выполнения этого против нашего целевого кода,

# target/target.py

d = {1: 2}
d.update({3: 4})
print(d)                 # Will print "{1: 2, 3: 4}"
print(d.hidden_field)    # Will print "(0, 0)"

is:

>>> {1: 2, 3: 4} 
>>> (0, 0)

Рабочий пример

Вы можете клонировать рабочий пример здесь.

Да, это возможно, это одна из самых крутых вещей в питоне, в питоне все классы создаются typeклассом

Вы можете подробно прочитать здесь, но вам нужно сделать следующее:

In [58]: My_Class = type("My_Class", (My_Class,), {"__my_hidden_field__": X})

In [59]: My_Class.__my_hidden_field__
Out[59]:
array([[0.73998002, 0.68213825, 0.41621582],
       [0.05936479, 0.14348496, 0.61119082]])

* Отредактировано, потому что отсутствовало наследование, вам нужно передать исходный класс в качестве второго аргумента (в кортеже), чтобы он обновлялся, иначе он просто перезаписывает класс)