为什么这个问题的 for 循环解决方案比我的 while 循环解决方案快得多？ 我完全被难住了

Question

I'm taking a Python course through Udemy. I have a fair amount of Java experience (for Android) but it's been a while so maybe I'm missing something obvious but I can't find it.

The assignment was to create a function that takes an int then returns True or False based on whether or not you fed it a prime number. Then use that function to find the first 5 primes over 1,000,000.

My solution worked correctly but took a full 3438ms to find the primes. The highest of the five is 1,000,081... so three seconds to loop 81 times? I ran and timed the instructors solution and his did it in 140ms.

The main difference between his and mine is that I'm using a while loop and he's using a for loop with a set max range. But that can't be it, what am I missing here?

My code:

def prime_checker(number):

    local_list = list()

    for count in range(number):
        if number % (count + 1) == 0 and count + 1 != number:
            local_list.append(count)

    if len(local_list) == 1:
        return True
    else:
        return False

current_count = 999999
prime_list = list()


while len(prime_list) < 5:

    current_count += 1
    print('current_count -> ', current_count)

    if prime_checker(current_count):
        prime_list.append(current_count)
    else:
        continue

print(prime_list)

The instructor's Solution:

def is_prime(n):
    prime = True
    i = 1
    while i < n // 2:
        i = i + 1
        if n % i == 0:
            prime = False
            break
    return prime

primes = []
for n in range(1_000_000, 100_000_000):
   if is_prime(n):
       primes.append(n)
       if len(primes) == 5:
           break

print(primes)

Answer 1

The main performance difference comes from your prime_checker logic. Your instructor's is_prime function stops its loop as soon as it finds a factor for the given number. Your prime_checker builds a complete list of factors and only checks the count onces it has them all.

For example, is_prime(1_000_000) will exit after performing one iteration returning False upon finding that 1_000_000 is divisible by 2. prime_checker(1_000_000) will divide the number 999998 times to build the list and find that there are 47 divisors.