Question

a = random number

b = magic number

if a < b:
    print(True)
if a > b:
    print(True)

outputs: True /n True

对于变量a中的所有值，它将始终传递任何大于或小于条件的值。

我主要需要它来递归，所以我可以创建一个递归函数，它接受一个嵌套列表，返回最大值和最小值。

目前我有这个并且想知道是否有任何方法可以使它更清洁：

def max_min(L):
    '''
    >>> L = [1, [], [45, [32]]]
    >>> max_min(L)
    (45,1)
    '''
    if L == []:
        result = (None, None)
    elif type(L[0]) == list:
        first, second = max_min(L[0])
        max, min = max_min(L[1:])
        if first != None:
            if max != None:
                if first > max:
                    max = first
            else:
                max = first
            if min != None:
                if first < min:
                    min = first
            else:
                min = first
        if second != None:
            if max != None:
                if second > max:
                    max = second
            else:
                max = second
            if min != None:
                if second < min:
                    min = second
            else:
                min = second
        result = (max, min)
    else:
        first = L[0]
        max, min = max_min(L[1:])
        if max != None:
            if first > max:
                max = first
        else:
            max = first
        if min != None:    
            if first < min:
                min = first
        else:
            min = first
        result = (max, min)
    return result

Answer 1

简单的答案是否定的。

您可以拥有一个包含True值的名称，并根据需要进行检查，但它始终是真的......但是您可以将其设置为无，否则将被评估为{{ 1}}。

因此，如果需要，您可以将变量设置为False或True，而不是将变量设置为此幻数。

我看到你发布了一个例子，我会经历这个。

编辑：要清理您的示例，您可以使用以下命令启动您的功能： None（或任何更好的本地函数）。

那样，不需要连续检查是否一切都是无。

Answer 2

您可以使用生成器递归flatten()列表，这意味着您只需浏览一次列表，例如：

In []:
def flatten(iterable):
    for item in iterable:
        if isinstance(item, Iterable) and not isinstance(item, (str, bytes)):
            yield from flatten(item)
        else:
            yield item

def max_min(L):
    f = flatten(L)
    try:
        min_ = max_ = next(f)
    except StopIteration:
        return None, None

    for x in f:
        if x < min_:
            min_ = x
        elif x > max_:
            max_ = x
    return max_, min_

max_min([1, [], [45, [32]]])

Out[]:
(45, 1)

您可以将它们组合成一个功能：

In []:
def max_min(iterable):
    max_ = min_ = None
    for item in iterable:
        if isinstance(item, Iterable):
            x, y = max_min(item)
        else:
            x = y = item

        if max_ is None or (x and x > max_):
            max_ = x
        if min_ is None or (y and y < min_):
            min_ = y

    return max_, min_

max_min([1, [], [45, [32]]])

Out[]:
(45, 1)

In []:
max_min([])

Out[]:
(None, None)

有没有办法得到一个总是会返回True的数字，无论是否＆gt;或者＆lt;比一个整数？

2 个答案: