2024.5.22

今天上午做的python实验：

（一）、设计高校人员信息包，并完成测试

【题目描述】定义一个人员类People，其属性有：姓名、性别、年龄；基于People实现学生类Student，添加属性：学号、入学时间和入学成绩；基于People实现教师类Teacher，添加属性：职务、部门、工作时间；基于Student实现究生类Graduate，添加属性：研究方向和导师，分别定义其中的构造函数和输出函数。程序中定义各种类的对象，并完成测试。 基于以上类利用接口实现在职研究生类 GradOnWork。

【源代码程序】

class People :

    def __init__(self, name = '贾建超',gender = '男',age=20):

        self.name = name

        self.gender = gender

        self.age = age

    def display(self):

        print("姓名："+self.name+"\n性别："+self.gender+"\n年龄："+str(self.age))

class Student(People):

    def __init__(self,student_id="20223675",into_time="2022-09-01",into_score="100.0"):

        People.__init__(self,name = '贾建超',gender = '男',age=20)

        self.student_id = student_id

        self.into_time = into_time

        self.into_score = into_score

    def display(self):

        print("姓名："+self.name+"\n性别："+self.gender+"\n年龄："+str(self.age)+"\n学号："+self.student_id+"\n入学时间："+self.into_time+"\n入学成绩："+str(self.into_score))

class Teacher(People):

    def __init__(self,post="院长",department="软件工程学院",job_time = "2008-12-03"):

        People.__init__(self, name = '刘立嘉',gender = '男',age=20)

        self.post = post

        self.department = department

        self.job_time = job_time

    def display(self):

        print("姓名："+self.name+"\n性别："+self.gender+"\n年龄："+str(self.age)+"\n职务："+self.post+"\n部门："+self.department+"\n工作时间："+self.job_time)

class Graduate(Student):

    def __init__(self,research_fields="软件工程",teacher = "刘立嘉"):

        Student.__init__(self,student_id="20223675",into_time="2022-09-01",into_score="100.0")

        self.research_fields = research_fields

        self.teacher = teacher

    def display(self):

        print("姓名："+self.name+"\n性别："+self.gender+"\n年龄："+str(self.age)+"\n学号："+self.student_id+"\n入学时间："+self.into_time+"\n入学成绩："+str(self.into_score)+"\n研究方向："+self.research_fields+"\n导师："+self.teacher)

class GradOnWork(Teacher,Graduate):

    def __init__(self):

        Teacher.__init__(self,post="辅导员",department="软件工程学院",job_time = "2008-12-03")

        Graduate.__init__(self,research_fields="软件工程",teacher = "刘立嘉")

    def display(self):

        print("姓名："+self.name+"\n性别："+self.gender+"\n年龄："+str(self.age)+"\n职务："+self.post+"\n部门："+self.department+"\n工作时间："+self.job_time+"\n学号："+self.student_id+"\n入学时间："+self.into_time+"\n入学成绩："+str(self.into_score)+"\n研究方向："+self.research_fields+"\n导师："+self.teacher)

p = People() # 人员类

p.display()

s = Student() # 学生类

s.display()

t = Teacher() # 教师类

t.display()

g = Graduate() # 研究生类

g.display()

gw = GradOnWork() # 在职研究生类

gw.display()

 

【运行测试】

<你的程序运行测试截图>

 

 

（二）、以圆类为基础设计三维图形体系

【题目描述】设计三维图形类体系，要求如下：

设计三维图形功能接口，接口包含周长、面积、体积计算方法；

基于以上接口，首先定义点类，应包含x，y坐标数据成员，坐标获取及设置方法、显示方法等；

以点类为基类派生圆类，增加表示半径的数据成员，半径获取及设置方法，重载显示函数，并可计算周长和面积等；

以圆类为基础派生球类、圆柱类、圆锥类；要求派生类球、圆柱、圆锥中都含有输入和输出显示方法；并可计算面积、周长。

程序中定义各种类的对象，并完成测试。

【源代码程序】

<你的程序源代码，要求完整，要有必要的注释，不能是图片形式。>

import math

class Shape:

    def cal_perimeter(self):

        pass

    def cal_area(self):

        pass

    def cal_volume(self):

        pass

class Point(Shape):

    def __init__(self,x=0,y=0):

        self.x = x

        self.y = y

    def setX(self,x):

        self.x = x

    def setY(self,y):

        self.y = y

    def getX(self):

        return self.x

    def getY(self):

        return self.y

    def display(self):

        print('({}'.format(self.x)+',{})'.format(self.y))

class Circle(Point):

    def __init__(self,r):

        Point.__init__(self,x=0,y=0)

        self.r = r

    def setR(self,r):

        self.r = r

    def getR(self):

        return self.r

    def cal_perimeter(self):

        perimeter=round(2*3.14*self.r,2)

        return perimeter

    def cal_area(self):

        area=round(3.14*self.r**2,2)

        return area

    def display(self):

        print('圆的周长：',self.cal_perimeter())

        print('圆的面积：',self.cal_area())

class Ball(Circle):

    def __init__(self,r=10):

        Circle.__init__(self,r)

    def cal_volume(self):

        perimeter=round((4/3)*3.14*(self.r**3),2)

        return perimeter

    def cal_area(self):

        area=round(3.14*self.r**2*4,2)

        return area

    def display(self):

        print('球的体积：',self.cal_volume())

        print('球的面积：',self.cal_area())

class Circular(Circle):

    def __init__(self,h,r=10):

        Circle.__init__(self,r)

        self.h = h

    def cal_volume(self):

        perimeter=round(3.14*(self.r**2)*self.h,2)

        return perimeter

    def cal_area(self):

        area=round(3.14*2*self.r*self.h+2*3.14*self.r**2,2)

        return area

    def display(self):

        print('圆柱的体积：',self.cal_volume())

        print('圆柱的面积：',self.cal_area())

class CircularCone(Circle):

    def __init__(self,h,r=10):

        Circle.__init__(self,r)

        self.h = h

    def cal_volume(self):

        perimeter=round((1/3)*3.14*(self.r**2)*self.h,2)

        return perimeter

    def cal_area(self):

        area=round(3.14*self.r*(self.r+math.sqrt(self.r**2+self.h**2)),2)

        return area

    def display(self):

        print('圆锥的体积：',self.cal_volume())

        print('圆锥的面积：',self.cal_area())

 

p = Point(10,5)

p.display()

 

c = Circle(10)

c.display()

 

r = float(input("请输入球体半径："))

b = Ball(r)

b.display()

 

r = float(input("请输入圆柱底面半径："))

h = float(input("请输入圆柱的高："))

cc = Circular(r,h)

cc.display()

 

r = float(input("请输入圆锥底面半径："))

h = float(input("请输入圆锥的高："))

cn = CircularCone(r,h)

cn.display()

 

【运行测试】

 

 

（三）、设计并实现计算不同职称的教师工资

【题目描述】设计教师接口，该接口包含教师工资计算方法。应用（一）中的高校人员信息包，设计不同职称的教师类：教授，副教授，讲师，教师的基本信息包括姓名、性别、出生年月、职称、课时工作量等属性。注意学校对教师每月工资的计算规定如下：固定工资+课时补贴；教授的固定工资为5000元，每个课时补贴50元；副教授的固定工资为3000元，每个课时补贴30元;讲师的固定工资为2000元，每个课时补贴20元。

程序中定义各种教师类的对象，并编写程序求这些教师的月工资。

【源代码程序】

class Teacher :

    def __init__(self, name,gender,birth,zhicheng,work):

        self.name = name

        self.gender = gender

        self.birth = birth

        self.zhicheng = zhicheng

        self.work = work

    def income(self):

        if self.zhicheng == "教授":

            return self.work*50+5000

        elif self.zhicheng == "副教授":

            return self.work*30+3000

        elif self.zhicheng == "讲师":

            return self.work*20+2000

    def display(self):

        print( self.name+self.zhicheng+"的工资："+str(Teacher.income(self)))

class Professor(Teacher) :

    def __init__(self):

        Teacher.__init__(self,name = '王建民',gender = '男',birth="1989-12-13",zhicheng="教授",work=5)

class Professor_Fu(Teacher) :

    def __init__(self):

        Teacher.__init__(self, name = '刘立嘉',gender = '男',birth="1990-05-07",zhicheng="副教授",work=5)

class Instructor(Teacher) :

    def __init__(self):

        Teacher.__init__(self, name = '刘丹',gender = '女',birth="1998-02-06",zhicheng="讲师",work=5)

       

p = Professor()

p.display()

pf = Professor_Fu()

pf.display()

i = Instructor()

i.display()

 

【运行测试】

 

（四）、设计异常处理类Cexception，并基于异常处理类设计并实现日期类Date

【题目描述】

【题目描述】

定义一个异常类Cexception解决日期类实现中的自定义异常处理。设计的日期类应包含以下内容：

①  有三个成员数据：年、月、日；

②  有设置日期的成员函数；

③  有用格式"月/日/年"输出日期的成员函数；

④  要求在日期设置及有参构造函数中添加异常处理。

【源代码程序】

class Cexception :

    def __init__(self,year,month,day):

        if Cexception.judge(year,month,day) :

            self.year = year

            self.month = month

            self.day = day

        else:

            self.year = -1

            self.month = -1

            self.day = -1

            print("日期有误")

    def setTime(self,year,month,day):

        if Cexception.judge(year,month,day) :

            self.year = year

            self.month = month

            self.day = day

        else:

            self.year = -1

            self.month = -1

            self.day = -1

            print("日期有误")

    def display(self):

        if self.month ==-1 or  self.year == -1 or self.day == -1:

            print("",end="")

        else:

            print(str(self.month)+"/"+str(self.day)+"/"+str(self.year))

    def judge(year,month,day):

        leap = False

        legal = False

        if year>0:

            if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:

                leap = True

            if month in [1, 3, 5, 7, 8, 10, 12]:

                if 1 <= day <= 31:

                    legal = True

            elif month in [4, 6, 9, 11]:

                if 1 <= day <= 30:

                    legal = True

            elif month == 2:

                if not leap and 1 <= day <= 28:

                    legal = True

                elif leap and 1 <= day <= 29:

                    legal = True

        else:

            legal = False

        return legal

 

c = Cexception(-1,11,2)

c.display()

c = Cexception(2024,5,8)

c.display()

c = Cexception(2024,5,29)

c.display()

c = Cexception(2024,2,28)

c.display()

c = Cexception(2024,13,28)

c.display()

c = Cexception(2024,2,30)

c.display()

【运行测试】

（五）、设计并实现平面点类Point

【题目描述】

定义一个平面点类Point，对其重载运算符关系运算符，关系运算以距离坐标原点的远近作为基准，远的为大。程序完成对其的测试。

【源代码程序】

import math

class Point():

    def __init__(self,x,y):

        self.x = x

        self.y = y

    def __lt__(self, other):

        l1 = math.sqrt(self.x**2+self.y**2)

        l2 = math.sqrt(other.x**2+other.y**2)

        return l1<l2

    def __le__(self, other):

        l1 = math.sqrt(self.x**2+self.y**2)

        l2 = math.sqrt(other.x**2+other.y**2)

        return l1<=l2

    def __gt__(self, other):

        l1 = math.sqrt(self.x**2+self.y**2)

        l2 = math.sqrt(other.x**2+other.y**2)

        return l1>l2

    def __ge__(self, other):

        l1 = math.sqrt(self.x**2+self.y**2)

        l2 = math.sqrt(other.x**2+other.y**2)

        return l1>=l2

    def __eq__(self, other):

        l1 = math.sqrt(self.x**2+self.y**2)

        l2 = math.sqrt(other.x**2+other.y**2)

        return l1==l2

    def __ne__(self, other):

        l1 = math.sqrt(self.x**2+self.y**2)

        l2 = math.sqrt(other.x**2+other.y**2)

        return l1!=l2

 

p1 = Point(1,2)

p2 = Point(3,4)

p3 = Point(2,1)

p=p1<p2

print(p)

p=p1<=p2

print(p)

p=p1>p2

print(p)

p=p1>=p2

print(p)

p=p1==p2

print(p)

p=p1!=p2

print(p)

p=p1==p3

print(p)

 

【运行测试】

 

 

四 实验分析及问题思考

结合实例，比较Python与Java在类的定义、继承、多态等方面的异同，总结Python面向对象程序设计中的原则和注意事项。

【答案】

1.类的定义：

在Python中，定义一个类非常简单，只需使用关键字class即可，而且不需要指定类的访问修饰符。在Java中，类的定义需要指定访问修饰符（public、private、protected等）。

Python示例：

class Person:

    def __init__(self, name, age):

        self.name = name

        self.age = age

    def display_info(self):

        print(f"Name: {self.name}, Age: {self.age}")

Java示例：

public class Person {

    private String name;

    private int age;

    public Person(String name, int age) {

        this.name = name;

        this.age = age;

    }

    public void displayInfo() {

        System.out.println("Name: " + name + ", Age: " + age);

    }

}

2.Python的继承

python和java在继承方面最大的区别就是python子类可以继承多个父类，但是java子类只能继承一个父类，如果一个子类需要多继承的话一般设计成interface接口的方式来实现。比如创造一个child类，类型fathermother。在Python中，father类和mother类可以都设计成child的父类，但在java中可以设计成father父类和mother接口，继承需要extends关键字实现，接口需要implements关键字实现

python实现

class child（father，mother）：

java实现

class child extends father implements mother

3. Python多态

java中的多态跟Python中的多态是有区别的。java中的多态定义：

多态存在的三个必要条件

1、要有继承；

2、要有重写；

3、父类引用指向子类对象。

java多态演示

public class Test {

    public static void main(String[] args) {

      show(new Cat());  // 以 Cat 对象调用 show 方法

      show(new Dog());  // 以 Dog 对象调用 show 方法     

      Animal a = new Cat();  // 向上转型  

      a.eat();               // 调用的是 Cat 的 eat

      Cat c = (Cat)a;        // 向下转型  

      c.work();        // 调用的是 Cat 的 work

  }  

    public static void show(Animal a)  {

      a.eat();  

        // 类型判断

        if (a instanceof Cat)  {  // 猫做的事情

            Cat c = (Cat)a;  

            c.work();  

        } else if (a instanceof Dog) { // 狗做的事情

            Dog c = (Dog)a;  

            c.work();  

        }  

    }  

}

abstract class Animal {  

    abstract void eat();  

}  

class Cat extends Animal {  

    public void eat() {  

        System.out.println("吃鱼");  

    }  

    public void work() {  

        System.out.println("抓老鼠");  

    }  

}  

class Dog extends Animal {  

    public void eat() {  

       System.out.println("吃骨头");  

    }  

    public void work() {  

        System.out.println("看家");  

    }  

}

#执行以上程序，输出结果为：

#吃鱼

#抓老鼠

#吃骨头

#看家

#吃鱼

#抓老鼠

Python多态

类具有继承关系，并且子类类型可以向上转型看做父类类型，如果我们从 Person 派生出 Student和Teacher ，并都写了一个 whoAmI() 方法：

class Person(object):

    def __init__(self, name, gender):

        self.name = name

        self.gender = gender

    def whoAmI(self):

        return 'I am a Person, my name is %s' % self.name

class Student(Person):

    def __init__(self, name, gender, score):

        super(Student, self).__init__(name, gender)

        self.score = score

    def whoAmI(self):

        return 'I am a Student, my name is %s' % self.name

class Teacher(Person):

    def __init__(self, name, gender, course):

        super(Teacher, self).__init__(name, gender)

        self.course = course

    def whoAmI(self):

        return 'I am a Teacher, my name is %s' % self.name

在一个函数中，如果我们接收一个变量 x，则无论该 x 是 Person、Student还是 Teacher，都可以正确打印出结果：

def who_am_i(x):

    print x.whoAmI()

p = Person('Tim', 'Male')

s = Student('Bob', 'Male', 88)

t = Teacher('Alice', 'Female', 'English')

who_am_i(p)

who_am_i(s)

who_am_i(t)

运行结果：

I am a Person, my name is Tim

I am a Student, my name is Bob

I am a Teacher, my name is Alice

这种行为称为多态。也就是说，方法调用将作用在 x 的实际类型上。s 是Student类型，它实际上拥有自己的 whoAmI()方法以及从 Person继承的 whoAmI方法，但调用 s.whoAmI()总是先查找它自身的定义，如果没有定义，则顺着继承链向上查找，直到在某个父类中找到为止。

由于Python是动态语言，所以，传递给函数 who_am_i(x)的参数 x 不一定是 Person 或 Person 的子类型。任何数据类型的实例都可以，只要它有一个whoAmI()的方法即可：

class Book(object):

    def whoAmI(self):

        return 'I am a book'

这是动态语言和静态语言（例如Java）最大的差别之一。动态语言调用实例方法，不检查类型，只要方法存在，参数正确，就可以调用。

总结Python面向对象程序设计中的原则和注意事项：

封装：将数据和方法封装在类中，通过访问修饰符控制数据的访问权限。

继承：通过继承实现代码的复用，避免重复编写相同的代码。

多态：允许不同类的对象对同一方法做出不同的响应，提高代码的灵活性和可扩展性。

遵循命名规范：类名使用驼峰命名法，方法名和变量名使用小写字母和下划线。

代码可读性：遵循PEP8规范，使用适当的缩进和空格，添加适当的注释，使代码易于理解和维护