Python类设计：如何让实例在直接引用时返回特定值而非内存地址

理解Python对象的默认行为

在Python中，当我们创建一个类的实例并将其赋值给一个变量时，该变量实际上持有的是该对象在内存中的引用。例如，考虑以下结构，它用于解析二进制数据头中的数据类型（DTYPE）：

class _DTYPE:
    def __init__(self, dtype: str):  # input dtype = '<f8'
        self.rawString = dtype       # 获取 '<f8'
        self.endianness = dtype[0]   # 获取 '<'
        self.character = dtype[1]    # 获取 'f'
        self.bytewidth = dtype[2]    # 获取 '8'

class Header:
    def __init__(self, path: str):
        # 假设 foo1() 返回 '<f8'
        self.DTYPE = _DTYPE("<f8") 
        self.NMEMB = "foo"
        self.NFILE = "bar"

# 实例化 Header
h = Header("dummy_path.txt")

# 访问 _DTYPE 实例的属性
char = h.DTYPE.character    # 返回 'f'
width = h.DTYPE.bytewidth    # 返回 '8'
raw = h.DTYPE.rawString      # 返回 '<f8'

# 直接引用 _DTYPE 实例
print(h.DTYPE)

当我们尝试直接引用 h.DTYPE 并打印它时，Python会输出类似 <__main__._DTYPE object at 0x...> 的内容，这表示该变量持有的正是 _DTYPE 类的实例的内存地址（或其默认字符串表示）。用户期望的是，在某些情况下，直接引用 h.DTYPE 能够返回 _DTYPE 实例内部的 rawString 值（例如 "<f8"），而不是对象引用本身，同时仍然能够通过 h.DTYPE.character 等方式访问其子成员。

用户可能会联想到字符串等内置类型，如 text="Some string"; a=text; b=text.upper()。在这里，a=text 似乎直接获取了字符串的值。然而，这并非因为字符串对象在赋值时返回了其内部值，而是因为 str 对象本身就是其内容的封装，且字符串是不可变类型。a 同样持有对 str 对象的引用，只是其默认表示和行为与用户定义的类有所不同。

解决方案：利用 __call__ 魔术方法

Python的面向对象模型规定，直接引用一个对象实例 (h.DTYPE) 始终返回该实例的引用。没有一个“魔术方法”能够改变这种行为，使其在没有显式属性访问或方法调用的情况下，直接返回一个内部值。

立即学习“Python免费学习笔记（深入）”；

然而，我们可以通过重写 __call__ 魔术方法，让对象实例表现得像一个函数。当一个对象实例被“调用”时（即在其后加上括号 ()），__call__ 方法就会被执行。这使得我们可以定义一个默认行为，在对象被调用时返回一个特定的值。

以下是修改后的 _DTYPE 类实现：

class _DTYPE:
    def __init__(self, dtype: str):  # input dtype = '<f8'
        self.rawString = dtype       # 获取 '<f8'
        self.endianness = dtype[0]   # 获取 '<'
        self.character = dtype[1]    # 获取 'f'
        self.bytewidth = dtype[2]    # 获取 '8'

    def __call__(self):
        """
        当 _DTYPE 实例被像函数一样调用时，返回其 rawString 属性。
        例如：h.DTYPE()
        """
        return self.rawString

class Header:
    def __init__(self, path: str):
        self.DTYPE = _DTYPE("<f8")
        self.NMEMB = "foo"
        self.NFILE = "bar"

# 实例化 Header
header = Header("dummy_path.txt")

# 演示 __call__ 的用法
# 此时，header.DTYPE() 会执行 _DTYPE 实例的 __call__ 方法，返回 self.rawString
test_value = header.DTYPE()            # <--- 调用实例，获取 '<f8'
print(f"通过调用实例获取的值: {test_value}")

# 仍然可以通过点号访问实例的属性
test_raw_string = header.DTYPE.rawString   # <--- 访问实例的属性，获取 '<f8'
test_character = header.DTYPE.character    # <--- 访问实例的属性，获取 'f'
print(f"通过属性访问获取的 rawString: {test_raw_string}")
print(f"通过属性访问获取的 character: {test_character}")

代码解析：

1. 在 _DTYPE 类中，我们添加了 __call__(self) 方法。
2. 当执行 header.DTYPE() 时，Python会调用 header.DTYPE 对象（即 _DTYPE 实例）的 __call__ 方法。
3. __call__ 方法返回 self.rawString，因此 test_value 将被赋值为 "<f8"。
4. 同时，我们仍然可以通过 header.DTYPE.rawString 或 header.DTYPE.character 等方式，使用点号来访问 _DTYPE 实例的其他属性。

这种方法在一定程度上满足了用户的需求，即在不直接访问特定属性的情况下，让对象实例执行一个“默认动作”并返回一个值。

来画数字人直播

来画数字人自动化直播，无需请真人主播，即可实现24小时直播，无缝衔接各大直播平台。

0

查看详情

注意事项与替代方案

1. Python对象模型的限制： 再次强调，在Python中，直接引用一个对象实例（例如 h.DTYPE）始终会返回该对象实例的引用本身。Python没有提供任何“魔术方法”能够改变这种基本行为，使其在不使用点号（.）访问属性或括号（()）调用方法的情况下，直接将对象实例赋值给变量时返回其内部的某个特定值。

2. __call__ 的适用性： __call__ 方法允许对象实例像函数一样被调用（obj()），从而在调用时执行特定逻辑并返回一个值。这是在不访问特定属性的情况下，让对象实例执行“默认行为”并返回一个值的最接近且符合Python习惯的方式。

3. 与用户期望的差异： 这种方法与用户最初期望的 raw = h.DTYPE 直接返回内部值有所不同，因为 __call__ 仍然需要显式的 () 调用。如果用户希望完全省略 ()，那么在Python的当前设计下是无法实现的。

4. __str__ 和 __repr__ 的局限性： 尽管 __str__ 和 __repr__ 可以改变对象在 print() 或交互式解释器中的字符串表示，但它们不会影响直接赋值时的行为。raw = h.DTYPE 仍然会将 _DTYPE 实例的引用赋值给 raw，而不是 __str__ 或 __repr__ 返回的字符串。

5. 其他设计考虑： 如果用户强烈希望 h.DTYPE 直接返回 rawString 而不需要 ()，那么可能需要重新考虑类的设计。例如，如果 _DTYPE 实例的主要目的是封装 rawString 并在某些情况下提供其解析后的组件，那么 Header 类可以直接有一个 raw_dtype_string 属性，而 _DTYPE 实例可以作为一个单独的、更复杂的属性存在，或者仅在需要其解析能力时才创建。

   # 替代设计示例：Header 直接提供 raw_dtype_string
   class HeaderAlternative:
       def __init__(self, path: str):
           self._raw_dtype_str = "<f8" # 假设 foo1() 返回 '<f8'
           self.NMEMB = "foo"
           self.NFILE = "bar"
   
       @property
       def DTYPE_raw(self):
           return self._raw_dtype_str
   
       @property
       def DTYPE_parsed(self):
           # 只有在需要时才创建或返回 _DTYPE 实例
           return _DTYPE(self._raw_dtype_str)
   
   h_alt = HeaderAlternative("dummy_path.txt")
   raw_val = h_alt.DTYPE_raw            # 直接获取 raw string
   char_val = h_alt.DTYPE_parsed.character # 访问解析后的属性

   登录后复制

   这种设计通过提供不同的属性名称来区分直接获取原始字符串和获取解析后的对象，避免了对Python核心行为的误解。

总结

在Python中，要实现一个类实例在被“调用”时返回一个特定值，同时仍能通过点号访问其内部属性，最符合Python习惯且有效的方法是重写 __call__ 魔术方法。这使得对象实例能够像函数一样被调用（例如 instance()），从而执行预定义的逻辑并返回所需的值。然而，需要明确的是，直接引用一个对象实例 (instance) 始终会返回该实例的引用，Python不提供改变此核心行为的机制。因此，对于期望 raw = h.DTYPE 自动返回内部值的场景，可能需要重新评估设计或接受 raw = h.DTYPE() 这种带括号的调用方式。

以上就是Python类设计：如何让实例在直接引用时返回特定值而非内存地址的详细内容，更多请关注php中文网其它相关文章！