我如何将实例的属性用作方法的默认参数？

Question

我想使用实例的属性值作为默认参数，将默认参数传递给实例方法：

class C:
    def __init__(self, format):
        self.format = format

    def process(self, formatting=self.format):
        print(formatting)

尝试这个时，我收到了以下错误信息：

NameError: name 'self' is not defined

我希望这个方法的行为像这样：

C("abc").process()       # prints "abc"
C("abc").process("xyz")  # prints "xyz"

这里有什么问题，为什么它不起作用？我该如何让它工作？

- Yugal Jindle

---

请勿使用“format”作为变量名称，因为它是Python中的内置函数。 - Yajushi

在process method中编辑self的错误。 - Yugal Jindle

有一份PEP草案正在进行中，它将使用=>而不是=来实现这一点。目前计划在Python 3.12中推出。 - Karl Knechtel

Answer 1

你不能真正将这个定义为默认值，因为默认值是在方法定义时计算的，而此时还不存在任何实例。通常的做法是改成这样：

class C:
    def __init__(self, format):
        self.format = format

    def process(self, formatting=None):
        if formatting is None:
            formatting = self.format
        print(formatting)

self.format只会在formatting为None时使用。

---

为了演示默认值的作用，请看以下示例：

def mk_default():
    print("mk_default has been called!")

def myfun(foo=mk_default()):
    print("myfun has been called.")

print("about to test functions")
myfun("testing")
myfun("testing again")

这里是输出结果：

mk_default has been called!
about to test functions
myfun has been called.
myfun has been called.

注意，mk_default仅被调用了一次，并且在该函数被调用之前就已经发生了！

- Adam Wagner

---

我认为在函数被调用之前已经调用了 mk_default，因为 foo=mk_default() 调用了它，这是由于括号的原因。难道不应该是 foo=mk_default 吗？那么你的例子可能会变成 myfun("testing") 然后是 myfun()。 - gary

请注意，formatting = formatting or self.format将会在formatting为假值时（如0），将formatting设置为self.format。这让我付出了代价。更安全的方法是输入formatting = formatting if formatting is not None else self.format或同等内容。 - Godsmith

@Godsmith，说得好！我已经更新了我的答案来解决这个问题..谢谢！ - Adam Wagner

Answer 2

在Python中，名称self并不特殊。这只是一种参数名称的约定，这就是为什么在__init__中有一个self参数的原因。 （实际上，__init__也不是非常特殊，特别是它实际上并没有创建对象...这是一个更长的故事）。 C（“abc”）.process（）创建一个C实例，查找C类中的process方法，并使用C实例作为第一个参数调用该方法。因此，如果您提供了它，则会进入self参数。

即使您拥有该参数，也不允许编写像def process(self, formatting = self.formatting)这样的内容，因为在设置默认值的点上尚未处于self范围内。在Python中，参数的默认值是在函数编译时计算的，并且“粘”到函数上。（这与您如果使用默认值[]的原因相同，该列表将记住函数调用之间的更改。）

  

我该怎么做才能让这有效？

传统的方法是将None用作默认值，并在函数内部检查该值并替换它。您可能会发现，使用一个专门的值（一个object实例就足够了，只要您隐藏它，使调用代码不使用相同的实例）比使用None稍微安全一些。无论哪种方式，您都应该使用is而不是==来检查此值。

- Karl Knechtel

---

你的解决方法在使用None时无法达到期望的输出。 - Yugal Jindle

如果“None”是“formatting”的有效值，那么你就必须选择其他东西，就像我所解释的那样。 - Karl Knechtel

Answer 3

由于您想使用self.format作为默认参数，这意味着该方法需要是实例特定的（即在类级别无法定义）。相反，您可以在类的__init__中定义特定的方法。这是您可以访问实例特定属性的位置。

一种方法是使用functools.partial来获取更新的（特定）版本的方法：

from functools import partial


class C:
    def __init__(self, format):
        self.format = format
        self.process = partial(self.process, formatting=self.format)

    def process(self, formatting):
        print(formatting)


c = C('default')
c.process()
# c.process('custom')  # Doesn't work!
c.process(formatting='custom')

请注意，使用此方法时，您只能通过关键字传递相应的参数，如果您按位置提供它，则会在“partial”中创建冲突。

另一种方法是在“__init__”中定义并设置该方法：

from types import MethodType


class C:
    def __init__(self, format):
        self.format = format

        def process(self, formatting=self.format):
            print(formatting)

        self.process = MethodType(process, self)


c = C('test')
c.process()
c.process('custom')
c.process(formatting='custom')

这样也可以通过位置传递参数，但方法解析顺序变得不太明显（这可能会影响IDE检查，但我想有特定的IDE解决方法）。

另一种方法是为这些“实例属性默认值”创建自定义类型，并使用特殊装饰器执行相应的getattr参数填充。

import inspect


class Attribute:
    def __init__(self, name):
        self.name = name


def decorator(method):
    signature = inspect.signature(method)

    def wrapper(self, *args, **kwargs):
        bound = signature.bind(*((self,) + args), **kwargs)
        bound.apply_defaults()
        bound.arguments.update({k: getattr(self, v.name) for k, v in bound.arguments.items()
                                if isinstance(v, Attribute)})
        return method(*bound.args, **bound.kwargs)

    return wrapper


class C:
    def __init__(self, format):
        self.format = format

    @decorator
    def process(self, formatting=Attribute('format')):
        print(formatting)


c = C('test')
c.process()
c.process('custom')
c.process(formatting='custom')

- a_guest

Answer 4

在方法定义中无法访问self。我的解决方法是这样的 -

最初的回答

class Test:
  def __init__(self):
    self.default_v = 20

  def test(self, v=None):
    v = v or self.default_v
    print(v)

Test().test()
> 20

Test().test(10)
> 10

- amolk

Answer 5

如果您想让类函数表现为非静态方法，"self"需要作为第一个参数传递。

它指的是对象本身。您不能将"self"作为默认参数传递，因为它的位置固定为第一个参数。

在您的情况下，不要使用"formatting=self.format"，而是使用"formatting=None"，然后按照以下代码分配值：

[编辑]

class c:
        def __init__(self, cformat):
            self.cformat = cformat

        def process(self, formatting=None):
            print "Formating---",formatting
            if formatting == None:
                formatting = self.cformat
                print formatting
                return formatting
            else:
                print formatting
                return formatting

c("abc").process()          # prints "abc"
c("abc").process("xyz")     # prints "xyz"

注意：在 Python 中不要使用“format”作为变量名，因为它是内置函数。

- Yajushi

---

我已经修正了 self 的问题。但是你的答案并不符合期望的输出。 - Yugal Jindle

Answer 6

不必创建一个跨越默认参数的if-then列表，可以利用“defaults”字典，并通过使用eval()来创建类的新实例：

class foo():
    def __init__(self,arg):
        self.arg = arg

class bar():
    def __init__(self,*args,**kwargs):
        #default values are given in a dictionary
        defaults = {'foo1':'foo()','foo2':'foo()'}
        for key in defaults.keys():

            #if key is passed through kwargs, use that value of that key
            if key in kwargs: setattr(self,key,kwargs[key]) 

            #if no key is not passed through kwargs
            #create a new instance of the default value
            else: setattr(self,key, eval(defaults[key]))

我在每个实例化另一个类作为默认参数的类的开头抛出这个。它避免了Python在编译时评估默认值... 我希望有一个更清晰的Python方法，但是嘿。

- noPounch