Question

如果我有一个功能：

def foo(self, a, b):
    c = a + b
    return c

如何在不更改功能中的c的情况下调用foo？所以我要说我在另一个函数中调用foo：

def bar(self):
    z = self.foo(2, 4)
    return (z)

然后我想在一个单独的函数中再次调用foo，但我希望从'bar'时间调用c。

def baz(self):
    self.foo(?, ?) # trying to just get c, without any changes.

基本上，我正在尝试在课堂上保留一个帐户，以便其他班级可以访问同一个帐户;只是一个简单的平衡，增加和减少金钱。

感谢。

Answer 1

将c存储为类变量或全局，并覆盖该函数以返回旧值。

e.g。

class SomeClass:
     def foo(self, a=None, b=None):
        if a and b:
            c = a + b
            self.stored_c = c
            return c
        return self.stored_c

注意：您必须处理何时更新stored_c以及任何并发问题。

更新：WRT glglgl 的评论，已针对方法重载进行了更新。

Answer 2

c是函数的本地，而不是静态的。这意味着每次函数退出时，c都会被垃圾收集。为什么不直接存储第一次计算的c的值？这似乎是一个明显的答案。

Answer 3

我已经采取了Rohan提供的答案并提出以下建议。它似乎有效，尽管可能有更好/更好的方法来实现这一目标。

以下代码允许我跟踪多个类和方法之间的帐户余额。

import os

class Foo():
    def __init__(self):
        self.stored_end = 0

    def account(self, a, b):
        c = float(a) + b
        print a
        print b
        print c
        self.stored_end = c
        print self.stored_end

    def testy(self, q, v):
        print "\n"
        print " _ " * 10
        z = float(q) + v
        print self.stored_end   
        self.stored_end = self.stored_end + z
        print " _ " * 10
        print self.stored_end

class Bar():
    def __init__(self):
        pass

    def zippy(self, a, b):
        print " _ " * 10
        print "this is zippy"
        foo.testy(a, b)

class Baz():
    def __init__(self):
        pass

    def cracky(self, g, m):
        y = g + m
        print " _ " * 10
        print "calling stored_end"
        foo.stored_end = foo.stored_end + y
        print " _ " * 10
        print "this is cracky"
        print "y = %r" % y
        print foo.stored_end    

os.system("clear")      
foo = Foo()
foo.account(5, 11)
foo.testy(100, 100)
bar = Bar()
bar.zippy(10, 100)
baz = Baz()
baz.cracky(1000, 1)

Answer 4

你需要有一些构造来保存最后的结果。例如，你可以对函数做一些包装

def keep_result(func):
    from functools import wraps
    @wraps(func)
    def wrapper(*a, **k):
        res = func(*a, **k)
        wrapper.last_result = res
        return res
    wrapper.func = func # makes it easy to bypass
    return wrapper

这是一个所谓的“装饰功能”。

现在，如果你这样做

@keep_result
def foo(self, a, b)
    c = a + b
    return c

函数foo（本身，而不是它的结果！）被用作keep_result()的参数，它创建一个新函数wrapper()，它调用原始函数，将其结果保存到属性并返回结果。返回此新函数以代替原始函数foo()。

所以你可以说

normal_result = foo(whatever)

然后再做

saved_result = foo.last_result

你会得到同样的结果。

Answer 5

为什么不将结果存储在self中，并且有可选参数来查看它是否应该进行任何计算？

类似的东西：

def foo(self, *args):
    if args:
        self.c = 0
        for value in args:
            self.c += value

    # In case `self.c` is not set yet, then use default of `0`
    return getattr(self, 'c', 0)

现在，如果使用参数调用foo，它将添加所有参数并存储它。如果没有参数调用它将返回最后存储的值。

Answer 6

看起来你想要的东西是一个缓存的属性。你可以让一个装饰器实现描述符，作为将来使用的通用东西：

def cachedproperty(f):
    """Cached property.

    Calculated once - serves forever.
    """

    def get(self):
        try:
            return self._properties[f]
        except AttributeError:
            self._properties = {}
            self._properties[f] = f(self)
            x = self._properties[f]
            return x
        except KeyError:
            x = self._properties[f] = f(self)
            return x

    return property(get)

让我们看看这个例子：

 class X(object):
     x = 0

     def __init__(self, x):
         self.x = x

     @cachedproperty
     def y(self):
         return self.x + 6

以下是一些测试。

 >>> ob = X(5)
 >>> ob.y
 11
 >>> ob.x = 10
 >>> ob.y
 11

python：如何在不更改参数的情况下调用函数？

6 个答案: