Python Complex Numbers: A Comprehensive Guide to the Complex Data Type

What Are Complex Numbers in Python?

Definition

A complex number in Python is a number with two parts: a real part and an imaginary part , expressed as a + bj, where a is the real component, b is the imaginary component, and j represents the imaginary unit (√-1). Python uses j (common in engineering) instead of i (common in mathematics) to denote the imaginary unit. The complex type allows Python to perform arithmetic and other operations on these numbers natively.

Examples

Here are some examples of complex numbers in Python:

• 3 + 4j (real: 3, imaginary: 4)
• -1.2 + 0j (real: -1.2, imaginary: 0)
• 0 + 2j (real: 0, imaginary: 2)

You can verify the type using the type() function:

Copy codez = 3 + 4j
print(type(z)) # Output: <class 'complex'>

Properties of Python Complex Numbers

Structure

A complex number in Python is stored as a pair of double-precision floating-point numbers (per IEEE 754), one for the real part and one for the imaginary part. This provides about 15-17 decimal digits of precision for each component, similar to Python’s float type.

You can access these parts using attributes:

• .real: Returns the real part as a float.
• .imag: Returns the imaginary part as a float.

Copy codez = 3 + 4j
print(z.real) # 3.0
print(z.imag) # 4.0

Conjugate

The complex conjugate, where the imaginary part’s sign is flipped, is available via the .conjugate() method:

Copy codez = 3 + 4j
print(z.conjugate()) # (3-4j)

Magnitude and Phase

While not directly provided as attributes, you can calculate a complex number’s magnitude (absolute value) and phase (angle) using the abs() function and the cmath module:

Copy codeimport cmath 
z = 3 + 4j
print(abs(z)) # 5.0 (magnitude: sqrt(3^2 + 4^2))
print(cmath.phase(z)) # 0.9272952180016122 (phase in radians)

Declaring and Using Complex Numbers

Literal Declaration

Complex numbers can be written directly using the a + bj syntax:

Copy codez1 = 2 + 3j 
z2 = -1.5 + 2.5j
print(z1, z2) # (2+3j) (-1.5+2.5j)

Note: The imaginary part must follow a number (e.g., 1j, not just j):

Copy codez = 5 + 1j # Correct # 
z = 5 + j # SyntaxError

Using the complex() Constructor

You can also create complex numbers with the complex() function, passing real and imaginary parts:

Copy codez = complex(2, 3) # 2 + 3j
print(z) # (2+3j) 
z = complex(-1.5, 0) # -1.5 + 0j
print(z) # (-1.5+0j)

Input as Complex Numbers

To accept complex numbers from user input, parse a string or use separate inputs:

Copy codereal = float(input("Enter real part: ")) 
imag = float(input("Enter imaginary part: ")) 
z = complex(real, imag)
print(z) # e.g., (3+4j) if inputs are 3 and 4

Operations with Complex Numbers

Python supports a range of arithmetic operations for complex numbers, making them practical for mathematical computations.

Basic Arithmetic

• Addition (+) :

  Copy codez1 = 3 + 4j 
  z2 = 1 + 2j
  print(z1 + z2) # (4+6j)

• Subtraction (-) :

  Copy codeprint(z1 - z2) # (2+2j)

• Multiplication (*) :

  Copy codeprint(z1 * z2) # (-5+10j) [ (3*1 - 4*2) + (3*2 + 4*1)j ]

• Division (/) :

  Copy codeprint(z1 / z2) # (2.2-0.4j)

• Exponentiation (**) :

  Copy codeprint(z1 ** 2) # (-7+24j)

Mixed Operations

Complex numbers can operate with integers or floats, which are implicitly converted to complex numbers with zero imaginary parts:

Copy codez = 3 + 4j
print(z + 5) # (8+4j) [5 treated as 5 + 0j]
print(z * 2.0) # (6+8j) [2.0 treated as 2.0 + 0j]

Comparison Operations

Direct comparisons like <, >, <=, or >= are not supported for complex numbers due to their two-dimensional nature:

Copy code# z1 < z2 # Raises TypeError

However, equality (==) and inequality (!=) work:

Copy codez1 = 3 + 4j 
z2 = 3 + 4j
print(z1 == z2) # True
print(z1 != (1 + 2j)) # True

Type Conversion Involving Complex Numbers

Converting to Complex

The complex() function converts other types to complex numbers:

• From Integer :

  Copy codeprint(complex(5)) # (5+0j)

• From Float :

  Copy codeprint(complex(3.14)) # (3.14+0j)

• From String : Must match the a+bj format:

  Copy codeprint(complex("2+3j")) # (2+3j) #
  print(complex("abc")) # Raises ValueError

Converting Complex to Other Types

• To Float or Integer : Not directly possible due to the imaginary part; extract components first:

  Copy codez = 3 + 4j
  print(float(z.real)) # 3.0
  print(int(z.imag)) # 4

• To String :

  Copy codeprint(str(3 + 4j)) # "(3+4j)"

Implicit Conversion

In mixed operations, integers and floats are promoted to complex numbers:

Copy coderesult = 3 + 4j + 2.5
print(result) # (5.5+4j)

Complex Numbers in Real-World Use Cases

Solving Quadratic Equations

Complex numbers handle cases where the discriminant is negative:

Copy codeimport cmath 
a, b, c = 1, 0, 1 # x^2 + 1 = 0 
disc = b**2 - 4*a*c # -4 
root1 = (-b + cmath.sqrt(disc)) / (2*a) 
root2 = (-b - cmath.sqrt(disc)) / (2*a)
print(root1, root2) # (0+1j) (0-1j)

Signal Processing

They’re used to represent signals with phase and amplitude:

Copy codez = 1 + 1j # Signal with real and imaginary components 
magnitude = abs(z) # 1.4142135623730951 
phase = cmath.phase(z) # 0.7853981633974483 (45 degrees)

Electrical Engineering

Complex numbers model AC circuits with resistance and reactance:

Copy codeimpedance = 3 + 4j # Resistance 3Ω, Reactance 4Ω 
current = 2 + 0j 
voltage = impedance * current
print(voltage) # (6+8j)

Conclusion

Python’s complex data type provides a seamless way to work with complex numbers, blending real and imaginary components for advanced computations. From their straightforward declaration and built-in operations to their utility in solving real-world problems, complex numbers are a powerful feature of Python’s numeric arsenal. This blog has delved into their properties, operations, conversions, and applications, all illustrated with practical examples.