Python divmod()

Understanding Python divmod() Function

Python divmod() takes two numeric arguments and returns a pair of numbers consisting of their quotient and remainder. It performs division and gives you the result of the division (the quotient) and what’s left over (the remainder) in a single step. Python divmod() is a shortcut for doing integer division and the modulo operation separately. The returned value is a tuple. This function only works with numeric types (integers and floats) and will raise exceptions if used with non-numeric types.

Syntax of Python divmod()

result = divmod(a, b)

Explanation

• result: Variable will store the result, which is a tuple containing the quotient and remainder.
• divmod(): Built-in function that performs the division and modulo operation.
• a: Dividend (the number being divided). It is used as first parameter in divmod().
• b: Divisor (the number dividing the dividend). It is used as second parameter in divmod().

Example of Python divmod()

result = divmod(8, 3)
print(result)

Explanation

• result = divmod(8, 3): Calls divmod() with 8 as the dividend and 3 as the divisor, storing the result in result.
• print(result): Prints the value of result, which is the tuple (2, 2).

Output

(2, 2)

divmod() Parameters

Python divmod() function takes two parameters: the dividend (a) and the divisor (b). Both of these parameters must be numbers, either integers or floating-point numbers. a is the number that is being divided, and b is the number that a is divided by. If you pass non-numeric arguments, divmod() will raise a TypeError.

Syntax

result = divmod(a, b)

Example

quotient_remainder = divmod(14, 4)
print(quotient_remainder)

Explanation

• quotient_remainder = divmod(14, 4): Calls divmod() with 14 as the dividend and 4 as the divisor, storing the result in quotient_remainder.
• print(quotient_remainder): Prints the value of quotient_remainder, which is the tuple (3, 2).

Output

(3, 2)

divmod() Return Value

Python divmod() function returns a tuple containing two values: the quotient and the remainder of the division. The quotient is the result of the division, and the remainder is what’s left over after the division. For example, if you call divmod(7, 3), it will return the tuple (2, 1) because 7 divided by 3 is 2 with a remainder of 1.

Example

result = divmod(17, 5)
print(result)

Explanation

• result = divmod(17, 5): Calls divmod() with 17 as the dividend and 5 as the divisor, storing the result (a tuple) in result.
• print(result): Prints the value of result, which is (3, 2).

Output

(3, 2)

Python divmod() with Integer Arguments

When you use Python divmod() with integer arguments, it performs integer division and returns the quotient and remainder as integers. The quotient is the whole number part of the division result, and the remainder is what’s left over when the dividend is divided by the divisor. Both the dividend and divisor can be positive or negative, and divmod() will handle the signs correctly.

Syntax

result = divmod(integer_dividend, integer_divisor)

Explanation

• result: Variable will store the tuple containing the integer quotient and remainder.
• divmod(): Function performs integer division.
• integer_dividend: Integer being divided. It is passed as first parameter to divmod().
• integer_divisor: Integer that divides the dividend. It is passed as second parameter to divmod().

Example

result = divmod(-7, 3)
print(result)

Explanation

• result = divmod(-7, 3): Calls divmod() with -7 as the dividend and 3 as the divisor, storing the result in result.
• print(result): Prints the value of result, which is (-3, 2).

Output

(-3, 2)

Python divmod() with Float Arguments

When you use Python divmod() with floating-point numbers, it performs floating-point division and returns a tuple containing the quotient and remainder as floats. The quotient might not always be a whole number, and the remainder will be a float that represents the difference between the dividend and the product of the divisor and the quotient. Using float as input will always return float as output in a tuple.

Syntax

result = divmod(float_dividend, float_divisor)

Explanation

• result: Variable will store the tuple containing the float quotient and remainder.
• divmod(): Function performs floating-point division.
• float_dividend: Floating-point number being divided. It is passed as first parameter to divmod().
• float_divisor: Floating-point number that divides the dividend. It is passed as second parameter to divmod().

Example

result = divmod(7.5, 2.5)
print(result)

Explanation

• result = divmod(7.5, 2.5): Calls divmod() with 7.5 as the dividend and 2.5 as the divisor, storing the result in result.
• print(result): Prints the value of result, which is (3.0, 0.0).

Output

(3.0, 0.0)

Python divmod() with Non-Numeric Arguments

If you try to use Python divmod() with non-numeric arguments, such as strings or lists, Python will raise a TypeError. This is because divmod() is specifically designed to work with numbers and perform mathematical division. It cannot operate on non-numeric data types. You will get an exception if you try to use non-numeric type.

Syntax

result = divmod(non_numeric_a, non_numeric_b)

Explanation

• result: Variable would attempt to store the result, but a TypeError will occur.
• divmod(): Function is designed for numeric arguments only.
• non_numeric_a: Represents a non-numeric argument (e.g., a string). It is passed as incorrect input.
• non_numeric_b: Represents another non-numeric argument. It is passed as incorrect input.

Example

try:
    result = divmod("hello", 2)
    print(result)
except TypeError as e:
    print(f"TypeError: {e}")

Explanation

• try:: Block attempts to execute code that might raise an exception.
• result = divmod("hello", 2): Attempts to call divmod() with a string and an integer, which will raise a TypeError.
• print(result): Print the result if no error occurred.
• except TypeError as e:: Catches the TypeError if it is raised.
• print(f"TypeError: {e}"): Prints the error message.

Output

TypeError: unsupported operand type(s) for divmod(): ‘str’ and ‘int’

Converting Seconds to Minutes and Seconds

One practical application of Python divmod() is converting a given number of seconds into minutes and seconds. You can use divmod() to divide the total number of seconds by 60 (the number of seconds in a minute). The quotient will be the number of whole minutes, and the remainder will be the number of seconds left over. This makes it easy to get a time duration in a more human-readable format.

Syntax

minutes, seconds = divmod(total_seconds, 60)

Explanation

• minutes: Variable will store the number of whole minutes.
• seconds: Variable will store the remaining seconds.
• divmod(): Function divides total_seconds by 60 and returns the quotient and remainder.
• total_seconds: Total number of seconds you want to convert. It is passed as first parameter to divmod().
• 60: Number of seconds in a minute, used as the divisor. It is passed as second parameter to divmod().

Example

total_seconds = 135
minutes, seconds = divmod(total_seconds, 60)
print(f"{minutes} minutes, {seconds} seconds")

Explanation

• total_seconds = 135: Sets the total number of seconds to 135.
• minutes, seconds = divmod(total_seconds, 60): Calls divmod() to divide total_seconds by 60, storing the quotient in minutes and the remainder in seconds.
• print(f"{minutes} minutes, {seconds} seconds"): Prints the result in the desired format.

Output

2 minutes, 15 seconds

Exceptions of Python divmod() Function

The Python divmod() function can raise exceptions if you use it incorrectly. The most common exception is a TypeError, which occurs if you pass non-numeric arguments to divmod(). Another exception is ZeroDivisionError which occurs when the second argument (the divisor) is zero. It’s important to handle these exceptions using try-except blocks to make your code more robust.

Syntax

try:
    result = divmod(a, b)
except TypeError:
    # Handle TypeError
except ZeroDivisionError:
    # Handle ZeroDivisionError

Explanation

• try:: Attempts to execute the divmod() function.
• result = divmod(a, b): Calls divmod() with a as the dividend and b as the divisor.
• except TypeError:: Catches a TypeError if it occurs (e.g., if a or b is not a number).
• # Handle TypeError: This is where you would write code to handle the TypeError.
• except ZeroDivisionError:: Block catches a ZeroDivisionError if it occurs (if b is zero).
• # Handle ZeroDivisionError: This is where you would write code to handle the ZeroDivisionError.

Example

try:
    result = divmod(10, 0)
    print(result)
except ZeroDivisionError as e:
    print(f"Error: {e}")

Explanation

• try:: Block attempts to execute the divmod() function.
• result = divmod(10, 0): Calls divmod() with 10 as the dividend and 0 as the divisor, which will raise a ZeroDivisionError.
• print(result): This line would print the result if no error occurred.
• except ZeroDivisionError as e:: Block catches the ZeroDivisionError if it is raised.
• print(f"Error: {e}"): Pprints the error message.

Output

Error: integer division or modulo by zero

Conclusion

Python divmod() function is a handy tool for performing division and getting both the quotient and remainder at once. It works with both integers and floating-point numbers and returns a tuple containing the results. While Python divmod() is straightforward to use, it’s important to remember that it only works with numeric types and can raise a TypeError if used with other types. It can also raise ZeroDivisionError if you try to divide by zero. You can use this function in many scenarios like converting seconds to minutes and seconds. Understanding these basics will help you use divmod() effectively in your Python code.

Also Read

Python dir()

Python enumerate()

Python Reference

python divmod()