# Python Modulus Operator

The modulus operator in Python is represented by the `%` symbol. It returns the remainder of a division operation.

For example:

```10 % 3
```

The output would be `1`, because 3 goes into 10 three times with 1 left over.

The modulus operator can be used with both positive and negative numbers:

```-10 % 3
```

The output would be `2`, because -10 divided by 3 is -3 with a remainder of 2.

The modulus operator is commonly used to check whether a number is even or odd:

```x = 5
if x % 2 == 0:
print("even")
else:
print("odd")
```

This code would output `"odd"`, because 5 is an odd number. If `x` were an even number, the code would output `"even"`.

### Get the modulus of two float numbers:

To get the modulus of two integers using a while loop in Python, you can use the following code:

```dividend = int(input("Enter dividend: "))
divisor = int(input("Enter divisor: "))

modulus = dividend

while modulus >= divisor:
modulus -= divisor

print("Modulus:", modulus)
```

Here, the program takes two integers as input from the user – `dividend` and `divisor`. It then initializes the `modulus` variable to the value of `dividend`.

The while loop is used to repeatedly subtract `divisor` from `modulus` until `modulus` is less than `divisor`. At this point, the value of `modulus` is the remainder or modulus of `dividend` divided by `divisor`.

Finally, the program prints the value of `modulus`.

For example, if the user enters `10` as the dividend and `3` as the divisor, the output would be:

```Enter dividend: 10
Enter divisor: 3
Modulus: 1
```

### Get the modulus of two float numbers:

The modulus operator `%` can only be used with integer operands in Python. Therefore, if you try to use it with float operands, you will get a `TypeError`:

```>>> 10.5 % 3.2
TypeError: can't mod complex numbers.
```

However, you can use the `math` module in Python to get the modulus of two float numbers. Specifically, you can use the `math.fmod()` function, which takes two arguments and returns the modulus of the first argument divided by the second argument.

Here’s an example:

```import math

dividend = 10.5
divisor = 3.2

modulus = math.fmod(dividend, divisor)

print("Modulus:", modulus)
```

In this example, the `math.fmod()` function is used to compute the modulus of `dividend` divided by `divisor`, which is assigned to the variable `modulus`. The program then prints the value of `modulus`.

Note that the `math.fmod()` function differs from the `%` operator in the way it handles negative numbers. Specifically, the `math.fmod()` function returns a result with the same sign as the dividend, whereas the `%` operator returns a result with the same sign as the divisor.

### Get the modulus of a negative number:

To get the modulus of a negative number in Python, you can use the modulus operator `%` or the `math.fmod()` function. However, it’s important to note that the result will depend on how Python handles integer division with negative numbers.

In Python, integer division with negative numbers rounds towards negative infinity. This means that the quotient of a division operation with a negative number will be rounded towards the more negative integer. For example:

```-7 // 3
```

The output would be `-3`, because `-7` divided by `3` is `-2.3333`, which rounds towards `-3`.

With this in mind, let’s look at two ways to get the modulus of a negative number:

Using the modulus operator `%`:

```num = -7
divisor = 3

modulus = num % divisor

print("Modulus:", modulus)
```

In this example, the modulus operator `%` is used to compute the remainder of `-7` divided by `3`. The result is `-1`, because `-7` divided by `3` is `-2` with a remainder of `-1`.

Using the `math.fmod()` function:

```import math

num = -7
divisor = 3

modulus = math.fmod(num, divisor)

print("Modulus:", modulus)
```

In this example, the `math.fmod()` function is used to compute the remainder of `-7` divided by `3`. The result is `-1`, because `-7` divided by `3` is `-2` with a remainder of `-1`.

Note that in both cases, the result of the modulus operation has the same sign as the dividend (`num`).

### Get the modulus of two numbers using fmod() function:

The `math.fmod()` function in Python can be used to get the modulus of two numbers, similar to the `%` operator. However, there are some differences in how the two approaches handle certain cases, such as negative numbers.

Here’s an example of using `math.fmod()` to get the modulus of two numbers:

```import math

dividend = 10
divisor = 3

modulus = math.fmod(dividend, divisor)

print("Modulus:", modulus)
```

In this example, the `math.fmod()` function is used to compute the remainder of `dividend` divided by `divisor`. The result is `1.0`, because `10` divided by `3` is `3` with a remainder of `1`.

Note that the result of `math.fmod()` may be a floating-point number, whereas the `%` operator always returns an integer. Also, `math.fmod()` behaves differently than `%` when dealing with negative numbers. Specifically, `math.fmod()` returns a result with the same sign as the dividend (`dividend` in this case), whereas `%` returns a result with the same sign as the divisor (`divisor` in this case).

Here’s an example that shows how `math.fmod()` handles negative numbers:

```import math

dividend = -10
divisor = 3

modulus = math.fmod(dividend, divisor)

print("Modulus:", modulus)
```

In this example, the result is `-1.0`, because `-10` divided by `3` is `-3` with a remainder of `-1`, and `math.fmod()` returns a result with the same sign as `-10`.

### Get the modulus of n numbers using function:

To get the modulus of `n` numbers using a function in Python, you can create a function that takes a list of numbers as an argument and uses a loop to compute the modulus of each number in the list.

Here’s an example implementation of such a function:

```import math

def get_modulus(numbers):
result = numbers
for i in range(1, len(numbers)):
result = math.fmod(result, numbers[i])
return result
```

In this function, the `math.fmod()` function is used to compute the modulus of each number in the input list. The function starts by initializing the `result` variable to the first number in the list. Then, it uses a loop to iterate over the remaining numbers in the list, updating `result` with the modulus of each number and the current value of `result`. Finally, the function returns the result of the last modulus operation.

You can call this function with a list of numbers to get the modulus of all the numbers in the list. For example:

```numbers = [10, 3, 4, 2]
modulus = get_modulus(numbers)
print("Modulus:", modulus)
```

In this example, the `get_modulus()` function is called with a list of four numbers (`10`, `3`, `4`, and `2`). The function computes the modulus of these numbers using `math.fmod()` and returns the result (`0.0` in this case), which is then printed to the console.

### Get the modulus of given array using mod() function:

In Python, there is no built-in `mod()` function. However, you can use the modulus operator `%` to get the modulus of a given array.

Here’s an example implementation that uses the `%` operator to get the modulus of a given array:

```def get_modulus(numbers):
result = numbers
for i in range(1, len(numbers)):
result = result % numbers[i]
return result
```

In this function, the modulus operator `%` is used to compute the modulus of each number in the input list. The function starts by initializing the `result` variable to the first number in the list. Then, it uses a loop to iterate over the remaining numbers in the list, updating `result` with the modulus of each number and the current value of `result`. Finally, the function returns the result of the last modulus operation.

You can call this function with an array of numbers to get the modulus of all the numbers in the array. For example:

```numbers = [10, 3, 4, 2]
modulus = get_modulus(numbers)
print("Modulus:", modulus)
```

In this example, the `get_modulus()` function is called with an array of four numbers (`10`, `3`, `4`, and `2`). The function computes the modulus of these numbers using `%` operator and returns the result (`0` in this case), which is then printed to the console.

### Get the modulus of two numbers using numpy.:

In Python, you can also use the NumPy library to get the modulus of two numbers. NumPy provides a function called `np.mod()` that can be used to compute the modulus of two numbers.

Here’s an example implementation that uses the `np.mod()` function:

```import numpy as np

dividend = 10
divisor = 3

modulus = np.mod(dividend, divisor)

print("Modulus:", modulus)
```

In this code, we import NumPy using the `import` statement and then use the `np.mod()` function to compute the modulus of `dividend` divided by `divisor`. The result is `1`, because `10` divided by `3` is `3` with a remainder of `1`.

Note that `np.mod()` behaves similarly to the `%` operator in that it returns an integer result and behaves differently than `math.fmod()` when dealing with negative numbers. Specifically, `np.mod()` returns a result with the same sign as the divisor (`divisor` in this case), whereas `math.fmod()` returns a result with the same sign as the dividend (`dividend` in this case).

### Exceptions in Python Modulus operator:

In Python, the modulus operator `%` can raise exceptions in certain situations. Here are some common exceptions that can be raised when using the modulus operator:

1. ZeroDivisionError: This exception is raised when you try to divide a number by zero. For example:
```>>> 10 % 0
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: integer division or modulo by zero
```

2. TypeError: This exception is raised when you try to use the modulus operator on incompatible types. For example:

```>>> 'hello' % 3
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: not all arguments converted during string formatting
```

In this example, the string `'hello'` is not compatible with the integer `3`, so a `TypeError` is raised.

3. ValueError: This exception is raised when you try to use the modulus operator on non-numeric types. For example:

```>>> True % 2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: unsupported operand type(s) for %: 'bool' and 'int'
```

In this example, the boolean value `True` is not compatible with the integer `2`, so a `ValueError` is raised.

It’s important to handle these exceptions properly in your code to ensure that your program doesn’t crash or produce unexpected results. You can use try-except blocks to catch and handle these exceptions. For example:

```try:
result = num
```