Question

抱歉，如果它令人困惑;举个例子。

def functionA():
    x=10
    b()

def functionB():
    Y=22
    return Y

当我调用B时，有没有办法从B访问x，而不将其作为参数传递？我想避免做像

这样的事情

def functionB(var):

根据我的理解，我不能称之为超级，因为B不是A的一部分，它只是从它调用。我想从A调用B，并在B中访问A中的变量（或多个;我正在探索这个概念）;但不将其作为B的参数传递。

这在Python中是否可行？

Answer 1

是的，你实际上可以：

import inspect

def A():
    X = 42
    B()

def B():
    print(inspect.stack()[1][0].f_locals['X'])

A()

但你不应该。

Answer 2

这是downvotes。这是你可以确保只在调用者是“functionA”时执行它并且在调用之前检索它的最后一个本地值的方法。

但这非常粗略。不要这样做。

import sys

def functionA():
    x=10
    x = 5
    functionB()
    x = 3

def functionB():
    frame = sys._getframe()
    outer = frame.f_back
    if outer.f_code.co_name == "functionA":
        print outer.f_locals["x"]
    Y=22
    return Y

Answer 3

如果两者都只是功能，没有。但是如果你同时创建了一个包含类的函数方法，那么你可以使一个变量可以被函数b访问。

class Wrapper(object):
  def __init__():
    self.a_val = None

  def functionA(self):
    self.a_val = 123
    self.functionB()

  def functionB(self):
     # you can access self.a_val here fine.

一旦你有了这个，你就会把functionA称为

Wrapper().functionA()

Answer 4

是的，你想要的是一个全局变量：

def functionA():
    global x
    x=10
    functionB()

def functionB():
    Y=22
    print 'X from B:', x
    return Y

functionA()

当然，正如任何负责任的程序员会告诉你的那样，要小心全局变量，因为他们可以轻松地将你的代码变成意大利面。

这样做的标准方法当然是使用类......

但是，出于论证的缘故，还有另一种方法可以使用闭包来使这两个函数之间的变量共享，并且仍然不是全局变量：

def defineFuns():
    global functionA, functionB

    x = 10
    def functionA():
        print 'X from A:', x
        functionB()

    def functionB():
        Y=22
        print 'X from B:', x
        return Y

defineFuns()
functionA()

或者使用该功能的字典......

def functionA():
    x = 10
    print 'X from A:', x
    functionB.func_globals['x'] = x
    functionB()

def functionB():
    Y=22
    print 'X from B:', x
    return Y

functionA()

Answer 5

这是嵌套函数的完美案例。

def a():
    x = 10
    def b():
        y = 22 + x
        return y
    b()

函数b返回32（22 + 10）。函数x中的b与x中的a相同。你无法从b之外调用a，但这很有意义，因为在这种情况下x的值将是未定义的。

我是否可以访问函数B中的变量X，如果它位于函数A中，它调用函数B？

5 个答案: