为什么reduce（operator .__ not__，[True]）得到True？

Question

reduce(operator.__not__, [False]) # False
reduce(oeprator.__not__, [True]) # True

我为leetocde 1106写了一个解决方案。 将表达式分成由顶级“，”分隔的组；对于每个顶级子表达式（带有大括号的子字符串），对其进行处理并将其添加到相应的组中；最后将各组合并。

import operator, functools
class Solution:
    def parseBoolExpr(self, expression: str, op=None) -> bool:
        groups = []
        level = 0

        for i, c in enumerate(expression):
            if c == '(':
                if level == 0:
                    start = i + 1
                level += 1
            elif c == ')':
                level -= 1
                if level == 0:
                    groups.append(self.parseBoolExpr(expression[start:i], op))
            elif c == '&':
                op = operator.__and__
            elif c == '|':
                op = operator.__or__
            elif c == '!':
                op = operator.__not__
            elif level == 0:
                if c == 't':
                    groups.append(True)
                else:
                    groups.append(False)

        return functools.reduce(op, groups)

但不适用于operator.__not__

Answer 1

由于reduce接受一个接受2个参数的函数，因此序列具有1个元素的情况被视为返回单个元素的边缘情况（除非传递了initial参数）。

print(functools.reduce(lambda x, y: (x, y), [1]))
# 1
print(functools.reduce(lambda x, y: (x, y), [1], 'with an initial argument'))
# ('with an initial argument', 1)

此行为记录在docs中：

  

如果存在可选的初始化程序，则将其放置在计算中序列项的前面，并在序列为空时用作默认值。 如果未提供初始化程序，并且序列仅包含一项，则返回第一项。