Python divmod() Function

Spread the love

divmod() is a built-in Python function that returns a pair of numbers (a tuple) representing the quotient and the remainder when dividing two numbers (dividend by divisor). This function works with both integers and floating-point numbers, making it versatile in different use cases.

Syntax and Parameters:

divmod(a, b)


  • a (required): the dividend (the number to be divided)
  • b (required): the divisor (the number by which division is to be performed)

Return Value

divmod() returns a tuple of two values:

  • The first value is the quotient obtained by performing floor division (using the // operator).
  • The second value is the remainder obtained using the modulus (%) operator.

Examples and Use Cases:

Python divmod() with Integer Arguments:

When the divmod() function is used with integer arguments in Python, it returns a tuple containing two integers. The first integer is the quotient of the division (obtained using floor division), and the second integer is the remainder (often referred to as the modulus).

Understanding the Results

  1. Quotient: This is the whole number result of the division without any fraction or remainder. When using integer arguments, the quotient is essentially the result of the floor division (//) operation.
  2. Remainder: This is the amount left over after the division. It’s the result you would get if you used the modulus (%) operation on the same two integers.

Example with Integer Arguments

Let’s understand this with an example:

result = divmod(17, 5)
print(result)  # Outputs: (3, 2)

Here’s what happened:

  • The floor division (or integer division) of 17 by 5 is 3, because 5 goes into 17 three whole times (3 * 5 = 15).
  • The remainder when 17 is divided by 5 is 2, because 17 minus the 15 (from the 3 whole times 5 goes into 17) is 2.

You can achieve the same results using the // and % operators:

quotient = 17 // 5  # This equals 3
remainder = 17 % 5  # This equals 2

Practical Application

A common use case of divmod() with integer arguments is when you’re trying to convert units. For instance, if you want to convert a given number of minutes into hours and minutes:

total_minutes = 125
hours, minutes = divmod(total_minutes, 60)
print(f"{hours} hour(s) and {minutes} minute(s)")  # Outputs: 2 hour(s) and 5 minute(s)

Key Takeaways

  • The divmod() function with integer arguments returns a tuple of integers: (quotient, remainder).
  • It’s essentially a combined operation of floor division (//) and modulus (%).
  • It’s efficient and useful in scenarios where you need both the quotient and the remainder, particularly for unit conversions or breaking down numbers into constituent parts.

Python divmod() with Float Arguments

The divmod() function in Python is not limited to integer arguments; it also accepts floating-point numbers. When used with floats, it returns a tuple containing two floats: the quotient of the division and the remainder. However, the interpretation and internal workings differ slightly when floats are involved.

Understanding the Results with Floats

  1. Quotient: This represents the whole number part of the result of the division. With floats, the quotient is still essentially the result of the floor division (//), but returned as a float.
  2. Remainder: For floating-point values, the remainder still represents what’s left after the division. But, due to the nature of floating-point arithmetic, there can sometimes be very small rounding errors.

Example with Float Arguments

Let’s dive in with an example:

result = divmod(17.5, 5.2)
print(result)  # Outputs something like: (3.0, 1.9)

Here’s what happened:

  • The floor division of 17.5 by 5.2 is approximately 3 (since 5.2 multiplied by 3 is 15.6, which is the largest multiple of 5.2 less than 17.5).
  • The remainder when 17.5 is divided by 5.2 is approximately 1.9 (because 17.5 minus 15.6 is 1.9).

Again, as a reference, you can achieve similar results using the // and % operators:

quotient = 17.5 // 5.2  # This will give a float value close to 3.0
remainder = 17.5 % 5.2  # This will give a float value close to 1.9

Floating Point Precision Issues

It’s important to remember that floating-point arithmetic in most programming languages, including Python, can introduce very small rounding errors. This is due to the nature of how computers represent floating-point numbers in binary. When using divmod() with float arguments, these precision issues can sometimes be observed in the remainder.

For instance:

result = divmod(1.0, 0.1)
print(result)  # Might output: (9.0, 0.09999999999999995)

Even though mathematically, 1.0 divided by 0.1 should perfectly give a quotient of 10 with no remainder, the tiny rounding errors in floating-point arithmetic result in the slightly-off values seen above.

Key Takeaways

  • The divmod() function can work with float arguments and will return a tuple of floats: (quotient, remainder).
  • Due to the nature of floating-point arithmetic, small rounding errors can sometimes be observed, especially in the remainder.
  • It’s always crucial to be aware of these floating-point precision issues when working with float values, not just in the context of divmod(), but in any computational scenario in programming.


The divmod() function is a convenient Python built-in that allows developers to quickly retrieve both the quotient and remainder of a division operation. While it’s a powerful tool in specific contexts like time or currency conversion, it’s essential to use it judiciously, especially concerning performance.

Leave a Reply