开发前端软件素材源码教程下载网站

全部
网站模板
网页特效
网站源码
素材资源
建站学院
软件工具
mysql mysql 微信 微信 小程序 苹果 dedecms 修真图
当前位置：首页 > 建站学院 > 其他教程 >  Python如何实现关键路径和七格图计算

Python如何实现关键路径和七格图计算

其他教程   发布日期：2023年08月30日   浏览次数：420次

本篇内容介绍了“Python如何实现关键路径和七格图计算”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

1.主程序

主程序主要实现了一个Project类，其中包含了计算关键路径和七格图的方法。具体实现方式如下：

1. 定义了一个Activity类，包含了活动的id、名称、持续时间和紧前任务列表等属性。

2. 定义了一个Project类，包含了活动列表、项目持续时间、日志等属性，以及计算关键路径、计算七格图、计算总浮动时间、计算自由浮动时间等方法。

3. 从JSON文件中读取活动信息，并创建Project对象并添加活动。

4. 调用Project对象的calculate方法，计算每个活动的最早开始时间、最晚开始时间等数据。

5. 调用Project对象的calculate_critical_path方法，计算关键路径。

6. 调用Project对象的calculate_project_duration方法，计算项目总工期。

7. 使用Jinja2模板引擎生成项目的活动清单，并将关键路径

  1. import json  
  2. from datetime import datetime  
  3. from typing import List  
  4.   
  5. import graphviz  
  6. from jinja2 import Template  
  7.   
  8. from activity import Activity  
  9.   
  10.   
  11. class Project:  
  12.     def __init__(self):  
  13.         self.activities: List[Activity] = []  
  14.         self.duration = 0  
  15.         self.logger = []  
  16.   
  17.     def log(self, log: str) -> None:  
  18.         self.logger.append(log)  
  19.   
  20.     def add_activity(self, activity: Activity) -> None:  
  21.         """  
  22.         添加一个活动到项目中  
  23.         :param  
  24.         activity: 待添加的活动  
  25.         """        # 将活动添加到项目中  
  26.         self.activities.append(activity)  
  27.   
  28.     def calculate(self) -> None:  
  29.         """ 计算整个项目的关键信息  
  30.         :return: None  
  31.         """        self.calculate_successor()  
  32.         self._calculate_forward_pass()  # 计算正推法  
  33.         self._calculate_backward_pass()  # 计算倒推法  
  34.         self._calculate_total_floats()  # 计算总浮动时间  
  35.         self._calculate_free_floats()  # 计算自由浮动时间  
  36.   
  37.     def calculate_successor(self) -> None:  
  38.         self.log("开始计算紧后活动")  
  39.         for act in self.activities:  
  40.             for pred in act.predecessors:  
  41.                 for act_inner in self.activities:  
  42.                     if act_inner.id == pred:  
  43.                         act_inner.successors.append(act.id)  
  44.   
  45.     def _calculate_forward_pass(self) -> None:  
  46.         self.log("## 开始正推法计算")  
  47.         # 进入 while 循环，只有当所有活动的最早开始时间和最早完成时间都已经计算出来时，才会退出循环  
  48.         while not self._is_forward_pass_calculated():  
  49.             # 遍历每个活动  
  50.             for activity in self.activities:  
  51.                 # 如果活动的最早开始时间已经被计算过，则跳过  
  52.                 if activity.est is not None:  
  53.                     continue  
  54.                 # 如果活动没有前置活动， 则从1开始计算最早开始时间和最早结束时间  
  55.                 if not activity.predecessors:  
  56.                     activity.est = 1  
  57.                     activity.eft = activity.est + activity.duration - 1  
  58.                     self.log(  
  59.                         f"活动 {activity.name} 没有紧前活动，设定最早开始时间为1， 并根据工期计算最早结束时间为{activity.eft}")  
  60.                 else:  
  61.                     # 计算当前活动的所有前置活动的最早完成时间  
  62.                     predecessors_eft = [act.eft for act in self.activities if  
  63.                                         act.id in activity.predecessors and act.eft is not None]  
  64.                     # 如果当前活动的所有前置活动的最早完成时间都已经计算出来，则计算当前活动的最早开始时间和最早完成时间  
  65.                     if len(predecessors_eft) == len(activity.predecessors):  
  66.                         activity.est = max(predecessors_eft) + 1  
  67.                         activity.eft = activity.est + activity.duration - 1  
  68.                         self.log(  
  69.                             f"活动 {activity.name} 紧前活动已完成正推法计算， 开始日期按最早开始时间里面最大的," +  
  70.                             f"设定为{activity.est}并根据工期计算最早结束时间为{activity.eft}")  
  71.   
  72.                         # 更新项目总持续时间为最大最早完成时间  
  73.         self.duration = max([act.eft for act in self.activities])  
  74.   
  75.     def _calculate_backward_pass(self) -> None:  
  76.         """ 计算倒推法  
  77.         :return: None  
  78.         """  
  79.         self.log("## 开始倒推法计算")  # 输出提示信息  
  80.         # 进入 while 循环，只有当所有活动的最晚开始时间和最晚完成时间都已经计算出来时，才会退出循环  
  81.         while not self._is_backward_pass_calculated():  
  82.             # 遍历每个活动  
  83.             for act in reversed(self.activities):  
  84.                 # 如果活动的最晚开始时间已经被计算过，则跳过  
  85.                 if act.lft is not None:  
  86.                     continue  
  87.                 # 如果活动没有后继活动， 则从总持续时间开始计算最晚开始时间和最晚结束时间  
  88.                 if not act.successors:  
  89.                     act.lft = self.duration  
  90.                     act.lst = act.lft - act.duration + 1  
  91.                     self.log(f"活动 {act.name} 没有紧后活动，按照正推工期设定最晚结束时间为{act.lft}," +  
  92.                              f"并根据工期计算最晚开始时间为{act.lst}")  
  93.                 else:  
  94.                     # 计算当前活动的所有后继活动的最晚开始时间  
  95.                     successors_lst = self._calculate_lst(act)  
  96.                     # 如果当前活动的所有后继活动的最晚开始时间都已经计算出来，则计算当前活动的最晚开始时间和最晚完成时间  
  97.                     if len(successors_lst) == len(act.successors):  
  98.                         act.lft = min(successors_lst) - 1  
  99.                         act.lst = act.lft - act.duration + 1  
  100.                         self.log(f"活动 {act.name} 紧后活动计算完成，按照倒推工期设定最晚结束时间为{act.lft}," +  
  101.                                  f"并根据工期计算最晚开始时间为{act.lst}")  
  102.         # 更新项目总持续时间为最大最晚完成时间  
  103.         self.duration = max([act.lft for act in self.activities])  
  104.   
  105.     def _calculate_lst(self, activity: Activity) -> List[int]:  
  106.         """计算某一活动的所有最晚开始时间  
  107.         :param activity: 活动对象  
  108.         :return: 最晚开始时间列表  
  109.         """        rst = []  # 初始化结果列表  
  110.         for act in activity.successors:  # 遍历该活动的后继活动  
  111.             for act2 in self.activities:  # 遍历所有活动  
  112.                 if act2.id == act and act2.lst is not None:  # 如果找到了该后继活动且其最晚开始时间不为空  
  113.                     rst.append(act2.lst)  # 将最晚开始时间加入结果列表  
  114.         return rst  # 返回结果列表  
  115.   
  116.     def _is_forward_pass_calculated(self) -> bool:  
  117.         """ 判断整个项目正推法计算已经完成  
  118.         :return: 若已计算正向传递则返回True，否则返回False  
  119.         """  
  120.         for act in self.activities:  # 遍历所有活动  
  121.             if act.est is None or act.eft is None:  # 如果该活动的最早开始时间或最早完成时间为空  
  122.                 return False  # 则返回False，表示还未计算正向传递  
  123.         return True  # 如果所有活动的最早开始时间和最早完成时间都已计算，则返回True，表示已计算正向传递  
  124.   
  125.     def _is_backward_pass_calculated(self) -> bool:  
  126.         """ 判断整个项目倒推法计算已经完成  
  127.         :return: 若已计算倒推法则返回True，否则返回False  
  128.         """        for act in self.activities:  # 遍历所有活动  
  129.             if act.lst is None or act.lft is None:  # 如果该活动的最晚开始时间或最晚完成时间为空  
  130.                 return False  # 则返回False，表示还未计算倒推法  
  131.         return True  # 如果所有活动的最晚开始时间和最晚完成时间都已计算，则返回True，表示已计算倒推法  
  132.   
  133.     def _calculate_total_floats(self) -> None:  
  134.         """ 计算所有活动的总浮动时间  
  135.         :return: None  
  136.          """  
  137.         self.log(f"## 开始计算项目所有活动的总浮动时间")  
  138.         for act in self.activities:  # 遍历所有活动  
  139.             if act.est is not None and act.lst is not None:  # 如果该活动的最早开始时间和最晚开始时间都已计算  
  140.                 act.tf = act.lst - act.est  # 则计算该活动的总浮动时间  
  141.                 self.log(f"计算{act.name}的总浮动时间" + f"最晚开始时间{act.lst} - 最早开始时间{act.est} = {act.tf}", )  
  142.             else:  # 如果该活动的最早开始时间或最晚开始时间为空  
  143.                 act.tf = None  # 则将该活动的总浮动时间设为None  
  144.   
  145.     def _calculate_free_floats(self) -> None:  
  146.         """ 计算所有活动的自由浮动时间  
  147.         :return: None  
  148.         """        self.log(f"## 开始计算项目所有活动的自由浮动时间")  # 输出提示信息  
  149.         for act in self.activities:  # 遍历所有活动  
  150.             if act.tf == 0:  # 如果该活动的总浮动时间为0  
  151.                 self.log(f"计算{act.name}的自由浮动时间" + f"因为{act.name}的总浮动时间为0，自由浮动时间为0")  # 输出提示信息  
  152.                 act.ff = 0  # 则将该活动的自由浮动时间设为0  
  153.             elif act.tf > 0:  # 如果该活动的总浮动时间大于0  
  154.                 self.log(f"计算{act.name}的自由浮动时间")  # 输出提示信息  
  155.                 self.log(f"- {act.name}的总浮动时间{act.tf} > 0,")  # 输出提示信息  
  156.                 tmp = []  # 初始化临时列表  
  157.                 for act2 in self.activities:  # 遍历所有活动  
  158.                     if act2.id in act.successors:  # 如果该活动是该活动的紧后活动  
  159.                         self.log(f"- {act.name}的紧后活动{act2.name}的自由浮动动时间为{act2.tf}")  # 输出提示信息  
  160.                         tmp.append(act2.tf)  # 将该紧后活动的自由浮动时间加入临时列表  
  161.                 if len(tmp) != 0:  # 如果临时列表不为空  
  162.                     act.ff = act.tf - max(tmp)  # 则计算该活动的自由浮动时间  
  163.                     if act.ff < 0:  
  164.                         act.ff = 0  
  165.                     self.log(f"- 用活动自己的总浮动{act.tf}减去多个紧后活动总浮动的最大值{max(tmp)} = {act.ff}")  
  166.                 else:  # 如果临时列表为空  
  167.                     act.ff = act.tf  # 则将该活动的自由浮动时间设为总浮动时间  
  168.   
  169.     def calculate_critical_path(self) -> List[Activity]:  
  170.         """ 计算整个项目的关键路径  
  171.         :return: 整个项目的关键路径  
  172.         """        ctc_path = []  # 初始化关键路径列表  
  173.         for act in self.activities:  # 遍历所有活动  
  174.             if act.tf == 0:  # 如果该活动的总浮动时间为0  
  175.                 ctc_path.append(act)  # 则将该活动加入关键路径列表  
  176.         return ctc_path  # 返回关键路径列表  
  177.   
  178.     def calculate_project_duration(self) -> int:  
  179.         """ 计算整个项目的持续时间  
  180.         :return: 整个项目的持续时间  
  181.         """        return max(activity.eft for activity in self.activities)  # 返回所有活动的最早完成时间中的最大值，即整个项目的持续时间  
  182.   
  183.   
  184. # 从JSON文件中读取活动信息  
  185. with open('activities.json', 'r', encoding='utf-8') as f:  
  186.     activities_data = json.load(f)  
  187.   
  188. # 创建Project对象并添加活动  
  189. project = Project()  
  190. for activity_data in activities_data:  
  191.     activity = Activity(  
  192.         activity_data['id'],  
  193.         activity_data['name'],  
  194.         activity_data['duration'],  
  195.         activity_data['predecessors']  
  196.     )    project.add_activity(activity)  
  197.   
  198. # 计算每个活动的最早开始时间、最晚开始时间等数据  
  199. project.calculate()  
  200.   
  201. # 计算关键路径和项目总工期  
  202. critical_path = project.calculate_critical_path()  
  203. project_duration = project.calculate_project_duration()  
  204.   
  205. # 生成项目的活动清单  
  206. with open('template.html', 'r', encoding='utf-8') as f:  
  207.     template = Template(f.read())  
  208. html = template.render(  
  209.     activities=project.activities,  
  210.     critical_path=critical_path,  
  211.     project_duration=project_duration,  
  212.     log=project.logger  
  213. )  
  214.   
  215. # 生成项目进度网络图  
  216. aon_graph = graphviz.Digraph(format='png', graph_attr={'rankdir': 'LR'})  
  217. for activity in project.activities:  
  218.     aon_graph.node(str(activity.id), activity.name)  
  219.     for predecessor in activity.predecessors:  
  220.         aon_graph.edge(str(predecessor), str(activity.id))  
  221.   
  222. timestamp = datetime.now().strftime('%Y%m%d%H%M%S')  
  223.   
  224. aon_filename = f"aon_{timestamp}"  
  225.   
  226. aon_graph.render(aon_filename)  
  227.   
  228. # 将项目进度网络图插入到HTML文件中  
  229. aon_image = f'<img src="{aon_filename}.png" alt="Precedence Diagramming Method: AON">'  
  230. html = html.replace('<p>Precedence Diagramming Method: AON: <br/>[image]</p>',  
  231.                     '<p>紧前关系绘图法: AON: <br/>' + aon_image + '</p>')  
  232.   
  233. filename = datetime.now().strftime('%Y%m%d%H%M%S') + '.html'  
  234. with open(filename, 'w', encoding='utf-8') as f:  
  235.     f.write(html)

2.活动类

程序名：

  1. activity.py
  1. class Activity:  
  2.     """  
  3.     活动类，用于表示项目中的一个活动。  
  4.   
  5.     Attributes:        id (int): 活动的唯一标识符。  
  6.         name (str): 活动的名称。  
  7.         duration (int): 活动的持续时间。  
  8.         predecessors (List[int]): 活动的前置活动列表，存储前置活动的id。  
  9.         est (int): 活动的最早开始时间。  
  10.         lst (int): 活动的最晚开始时间。  
  11.         eft (int): 活动的最早完成时间。  
  12.         lft (int): 活动的最晚完成时间。  
  13.         tf (int): 活动的总浮动时间。  
  14.         ff (int): 活动的自由浮动时间。  
  15.         successors (List[int]): 活动的后继活动列表，存储后继活动的Activity对象。  
  16.     """  
  17.     def __init__(self, id: int, name: str, duration: int, predecessors: List[int]):  
  18.         """  
  19.         初始化活动对象。  
  20.   
  21.         Args:            id (int): 活动的唯一标识符。  
  22.             name (str): 活动的名称。  
  23.             duration (int): 活动的持续时间。  
  24.             predecessors (List[int]): 活动的前置活动列表，存储前置活动的id。  
  25.         """        self.id = id  
  26.         self.name = name  
  27.         self.duration = duration  
  28.         self.predecessors = predecessors  
  29.         self.est = None  
  30.         self.lst = None  
  31.         self.eft = None  
  32.         self.lft = None  
  33.         self.tf = None  
  34.         self.ff = None  
  35.         self.successors = []  
  36.   
  37.     def __str__(self):  
  38.         return f"id: {self.id}, name: {self.name}, est: {self.est}, lst: {self.lst}, eft: {self.eft}, lft: {self.lft},"  
  39.         + f"successors: {self.successors}"

3.任务列表JSON文件

文件名：

  1. activities.json
  1. [  
  2.   {    "id": 1,  
  3.     "name": "A",  
  4.     "duration": 2,  
  5.     "predecessors": []  
  6.   },  
  7.   {  
  8.     "id": 9,  
  9.     "name": "A2",  
  10.     "duration": 3,  
  11.     "predecessors": []  
  12.   },  
  13.     {  
  14.     "id": 10,  
  15.     "name": "A3",  
  16.     "duration": 2,  
  17.     "predecessors": []  
  18.   },  
  19.   {  
  20.     "id": 2,  
  21.     "name": "B",  
  22.     "duration": 3,  
  23.     "predecessors": [  
  24.       1,  
  25.       9  
  26.     ]  
  27.   },  
  28.   {  
  29.     "id": 3,  
  30.     "name": "C",  
  31.     "duration": 4,  
  32.     "predecessors": [  
  33.       1  
  34.     ]  
  35.   },  
  36.   {  
  37.     "id": 4,  
  38.     "name": "D",  
  39.     "duration": 2,  
  40.     "predecessors": [  
  41.       2,10  
  42.     ]  
  43.   },  
  44.   {  
  45.     "id": 5,  
  46.     "name": "E",  
  47.     "duration": 3,  
  48.     "predecessors": [  
  49.       2  
  50.     ]  
  51.   },  
  52.   {  
  53.     "id": 6,  
  54.     "name": "F",  
  55.     "duration": 2,  
  56.     "predecessors": [  
  57.       3  
  58.     ]  
  59.   },  
  60.   {  
  61.     "id": 7,  
  62.     "name": "G",  
  63.     "duration": 3,  
  64.     "predecessors": [  
  65.       4,  
  66.       5  
  67.     ]  
  68.   },  
  69.   {  
  70.     "id": 8,  
  71.     "name": "H",  
  72.     "duration": 2,  
  73.     "predecessors": [  
  74.       6,  
  75.       7  
  76.     ]  
  77.   },  
  78.   {  
  79.     "id": 11,  
  80.     "name": "H2",  
  81.     "duration": 4,  
  82.     "predecessors": [  
  83.       6,  
  84.       7  
  85.     ]  
  86.   }  
  87. ]

4.输出模板文件

  1. <!DOCTYPE html>  
  2. <html>  
  3. <head>  
  4.     <meta charset="UTF-8">  
  5.     <title>PMP关键路径计算</title>  
  6.     <style>        table {  
  7.             border-collapse: collapse;  
  8.             width: 100%;  
  9.         }  
  10.   
  11.         th, td {  
  12.             border: 1px solid black;  
  13.             padding: 8px;  
  14.             text-align: center;  
  15.         }  
  16.   
  17.         th {  
  18.             background-color: #4CAF50;  
  19.             color: white;  
  20.         }  
  21.   
  22.         .critical {  
  23.             background-color: #ffcccc;  
  24.         }  
  25.     </style>  
  26. </head>  
  27. <body>  
  28. <h2>活动清单</h2>  
  29. <table>  
  30.     <tr>  
  31.         <th>ID</th>  
  32.         <th>活动名</th>  
  33.         <th>持续时间</th>  
  34.         <th>紧前活动</th>  
  35.         <th>紧后活动</th>  
  36.         <th>最早开始时间EST</th>  
  37.         <th>最早结束时间EFT</th>  
  38.         <th>最晚开始时间LST</th>  
  39.         <th>最晚结束时间LFT</th>  
  40.         <th>总浮动时间TF</th>  
  41.         <th>自由浮动时间FF</th>  
  42.     </tr>  
  43.     {% for activity in activities %}  
  44.     <tr {% if activity in critical_path %}class="critical" {% endif %}>  
  45.         <td>{{ activity.id }}</td>  
  46.         <td>{{ activity.name }}</td>  
  47.    &n						
  48. 						
  49. 						
  50. 						
  51. 						
  52. 						
  53. 						
  54.

以上就是Python如何实现关键路径和七格图计算的详细内容，更多关于Python如何实现关键路径和七格图计算的资料请关注九品源码其它相关文章！

相关热词： Python实现关键路径计算
上一篇：讲一讲如何在一个页面中使用多个百度分享按钮，分享不同的文章
下一篇：Python中的布尔类型bool怎么应用

文章分类

IT资讯 CMS教程 服务器 数据库 前端开发 后端开发 工具使用 其他教程

最后更新

热门排行

网站首页 | 关于我们 | 免责声明 | 网站建设 | 在线工具 | 网站地图

版权声明：本站发布的资源部分自互联网，所有资源版权归原作者所有。如果有侵犯到您的权益，请联系本站删除，谢谢合作！

Copyright 2018-2025 ©19jp.com All Rights Reserved. 陕ICP备16002142号-1