простое сито, возвращающее некоторые странные числа

Одна из причин, по которой вы получаете композиты выше квадратного корня, заключается в том, как построены ваши циклы. Когда элемент удаляется из списка, все элементы с более высокими индексами сдвигаются вниз на один. Итак, когда элемент удаляется в первом цикле, квадратный корень перемещается вниз. Когда начинается второй цикл, squareroot больше не является индексом квадратного корня.

# Removing composites BELOW the square root
for p in prime[:squareroot][:]:
    for f in range(2, int(p ** 0.5) + 1):
        if p % f == 0:
            prime.remove(p)  # <- you removed an item from `prime`, so the
            break            # square root is now at prime[squareroot - 1]

# Removing composites ABOVE the square root
for f in prime[:squareroot][:]:    #    now p[squareroot] is actually a number
    for p in prime[squareroot:]:   # <- above the real square root, so this 
        if p % f == 0:             #    loop starts too high
            prime.remove(p)

Один из способов исправить это - изменить значение squareroot всякий раз, когда значение удаляется в первом цикле. Другой вариант - пересчитать squareroot перед вторым циклом.

Как правило, добавлять или удалять элементы из списка во время итерации по списку - плохая идея. Например, элементы можно пометить (например, установить для них ноль или Нет) за один проход, а затем немаркированные элементы можно скопировать за второй проход.

В Edit добавлен пример кода для отметки композитов:

# Removing composites BELOW the square root
for i,p in enumerate(prime[:squareroot]):
    for f in range(2, int(p ** 0.5) + 1):
        if p % f == 0:
            prime[i] = 0  # <- mark composites
            break         

# Removing composites ABOVE the square root
for f in prime[:squareroot]:    
    if f == 0: 
        continue                              # skip composites
    for i,p in enumerate(prime[squareroot:]): # <- this loop is okay now
        if p % f == 0:            
            prime[i] = 0                      # mark composite

# at this point, prime contains 0's where the compsites were found
# and non-zeros for the primes.  Just need to collect all the
# non-zero elements.
result = []         
for p in prime:     
    if p:                    
        result.append(p)

Есть и другие проблемы с вашим кодом, но это должно дать ответ на ваш непосредственный вопрос. По мере того, как вы станете более опытным с python, вы увидите дальнейшие улучшения, которые вы можете сделать (простое решето можно записать примерно на 6 строках python).

После удаления простых чисел, меньших квадратного корня, вы больше не сможете использовать squareroot в качестве индекса в primes, поскольку длина primes изменится.

Я исправил это на основе ответа Т. Сильвера - я просто сделал так, что после того, как убедился, что все, что ниже квадратного корня из предела, является простым, он снова нашел квадратный корень. Вот фиксированный код:

# Just make an empty list where the primes go
prime = []
# This next for loop just adds all the numbers of the form 6n+/-1 to the list, as all primes are of this form
for i in range(1,limit / 6 + 1):
    prime.append(6*i - 1)
    prime.append(6*i + 1)
# If the limit is divisible by 6, the last number on the list is sometimes over the limit
if limit % 6 == 0 and prime[-1] > limit:
    prime.remove(prime[-1])
# This next line just finds the place of the 'square root' of the limit, which is as high as it has to check for factors
squareroot = min(range(len(prime)), key=lambda i: abs(prime[i]-(limit**0.5))) + 1
# Removing composites BELOW the square root
for p in prime[:squareroot][:]:
    for f in range(2, int(p ** 0.5) + 1):
        if p % f == 0:
            prime.remove(p)
            break
# Here's where i put the fix!
squareroot = min(range(len(prime)), key=lambda i: abs(prime[i]-(limit**0.5))) + 1
# Removing composites ABOVE the square root
for f in prime[:squareroot][:]:
    for p in prime[squareroot:]:
        if p % f == 0:
            prime.remove(p)
return [2, 3] + prime