Доступ к переменным функции вызывающего абонента в Python

Question

Мое подозрение в том, что то, что я хочу сделать, не совсем понятно в Python. Вот несколько вложенных функций, которые называют друг друга. (В общем, они не должны быть лексически ограниченные, но нужно динамически вызывать друг друга.)

def outer() : 
    s_outer = "outer\n" 

    def inner() : 
     s_inner = "inner\n" 
     do_something() 

    inner() 

Теперь, когда я звоню do_something() тогда я хотел бы получить доступ к переменным функций вызова дальше callstack, в этом случае s_outer и s_inner.

К сожалению, ключевое слово nonlocal здесь помогает мне, только если я определю do_something() внутри функции inner(). Однако, если я определяю его на уровне outer(), тогда ключевое слово nonlocal не будет работать.

Тем не менее, я хочу позвонить do_something() из различных других функций, но всегда выполняйте его в соответствующем контексте и получайте доступ к соответствующим областям.

Чувство озорной я тогда написал небольшую аксессор, что я могу назвать изнутри do_something(), как это:

def reach(name) : 
    for f in inspect.stack() : 
     if name in f[0].f_locals : return f[0].f_locals[name] 
    return None 

и затем

def do_something() : 
    print(reach("s_outer"), reach("s_inner")) 

работает просто отлично.

Мои два вопроса эти

1. Есть ли лучший способ решить эту проблему? (Помимо обертывания соответствующих данных в dicts и передачи этих dicts явно на do_something())

2. Есть ли более элегантный/укороченный способ реализации функции reach()?

Приветствия!

Answer 1

То, что я в конечном итоге делает был

scope = locals() 

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

Answer 2

Нет, и, на мой взгляд, не должно быть элегантного способа реализации reach, так как это вводит новую нестандартную косвенность, которую очень сложно понять, отладить, протестировать и поддерживать. Поскольку мантра Python (пример import this) говорит:

Явный лучше, чем неявный.

Итак, просто передайте аргументы. Вы-из-за-будущего будете очень благодарны вам - с сегодняшнего дня.

Answer 3

Есть ли лучший способ решить эту проблему?(Помимо обертывания соответствующих данных в dicts и передачи этих dicts явно в do_something())

Передача диктонов явно является лучшим способом.

Что вы предлагаете, звучит очень нетрадиционно. Когда код увеличивается по размеру, вам нужно разбить код на модульную архитектуру с чистыми API-интерфейсами между модулями. Он также должен быть тем, что легко понять, легко объяснить и легко передать другому программисту, чтобы изменить/улучшить/отладить его. То, что вы предлагаете, звучит так: нет чистый API, нетрадиционный, с неочевидным потоком данных. Я подозреваю, что это, вероятно, заставит многих программистов сердиться, когда они это увидели. :)

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