Question

这个问题很模糊，因为问题在于滥用Python是有道理的。假设我有python作为程序输入：

scf() # produces F,C that are somehow available globally
ci() # uses F,C

问题是，可以scf修改来电者的模块吗？

和第二种情况：

F,C = scf() # F,C are not set globally.

所以基本上是捕获值（x）或全局设置它。怎么办呢？

Answer 1

分享这个让我生病，但在CPython中你可以改变堆栈框架：

import sys
def scf():
    frame = sys._getframe(1) #caller's frame (probably)
    frame.f_globals['F'] = 'F' #add/overwrite globals
    frame.f_globals['C'] = 'C'

def ci():
    print F, C

scf()
ci() # prints 'F C'

但是，为什么需要隐形地改变调用者的命名空间？这种糟糕的设计令人厌恶。 scf()应该返回内容，ci()应该接受这些内容作为参数。如果你分享更多关于你正在做的事情，也许我们可以建议更好的方法。

更新

所以你试图在外部执行的字符串之间保持一些状态，这些字符串是Python程序。在Python中这很简单：只需保留一个显式的locals和globals命名空间，并在exec and friends的调用之间传递它。

s1 = """
foo = 'bar'
"""

s2 = """
def myImpureFunction():
    global foo
    foo = 1
myImpureFunction()
"""

lvars, gvars = {}, {}

exec s1 in lvars, gvars
print gvars
exec s2 in lvars, gvars
print gvars

也许为了保持一些的理智，您可以向用户保证在运行之间会保留一个特殊的var：

s1 = """
stash.foo = 'bar'
"""

s2 = """
def myImpureFunction():
    stash.foo = 'foo'
myImpureFunction()
"""

from types import ModuleType

lvars = {'stash': ModuleType('stash')}

exec s1 in lvars
print lvars['stash'].foo
exec s2 in lvars
print lvars['stash'].foo

Answer 2

我通常通过创建类似于以下

的对象池来解决此问题

>>> class Pool:
    from collections import namedtuple, defaultdict, OrderedDict
    namespace = defaultdict(OrderedDict)
    @staticmethod
    def add(ns='default', **kwargs):
        Pool.namespace[ns].update(kwargs)
    @staticmethod
    def pop(ns='default', *args):
        return [Pool.namespace[ns].pop(k) for k in args]
    @staticmethod
    def remove(ns):
        if ns == 'default':
            raise AttributeError
        del Pool.namespace[ns]
    @staticmethod
    def get(ns='default', **kwargs):
        if kwargs:
            return namedtuple(ns,kwargs.keys())(Pool.namespace[ns][k] for k in kwargs)
        else:

            return namedtuple(ns,Pool.namespace[ns].keys())(*Pool.namespace[ns].values())
    @staticmethod
    def ns():
        return Pool.namespace.keys()
    @staticmethod
    def purge():
        Pool.namespace = defaultdict(OrderedDict)


>>> Pool.add('NS1',F=10,G=20)
>>> Pool.add('NS2',A=1,B=2)
>>> Pool.pop('NS1')
[]
>>> Pool.pop('NS1','F')
[10]
>>> Pool.get('NS1')
NS1(G=20)
>>> Pool.add(X=100,Y=200)
>>> Pool.ns()
['', 'NS1', 'NS2']
>>> Pool.remove('NS1')
>>> Pool.ns()
['', 'NS2']

>>> def sci():
    Pool.add("sci",F=20,G=30)


>>> def ci():
    ns_sci = Pool.get("sci")
    print ns_sci.F, ns_sci.G


>>> sci()
>>> ci()
20 30
>>>

现在，您可以跨功能或模块使用它，而不会污染全局命名空间。您还可以跨命名空间分发它，以便多个命名空间可以共存。

Answer 3

你可以创建一个类：

class A(object):
    def scf(self):
        self.F = 10
        self.C = 20
    def ci(self):
        print self.F, self.C

<强>更新

或＆＃34;独立＆＃34;类：

class B(object):
    @staticmethod
    def scf():
        B.F = 10
        B.C = 20
    @staticmethod
    def ci():
        print B.F, B.C

B.scf()
B.ci()

Python，返回值设计的建议

3 个答案:

更新