通过子字符串分配 Python 字典

Question

给定一个预先存在的 Python 字典：

my_dict = {
    "Robert" : 37,
    "Kevin"  : 25,
    "Mark"   : 81,
}

如果您只提供了一个子字符串或不同大小写版本的键，那么在此结构中为现有键插入新值的最有效方法是什么？例如。 “抢”或“kev”

我目前的工作，但我正在做类似以下的事情，对于多个输入，这是 O(N^2)：

for key in list(my_dict):
    if my_input.name.lower() in key.lower():
        my_dict[key] = my_input.value
        break

Answer 1

首先，正如我在问题下的 cmets 中解释的那样，您可以采取一些措施来优化现有代码：

my_dict = {
    "Robert" : 37,
    "Kevin"  : 25,
    "Mark"   : 81,
    "Andre"  : 55
}

# optimized version of existing code
def update_key(my_dict, my_input, my_value):
    my_input = my_input.lower()
    for key in my_dict:
        if my_input in key.lower():
            my_dict[key] = my_value
            break

正如@Stephen Rauch 所做的那样，我认为建立索引是可行的方法。但是，我认为构建每个键的每个可能的子字符串都是昂贵的。此外，它对出现在字符串中间或末尾的子字符串并不健壮。

这是另一种基于索引的方法。这个想法是我们将所有键连接在一起并构建一个字符串。我们还跟踪列表中每个字符串的长度。

然后对于给定的测试字符串，我们使用str.find()（应该是O(N)）来查找子字符串的索引。接下来我们在length数组中进行计数，找到对应的key。

def create_index(my_dict):
    key_str = ""
    key_lengths = []
    for key in my_dict:
        key_str += key
        key_lengths.append(len(key))

    # return the concatenated keys, a lower case version, and the lengths list
    return (key_str, key_str.lower(), key_lengths)

def key_lookup(key_str, key_str_lower, key_lengths, my_input):
    idx = key_str_lower.find(my_input.lower())
    if idx == -1:
        return None
    len_sum = 0
    for kl in key_lengths:
        if idx < len_sum+kl:
            return key_str[len_sum:len_sum+kl]
        else:
            len_sum += kl
    return None

key_str, key_str_lower, key_lengths = create_index(my_dict)

print key_str_lower
#andrerobertkevinmark
print key_lengths
#[5, 6, 5, 4]

示例输出：

print(key_lookup(key_str, key_str_lower, key_lengths, my_input='rob'))
#Robert
print(key_lookup(key_str, key_str_lower, key_lengths, my_input='dre'))
#Andre

注意事项

• 我认为您现有的代码可能比这个解决方案更好。它肯定更具可读性，也更容易理解。
• 也有一些方法可以修改它，这取决于您的实际目的。例如，您可以将每个可能的偏移量以{offset: key} 的形式存储在字典中，而不是遍历并计算字符串偏移量。这会稍微增加索引创建时间并使用更多空间，但查找速度会更快。
• 与原始示例一样，如果子字符串包含在多个字符串中，这将返回第一个匹配项。由于字典是无序的，因此可以在构建索引时选择对键进行排序，以使输出具有确定性。

---

计时结果

import random
import string

random.seed(12345)

N = 1000
my_dict = {
    ''.join(random.choice(string.ascii_letters) for _ in range(random.randint(3,30))): j for j in range(N)
}

def key_lookup_orig(my_dict, my_input):
    my_input = my_input.lower()
    for key in my_dict:
        if my_input in key.lower():
            return key
    return None

subs = [k[random.randint(0,len(k)-1):max(random.randint(0,len(k)), len(k))] for k in my_dict]

%%timeit
sum([1 if not key_lookup_orig(my_dict, s) else 0 for s in subs])
#1000 loops, best of 3: 1.5 ms per loop

key_str, key_str_lower, key_lengths = create_index(my_dict)

%%timeit
sum([1 if not key_lookup(key_str, key_str_lower, key_lengths, my_input=s) else 0 for s in subs])
#1000 loops, best of 3: 795 µs per loop

Answer 2

我不知道这是否是最最有效的方式，但您可以使用dict 为数据建立索引，例如：

构建索引：

def build_index(data):
    lookup = {}
    for k in data:
        orig = k
        k = k.lower()
        while k:
            if k in lookup:
                lookup[k] = None
                break
            lookup[k] = orig
            k = k[:-1]
    return lookup

使用索引：

def findit(value, lookup, data):
    k = lookup.get(value.lower())
    if k is not None:
        return data[k]

测试代码：

data = {
    "Robert": 37,
    "Kevin": 25,
    "Mark": 81,
}

lookup = build_index(data)
print(findit('kev', lookup, data))
print(findit('Rob', lookup, data))

结果：

25
37

Answer 3

所以您说的是等价类，其中等价关系可能是子字符串或不区分大小写的等价，并且您将同一等价类中的元素映射到相同的值。除非有办法将相同等价类的元素一致地转换为唯一代表，否则这里的字典是无用的，只会产生不必要的开销。如果是这种情况，请使用更简单的数据结构，例如元组列表。每次您需要进行更新时，您都会遍历整个列表，对每个元素进行等效性测试。

也就是说，最好的办法是找出一种有效的算法来将元素转换为其等价代表，然后使用字典。这就像只有在您能够为您的场景找出有效的哈希函数时才使用哈希表。