# Calculating the Sum of Two Numbers in Python Without Arithmetic Operators [Multiple Approaches]

Written by

**Introduction**

When it comes to performing mathematical calculations in Python, the most common approach is to use built-in arithmetic operators such as +, -, *, and /.

However, there may be situations where using arithmetic operators is not possible or desirable. For example, when working with low-level hardware or embedded systems, it may be necessary to perform calculations without using arithmetic operators. In this article, we will discuss several approaches for calculating the sum of two numbers in Python without using arithmetic operators. Various approaches

## Using bin() function:

One of the most straightforward approaches for calculating the sum of two numbers without using arithmetic operators is to use the built-in bin() function to convert the numbers to their binary representation. Then, using bitwise operators, we can perform bit-level manipulation to calculate the sum.

```
def add(a, b):
while b:
# carrying
carry = a & b
# sum of bits
a = a ^ b
# carry is shifted by one so that adding it to a gives the required sum
b = carry << 1
return a
print(add(10, 20))
```

In this example, we first use the bitwise operator `&`

to calculate the carry, which is the common set of 1-bits between the two numbers. Next, we use the bitwise operator `^`

to calculate the sum of the bits without the carry. Finally, we left-shift the carry by one and add it to the sum, which gives the final result.

## Using recursion:

Another approach is to use recursion to calculate the sum of two numbers without using arithmetic operators. The basic idea behind this approach is to divide the problem into smaller sub-problems and use recursion to solve them. Here is an example:

```
def add(a, b):
if b == 0:
return a
else:
return add(a^b, (a&b) << 1)
print(add(10, 20))
```

In this example, we use a recursive function add() to calculate the sum of two numbers. The base case for the recursion is when the second number is zero, in which case we return the first number. In all other cases, we first use the bitwise operator ^ to calculate the sum and the operator & to calculate the carry. We left-shift the carry by one, and then recursively call the add function with the sum and the carry as the input parameters. We return the final answer once the recursion stops when the second number becomes zero.

## Using the sum() function:

The built-in sum() function can also be used to find the sum of two numbers by passing the two numbers as an iterable.

```
print(sum([a,b]))
```

The iterable can have any number of numbers inside it.

## Using the math.fsum() function:

The built-in math module provides a function fsum() which can be used to calculate the sum of a list of numbers. We can make use of this function by passing the two numbers we want to add as a list.

```
Import math
print(math.fsum([a,b]))
```

## Conclusions

All of these approaches provide a way to calculate the sum of two numbers in Python without using arithmetic operators. Each approach has its own advantages and disadvantages, and the best approach for a given problem will depend on the specific constraints and requirements of the problem. For example, the bitwise operator approach may be more efficient for working with low-level hardware. It's worth noting that these methods may not be the most efficient way of solving this problem but they demonstrate different ways of thinking about a problem and are beneficial for problem-solving, troubleshooting and for cases when the operations are not allowed.