The floor division operator in Python is //, while the modulo operator is %. An equation like A = B * (A / B) + (A % B) is always fulfilled if the numerator is A and the denominator is B. Use the math module’s floor() function or the floor division operator / to always get the floor division of 2 integers.

The Floor-Division operator in Python is made up of two forward slashes. Because it accepts two operands: the dividend and the divisor, the Floor-Division operator is an example of a binary operator.

The / floor division operator divides two integers and rounds them down to the nearest integer. Assume a movie has a run duration of 102 minutes. You may be curious as to how long that is in hours. The result of conventional division is a floating-point number:

>>>Total minutes = 102

>>> minutes / 60

*1.7 hours*

Hours, on the other hand, are rarely written with decimal points. The integer number of hours is returned by floor division, rounded down:

>>> Total minutes = 102

>>> Number of hours = minutes // 60

>>> hours

*1 hour*

You might remove 1 hour in the total minutes to obtain the remainder:

The remainder will now be = (minutes – hours) * 60

Therefore, the remainder will be = 45

The modulus expression, %, divides two integers and returns the residual as an alternative.

The remainder will be = total minutes % 60, which will give a result of 45.

The modulus operator has more applications than it appears. You may, for example, see if one number is divisible by another by looking at its percent—if x % y is 0, then x is divisible by y.

You can also extract the number’s right-most digit or digits. For instance, x % 10 equals x’s right-most digit (in base 10). In the same way, x % 100 gives you the last two numbers.

When using Python 2, division is handled differently. When both operands are integers, the division operator / performs floor division; if either operand is a float, it performs floating-point division.

Because there is no (lossy) floating-point conversion, the floor division also functions with Python’s huge integers.

Here’s an example of what we are talking about:

**Is there a Python operator that’s equivalent to the ceiling of //?**

With ceil, there’s really no operator that divides. You’ll need to utilize math.ceil and import math. Here are some ideas about how to go about it:

**Solution 1:** With negation, convert the floor to the ceiling.

This “flips the universe upside down (by using negation), then uses basic floor division (with the ceiling and floor flipped), and finally puts the universe right-side up (by using negation again),” similar to the Penn & Teller levitation trick.

**Solution 2:** Allow divmod() to perform the heavy lifting.

For integers, the divmod() method returns (a / b, a % b) (due to round-off inaccuracy, this would be less accurate with floats). When there is a non-zero residual, the bool(r) step adds one to the quotient.

**Solution 3:** Before dividing, adjust the numerator.

Round down to the required ceiling by translating the numerator upwards. It’s worth noting that this only works with integers.

**Solution 4:** To use math.ceil, convert to floats ()

The math. ceil() function is simple to use, but it converts ints to floats and back. This isn’t particularly quick, and there may be difficulties with rounding. It also uses Python 3 semantics, in which “true division” yields a float and the ceil() method yields an integer.

**What’s the Difference Between Floor Division and Division?**

Both the / Division and // floor division operators work in the same way. // is floor division, therefore the result will always be the integer floor. The other is what is known as ‘regular’ division. The equation’s solution is rounded to the nearest smallest integer or float.

**A Simple Floor Division Example**

Normal division and floor division are comparable. It does, however, provide the greatest integer that is less than or equal to the result of the division.

Let’s look at the division below as an example:

100/3.

It will result in a total of 33, with 1 left over.

33 * 3 + 1 is another way of expressing it. Using floor division, we get the value of 33. The floor may be found using //.

100//3, for example, yields 25.

*Consider the following scenario:*

It will print the below output:

If you look at the output/result of the first action, you’ll notice that it’s an integer value. The remaining outcomes are also floating. Furthermore, it is similar to exponentiation and multiplication.

Let’s look at why the number 2 was rounded off instead of the number 3.

The nearest integer number that is smaller than the actual result is rounded off. The nearest integer smaller than 1.5 in the given example is 1. As an example,

Now let’s look at some negative numbers.

As a result, the given code produces the values -2 and -2.0. Why?

-1.5 and -1.5 are the results of the code with the / operator. The floor division (//) method rounds the result to the smallest integer number possible. In other words, -2 is less than -1. As a result, the outputs are -2 and -2.0.