返回 None 或元组并解包

Question

我总是对这个事实感到恼火：

$ cat foo.py
def foo(flag):
    if flag:
        return (1,2)
    else:
        return None

first, second = foo(True)
first, second = foo(False)

$ python foo.py
Traceback (most recent call last):
  File "foo.py", line 8, in <module>
    first, second = foo(False)
TypeError: 'NoneType' object is not iterable

事实是，为了顺利解压，我必须捕获 TypeError 或拥有类似的东西

values = foo(False)
if values is not None:
    first, second = values

这有点烦人。是否有改善这种情况的技巧（例如，在没有 foo 返回 (None, None) 的情况下将 first 和 second 都设置为 None ）或关于我提出的案例的最佳设计策略的建议？ *变量可能吗？

Answer 1

好吧，你可以这样做......

first,second = foo(True) or (None,None)
first,second = foo(False) or (None,None)

但据我所知，没有更简单的方法可以扩展 None 来填充整个元组。

Answer 2

我看不出返回 (None,None) 有什么问题。它比这里建议的解决方案要干净得多，因为这里涉及的代码更改要多得多。

您希望 None 自动拆分为 2 个变量也是没有意义的。

Answer 3

我认为抽象有问题。

函数应保持一定程度的抽象，这有助于降低代码的复杂性。
在这种情况下，要么函数没有维护正确的抽象，要么调用者不尊重它。

函数可能类似于get_point2d();在这种情况下，抽象级别在元组上，因此返回 None 将是表示某些特定情况（例如不存在的实体）的好方法。这种情况下的错误是期望两个项目，而实际上您唯一知道的是该函数返回一个对象（带有与 2d 点相关的信息）。

但它也可能是 get_two_values_from_db();在这种情况下，抽象将通过返回 None 来破坏，因为函数（顾名思义）应该返回两个值而不是一个！

无论哪种方式，使用函数的主要目标 - 降低复杂性 - 至少部分丢失了。

请注意，使用原始名称时，此问题不会清楚地显示出来；这也是为什么给函数和方法起好名字总是很重要的原因。

Answer 4

我不认为有什么技巧。您可以将调用代码简化为：

values = foo(False)
if values:
    first, second = values

甚至：

values = foo(False)
first, second = values or (first_default, second_default)

其中 first_default 和 second_default 是您赋予 first 和 second 作为默认值的值。

Answer 5

这个怎么样：

$ cat foo.py 
def foo(flag):
    if flag:
        return (1,2)
    else:
        return (None,)*2

first, second = foo(True)
first, second = foo(False)

编辑：需要明确的是，唯一的变化是将return None 替换为return (None,)*2。我非常惊讶没有其他人想到这一点。 （或者如果他们有，我想知道他们为什么不使用它。）

Answer 6

您应该小心x or y 风格的解决方案。它们有效，但它们比您的原始规范更广泛。本质上，如果foo(True) 返回一个空元组() 怎么办？只要您知道可以将其视为(None, None)，您就可以使用所提供的解决方案。

如果这是一个常见的场景，我可能会编写一个实用函数，例如：

# needs a better name! :)
def to_tup(t):
    return t if t is not None else (None, None)

first, second = to_tup(foo(True))
first, second = to_tup(foo(False))

Answer 7

def foo(flag):
    return ((1,2) if flag else (None, None))

Answer 8

好的，我会返回 (None, None)，但只要我们在 whacko-land (heh)，这里有一种使用元组子类的方法。在 else 的情况下，你不返回 None，而是返回一个空容器，这似乎符合事物的精神。容器的“迭代器”在空时解包 None 值。无论如何演示迭代器协议...

使用 v2.5.2 测试：

class Tuple(tuple):
    def __iter__(self):
        if self:
            # If Tuple has contents, return normal tuple iterator...
            return super(Tuple, self).__iter__()
        else:
            # Else return a bogus iterator that returns None twice...
            class Nonerizer(object):
                def __init__(self):
                    self.x=0
                def __iter__(self):
                    return self
                def next(self):
                    if self.x < 2:
                        self.x += 1
                        return None
                    else:
                        raise StopIteration
            return Nonerizer()


def foo(flag):
    if flag:
        return Tuple((1,2))
    else:
        return Tuple()  # It's not None, but it's an empty container.

first, second = foo(True)
print first, second
first, second = foo(False)
print first, second

输出是期望的：

1 2
None None

Answer 9

10 多年后，如果你想使用默认值，我认为没有比已经提供的更好的方法了：

first, second = foo(False) or (first_default, second_default)

但是，如果您想在返回 None 时跳过这种情况，从 Python 3.8 开始，您可以使用 walrus 运算符（即assignment expressions） - 另请注意简化的 @987654325 @：

def foo(flag):
    return (1, 2) if flag else None

if values := Foo(False):
    (first, second) = values

您可以使用else 分支来分配比之前的or 选项更差的默认值。

可悲的是，海象运算符does not support unparenthesized tuples 因此与以下相比仅是一条线的增益：

values = foo(False)
if values:
    first, second = values

Answer 10

当您可以控制方法 foo 时，您可以使用一种机制来完全避免该问题，即更改原型以允许提供默认值。如果您正在包装状态但不能保证存在特定的元组值，则此方法有效。

# self.r is for example, a redis cache

# This method is like foo - 
# it has trouble when you unpack a json serialized tuple
def __getitem__(self, key):
    val = self.r.get(key)
    if val is None:
        return None
    return json.loads(val)

# But this method allows the caller to 
# specify their own default value whether it be
# (None, None) or an entire object
def get(self, key, default):
    val = self.r.get(key)
    if val is None:
        return default
    return json.loads(val)

Answer 11

我找到了解决这个问题的方法：

返回 None 或返回一个对象。

但是，您不希望仅仅为了返回一个对象而编写一个类。为此，您可以使用 命名元组

像这样：

from collections import namedtuple
def foo(flag):
if flag:
   return None
else:
    MyResult = namedtuple('MyResult',['a','b','c']
    return MyResult._make([1,2,3])

然后：

result = foo(True) # result = True
result = foo(False) # result = MyResult(a=1, b=2, c=3)

您可以访问这样的结果：

print result.a # 1
print result.b # 2
print result.c # 3