Question

我有这样的字典：

dict = {
        "AA": {"Rad": 1000.0, "Code": "C01"},
        "BB": {"Rad": 2200.0, "Code": "C02"},
        "CC": {"Rad": 2300.0, "Code": "C02"},
        "DD": {"Rad": 3000.0, "Code": "C04"}
    }

大多数情况下，选择合适的值非常简单。我的代码通过传入我需要的键和属性来从字典条目中获取值。例如，如果我的值是＆＃34; CC＆＃34;，我会得到dict["CC"]["Code"]的代码。很简单，绝大多数时间都可以使用。

现在，我需要调整业务逻辑的变化。如果我按照我过去所做的做法，字典将如下所示：

dict = {
        "AA": {"Rad": 1000.0, "Code": "C01"},
        "BB": {"Rad": 2200.0, "Code": "C02"},
        "CC": {"Rad": 2300.0, "Code": "C02"},
        "DD": {"Rad": 3000.0, "Code": "C04"},
        "DD": {"Rad": 7000.0, "Code": "C03"}
    }

但这不起作用。字典中的两个相同的键不起作用。这是问题一。

另一个问题是，在选择Rad时，我需要考虑Code的价值。 Rad是用于比较的最小值。如果我的变量中的值大于Rad，请使用相应的Code值。

如何对其进行重组以适应字典键（此代码所执行的大部分内容）的值检索以及key＆amp; Rad值？如果有必要，我可以通过这个词典结构并做一些不同的事情。

更新2：稍微改进业务逻辑。字典中指定的rad值是最小值。无论字典中列出的顺序如何，我都需要抓取大于最小值的最小值。

在以下情况中，

"DD": [{"Rad": 3000.0, "Code": "C04"},
       {"Rad": 7000.0, "Code": "C03"},
       {"Rad": 4000.0, "Code": "C09"}]]

get(d, "DD", 5000)返回C04，但预计会C09。

更新1：任何类型的数据库都对这个项目有点过分。这本词典最多只有六个条目。

以下是展示我尝试做的最小代码。

dict = {
        "AA": {"Rad": 1000.0, "Code": "C01"},
        "BB": {"Rad": 2200.0, "Code": "C02"},
        "CC": {"Rad": 2300.0, "Code": "C02"},
        "DD": {"Rad": 3000.0, "Code": "C04"},
        "DD": {"Rad": 7000.0, "Code": "C03"}
    }

type = "DD"
rad = 4000

# need to incorporate rad variable
print dict["type"]["Code"]  

# Should print C04

Answer 1

这样做的一种方法是按照以下方式构建字典：

dict = {
    "AA": {1000.0: "C01"},
    "BB": {2200.0: "C02"},
    "CC": {2300.0: "C02"},
    "DD": {3000.0: "C04",
           7000.0: "C03"},
}

然后，要获得Code字段，您可以编写dict["AA"][1000.0]。

Answer 2

子词典总是会有相同的两个字段吗？如果是这样，您可以将“Rad”和“Code”字段放入元组中，然后将元组放入列表中，如：

dict = {
            "AA": [(1000.0, "C01")]
            ...
            "DD": [(3000.0,"C04"), (7000.0, "C03")]

       }

要访问“DD”字段的第一个条目的“代码”字段，请使用：

dict["DD"][0][1]

Answer 3

您可以在字典列表中创建值，因此可以将一个键映射到多个值。

d = {
        "AA": [{"Rad": 1000.0, "Code": "C01"}],
        "BB": [{"Rad": 2200.0, "Code": "C02"}],
        "CC": [{"Rad": 2300.0, "Code": "C02"}],
        "DD": [{"Rad": 3000.0, "Code": "C04"}, {"Rad": 7000.0, "Code": "C03"}]
    }

要从列表中获取满足code约束的rad，您可以尝试这样做：

def get(d, t, r):
    try:
        return max((x for x in d[t] if x["Rad"] < r), key=lambda x: x["Rad"])["Code"]
    except ValueError:
        return None

示例：

>>> get(d, "DD", 4000)
C04

Answer 4

dict = {
        ...
        "DD": {4000:{"code":"C04"}, 7000: {"Code": "C03"}}
    }

Answer 5

您可以编写自定义类型类来执行此操作。

import itertools
import bisect

class cdict(dict):
    def __init__(self, data=None):
        dict.__init__(self)
        if data: self.update(data)

    def __call__(self,base,target):
        res = self.get(base) if base else None
        _st = res.items() if isinstance(res,dict) else res
        if isinstance(res,dict):
            if res and target:
                _item = res['Rad']
                if target >= _item: return res['Code']
        elif isinstance(res,list):
            _iter = sorted ( filter (lambda x: not isinstance(x,str),list (itertools.chain.from_iterable(map(lambda x: x.values(),res)))))
            if len(res) and target:
                _filter = filter (lambda x: x <= target,_iter)
                _sorted =  bisect.bisect(_filter,target)
                if len(_filter) and not _sorted: return filter (lambda x: x['Rad'] == _iter [ _sorted ],res)[0]['Code']
                elif len(_filter) and _sorted: return filter (lambda x: x['Rad'] == _iter [ _sorted -1 ],res)[0]['Code']
        return None

x = cdict({
    "AA": {"Rad": 1000.0, "Code": "C01"},
    "BB": {"Rad": 2200.0, "Code": "C02"},
    "CC": {"Rad": 2300.0, "Code": "C02"},
    "DD": [ {"Rad": 7000.0, "Code": "C04"}, {"Rad": 3000.0, "Code": "C03"} ] } )

print x('AA',2000.0)
print x('DD',8000.0)
print x('DD',4000.0)

C01 C04 C03

如何基于多个参数进行查找？

5 个答案: