Question

我创建了一组相互调用价格选项的函数。其中一个函数运行了一段时间来优化一些参数（使用Nelder Mead）。在这个函数中，计算一个值，我想在其他一些函数中使用，但我不想通过return语句将它传递出去。我认为使用全局变量将是完美的。

现在，奇怪的部分：当我通过import *加载我作为包编写的函数时，我无法访问一个函数创建的全局var。如果我将脚本与函数定义一起使用，运行它以在我的Python控制台中定义函数，然后调用函数，全局变量构造工作正常。可能是什么问题以及为什么我将这些功能加载/定义为包或“手动”会产生影响？

作为包加载时出错：NameError: name 'h_out' is not defined。

global h_out
h_out=None
import hngoption

prices = timeseries[data.Date[i]:].head(30)
output = hngoption.params(prices) 

params() calls function LogLike() as part of its computations which contains:

def LogLike(B, r):
        # (...)
        for i in range(N - 3, -1, -1):
            h[i] = B[0] + B[2] * h[i + 1] + B[1] * pow(Z[i + 1] - B[3] * sqrt(h[i + 1]), 2)
            Z[i] = (ret[i] - r - B[4] * h[i]) / (h[i] ** 0.5)
            L[i] = -log(h[i]+ 0.000000000000001) - (ret[i] ** 2) / h[i]

        LogL = VecSum(L)

        global h_out       #IMPORTANT PART
        h_out = h[0]

        if ((B[0] < 0) | (B[1] < 0) | (B[2] < 0) | (B[3] < 0) | (B[4] < 0)):  # (B[2]+B[1]*pow(B[3],2)>=1))

            return 1e50
        else:
            return -LogL  # Minimize -Log-Like(Beta)

完整LogLike功能：

def LogLike(B, r):

    N = len(timeseries)  #timeseries is a global var
    # Calculate S&P500 returns
    ret = [0.0] * (N - 1)
    for i in range(0, N - 1):
        ret[i] = (log(timeseries.ix[i] / timeseries.ix[i + 1]))

    Variance = VecVar(ret)
    h = [0 * i for i in range(N - 1)]
    Z = [0 * i for i in range(N - 1)]
    L = [0 * i for i in range(N - 1)]

    # Construct GARCH(1,1) process by working back in time
    h[N - 2] = Variance
    Z[N - 2] = (ret[N - 2] - r - B[4] * h[N - 2]) / h[N - 2] ** 0.5
    L[N - 2] = -log(h[N - 2]) - (ret[N - 2] ** 2) / h[N - 2]

    for i in range(N - 3, -1, -1):
        h[i] = B[0] + B[2] * h[i + 1] + B[1] * pow(Z[i + 1] - B[3] * sqrt(h[i + 1]), 2)
        Z[i] = (ret[i] - r - B[4] * h[i]) / (h[i] ** 0.5)
        L[i] = -log(h[i]+ 0.000000000000001) - (ret[i] ** 2) / h[i]

    LogL = VecSum(L)

    global h_out       #IMPORTANT PART
    h_out = h[0]


    if ((B[0] < 0) | (B[1] < 0) | (B[2] < 0) | (B[3] < 0) | (B[4] < 0)):  # (B[2]+B[1]*pow(B[3],2)>=1))

        return 1e50
    else:
        return -LogL  # Minimize -Log-Like(Beta)

Answer 1

您可以使用以下类型的参数来传递结果。

def test(a):
    a[0]=a[0]+2

>>> a = [2]
>>> test(a)
>>> a
[4]

Answer 2

from somemodule import *将当时存在的somemodule中的全局变量绑定到当前模块中的同名变量。尚未导入尚未创建的变量。如果重新分配另一个模块中的变量，当前模块现在有自己对不受影响的对象的引用。

要解决您的问题，请在全局范围内为h_out分配一些默认值，以便其他模块在函数完成之前引用它时不会出错。并通过模块访问变量以获取共享值，而不是执行通配符导入。

somemodule.py

h_out = None

def LogLikeDeep(B, r):
    global h_out       #IMPORTANT PART
    h_out = h[0]

使用

>>> import somemodule
>>> somemodule.h_out
>>> print(repr(somemodule.h_out))
None
>>> somemodule.LogLikeDeep('foo', 'bar')
>>> print(repr(somemodule.h_out))
'foo'

如何在不使用return的情况下将值传递出函数？

2 个答案: