71

我想在一个类中使用取自该类的默认值参数构建一个方法。一般来说，我会过滤一些数据。在我的课堂上，我有一个通常传递数据向量的方法。有时我没有向量，我采用模拟数据。每次我不传递特定向量时，我都想默认采用模拟数据。我认为这应该是一个简单的构造，在我的方法定义中我说a=self.vector。但由于某种原因，我有一个错误NameError: name 'self' is not defined。简化的结构是：

class baseClass(object):  # This class takes an initial data or simulation
    def __init__(self):
        self.x = 1
        self.y = 2

class extendedClass(baseClass): # This class does some filtering
    def __init__(self):
        baseClass.__init__(self)
        self.z = 5
    def doSomething(self, a=self.z):
        self.z = 3
        self.b = a

if __name__ == '__main__':
    a = extendedClass()
    print a.__dict__
    a.doSomething()
    print a.__dict__

我期望的输出应该是：

{'y': 2, 'x': 1, 'z': 5}
{'y': 2, 'x': 1, 'z': 3, 'b': 5}

我尝试了默认分配，因为def doSomething(self, a=z):显然它永远不会起作用。据我了解self.z，在此范围内是可见的，将其作为默认值应该不是问题。不知道为什么我有这个错误以及如何做到这一点。这可能是一个简单的问题，但我已经尝试弄清楚或找到不乏解决方案的解决方案。我发现仅针对其他语言的类似问题。

4

4 回答 4

84

你的理解是错误的。self本身就是该函数定义的参数，因此此时它不可能在范围内。它仅在函数本身的范围内。

答案只是将参数默认为None，然后在方法中检查它：

def doSomething(self, a=None):
    if a is None:
        a = self.z
    self.z = 3
    self.b = a
于 2013-03-03T18:37:21.653 回答
9

这是一个简单示例模块的代码反汇编。代码对象是字节码的只读容器，它使用的常量和名称，以及有关局部变量数量、所需堆栈大小等的元数据。请注意，所有代码对象都被编译为常量。这些是在编译时创建的。但是对象class A和function test是在执行时实例化的（例如，在导入模块时）。

要创建类，BUILD_CLASS需要使用 name 'A'、 basestuple (object,)和dict包含类命名空间属性的 a。这就像通过调用手动实例化一个类型type(name, bases, dict)。为了制作dict，从代码对象创建一个函数A并调用它。最后，类对象通过STORE_NAME.

在代码对象A中，self.z作为参数加载到堆栈中MAKE_FUNCTION。字节码操作LOAD_NAME将self在当前局部变量（即定义的类命名空间）、模块全局变量和内置函数中进行搜索。如果self没有在全局或内置范围内定义，这显然会失败；它显然没有在本地范围内定义。

但是，如果它确实成功了，该函数将被创建(self.z,)为它的__defaults__属性，然后存储到本地 name test。

>>> code = compile('''
... class A(object):
...   def test(self, a=self.z): pass
... ''', '<input>', 'exec')

>>> dis.dis(code)
  2           0 LOAD_CONST               0 ('A')
              3 LOAD_NAME                0 (object)
              6 BUILD_TUPLE              1
              9 LOAD_CONST               1 (<code object A ...>)
             12 MAKE_FUNCTION            0
             15 CALL_FUNCTION            0
             18 BUILD_CLASS         
             19 STORE_NAME               1 (A)
             22 LOAD_CONST               2 (None)
             25 RETURN_VALUE

>>> dis.dis(code.co_consts[1]) # code object A
  2           0 LOAD_NAME                0 (__name__)
              3 STORE_NAME               1 (__module__)

  3           6 LOAD_NAME                2 (self)
              9 LOAD_ATTR                3 (z)
             12 LOAD_CONST               0 (<code object test ...>)
             15 MAKE_FUNCTION            1
             18 STORE_NAME               4 (test)
             21 LOAD_LOCALS         
             22 RETURN_VALUE

@uselpa：您的 pastebin 示例（为 2.x 重写）：

>>> code = compile('''
... default = 1
... class Cl(object):
...     def __init__(self, a=default):
...         print a
... Cl()
... default = 2
... Cl()
... ''', '<input>', 'exec')
>>> dis.dis(code)
  2           0 LOAD_CONST               0 (1)
              3 STORE_NAME               0 (default)

  3           6 LOAD_CONST               1 ('Cl')
              9 LOAD_NAME                1 (object)
             12 BUILD_TUPLE              1
             15 LOAD_CONST               2 (<code object Cl ...>)
             18 MAKE_FUNCTION            0
             21 CALL_FUNCTION            0
             24 BUILD_CLASS         
             25 STORE_NAME               2 (Cl)

  6          28 LOAD_NAME                2 (Cl)
             31 CALL_FUNCTION            0
             34 POP_TOP             

  7          35 LOAD_CONST               3 (2)
             38 STORE_NAME               0 (default)

  8          41 LOAD_NAME                2 (Cl)
             44 CALL_FUNCTION            0
             47 POP_TOP             
             48 LOAD_CONST               4 (None)
             51 RETURN_VALUE

如您所见，类对象Cl（和函数对象__init__）仅被实例化并存储到本地名称'Cl'一次。该模块在运行时按顺序执行，因此随后重新绑定名称default将不会影响__init__.

您可以使用先前编译的代码和新的默认值动态实例化一个新函数：

>>> default = 1
>>> class Cl(object):
...     def __init__(self, a=default):
...         print a
... 

>>> from types import FunctionType
>>> default = 2
>>> Cl.__init__ = FunctionType(
...   Cl.__init__.__code__, globals(), '__init__', (default,), None)
>>> c = Cl()
2

这将重用已编译的代码对象__init__.__code__来创建具有__defaults__新元组的函数：

>>> Cl.__init__.__defaults__
(2,)
于 2013-03-03T22:18:40.123 回答
7

执行定义时，默认参数仅被评估一次。相反，请执行以下操作：

def doSomething(self, a=None):
    if a is None:
        a = self.z
    self.z = 3
    self.b = a

另请参阅http://docs.python.org/release/3.3.0/tutorial/controlflow.html#more-on-defining-functions。

于 2013-03-03T18:38:53.863 回答
3

这将插入self.zif ais None// False：empty_value

def doSomething(self, a=None):
        self.z = 3
        self.b = (a or self.z)
于 2018-10-17T11:34:17.703 回答