Python列表字典的模式

我有一个这样的文件

module1 instance1(.wire1 (connectionwire1), .wire2 (connectionwire2),.... ,wire100 (connectionwire100)) ; module 2 instance 2(.wire1 (newconnectionwire1), .wire2 (newconnectionwire2),.... ,wire99 (newconnectionwire99)) 

这些导线沿着模块重复。可以有许多模块。 我想建立一个这样的字典（不是第二个模块中的每一条线都是重复的）

我正在拆分

上的字符串

然后在

，

上拆分，然后在

（

上获得wire和connectionwire字符串。我不知道如何填充数据结构，尽管如此，wire是键，模块，instancename和connection是元素

Goal- get this datastructure- [ wire: (module, instance, connectionwire) ] 

filedata=file.read()
realindex=list(find_pos(filedata,';'))
tempindex=0
for l in realindex:
    module=filedata[tempindex:l]
    modulename=module.split()[0]
    openbracketindex=module.find("(")
    closebracketindex=module.strip("\n").find(");")
    instancename=module[:openbracketindex].split()[1]
    tempindex=l
    tempwires=module[openbracketindex:l+1]
    #got to split wires on commas
    for tempw in tempwires.split(","):
        wires=tempw
        listofwires.append(wires)

---

使用

re

模块

import re
from collections import defaultdict

s = "module1 instance1(.wire1 (connectionwire1), .wire2 (connectionwire2), .wire100 (connectionwire100)) ; module2 instance2(.wire1 (newconnectionwire1), .wire2 (newconnectionwire2), wire99 (newconnectionwire99))'

d = defaultdict(list)
module_pattern = r'(\w+)\s(\w+)\(([^;]+)'
mod_rex = re.compile(module_pattern)
wire_pattern = r'\.(\w+)\s\(([^\)]+)'
wire_rex = re.compile(wire_pattern)

for match in mod_rex.finditer(s):
    #print '\n'.join(match.groups())
    module, instance, wires = match.groups()
    for match in wire_rex.finditer(wires):
        wire, connection = match.groups()
        #print '\t', wire, connection
        d[wire].append((module, instance, connection))

for k, v in d.items():
    print k, ':', v

产生

wire1 : [('module1', 'instance1', 'connectionwire1'), ('module2', 'instance2', 'newconnectionwire1')]
wire2 : [('module1', 'instance1', 'connectionwire2'), ('module2', 'instance2', 'newconnectionwire2')]
wire100 : [('module1', 'instance1', 'connectionwire100')]   

---

使用

re

模块

import re
from collections import defaultdict

s = "module1 instance1(.wire1 (connectionwire1), .wire2 (connectionwire2), .wire100 (connectionwire100)) ; module2 instance2(.wire1 (newconnectionwire1), .wire2 (newconnectionwire2), wire99 (newconnectionwire99))'

d = defaultdict(list)
module_pattern = r'(\w+)\s(\w+)\(([^;]+)'
mod_rex = re.compile(module_pattern)
wire_pattern = r'\.(\w+)\s\(([^\)]+)'
wire_rex = re.compile(wire_pattern)

for match in mod_rex.finditer(s):
    #print '\n'.join(match.groups())
    module, instance, wires = match.groups()
    for match in wire_rex.finditer(wires):
        wire, connection = match.groups()
        #print '\t', wire, connection
        d[wire].append((module, instance, connection))

for k, v in d.items():
    print k, ':', v

产生

wire1 : [('module1', 'instance1', 'connectionwire1'), ('module2', 'instance2', 'newconnectionwire1')]
wire2 : [('module1', 'instance1', 'connectionwire2'), ('module2', 'instance2', 'newconnectionwire2')]
wire100 : [('module1', 'instance1', 'connectionwire100')]   

---

使用

re

模块

import re
from collections import defaultdict

s = "module1 instance1(.wire1 (connectionwire1), .wire2 (connectionwire2), .wire100 (connectionwire100)) ; module2 instance2(.wire1 (newconnectionwire1), .wire2 (newconnectionwire2), wire99 (newconnectionwire99))'

d = defaultdict(list)
module_pattern = r'(\w+)\s(\w+)\(([^;]+)'
mod_rex = re.compile(module_pattern)
wire_pattern = r'\.(\w+)\s\(([^\)]+)'
wire_rex = re.compile(wire_pattern)

for match in mod_rex.finditer(s):
    #print '\n'.join(match.groups())
    module, instance, wires = match.groups()
    for match in wire_rex.finditer(wires):
        wire, connection = match.groups()
        #print '\t', wire, connection
        d[wire].append((module, instance, connection))

for k, v in d.items():
    print k, ':', v

产生

wire1 : [('module1', 'instance1', 'connectionwire1'), ('module2', 'instance2', 'newconnectionwire1')]
wire2 : [('module1', 'instance1', 'connectionwire2'), ('module2', 'instance2', 'newconnectionwire2')]
wire100 : [('module1', 'instance1', 'connectionwire100')]   

---

使用

re

模块

import re
from collections import defaultdict

s = "module1 instance1(.wire1 (connectionwire1), .wire2 (connectionwire2), .wire100 (connectionwire100)) ; module2 instance2(.wire1 (newconnectionwire1), .wire2 (newconnectionwire2), wire99 (newconnectionwire99))'

d = defaultdict(list)
module_pattern = r'(\w+)\s(\w+)\(([^;]+)'
mod_rex = re.compile(module_pattern)
wire_pattern = r'\.(\w+)\s\(([^\)]+)'
wire_rex = re.compile(wire_pattern)

for match in mod_rex.finditer(s):
    #print '\n'.join(match.groups())
    module, instance, wires = match.groups()
    for match in wire_rex.finditer(wires):
        wire, connection = match.groups()
        #print '\t', wire, connection
        d[wire].append((module, instance, connection))

for k, v in d.items():
    print k, ':', v

产生

wire1 : [('module1', 'instance1', 'connectionwire1'), ('module2', 'instance2', 'newconnectionwire1')]
wire2 : [('module1', 'instance1', 'connectionwire2'), ('module2', 'instance2', 'newconnectionwire2')]
wire100 : [('module1', 'instance1', 'connectionwire100')]   

---

第二次世界大战使用re提供的答案是正确的。我正在分享一个例子，说明如何使用pyparsing模块解决您的问题，该模块使解析变得易懂易懂

from pyparsing import Word, alphanums, Optional, ZeroOrMore, Literal, Group, OneOrMore
from collections import defaultdict
s = 'module1 instance1(.wire1 (connectionwire1), .wire2 (connectionwire2), .wire100 (connectionwire100)) ; module2 instance2(.wire1 (newconnectionwire1), .wire2 (newconnectionwire  2), .wire99 (newconnectionwire99))'
connection = Word(alphanums)
wire = Word(alphanums)
module = Word(alphanums)
instance = Word(alphanums)
dot = Literal(".").suppress()
comma = Literal(",").suppress()
lparen = Literal("(").suppress()
rparen = Literal(")").suppress()
semicolon = Literal(";").suppress()
wire_connection = Group(dot + wire("wire") + lparen + connection("connection") + rparen + Optional(comma))
wire_connections = Group(OneOrMore(wire_connection))
module_instance = Group(module("module") + instance("instance") + lparen + ZeroOrMore(wire_connections("wire_connections")) + rparen + Optional(semicolon))
module_instances = OneOrMore(module_instance)
results = module_instances.parseString(s)
# create a dict
d = defaultdict(list)
for r in results:
    m = r['module']
    i = r['instance']
    for wc in r['wire_connections']:
        w = wc['wire']
        c = wc['connection']
        d[w].append((m, i, c)) 
print d

输出：

defaultdict(<type 'list'>, {'wire1': [('module1', 'instance1', 'connectionwire1'), ('module2', 'instance2', 'newconnectionwire1')], 'wire2': [('module1', 'instance1', 'connectionwire2'), ('module2', 'instance2', 'newconnectionwire2')], 'wire100': [('module1', 'instance1', 'connectionwire100')], 'wire99': [('module2', 'instance2', 'newconnectionwire99')]})

defaultdict（，{'wire1'：[（'module1'，'instance1'，'connectionwire1'），（'module2'，'instance2'，'newconnectionwire1'），'wire2'：[（'module1'，'instance1'，'connectionwire2'），'wire100'：[（'module1'，'instance1'，'connectionwire100'），'wire99'：[（'module2'，'instance2'，'newconnectionwire99'）]））

第二次世界大战使用re提供的答案是正确的。我正在分享一个示例，说明如何使用pyparsing模块解决您的问题，该模块使解析变得易懂易懂

from pyparsing import Word, alphanums, Optional, ZeroOrMore, Literal, Group, OneOrMore
from collections import defaultdict
s = 'module1 instance1(.wire1 (connectionwire1), .wire2 (connectionwire2), .wire100 (connectionwire100)) ; module2 instance2(.wire1 (newconnectionwire1), .wire2 (newconnectionwire  2), .wire99 (newconnectionwire99))'
connection = Word(alphanums)
wire = Word(alphanums)
module = Word(alphanums)
instance = Word(alphanums)
dot = Literal(".").suppress()
comma = Literal(",").suppress()
lparen = Literal("(").suppress()
rparen = Literal(")").suppress()
semicolon = Literal(";").suppress()
wire_connection = Group(dot + wire("wire") + lparen + connection("connection") + rparen + Optional(comma))
wire_connections = Group(OneOrMore(wire_connection))
module_instance = Group(module("module") + instance("instance") + lparen + ZeroOrMore(wire_connections("wire_connections")) + rparen + Optional(semicolon))
module_instances = OneOrMore(module_instance)
results = module_instances.parseString(s)
# create a dict
d = defaultdict(list)
for r in results:
    m = r['module']
    i = r['instance']
    for wc in r['wire_connections']:
        w = wc['wire']
        c = wc['connection']
        d[w].append((m, i, c)) 
print d

输出：

defaultdict(<type 'list'>, {'wire1': [('module1', 'instance1', 'connectionwire1'), ('module2', 'instance2', 'newconnectionwire1')], 'wire2': [('module1', 'instance1', 'connectionwire2'), ('module2', 'instance2', 'newconnectionwire2')], 'wire100': [('module1', 'instance1', 'connectionwire100')], 'wire99': [('module2', 'instance2', 'newconnectionwire99')]})

defaultdict（，{'wire1'：[（'module1'，'instance1'，'connectionwire1'），（'module2'，'instance2'，'newconnectionwire1'），'wire2'：[（'module1'，'instance1'，'connectionwire2'），'wire100'：[（'module1'，'instance1'，'connectionwire100'），'wire99'：[（'module2'，'instance2'，'newconnectionwire99'）]））

第二次世界大战使用re提供的答案是正确的。我正在分享一个示例，说明如何使用pyparsing模块解决您的问题，该模块使解析变得易懂易懂

from pyparsing import Word, alphanums, Optional, ZeroOrMore, Literal, Group, OneOrMore
from collections import defaultdict
s = 'module1 instance1(.wire1 (connectionwire1), .wire2 (connectionwire2), .wire100 (connectionwire100)) ; module2 instance2(.wire1 (newconnectionwire1), .wire2 (newconnectionwire  2), .wire99 (newconnectionwire99))'
connection = Word(alphanums)
wire = Word(alphanums)
module = Word(alphanums)
instance = Word(alphanums)
dot = Literal(".").suppress()
comma = Literal(",").suppress()
lparen = Literal("(").suppress()
rparen = Literal(")").suppress()
semicolon = Literal(";").suppress()
wire_connection = Group(dot + wire("wire") + lparen + connection("connection") + rparen + Optional(comma))
wire_connections = Group(OneOrMore(wire_connection))
module_instance = Group(module("module") + instance("instance") + lparen + ZeroOrMore(wire_connections("wire_connections")) + rparen + Optional(semicolon))
module_instances = OneOrMore(module_instance)
results = module_instances.parseString(s)
# create a dict
d = defaultdict(list)
for r in results:
    m = r['module']
    i = r['instance']
    for wc in r['wire_connections']:
        w = wc['wire']
        c = wc['connection']
        d[w].append((m, i, c)) 
print d

输出：

defaultdict(<type 'list'>, {'wire1': [('module1', 'instance1', 'connectionwire1'), ('module2', 'instance2', 'newconnectionwire1')], 'wire2': [('module1', 'instance1', 'connectionwire2'), ('module2', 'instance2', 'newconnectionwire2')], 'wire100': [('module1', 'instance1', 'connectionwire100')], 'wire99': [('module2', 'instance2', 'newconnectionwire99')]})

defaultdict（，{'wire1'：[（'module1'，'instance1'，'connectionwire1'），（'module2'，'instance2'，'newconnectionwire1'），'wire2'：[（'module1'，'instance1'，'connectionwire2'），'wire100'：[（'module1'，'instance1'，'connectionwire100'），'wire99'：[（'module2'，'instance2'，'newconnectionwire99'）]））

第二次世界大战使用re提供的答案是正确的。我正在分享一个示例，说明如何使用pyparsing模块解决您的问题，该模块使解析变得易懂易懂

from pyparsing import Word, alphanums, Optional, ZeroOrMore, Literal, Group, OneOrMore
from collections import defaultdict
s = 'module1 instance1(.wire1 (connectionwire1), .wire2 (connectionwire2), .wire100 (connectionwire100)) ; module2 instance2(.wire1 (newconnectionwire1), .wire2 (newconnectionwire  2), .wire99 (newconnectionwire99))'
connection = Word(alphanums)
wire = Word(alphanums)
module = Word(alphanums)
instance = Word(alphanums)
dot = Literal(".").suppress()
comma = Literal(",").suppress()
lparen = Literal("(").suppress()
rparen = Literal(")").suppress()
semicolon = Literal(";").suppress()
wire_connection = Group(dot + wire("wire") + lparen + connection("connection") + rparen + Optional(comma))
wire_connections = Group(OneOrMore(wire_connection))
module_instance = Group(module("module") + instance("instance") + lparen + ZeroOrMore(wire_connections("wire_connections")) + rparen + Optional(semicolon))
module_instances = OneOrMore(module_instance)
results = module_instances.parseString(s)
# create a dict
d = defaultdict(list)
for r in results:
    m = r['module']
    i = r['instance']
    for wc in r['wire_connections']:
        w = wc['wire']
        c = wc['connection']
        d[w].append((m, i, c)) 
print d

输出：

defaultdict(<type 'list'>, {'wire1': [('module1', 'instance1', 'connectionwire1'), ('module2', 'instance2', 'newconnectionwire1')], 'wire2': [('module1', 'instance1', 'connectionwire2'), ('module2', 'instance2', 'newconnectionwire2')], 'wire100': [('module1', 'instance1', 'connectionwire100')], 'wire99': [('module2', 'instance2', 'newconnectionwire99')]})

defaultdict（，{'wire1'：[（'module1'，'instance1'，'connectionwire1'），（'module2'，'instance2'，'newconnectionwire1'），'wire2'：[（'module1'，'instance1'，'connectionwire2'），'wire100'：[（'module1'，'instance1'，'connectionwire100'），'wire99'：[（'module2'，'instance2'，'newconnectionwire99'）]））

也许可以更简洁地为您工作？不太擅长正则表达式/另外还有一个问题，即导线任意长，并且有多个未知的括号（“（”）”）我想你可能会为此尝试pyparsing。它有点像正则表达式，但更具可读性。在你的示例字符串中，模块2和实例2中有空格-这是故意的吗？一个模块中可以有多个实例吗？也许可以为你工作得更干净一点？不太擅长正则表达式/另外还有一个问题，就是连线是任意的很长，有多个未知括号（“（”））我想你可能会为此尝试pyparsing。它有点像正则表达式，但更具可读性。在你的示例字符串中，模块2和实例2中有空格-这是故意的吗？一个模块中可以有多个实例吗？也许可以为你工作得更干净一点？不太擅长正则表达式/另外还有一个问题，就是连线是任意的很长，有多个未知括号（“（”））我想你可能会为此尝试pyparsing。它有点像正则表达式，但更具可读性。在你的示例字符串中，模块2和实例2中有空格-这是故意的吗？一个模块中可以有多个实例吗？也许可以为你工作得更干净一点？不太擅长正则表达式/另外还有一个问题，就是连线是任意的很长，有多个未知的括号（“（”））。我想你可以为此尝试pyparsing。它有点像正则表达式，但可读性更强。在你的示例字符串中，模块2和实例2中有空格-这是故意的吗？模块中可以有多个实例吗？wire99前面没有点（在示例字符串中）所以它不匹配。我删除了模块2和实例2的额外空间，但我错过了那个点。非常感谢，非常有用！如果我想以相同的格式打印任何不匹配的左侧导线，我将如何在第二次世界大战时做到这一点？如果一条导线可以不由点进行，请更改图案，这样就不需要点-

wire_pattern=r'（\w+）\s\（[^\）]+）'

谢谢，我有一些唯一的导线，它们只在一个模块中，我想以相同的格式获取它们->wire101:[（模块1，实例1，连接101）wire99前面没有点（在示例字符串中）所以它不匹配。我删除了模块2和实例2的额外空间，但我错过了那个点。非常感谢，非常有用！如果我想以相同的格式打印任何不匹配的左侧导线，我将如何在第二次世界大战时做到这一点？如果一条导线可以不由点进行，请更改图案，这样就不需要点-

wire_pattern=r'（\w+）\s\（[^\）]+）'

谢谢，我有一些唯一的导线，它们只在一个模块中，我想以相同的格式获取它们->wire101:[（模块1，实例1，连接101）wire99前面没有点（在示例字符串中）所以它不匹配。我删除了module2和instance2的额外空间，但我错过了那个点。非常感谢，非常有用！如果我想打印