是否可以创建一个带有可以接受各种形式的键的python字典？

Question

data = (1,1,1,1,1)

dict_letters = {(1,1,1,1,1) : 'A',
                (0,1,1,0,1) : 'B',
                (1,1,1,1,1) : 'C',   
                (1,0,1,0,1) : 'D'}

def search():
            for key in dict_letters:
                if data == key:
                    print(dict_letters[key])

search()

#when running, this would result in only 'C' being printed; 'A' was never printed

之前在我的代码中，我获得了一个由 0 和 1 组成的唯一 5 项元组（data 元组）。这 5 个项目对于区分大多数字母（例如“B”和“D”）与我字典中的其他字母至关重要。但是，当有两个键具有相同的 5 个项目时，我遇到了一个问题，因此我在元组中添加了 10 个项目（其他标识数据）以帮助进一步区分键；这是我当前字典的摘录：

data = (0,1,1,0,1,1,1,1,1,1,1,1,1,1,1)
data = (0,1,1,0,1,0,0,0,0,0,0,0,0,0,0)
data = (0,1,1,0,1,0,0,1,1,1,0,0,1,0,1)

#x = 0 or 1
dict_letters = {(1,1,1,1,1,x,x,1,x,x,x,x,x,x,x) : 'A',
                (0,1,1,0,1,x,x,x,x,x,x,x,x,x,x) : 'B',
                (1,1,1,1,1,x,x,0,x,x,x,x,x,x,x) : 'C',    
                (1,1,0,0,1,x,x,x,x,x,x,x,x,x,x) : 'D'}

def search():
            for key in dict_letters:
                if data == key:
                    print(dict_letters[key])

search()

#I need to find a way for all of the data tuples to print 'B' after running the program

在这段摘录中，我只为其中一项附加项目创造了条件，以区分“A”和“C”。我想知道是否可以忽略其他 9 个附加项目是 0 还是 1，因为它们在区分这两个键时没有用（我希望忽略的项目标有 x）。我还想忽略“B”和“D”的 10 个附加项目，因为前 5 个项目足以识别。例如，我想要一种将(0,1,1,0,1,0,0,0,0,0,0,0,0,0,0)、(0,1,1,0,1,1,1,1,1,1,1,1,1,1,1)、(0,1,1,0,1,0,0,1,1,1,0,0,1,0,1) 等都读取为“B”的方法，而无需为“B”编码 2047 个额外的键。

我尝试在字典之前设置x = 0 or 1 和x = 0 and 1，但这些不起作用，因为我发现在运行程序后出于某种原因将密钥设置为(0,1,1,0,1,1,1,1,1,1,1,1,1,1,1)。

注意：我正在考虑在未来至少使用一次所有附加项目，因此删除 10 个附加项目中的任何一个都不是一种选择。

我对 Python 也比较陌生，所以如果您能尽可能简单地回答，我将不胜感激。提前谢谢！

Answer 1

我们可以为这个任务使用一个普通的dict，我们只需要为每个字母构建所有可能的键。您的键元组包含 15 个项目，每个项目有 2 个不同的值，因此最多只有 2**15 = 32768 个不同的模式，这在现代机器上相当小。

我们可以使用itertools.product 高效地生成所有模式。 product 有效地从您传递的参数创建嵌套的 for 循环。这是该技术的简短说明。以下代码生成10XX01对应的所有模式。

from itertools import product

for t in product(*[(1,), (0,), (0, 1), (0, 1), (0,), (1,)]):
    print(t)

输出

(1, 0, 0, 0, 0, 1)
(1, 0, 0, 1, 0, 1)
(1, 0, 1, 0, 0, 1)
(1, 0, 1, 1, 0, 1)

这里有一些代码使用问题中给出的数据来构建dict，您可以将其用于搜索。我们使用dict.get 方法，因此如果您查找不在字典中的模式，代码将返回None。

from __future__ import print_function
from itertools import product

#x = 0 or 1
X = 'x'
letter_patterns = {
    (1, 1, 1, 1, 1, X, X, 1, X, X, X, X, X, X, X): 'A',
    (0, 1, 1, 0, 1, X, X, X, X, X, X, X, X, X, X): 'B',
    (1, 1, 1, 1, 1, X, X, 0, X, X, X, X, X, X, X): 'C',
    (1, 1, 0, 0, 1, X, X, X, X, X, X, X, X, X, X): 'D',
}

def make_dict(letter_patterns):
    ''' Build a dict of all the bit patterns for each letter '''
    xlate = {0: (0,), 1: (1,), X: (0, 1)}
    letter_dict = {}
    # Generate all of the (0, 1) combinations for each X in each pattern
    for pattern, letter in letter_patterns.items():
        for key in product(*[xlate[u] for u in pattern]):
            letter_dict[key] = letter
    return letter_dict

# test

letter_dict = make_dict(letter_patterns)

test_items = [
    ((1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0), 'A'),
    ((1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1), 'A'),
    ((1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0), 'A'),
    ((0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1), 'B'),
    ((0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 'B'),
    ((0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1), 'B'),
    ((1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 'C'),
    ((1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1), 'C'),
    ((1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0), 'C'),
    ((1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 'D'),
    ((1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1), 'D'),
    ((1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1), 'D'),
    ((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 'Z'),
]

# Check that each test key gets the correct letter, or returns
# None if the key isn't in letter_dict
for key, true_letter in test_items:
    letter = letter_dict.get(key)
    print(key, true_letter, letter, letter == true_letter)

输出

(1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0) A A True
(1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1) A A True
(1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0) A A True
(0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1) B B True
(0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) B B True
(0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1) B B True
(1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) C C True
(1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1) C C True
(1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0) C C True
(1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) D D True
(1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1) D D True
(1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1) D D True
(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) Z None False

此代码在 Python 2 和 3 上都能正常运行（在 2.6.6 和 3.6.0 上测试）。您可以通过更改

使其在 Python 2 上更高效

for pattern, letter in letter_patterns.items():

到

for pattern, letter in letter_patterns.iteritems():

---

letter_patterns 中的元组不是很方便，尤其是如果你想在letter_patterns 中放入很多符号。为了减少打字，我们可以使用字符串，而不是使用那些元组。这是执行此操作的上述代码的变体。生成的letter_dict 仍然使用元组键，因为我假设这就是你从 Leap Motion 设备硬件中得到的。

letter_patterns = {
    'A': '11111xx1xxxxxxx',
    'B': '01101xxxxxxxxxx',
    'C': '11111xx0xxxxxxx',
    'D': '11001xxxxxxxxxx',
}

def make_dict(letter_patterns):
    ''' Build a dict of all the bit patterns for each letter '''
    xlate = {'0': (0,), '1': (1,), 'x': (0, 1)}
    letter_dict = {}
    # Generate all of the (0, 1) combinations for each X in each pattern
    for letter, pattern in letter_patterns.items():
        for key in product(*[xlate[u] for u in pattern]):
            letter_dict[key] = letter
    return letter_dict

Answer 2

我的理解是，给定一些 tuple 作为键，如果此 tuple 中的某些条目与现有键不完全匹配，您希望忽略它们。

您可以通过在collections.UserDict 和自定义__getitem__ 方法的帮助下实现自己的类字典类来做到这一点。

以下实现假定tuple 中的条目是1 或0。如果没有这个假设，它将不得不遍历所有键。

from UserDict import UserDict
# for Python 3 use this import instead:
# from collections import UserDict

from itertools import product

class WildcardDict(UserDict):
    def __getitem__(self, args):
        item, *wildcards = args

        try:
            return self.data[item]
        except KeyError:
            for xs in product((0, 1), repeat=len(wildcards)):
                xs = iter(xs)
                item = tuple(next(xs) if i in wildcards else x for i, x in enumerate(item))
                if item in self.data:
                    return self.data[item]
        raise KeyError(args)

d = WildcardDict()

d[0, 1, 1, 0, 1] = 'B'

print(d[(0, 1, 1, 0, 1), ]) # 'B'
print(d[(0, 1, 0, 0, 0), 2, 4]) # 'B'

请注意，dict 项目查找通常是 O(1)，尽管这使得它 O(2^k) 其中 k 是通配符的数量。特别是，这意味着如果通配符的数量不断增加，您最好使用list，其中查找将是O(n)。