Python：is_correct_sequence（不加倍）

Question

def is_correct_sequence(seq):
    """
    Check whether the given sequence does not contain
    the same value (except for None) more than once,
    and whether it only contains (1) integer values between 1
    and the length of the given sequence and/or (2) the special value None.
    """

    for i in range(len(seq)):
        if seq[i] < 1 or seq[i] > len(seq):
           return False
        elif type(seq[i]) != type(None) or type(seq[i]) != int:
            return False
        else:
            for i in range(len(seq)-1):
               for j in range(i+1, len(seq)):
                  if seq[i] == seq[j] != None:
                     return False
                  else:
                     return True

##TESTS

assert not is_correct_sequence((4, "abc", None, -17, None, "xyz"))
assert not is_correct_sequence((1, 2, 1))
assert not is_correct_sequence((1.0, None, 1))
assert is_correct_sequence((None, None, 4, 1))
assert is_correct_sequence((None, 1, 2, 3))

我对最后两个断言有问题，所以目标不是删除双打，而是查看顺序是否正确。 如果序列中的两个元素相同，则序列是不正确的，除了“无”（可能无数次出现）之外。 如何在我的代码中阐明这一点？

Answer 1

您的代码有一些问题。

一个主要问题是，您实际上从未检查过每个元素一次-当您的代码命中“ return”语句时，它会立即返回，而不检查其他所有语句。 当您需要返回False时，这是False ，因为如果任何时候都为False ，则无需检查序列的其余部分。

但是，当您返回True时，这是一个问题，因为您还没有排除以后该子序列可能不正确的情况。

另一个问题是if语句中的条件微不足道-尝试仔细查看并找出它们的实际作用。 考虑到这些因素，您的代码的正确版本将是：

def is_correct_sequence(seq):
    for i in range(len(seq)):
        if seq[i] is not None and (seq[i] <= 1 and seq[i] >= len(seq)):
            # This check previously failed if seq[i] was None, and did not
            # check the bounds properly
            return False
        elif seq[i] is not None and type(seq[i]) != int:
            # Use 'and', not 'or'
            return False
        else:
            for i in range(len(seq)-1):
                for j in range(i+1, len(seq)):
                    if seq[i] == seq[j] and seq[i] is not None and seq[j] is not None:
                        # Again, same thing. This failed if either seq[i] or seq[j]
                        # were not equal to None
                        return False
    return True

如代码中所述，您的主要问题不是检查项目是否等于“无”。 如果是这样，将其与数字进行比较时会得到奇怪的结果。

顺便说一句，要检查的正确方法如果一个元素是None或不None在Python是成语item is None或item is not None 。

但是，更简洁的代码编写方式可能是：

def is_correct_sequence(seq):
    nums = [a for a in seq if a is not None]
    allowed_types = (type(None), int)

    contains_correct_types = all(isinstance(a, allowed_types) for a in seq)
    numbers_within_bounds = all(1 <= a <= len(seq) for a in nums)
    numbers_are_unique = len(nums) == len(set(nums))
    # Set returns a version of a list with all duplicates removed

    return contains_correct_types and numbers_within_bounds and numbers_are_unique

而不是使用一个for循环中，我们可以使用列表内涵和发电机内涵以及内建的any和all的功能更清楚地表达你的代码的意图。

Answer 2

尝试通过以下方法，看是否有意义。 我仅使用您提供的断言对其进行了测试，并且似乎可以使用。

def is_correct_sequence(seq):
    return has_unique_values(seq) and has_correct_range(seq)

def has_unique_values(seq):
    """
    Check whether sequence contains the same value (excluding None) more than once

    Returns True if all values are unique or None, False otherwise.
    """

    nones = seq.count(None)
    seq_set = set(seq)

    if nones:
        if len(seq) != (len(seq_set) + nones - 1):
            return False
    else:
        if len(seq) != len(seq_set):
            return False

    return True

def has_correct_range(seq):
    """
    Check whether sequence contains integer values between 1 and the length
    of the given sequence and/or the special value None.
    """

    accepted_range = range(1, len(seq) + 1)
    for e in seq:
        if e not in accepted_range and e is not None:
            return False

    return True

assert not is_correct_sequence((4, "abc", None, -17, None, "xyz"))
assert not is_correct_sequence((1, 2, 1))
assert not is_correct_sequence((1.0, None, 1))
assert is_correct_sequence((None, None, 4, 1))
assert is_correct_sequence((None, 1, 2, 3))

Answer 3

这是一个通过所有断言的紧凑版本：

from collections import Counter

def is_correct_sequence(seq):

    len_seq = len(seq)
    counts = Counter(seq)

    for value, count in counts.items():

        # Never check None items
        if (value is not None and (

            # Does the value occur more than once
            # or has it a bad type (no integer)?
            (count > 1 or not isinstance(value, int)) or

            # Or is the integer not in the valid range?
            (value < 1 or value > len_seq))
            ):

            # Sequence is in correct!
            return False

    return True


assert not is_correct_sequence((4, "abc", None, -17, None, "xyz"))
assert not is_correct_sequence((1, 2, 1))
assert not is_correct_sequence((1.0, None, 1))
assert is_correct_sequence((None, None, 4, 1))
assert is_correct_sequence((None, 1, 2, 3))

你应该用

• isinstance()用于类型检查
• is None / is not None而不是== None / != None
• 对于这样的简单测试，没有嵌套循环（ collections.Counter应该使我的解决方案相当有效）