Python 3.6中基类如何通过多态访问子类变量？求最佳实践

首先明确说：Python技术上完全能做到基类访问子类的变量，但确实像你说的，这有点违背OOP的设计原则——基类本该是抽象的，不该依赖子类的具体实现。咱们先看怎么实现，再聊聊这种场景下的最佳实践。

一、技术上的实现方式 #

因为Python是动态类型语言，只要子类实例拥有某个属性，基类通过self就能访问到它。结合你给的Animal示例，咱们改一下：

class Animal:
    def __init__(self, name):
        self.name = name
    
    def talk(self):
        # 抽象方法，按约定定义
        raise NotImplementedError
    
    # 基类方法，访问子类的变量
    def get_species(self):
        # 先判断实例有没有这个属性，避免报错
        if hasattr(self, 'species'):
            return self.species
        return "Unknown"

class Dog(Animal):
    def __init__(self, name):
        super().__init__(name)
        # 子类定义自己的变量
        self.species = "Canine"
    
    def talk(self):
        return "Woof!"

class Cat(Animal):
    def __init__(self, name):
        super().__init__(name)
        self.species = "Feline"
    
    def talk(self):
        return "Meow!"

测试一下就知道，当你创建Dog或Cat的实例，调用get_species()时，基类的方法能拿到子类的species值——本质是self在运行时指向的是子类的实例，自然能访问到实例上的属性。

但这种方式的问题很明显：基类硬编码了子类的属性名，一旦子类改了species的名字，基类的方法直接就崩了，耦合度太高，完全不符合OOP的依赖倒置原则。

二、更合理的最佳实践 #

既然直接访问子类属性不太靠谱，咱们有两种更符合OOP原则的方案：

1. 用抽象属性强制子类实现 #

Python 3.6可以借助abc模块，在基类里定义抽象属性，强制所有子类必须实现这个属性。这样既保证了多态性，又让基类只依赖抽象定义，不依赖子类的具体实现：

from abc import ABCMeta, abstractmethod, abstractproperty

class Animal(metaclass=ABCMeta):
    def __init__(self, name):
        self.name = name
    
    @abstractmethod
    def talk(self):
        pass
    
    # 定义抽象属性，子类必须实现
    @abstractproperty
    def species(self):
        pass
    
    def get_species(self):
        # 只依赖抽象的species属性，不管子类怎么实现
        return self.species

class Dog(Animal):
    def __init__(self, name):
        super().__init__(name)
    
    def talk(self):
        return "Woof!"
    
    # 子类实现抽象属性
    @property
    def species(self):
        return "Canine"

class Cat(Animal):
    def __init__(self, name):
        super().__init__(name)
    
    def talk(self):
        return "Meow!"
    
    @property
    def species(self):
        return "Feline"

这种方式下，如果子类没实现species属性，连实例都创建不了，从源头保证了一致性，耦合度低，代码也更易维护。

2. 通过初始化参数传递属性 #

如果这个变量是实例级别的，也可以在子类初始化时，把属性值传递给基类的构造函数，让基类自己持有这个属性：

class Animal:
    def __init__(self, name, species):
        self.name = name
        # 基类自己拥有species属性
        self.species = species
    
    def talk(self):
        raise NotImplementedError
    
    def get_species(self):
        return self.species

class Dog(Animal):
    def __init__(self, name):
        # 子类传递具体的species值给基类
        super().__init__(name, "Canine")
    
    def talk(self):
        return "Woof!"

class Cat(Animal):
    def __init__(self, name):
        super().__init__(name, "Feline")
    
    def talk(self):
        return "Meow!"

这种方案更简单直接，基类完全不依赖子类的内部实现，所有属性都由基类自己管理，完全符合OOP的封装和继承原则，是最安全的做法。

总结 #

技术上Python支持基类访问子类变量，但不推荐这么做——耦合度太高，代码容易出问题。更合理的选择是用抽象属性强制子类实现，或者通过初始化参数把属性交给基类管理，这两种方案都能满足你的需求，同时符合OOP的设计理念。

内容的提问来源于stack exchange，提问作者Shahar Do