shape为抽象基类，circle，triangle，square为子类，main函数中测试多态效果，成员函数draw()

作用是输出不同形状的图形。

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def draw(self):
        pass

class Circle(Shape):
    def draw(self):
        print("Drawing a circle")

class Triangle(Shape):
    def draw(self):
        print("Drawing a triangle")

class Square(Shape):
    def draw(self):
        print("Drawing a square")

def main():
    shapes = [Circle(), Triangle(), Square()]
    for shape in shapes:
        shape.draw()

if __name__ == '__main__':
    main()

输出结果：

Drawing a circle
Drawing a triangle
Drawing a square

相关问题

定义抽象基类shape，由它派生出五个派生类：circle（圆形）、square（正方形）、rectangle（ 长方形）、trapezoid （梯形）和triangle （三角形），用虚函数分别计算

### 回答1：
面积和周长。抽象基类shape中包含两个纯虚函数：计算面积和计算周长。每个派生类都必须实现这两个函数。这样，我们可以通过shape指针来访问不同的派生类对象，而不必关心它们的具体类型。这种设计模式称为多态。

### 回答2：
抽象基类shape是一个纯虚类，它的主要作用是为了其它派生类提供一些通用的方法和属性。在这个题目中，我们定义了一个shape类，并且派生出了五个不同的图形，分别是圆形、正方形、长方形、梯形和三角形，每个图形都有不同的属性和方法。

在这个题目中，我们可以将shape类中的一些属性设置为纯虚函数，以便在派生类中进行重写。例如，计算面积和计算周长这些方法可以被定义为纯虚函数，以便每个派生类可以在其内部完成相应的计算。

对于圆形，我们可以定义一个radius属性，表示圆的半径，然后可以通过计算公式π*r^2和周长2*π*r来计算圆的面积和周长。对于正方形和长方形，我们可以定义width和height属性，分别代表矩形的宽度和高度，然后可以通过计算公式w*h来计算面积，通过计算公式2*(w+h)来计算周长。

对于梯形，我们可以定义一个height属性，表示梯形的高度，同时定义top和bottom属性，表示梯形的上底和下底，然后可以通过计算公式(上底+下底)*height/2来计算梯形的面积，通过计算公式上底+下底+2*height来计算周长。

对于三角形，我们可以定义base和height属性，表示三角形的底和高，然后可以通过计算公式base*height/2来计算三角形的面积，通过计算公式sqrt(base^2+height^2)+base+height来计算周长。

以上就是shape类及其派生类的具体定义和实现过程，每个派生类都可以通过重载基类的纯虚函数，实现自己独特的功能。通过这样的设计，我们可以很方便地对不同的图形进行面积和周长的计算，从而提高代码的复用性和灵活性。

### 回答3：
抽象基类shape是一种只包含纯虚函数的类，它不能被实例化，但可以用作其他类的基类。在这个问题中，我们定义了shape类用于派生五个派生类：circle（圆形）、square（正方形）、rectangle（长方形）、trapezoid（梯形）和triangle（三角形）。

对于shape类，我们可以定义一个纯虚函数来计算图形的面积。每个派生类都将实现这个函数以计算不同形状的面积，例如：

class shape{
public:
    virtual double calculate_area() = 0; // 纯虚函数
};

class circle : public shape {
private:
    double radius;
public:
    circle(double r) : radius(r) {}
    double calculate_area() {
        return 3.14 * radius * radius;
    }
};

class square : public shape {
private:
    double side;
public:
    square(double s) : side(s) {}
    double calculate_area() {
        return side * side;
    }
};

class rectangle : public shape {
private:
    double length;
    double width;
public:
    rectangle(double l, double w) : length(l), width(w) {}
    double calculate_area() {
        return length * width;
    }
};

class trapezoid : public shape {
private:
    double base1;
    double base2;
    double height;
public:
    trapezoid(double b1, double b2, double h) : base1(b1), base2(b2), height(h) {}
    double calculate_area() {
        return ((base1 + base2) / 2) * height;
    }
};

class triangle : public shape {
private:
    double base;
    double height;
public:
    triangle(double b, double h) : base(b), height(h) {}
    double calculate_area() {
        return 0.5 * base * height;
    }
};

以上是shape类和其五个派生类的定义。每个派生类实现了它们自己的计算面积的函数。当我们需要计算某个图形的面积时，可以声明一个指向派生类对象的指针，该指针可以调用该对象的calculate_area()函数进行计算。例如：

shape* s1 = new circle(3);      // 圆形
shape* s2 = new square(4);      // 正方形
shape* s3 = new rectangle(3,4); // 长方形
shape* s4 = new trapezoid(4,5,2);// 梯形
shape* s5 = new triangle(3,4);  // 三角形

cout << s1->calculate_area() << endl; // 输出圆形面积
cout << s2->calculate_area() << endl; // 输出正方形面积
cout << s3->calculate_area() << endl; // 输出长方形面积
cout << s4->calculate_area() << endl; // 输出梯形面积
cout << s5->calculate_area() << endl; // 输出三角形面积

以上代码将输出每个派生类对象的面积，因为shape类是抽象类，所以不能实例化。我们需要通过指向派生类对象的指针来调用它们的calculate_area()函数。虚函数是一种实现多态的方式，它可让派生类对象访问其成员函数，在运行时动态确定调用哪个函数，因此多个派生类可以共享同一个接口，从而提高代码的可维护性和可扩展性。

怎么实现C++中基类使用虚函数怎么调用多个子类

实现C++中基类使用虚函数的调用多个子类方法可以采用多态的机制，具体可以通过以下步骤实现：

1. 在基类中声明虚函数，子类可以重写这个函数。
2. 声明一个基类指针指向子类对象，通过这个指针调用虚函数实现多态。
3. 通过动态绑定机制在运行时确定调用哪个子类的虚函数。

例如：

#include <iostream>
using namespace std;

class Shape {
public:
    virtual void draw() {
        cout << "Shape::draw() called" << endl;
    }
};

class Circle : public Shape {
public:
    void draw() {
        cout << "Circle::draw() called" << endl;
    }
};

class Square : public Shape {
public:
    void draw() {
        cout << "Square::draw() called" << endl;
    }
};

int main() {
    Shape *s;
    Circle c;
    Square sq;

    s = &c;
    s -> draw();

    s = &sq;
    s -> draw();

    return 0;
}

输出：

Circle::draw() called
Square::draw() called

在这个例子中，Shape作为基类声明了虚函数draw()，然后Circle类和Square类都重写了这个函数并实现自己的逻辑。在main()函数中，我们声明了Shape类型的指针s，并用它依次指向了Circle对象和Square对象，然后通过指针s调用draw()函数。运行结果表明，程序正确地调用了Circle::draw()和Square::draw()函数，这就是多态机制的体现。