Python 我在埃拉托斯坦筛上的代码有问题

请参阅下面的代码。我一直收到一个错误代码，我也不明白它的意思。我可以在代码中的什么地方查看

def list_true(n):
    return [False for x in range(2)] + [x for x in range (2, n+1)]

assert len(list_true(20)) == 21
assert list_true(20)[0] is False
assert list_true(20)[1] is False


def mark_false(bool_list, p):
    mark_false = []
    for x in bool_list:
        if x/p == 1:
            mark_false.append(True)
        elif x % p == 0:
            mark_false.append(False)
        else:
            mark_false.append(True)
    return mark_false

assert mark_false(list_true(6), 2) == [False, False, True, True, False, True, False]

def find_next(bool_list, p):
    x = 0
    cleared = False
    for bool in bool_list:
        if cleared:
            if bool:
                return x
        if x == p and bool:
            cleared = True
        x += 1
    return None

assert find_next([True, True, True, True], 2) == 3
assert find_next([True, True, True, False], 2) is None

def prime_from_list(bool_list):
    y = [x for x, i in enumerate(bool_list) if i]
    prime_from_list = []
    for element in bool_list:
        if element == True:
            return y
    return prime_from_list

assert prime_from_list([False, False, True, True, False]) ==  [2, 3]

def sieve(n):
    bool_list = list_true(n)
    p = 2
    while p is not None:
        bool_list = mark_false(bool_list, p)
        p = find_next(bool_list, p)
    return prime_from_list(bool_list)

然后，我得到一个错误消息后，下面的代码

assert sieve(1000) == get_primes(0, 1000)
--------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
<ipython-input-50-c49169fabbae> in <module>()
----> 1 assert sieve(1000) == get_primes(0, 1000)

AssertionError: 

assert sieve（1000）=获取素数（0，1000）
--------------------------------------------------------------------------
AssertionError回溯（上次最近的调用）
在（）
---->1断言筛（1000）=获取素数（0，1000）
断言者错误：

---

为什么我会出现错误？有没有可能的方法可以修改它？

这是一个奇怪的问题。首先，您没有提供

get_primes（0，1000）

，因此我们无法比较结果。其次，作为程序员，您需要输入

assert

语句来测试您知道不应该发生的情况，因此您不应该质疑

assert

本身

我认为

断言失败的原因是，您受折磨的代码不会产生素数（它包括复合奇数），例如
sieve（20）
返回：

[2, 3, 5, 7, 9, 11, 13, 15, 17, 19]

此外，您的代码实际上不是一个筛子！
mark\u false（）
例程应该简单地删除最近发现的素数的倍数，但是它会测试所有的数字，看看它们是否可以被素数整除！这是以筛子为幌子的强力素数搜索

下面是我对您的代码进行的返工和简化，这些代码应该通过有问题的断言：

def list_true(n):
    return [False for _ in range(2)] + [True for _ in range(2, n + 1)]

assert len(list_true(20)) == 21
assert list_true(20)[0] is False
assert list_true(20)[19] is True

def mark_false(bool_list, prime):

    for index in range(prime * prime, len(bool_list), prime):
        if bool_list[index] is False:
            continue

        bool_list[index] = False

    return bool_list

assert mark_false(list_true(6), 2) == [False, False, True, True, False, True, False]

def find_next(bool_list, index):
    while index + 1 < len(bool_list):
        index += 1

        if bool_list[index]:
            return index

    return None

assert find_next([True, True, True, True], 2) == 3
assert find_next([True, True, True, False], 2) is None

def prime_from_list(bool_list):
    return [index for index, boolean in enumerate(bool_list) if boolean]

assert prime_from_list([False, False, True, True, False]) == [2, 3]

def sieve(number):
    bool_list = list_true(number)
    prime = 2

    while prime is not None:
        bool_list = mark_false(bool_list, prime)
        prime = find_next(bool_list, prime)

    return prime_from_list(bool_list)

assert sieve(1000) == get_primes(0, 1000)

def list_true（n）：
返回[范围（2）内的为假]+[范围（2，n+1）内的为真]
断言len（list_true（20））==21
断言列表_true（20）[0]为False
断言列表_true（20）[19]为true
def mark_false（布尔_列表，素数）：
对于范围内的索引（prime*prime，len（bool_列表），prime）：
如果布尔_列表[索引]为False：
持续
bool_列表[索引]=False
返回bool_列表
断言标记为false（列表为true（6），2）=[false，false，true，true，false]
def find_next（布尔_列表，索引）：
而索引+1

请注意，
bool
是一个Python类，不要将其用作变量名。
您的断言不起作用。如果断言不能正确断言，则会出现该错误。你也很含糊。请不要在这里这么含糊，ppl会欺负你筛（1000）不等于得到_素数（01000），这就是它的意思。。。可能会检查一些较小的值，如
print（筛（5），“==”，get_primes（0,5））