SDUT—Python程序设计实验10&11(面向对象)

7-1 sdut-oop-2 Shift Dot(类和对象）

给出平面直角坐标系中的一点，并顺序给出n个向量，求该点根据给定的n个向量位移后的位置。 设计点类Point，内含：
（1）整型属性x和y，表示点的横坐标和纵坐标； （2）带参构造方法，便于使用初始值构造该类对象；
（3）点移动的方法move(x1,y1)，其 中x1和y1表示移动的向量，该方法返回移动后的新的点对象；
（4）展示点对象的字符串方法toString()，以“(横坐标,纵坐标）”的形式。

输入格式:
多组输入。
第一行是三个整数x，y，n，表示点的坐标（x，y），和向量的个数n。
接下来n行，每行两个数xi，yi，表示第i个向量。
题目中所有数据不会超出整型范围。

输出格式:
对于每组输入，输出一行，形式为：“(x,y)”，表示点的最终点位置的横坐标和纵坐标。

输入样例:

0 0 1
2 3
0 0 2
1 2
2 3
1
2
3
4
5

输出样例:

(2,3)
(3,5)
1
2

代码：

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def move(self, x1, y1):
        self.x += x1
        self.y += y1

    def tostring(self):
        print("(%d,%d)" % (self.x, self.y))

while True:
    try:
        x, y, n = map(int, input().split())
        p = Point(x, y)
        for i in range(n):
            xi, yi = map(int, input().split())
            p.move(xi, yi)
        p.tostring()
    except:
        break
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

7-2 sdut-Time类的定义与使用

设计一个时间类Time。它拥有：
私有数据成员：hour(时)、minute(分)、second(秒)；
公开的成员函数：

setHour(int)设置数据成员hour的值（采用12小时制），非法的输入默认为12；
setMinue(int)设置数据成员minute的值，非法输入默认为0；
setSecond(int)设置数据成员second的值，非法输入默认为0；
setTime(int，int，int)设置时、分、秒三个数据成员的值； showTime()显示时间对象的值。

在主函数main()中调用相应成员函数，使得时间对象的值能从键盘接收，并正确显示。
提示：时、分、秒均按2位数值形式显示 。

输入格式:
输入3个整数，用一个空格间隔。

输出格式:
输出 时、分、秒的值，中间用“:”间隔。

输入样例1:

10 11 12
1

输出样例1:

10:11:12
1

输入样例2:

58 23 85
1

输出样例2:

12:23:00
1

代码：

class Time:
    def __init__(self, h, m, s):
        self.h, self.m, self.s = h, m, s

    def sethour(self, h):
        if h > 12:
            self.h = 12
        else:
            self.h = h

    def setminute(self, m):
        if m > 60:
            self.m = 0
        else:
            self.m = m

    def setsecond(self, s):
        if s > 60:
            self.s = 0
        else:
            self.s = s

    def showtime(self):
        print("%02d:%02d:%02d" % (self.h, self.m, self.s))


hour, minute, second = map(int, input().split())
t = Time(hour, minute, second)
t.sethour(hour)
t.setminute(minute)
t.setsecond(second)
t.showtime()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

7-3 sdut-谁是最强的女汉子

众所周知，一年一度的女汉子大赛又来啦。由于最近女汉子比较流行，所以参加女汉子比赛的人数变得很多很多。所以赛事组找来了你，让你写一个程序找出谁是最强的女汉子。
大家都知道，越是不漂亮的女生就越容易成为女汉子（漂亮的怎么会成为汉子？）,而越是力量大的女生也越成为女汉子（毕竟女汉子还是比较有力量的）。
所以，就给女汉子两个属性，一个是漂亮值x，一个是力量值y。当然x的值越大，就代表这个女生就越漂亮。现在想让你求出来最不漂亮的女生有多少个，她们的力量和是多少。

输入格式:
先输入一个T，代表有T个人（T<10000）。
接下来T行，每行有两个数字x,y，分别代表这个女汉子的漂亮值和力量值（x,y<2*10^9) 。中间有1个空格分隔。

输出格式:
输出一行，有两个数字，分别代表最强的女汉子的数量，和她们的力量和。中间用1个空格分隔。

输入样例:

5
1 1
2 2
1 4
2 10
10 100
1
2
3
4
5
6

输出样例:

2 5
1

代码：

class Girl:
    def __init__(self, x, y):
        self.x, self.y = x, y

ls = []
n = int(input())
for i in range(n):
    x, y = map(int, input().split())
    ls.append(Girl(x, y))
ls = sorted(ls, key=lambda it: it.x)
cnt, sum = 0, 0
for it in ls:
    if it.x == ls[0].x:
        cnt += 1
        sum += it.y
print(cnt, sum)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

7-4 sdut-oop-5 计算长方体和四棱锥的表面积和体积（类的继承）

计算如下立体图形的表面积和体积。

从图中观察，可抽取长方体和四棱锥两种立体图形的共同属性到父类Rect中：长度：l 宽度：h 高度：z。
编程要求：
（1）在父类Rect中，定义求底面周长的方法length( )和底面积的方法area( )。
（2）定义父类Rect的子类立方体类Cubic，计算立方体的表面积和体积。其中表面积area( )重写父类的方法。
（3）定义父类Rect的子类四棱锥类Pyramid，计算四棱锥的表面积和体积。其中表面积area( )重写父类的方法。
（4）在主程序中，输入立体图形的长(l)、宽(h)、高(z)数据，分别输出长方体的表面积、体积、四棱锥的表面积和体积。
提示：
（1）四棱锥体积公式：V= 1/3*Sh，S——底面积 h——高
（2）在Java中，利用Math.sqrt(a)方法可以求得a的平方根（方法的参数及返回结果均为double数据类型）
（3）在Python中，利用math模块的sqrt(a)方法，求得a的平方根。
输入格式:
输入多行数值型数据（double）；

每行三个数值，分别表示l、h、z，数值之间用空格分隔。

若输入数据中有0或负数，则不表示任何图形，表面积和体积均为0。

输出格式:
行数与输入相对应，数值为长方体表面积 长方体体积 四棱锥表面积 四棱锥体积（中间有一个空格作为间隔，数值保留两位小数）。

输入样例:

1 2 3
0 2 3
-1 2 3
3 4 5
1
2
3
4

输出样例:

22.00 6.00 11.25 2.00
0.00 0.00 0.00 0.00
0.00 0.00 0.00 0.00
94.00 60.00 49.04 20.00
1
2
3
4

代码：

from math import *

class Rect:
    def __init__(self, l, h, z):
        if l <= 0 or h <= 0 or z <= 0:
            self.l, self.h, self.z = 0, 0, 0
        else:
            self.l, self.h, self.z = l, h, z

    def length(self):
        return (self.l + self.h) * 2.0
        
    def area(self):
        pass

class Cubic(Rect):
    def __init__(self, l, h, z):
        super().__init__(l, h, z)

    def area_1(self):
        return 2.0 * (self.l * self.h + self.l * self.z + self.h * self.z)

    def volume_1(self):
        return self.l * self.h * self.z

class Pyramid(Rect):
    def __init__(self, l, h, z):
        super().__init__(l, h, z)

    def area_2(self):
        return self.l * self.h + (self.h * sqrt((self.l / 2) * (self.l / 2) + self.z ** 2)) + (
                self.l * sqrt((self.h / 2) * (self.h / 2) + self.z ** 2))

    def volume_2(self):
        return self.l * self.h * self.z / 3.0


while True:
    try:
        l, h, z = map(float, input().split())
        c = Cubic(l, h, z)
        p = Pyramid(l, h, z)
        print("%.2f %.2f %.2f %.2f" % (c.area_1(), c.volume_1(), p.area_2(), p.volume_2()))
    except:
        break
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

7-5 sdut-oop-6 计算各种图形的周长（多态）

定义接口或类 Shape，定义求周长的方法length()。
定义如下类，实现接口Shape或父类Shape的方法。
（1）三角形类Triangle （2）长方形类Rectangle （3）圆形类Circle等。
定义测试类ShapeTest，用Shape接口（或类）定义变量shape，用其指向不同类形的对象，输出各种图形的周长。并为其他的Shape接口实现类提供良好的扩展性。
提示： 计算圆周长时PI取3.14。

输入格式:
输入多组数值型数据（double）；
一行中若有1个数，表示圆的半径；
一行中若有2个数（中间用空格间隔），表示长方形的长度、宽度。
一行中若有3个数（中间用空格间隔），表示三角形的三边的长度。（需要判断三个边长是否能构成三角形）
若输入数据中有0或负数，则不表示任何图形，周长为0。

输出格式:
行数与输入相对应，数值为根据每行输入数据求得的图形的周长。

输入样例:
在这里给出一组输入。例如：

1
2 3
4 5 6
2
-2
-2 -3
1
2
3
4
5
6

输出样例:
在这里给出相应的输出。例如：

6.28
10.00
15.00
12.56
0.00
0.00
1
2
3
4
5
6

代码：

class Shape:
    def length(self):
        pass

class Triangle(Shape):
    def __init__(self, a, b, c):
        if a <= 0 or b <= 0 or c <= 0 or (not (a + b > c and a + c > b and b + c > a)):
            self.a, self.b, self.c = 0.0, 0.0, 0.0
        else:
            self.a, self.b, self.c = a, b, c

    def length(self):
        return self.a + self.b + self.c

class Rectangle(Shape):
    def __init__(self, a, b):
        if a <= 0 or b <= a:
            self.a, self.b = 0.0, 0.0
        else:
            self.a, self.b = a, b

    def length(self):
        return 2.0 * (self.a + self.b)

class Circle(Shape):
    def __init__(self, r):
        if r <= 0:
            self.r = 0.0
        else:
            self.r = r

    def length(self):
        return 2 * 3.14 * self.r

while True:
    try:
        ls = list(map(float, input().split()))
        if len(ls) == 1:
            c = Circle(ls[0])
            print("%.2f" % c.length())
        elif len(ls) == 2:
            r = Rectangle(ls[0], ls[1])
            print("%.2f" % r.length())
        elif len(ls) == 3:
            t = Triangle(ls[0], ls[1], ls[2])
            print("%.2f" % t.length())
    except EOFError:
        break
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

7-6 sdut-oop-9 计算长方形的周长和面积（类和对象）

设计一个长方形类Rect，计算长方形的周长与面积。
成员变量：整型、私有的数据成员length(长)、width(宽)
构造方法如下：

（1）Rect(int length) —— 1个整数表示正方形的边长
（2）Rect(int length, int width)——2个整数分别表示长方形长和宽
1
2

成员方法：包含求面积和周长。（可适当添加其他方法）
要求：编写主函数，对Rect类进行测试，输出每个长方形的长、宽、周长和面积。

输入格式:
输入多组数据；
一行中若有1个整数，表示正方形的边长；
一行中若有2个整数（中间用空格间隔），表示长方形的长度、宽度。
若输入数据中有负数，则不表示任何图形，长、宽均为0。

输出格式:
每行测试数据对应一行输出，格式为：
长度 宽度 周长 面积（数据之间有1个空格分隔）

输入样例:
在这里给出一组输入。例如：

1
2 3
4 5
2
-2
-2 -3
1
2
3
4
5
6

输出样例:
在这里给出相应的输出。例如：

1 1 4 1
2 3 10 6
4 5 18 20
2 2 8 4
0 0 0 0
0 0 0 0
1
2
3
4
5
6

代码：

class Rect:
    def __init__(self, l, w):
        if l <= 0 or w <= 0:
            self.l, self.w = 0, 0
        else:
            self.l, self.w = l, w

    def area_1(self):
        return self.l * 4

    def area_2(self):
        return 2 * (self.l + self.w)

    def length_1(self):
        return self.l ** 2

    def length_2(self):
        return self.l * self.w

while True:
    try:
        ls = list(map(int, input().split()))
        if len(ls) == 1:
            r = Rect(ls[0], 1)
            print(r.l, r.l, r.area_1(), r.length_1())
        elif len(ls) == 2:
            r = Rect(ls[0], ls[1])
            print(r.l, r.w, r.area_2(), r.length_2())
    except EOFError:
        break
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

7-7 sdut-oop-7 答答租车系统（类的继承与多态 面向对象综合练习）

各位面向对象的小伙伴们，在学习了面向对象的核心概念——类的封装、继承、多态之后，答答租车系统开始营运了。
请你充分利用面向对象思想，为公司解决智能租车问题，根据客户选定的车型和租车天数，来计算租车费用，最大载客人数，最大载载重量。
公司现有三种车型（客车、皮卡车、货车），每种车都有名称和租金的属性；其中：客车只能载人，货车只能载货，皮卡车是客货两用车，即可以载人，也可以载货。
下面是答答租车公司的可用车型、容量及价目表：

要求：根据客户输入的所租车型的序号及天数，计算所能乘载的总人数、货物总数量及租车费用总金额。

输入格式:
首行是一个整数：代表要不要租车 1——要租车（程序继续），0——不租车（程序结束）；
第二行是一个整数，代表要租车的数量N；
接下来是N行数据，每行2个整数m和n，其中：m表示要租车的编号，n表示租用该车型的天数。

输出格式:
若成功租车，则输出一行数据，数据间有一个空格，含义为：
载客总人数 载货总重量（保留2位小数） 租车金额（整数）
若不租车，则输出：
0 0.00 0（含义同上）

输入样例:

1
2
1 1
2 2
1
2
3
4

输出样例:
在这里给出相应的输出。例如：

15 0.00 1600
1

代码：

class Car:
    def __init__(self, n, p, t, m):
        self.n, self.p, self.t, self.m = n, p, t, m

car = dict()
car[1] = Car("A", 5, 0, 800)
car[2] = Car("B", 5, 0, 400)
car[3] = Car("C", 5, 0, 800)
car[4] = Car("D", 51, 0, 1300)
car[5] = Car("E", 55, 0, 1500)
car[6] = Car("F", 5, 0.45, 500)
car[7] = Car("G", 5, 2.0, 450)
car[8] = Car("H", 0, 3, 200)
car[9] = Car("I", 0, 25, 1500)
car[10] = Car("J", 0, 35, 2000)

opt = int(input())
if opt == 1:
    N = int(input())
    sum_p, sum_t, sum_m = 0, 0.0, 0
    for i in range(N):
        m, n = map(int, input().split())
        sum_p += car[m].p * n
        sum_t += car[m].t * n * 1.0
        sum_m += car[m].m * n
    print("%d %.2f %d" % (sum_p, sum_t, sum_m))
elif opt == 0:
    print("0 0.00 0")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

9-1 求文件行数

下载题目附件，编辑src/目录下的test.py文件，实现读取统计data.txt文件的有效行数，
并将结果输出保存到result.txt文件。(20分)

说明

（1）有效行指至少包括一个字符行，空行不计为有效行
（2）程序文件名 test.py 不能修改
（3）本地编写测试完成后，将src文件夹打包为 src.zip文件后上传提交
1
2
3

data.txt的内容如下:

python程序设计

人生苦短，我学python
程序设计

抽象过程
自动化求解的计算思维
结合问题思考程序结构
1
2
3
4
5
6
7
8

输出结果如下：结果写入到result.txt中

有效行数为:6行
1

步骤：下载压缩包后解压并用Pycharm或其它IDE打开文件，将下面代码复制进test.py文件，再将文件压缩并提交即可，注意提交的压缩包包含src和main.sh，不能仅压缩src提交
代码：

cnt = len([line for line in open("data.txt", 'r', encoding='utf-8').readlines() if line != '\n'])
s = "有效行数为:" + str(cnt) + '行'
with open("result.txt", 'w', encoding='utf-8') as f:  # 这样写自带文件关闭功能
    f.write(s)
1
2
3
4

212丨acc丨2022.12.03