Complex Numbers in Python

Complex numbers are a fascinating mathematical concept that goes beyond our familiar world of real numbers. They find applications in various fields, from physics and engineering to signal processing and computer graphics. In this article, we will take a journey into the realm of complex numbers, exploring what they are, how to work with them in Python, and the real-world applications that make them so valuable.

What Are Complex Numbers?

Complex numbers, denoted as a + bi, consist of two parts: a real part (a) and an imaginary part (bi). In this representation, a and b are real numbers, and i is the imaginary unit, defined as i^2 = -1. These numbers are particularly useful in situations where real numbers alone can’t provide solutions, such as in the case of square roots of negative numbers.

In Python, complex numbers are built into the language, making it easy to perform arithmetic operations and manipulate them in various ways.

Creating Complex Numbers in Python

Python represents complex numbers using the j or J suffix for the imaginary part. Here’s how you can create complex numbers in Python:

if __name__ == "__main__":
    # Check if the script is the main program.

    # Define two complex numbers using different notations.
    z1 = 3 + 2j
    z2 = 1 - 4J

    # Print the values of z1 and z2.
    print("Complex Number z1:", z1)  # Output: (3+2j)
    print("Complex Number z2:", z2)  # Output: (1-4J)

These lines create two complex numbers: z1 with a real part of 3 and an imaginary part of 2, and z2 with a real part of 1 and an imaginary part of -4.

Basic Arithmetic with Complex Numbers

Python allows you to perform various arithmetic operations with complex numbers just like you would with real numbers. Let’s see some examples:

Addition and Subtraction:

if __name__ == "__main__":
    # Check if the script is the main program.

    # Define two complex numbers.
    z1 = 3 + 2j
    z2 = 1 - 4j

    # Add z1 and z2 to get the sum.
    sum_result = z1 + z2  # The result will be (4 - 2j).

    # Subtract z2 from z1 to get the difference.
    diff_result = z1 - z2  # The result will be (2 + 6j).

    # Print the results of addition and subtraction.
    print("Addition Result:", sum_result)
    print("Subtraction Result:", diff_result)

Multiplication and Division:

if __name__ == "__main__":
    # Check if the script is the main program.

    # Define two complex numbers.
    z1 = 3 + 2j
    z2 = 1 - 4j

    # Multiply z1 and z2 to get the result.
    mul_result = z1 * z2  # The result will be (11-10j).

    # Divide z1 by z2 to get the result.
    div_result = z1 / z2  # The result will be (-0.29411764705882354+0.8235294117647058j).

    # Print the results of multiplication and division.
    print("Multiplication Result:", mul_result)
    print("Division Result:", div_result)

Conjugate and Absolute Value (Magnitude)

Python also provides functions to obtain the conjugate and absolute value (magnitude) of complex numbers. The conjugate of a complex number, denoted as z*, is obtained by changing the sign of the imaginary part while keeping the real part intact.
The magnitude, often denoted as |z| or abs(z), is the distance of the complex number from the origin in the complex plane, calculated using the Pythagorean theorem:

if __name__ == "__main__":
    # Check if the script is the main program.

    # Create a complex number with a real part of 3 and an imaginary part of 4.
    z = 3 + 4j

    # Calculate the conjugate of the complex number 'z'.
    conjugate = z.conjugate()

    # Calculate the magnitude of the complex number 'z'.
    magnitude = abs(z)

    # Print the conjugate and magnitude of the complex number 'z'.
    print("Original Complex Number:", z)
    print("Conjugate:", conjugate)  # Output: (3-4j)
    print("Magnitude:", magnitude)  # Output: 5.0

Polar Form of Complex Numbers

In addition to the standard Cartesian form (a + bi), complex numbers can also be expressed in polar form (r * (cos(θ) + isin(θ))). Python’s cmath module provides functions to convert between these representations.

To convert a complex number to polar form:

import cmath

if __name__ == "__main__":
    # Check if the script is the main program.

    # Create a complex number z with a real part of 3 and an imaginary part of 4.
    z = 3 + 4j

    # Use the cmath.polar() function to convert z to its polar form.
    # This function returns two values: the magnitude r and the phase angle theta.
    r, theta = cmath.polar(z)

    # Print the original complex number z in Cartesian form.
    print("Original Complex Number (Cartesian Form):", z)

    # Print the magnitude r of the complex number (its distance from the origin).
    print("Magnitude (r):", r)

    # Print the phase angle theta in radians.
    print("Phase Angle (theta in radians):", theta)

To convert polar coordinates back to the Cartesian form:

import cmath

if __name__ == "__main__":
    # Check if the script is the main program.

    # Create a complex number z with a real part of 3 and an imaginary part of 4.
    z = 3 + 4j

    # Use the cmath.polar() function to convert z to its polar form.
    # This function returns two values: the magnitude r and the phase angle theta.
    r, theta = cmath.polar(z)

    # Convert the polar coordinates (r, theta) back to the Cartesian form.
    # This will reconstruct the original complex number.
    cartesian_z = cmath.rect(r, theta)

    # Print the complex number in Cartesian form, which should match the original z.
    print("Complex Number in Cartesian Form:", cartesian_z)

Polar form is particularly useful in problems involving complex exponentials, rotations, and phasors in engineering and physics.

Complex Numbers in Practical Applications

Complex numbers are not just mathematical curiosities; they find applications in various real-world scenarios, such as:

Electrical Engineering

In electrical engineering, complex numbers are used to represent impedance, which combines resistance and reactance. This allows engineers to analyze and design electrical circuits more effectively.

Control Systems

Complex numbers are used in control theory to analyze and design systems that control dynamic processes. The Laplace transform, a fundamental tool in control systems, uses complex numbers to simplify differential equations.

Quantum Mechanics

Quantum mechanics heavily relies on complex numbers to describe the behavior of quantum systems. The Schrödinger equation, which governs the evolution of quantum states, involves complex numbers.

Signal Processing

In signal processing, complex numbers are employed to analyze and manipulate signals in both the time and frequency domains. The fast Fourier transform (FFT) is a key algorithm that leverages complex numbers for efficient signal analysis.

Conclusion

Python’s built-in support for complex numbers makes it an excellent choice for working with these mathematical entities. From basic arithmetic to advanced applications in various scientific and engineering fields, Python provides the tools necessary to harness the power of complex numbers. So, whether you’re exploring quantum mechanics or designing a cutting-edge electrical circuit, Python’s got you covered when it comes to complex numbers. With Python’s versatility and the elegance of complex numbers, the possibilities are limitless.

I hope you found this article informative and useful. If you would like to receive more content, please consider subscribing to our newsletter.