仅在满足条件时才添加到字典

Question

我正在使用urllib.urlencode 来构建网络 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
})

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

Answer 1

在创建初始 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})

但这不是很可读。

如果您使用的是 Python 3.9 或更新版本，则可以使用 new dict merging operator support 和条件表达式：

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

但我发现可读性受到影响，因此可能仍会使用单独的 if 表达式：

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

另一种选择是使用dictionary unpacking，但对于单个键，它的可读性并不那么好：

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

我个人永远不会使用它，它太 hacky 并且不像使用单独的 if 语句那样明确和清晰。正如Zen of Python 所说：可读性很重要。

Answer 2

为了搭载 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

Answer 3

相当老的问题，但这里有一个替代方法，即使用空 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)

Answer 4

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

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}

Answer 5

我建议的一种技术是为此使用dictionary unpacking operatior。

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

说明

基本上，如果orange是None，那么上面的字典就简化为

{
    'apple': apple,
    **({})
}

# which results in just
{
    'apple': apple,
} 

如果orange 不是None，则相反：

{
    'apple': apple,
    **({ "orange": orange })
}

# which results in just
{
    'apple': apple,
    'orange': orange
} 

可读性是有条件地添加内联键的缺点。可以创建一个函数来帮助解决可读性问题。

from typing import Callable

def cond_pairs(
        cond: bool, pairs: Callable[[], dict],
) -> dict:
    return pairs() if cond else {}

{
    'apple': apple,
    **cond_pairs(orange, lambda: { 'orange': orange })
}

Answer 6

你可以在赋值后清除None：

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)

Answer 7

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

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'}

Answer 8

我发现使用generator function 更容易理解，也足够灵活。它也适用于 Python 2 和 3。

def generate_request_items(apple, orange):
    yield "apple", apple
    if orange:
        yield "orange", orange
    # Add additional conditionals and yield statements here


apple = 'green'
orange = None
params = urllib.urlencode(dict(generate_request_items(apple, orange)))

Answer 9

我真的很喜欢这里答案中的巧妙技巧：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. 'None values' 的内容永远不会存在于 dict 中（以防您之后忘记del）

如果您不担心这些事情，您可以将其排除在外，并将 del 包裹在 try...except 中（或检查 None 键是否存在于 deling 之前）。要解决第 2 个问题，您还可以对值（除了键）进行条件检查。

Answer 10

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

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

Answer 11

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

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

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

Answer 12

您可以使用字典推导式使用单个条件处理所有可选项目：

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'}