[已解决]求助！小白求问怎么用Python来寻找大量的化学反应式中的环路

13691255250

我现在有一个Excel，里面有上百的化学方程式，
大概这种形式
A+B=C+D
C=E+F
F+G=A+H
...
可以看到存在A-C-F-A的化学反应环路
求问各路大神，怎么用Python在上百个错综复杂的反应中，找出如上存在的环路？

如有大神解答，愿以酬金奉上

最佳答案

月排行榜 / 总排行榜

java2python

2020-5-30 12:16:50

1. #反应方程式
   
2. class  Chem_equation:
   
3.     def __init__(self,left,right):
   
4.         self.left = left
   
5.         self.right = right
   
6.     #打印方程式：a+b=c+d
   
7.     def get_equation(self):
   
8.         chem_equ = ""
   
9.         for l in range(0,len(self.left)):
   
10.             chem_equ = chem_equ + self.left[l] + "+"
    
11.         chem_equ = chem_equ[0:-1] + "="
    
12.         for r in range(0,len(self.right)):
    
13.             chem_equ = chem_equ + self.right[r] + "+"
    
14.         chem_equ = chem_equ[0:-1]
    
15.         return chem_equ
    
16.         
    
17. #某元素是反应物的词典：(0)a+b=c+d (7)a+m=k+l 那么map中就有一条{'a':[0,7]}
    
18. class React_map:
    
19.     react_element = {}
    
20. 
    
21.     @staticmethod
    
22.     def ele_in_equation_left(chem_list):
    
23.         for c in range(0,len(chem_list)):
    
24.             chem = chem_list[c]
    
25.             left = chem.left
    
26.             for l in range(0,len(left)):
    
27.                 element = React_map.react_element.get(left[l])
    
28.                 if element == None:
    
29.                     React_map.react_element.update({left[l]:[c]})
    
30.                 else:
    
31.                     element.append(c)
    
32. 
    
33. #搜索节点：
    
34. class Srh_node:
    
35.     def __init__(self,equation_no,equafrom,routefrom):
    
36.         self.equation_no = equation_no       #方程式编号
    
37.         self.equafrom = equafrom             #本节点来自于方程式编号
    
38.         self.routefrom = routefrom           #本节点来自于搜索队列号
    
39. 
    
40. #初始化反应方程式列表
    
41. def init_equation_list():
    
42.     chem_list = []
    
43.     chem_list.append(Chem_equation(['a','b'],['c','d']))
    
44.     chem_list.append(Chem_equation(['c'],['e','f']))
    
45.     chem_list.append( Chem_equation( ['f','g'],['a','h']))
    
46.     chem_list.append(Chem_equation(['c','g'],['d','h']))
    
47.     chem_list.append(Chem_equation(['d'],['m','n']))
    
48.     chem_list.append(Chem_equation(['m','g'],['b','x']))
    
49.     chem_list.append(Chem_equation(['s','t'],['u','v']))
    
50.     return chem_list
    
51. 
    
52. #主程序
    
53. def main():
    
54.     chem_list = init_equation_list()
    
55.     React_map.ele_in_equation_left(chem_list)
    
56.     #debug :打印方程式列表
    
57.     print("#################方程式列表")
    
58.     for i in range(0,len(chem_list)):
    
59.         print("<%d>%s" % (i,chem_list[i].get_equation()))
    
60.     #debug test：打印元素在左侧的方程式：元素，方程式列表
    
61.     print("#################元素在左侧的方程式：元素，方程式列表")
    
62.     for item in React_map.react_element.items():
    
63.         print(item[0],item[1])
    
64. 
    
65.     #搜索开始
    
66.     chem_list_visted = {}    #已访问节点
    
67.     routes = []       #搜索路线，列表中保存搜索节点
    
68.     circles = []      #构成环路路线：保存字符串：方程式0->方程式4->方程式5->方程式0
    
69.     srh_node = Srh_node(0,0,0)
    
70.     routes.append(srh_node)
    
71.     #上次搜索指针，当前搜索指针（指向搜索队列）
    
72.     # 搜到的节点加入一个，当前搜索指针就加1，当前搜索指针>上次搜索指针意味搜索没有结束
    
73.     last_routes_ptr = 0
    
74.     cur_routes_ptr = 1
    
75.     #第一次从初节点开始，不断发展，知道发展不出新节点
    
76.     while cur_routes_ptr > last_routes_ptr:
    
77.         cur_routes_ptr_tmp = cur_routes_ptr
    
78.         #从上次搜索指针->当前搜索节点，也就是上次新发展的节点再发展
    
79.         for i in range(last_routes_ptr,cur_routes_ptr_tmp):
    
80.             #从队列取出一个节点（方程式）
    
81.             srh_node = routes[i]
    
82.             #该方程式取出右侧元素，对所有右侧元素循环
    
83.             right = chem_list[srh_node.equation_no].right
    
84.             for r in range(0,len(right)):
    
85.                 #找出右侧元素在方程式左侧的方程式
    
86.                 equations = React_map.react_element.get(right[r])
    
87.                 if equations != None:
    
88.                     #把这些方程式中没有访问过的，全部加入队列
    
89.                     for e in range(0,len(equations)):
    
90.                         if chem_list_visted.get(equations[e]) == None:
    
91.                             if routes[0].equation_no == equations[e]:
    
92.                                 #回到初始节点
    
93.                                 circle_node = srh_node
    
94.                                 route_str = "->方程式" + str(circle_node.equation_no) + "->方程式0"
    
95.                                 while circle_node.equafrom != routes[0].equation_no:
    
96.                                     circle_node = routes[circle_node.routefrom]
    
97.                                     route_str = "->方程式" + str(circle_node.equation_no) + route_str
    
98.                                 route_str = "方程式0" + route_str
    
99.                                 circles.append(route_str)
    
100.                             else:
     
101.                                 #非初始节点，且没有被访问过
     
102.                                 chem_list_visted.update({equations[e]:0})
     
103.                                 sub_node = Srh_node(equations[e],srh_node.equation_no,i)
     
104.                                 routes.append(sub_node)
     
105.                                 cur_routes_ptr += 1
     
106.         #搜索队列/上次搜索指针更新
     
107.         last_routes_ptr = cur_routes_ptr_tmp
     
108.     #debug test：打印所有从起点开始发展出来的两个节点之间连线
     
109.     print("#################所有从起点开始发展出来的两个节点之间连线")
     
110.     for r in range(0,len(routes)):
     
111.         srh_node = routes[r]
     
112.         no = srh_node.equation_no
     
113.         print("<%d:%s>来自于方程式编号：<%d:%s>" % (no,chem_list[no].get_equation(),srh_node.equafrom,chem_list[srh_node.equafrom].get_equation()))
     
114.     #打印所有构成环路的线路
     
115.     print("#################所有构成环路的线路")
     
116.     for c in range(0,len(circles)):
     
117.         print(circles[c])
     
118. main()
     

复制代码

结果（只是以方程式0为起始点的一个列子，如果需要找出其他环路，那么再加一个外层循环：起始点就要遍历所有方程，
另外搜索中为了避免打转，标记了已访问节点，那么有些环路被忽视了：比如0->1->3，和0->1->2->3，因为第二条线路到3节点晚了，所有被忽视了）：
#################方程式列表
<0>a+b=c+d
<1>c=e+f
<2>f+g=a+h
<3>c+g=d+h
<4>d=m+n
<5>m+g=b+x
<6>s+t=u+v
#################元素在左侧的方程式：元素，方程式列表
a [0]
b [0]
c [1, 3]
f [2]
g [2, 3, 5]
d [4]
m [5]
s [6]
t [6]
#################所有从起点开始发展出来的两个节点之间连线
<0:a+b=c+d>来自于方程式编号：<0:a+b=c+d>
<1:c=e+f>来自于方程式编号：<0:a+b=c+d>
<3:c+g=d+h>来自于方程式编号：<0:a+b=c+d>
<4:d=m+n>来自于方程式编号：<0:a+b=c+d>
<2:f+g=a+h>来自于方程式编号：<1:c=e+f>
<5:m+g=b+x>来自于方程式编号：<4:d=m+n>
#################所有构成环路的线路
方程式0->方程式1->方程式2->方程式0
方程式0->方程式4->方程式5->方程式0

跳转到最佳答案楼层

13691255250

第一次用这个论坛，怎么设置酬金呀，要是有大神解答，可以直接WX联系

Twilight6

13691255250 发表于 2020-5-29 22:17
第一次用这个论坛，怎么设置酬金呀，要是有大神解答，可以直接WX联系

不一定用赏金，只要你描述好问题，态度诚恳，自然会有鱼油为你解答

java2python

没明白题目意思：
什么叫环路，
A+B=C+D
C=E+F
F+G=A+H
只要反应式左侧中有A，然后一堆推导后，反应式的右侧中有A，就算环路？可实际，这需要别的元素加入，道理上
a+b=c+d
c+d=e+f
e+f=a+b
这样才叫环路，可实际也是不可能的，因为能反应，意味着能量释放，从能量守恒角度来说，这条路走不通的

青出于蓝

酬金可能是等级不够~~

13691255250

java2python 发表于 2020-5-29 22:19
没明白题目意思：
什么叫环路，
A+B=C+D

我主要是想找出，一系列反应中，某一个物质A，经历了n个方程式后，又回到原来的形态，比如A变成了C，C又变成了F，F又变成了A

糖逗

感觉这是个递归问题可能还涉及到图（数据结构中有关于找图中环的问题）

1q2w3easxz

初一表示好懵

java2python

1. #反应方程式
   
2. class  Chem_equation:
   
3.     def __init__(self,left,right):
   
4.         self.left = left
   
5.         self.right = right
   
6.     #打印方程式：a+b=c+d
   
7.     def get_equation(self):
   
8.         chem_equ = ""
   
9.         for l in range(0,len(self.left)):
   
10.             chem_equ = chem_equ + self.left[l] + "+"
    
11.         chem_equ = chem_equ[0:-1] + "="
    
12.         for r in range(0,len(self.right)):
    
13.             chem_equ = chem_equ + self.right[r] + "+"
    
14.         chem_equ = chem_equ[0:-1]
    
15.         return chem_equ
    
16.         
    
17. #某元素是反应物的词典：(0)a+b=c+d (7)a+m=k+l 那么map中就有一条{'a':[0,7]}
    
18. class React_map:
    
19.     react_element = {}
    
20. 
    
21.     @staticmethod
    
22.     def ele_in_equation_left(chem_list):
    
23.         for c in range(0,len(chem_list)):
    
24.             chem = chem_list[c]
    
25.             left = chem.left
    
26.             for l in range(0,len(left)):
    
27.                 element = React_map.react_element.get(left[l])
    
28.                 if element == None:
    
29.                     React_map.react_element.update({left[l]:[c]})
    
30.                 else:
    
31.                     element.append(c)
    
32. 
    
33. #搜索节点：
    
34. class Srh_node:
    
35.     def __init__(self,equation_no,equafrom,routefrom):
    
36.         self.equation_no = equation_no       #方程式编号
    
37.         self.equafrom = equafrom             #本节点来自于方程式编号
    
38.         self.routefrom = routefrom           #本节点来自于搜索队列号
    
39. 
    
40. #初始化反应方程式列表
    
41. def init_equation_list():
    
42.     chem_list = []
    
43.     chem_list.append(Chem_equation(['a','b'],['c','d']))
    
44.     chem_list.append(Chem_equation(['c'],['e','f']))
    
45.     chem_list.append( Chem_equation( ['f','g'],['a','h']))
    
46.     chem_list.append(Chem_equation(['c','g'],['d','h']))
    
47.     chem_list.append(Chem_equation(['d'],['m','n']))
    
48.     chem_list.append(Chem_equation(['m','g'],['b','x']))
    
49.     chem_list.append(Chem_equation(['s','t'],['u','v']))
    
50.     return chem_list
    
51. 
    
52. #主程序
    
53. def main():
    
54.     chem_list = init_equation_list()
    
55.     React_map.ele_in_equation_left(chem_list)
    
56.     #debug :打印方程式列表
    
57.     print("#################方程式列表")
    
58.     for i in range(0,len(chem_list)):
    
59.         print("<%d>%s" % (i,chem_list[i].get_equation()))
    
60.     #debug test：打印元素在左侧的方程式：元素，方程式列表
    
61.     print("#################元素在左侧的方程式：元素，方程式列表")
    
62.     for item in React_map.react_element.items():
    
63.         print(item[0],item[1])
    
64. 
    
65.     #搜索开始
    
66.     chem_list_visted = {}    #已访问节点
    
67.     routes = []       #搜索路线，列表中保存搜索节点
    
68.     circles = []      #构成环路路线：保存字符串：方程式0->方程式4->方程式5->方程式0
    
69.     srh_node = Srh_node(0,0,0)
    
70.     routes.append(srh_node)
    
71.     #上次搜索指针，当前搜索指针（指向搜索队列）
    
72.     # 搜到的节点加入一个，当前搜索指针就加1，当前搜索指针>上次搜索指针意味搜索没有结束
    
73.     last_routes_ptr = 0
    
74.     cur_routes_ptr = 1
    
75.     #第一次从初节点开始，不断发展，知道发展不出新节点
    
76.     while cur_routes_ptr > last_routes_ptr:
    
77.         cur_routes_ptr_tmp = cur_routes_ptr
    
78.         #从上次搜索指针->当前搜索节点，也就是上次新发展的节点再发展
    
79.         for i in range(last_routes_ptr,cur_routes_ptr_tmp):
    
80.             #从队列取出一个节点（方程式）
    
81.             srh_node = routes[i]
    
82.             #该方程式取出右侧元素，对所有右侧元素循环
    
83.             right = chem_list[srh_node.equation_no].right
    
84.             for r in range(0,len(right)):
    
85.                 #找出右侧元素在方程式左侧的方程式
    
86.                 equations = React_map.react_element.get(right[r])
    
87.                 if equations != None:
    
88.                     #把这些方程式中没有访问过的，全部加入队列
    
89.                     for e in range(0,len(equations)):
    
90.                         if chem_list_visted.get(equations[e]) == None:
    
91.                             if routes[0].equation_no == equations[e]:
    
92.                                 #回到初始节点
    
93.                                 circle_node = srh_node
    
94.                                 route_str = "->方程式" + str(circle_node.equation_no) + "->方程式0"
    
95.                                 while circle_node.equafrom != routes[0].equation_no:
    
96.                                     circle_node = routes[circle_node.routefrom]
    
97.                                     route_str = "->方程式" + str(circle_node.equation_no) + route_str
    
98.                                 route_str = "方程式0" + route_str
    
99.                                 circles.append(route_str)
    
100.                             else:
     
101.                                 #非初始节点，且没有被访问过
     
102.                                 chem_list_visted.update({equations[e]:0})
     
103.                                 sub_node = Srh_node(equations[e],srh_node.equation_no,i)
     
104.                                 routes.append(sub_node)
     
105.                                 cur_routes_ptr += 1
     
106.         #搜索队列/上次搜索指针更新
     
107.         last_routes_ptr = cur_routes_ptr_tmp
     
108.     #debug test：打印所有从起点开始发展出来的两个节点之间连线
     
109.     print("#################所有从起点开始发展出来的两个节点之间连线")
     
110.     for r in range(0,len(routes)):
     
111.         srh_node = routes[r]
     
112.         no = srh_node.equation_no
     
113.         print("<%d:%s>来自于方程式编号：<%d:%s>" % (no,chem_list[no].get_equation(),srh_node.equafrom,chem_list[srh_node.equafrom].get_equation()))
     
114.     #打印所有构成环路的线路
     
115.     print("#################所有构成环路的线路")
     
116.     for c in range(0,len(circles)):
     
117.         print(circles[c])
     
118. main()
     

复制代码

结果（只是以方程式0为起始点的一个列子，如果需要找出其他环路，那么再加一个外层循环：起始点就要遍历所有方程，
另外搜索中为了避免打转，标记了已访问节点，那么有些环路被忽视了：比如0->1->3，和0->1->2->3，因为第二条线路到3节点晚了，所有被忽视了）：
#################方程式列表
<0>a+b=c+d
<1>c=e+f
<2>f+g=a+h
<3>c+g=d+h
<4>d=m+n
<5>m+g=b+x
<6>s+t=u+v
#################元素在左侧的方程式：元素，方程式列表
a [0]
b [0]
c [1, 3]
f [2]
g [2, 3, 5]
d [4]
m [5]
s [6]
t [6]
#################所有从起点开始发展出来的两个节点之间连线
<0:a+b=c+d>来自于方程式编号：<0:a+b=c+d>
<1:c=e+f>来自于方程式编号：<0:a+b=c+d>
<3:c+g=d+h>来自于方程式编号：<0:a+b=c+d>
<4:d=m+n>来自于方程式编号：<0:a+b=c+d>
<2:f+g=a+h>来自于方程式编号：<1:c=e+f>
<5:m+g=b+x>来自于方程式编号：<4:d=m+n>
#################所有构成环路的线路
方程式0->方程式1->方程式2->方程式0
方程式0->方程式4->方程式5->方程式0

_2_

糖逗 发表于 2020-5-29 22:45
感觉这是个递归问题可能还涉及到图（数据结构中有关于找图中环的问题）

还没学到化学，
无缘了

_荟桐_

_2_ 发表于 2020-5-30 12:48
还没学到化学，
无缘了

应该和化学没多大关系吧
和这道题有一丢丢像
https://fishc.com.cn/thread-170547-1-5.html

_2_

_荟桐_ 发表于 2020-5-30 12:51
应该和化学没多大关系吧
和这道题有一丢丢像
https://fishc.com.cn/thread-170547-1-5.html

不懂写出来就不一样
自己也不理解

java2python

搜索一下：带权重无向图 最短路径

13691255250

java2python 发表于 2020-5-30 12:16
结果（只是以方程式0为起始点的一个列子，如果需要找出其他环路，那么再加一个外层循环：起始点就要遍历 ...

大神，你好，我刚看到你回的帖子，太完美了！
方便加个微信吗？我好像是账号等级不够，没法私聊
请问怎么再外层加个循环，让七点遍历所有方程呀

java2python

13691255250 发表于 2020-5-31 13:18
大神，你好，我刚看到你回的帖子，太完美了！
方便加个微信吗？我好像是账号等级不够，没法私聊
请问怎 ...

过奖，其实和外面博客程序比，差不少。
外层加循环：
第53行def main()
改为：def srh(srhno):
第118行main()
改为：
srh(0)
srh(1)
第69行：    srh_node = Srh_node(0,0,0)
    srh_node = Srh_node(srhno,0,0)
就行了，另外输出：方程式0->方程式2->方程式0->方程式0的地方，我把开头和结尾都固定了，这里也要改
如果在一个环路中，可能输出相同（只是开头节点变化），如果在不同环路中（不相连），原先是连不上，输出不了结果，现在因为有了切入点，可以输出了。

13691255250

java2python 发表于 2020-5-30 12:16
结果（只是以方程式0为起始点的一个列子，如果需要找出其他环路，那么再加一个外层循环：起始点就要遍历 ...

大神，能帮我理解下第81行吗？我感觉srh_node是类Srh_node的一个实例，routes是刚创建的空列表，routes【i】是这个列表的第i个元素， 那  srh_node = routes怎么理解呀？

java2python

13691255250 发表于 2020-6-2 14:47
大神，能帮我理解下第81行吗？我感觉srh_node是类Srh_node的一个实例，routes是刚创建的空列表，routes ...

Srh_node是一个数据类，存放：（#方程式编号，#本节点来自于方程式编号，#本节点来自于搜索队列号）
方程式编号：就是chem_list里的第几个方程，A+B=C+D,这是第0个方程式，那么方程式编号就是0

本节点来自于方程式编号：比如从A+B=C+D，找到C,那么C作为反应物的方程式，比如C=e+f，建立C的搜索节点时，他的方程式编号是1，那么搜索的时候他是怎么来的，比如完全独立的(x+y=z)，他不可能通过A+B=C+D出发的来找到，来自于方程式，表示这个C是哪个方程式产生的意思，换句话说，方程式编号就是C是反应物的方程式，来自于方程式，就是C是生成物的方程式编号，希望说了一堆别更糊涂。

本节点来自于搜索队列号：比如是通过第0个搜索节点来的，那么来自于搜索节点号就是0，一开始都是0，实际搜索展开后，这些数字是不同的。

程序写的不太好，比如列表中，有某个类，但你找不到，甚至是词典a->b，可以用key来搜索，但反过来知道b,a也是找不到，当然可以用循环来找，这样程序全乱了。
你首先是简化数据，让程序循环数最少，比如就只有三个产生式，就像你所举的例子，再加一个无关的，比如x+y=z,这和查找的不构成环路。然后调试，看看能不能理解，其实这程序能改进的地方太多了

已经费了很多力气了，不再回复了。。。
程序结构变动，Srh_node改为SRH类，里面具体成员就两个(方程号，方程来自于搜索节点)，静态成员chem_list_visted已访问方程式，circles存放找到的环路：

1. #反应方程式
   
2. class  Chem:
   
3.     chem_list = []
   
4.     react_map = {} #某元素是反应物的词典：(0)a+b=c+d (7)a+m=k+l 那么map中就有一条{'a':[0,7]}
   
5.     def __init__(self,left,right):
   
6.         self.left = left
   
7.         self.right = right
   
8.         Chem.chem_list.append(self)
   
9.     #打印方程式：a+b=c+d
   
10.     def get_equation(self):
    
11.         chem_equ = ""
    
12.         for l in range(0,len(self.left)):
    
13.             chem_equ = chem_equ + self.left[l] + "+"
    
14.         chem_equ = chem_equ[0:-1] + "="
    
15.         for r in range(0,len(self.right)):
    
16.             chem_equ = chem_equ + self.right[r] + "+"
    
17.         chem_equ = chem_equ[0:-1]
    
18.         return chem_equ
    
19. 
    
20.     @staticmethod
    
21.     def ele_in_equation_left():
    
22.         for c in range(0,len(Chem.chem_list)):
    
23.             chem = Chem.chem_list[c]
    
24.             left = chem.left
    
25.             for l in range(0,len(left)):
    
26.                 element = Chem.react_map.get(left[l])
    
27.                 if element == None:
    
28.                     Chem.react_map.update({left[l]:[c]})
    
29.                 else:
    
30.                     element.append(c)
    
31. 
    
32. #搜索节点：
    
33. class SRH:
    
34.     chem_list_visted = {}    #已访问节点
    
35.     circles = []      #构成环路路线：保存字符串：方程式0->方程式4->方程式5->方程式0
    
36.     start = 0         #搜索起点
    
37.     def __init__(self,equation_no,routefrom):
    
38.         self.equation_no = equation_no       #方程式编号
    
39.         self.routefrom = routefrom           #本节点来自于搜索队列号
    
40.         SRH.chem_list_visted.update({self.equation_no:self})
    
41.     #搜索环路
    
42.     @staticmethod
    
43.     def srh(srhno):
    
44.         SRH.start = srhno
    
45.         srh_node = SRH(SRH.start,None)
    
46.         #上次搜索到节点，本次搜索到节点
    
47.         step0_nodes = [SRH.start]
    
48.         step1_nodes = []
    
49.         #第一次从初节点开始，不断发展，直到发展不出新节点
    
50.         while len(step0_nodes) > 0:
    
51.             for n in range(0,len(step0_nodes)):
    
52.                 #从队列取出一个节点（方程式）,把这个方程式中的生成物，作为反应物的方程式全部找出，加入step1_nodes
    
53.                 srh_node = SRH.chem_list_visted.get(step0_nodes[n])
    
54.                 SRH.add_next_step_nodes(srh_node,step1_nodes)
    
55.             #用这次搜索到的节点(step1_nodes)，复制给step0_nodes，作为下一次搜索的初始化
    
56.             step0_nodes = step1_nodes[:]
    
57.             step1_nodes.clear()
    
58.         #打印所有构成环路的线路
    
59.         print("#################方程式<%d>为起点的所有环路" % SRH.start)
    
60.         for c in range(0,len(SRH.circles)):
    
61.             print(SRH.circles[c])
    
62.         SRH.chem_list_visted.clear()
    
63.         SRH.circles.clear()
    
64. 
    
65.     @staticmethod
    
66.     def get_visited(ikey):
    
67.         return SRH.chem_list_visted.get(ikey)
    
68.     @staticmethod
    
69.     def is_visited(ikey):
    
70.         return SRH.chem_list_visted.get(ikey) != None
    
71.     @staticmethod
    
72.     def add_next_step_nodes(srh_node,step1_nodes):
    
73.         #该方程式取出生成物
    
74.         right = Chem.chem_list[srh_node.equation_no].right
    
75.         for r in range(0,len(right)):
    
76.             #对所有生成物查找他们作为反应物的方程式
    
77.             equations = Chem.react_map.get(right[r])
    
78.             if equations == None:
    
79.                 continue
    
80.             #把这些方程式中没有访问过的，全部加入队列
    
81.             for e in range(0,len(equations)):
    
82.                 if SRH.start == equations[e]:
    
83.                     SRH.find_circle(srh_node)
    
84.                 elif SRH.is_visited(equations[e]) == False:
    
85.                     SRH(equations[e],srh_node)
    
86.                     step1_nodes.append(equations[e])
    
87. 
    
88.     @staticmethod
    
89.     def find_circle(node):
    
90.         #回到初始节点
    
91.         circle_node = node
    
92.         route_str = "->方程式" + str(circle_node.equation_no) + "->方程式"+str(SRH.start)
    
93.         while circle_node.routefrom.equation_no != SRH.start:
    
94.             circle_node = circle_node.routefrom
    
95.             route_str = "->方程式" + str(circle_node.equation_no) + route_str
    
96.         route_str = "方程式"+str(SRH.start) + route_str
    
97.         SRH.circles.append(route_str)
    
98. 
    
99. #初始化反应方程式列表
    
100. def init_equation_list():
     
101.     Chem(['a','b'],['c','d'])
     
102.     Chem(['c'],['e','f'])
     
103.     Chem( ['f','g'],['a','h'])
     
104.     Chem(['c','g'],['d','h'])
     
105.     Chem(['d'],['m','n'])
     
106.     Chem(['m','g'],['b','x'])
     
107.     Chem(['s','t'],['u','v'])
     
108. 
     
109. init_equation_list()
     
110. Chem.ele_in_equation_left()
     
111. #debug :打印方程式列表
     
112. print("#########################DEBUG 显示方程组初始化结果是否正确")
     
113. print("-----------------方程式列表")
     
114. for i in range(0,len(Chem.chem_list)):
     
115.     print("<%d>%s" % (i,Chem.chem_list[i].get_equation()))
     
116. #debug test：打印元素在左侧的方程式：元素，方程式列表
     
117. print("-----------------元素在左侧的方程式：元素，方程式列表")
     
118. for item in Chem.react_map.items():
     
119.     print(item[0],item[1])
     
120. for e in range(len(Chem.chem_list)):
     
121.     SRH.srh(e)

复制代码