获取任意时刻的值

电池初始有电100；有两个耗电任务，速率为-2，task1:开始和结束时间为：“2024-02-02 02:00:00.000”,“2024-02-02 02:10:00.000”；
task2:开始和结束时间为：“2024-02-02 02:20:00.000”,“2024-02-02 02:40:00.000”；
有一个充电任务，速率为1，power:开始和结束时间为：“2024-02-02 02:05:00.000”,“2024-02-02 02:25:00.000”；

import pandas as pd
from datetime import datetime, timedelta
import matplotlib.pyplot as plt


def str2time(time_str):
    return datetime.strptime(time_str, "%Y-%m-%d %H:%M:%S.%f")

class Task:
    def __init__(self, ):
        self.task_id = ""
        self.start = ""
        self.end = ""
        self.rate = ""

    def set_task_info(self, task_id, rate, start, end):
        """
        基础信息设置
        @param task_id:
        @param rate:
        @param start:
        @param end:
        @return:
        """
        self.task_id = task_id
        self.start = str2time(start)
        self.end = str2time(end)
        self.rate = rate


class Battery:
    def __init__(self, initial_battery):
        # 初始电量
        # self.battery_level = initial_battery
        self.initial_battery = initial_battery
        self.tasks = ""

    def set_task(self, task_list: list):
        self.tasks = task_list

    def get_battery_level_at_time(self, target_time):
        battery_level = self.initial_battery
        # 遍历每个任务，计算电量变化
        for task_info in self.tasks:
            if task_info.start <= target_time <= task_info.end:
                # 计算在目标时间点上的任务持续时间
                delta = (target_time - task_info.start).total_seconds() / 60.0
                battery_level += task_info.rate * delta
            elif task_info.end < target_time:
                # 计算整个任务持续时间
                delta = (task_info.end - task_info.start).total_seconds() / 60.0
                battery_level += task_info.rate * delta

        return battery_level

    def visualize_battery_levels(self):
        # 创建一个时间范围，步长为1分钟
        start_time = min(task_info.start for task_info in self.tasks)
        end_time = max(task_info.end for task_info in self.tasks) + timedelta(minutes=10)
        times = pd.date_range(start_time, end_time, freq='T')

        # 计算每个时间点的电量
        battery_levels = [self.get_battery_level_at_time(time) for time in times]

        # 可视化电池电量随时间的变化
        plt.figure(figsize=(10, 6))
        plt.plot(times, battery_levels, label="Battery Level")
        plt.axhline(self.initial_battery, color='r', linestyle='--', label="Initial Battery Level")

        # 标记任务的开始和结束时间
        for task_info in self.tasks:
            plt.axvline(task_info.start, color='g', linestyle='--', alpha=0.7)
            plt.axvline(task_info.end, color='b', linestyle='--', alpha=0.7)
            plt.text(task_info.start, self.initial_battery + 10, task["name"], rotation=90, verticalalignment='center')

        plt.xlabel("Time")
        plt.ylabel("Battery Level")
        plt.title("Battery Level Over Time")
        plt.legend()
        plt.grid(True)
        plt.tight_layout()
        plt.show()

    # 测试任意输入时间并获取电量
    def get_battery_level_at_input_time(self):
        input_time_str = input("请输入要查询的时间 (格式: YYYY-MM-DD HH:MM:SS.fff): ")
        input_time = datetime.strptime(input_time_str, "%Y-%m-%d %H:%M:%S.%f")
        battery_level = self.get_battery_level_at_time(input_time)
        print(f"电池在时间 {input_time_str} 的电量为: {battery_level:.2f}")

    def run(self):
        # 可视化电池电量随时间的变化
        self.visualize_battery_levels()
        # 获取用户输入时间的电量


if __name__ == "__main__":
    tasks = [
        {"name": "task1", "rate": -2, "start": "2024-02-02 02:00:00.000", "end": "2024-02-02 02:10:00.000"},
        {"name": "task2", "rate": -2, "start": "2024-02-02 02:20:00.000", "end": "2024-02-02 02:40:00.000"},
        {"name": "power", "rate": 1, "start": "2024-02-02 02:05:00.000", "end": "2024-02-02 02:25:00.000"}
    ]

    task_list = []
    for task in tasks:
        ts = Task()
        ts.set_task_info(task["name"], task["rate"], task["start"], task["end"])
        task_list.append(ts)

    initial_battery = 100
    by = Battery(initial_battery)
    by.set_task(task_list)
    by.run()
    # get_battery_level_at_input_time()

• 代码升级

import pandas as pd
from datetime import datetime, timedelta
import matplotlib.pyplot as plt


def str2time(time_str):
    return datetime.strptime(time_str, "%Y-%m-%d %H:%M:%S.%f")

class Task:
    def __init__(self):
        self.task_id = ""
        self.start = ""
        self.end = ""
        self.rate = 0

    def set_task_info(self, task_id, rate, start, end):
        """
        Set basic task information
        """
        self.task_id = task_id
        self.start = str2time(start)
        self.end = str2time(end)
        self.rate = rate


class Battery:
    def __init__(self, initial_battery):
        self.initial_battery = initial_battery
        self.tasks = []

    def set_task(self, task_list: list):
        self.tasks = task_list

    def get_events(self):
        events = []
        for task in self.tasks:
            events.append((task.start, task.rate))
            events.append((task.end, -task.rate))
        return sorted(events)

    def get_battery_level_at_time(self, target_time):
        events = self.get_events()
        battery_level = self.initial_battery
        current_time = events[0][0]
        current_rate = 0

        for event_time, rate_change in events:
            if event_time > target_time:
                break
            time_diff = (event_time - current_time).total_seconds() / 60.0
            battery_level += current_rate * time_diff
            current_rate += rate_change
            current_time = event_time

        if current_time < target_time:
            time_diff = (target_time - current_time).total_seconds() / 60.0
            battery_level += current_rate * time_diff

        return battery_level

    def visualize_battery_levels(self):
        # Create a time range with a step size of 1 minute
        start_time = min(task.start for task in self.tasks)
        end_time = max(task.end for task in self.tasks) + timedelta(minutes=10)
        times = pd.date_range(start_time, end_time, freq='T')

        # Calculate battery level at each time point
        battery_levels = [self.get_battery_level_at_time(time) for time in times]

        # Visualize battery level changes over time
        plt.figure(figsize=(10, 6))
        plt.plot(times, battery_levels, label="Battery Level")
        plt.axhline(self.initial_battery, color='r', linestyle='--', label="Initial Battery Level")

        # Mark task start and end times
        for task in self.tasks:
            plt.axvline(task.start, color='g', linestyle='--', alpha=0.7)
            plt.axvline(task.end, color='b', linestyle='--', alpha=0.7)
            plt.text(task.start, self.initial_battery + 10, task.task_id, rotation=90, verticalalignment='center')

        plt.xlabel("Time")
        plt.ylabel("Battery Level")
        plt.title("Battery Level Over Time")
        plt.legend()
        plt.grid(True)
        plt.tight_layout()
        plt.show()

    def get_battery_level_at_input_time(self):
        input_time_str = input("请输入要查询的时间 (格式: YYYY-MM-DD HH:MM:SS.fff): ")
        input_time = datetime.strptime(input_time_str, "%Y-%m-%d %H:%M:%S.%f")
        battery_level = self.get_battery_level_at_time(input_time)
        print(f"电池在时间 {input_time_str} 的电量为: {battery_level:.2f}")

    def run(self):
        # Visualize battery level changes over time
        self.visualize_battery_levels()
        # Get battery level at user-input time
        self.get_battery_level_at_input_time()


if __name__ == "__main__":
    tasks = [
        {"name": "task1", "rate": -2, "start": "2024-02-02 02:00:00.000", "end": "2024-02-02 02:10:00.000"},
        {"name": "task2", "rate": -2, "start": "2024-02-02 02:20:00.000", "end": "2024-02-02 02:40:00.000"},
        {"name": "power", "rate": 1, "start": "2024-02-02 02:05:00.000", "end": "2024-02-02 02:25:00.000"}
    ]

    task_list = []
    for task in tasks:
        ts = Task()
        ts.set_task_info(task["name"], task["rate"], task["start"], task["end"])
        task_list.append(ts)

    initial_battery = 100
    by = Battery(initial_battery)
    by.set_task(task_list)
    by.run()