函数参数名称中的类与嵌套类属性冲突

Question

考虑这段代码：

def gee(bool_, int32, int64, str_):

    class S:
        bool_ = bool_
        int32 = int32
        int64 = int64
        str_ = str_

    return S

gee(1, 2, 3, 4)

运行会报错：

Traceback (most recent call last):
  File "test_.py", line 36, in <module>
    gee(1, 2, 3, 4)
  File "test_.py", line 27, in gee
    class S:
  File "test_.py", line 28, in S
    bool_ = bool_
NameError: name 'bool_' is not defined

我不知道这里适用哪些范围/关闭规则。 nonlocal 修复了错误但结果不是我所期望的：

def gee(bool_, int32, int64, str_):

    class S:
        nonlocal bool_, int32, int64, str_
        bool_ = None
        int32 = None
        int64 = None
        str_ = None
    print(bool_, int32, int64, str_ )

    return S

g = gee(1, 2, 3, 4)
g.bool_

输出：

None None None None
Traceback (most recent call last):
  File "test_.py", line 38, in <module>
    g.bool_
AttributeError: type object 'S' has no attribute 'bool_'

除了重命名之外，我还能做些什么来使第一个代码 sn-p 中的分配工作？为什么它会这样？因为有name = ...？为什么 Python 在赋值之前不评估名称？

Answer 1

在一个范围内，如果您指定一个名称，则它在该范围内是本地的。类体是一个范围。因此，_bool 是本地的，因此尝试将 _bool 分配给它是错误的，因为尚未定义 _bool。与其他一些语言不同，当名称尚未在作用域中定义时，Python 不会查看外部作用域。

nonlocal，正如您所注意到的，它不能解决问题，因为它会导致外部作用域的名称被分配给。

简单的答案是使用不同的名称。

如果您仅在S 的方法中使用这些值，另一种可能性是简单地使用闭包并访问方法中的值，就好像它们是本地值一样。那么你根本不需要它们作为类的属性。

Answer 2

编译类时，使用与函数类似的规则来解析名称。因为类主体包含对bool_ 变量的赋值，解释器将其视为类变量，因此当被要求解析赋值右侧的值时，会在类命名空间中查找。

一种可能性是使它们成为实例变量，在__init__ 方法中分配，将参数默认为调用gee 时提供的值：

def gee(bool_, int32, int64, str_):

    class S:
        def __init__(self, bool_=bool_, int32=int32, int64=int64, str_=str_):
            self.bool_ = bool_
            self.int32 = int32
            self.int64 = int64
            self.str_ = str_

    return S

my_class = gee(1, 2, 3, 4)
my_instance = my_class()

print(my_instance.bool_)

您应该会发现此代码打印出1。这可能的原因是命名参数使用标准（词法）范围规则解析值表达式，而参数名称本身在每次调用开始时被注入命名空间。

如果您使用表单的赋值将值绑定到类变量，您会发现代码也可以工作

S.bool_ = bool_

因为，当__init__ 方法运行时，类名S 已经绑定在词法封闭的命名空间中。即使这些值绑定到类，它们也可以相对于实例进行引用——因为它们不存在于那里，解释器会继续在实例的类中查找。

但是，无论哪种情况，都需要调用类来设置__init__ 中的属性值。

Answer 3

变量命名和范围是您的问题。如果你稍微改变你的代码，它应该可以工作。

def gee(some_bool, some_int32, some_int64, some_str):

    class S:
        bool_ = some_bool
        int32 = some_int32
        int64 = some_int64
        str_ = some_str

    return S

print(gee(1, 2, 3, 4))
# 1, 2, 3, 4

Answer 4

让我们用另一个问题来回答你的问题 - 你认为 Python 是如何知道 bool_ = bool_ 行中的哪个 bool_ 的？

def gee(bool_, int32, int64, str_):

    class S:
        bool_ = bool_

第一个bool_ 是类属性吗？还是函数中的nonlocalbool_？还是 *gasps* global 对象？那么分配的对象呢，= bool_ 应该引用哪个范围？

这就是为什么 Python 的口号是“显式优于隐式”。应该明确定义范围，以便 Python 理解您所指的范围，否则解释器会假定最直接的范围。

但您已经知道解决方案 - 只需将其重命名为其他名称即可解决问题，因为它明确告诉 Python 解释器该对象所指的范围。

另一种方法是您可以将类属性定义移到类范围之外：

def gee(bool_, int32, int64, str_):

    class S:
        pass

    S.bool_ = bool_
    S.int32 = int32
    ...
    return S

这样你可以清楚地定义哪个bool_属于哪个作用域。

Answer 5

您可以使用此代码。无需更改变量的名称。你可以使用属性和类构造函数来解决这个问题。

def gee(bool_, int32, int64, str_):

    class S:
        def __init__(self, bool_, int32, int64, str_):
            self.bool_ = bool_
            self.int32 = int32
            self.int64 = int64
            self.str_ = str_

        def get_bool_(self):
            return self.bool_

        def set_bool_(self, bool_):
            self.bool_ = bool_

        def get_int32(self):
            return self.int32

        def set_int32(self, int32):
            self.int32 = int32

        def get_int64(self):
            return self.int64

        def set_int64(self, int64):
            self.int64 = int64

        def get_str_(self):
            return self.str_

        def set_str_(self, str_):
            self.str_ = str_

    print(bool_, int32, int64, str_ )

    return S
g = gee(1, 2, 3, 4)

Answer 6

一种可能性是将它们设为实例变量，在 init 方法中分配，将参数默认为调用中提供的值。