Python eratostheness算法的筛选

我有这个函数，可以用埃拉托斯烯筛来计算素数。我有一个错误，我不明白为什么

def era1(n):

    llista1 = []
    llista2 = []
    i = 2

    while(i<(n+1)):
        llista1.append(i)
        i = i + 1

    while (llista1[0]<(n**0.5)):
        llista2.append(llista1[0])    
        for j in range ((len(llista1))-1):
            if (llista1[j] % llista1[0] == 0) :  #<------- error list index out of range
                llista1.remove(llista1[j])
        llista1.remove(llista1[0])
    print llista2

def era1（n）：
Lista1=[]
Lista2=[]
i=2
while（i这是在迭代时删除列表中的项目的结果。您已指定for循环运行
n
次，但当您到达第n个项目时，曾经存在的项目已向后移动了一些索引，因为您正在从列表中删除项目

您需要重新考虑重新实现筛选的方法。我不能100%遵循您的方法，但我相信这可能涉及到第二个列表。白名单，而不是黑名单：）

另外，这是一个很酷的函数。
这是在遍历列表时删除列表中的项目的结果。您已指定for循环运行
n
的次数，但当您到达第n个项目时，曾经存在的项目已向后移动了一些索引，因为您正在从列表中删除项目

您需要重新考虑重新实现筛选的方法。我不能百分之百地遵循你的方法，但我相信这可能涉及到第二个列表。白名单，不黑名单：）

另外，这是一个很酷的函数。对于仍在寻找这种算法方法的任何人来说，
可能都很有用

def SieveOfEratosthenes(n): 
    # Create a boolean array "prime[0..n]" and initialize 
    # all entries it as true. A value in prime[i] will 
    # finally be false if i is Not a prime, else true. 
    prime = [True for i in range(n + 1)] 
    p = 2
    while (p * p <= n): 
            
        # If prime[p] is not changed, then it is a prime 
        if (prime[p] == True): 
                
            # Update all multiples of p 
            for i in range(p * 2, n + 1, p): 
                prime[i] = False
        p += 1
    prime[0]= False
    prime[1]= False
    # Print all prime numbers 
    for p in range(n + 1): 
        if prime[p]: 
            print (p) 
    
# driver program 
if __name__=='__main__': 
    n = 30
    print ("Following are the prime numbers smaller") 
    print ("than or equal to", n )
    SieveOfEratosthenes(n) 

def筛下费拉托斯烯（n）：
#创建布尔数组“素数[0..n]”并初始化
#所有条目都被认为是真实的。素数[i]中的值将
#最后，如果我不是质数，那就错了，否则就真了。
prime=[范围（n+1）内的i为真]
p=2
而（p*p可能对仍在寻找这种算法方法的人有用

def SieveOfEratosthenes(n): 
    # Create a boolean array "prime[0..n]" and initialize 
    # all entries it as true. A value in prime[i] will 
    # finally be false if i is Not a prime, else true. 
    prime = [True for i in range(n + 1)] 
    p = 2
    while (p * p <= n): 
            
        # If prime[p] is not changed, then it is a prime 
        if (prime[p] == True): 
                
            # Update all multiples of p 
            for i in range(p * 2, n + 1, p): 
                prime[i] = False
        p += 1
    prime[0]= False
    prime[1]= False
    # Print all prime numbers 
    for p in range(n + 1): 
        if prime[p]: 
            print (p) 
    
# driver program 
if __name__=='__main__': 
    n = 30
    print ("Following are the prime numbers smaller") 
    print ("than or equal to", n )
    SieveOfEratosthenes(n) 

def筛下费拉托斯烯（n）：
#创建布尔数组“素数[0..n]”并初始化
#所有条目均为true。素数[i]中的值将
#最后，如果我不是质数，那就错了，否则就真了。
prime=[范围（n+1）内的i为真]
p=2
而（p*p）我建议重命名变量，使代码更清晰。特别是，可以调用这两个列表，例如“unsivedNumbersList”和“sivedNumbersList”。这两个列表描述了它们的优点。我建议重命名变量，使代码更清晰。特别是，可以调用这两个列表，例如，“未筛选号码列表”和“筛选号码列表”"。一些描述它们更好的东西。有趣的-在这种情况下，每次迭代删除东西是否也会导致效率问题，因为索引必须一直重新计算？@ColmBhandal如果要重新计算索引，那么当然可以。但是，这确实应该避免，因为总有一个更好的wPython不尝试重新计算索引（因此是索引器）@Terry，
enumerate
在这里有什么帮助？它会创建一个浅拷贝吗？@TerryA我想我问的是这个问题。当你用Python索引一个列表时，如果你在元素之前删除了东西，Python怎么知道要检索哪个元素？例如，我有字母={a，B，C，D，E}。如果我做字母[3]，我得到D。然后我做字母。删除（C）现在当我给字母[3]编制索引时，我得到了E。Python如何知道字母[3]现在是E，而不是D，而不必做一些计算来向下移动索引？@TerryA yeah这似乎还意味着对项目的检索是
O（n）
也是，在for循环中使用某些东西似乎非常浪费。无论如何，如果我们后退几步，我想你的评论说明了一切：白名单，不要黑名单！；）有趣-在这种情况下，每次迭代删除东西是否也会导致效率问题，因为必须始终重新计算索引？@ColmBhandal如果要重新计算索引，那么当然可以。但是，这确实应该避免，因为总会有更好的方法来修复它。Python不会尝试重新计算索引后期索引（因此是索引器）@Terry，
enumerate
在这里有什么帮助？它是否创建了一个浅层副本？@TerryA我想我问的是这样的。当你用Python索引一个列表时，如果你删除了元素之前的内容，Python如何知道要检索哪个元素？例如，我有字母={a，B，C，D，E}。如果我有字母[3]我得到了D。然后我得到了字母。删除（C）。现在当我给字母[3]编制索引时，我得到了E。Python如何知道字母[3]现在是E，而不是D，而不必做一些计算来向下移动索引？@TerryA是的，这似乎也暗示着对项目的检索是
O（n）
也是，在for循环中使用某些东西似乎非常浪费。无论如何，如果我们后退几步，我想你的评论说明了一切：白名单，不要黑名单！；）