多键多值非确定性 python 字典
Multikey Multivalue Non Deterministic python dictionary
python 中已经有一个 multi key dict 和一个多值字典。我需要一个 python 字典，它是：
示例：
# probabilistically fetch any one of baloon, toy or car
d['red','blue','green']== "baloon" or "car" or "toy"
d['red']==d['green']的概率高，d['red']!=d['red']的概率低但可能
单个输出值应该根据键的规则以概率方式确定（模糊）
eg:in 以上案例规则可能是如果键同时具有 "red" 和 "blue" 那么 return "baloon" 80% 的时间如果只有蓝色那么 return "toy" 15% 的时间 其他 "car" 5% 的时间。
setitem 方法应设计成以下可能：
d["red", "blue"] =[
("baloon",haseither('red','green'),0.8),
("toy",.....)
,....
]
上面使用谓词函数和相应的概率将多个值分配给字典。而不是上面的分配列表，甚至字典作为分配将是更可取的：
d["red", "blue"] ={
"baloon": haseither('red','green',0.8),
"toy": hasonly("blue",0.15),
"car": default(0.05)
}
在上面的气球中，如果 "red" 或存在绿色，则 80% 的时间会 returned
, return 玩具 15% 的时间如果蓝色出现和 return 汽车 5% 的时间没有任何条件。
在python中是否有已经满足上述要求的现有数据结构？如果不是那么如何修改 multikeydict 代码以满足 python?
中的上述要求
如果使用字典，则可以有一个配置文件或使用适当的嵌套装饰器来配置上述概率谓词逻辑，而无需硬编码 if \else 语句。
注意：以上是基于规则的自动回复应用程序的有用自动机，因此如果任何类似的基于规则的框架在 python 中可用，请告诉我，即使它不使用字典结构？
如果可以更改数据结构，让函数返回您需要的数据会更简单。这将是完全灵活的，可以容纳任何类型的数据，如果您以后需要更改它们的话。
import random
def myfunc(*args):
if 'red' in args:
return 'blue'
elif 'green' in args or 'violet' in args:
return 'violet'
else:
r = random.random()
if 0 < r < 0.2:
return 'blue'
else:
return 'green'
print(myfunc('green', 'blue'))
print(myfunc('yellow'))
输出（第二行明显变了）：
violet
blue
the single output value should be probabilistically determined (fuzzy) based on a rule from keys eg:in above case rule could be if keys have both "red" and "blue" then return "baloon" 80% of time if only blue then return "toy" 15% of time else "car" 5% of time.
请记住，您的案例分析不完整，而且模棱两可，但您可以执行以下操作"in spirit"（充实所需的结果）：
import random
def randomly_return(*colors):
colors = set(*colors)
if 'red' in colors and 'blue' in colors:
if random.random() < 0.8: # 80 % of the time
return "baloon"
if 'blue' in colors and len(colors) == 1: # only blue in colors
if random.random() < 0.15:
return "toy"
else:
if random.random() < 0.05:
return "car"
# other cases to consider
我会保留它作为一个函数，因为它是一个函数！但是如果你坚持让它像 dict 一样，那么 python 让你通过覆盖 __getitem__ 来做到这一点（IMO 它不是 pythonic）。
class RandomlyReturn(object):
def __getitem__(self, *colors):
return randomly_return(*colors)
>>> r = RandomlyReturn()
>>> r["red", "blue"] # 80% of the time it'll return "baloon"
"baloon"
根据您的说明，OP 想要传递并生成：
randreturn((haseither(red,blue),baloon:0.8),((hasonly(blue),toy:0.15)),(default(),car:0.05)))
您想生成如下函数：
funcs = {"haseither": lambda needles, haystack: any(n in haystack for n in needles),
"hasonly": lambda needles, haystack: len(needles) == 1 and needles[1] in haystack}
def make_random_return(crits, default):
def random_return(*colors):
colors = set(*colors)
for c in crits:
if funcs[c["func"]](c["args"], colors) and random.random() > c["with_prob"]:
return c["return_value"]
return default
return random_return
在这种情况下暴击和默认是：
crit = [{"func": "haseither", "args": ("red", "blue"), "return_value": "baloon", "with_prob": 0.8}, ...]
default = "car" # ??
my_random_return = make_random_return(crits, default)
正如我所说，你的概率 ambiguous/don 不相加，所以你很可能需要调整这个...
您可以通过在实例化时传递 crit 和 default 来扩展 class 定义：
class RandomlyReturn(object):
def __init__(self, crit, default):
self.randomly_return = make_random_return(crit, default)
def __getitem__(self, *colors):
return self.randomly_return(*colors)
>>> r = RandomlyReturn(crit, default)
>>> r["red", "blue"] # 80% of the time it'll return "baloon"
"baloon"
模拟多键字典
multi_key_dict did not allow __getitem__() 一次有多个键...
（例如 d["red", "green"]）
可以用tuple or set keys. If order does not matter, set seems the best (actually the hashable frozen set模拟一个多键，这样["red", "blue"]就和["blue", "red"]一样了。
模拟 MultiVal 字典
多个值是使用某些数据类型所固有的，可以any storage element that may be conveniently indexed. A standard dict应该提供。
非确定性
使用由规则和假设定义的概率分布1，使用 python 文档中的 this recipe 执行非确定性选择。
MultiKeyMultiValNonDeterministicDict Class
好名字。 \o/-不错！
此 class 采用多个键，这些键定义了多个值的概率规则集。在项目创建过程中 (__setitem__()) all value probabilities are precomputed for all combinations of keys1. During item access (__getitem__()) 选择预先计算的概率分布，并根据随机加权选择评估结果。
定义
import random
import operator
import bisect
import itertools
# or use itertools.accumulate in python 3
def accumulate(iterable, func=operator.add):
'Return running totals'
# accumulate([1,2,3,4,5]) --> 1 3 6 10 15
# accumulate([1,2,3,4,5], operator.mul) --> 1 2 6 24 120
it = iter(iterable)
try:
total = next(it)
except StopIteration:
return
yield total
for element in it:
total = func(total, element)
yield total
class MultiKeyMultiValNonDeterministicDict(dict):
def key_combinations(self, keys):
"""get all combinations of keys"""
return [frozenset(subset) for L in range(0, len(keys)+1) for subset in itertools.combinations(keys, L)]
def multi_val_rule_prob(self, rules, rule):
"""
assign probabilities for each value,
spreading undefined result probabilities
uniformly over the leftover results not defined by rule.
"""
all_results = set([result for result_probs in rules.values() for result in result_probs])
prob = rules[rule]
leftover_prob = 1.0 - sum([x for x in prob.values()])
leftover_results = len(all_results) - len(prob)
for result in all_results:
if result not in prob:
# spread undefined prob uniformly over leftover results
prob[result] = leftover_prob/leftover_results
return prob
def multi_key_rule_prob(self, key, val):
"""
assign probability distributions for every combination of keys,
using the default for combinations not defined in rule set
"""
combo_probs = {}
for combo in self.key_combinations(key):
if combo in val:
result_probs = self.multi_val_rule_prob(val, combo).items()
else:
result_probs = self.multi_val_rule_prob(val, frozenset([])).items()
combo_probs[combo] = result_probs
return combo_probs
def weighted_random_choice(self, weighted_choices):
"""make choice from weighted distribution"""
choices, weights = zip(*weighted_choices)
cumdist = list(accumulate(weights))
return choices[bisect.bisect(cumdist, random.random() * cumdist[-1])]
def __setitem__(self, key, val):
"""
set item in dictionary,
assigns values to keys with precomputed probability distributions
"""
precompute_val_probs = self.multi_key_rule_prob(key, val)
# use to show ALL precomputed probabilities for key's rule set
# print precompute_val_probs
dict.__setitem__(self, frozenset(key), precompute_val_probs)
def __getitem__(self, key):
"""
get item from dictionary,
randomly select value based on rule probability
"""
key = frozenset([key]) if isinstance(key, str) else frozenset(key)
val = None
weighted_val = None
if key in self.keys():
val = dict.__getitem__(self, key)
weighted_val = val[key]
else:
for k in self.keys():
if key.issubset(k):
val = dict.__getitem__(self, k)
weighted_val = val[key]
# used to show probabality for key
# print weighted_val
if weighted_val:
prob_results = self.weighted_random_choice(weighted_val)
else:
prob_results = None
return prob_results
用法
d = MultiKeyMultiValNonDeterministicDict()
d["red","blue","green"] = {
# {rule_set} : {result: probability}
frozenset(["red", "green"]): {"ballon": 0.8},
frozenset(["blue"]): {"toy": 0.15},
frozenset([]): {"car": 0.05}
}
测试
检查概率
N = 10000
red_green_test = {'car':0.0, 'toy':0.0, 'ballon':0.0}
red_blue_test = {'car':0.0, 'toy':0.0, 'ballon':0.0}
blue_test = {'car':0.0, 'toy':0.0, 'ballon':0.0}
red_blue_green_test = {'car':0.0, 'toy':0.0, 'ballon':0.0}
default_test = {'car':0.0, 'toy':0.0, 'ballon':0.0}
for _ in xrange(N):
red_green_test[d["red","green"]] += 1.0
red_blue_test[d["red","blue"]] += 1.0
blue_test[d["blue"]] += 1.0
default_test[d["green"]] += 1.0
red_blue_green_test[d["red","blue","green"]] += 1.0
print 'red,green test =', ' '.join('{0}: {1:05.2f}%'.format(key, 100.0*val/N) for key, val in red_green_test.items())
print 'red,blue test =', ' '.join('{0}: {1:05.2f}%'.format(key, 100.0*val/N) for key, val in red_blue_test.items())
print 'blue test =', ' '.join('{0}: {1:05.2f}%'.format(key, 100.0*val/N) for key, val in blue_test.items())
print 'default test =', ' '.join('{0}: {1:05.2f}%'.format(key, 100.0*val/N) for key, val in default_test.items())
print 'red,blue,green test =', ' '.join('{0}: {1:05.2f}%'.format(key, 100.0*val/N) for key, val in red_blue_green_test.items())
red,green test = car: 09.89% toy: 10.06% ballon: 80.05%
red,blue test = car: 05.30% toy: 47.71% ballon: 46.99%
blue test = car: 41.69% toy: 15.02% ballon: 43.29%
default test = car: 05.03% toy: 47.16% ballon: 47.81%
red,blue,green test = car: 04.85% toy: 49.20% ballon: 45.95%
概率匹配规则！
脚注
分布假设
由于规则集未完全定义，因此对概率分布进行了假设，其中大部分是在 multi_val_rule_prob() 中完成的。基本上任何未定义的概率都将均匀分布在其余值上。这是针对 所有 键组合完成的，并为随机加权选择创建通用键接口。
给定示例规则集
d["red","blue","green"] = {
# {rule_set} : {result: probability}
frozenset(["red", "green"]): {"ballon": 0.8},
frozenset(["blue"]): {"toy": 0.15},
frozenset([]): {"car": 0.05}
}
这将创建以下分布
'red' = [('car', 0.050), ('toy', 0.475), ('ballon', 0.475)]
'green' = [('car', 0.050), ('toy', 0.475), ('ballon', 0.475)]
'blue' = [('car', 0.425), ('toy', 0.150), ('ballon', 0.425)]
'blue,red' = [('car', 0.050), ('toy', 0.475), ('ballon', 0.475)]
'green,red' = [('car', 0.098), ('toy', 0.098), ('ballon', 0.800)]
'blue,green' = [('car', 0.050), ('toy', 0.475), ('ballon', 0.475)]
'blue,green,red'= [('car', 0.050), ('toy', 0.475), ('ballon', 0.475)]
default = [('car', 0.050), ('toy', 0.475), ('ballon', 0.475)]
如有不妥，请指教
OP 想要如下，
d["red", "blue"] ={
"baloon": haseither('red','green',0.8),
"toy": hasonly("blue",0.15),
"car": default(0.05)
}
但这是具有嵌入式逻辑的数据。为每个值定义一个函数是非常乏味的。我的建议是将数据和逻辑分开。
Python 有一个数据类型，即 class。 class 的可调用实例可以分配给 dict 并让 dict 传递键并调用对象以 return 结果。
我继承并扩展了multiple_key_dict，支持多键获取，将键传给对象，调用存储在dict中的对象。
我假设数据是根据规则重新计算的。这是 Rule class，它有规则列表。规则是一个 Python 表达式，它可以访问 len 函数和 keys 列表。所以可以写一个像 len(keys) == 1 and 'blue' in keys 这样的规则。
class Rule(object):
def __init__(self, rule, data):
self.rule = rule
self.data = data
这是Data class，既有数据集又有规则。
class Data(object):
def __init__(self, rules):
self.rules= rules
def make_choice(self, data):
data = tuple(self.make_list_of_values(data))
return random.choice(data)
def make_list_of_values(self, data):
for val, weight in data:
percent = int(weight * 100)
for v in [val] * percent:
yield v
def __call__(self, keys):
for rule in self.rules:
if eval(rule.rule,dict(keys=keys)):
return self.make_choice(rule.data)
这是RuleDict，但无法获取非可调用文件。
class RuleDict(multi_key_dict):
def __init__(self, *args, **kwargs):
multi_key_dict.__init__(self, *args, **kwargs)
def __getitem__(self, keys):
if isinstance(keys, str):
keys = (keys, )
keys_set = frozenset(keys)
for key in self.keys():
key = frozenset(key)
if keys_set <= key:
return multi_key_dict.__getitem__(self,keys[0])(keys)
raise KeyError(keys)
用法示例，
d = RuleDict()
rule1 = Rule('"red" in keys and "green" in keys',(('baloon',0.8), ('car',0.05), ('toy',0.15)))
rule2 = Rule('len(keys) ==1 and "blue" in keys',(('baloon',0.25), ('car',0.35), ('toy',0.15)))
data = Data((rule1, rule2))
d['red','blue','green'] = data
print(d['red','green'])
d['red','green'] 使用分配的键和 return 结果调用对象。
另一种方法是使 dict 可调用。这似乎是一种合理的方法，因为数据和逻辑是分开的。通过这种方式，您将键和逻辑（可调用）传递给 dict 和 return 结果。 f.e.,
def f(keys, data):
pass # do the logic and return data
d['red','blue','green'] = ('baloon', 'car', 'toy')
现在调用 dict
d(('red','blue'),f)
这是可调用的 dict。如果没有给出可调用对象，则仅 returns 整个数据。
class callable_mkd(multi_key_dict):
def __init__(self, *args, **kwargs):
multi_key_dict.__init__(self, *args, **kwargs)
def __call__(self, keys, process=None):
keys_set = frozenset(keys)
for key in self.keys():
key = frozenset(key)
if keys_set <= key:
if process:
return process(keys, self[keys[0]])
return self[keys[0]]
raise KeyError(keys)
python 中已经有一个 multi key dict 和一个多值字典。我需要一个 python 字典，它是：
示例：
# probabilistically fetch any one of baloon, toy or car
d['red','blue','green']== "baloon" or "car" or "toy"
d['red']==d['green']的概率高，d['red']!=d['red']的概率低但可能
单个输出值应该根据键的规则以概率方式确定（模糊） eg:in 以上案例规则可能是如果键同时具有 "red" 和 "blue" 那么 return "baloon" 80% 的时间如果只有蓝色那么 return "toy" 15% 的时间 其他 "car" 5% 的时间。
setitem 方法应设计成以下可能：
d["red", "blue"] =[
("baloon",haseither('red','green'),0.8),
("toy",.....)
,....
]
上面使用谓词函数和相应的概率将多个值分配给字典。而不是上面的分配列表，甚至字典作为分配将是更可取的：
d["red", "blue"] ={
"baloon": haseither('red','green',0.8),
"toy": hasonly("blue",0.15),
"car": default(0.05)
}
在上面的气球中，如果 "red" 或存在绿色，则 80% 的时间会 returned , return 玩具 15% 的时间如果蓝色出现和 return 汽车 5% 的时间没有任何条件。
在python中是否有已经满足上述要求的现有数据结构？如果不是那么如何修改 multikeydict 代码以满足 python?
中的上述要求如果使用字典，则可以有一个配置文件或使用适当的嵌套装饰器来配置上述概率谓词逻辑，而无需硬编码 if \else 语句。
注意：以上是基于规则的自动回复应用程序的有用自动机，因此如果任何类似的基于规则的框架在 python 中可用，请告诉我，即使它不使用字典结构？
如果可以更改数据结构，让函数返回您需要的数据会更简单。这将是完全灵活的，可以容纳任何类型的数据，如果您以后需要更改它们的话。
import random
def myfunc(*args):
if 'red' in args:
return 'blue'
elif 'green' in args or 'violet' in args:
return 'violet'
else:
r = random.random()
if 0 < r < 0.2:
return 'blue'
else:
return 'green'
print(myfunc('green', 'blue'))
print(myfunc('yellow'))
输出（第二行明显变了）：
violet
blue
the single output value should be probabilistically determined (fuzzy) based on a rule from keys eg:in above case rule could be if keys have both "red" and "blue" then return "baloon" 80% of time if only blue then return "toy" 15% of time else "car" 5% of time.
请记住，您的案例分析不完整，而且模棱两可，但您可以执行以下操作"in spirit"（充实所需的结果）：
import random
def randomly_return(*colors):
colors = set(*colors)
if 'red' in colors and 'blue' in colors:
if random.random() < 0.8: # 80 % of the time
return "baloon"
if 'blue' in colors and len(colors) == 1: # only blue in colors
if random.random() < 0.15:
return "toy"
else:
if random.random() < 0.05:
return "car"
# other cases to consider
我会保留它作为一个函数，因为它是一个函数！但是如果你坚持让它像 dict 一样，那么 python 让你通过覆盖 __getitem__ 来做到这一点（IMO 它不是 pythonic）。
class RandomlyReturn(object):
def __getitem__(self, *colors):
return randomly_return(*colors)
>>> r = RandomlyReturn()
>>> r["red", "blue"] # 80% of the time it'll return "baloon"
"baloon"
根据您的说明，OP 想要传递并生成：
randreturn((haseither(red,blue),baloon:0.8),((hasonly(blue),toy:0.15)),(default(),car:0.05)))
您想生成如下函数：
funcs = {"haseither": lambda needles, haystack: any(n in haystack for n in needles),
"hasonly": lambda needles, haystack: len(needles) == 1 and needles[1] in haystack}
def make_random_return(crits, default):
def random_return(*colors):
colors = set(*colors)
for c in crits:
if funcs[c["func"]](c["args"], colors) and random.random() > c["with_prob"]:
return c["return_value"]
return default
return random_return
在这种情况下暴击和默认是：
crit = [{"func": "haseither", "args": ("red", "blue"), "return_value": "baloon", "with_prob": 0.8}, ...]
default = "car" # ??
my_random_return = make_random_return(crits, default)
正如我所说，你的概率 ambiguous/don 不相加，所以你很可能需要调整这个...
您可以通过在实例化时传递 crit 和 default 来扩展 class 定义：
class RandomlyReturn(object):
def __init__(self, crit, default):
self.randomly_return = make_random_return(crit, default)
def __getitem__(self, *colors):
return self.randomly_return(*colors)
>>> r = RandomlyReturn(crit, default)
>>> r["red", "blue"] # 80% of the time it'll return "baloon"
"baloon"
模拟多键字典
multi_key_dict did not allow __getitem__() 一次有多个键...
（例如 d["red", "green"]）
可以用tuple or set keys. If order does not matter, set seems the best (actually the hashable frozen set模拟一个多键，这样["red", "blue"]就和["blue", "red"]一样了。
模拟 MultiVal 字典
多个值是使用某些数据类型所固有的，可以any storage element that may be conveniently indexed. A standard dict应该提供。
非确定性
使用由规则和假设定义的概率分布1，使用 python 文档中的 this recipe 执行非确定性选择。
MultiKeyMultiValNonDeterministicDict Class
好名字。 \o/-不错！
此 class 采用多个键，这些键定义了多个值的概率规则集。在项目创建过程中 (__setitem__()) all value probabilities are precomputed for all combinations of keys1. During item access (__getitem__()) 选择预先计算的概率分布，并根据随机加权选择评估结果。
定义
import random
import operator
import bisect
import itertools
# or use itertools.accumulate in python 3
def accumulate(iterable, func=operator.add):
'Return running totals'
# accumulate([1,2,3,4,5]) --> 1 3 6 10 15
# accumulate([1,2,3,4,5], operator.mul) --> 1 2 6 24 120
it = iter(iterable)
try:
total = next(it)
except StopIteration:
return
yield total
for element in it:
total = func(total, element)
yield total
class MultiKeyMultiValNonDeterministicDict(dict):
def key_combinations(self, keys):
"""get all combinations of keys"""
return [frozenset(subset) for L in range(0, len(keys)+1) for subset in itertools.combinations(keys, L)]
def multi_val_rule_prob(self, rules, rule):
"""
assign probabilities for each value,
spreading undefined result probabilities
uniformly over the leftover results not defined by rule.
"""
all_results = set([result for result_probs in rules.values() for result in result_probs])
prob = rules[rule]
leftover_prob = 1.0 - sum([x for x in prob.values()])
leftover_results = len(all_results) - len(prob)
for result in all_results:
if result not in prob:
# spread undefined prob uniformly over leftover results
prob[result] = leftover_prob/leftover_results
return prob
def multi_key_rule_prob(self, key, val):
"""
assign probability distributions for every combination of keys,
using the default for combinations not defined in rule set
"""
combo_probs = {}
for combo in self.key_combinations(key):
if combo in val:
result_probs = self.multi_val_rule_prob(val, combo).items()
else:
result_probs = self.multi_val_rule_prob(val, frozenset([])).items()
combo_probs[combo] = result_probs
return combo_probs
def weighted_random_choice(self, weighted_choices):
"""make choice from weighted distribution"""
choices, weights = zip(*weighted_choices)
cumdist = list(accumulate(weights))
return choices[bisect.bisect(cumdist, random.random() * cumdist[-1])]
def __setitem__(self, key, val):
"""
set item in dictionary,
assigns values to keys with precomputed probability distributions
"""
precompute_val_probs = self.multi_key_rule_prob(key, val)
# use to show ALL precomputed probabilities for key's rule set
# print precompute_val_probs
dict.__setitem__(self, frozenset(key), precompute_val_probs)
def __getitem__(self, key):
"""
get item from dictionary,
randomly select value based on rule probability
"""
key = frozenset([key]) if isinstance(key, str) else frozenset(key)
val = None
weighted_val = None
if key in self.keys():
val = dict.__getitem__(self, key)
weighted_val = val[key]
else:
for k in self.keys():
if key.issubset(k):
val = dict.__getitem__(self, k)
weighted_val = val[key]
# used to show probabality for key
# print weighted_val
if weighted_val:
prob_results = self.weighted_random_choice(weighted_val)
else:
prob_results = None
return prob_results
用法
d = MultiKeyMultiValNonDeterministicDict()
d["red","blue","green"] = {
# {rule_set} : {result: probability}
frozenset(["red", "green"]): {"ballon": 0.8},
frozenset(["blue"]): {"toy": 0.15},
frozenset([]): {"car": 0.05}
}
测试
检查概率
N = 10000
red_green_test = {'car':0.0, 'toy':0.0, 'ballon':0.0}
red_blue_test = {'car':0.0, 'toy':0.0, 'ballon':0.0}
blue_test = {'car':0.0, 'toy':0.0, 'ballon':0.0}
red_blue_green_test = {'car':0.0, 'toy':0.0, 'ballon':0.0}
default_test = {'car':0.0, 'toy':0.0, 'ballon':0.0}
for _ in xrange(N):
red_green_test[d["red","green"]] += 1.0
red_blue_test[d["red","blue"]] += 1.0
blue_test[d["blue"]] += 1.0
default_test[d["green"]] += 1.0
red_blue_green_test[d["red","blue","green"]] += 1.0
print 'red,green test =', ' '.join('{0}: {1:05.2f}%'.format(key, 100.0*val/N) for key, val in red_green_test.items())
print 'red,blue test =', ' '.join('{0}: {1:05.2f}%'.format(key, 100.0*val/N) for key, val in red_blue_test.items())
print 'blue test =', ' '.join('{0}: {1:05.2f}%'.format(key, 100.0*val/N) for key, val in blue_test.items())
print 'default test =', ' '.join('{0}: {1:05.2f}%'.format(key, 100.0*val/N) for key, val in default_test.items())
print 'red,blue,green test =', ' '.join('{0}: {1:05.2f}%'.format(key, 100.0*val/N) for key, val in red_blue_green_test.items())
red,green test = car: 09.89% toy: 10.06% ballon: 80.05%
red,blue test = car: 05.30% toy: 47.71% ballon: 46.99%
blue test = car: 41.69% toy: 15.02% ballon: 43.29%
default test = car: 05.03% toy: 47.16% ballon: 47.81%
red,blue,green test = car: 04.85% toy: 49.20% ballon: 45.95%
概率匹配规则！
脚注
分布假设
由于规则集未完全定义，因此对概率分布进行了假设，其中大部分是在
multi_val_rule_prob()中完成的。基本上任何未定义的概率都将均匀分布在其余值上。这是针对 所有 键组合完成的，并为随机加权选择创建通用键接口。给定示例规则集
d["red","blue","green"] = { # {rule_set} : {result: probability} frozenset(["red", "green"]): {"ballon": 0.8}, frozenset(["blue"]): {"toy": 0.15}, frozenset([]): {"car": 0.05} }这将创建以下分布
'red' = [('car', 0.050), ('toy', 0.475), ('ballon', 0.475)] 'green' = [('car', 0.050), ('toy', 0.475), ('ballon', 0.475)] 'blue' = [('car', 0.425), ('toy', 0.150), ('ballon', 0.425)] 'blue,red' = [('car', 0.050), ('toy', 0.475), ('ballon', 0.475)] 'green,red' = [('car', 0.098), ('toy', 0.098), ('ballon', 0.800)] 'blue,green' = [('car', 0.050), ('toy', 0.475), ('ballon', 0.475)] 'blue,green,red'= [('car', 0.050), ('toy', 0.475), ('ballon', 0.475)] default = [('car', 0.050), ('toy', 0.475), ('ballon', 0.475)]如有不妥，请指教
OP 想要如下，
d["red", "blue"] ={
"baloon": haseither('red','green',0.8),
"toy": hasonly("blue",0.15),
"car": default(0.05)
}
但这是具有嵌入式逻辑的数据。为每个值定义一个函数是非常乏味的。我的建议是将数据和逻辑分开。
Python 有一个数据类型，即 class。 class 的可调用实例可以分配给 dict 并让 dict 传递键并调用对象以 return 结果。
我继承并扩展了multiple_key_dict，支持多键获取，将键传给对象，调用存储在dict中的对象。
我假设数据是根据规则重新计算的。这是 Rule class，它有规则列表。规则是一个 Python 表达式，它可以访问 len 函数和 keys 列表。所以可以写一个像 len(keys) == 1 and 'blue' in keys 这样的规则。
class Rule(object):
def __init__(self, rule, data):
self.rule = rule
self.data = data
这是Data class，既有数据集又有规则。
class Data(object):
def __init__(self, rules):
self.rules= rules
def make_choice(self, data):
data = tuple(self.make_list_of_values(data))
return random.choice(data)
def make_list_of_values(self, data):
for val, weight in data:
percent = int(weight * 100)
for v in [val] * percent:
yield v
def __call__(self, keys):
for rule in self.rules:
if eval(rule.rule,dict(keys=keys)):
return self.make_choice(rule.data)
这是RuleDict，但无法获取非可调用文件。
class RuleDict(multi_key_dict):
def __init__(self, *args, **kwargs):
multi_key_dict.__init__(self, *args, **kwargs)
def __getitem__(self, keys):
if isinstance(keys, str):
keys = (keys, )
keys_set = frozenset(keys)
for key in self.keys():
key = frozenset(key)
if keys_set <= key:
return multi_key_dict.__getitem__(self,keys[0])(keys)
raise KeyError(keys)
用法示例，
d = RuleDict()
rule1 = Rule('"red" in keys and "green" in keys',(('baloon',0.8), ('car',0.05), ('toy',0.15)))
rule2 = Rule('len(keys) ==1 and "blue" in keys',(('baloon',0.25), ('car',0.35), ('toy',0.15)))
data = Data((rule1, rule2))
d['red','blue','green'] = data
print(d['red','green'])
d['red','green'] 使用分配的键和 return 结果调用对象。
另一种方法是使 dict 可调用。这似乎是一种合理的方法，因为数据和逻辑是分开的。通过这种方式，您将键和逻辑（可调用）传递给 dict 和 return 结果。 f.e.,
def f(keys, data):
pass # do the logic and return data
d['red','blue','green'] = ('baloon', 'car', 'toy')
现在调用 dict
d(('red','blue'),f)
这是可调用的 dict。如果没有给出可调用对象，则仅 returns 整个数据。
class callable_mkd(multi_key_dict):
def __init__(self, *args, **kwargs):
multi_key_dict.__init__(self, *args, **kwargs)
def __call__(self, keys, process=None):
keys_set = frozenset(keys)
for key in self.keys():
key = frozenset(key)
if keys_set <= key:
if process:
return process(keys, self[keys[0]])
return self[keys[0]]
raise KeyError(keys)