继承
例行寒暄之后，课程正式开始
查老四：继承是面向对象编程中的一个重要概念。它允许我们创建一个新类，继承一个现有类的属性和方法，从而实现代码的重用。新类被称为子类，现有类被称为父类。
在Python中，通过在子类名后的括号中写入父类名来实现继承。下面是一个简单的示例
# 父类
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
return f"{self.name} 说：我是一个动物。"
# 子类
class Dog(Animal):
def speak(self):
return f"{self.name} 说：汪汪！"
dog = Dog("旺财")
print(dog.speak()) # 输出：旺财 说：汪汪！在这个示例中，我们定义了一个父类Animal，它有一个name属性和一个speak方法。然后我们创建了一个Dog类，继承自Animal。Dog类重写了speak方法，以提供狗的叫声。
练习题：请创建一个名为Cat的子类，继承自Animal类，并重写speak方法，输出猫的叫声。
练习：
首先，我们需要创建一个基类 Animal，然后创建一个继承自 Animal 类的子类 Cat。接下来重写 speak 方法以输出猫的叫声。下面是示例代码：
# 基类 Animal
class Animal:
def speak(self):
print("Animals have their own ways of speaking.")
# 子类 Cat 继承自 Animal
class Cat(Animal):
def speak(self):
print("Meow!")
# 创建一个 Cat 类的实例并调用 speak 方法
cat1 = Cat()
cat1.speak()在这个示例中，我们首先定义了一个名为 Animal 的基类，并为其添加了一个简单的 speak 方法。然后，我们创建了一个名为 Cat 的子类，它继承自 Animal 类。我们重写了 speak 方法，使其输出猫的叫声 "Meow!"。
最后，我们创建了一个 Cat 类的实例 cat1 并调用了 speak() 方法。这将输出 "Meow!"，而不是 Animal 类中定义的 "Animals have their own ways of speaking."。这证明了我们已经成功地重写了 speak 方法。
多态
查老四：2. 多态的概念及如何在Python中实现多态
多态是指不同类的对象可以使用相同的方法名，但具有不同的实现。在Python中，多态的实现主要依赖于动态类型和鸭子类型。
下面是一个多态的示例：
def animal_speak(animal):
print(animal.speak())
# 创建一个狗对象
dog = Dog("旺财")
# 创建一个猫对象（请参照上面的练习题创建Cat类）
cat = Cat("咪咪")
animal_speak(dog) # 输出：旺财 说：汪汪！
animal_speak(cat) # 输出：咪咪 说：喵喵！在这个示例中，我们定义了一个名为animal_speak的函数，它接受一个animal参数，并调用其speak方法。因为Dog和Cat类都有speak方法，所以我们可以将它们的对象传递给这个函数，实现多态。
练习题：请创建一个名为Fish的子类，继承自Animal类，并重写speak方法，输出鱼的叫声。然后使用animal_speak函数，让这条鱼“说话”。
练习：
首先，我们需要创建一个名为 Fish 的子类，继承自 Animal 类，并重写 speak 方法以输出鱼的叫声。接下来，我们将定义一个名为 animal_speak 的函数，用于调用输入动物对象的 speak 方法。以下是示例代码：
# 基类 Animal
class Animal:
def speak(self):
print("Animals have their own ways of speaking.")
# 子类 Fish 继承自 Animal
class Fish(Animal):
def speak(self):
print("Fish don't make audible sounds, they communicate in other ways!")
# 定义 animal_speak 函数
def animal_speak(animal):
animal.speak()
# 创建一个 Fish 类的实例并使用 animal_speak 函数让它“说话”
fish1 = Fish()
animal_speak(fish1)在这个示例中，我们已经有了一个名为 Animal 的基类。接着，我们创建了一个名为 Fish 的子类，它继承自 Animal 类。我们重写了 speak 方法，使其输出关于鱼如何交流的信息。
然后，我们定义了一个名为 animal_speak 的函数，该函数接受一个动物对象作为参数，然后调用该对象的 speak 方法。
最后，我们创建了一个 Fish 类的实例 fish1 并通过 animal_speak 函数调用了它的 speak() 方法。这将输出 "Fish don't make audible sounds, they communicate in other ways!"，表明我们已经成功地重写了 speak 方法并使用了 animal_speak 函数。
重写父类
有时候，在子类中我们可能需要在重写的方法中调用父类的同名方法。这时，我们可以使用super()函数。super()函数用于调用父类的方法。
下面是一个使用super()的示例：
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
return f"{self.name} 说：我是一个动物。"
class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name)
self.breed = breed
def speak(self):
return super().speak() + f" 我是一只{self.breed}。"
dog = Dog("旺财", "柯基")
print(dog.speak()) # 输出：旺财 说：我是一个动物。 我是一只柯基。在这个示例中，我们为Dog类添加了一个breed属性，表示狗的品种。Dog类的__init__方法使用super().__init__(name)调用Animal类的__init__方法，以设置name属性。Dog类的speak方法也使用super().speak()调用了父类的speak方法，然后追加了狗的品种信息。
练习题：请为Cat类添加一个表示猫的颜色的color属性，并使用super()函数在__init__方法中调用父类的__init__方法。然后在speak方法中调用父类的speak方法，并追加猫的颜色信息。
首先，我们需要修改 Animal 类的 __init__ 方法以接受并存储颜色属性。然后，在 Cat 类中，我们将使用 super() 函数调用父类的 __init__ 方法，并在 speak 方法中调用父类的 speak 方法，之后追加猫的颜色信息。以下是示例代码：
# 基类 Animal
class Animal:
def __init__(self, color):
self.color = color
def speak(self):
print("Animals have their own ways of speaking.")
# 子类 Cat 继承自 Animal
class Cat(Animal):
def __init__(self, color):
super().__init__(color)
def speak(self):
super().speak()
print(f"The cat says 'Meow!' and its color is {self.color}.")
# 创建一个 Cat 类的实例并调用 speak 方法
cat1 = Cat("black")
cat1.speak()在这个示例中，我们修改了基类 Animal 的 __init__ 方法，使其接受颜色参数并将其存储到 color 属性中。接着，我们创建了一个名为 Cat 的子类，它继承自 Animal 类。在 Cat 类的 __init__ 方法中，我们使用了 super().__init__(color) 来调用父类的构造方法，并传递颜色参数。
然后，我们修改了 Cat 类的 speak 方法。在此方法中，我们首先调用了父类（Animal）的 speak 方法，然后输出了猫的叫声和颜色信息。
最后，我们创建了一个具有 "black" 颜色的 Cat 类实例 cat1 并调用了其 speak() 方法。这将依次输出 "Animals have their own ways of speaking." 和 "The cat says 'Meow!' and its color is black."，证明我们已经成功地调用了父类的 __init__ 和 speak 方法，并追加了猫的颜色信息。
当日大作业
编写一些涉及继承和多态的Python程序，巩固所学知识
请根据以上讲解和示例，编写涉及继承和多态的Python程序。您可以尝试创建其他动物类，如Bird、Snake等，并为它们添加特定的属性和方法。同时，尝试使用animal_speak函数，让不同种类的动物“说话”。
练习：
下面是一个涉及继承和多态的 Python 程序示例，包含 Bird 和 Snake 类。这两个类都继承自基类 Animal 并重写了 speak 方法。我们还会使用之前定义的 animal_speak 函数让不同种类的动物“说话”。
class Animal:
def __init__(self, color):
self.color = color
def speak(self):
print("Animals have their own ways of speaking.")
class Bird(Animal):
def __init__(self, color, can_fly=True):
super().__init__(color)
self.can_fly = can_fly
def speak(self):
super().speak()
if self.can_fly:
print(f"The bird tweets and its color is {self.color}.")
else:
print(f"The flightless bird tweets and its color is {self.color}.")
class Snake(Animal):
def __init__(self, color, venomous=False):
super().__init__(color)
self.venomous = venomous
def speak(self):
super().speak()
if self.venomous:
print(f"The venomous snake hisses and its color is {self.color}.")
else:
print(f"The non-venomous snake hisses and its color is {self.color}.")
def animal_speak(animal):
animal.speak()
# 创建各种动物实例
bird1 = Bird("blue")
bird2 = Bird("grey", can_fly=False)
snake1 = Snake("green", venomous=True)
snake2 = Snake("brown", venomous=False)
# 使用 animal_speak 函数让动物说话
print("\nBird 1 speaks:")
animal_speak(bird1)
print("\nBird 2 speaks:")
animal_speak(bird2)
print("\nSnake 1 speaks:")
animal_speak(snake1)
print("\nSnake 2 speaks:")
animal_speak(snake2)在这个示例中，我们创建了两个子类 Bird 和 Snake，它们都继承自基类 Animal。每个子类都有其特定的属性和方法。Bird 类具有 can_fly 属性，表示鸟是否能飞，且默认值为 True；Snake 类具有 venomous 属性，表示蛇是否有毒，且默认值为 False。
我们分别为 Bird 和 Snake 类重写了 speak 方法，使其输出父类 Animal 的 speak 方法结果，然后追加输出特定的动物叫声信息和颜色信息。
最后，我们创建了两只鸟（bird1 和 bird2）和两条蛇（snake1 和 snake2）的实例，并通过 animal_speak 函数调用它们各自的 speak() 方法。这展示了多态性，因为我们可以使用相同的函数处理不同种类的动物对象。
标签：__,animal,Python,self,多态,color,Animal,Day,speak From： https://blog.51cto.com/cloudzun/6188122所有练习都对了答案，查老四反馈都说好