仅在满足条件的情况下添加到dict

我正在使用urllib.urlencode构建Web POST参数，但是，如果None它们不存在其他值，我只想添加一些值。

apple = 'green'
orange = 'orange'
params = urllib.urlencode({
    'apple': apple,
    'orange': orange
})

效果很好，但是如果我将orange变量设置为可选，如何防止将其添加到参数中？这样的东西（伪代码）：

apple = 'green'
orange = None
params = urllib.urlencode({
    'apple': apple,
    if orange: 'orange': orange
})

我希望这已经足够清楚了，有人知道如何解决吗？

创建初始字母后，您必须单独添加密钥dict：

params = {'apple': apple}
if orange is not None:
    params['orange'] = orange
params = urllib.urlencode(params)

Python没有语法将键定义为条件键；如果您已经按顺序拥有所有内容，则可以使用dict理解：

params = urllib.urlencode({k: v for k, v in (('orange', orange), ('apple', apple)) if v is not None})

但这不是很可读。

另一个选择是使用字典拆包，但是对于单个键来说，可读性不是那么高：

params = urllib.urlencode({
    'apple': apple,
    **({'orange': orange} if orange is not None else {})
})

我个人永远不会使用它，因为它太hacky了，而且不如使用单独的语句那么明确和清晰if。正如Python的禅宗所言：可读性至关重要。

为了搭载sqreept的答案，以下是该类的子类，dict其行为符合预期：

class DictNoNone(dict):
    def __setitem__(self, key, value):
        if key in self or value is not None:
            dict.__setitem__(self, key, value)


d = DictNoNone()
d["foo"] = None
assert "foo" not in d

这将允许将现有键的值更改为None，但是分配None给不存在的键是无操作的。如果你想设置的项目None，以除去从如果它已经存在的字典，你可以这样做：

def __setitem__(self, key, value):
    if value is None:
        if key in self:
            del self[key]
    else:
        dict.__setitem__(self, key, value)

如果在构造过程中传递它们，则None 可以获取的值。如果要避免这种情况，请添加一种__init__方法将其过滤掉：

def __init__(self, iterable=(), **kwargs):
    for k, v in iterable:
        if v is not None: self[k] = v
    for k, v in kwargs.iteritems():
        if v is not None: self[k] = v

您也可以通过编写使其通用，以便在创建字典时传递所需的条件：

class DictConditional(dict):
    def __init__(self, cond=lambda x: x is not None):
        self.cond = cond
    def __setitem__(self, key, value):
        if key in self or self.cond(value):
            dict.__setitem__(self, key, value)

d = DictConditional(lambda x: x != 0)
d["foo"] = 0   # should not create key
assert "foo" not in d

params = urllib.urlencode({
    'apple': apple,
    **({'orange': orange} if orange else {}),
})

相当老的问题，但这是使用以下事实的替代方法：用空的dict更新一个dict不会执行任何操作。

def urlencode_func(apple, orange=None):
    kwargs = locals().items()
    params = dict()
    for key, value in kwargs:
        params.update({} if value is None else {key: value})
    return urllib.urlencode(params)

我做到了 希望对您有所帮助。

apple = 23
orange = 10
a = {
    'apple' : apple,
    'orange' if orange else None : orange
}

预期产量： {'orange': 10, 'apple': 23}

虽然，如果orange = None，那么将只有一个条目None:None。例如考虑一下：

apple = 23
orange = None
a = {
    'apple' : apple,
    'orange' if orange else None : orange
}

预期产量： {None: None, 'apple': 23}

您可以在分配后清除无：

apple = 'green'
orange = None
dictparams = {
    'apple': apple,
    'orange': orange
}
for k in dictparams.keys():
    if not dictparams[k]:
        del dictparams[k]
params = urllib.urlencode(dictparams)

另一个有效的答案是，您可以创建自己的类似dict的容器，该容器不存储None值。

class MyDict:
    def __init__(self):
        self.container = {}
    def __getitem__(self, key):
        return self.container[key]
    def __setitem__(self, key, value):
        if value != None:
            self.container[key] = value
    def __repr__(self):
        return self.container.__repr__()

a = MyDict()
a['orange'] = 'orange';
a['lemon'] = None

print a

产量：

{'orange': 'orange'}

我真的很喜欢这里答案中的巧妙技巧：https：//stackoverflow.com/a/50311983/3124256

但是，它有一些陷阱：

1. 重复if测试（重复键和值）
2. 讨厌None: None的结果dict

为避免这种情况，可以执行以下操作：

apple = 23
orange = None
banana = None
a = {
    'apple' if apple else None: apple,
    'orange' if orange else None : orange,
    'banana' if banana else None: banana,
    None: None,
}
del a[None]

预期产量： {'apple': 23}

注意：该None: None条目确保两件事：

1. 该None键将始终存在（del会不会引发错误）
2. “无值”的内容在字典中将永远不存在（以防del以后忘记）

如果您不担心这些事情，则可以将其省略，然后将del包裹在其中try...except（或None在del输入之前检查键是否存在）。要另外选择地址2，您还可以对值（除了键）进行条件检查。

fruits = [("apple", get_apple()), ("orange", get_orange()), ...]

params = urllib.urlencode({ fruit: val for fruit, val in fruits if val is not None })

有一个违反直觉但可靠的技巧，可以重用您要排除的其他道具名称。

{
    'orange' if orange else 'apple': orange,
    'apple': apple,
}

在这种情况下，后一个“苹果”将覆盖前一个“苹果”，从而有效地将其删除。请注意，条件表达式应高于真实表达式。

您可以使用字典理解来使用单个条件处理所有可选项目：

apple = "red"
orange = None
dictparams = {
    key: value for key, value in
    {
        "apple": apple,
        "orange": orange
    }.items()
    if value is not None
}

该dictparams结果将不包含"orange"在这种情况下，由于orange是None：

{'apple': 'green'}