Find the division remainder of a number

Use the % instead of the / when you divide. This will return the remainder for you. So in your case

26 % 7 = 5

Modulo would be the correct answer, but if you’re doing it manually this should work.

num = input("Enter a number: ")
div = input("Enter a divisor: ")

while num >= div:
    num -= div
print num

The remainder of a division can be discovered using the operator %:

>>> 26%7
5

In case you need both the quotient and the modulo, there’s the builtin divmod function:

>>> seconds= 137
>>> minutes, seconds= divmod(seconds, 60)

If you want to avoid modulo, you can also use a combination of the four basic operations 🙂

26 - (26 // 7 * 7) = 5

26 % 7 (you will get remainder)

26 / 7 (you will get divisor, can be float value)

26 // 7 (you will get divisor, only integer value)

If you want the remainder of your division problem, just use the actual remainder rules, just like in mathematics. Granted this won’t give you a decimal output.

valone = 8
valtwo = 3
x = valone / valtwo
r = valone - (valtwo * x)
print "Answer: %s with a remainder of %s" % (x, r)

If you want to make this in a calculator format, just substitute valone = 8
with valone = int(input("Value One")). Do the same with valtwo = 3, but different vairables obviously.

From Python 3.7, there is a new math.remainder() function:

from math import remainder
print(remainder(26,7))

Output:

-2.0  # not 5

Note, as above, it’s not the same as %.

Quoting the documentation:

math.remainder(x, y)

Return the IEEE 754-style remainder of x with
respect to y. For finite x and finite nonzero y, this is the
difference x – n*y, where n is the closest integer to the exact value
of the quotient x / y. If x / y is exactly halfway between two
consecutive integers, the nearest even integer is used for n. The
remainder r = remainder(x, y) thus always satisfies abs(r) <= 0.5 *
abs(y).

Special cases follow IEEE 754: in particular, remainder(x, math.inf)
is x for any finite x, and remainder(x, 0) and remainder(math.inf, x)
raise ValueError for any non-NaN x. If the result of the remainder
operation is zero, that zero will have the same sign as x.

On platforms using IEEE 754 binary floating-point, the result of this
operation is always exactly representable: no rounding error is
introduced.

Issue29962 describes the rationale for creating the new function.

We can solve this by using modulus operator (%)

26 % 7 = 5;

but
26 / 7 = 3 because it will give quotient but % operator will give remainder.

If you want to get quotient and remainder in one line of code (more general usecase), use:

quotient, remainder = divmod(dividend, divisor)
#or
divmod(26, 7)

You can find remainder using modulo operator
Example

a=14
b=10
print(a%b)

It will print 4

you can define a function and call it remainder with 2 values like rem(number1,number2) that returns number1%number2
then create a while and set it to true then print out two inputs for your function holding number 1 and 2 then print(rem(number1,number2)

Here’s an integer version of remainder in Python, which should give the same results as C’s "%" operator:

def remainder(n, d):
    return (-1 if n < 0 else 1) * (abs(n) % abs(d))

Expected results:

remainder(123, 10)   ==  3
remainder(123, -10)  ==  3
remainder(-123, 10)  == -3
remainder(-123, -10) == -3