complex()

Einleitung

Komplexe Zahlen begegnen einem in Signalverarbeitung, Wechselstrom-Berechnungen, Quanten-Mechanik, 2D-Geometrie (Real = X, Imag = Y) und natürlich der Mathematik. Python hat sie als nativen Typ — kein Modul-Import nötig.

Komponenten-Zugriff über .real und .imag (beide float), Konjugierte über .conjugate(), Betrag über abs(). Arithmetik (+, -, *, /, **) funktioniert wie erwartet.

complex() akzeptiert:

• Zwei Zahlen — Real- und Imaginärteil.
• Einen String wie "3+4j" (kein Whitespace innen!).
• Eine einzelne Zahl — wird zum Realteil, Imag = 0.

Syntax

complex()                # → 0j
complex(real)            # → real + 0j
complex(real, imag)
complex("real+imagj")    # String parsen

Rückgabewert

Eine complex-Instanz mit den Attributen real und imag (beide float).

Beispiele

Verschiedene Konstruktor-Formen

complex() ist flexibel — die Literal-Form 3+4j ist aber meistens kürzer:

print(complex())
print(complex(2))
print(complex(3, 4))
print(complex("1+2j"))
print(3 + 4j)

0j
(2+0j)
(3+4j)
(1+2j)
(3+4j)

Arithmetik

Alle Standard-Operatoren funktionieren auf komplexen Zahlen — Multiplikation rotiert und skaliert:

a = 3 + 4j
b = 1 - 2j
print(a + b)
print(a * b)
print(a / b)
print(a ** 2)

(4+2j)
(11-2j)
(-1+2j)
(-7+24j)

Eigenschaften und Methoden

.real, .imag, .conjugate(), abs() und cmath decken die gängigen Operationen ab:

z = 3 + 4j
print(z.real)
print(z.imag)
print(z.conjugate())
print(abs(z))             # Betrag = √(3² + 4²) = 5

3.0
4.0
(3-4j)
5.0

Praktische Beispiele

2D-Punkt-Rotation als Komplex-Multiplikation

Komplexe Zahlen sind die eleganteste Art, 2D-Rotationen auszudrücken — Multiplikation mit e^(iθ) rotiert um den Winkel θ:

import cmath, math
point = 1 + 0j               # (1, 0)
rotation = cmath.exp(1j * math.pi / 2)   # 90° gegen den Uhrzeigersinn
rotated = point * rotation
print(round(rotated.real, 2), round(rotated.imag, 2))

0.0 1.0

Polarform und Rückkonvertierung

Mit cmath.polar() und cmath.rect() lassen sich Komplexzahlen in (Magnitude, Winkel) und zurück wandeln:

import cmath
z = 1 + 1j
magnitude, angle = cmath.polar(z)
print(f"|z| = {magnitude:.3f}, ∠z = {cmath.degrees(angle):.1f}°"
      if hasattr(cmath, "degrees") else f"|z| = {magnitude:.3f}")
# cmath hat keine degrees — math übernimmt
import math
print(f"|z| = {magnitude:.3f}, ∠z = {math.degrees(angle):.1f}°")

|z| = 1.414, ∠z = 45.0°

Wechselstrom-Beispiel: Impedanz berechnen

Komplexe Zahlen sind das Standard-Werkzeug für Impedanz-Berechnungen — Real = Widerstand, Imag = Reaktanz:

# Reihenschaltung aus R und L
R = 10              # Ohm
omega_L = 5         # Reaktanz der Spule
Z = complex(R, omega_L)
print(f"Impedanz: {Z} Ω")
print(f"Betrag:    {abs(Z):.3f} Ω")

Impedanz: (10+5j) Ω
Betrag:    11.180 Ω

Praktische Hinweise

• Literal Nj ist meist kürzer — 3+4j statt complex(3, 4).
• cmath-Modul für Funktionen wie sin, cos, exp, log, sqrt mit komplexem Input.
• Vergleich: Komplexe Zahlen unterstützen nur == und !=, kein </> (es gibt keine natürliche Ordnung in C).
• abs(z) liefert den Betrag (Modulus) — gleicher Algorithmus wie für reelle Zahlen.
• Verwandte Module: cmath (komplexe Mathematik), numpy (komplexe Arrays für Performance).