A complex number is created from two real numbers. Python complex number can be created using complex() function as well as using direct assignment statement.

Complex numbers are mostly used where we define something using two real numbers. For example, a circuit element that is defined by Voltage (V) and Current (I). They are mostly used in geometry, calculus and scientific calculations.

Table of Contents

## Python Complex Numbers

Let’s first learn how to create complex numbers in python.

```
c = 1 + 2j
print(type(c))
print(c)
c1 = complex(2, 4)
print(type(c1))
print(c1)
```

Output:

```
<class 'complex'>
(1+2j)
<class 'complex'>
(2+4j)
```

Python complex numbers are of type `complex`

. Every complex number contains one real part and one imaginary part.

## Python Complex Numbers Attributes and Functions

Let’s look at some attributes and instance functions of complex numbers.

```
c = 1 + 2j
print('Real Part =', c.real)
print('Imaginary Part =', c.imag)
print('Complex conjugate =', c.conjugate())
```

Output:

```
Real Part = 1.0
Imaginary Part = 2.0
Complex conjugate = (1-2j)
```

## Complex Numbers Mathematical Calculations

Complex numbers support mathematical caluclations such as addition, subtraction, multiplication and division.

```
c = 1 + 2j
c1 = 2 + 4j
print('Addition =', c + c1)
print('Subtraction =', c - c1)
print('Multiplication =', c * c1)
print('Division =', c1 / c)
```

Output:

```
Addition = (3+6j)
Subtraction = (-1-2j)
Multiplication = (-6+8j)
Division = (2+0j)
```

Complex numbers don’t support comparison operators. If we try to execute `c < c1`

then the error message will be thrown as `TypeError: '<' not supported between instances of 'complex' and 'complex'`

.

## Python cmath module

Python cmath module provides access to mathematical functions for complex numbers. Let’s look at some of the important features of complex numbers and how we can use cmath module function to calculate them.

### Phase of Complex Number

The phase of a complex number is the angle between the real axis and the vector representing the imaginary part. Below image illustrates the phase of a complex number and how to get this value using cmath and math modules.

Note that the phase returned by math and cmath modules are in radians, we can use `numpy.degrees()`

function to convert it to degrees. The range of phase is from -π to +π (-pi to +pi) in radians and it’s equivalent to -180 to +180 degrees.

```
import cmath, math, numpy
c = 2 + 2j
# phase
phase = cmath.phase(c)
print('2 + 2j Phase =', phase)
print('Phase in Degrees =', numpy.degrees(phase))
print('-2 - 2j Phase =', cmath.phase(-2 - 2j), 'radians. Degrees =', numpy.degrees(cmath.phase(-2 - 2j)))
# we can get phase using math.atan2() function too
print('Complex number phase using math.atan2() =', math.atan2(2, 1))
```

Output:

```
2 + 2j Phase = 0.7853981633974483
Phase in Degrees = 45.0
-2 - 2j Phase = -2.356194490192345 radians. Degrees = -135.0
Complex number phase using math.atan2() = 1.1071487177940904
```

### Polar and Rectangular Coordinates

We can write a complex number in polar coordinates, which is a tuple of modulus and phase of the complex number.

We can use cmath.rect() function to create a complex number in rectangular format by passing modulus and phase as arguments.

```
c = 1 + 2j
modulus = abs(c)
phase = cmath.phase(c)
polar = cmath.polar(c)
print('Modulus =', modulus)
print('Phase =', phase)
print('Polar Coordinates =', polar)
print('Rectangular Coordinates =', cmath.rect(modulus, phase))
```

Output:

```
Modulus = 2.23606797749979
Phase = 1.1071487177940904
Polar Coordinates = (2.23606797749979, 1.1071487177940904)
Rectangular Coordinates = (1.0000000000000002+2j)
```

### cmath module constants

There are a bunch of constants in cmath module that are used in the complex number calculations.

```
print('π =', cmath.pi)
print('e =', cmath.e)
print('tau =', cmath.tau)
print('Positive infinity =', cmath.inf)
print('Positive Complex infinity =', cmath.infj)
print('NaN =', cmath.nan)
print('NaN Complex =', cmath.nanj)
```

Output:

```
π = 3.141592653589793
e = 2.718281828459045
tau = 6.283185307179586
Positive infinity = inf
Positive Complex infinity = infj
NaN = nan
NaN Complex = nanj
```

### Power and Log Functions

There are some useful functions for logarithmic and power operations.

```
c = 2 + 2j
print('e^c =', cmath.exp(c))
print('log2(c) =', cmath.log(c, 2))
print('log10(c) =', cmath.log10(c))
print('sqrt(c) =', cmath.sqrt(c))
```

Output:

```
e^c = (-3.074932320639359+6.71884969742825j)
log2(c) = (1.5000000000000002+1.1330900354567985j)
log10(c) = (0.4515449934959718+0.3410940884604603j)
sqrt(c) = (1.5537739740300374+0.6435942529055826j)
```

### Trigonometric Functions

```
c = 2 + 2j
print('arc sine =', cmath.asin(c))
print('arc cosine =', cmath.acos(c))
print('arc tangent =', cmath.atan(c))
print('sine =', cmath.sin(c))
print('cosine =', cmath.cos(c))
print('tangent =', cmath.tan(c))
```

Output:

```
arc sine = (0.7542491446980459+1.7343245214879666j)
arc cosine = (0.8165471820968505-1.7343245214879666j)
arc tangent = (1.311223269671635+0.2388778612568591j)
sine = (3.4209548611170133-1.5093064853236156j)
cosine = (-1.5656258353157435-3.2978948363112366j)
tangent = (-0.028392952868232294+1.0238355945704727j)
```

### Hyperbolic Functions

```
c = 2 + 2j
print('inverse hyperbolic sine =', cmath.asinh(c))
print('inverse hyperbolic cosine =', cmath.acosh(c))
print('inverse hyperbolic tangent =', cmath.atanh(c))
print('hyperbolic sine =', cmath.sinh(c))
print('hyperbolic cosine =', cmath.cosh(c))
print('hyperbolic tangent =', cmath.tanh(c))
```

Output:

```
inverse hyperbolic sine = (1.7343245214879666+0.7542491446980459j)
inverse hyperbolic cosine = (1.7343245214879666+0.8165471820968505j)
inverse hyperbolic tangent = (0.2388778612568591+1.311223269671635j)
hyperbolic sine = (-1.5093064853236156+3.4209548611170133j)
hyperbolic cosine = (-1.5656258353157435+3.2978948363112366j)
hyperbolic tangent = (1.0238355945704727-0.028392952868232294j)
```

### Classification Functions

There are some miscellaneous functions to check if the complex number is finite, infinite or nan. There is also a function to check if two complex numbers are close.

```
print(cmath.isfinite(2 + 2j)) # True
print(cmath.isfinite(cmath.inf + 2j)) # False
print(cmath.isinf(2 + 2j)) # False
print(cmath.isinf(cmath.inf + 2j)) # True
print(cmath.isinf(cmath.nan + 2j)) # False
print(cmath.isnan(2 + 2j)) # False
print(cmath.isnan(cmath.inf + 2j)) # False
print(cmath.isnan(cmath.nan + 2j)) # True
print(cmath.isclose(2+2j, 2.01+1.9j, rel_tol=0.05)) # True
print(cmath.isclose(2+2j, 2.01+1.9j, abs_tol=0.005)) # False
```

The output of each statement is provided in the comments.

Reference: API Doc

good article, requested to say limitation of QUAD integration package.

Dear Pankaj,

Nice article on python..can you provide code snippets for the same…