求助！小白求问怎么用Python来寻找大量的化学反应式中的环路
我现在有一个Excel，里面有上百的化学方程式，大概这种形式
A+B=C+D
C=E+F
F+G=A+H
...
可以看到存在A-C-F-A的化学反应环路
求问各路大神，怎么用Python在上百个错综复杂的反应中，找出如上存在的环路？
如有大神解答，愿以酬金奉上 第一次用这个论坛，怎么设置酬金呀，要是有大神解答，可以直接WX联系 13691255250 发表于 2020-5-29 22:17
第一次用这个论坛，怎么设置酬金呀，要是有大神解答，可以直接WX联系
不一定用赏金，只要你描述好问题，态度诚恳，自然会有鱼油为你解答 没明白题目意思：
什么叫环路，
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
这样才叫环路，可实际也是不可能的，因为能反应，意味着能量释放，从能量守恒角度来说，这条路走不通的 酬金可能是等级不够~~ java2python 发表于 2020-5-29 22:19
没明白题目意思：
什么叫环路，
A+B=C+D
我主要是想找出，一系列反应中，某一个物质A，经历了n个方程式后，又回到原来的形态，比如A变成了C，C又变成了F，F又变成了A 感觉这是个递归问题可能还涉及到图（数据结构中有关于找图中环的问题） 初一表示好懵 本帖最后由 java2python 于 2020-5-30 12:24 编辑
#反应方程式
classChem_equation:
def __init__(self,left,right):
self.left = left
self.right = right
#打印方程式：a+b=c+d
def get_equation(self):
chem_equ = ""
for l in range(0,len(self.left)):
chem_equ = chem_equ + self.left + "+"
chem_equ = chem_equ + "="
for r in range(0,len(self.right)):
chem_equ = chem_equ + self.right + "+"
chem_equ = chem_equ
return chem_equ
#某元素是反应物的词典：(0)a+b=c+d (7)a+m=k+l 那么map中就有一条{'a':}
class React_map:
react_element = {}
@staticmethod
def ele_in_equation_left(chem_list):
for c in range(0,len(chem_list)):
chem = chem_list
left = chem.left
for l in range(0,len(left)):
element = React_map.react_element.get(left)
if element == None:
React_map.react_element.update({left:})
else:
element.append(c)
#搜索节点：
class Srh_node:
def __init__(self,equation_no,equafrom,routefrom):
self.equation_no = equation_no #方程式编号
self.equafrom = equafrom #本节点来自于方程式编号
self.routefrom = routefrom #本节点来自于搜索队列号
#初始化反应方程式列表
def init_equation_list():
chem_list = []
chem_list.append(Chem_equation(['a','b'],['c','d']))
chem_list.append(Chem_equation(['c'],['e','f']))
chem_list.append( Chem_equation( ['f','g'],['a','h']))
chem_list.append(Chem_equation(['c','g'],['d','h']))
chem_list.append(Chem_equation(['d'],['m','n']))
chem_list.append(Chem_equation(['m','g'],['b','x']))
chem_list.append(Chem_equation(['s','t'],['u','v']))
return chem_list
#主程序
def main():
chem_list = init_equation_list()
React_map.ele_in_equation_left(chem_list)
#debug :打印方程式列表
print("#################方程式列表")
for i in range(0,len(chem_list)):
print("<%d>%s" % (i,chem_list.get_equation()))
#debug test：打印元素在左侧的方程式：元素，方程式列表
print("#################元素在左侧的方程式：元素，方程式列表")
for item in React_map.react_element.items():
print(item,item)
#搜索开始
chem_list_visted = {} #已访问节点
routes = [] #搜索路线，列表中保存搜索节点
circles = [] #构成环路路线：保存字符串：方程式0->方程式4->方程式5->方程式0
srh_node = Srh_node(0,0,0)
routes.append(srh_node)
#上次搜索指针，当前搜索指针（指向搜索队列）
# 搜到的节点加入一个，当前搜索指针就加1，当前搜索指针>上次搜索指针意味搜索没有结束
last_routes_ptr = 0
cur_routes_ptr = 1
#第一次从初节点开始，不断发展，知道发展不出新节点
while cur_routes_ptr > last_routes_ptr:
cur_routes_ptr_tmp = cur_routes_ptr
#从上次搜索指针->当前搜索节点，也就是上次新发展的节点再发展
for i in range(last_routes_ptr,cur_routes_ptr_tmp):
#从队列取出一个节点（方程式）
srh_node = routes
#该方程式取出右侧元素，对所有右侧元素循环
right = chem_list.right
for r in range(0,len(right)):
#找出右侧元素在方程式左侧的方程式
equations = React_map.react_element.get(right)
if equations != None:
#把这些方程式中没有访问过的，全部加入队列
for e in range(0,len(equations)):
if chem_list_visted.get(equations) == None:
if routes.equation_no == equations:
#回到初始节点
circle_node = srh_node
route_str = "->方程式" + str(circle_node.equation_no) + "->方程式0"
while circle_node.equafrom != routes.equation_no:
circle_node = routes
route_str = "->方程式" + str(circle_node.equation_no) + route_str
route_str = "方程式0" + route_str
circles.append(route_str)
else:
#非初始节点，且没有被访问过
chem_list_visted.update({equations:0})
sub_node = Srh_node(equations,srh_node.equation_no,i)
routes.append(sub_node)
cur_routes_ptr += 1
#搜索队列/上次搜索指针更新
last_routes_ptr = cur_routes_ptr_tmp
#debug test：打印所有从起点开始发展出来的两个节点之间连线
print("#################所有从起点开始发展出来的两个节点之间连线")
for r in range(0,len(routes)):
srh_node = routes
no = srh_node.equation_no
print("<%d:%s>来自于方程式编号：<%d:%s>" % (no,chem_list.get_equation(),srh_node.equafrom,chem_list.get_equation()))
#打印所有构成环路的线路
print("#################所有构成环路的线路")
for c in range(0,len(circles)):
print(circles)
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
b
c
f
g
d
m
s
t
#################所有从起点开始发展出来的两个节点之间连线
<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 糖逗 发表于 2020-5-29 22:45
感觉这是个递归问题可能还涉及到图（数据结构中有关于找图中环的问题）
还没学到化学，
无缘了{:10_269:} _2_ 发表于 2020-5-30 12:48
还没学到化学，
无缘了
应该和化学没多大关系吧
和这道题有一丢丢像
https://fishc.com.cn/thread-170547-1-5.html _荟桐_ 发表于 2020-5-30 12:51
应该和化学没多大关系吧
和这道题有一丢丢像
https://fishc.com.cn/thread-170547-1-5.html
不懂写出来就不一样
自己也不理解{:10_266:} 搜索一下：带权重无向图 最短路径 java2python 发表于 2020-5-30 12:16
结果（只是以方程式0为起始点的一个列子，如果需要找出其他环路，那么再加一个外层循环：起始点就要遍历 ...
大神，你好，我刚看到你回的帖子，太完美了！
方便加个微信吗？我好像是账号等级不够，没法私聊
请问怎么再外层加个循环，让七点遍历所有方程呀 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的地方，我把开头和结尾都固定了，这里也要改
如果在一个环路中，可能输出相同（只是开头节点变化），如果在不同环路中（不相连），原先是连不上，输出不了结果，现在因为有了切入点，可以输出了。 java2python 发表于 2020-5-30 12:16
结果（只是以方程式0为起始点的一个列子，如果需要找出其他环路，那么再加一个外层循环：起始点就要遍历 ...
大神，能帮我理解下第81行吗？我感觉srh_node是类Srh_node的一个实例，routes是刚创建的空列表，routes【i】是这个列表的第i个元素， 那srh_node = routes怎么理解呀？ 本帖最后由 java2python 于 2020-6-2 18:17 编辑
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存放找到的环路：
#反应方程式
classChem:
chem_list = []
react_map = {} #某元素是反应物的词典：(0)a+b=c+d (7)a+m=k+l 那么map中就有一条{'a':}
def __init__(self,left,right):
self.left = left
self.right = right
Chem.chem_list.append(self)
#打印方程式：a+b=c+d
def get_equation(self):
chem_equ = ""
for l in range(0,len(self.left)):
chem_equ = chem_equ + self.left + "+"
chem_equ = chem_equ + "="
for r in range(0,len(self.right)):
chem_equ = chem_equ + self.right + "+"
chem_equ = chem_equ
return chem_equ
@staticmethod
def ele_in_equation_left():
for c in range(0,len(Chem.chem_list)):
chem = Chem.chem_list
left = chem.left
for l in range(0,len(left)):
element = Chem.react_map.get(left)
if element == None:
Chem.react_map.update({left:})
else:
element.append(c)
#搜索节点：
class SRH:
chem_list_visted = {} #已访问节点
circles = [] #构成环路路线：保存字符串：方程式0->方程式4->方程式5->方程式0
start = 0 #搜索起点
def __init__(self,equation_no,routefrom):
self.equation_no = equation_no #方程式编号
self.routefrom = routefrom #本节点来自于搜索队列号
SRH.chem_list_visted.update({self.equation_no:self})
#搜索环路
@staticmethod
def srh(srhno):
SRH.start = srhno
srh_node = SRH(SRH.start,None)
#上次搜索到节点，本次搜索到节点
step0_nodes =
step1_nodes = []
#第一次从初节点开始，不断发展，直到发展不出新节点
while len(step0_nodes) > 0:
for n in range(0,len(step0_nodes)):
#从队列取出一个节点（方程式）,把这个方程式中的生成物，作为反应物的方程式全部找出，加入step1_nodes
srh_node = SRH.chem_list_visted.get(step0_nodes)
SRH.add_next_step_nodes(srh_node,step1_nodes)
#用这次搜索到的节点(step1_nodes)，复制给step0_nodes，作为下一次搜索的初始化
step0_nodes = step1_nodes[:]
step1_nodes.clear()
#打印所有构成环路的线路
print("#################方程式<%d>为起点的所有环路" % SRH.start)
for c in range(0,len(SRH.circles)):
print(SRH.circles)
SRH.chem_list_visted.clear()
SRH.circles.clear()
@staticmethod
def get_visited(ikey):
return SRH.chem_list_visted.get(ikey)
@staticmethod
def is_visited(ikey):
return SRH.chem_list_visted.get(ikey) != None
@staticmethod
def add_next_step_nodes(srh_node,step1_nodes):
#该方程式取出生成物
right = Chem.chem_list.right
for r in range(0,len(right)):
#对所有生成物查找他们作为反应物的方程式
equations = Chem.react_map.get(right)
if equations == None:
continue
#把这些方程式中没有访问过的，全部加入队列
for e in range(0,len(equations)):
if SRH.start == equations:
SRH.find_circle(srh_node)
elif SRH.is_visited(equations) == False:
SRH(equations,srh_node)
step1_nodes.append(equations)
@staticmethod
def find_circle(node):
#回到初始节点
circle_node = node
route_str = "->方程式" + str(circle_node.equation_no) + "->方程式"+str(SRH.start)
while circle_node.routefrom.equation_no != SRH.start:
circle_node = circle_node.routefrom
route_str = "->方程式" + str(circle_node.equation_no) + route_str
route_str = "方程式"+str(SRH.start) + route_str
SRH.circles.append(route_str)
#初始化反应方程式列表
def init_equation_list():
Chem(['a','b'],['c','d'])
Chem(['c'],['e','f'])
Chem( ['f','g'],['a','h'])
Chem(['c','g'],['d','h'])
Chem(['d'],['m','n'])
Chem(['m','g'],['b','x'])
Chem(['s','t'],['u','v'])
init_equation_list()
Chem.ele_in_equation_left()
#debug :打印方程式列表
print("#########################DEBUG 显示方程组初始化结果是否正确")
print("-----------------方程式列表")
for i in range(0,len(Chem.chem_list)):
print("<%d>%s" % (i,Chem.chem_list.get_equation()))
#debug test：打印元素在左侧的方程式：元素，方程式列表
print("-----------------元素在左侧的方程式：元素，方程式列表")
for item in Chem.react_map.items():
print(item,item)
for e in range(len(Chem.chem_list)):
SRH.srh(e)
页:
[1]