# 5 Best Ways to Perform Complex Number Addition in Python

Python Complex Number Additionπ‘ Problem Formulation: In Python, adding complex numbers is a common operation for those working with mathematical or engineering applications. A complex number has a real part and an imaginary part, typically defined as `a + bj`. For instance, given two complex numbers `3 + 4j` and `5 + 6j`, we aim to find the sum `8 + 10j`.

## Method 1: Using the + Operator

Python inherently supports complex numbers and their addition using the `+` operator. This operation adds the real parts and the imaginary parts separately, returning a new complex number with the summed components.

Here’s an example:

```complex_num1 = 3 + 4j
complex_num2 = 5 + 6j
result = complex_num1 + complex_num2
print(result)```

Output: `(8+10j)`

This snippet demonstrates the most straightforward method to add two complex numbers in Python. The `+` operator handles the addition, and the result is a new complex number.

## Method 2: Using complex() Constructor

The `complex(real, imag)` constructor creates a complex number in Python. To add complex numbers, create both using `complex()` and then add them using the `+` operator.

Here’s an example:

```complex_num1 = complex(3, 4)
complex_num2 = complex(5, 6)
result = complex_num1 + complex_num2
print(result)```

Output: `(8+10j)`

By using the `complex()` constructor, we can explicitly create complex numbers from their real and imaginary parts, then add them as in the previous method.

## Method 3: Adding Complex Numbers from Lists

Given lists of real and imaginary parts, you can perform addition by using Python’s list comprehensions and the zip function to pair and add corresponding elements.

Here’s an example:

```reals = [3, 5]
imags = [4, 6]
result = [complex(r, i) for r, i in zip(reals, imags)]
sum_result = sum(result, complex(0, 0))
print(sum_result)```

Output: `(8+10j)`

This code creates a list of complex numbers and then uses `sum()` with an initial value of `complex(0, 0)` to arrive at the final added complex number.

## Method 4: Using a Custom Function

If you’re looking for more control or want to encapsulate complex number addition, you can define a custom function that performs the addition manually.

Here’s an example:

```def add_complex(c1, c2):
return (c1.real + c2.real) + (c1.imag + c2.imag) * 1j

complex_num1 = 3 + 4j
complex_num2 = 5 + 6j
print(result)```

Output: `(8+10j)`

In this custom function, `add_complex()`, we directly access the `.real` and `.imag` properties of the complex number objects and return the result as a new complex number.

## Bonus One-Liner Method 5: Using NumPy

If you’re using NumPy, complex number addition can be done through its array capabilities which handle complex numbers efficiently when dealing with large datasets or matrices.

Here’s an example:

```import numpy as np

complex_num1 = np.array([3 + 4j])
complex_num2 = np.array([5 + 6j])
Output: `[8.+10.j]`
This code snippet demonstrates complex number addition using NumPy’s `add()` function, which is vectorized for better performance on arrays of numbers.