As part of Nick Russo’s DevAsc study plan, he recommends doing a few Python challenges to check your existing knowledge of Python. One of these is the Divisors challenge. The goal of of this exercise is to take a number, such as 12, and then find all the divisors, that is the numbers that you can divide 12 with and have no remainder. This would 1, 2, 3, 4, 6, and finally 12 itself.
Now, solving this doesn’t take a lot of code. However, I decided that gold plating is allowed in my studies of code. That is, I would rather practice writing functions from the get go rather than just quickly moving from exercises.
To find divisors, we need a little basic math. We can use the Modulo operation to find the reminder of a division. For example, if you divide 5 by 2, the remainder is 1. We call this 5 modulo 2. Because there is a remainder of 1, this means that 2 is not a divisor for 5. If we however use 9 and 3 instead, with 9 modulo 3, the remainder is 0. This means that 3 is a divisor for 9. We then know that the remainder should be 0 for all divisors and we can easily check this with the modulo operation.
I decided to divide my code into three functions:
First, it’s good practice to describe what your program does with a docstring:
"""Program to check all divisors of a positive integer"""
Our program will look for all divisors for positive integers.
The first step to finding a divisor, is to ask the user for what number to check. We can ask the user to input a number using the
input() function in Python.
number = input("Please enter a positive integer: ")
It’s important to note that this function returns a string. We need a number, more specifically an integer. Luckily, we can use the
int() function to get an integer from the string specified. We will call this variable
Like I said, I wanted to create a function out of this code:
def get_number(): """Get a number from user, convert to integer, and return the value""" # Get number, this will be a string number = input("Please enter a positive integer: ") # Convert string to an integer number_int = int(number) # Return the number return number_int
Notice that the function returns
number_int and that this function doesn’t require any arguments. When I first tried my complete solution, I had an error saying something about
number_int not being defined. What I hadn’t realized, was that even though I am returning
number_int in my function, this variable is only known within the function. It does not have global scope. I wanted to take this value and feed it into the next function. We’ll get back to this later.
Our next goal is to create a list that contains all possible divisors. In Python, there is a function called
range() that we can use to create ranges of values. To find all divisors, we want to create a list where 1 is the first number and where the last number is the number that the user input, namely
number_int. When using the
range() function, the first argument we give is the starting number. The second argument we give, is the ending number. However, ending number actually means that the range is from starting number to ending number – 1. Meaning that if we use
range(1, 10), the range would be from 1 to 9.
One error I did at this point was thinking I could create a list like this:
>>> mylist = range(1, 10) >>> print(mylist) range(1, 10)
However, as you see, this just created a list containing the range, not the numbers themself. What we need to do is to combine this with the
>>> mylist = list(range(1, 10)) >>> print(mylist) [1, 2, 3, 4, 5, 6, 7, 8, 9]
Now we have an actual list.
Great, now let’s turn this into a function. We want to send the argument
number_int into the function. When creating the list, the range will be from 1 to
number_int + 1. Why do we need to add 1 to number_int? Because otherwise the list will not be complete because the
range() function creates a range where the range ends one number before the ending number input.
def create_list(number_int): """Create list consisting of all numbers from zero to user-specified number, to find divisors""" # Create list using range, user number plus 1 is end number mylist = list(range(1, (number_int + 1))) # Return the list return mylist
We return a list called
mylist. One mistake I made here was first calling the list I was creating
list. Don’t name your variables to something that exists within Python itself, such as function names, you may end up with code not running.
Now for the code that actually looks for divisors. What we are trying to achieve is this:
- Create an empty list containing divisors
- Iterate through all numbers in mylist
- Check if we have a divisor with modulo function
- If we have a match, add it to the list
- Print all the divisors
Creating an empty list is as easy as this:
divisors = 
We then have the code looking for divisors:
for number in mylist: # Check if modulo is 0, then divisor is found if (mylist[-1] % number == 0): # When divisor found, add to list divisors.append(number)
We iterate through all the numbers in mylist using the iterator
number. To see if we have a divisor, we have in if statement with
(mylist[-1] % number == 0). What does
mylist[-1] mean? It’s the last number in our list, the number that the user originally input. To use the modulo fuction in Python, we use the
% operator. If the result is == 0, then we have a divisor.
If a divisor is found, we add it to the list called divisors with the
We also want the function to print all the divisors. This is done below:
for divisor in divisors: print(divisor)
All the divisors are in the
divisors list. We iterate using
divisor and then simply print them one by one.
We now have three functions, but our code doesn’t really do anything. We need to actually call the functions. This is done below:
if __name__ == "__main__": number_int = get_number() mylist = create_list(number_int) check_divisor(mylist)
The first if statement just checks that if dunder
name is dunder
main, the code is run, that is if it’s run standalone and not imported as a module.
Like I mentioned before, variables are local to functions. That’s why I need to use
number_int globally. I get this value by calling
get_number(). Then this number, an integer, is fed into
create_list, as an argument, to create our list of potential divisors. Finally, we take the result of this function in the form of
mylist, send it through
check_divisor and get our divisors printed to us. Neat! This is what it looks like:
daniel@devasc:~/DevAsc$ python3 divisors.py Please enter a positive integer: 48 1 2 3 4 6 8 12 16 24 48 daniel@devasc:~/DevAsc$
Finally, here’s the entire code if you want to run it for yourself:
"""Program to check all divisors of a positive integer""" def get_number(): """Get a number from user, convert to integer, and return the value""" # Get number, this will be a string number = input("Please enter a positive integer: ") # Convert string to an integer number_int = int(number) # Return the number return number_int def create_list(number_int): """Create list consisting of all numbers from zero to user-specified number, to find divisors""" # Create list using range, user number plus 1 is end number mylist = list(range(1, (number_int + 1))) # Return the list return mylist def check_divisor(mylist): """Take a list and check for all divisors""" # Create empty list to store divisors divisors =  # Loop through the list for number in mylist: # Check if modulo is 0, then divisor is found if (mylist[-1] % number == 0): # When divisor found, add to list divisors.append(number) # Print all divisors for divisor in divisors: print(divisor) # Run code if not imported as module if __name__ == "__main__": number_int = get_number() mylist = create_list(number_int) check_divisor(mylist)
I have also added the code to Github.
I hope this post was helpful. I certainly learned a lot by writing it.