How to List All Primes up to 1000 in Python

First, identify your desired output.

Problem

Write a Python program that prints out all prime numbers up to 1000.

Understanding the math

The first step is to understand the definition of a prime. A prime number is a positive integer that is only divisible by one and itself. The specific requirements of this definition keep 1 from being a prime number because 1 is only divisible by 1. There is no “and itself”.

Thus, the smallest prime number is 2.

Understanding the output

A key consideration before we start writing code is what exactly the output should be. If we aren’t clear about what we want, we will not be able to write a program that solves the problem.

You’re about to see a block of numbers. These are the values we should get if we want all the primes up to 1000.

When we run our code, we want the output to be:

2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997

Getting started with the program

Before we begin, remember that there are often multiple ways to accomplish the same result. This article demonstrates one way.

Let’s first define our function. We will choose a name that makes sense given our task.

Here’s the syntax: def primes():

Next, let’s think about what the program should do. It can be very helpful to write out exactly what you want your code to accomplish.

At a high level of abstraction, this program should return 168 prime integers up to 1000. Let’s break it down further. The program should run through each integer between 2 and 1000 and check if it’s prime. This part alone indicates that we can use a for loop.

Here’s the syntax: for i in range (2, 1000)

Note that range is not inclusive, which means that 1000 will not get tested. The largest value this for loop will reach is 999. This isn’t an issue because we know that 1000 is an even number, so it’s divisible by two. It’s not a prime integer.

If you do want to have your program check if 1000 is a prime number, you can simply change the loop’s syntax to

for i in range(2, 1001)

This will change the highest value of i to 1000.

Testing if an integer is prime

The next step is to figure out how to write syntax that takes each integer outputted by the for loop above and checks if it’s a prime number.

Often we have to think about a definition in creative ways when we’re solving a coding problem. We know that a prime number X is only divisible by one and itself.

This also means that X is not divisible by any number between 2 and X-1. So, if we’re checking if 9 is prime, we know that 9 cannot be divisible by any integer between 2 and 8.

Specifically, all of the statements below must be true.

9 cannot be divisible by 2. 9 cannot be divisible by 3. 9 cannot be divisible by 4. 9 cannot be divisible by 5. 9 cannot be divisible by 6. 9 cannot be divisible by 7. 9 cannot be divisible by 8.

To check if a prime number is divisible by any of the above integers, we can use the modulo operator, which returns the remainder when one number is divided by another number. This is written as % in Python. Let’s continue using 9 as our example.

We want to write code that asks the following questions:

Does 9 divided by 2 have a remainder of zero?

9%2 == 0

No, but we haven’t checked all of the integers up to 9–1=8 yet. We still cannot classify 9 as a prime number.

Does 9 divided by 3 have a remainder of zero?

9%3 ==0

Yes, and this tells us that 9 is divisible by some number between 2 and 8, which means it doesn’t meet the definition of a prime integer. We can stop here and identify 9 as a composite (non-prime integer). We now know that we don’t want to output it.

It seems like we’re using a list of divisors, doesn’t it? And we’re cycling through each divisor. This calls for another for loop. This time, it will be a nested for loop.

Here’s the syntax: for j in range (2, i)

This for loop uses j and takes the values 2, 3, 4, 5, etc. until it reaches i-1. Remember that range is noninclusive.

What we have so far

Our code looks like:

Finishing it up

For each i and j, we want to check if i%j==0.

If it does, then the number is not a prime. If we run through each value of j for a particular i and never have a case where i%j==0 is true, we know that the number i meets the criteria of being a prime.

Now, the code can get a bit complicated, but here’s an easy workaround. First, we will initialize a variable called divisor directly under our first for loop and set it to equal to 0.

Here’s the syntax: divisor=0

Then, we will use a simple if statement to check if i divided by j has a zero remainder for each j: i%j==0. Whenever this is true, we will increase the value of divisor by 1.

When the nested for loop is done running through all values for j, we will use a subsequent if statement that asks if the value of divisor is still 0. If it is, we know that i, the number we are evaluating, is, in fact, a prime. We’ll also just throw in the Boolean operator or to make sure the case of 2 is covered since it’s a little tricky.

The final program

The finished code will be:

Try it out!

Some tips as you write code

When you’re solving a Python problem, do not be afraid to make mistakes. Even if your output isn’t what you want, you can use it as a guiding compass. Evaluate your output and ask yourself which parts of your problem your existing code solves and which parts it’s getting wrong.

The first few times I tried to write this program, my output gave me many repeating numbers, and it included composite integers. However, the output did run from 2 to 1000, which showed me that at least I had gotten my outer for loop to work.

You can always build your skills and learn to write better code by being open to making mistakes.