实验9 Python面向对象编程

实验目的

1. 理解Python面向对象编程的概念：类，对象，继承，多态
2. 掌握Python面向对象编程的方法
3. 掌握使用面向对象的方法求解问题

实验内容

1. 设计时间Time类

设计一个名为Time的类。该类包括：

1. 表示时间的属性hour, minute, second。
2. 构造方法__init__()，使用当前时间初始化hour, minute, second来构造一个Time对象。
3. 属性hour, minute, second各自的get方法。
4. set_time(elapse_time)方法，使用流逝的秒数为对象设置一个新时间。例如，如果流逝的秒数是555550秒，则hour是10，minute是19，second是12。

编写程序，实现这个Time类，创建一个Time对象，显示它的小时、分钟和秒数，然后，再提示用户输入流逝的时间，将它设置到Time对象中，显示设置后的小时、分钟和秒数。

[提示]

当前的流逝时间可以使用time.time()获取

[运行示例]

当前时间是：12:41:12

输入流逝的时间：55550505

该流逝时间的小时:分钟:秒是：22:41:45

# 1.	设计时间Time类
# 设计一个名为Time的类。该类包括：
# (1)	表示时间的属性hour, minute, second。
# (2)	构造方法__init__()，使用当前时间初始化hour, minute, second来构造一个Time对象。
# (3)	属性hour, minute, second各自的get方法。
# (4)	set_time(elapse_time)方法，使用流逝的秒数为对象设置一个新时间。例如，如果流逝的秒数是555550秒，则hour是10，minute是19，second是12。
# 编写程序，实现这个Time类，创建一个Time对象，显示它的小时、分钟和秒数，然后，再提示用户输入流逝的时间，将它设置到Time对象中，显示设置后的小时、分钟和秒数。
# [提示]
# 当前的流逝时间可以使用time.time()获取
# [运行示例]
# 当前时间是：12:41:12
# 输入流逝的时间：55550505
# 该流逝时间的小时:分钟:秒是：22:41:45

class Time:
    hour = None
    minute = None
    second = None

    def __init__(self, hour, minute, second):
        self.hour = hour
        self.minute = minute
        self.second = second

    def get_hour(self):
        return self.hour

    def get_minute(self):
        return self.minute

    def get_second(self):
        return self.second

    def set_time(self, elapse_time):
        elapse_hour = elapse_time // 3600
        elapse_minute = elapse_time % 3600 // 60
        elapse_second = elapse_time % 60

        self.hour += elapse_hour
        self.minute += elapse_minute
        if self.minute >= 60:
            self.hour += 1
            self.minute -= 60

        self.second += elapse_second
        if self.second >= 60:
            self.minute += 1
            self.second -= 60


def main():
    hour, minute, second = map(int, input("当前时间是：").split(":"))
    t = Time(hour, minute, second)

    elapse_time = int(input("输入流逝的时间："))
    t.set_time(elapse_time)
    print("该流逝时间的小时:分钟:秒是：{}:{}:{}".format(t.hour, t.minute, t.second))
    # print(t.hour, t.minute, t.second)


if __name__ == '__main__':
    main()

2. 设计秒表StopWatch类

设计一个名为StopWatch的类。该类包括：

1. 具有get方法的属性start_time和end_time
2. 构造方法__init__()，使用当前时间初始化start_time属性来构造一个StopWatch对象
3. start()方法，将start_time重置为当前时间
4. stop()方法，将end_time设置为当前时间
5. get_elapsed_time()方法，返回秒表流逝的毫秒数

编写程序，实现这个类，然后使用该类测量将数值从1增加到1000000的执行时间

# 2.	设计秒表StopWatch类
# 设计一个名为StopWatch的类。该类包括：
# (1)	具有get方法的属性start_time和end_time
# (2)	构造方法__init__()，使用当前时间初始化start_time属性来构造一个StopWatch对象
# (3)	start()方法，将start_time重置为当前时间
# (4)	stop()方法，将end_time设置为当前时间
# (5)	get_elapsed_time()方法，返回秒表流逝的毫秒数
# 编写程序，实现这个类，然后使用该类测量将数值从1增加到1000000的执行时间

import time


class StopWatch:
    start_time = None
    end_time = None

    def get_start_time(self, start_time):
        self.start_time = start_time

    def get_end_time(self, end_time):
        self.end_time = end_time

    def __init__(self, start_time, end_time):
        self.start_time = start_time
        self.end_time = end_time

    def start(self):
        self.start_time = time.time()

    def stop(self):
        self.end_time = time.time()

    def get_elapsed_time(self):
        return self.end_time - self.start_time


def main():
    s = StopWatch(1, 1000000)
    print(s.get_elapsed_time())


main()

3. 使用继承实现Stack类

使用继承扩展list创建一个Stack类。编写程序，实现这个类，提示用户输入5个字符串，然后使用这个Stack类以逆序显示这些字符串。

# 3.	使用继承实现Stack类
# 使用继承扩展list创建一个Stack类。编写程序，实现这个类，提示用户输入5个字符串，然后使用这个Stack类以逆序显示这些字符串。


class Stack(list):
    def push(self, item):
        self.append(item)

    def is_empty(self):
        return len(self) == 0


def main():
    my_stack = Stack()
    for i in range(5):
        user_input = input("请输入一个字符串：")
        my_stack.push(user_input)

    print("逆序显示的字符串：")
    while not my_stack.is_empty():
        print(my_stack.pop())


main()