python，继承错误，python图形及代码

Python继承错误

Python是一种面向对象的编程语言，面向对象程序设计中继承是非常重要的一个概念。继承是一种机制，使子类继承父类的属性和方法。在Python中实现继承非常简单，但是继承错误也是程序员所面临的一大挑战。

常见的继承错误有多种，其中一种常见的错误是方法重写，在子类中重新定义了与父类同名的方法。另一种继承错误是没有正确使用super()，从而导致方法的执行顺序或参数传递错误。

方法重写错误

方法重写是指在子类中重新定义了与父类同名的方法，从而覆盖了父类中原有的方法。在某些情况下，这可能是有意的，但有时候会导致一些意想不到的结果。例如，考虑以下代码：

```python

class Animal:

def speak(self):

print("Animal speaks")

class Dog(Animal):

def speak(self):

print("Dog barks")

class Cat(Animal):

pass

a = Animal()

d = Dog()

c = Cat()

a.speak() # Animal speaks

d.speak() # Dog barks

c.speak() # Animal speaks

```

在上面的代码中，我们定义了一个Animal类和两个子类，Dog和Cat。Animal类有一个speak()方法，该方法打印一个字符串“Animal speaks”。Dog类重写了speak()方法，打印“Dog barks”。Cat类没有定义speak()，因此继承自Animal类。

在上面的代码中调用speak()方法时，输出结果与我们所期望的一样：a.speak()输出“Animal speaks”、d.speak()输出“Dog barks”、c.speak()（通过继承Animal）也输出“Animal speaks”。

现在考虑修改Cat类，为其定义speak()方法：

```python

class Cat(Animal):

def speak(self):

print("Cat meows")

a = Animal()

d = Dog()

c = Cat()

a.speak() # Animal speaks

d.speak() # Dog barks

c.speak() # Cat meows

```

在上面的代码中，我们给Cat类定义了一个speak()方法，该方法输出“Cat meows”。然而，我们还预料到c.speak()会输出“Animal speaks”，因为Cat类继承了Animal类，并且没有重写speak()方法。但是，输出的结果与我们预想的不一样。这是由于父类的方法被覆盖，当我们实例化Cat对象时，它从父类Animal中继承了speak()方法，该方法同样被重写，输出了“Cat meows”。

解决这个问题最简单的方法是在子类中调用父类的方法。在Python中，可以使用super()函数调用父类的方法。在这种情况下，我们应该修改Cat类的定义如下：

```python

class Cat(Animal):

def speak(self):

super().speak()

print("Cat meows")

```

在上面的代码中，我们使用super()函数调用父类的speak()方法。这将确保Cat类继承了Animal类的speak()方法，并在该方法调用后添加了其他的实现。现在运行c.speak()，输出结果为“Animal speaks”、“Cat meows”，符合预期。

super()函数错误

super()函数是Python中调用父类方法的一种常见方式。通过使用super()函数，子类可以调用父类的方法并继承其属性。使用super()函数有两种常见的错误：错误的执行顺序和错误的参数传递。

1. 执行顺序错误

考虑以下代码，它定义了两个类Employee和Manager。Manager继承自Employee，并覆盖了父类中salary()方法。这个方法计算每个员工的工资，并在Manager对象上添加一个奖金。

```python

class Employee:

def __init__(self, name, rate, hours):

self.name = name

self.rate = rate

self.hours = hours

def salary(self):

salary = self.rate * self.hours

return salary

class Manager(Employee):

def __init__(self, name, rate, hours, bonus):

super().__init__(name, rate, hours)

self.bonus = bonus

def salary(self):

salary = super().salary()

return salary + self.bonus

e = Employee("John", 25, 40)

m = Manager("Susan", 35, 45, 1000)

print(e.salary()) # 1000

print(m.salary()) # 2275

```

在上面的代码中，我们使用super()函数在Manager类中调用Employee类的构造函数以初始化共有的属性。在Manager类中使用super()函数调用salary()方法时，我们仅需要返回Manager的基本工资和奖金之和。

当我们运行该代码时，发现输出的内容与预期不一致。Employee对象输出1000，Manager对象输出2275。原因是在Manager类的salary()方法中，我们调用了升级的方法而不是父类的方法。由于方法执行顺序出错，我们计算的不是基本工资和奖金之和，而是包括奖金的原有工资。这是我们在定义Manager类时需要小心的一个细节。调用父类方法时，应该先执行父类，然后才执行子类的方法。

我们可以通过修改Manager类中的salary()方法，如下所示，来解决这个问题：

```python

class Manager(Employee):

def __init__(self, name, rate, hours, bonus):

super().__init__(name, rate, hours)

self.bonus = bonus

def salary(self):

salary = self.rate * self.hours

return salary + self.bonus

```

2. 参数传递错误

在一些情况下，子类需要传递参数给其父类方法。这些参数可能是必需的，或者将一个属性与另一个属性进行相互转换。但是，子类在调用父类方法时必须提供正确的参数。

现在假设我们有两个类Person和Worker，Worker继承自Person。Person类有一个初始化方法，Worker类有一个salary()方法。每个工人都有一个工作时长work_hours，其小时工资rate，以及名字和年龄。Person类初始化时只需要名字和年龄，而Worker类初始化时还需要传递工作时间和小时工资。

```python

class Person:

def __init__(self, name, age):

self.name = name

self.age = age

class Worker(Person):

def __init__(self, name, age, rate, work_hours):

super().__init__(name, age)

self.rate = rate

self.work_hours = work_hours

def salary(self):

return self.rate * self.work_hours

p = Person("Sarah", 21)

w = Worker("Tom", 25, 20, 40)

print(p.name) # Sarah

print(w.name) # Tom

print(w.salary()) # 800

```

在上面的代码中，我们创建了两个类Person和Worker。Worker继承自Person，并将工作时间和小时工资提供给salary()方法。我们创建了两个实例p和w，并测试了它们的属性和方法。

当我们运行该代码时，将得到正确的输出结果。但是，考虑下面的代码：

```python

class Manager(Worker):

def __init__(self, name, age, rate, work_hours, bonus):

super().__init__(name, age)

self.bonus = bonus

def salary(self):

salary = super().salary()

return salary + self.bonus

m = Manager("Mike", 32, 30, 40, 1000)

print(m.name) # Mike

print(m.salary()) # TypeError: salary() missing 2 required positional arguments: 'rate' and 'work_hours'

```

在上面的代码中，我们定义了Manager类，继承自Worker类。与Worker类一样，我们也重写了salary()方法。我们在Manager类的初始化中添加了一个bonus属性。在salary()方法中使用super()函数调用Worker类的salary()方法。运行上面的代码，将抛出一个TypeError异常“salary() missing 2 required positional arguments: 'rate' and 'work_hours'”。

这是由于在Manager类的初始化中，我们忘记了向Worker类传递所需的额外参数rate和work_hours。为了解决这个问题，我们应该修改Manager类的初始化方法，如下所示：

```python

class Manager(Worker):

def __init__(self, name, age, rate, work_hours, bonus):

super().__init__(name, age, rate, work_hours)

self.bonus = bonus

def salary(self):

salary = super().salary()

return salary + self.bonus

m = Manager("Mike", 32, 30, 40, 1000)

print(m.name) # Mike

print(m.salary()) # 1300

```

在上面的代码中，我们向Worker类传递了所需的额外参数，现在运行代码输出符合预期。

总结

在Python中，如果要实现面向对象的编程，继承是必不可少的一个概念。正如本文中所讨论的那样，继承中可能会出现各种各样的错误，包括方法重写和super()函数的使用。通过小心地编写代码，遵循最佳实践，我们可以避免这些错误，并实现高效的继承。 如果你喜欢我们三七知识分享网站的文章， 欢迎您分享或收藏知识分享网站文章 欢迎您到我们的网站逛逛喔！https://www.37seo.cn/