Skip to content
CodeMDD.io | Coding Tutorials

Effortlessly Mastering the Modulo Operator in Python

[

Python Modulo in Practice: How to Use the % Operator

Table of Contents

Python supports a wide range of arithmetic operators that you can use when working with numbers in your code. One of these operators is the modulo operator (%), which returns the remainder of dividing two numbers.

Modulo in Mathematics

The term modulo comes from a branch of mathematics called modular arithmetic. Modular arithmetic deals with integer arithmetic on a circular number line that has a fixed set of numbers. All arithmetic operations performed on this number line will wrap around when they reach a certain number called the modulus.

A classic example of modulo in modular arithmetic is the twelve-hour clock. A twelve-hour clock has a fixed set of values, from 1 to 12. When counting on a twelve-hour clock, you count up to the modulus 12 and then wrap back to 1. A twelve-hour clock can be classified as “modulo 12,” sometimes shortened to “mod 12.”

The modulo operator is used when you want to compare a number with the modulus and get the equivalent number constrained to the range of the modulus.

For example, say you want to determine what time it would be nine hours after 8:00 a.m. On a twelve-hour clock, you can’t simply add 9 to 8 because you would get 17. You need to take the result, 17, and use mod to get its equivalent value in a twelve-hour context:

8 o'clock + 9 = 17 o'clock
17 mod 12 = 5

17 mod 12 returns 5. This means that nine hours past 8:00 a.m. is 5:00 p.m. You determined this by taking the number 17 and applying it to a mod 12.

Python Modulo Operator Basics

Modulo Operator With int

In Python, you can use the modulo operator with integers to get the remainder of the division operation. The modulo operator is represented by the percent sign (%).

x = 17
y = 5
result = x % y
print(result)  # Output: 2

In this example, x is divided by y using the modulo operator. The remainder of the division, which is 2, is stored in the variable result and then printed to the console.

Modulo Operator With float

The modulo operator can also be used with floating-point numbers.

x = 17.5
y = 5.2
result = x % y
print(result)  # Output: 1.1

This example demonstrates how the modulo operator works with floating-point numbers. The remainder of the division between x and y, which is 1.1, is stored in the variable result and then printed to the console.

Modulo Operator With a Negative Operand

When one of the operands of the modulo operator is negative, the result may not always match the expected behavior.

x = -17
y = 5
result = x % y
print(result)  # Output: 3

In this example, x is a negative number, and y is a positive number. The modulo operator returns a positive result, 3, rather than a negative result. This behavior is different from some other programming languages.

Modulo Operator and divmod()

Python provides a built-in function called divmod() that combines the modulo operation and integer division into a single function call.

x = 17
y = 5
quotient, remainder = divmod(x, y)
print(quotient)   # Output: 3
print(remainder)  # Output: 2

The divmod() function takes two arguments, x and y, and returns a tuple containing the quotient and remainder of the division x / y. In this example, the quotient is 3, and the remainder is 2.

Modulo Operator Precedence

The modulo operator has the same precedence as the other arithmetic operators in Python. It is evaluated from left to right, just like addition and subtraction.

x = 10
y = 3
z = 4
result = x + y % z
print(result)  # Output: 11

In this example, the modulo operator is evaluated before the addition operation. The result of y % z is 3, which is then added to x, resulting in 11.

Python Modulo Operator in Practice

How to Check if a Number Is Even or Odd

The modulo operator is commonly used to determine if a number is even or odd. If a number is divisible by 2 without a remainder, it is even. Otherwise, it is odd.

def is_even(n):
    return n % 2 == 0


print(is_even(10))  # Output: True
print(is_even(7))   # Output: False

In this example, the function is_even() checks if a number n is even using the modulo operator. If the remainder of n divided by 2 is equal to 0, it means the number is even, and the function returns True. Otherwise, it returns False.

How to Run Code at Specific Intervals in a Loop

The modulo operator can be used to run code at specific intervals in a loop. By checking if the loop index is divisible by a certain number, you can execute code only when the condition is met.

for i in range(1, 11):
    if i % 2 == 0:
        print(f"Running code at interval {i}")

In this example, a loop is executed from 1 to 10. The modulo operator is used to check if the loop index i is divisible by 2. If it is, the code inside the if block is executed, which prints a message indicating the interval.

How to Create Cyclic Iteration

The modulo operator can also be used to create cyclic iteration. By taking the modulo of the loop index with the length of a sequence, you can repeat the loop index within the bounds of the sequence.

sequence = ["Red", "Green", "Blue"]
for i in range(10):
    color = sequence[i % len(sequence)]
    print(color)

In this example, a loop is executed 10 times. The modulo operator is used to cycle through the colors in the sequence list. By taking the modulo of the loop index with the length of the sequence, the loop will iterate over the colors in a cyclic manner.

How to Convert Units

The modulo operator can be used to convert units. By applying the modulo operator to a value and a conversion factor, you can determine the remainder and use it to convert between different units of measurement.

meters = 150
conversion_factor = 100
kilometers = meters // conversion_factor
meters_remaining = meters % conversion_factor
print(f"{meters} meters is equivalent to {kilometers} kilometers and {meters_remaining} meters")

In this example, 150 meters are converted to kilometers and meters. The // operator performs integer division to get the number of kilometers, while the % operator calculates the remaining meters. The result is printed to the console.

How to Determine if a Number Is a Prime Number

The modulo operator can also be used to determine if a number is prime. If a number is divisible by any number other than 1 and itself without a remainder, it is not prime.

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True


print(is_prime(17))  # Output: True
print(is_prime(10))  # Output: False

In this example, the function is_prime() checks if a number n is prime using the modulo operator. It checks if any number i from 2 to the square root of n divides n without a remainder. If any such number is found, the function returns False. Otherwise, it returns True.

How to Implement Ciphers

The modulo operator can be used to implement ciphers, such as the Caesar cipher. By applying the modulo operator to the plaintext and the number of characters in the alphabet, you can wrap the letters within the alphabet to create a shifted cipher.

alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
shift = 3
plaintext = "HELLO"
ciphertext = ""
for letter in plaintext:
    index = alphabet.index(letter)
    shifted_index = (index + shift) % len(alphabet)
    ciphertext += alphabet[shifted_index]
print(ciphertext)  # Output: "KHOOR"

In this example, the plaintext "HELLO" is encrypted using a Caesar cipher with a shift of 3. Each letter in the plaintext is mapped to the corresponding shifted letter in the alphabet using the modulo operator, and the ciphertext is constructed.

Python Modulo Operator Advanced Uses

Using the Python Modulo Operator With decimal.Decimal

The modulo operator can also be used with the decimal.Decimal class from the decimal module. This allows you to perform modulo operations with decimal numbers that have arbitrary precision.

from decimal import Decimal


x = Decimal("10.5")
y = Decimal("3.2")
result = x % y
print(result)  # Output: Decimal('1.7')

In this example, the decimal.Decimal class is used to represent the numbers 10.5 and 3.2. The modulo operation is then performed using the % operator, and the result is printed to the console.

Using the Python Modulo Operator With Custom Classes

You can override the .__mod__() method in your own classes to define the behavior of the modulo operator in the context of your class.

class MyClass:
    def __init__(self, value):
        self.value = value


    def __mod__(self, other):
        return self.value % other.value


a = MyClass(7)
b = MyClass(3)
result = a % b
print(result)  # Output: 1

In this example, a custom class MyClass is defined with a .__mod__() method. This method calculates the modulo of the value attribute of two MyClass instances. The modulo operator is then used with these instances, and the result is printed to the console.

Conclusion

The Python modulo operator is a powerful tool that allows you to perform division with remainders. It can be used to solve various real-world problems, such as determining if a number is even or odd, running code at specific intervals, creating cyclic iteration, converting units, determining if a number is prime, implementing ciphers, and more. Understanding how to use the modulo operator and its various applications will enhance your Python programming skills and provide you with valuable problem-solving techniques.