实验六 Python面向对象的程序设计

1. 设计一个圆类,包括圆心位置、半径、颜色等属性。编写构造方法, 计算周长和面积。

import math

class Circle:
    def __init__(self, o, r, colour):
        self.o = o
        self.r = r
        self.colour = colour

    def length(self):  # 周长
        C = math.pi * self.r * 2
        return C

    def area(self):  # 面积
        S = math.pi * self.r ** 2
        return S

if __name__ == "__main__":
    r = eval(input("请输入半径："))
    circle = Circle((0, 0), r, 'blue')  # 坐标、半径、颜色
    C = circle.length()
    S = circle.area()
    print(f'圆周长为：{C:.2f}')
    print(f'圆面积为：{S:.2f}')

2. 设计一个描述自由落体运动的类，要求能获得任意时刻的速度及位移，并进行测试。已知重力加速度为 9.8m/s。

class Free:
    def __init__(self, t):
        self.t = t

    def getv(self):  # 速度函数
        v = 9.8 * self.t
        return v

    def getx(self):  # 位移函数
        x = 0.5 * 9.8 * self.t ** 2
        return x

if __name__ == "__main__":
    t = eval(input("请输入时刻t："))
    f = Free(t)  # 调用
    print(f"t={t} 时刻的速度为:{f.getv():.2f}")
    print(f"t={t} 时刻的位移为:{f.getx():.2f}")

3. 为二次方程式 ax²+bx+c=0 设计一个名为 Equation 的类，这个类包括:

• 代表 3 个系数的成员变量 a、b、c;
• 一个参数为 a、b、c 的构造方法;
• 一个名为 getDiscriminant1 的方法返回判别式的值;
• 一个名为 getRoot1 和 getRoot2 的方法返回等式的两个根, 如果判别式为负,这些方法返回0。

import math

class Equation:
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c

    def getDiscriminant1(self):  # 判别式
        d = (self.b) ** 2 - (4 * self.a * self.c)
        return d

    def getRoot1(self):
        if self.getDiscriminant1() >= 0:
            x1 = (-self.b + math.sqrt(self.getDiscriminant1())) / 2 * self.a
            return x1
        else:
            return 0

    def getRoot2(self):
        if self.getDiscriminant1() >= 0:
            x2 = (-self.b + math.sqrt(self.getDiscriminant1())) / 2 * self.a
            return x2
        else:
            return 0

if __name__ == "__main__":
    a = eval(input("请输入系数a："))
    b = eval(input("请输入系数b："))
    c = eval(input("请输入系数c："))
    f = Equation(a, b, c)
    print("判别式：", f.getDiscriminant1())
    print("根1：", f.getRoot1())
    print("根2：", f.getRoot2())

4. 设计一个二维向量类，实现向量的加法、减法及向量与标量的乘法和除法运算，其中要求输入是元组。

class Vector:
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def jia(self):
        c1 = (self.a[0] + self.b[0])
        c2 = (self.a[1] + self.b[1])
        return (c1, c2)

    def jian(self):
        c1 = (self.a[0] - self.b[0])
        c2 = (self.a[1] - self.b[1])
        return (c1, c2)

    def diancheng(self):
        c1 = (self.a[0] * self.b[0])
        c2 = (self.a[1] * self.b[1])
        return c1 + c2
    # 向量无除法

if __name__ == "__main__":
    a = eval(input("请输入向量a："))
    b = eval(input("请输入向量b："))
    f = Vector(a, b)
    print("  加：", f.jia())
    print("  减：", f.jian())
    print("点乘：", f.diancheng())

5. （选做）设计一个课程类,包括课程编号、课程名称、任课教师、上课地点 等属性,把上课地点变量设为私有的,增加构造方法和显示课程信息的方法。

class Course:
    def __init__(self, Cno, Cname, teacher, local):
        self.Cno = Cno
        self.Cname = Cname
        self.teacher = teacher
        self.__local = local  # 把上课地点变量设为私有的

    def information(self):
        print("课程编号:", self.Cno)
        print("课程名称:", self.Cname)
        print("任课教师:", self.teacher)
        print("上课地点:", self.__local)

if __name__ == "__main__":
    f = Course('NO.', 'what', 'who', 'where')
    f.information()

6. 设计一个整形数组的封装类,要求实现下列功能:

• 显示全部数组数据
• 显示从某位置开始的一段连续数组数据。（选做）

import random

class List:
    def __init__(self, lis):
        self.__lis = lis

    def quanbu(self):  # 全部数组数据
        return self.__lis

    def bufen(self, id):  # 从部分位置开始的一段连续数组数据
        return self.__lis[id:]

f = List([random.randint(1, 51) for i in range(20)])  # 设置数组为20个1-50的随机数组合
print("显示全部数组数据:", f.quanbu())
random_index = random.randint(0, 20)  # 随机选取从某一位置开始的索引号
print(f"显示从<第{random_index}>位置开始的一段连续数组数据:{f.bufen(random_index)}")