Python多继承中类变量的作用是什么？

Python中的多继承机制使得一个类可以从多个父类中继承属性和方法。在多继承中，类变量的作用显得格外重要。本文将详细介绍类变量在多继承中的应用及其作用。

更多Python文章，请阅读：Python 教程

Python中的多继承

在Python中，多继承的概念比较简单，即一个子类可以继承多个父类的属性和方法。

例如，我们定义一个Animal类，其中有一个make_sound()方法：

class Animal:
    species = 'unknown'
    def make_sound(self):
        print("The animal makes a sound")

然后再定义两个父类：

class Bird:
    species = 'bird'
    def fly(self):
        print("The bird flies")

class Mammal:
    species = 'mammal'
    def feed_young(self):
        print("The mammal feeds its young")

现在可以通过多继承来创建一个新的类：

class Platypus(Bird, Mammal, Animal):
    def __init__(self):
        self.species = 'platypus'

p = Platypus()
p.fly()
p.feed_young()
p.make_sound()

可以看出，Platypus类继承了Bird、Mammal和Animal三个父类的属性和方法。

类变量的作用

类变量是在整个类中都可见、任何实例对象都可以访问的变量。在多继承中，如果有多个父类定义了同名的类变量，那么子类在访问这个类变量时，会按照继承顺序依次查找，直到找到为止。

例如，我们定义三个父类，其中Bird和Animal有一个相同的类变量species：

class Bird:
    species = 'bird'
    def fly(self):
        print("The bird flies")

class Animal:
    species = 'unknown'
    def make_sound(self):
        print("The animal makes a sound")

class Platypus(Animal, Bird):
    def __init__(self):
        pass

p = Platypus()
print(p.species)

此时输出的结果是’unknown’，即在多继承中按照继承顺序查找，先找到Animal类的species变量，因此输出为’unknown’。

如果我们将Animal和Bird的继承顺序调换一下，再运行程序，输出的结果就是’bird’了：

class Platypus(Bird, Animal):
    def __init__(self):
        pass

p = Platypus()
print(p.species)

这是因为在多继承中，按照继承顺序查找类变量时是从左到右依次进行的，找到第一个后就停止查找了。

类变量的修改

在多继承中，如果一个子类修改了类变量的值，那么这个值也会在其他继承这个类的子类中被修改。

例如，我们定义一个父类Animal，其中有一个类变量species:

class Animal:
    species = 'unknown'
    def __init__(self, name):
        self.name = name
    def print_species(self):
        print(f"{self.name} is a {self.species}")

然后定义两个子类Dog和Cat，它们都继承了Animal类：

class Dog(Animal):
    species = 'dog'

class Cat(Animal):
    species = 'cat'

现在我们创建了两个实例对象：

d = Dog('Jack')
c = Cat('Misty')

执行以下代码，输出结果都为各自的species值：

d.print_species()
c.print_species()

接下来我们修改Dog类的species值：

Dog.species = 'puppy'

然后执行以下代码，输出结果为puppy和cat：

d.print_species()
c.print_species()

可以看出，修改了Dog类的species值之后，所有继承它的子类的species都发生了变化。

继承顺序

在多继承中，继承顺序是非常重要的。因为如果有多个父类都定义了同名的方法，那么子类在调用该方法时会按照继承顺序查找，直到找到为止。

Python中有一个标准的继承顺序算法——C3算法。它可以确保在任何情况下都能找到最好的继承顺序。

例如，我们定义三个父类，其中Bird和Mammal中都有一个相同的方法feed_young：

class Bird:
    species = 'bird'
    def fly(self):
        print("The bird flies")
    def feed_young(self):
        print("The bird feeds its young")

class Animal:
    species = 'unknown'
    def make_sound(self):
        print("The animal makes a sound")

class Mammal:
    species = 'mammal'
    def feed_young(self):
        print("The mammal feeds its young")

然后创建一个子类Platypus继承这三个父类：

class Platypus(Animal, Mammal, Bird):
    def __init__(self):
        pass

p = Platypus()
p.feed_young()

在执行p.feed_young()时，会按照C3算法的继承顺序依次查找，即Animal -> Mammal -> Bird，最终调用Bird类的feed_young()方法。因此输出的结果是：

The bird feeds its young

如果没有使用C3算法，那么这个方法调用的顺序就不一定了。

super()方法

在多继承中，如果不确定应该调用哪个父类的方法，可以使用super()方法来解决这个问题。

super()方法返回一个临时对象，该对象继承了指定的父类，可以使用它来调用指定父类的方法。

例如，我们现在有两个父类：

class Grandfather:
    def speak(self):
        print("The grandfather speaks")

class Father:
    def speak(self):
        print("The father speaks")

然后创建一个子类，同时继承这两个父类，并重写speak()方法：

class Son(Grandfather, Father):
    def speak(self):
        super().speak()

这里的super()方法会返回一个临时对象，从而调用指定的父类的speak()方法。这里我定义的是Grandfather在先，所以输出结果为：

The grandfather speaks

如果将继承顺序改为Father在先，则输出结果为：

The father speaks

结论

在多继承中，类变量的作用十分重要。它们可以影响子类中同名变量的值，同时也可以尽量避免在继承链中出现混乱的重名方法。但是，在使用类变量时需要注意一些细节，比如继承顺序的问题。此外，如果出现多个同名方法的情况，可以使用super()方法来解决。