# Python Modulo Operator – Tutorial with Examples

The modulo operator, represented by the percent symbol (%), is a fundamental operator in Python used for performing division and finding the remainder of the division. It is an essential tool for many tasks in computer science and programming, and it is widely used in Python for many purposes, including arithmetic operations, string formatting, and data processing.

## Basics of the Modulo Operator

The modulo operator is used to perform division and find the remainder of the division of two numbers. The syntax for the modulo operator is:

```a % b
```

where ‘a’ and ‘b’ are operands. The operator returns the remainder of the division of ‘a’ by ‘b’.

For example:

```print(10 % 3)

# Output: 1
```

In this example, 10 divided by 3 is 3 with a remainder of 1, so the result of the expression is 1.

## Modulo Operator and Data Types

The modulo operator works with all numeric data types in Python, including integers, floating-point numbers, and complex numbers. It can also be used with mixed data types, but the result may depend on the type of the operands and the type coercion rules of Python.

### Integers

When used with integers, the modulo operator returns the remainder of the division of the two integers. For example:

```print(11 % 5)

# Output: 1
```

### Floating-Point Numbers

When used with floating-point numbers, the modulo operator returns the remainder of the division of the two numbers, represented as a floating-point number. For example:

```print(11.0 % 5)

# Output: 1.0
```

## The divmod() Function

In addition to the modulo operator, Python provides the built-in function ‘divmod()’ for performing division and finding the remainder. The ‘divmod()’ function takes two operands and returns a tuple of two values: the quotient and the remainder of the division of the operands. The syntax for the ‘divmod()’ function is:

```divmod(a, b)
```

For example:

```result = divmod(10, 3)
print(result)

# Output: (3, 1)
```

In this example, the result is a tuple (3, 1) representing the quotient and the remainder of the division of 10 by 3.

## Negative Operands

When used with negative operands, the modulo operator can return negative results. The sign of the result depends on the sign of the dividend and the sign of the divisor. For example:

```print(-11 % 5)

# Output: -1
```

In this example, the result of the expression is -1 because the dividend (-11) is negative and the divisor (5) is positive.

When the divisor is negative, the sign of the result depends on the sign of the dividend. For example:

```print(11 % -5)
# Output: 1
```

In this example, the result of the expression is 1 because the dividend (11) is positive and the divisor (-5) is negative.

If both the dividend and the divisor are negative, the result will also be negative:

```print(-11 % -5)
# Output: -1
```

## Precedence of the Modulo Operator

In Python, the modulo operator has lower precedence than arithmetic operators like addition, subtraction, multiplication, and division. This means that expressions containing the modulo operator will be evaluated according to the rules of operator precedence. For example:

```print(10 * 3 % 5)
# Output: 0
```

In this example, the expression is evaluated as:

```(10 * 3) % 5
# Output: 0
```

The expression inside the parentheses is evaluated first, resulting in 30. Then, the modulo operator is applied to 30 and 5, resulting in the final answer of 0.

It is a good practice to use parentheses to clarify the intended order of operations in complex expressions that contain multiple operators.

## Conclusion

The modulo operator is a fundamental operator in Python that is widely used for a variety of purposes. It is used to perform division and find the remainder of the division of two numbers. The operator works with all numeric data types and can return negative results depending on the signs of the operands. The ‘divmod()’ function provides a convenient alternative to the modulo operator for performing division and finding the remainder. The operator has lower precedence than arithmetic operators, and it is important to use parentheses to clarify the intended order of operations in complex expressions.