如果包含相同的字符串比较相同的字符串键python

Question

我有一个与许多键和大约100个值这些键的字典。 但是每个字典在最后都有某种ID，我需要比较每个字典的值与一些引用，但只是它们具有相同的ID。 例如，键：

{'mmc-1/bbc-1': { 
'inner_key1' : '1', 
'inner_key2' : '4', 
'inner_key3' : '3', 
'inner_key4' : '5', 
'inner_key5' : '4', 
'inner_key6' : '5', 
'inner_key7' : '2', 
'inner_key8' : '0', 
'inner_key9' : '10'}, 
'mmc-1/bbc-2': { 
'inner_key1' : '3', 
'inner_key2' : '4', 
'inner_key3' : '3', 
'inner_key4' : '5', 
'inner_key5' : '6', 
'inner_key6' : '5', 
'inner_key7' : '2', 
'inner_key8' : '8', 
'inner_key9' : '10'}, 
... 
'mmc-2/bbc-1': { 
'inner_key1' : '1', 
'inner_key2' : '4', 
'inner_key3' : '3', 
'inner_key4' : '5', 
'inner_key5' : '7', 
'inner_key6' : '5', 
'inner_key7' : '2', 
'inner_key8' : '0', 
'inner_key9' : '10'}} 

所以我需要比较刚刚MMC-1/BBC-1使用MMC-2/BBC-1和MMC-3/BBC-1，因此，BBC ID是一个条件。请记住，这些是字典的关键。 我可以

.split('/')[1].split('-')[1] 

开口键，但不知道如何使一个条件比较只是与同BBC字典。 这是比较并将差异放入新字典中的代码，但是对于每个密钥都是这样做的，不需要改动bbc id，这就是我需要改变的地方。 objDict是我的对象字典，refd是带引用对象的字典，让我们从上面的例子中为ref对象取第一个对象。

#Choose reference object 
ref = tempdict['mmc-1/bbc-1'] 
m_dif = {} 

#Main function for finding differences 
for obj, objDict in tempdict.iteritems(): 
    currentDict = {} 

    # Check if the keys match. 
    if objDict.keys() != ref.keys(): 
     for key in ref: 
      if key not in objDict.keys(): 
       currentDict[key] = None 

     for key in objDict: 
      if key not in ref.keys(): 
       # Store unexpected values in object. 
       currentDict[key] = None 

    # Check if values are the same. 
    for k, v in objDict.iteritems(): 
     # Check if the key is in ref to avoid error 
     if k in ref: 
      # Then compare if values are equal 
      if ref[k] != objDict[k]: 
       # Make actual diff 
       currentDict[k] = v 
    # Store differences for current object against object title. 
    m_dif[obj] = currentDict 

我知道这不是一个很好解释的问题，但让我知道什么是混乱，我要解释。

让我们假设基准是MMC-1/BBC-1与BBC ID = 1 所需的输出对象：

{'mmc-2/bbc-1': { 
'inner_key5' : '7'}} 

而对于所有其他BBC ID同样的事情。如果只有一个ref的所有对象，无论bbc id是什么，此代码完美工作。

Answer 1

要“组一起与同BBC值键”（这是你的问题我的工作解释），有几件事情你可以做：

import pprint 

from collections import defaultdict 

max_mmc = 10 
max_bbc = 3 

data = {"mmc-{}/bbc-{}".format(a, b): a * 10 ** b for a in range(max_mmc) 
                for b in range(max_bbc)} 

pprint.pprint(data) 

# approach where you already know the maximum id of bbc and mmc 

result_1 = {"bbc-{}".format(bbc): [data["mmc-{}/bbc-{}".format(mmc, bbc)] 
            for mmc in range(max_mmc)] 
            for bbc in range(max_bbc)} 

# approach where you don't know the maximums 

result_2 = defaultdict(list) 

for k, v in data.items(): # items because of Python 3 
    mmc, bbc = k.split("/") 
    result_2[bbc].append(v) 

pprint.pprint(result_1) 
pprint.pprint(result_2) 

在这里，我一个漂亮的加入简短的临界PEP-8兼容数据模型 - 您的密钥的一个子集被重新创建，每个值都是mmc和bbc的粗略“散列”版本。这让我们以后可以看到它已正常工作。 （即根据bbc-2分组应产生100的所有倍数）。它也消除了比约恩谈论的许多混乱。

该代码包含两种方法 - 它将根据您对数据的了解程度而改变。第一种方法将会更有效率。该代码只是产生一个键列表，因为我不确定你想要如何处理它们 - 但是，这种方法仍然适用于你想对组进行任何操作。

在这两种情况下，您都可以立即访问分组值（v或data[...]）并对其进行修改，或追溯性地通过列表并执行一些操作。

这有以下的输出：

{'mmc-0/bbc-0': 0, 
'mmc-0/bbc-1': 0, 
'mmc-0/bbc-2': 0, 
'mmc-1/bbc-0': 1, 
'mmc-1/bbc-1': 10, 
'mmc-1/bbc-2': 100, 
'mmc-2/bbc-0': 2, 
'mmc-2/bbc-1': 20, 
'mmc-2/bbc-2': 200, 
'mmc-3/bbc-0': 3, 
'mmc-3/bbc-1': 30, 
'mmc-3/bbc-2': 300, 
'mmc-4/bbc-0': 4, 
'mmc-4/bbc-1': 40, 
'mmc-4/bbc-2': 400, 
'mmc-5/bbc-0': 5, 
'mmc-5/bbc-1': 50, 
'mmc-5/bbc-2': 500, 
'mmc-6/bbc-0': 6, 
'mmc-6/bbc-1': 60, 
'mmc-6/bbc-2': 600, 
'mmc-7/bbc-0': 7, 
'mmc-7/bbc-1': 70, 
'mmc-7/bbc-2': 700, 
'mmc-8/bbc-0': 8, 
'mmc-8/bbc-1': 80, 
'mmc-8/bbc-2': 800, 
'mmc-9/bbc-0': 9, 
'mmc-9/bbc-1': 90, 
'mmc-9/bbc-2': 900} 

{'bbc-0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 
'bbc-1': [0, 10, 20, 30, 40, 50, 60, 70, 80, 90], 
'bbc-2': [0, 100, 200, 300, 400, 500, 600, 700, 800, 900]} 

defaultdict(<class 'list'>, 
      {'bbc-0': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 
      'bbc-1': [0, 10, 20, 30, 40, 50, 60, 70, 80, 90], 
      'bbc-2': [0, 100, 200, 300, 400, 500, 600, 700, 800, 900]}) 

我们可以看到，结果在这两种情况下被正确分组。请注意，对于任何可以使用字典的任何东西，您都可以使用defaultdict--它仅用于在满足新密钥时创建列表。

如果您无法访问数据源，则必须执行此操作。但是，如果你可以改变它，像嵌套字典/列表（因为索引是连续的）会让你的生活变得更容易。