Die Python-Funktion pow(base, exp) berechnet base hoch exp — funktional identisch zum Operator **. Der echte Mehrwert liegt im dritten Argument: pow(base, exp, mod) führt eine modulare Exponentiation in einem Schritt aus, deutlich schneller und speicher-effizienter als (base ** exp) % mod. Damit ist pow() das Werkzeug der Wahl in Kryptografie- und Number-Theory-Anwendungen.
Einleitung
Die zweistellige Form pow(x, y) ist äquivalent zu x ** y und akzeptiert sowohl Ganzzahlen als auch Floats — auch negative Exponenten (Kehrwert) und nicht-ganzzahlige Exponenten (Wurzeln).
Die dreistellige Form pow(x, y, z) berechnet (x ** y) % z — aber ohne die Riesenzahl x ** y jemals zu erzeugen. Bei großen Exponenten ist das ein gewaltiger Performance-Unterschied. Diese Operation heißt Modulare Exponentiation und ist Grundbaustein von RSA, Diffie-Hellman, Elliptic Curve Cryptography und vielen Number-Theory-Algorithmen.
Seit Python 3.8 unterstützt die dreistellige Form auch modulares Inverses: pow(x, -1, m) liefert das modulare Inverse von x modulo m.
Syntax
pow(base, exp)
pow(base, exp, mod)base Basis. Zahl (int, float, complex).
exp Exponent. Zahl. Bei dritten Argument muss exp ganzzahlig sein.
mod (Optional) Modulus. Wenn gesetzt, wird (base ** exp) % mod berechnet — ganzzahlig.
Rückgabewert
Das Ergebnis der Potenzrechnung — bei Modulo immer als int, bei Floats ein float.
Beispiele
Standard-Exponentiation
pow(x, y) und x ** y liefern dasselbe — pow() ist nützlich, wenn man die Funktion z. B. an map() weiterreichen möchte:
print(pow(2, 10))
print(pow(3, 4))
print(2 ** 10) # gleicher Effekt1024
81
1024Negative und Float-Exponenten
Negative Exponenten ergeben Kehrwerte, gebrochene Exponenten Wurzeln:
print(pow(2, -3)) # 1/8
print(pow(9, 0.5)) # √9
print(pow(8, 1/3)) # ³√80.125
3.0
2.0Modulare Exponentiation
Für Krypto-Anwendungen entscheidend: pow(a, b, n) ist um Größenordnungen schneller als (a ** b) % n bei großen Zahlen, weil intern „square-and-multiply" verwendet wird:
# 2^1000000 mod 1009 — ohne mod nicht praktikabel
print(pow(2, 1_000_000, 1009))496Praktische Beispiele
Modulares Inverses (Python 3.8+)
Mit pow(x, -1, m) lässt sich das multiplikative Inverse modulo m direkt berechnen — vorausgesetzt x und m sind teilerfremd:
# 3 * x ≡ 1 (mod 11) — gesucht: x
x = pow(3, -1, 11)
print(x)
print((3 * x) % 11) # Bestätigung4
1RSA-Verschlüsselung in 3 Zeilen
Das gesamte Herz von RSA ist eine modulare Exponentiation — pow() macht die Implementierung trivial:
# Mini-RSA mit kleinen Zahlen — nur zur Illustration!
p, q = 61, 53
n = p * q
e = 17
d = pow(e, -1, (p - 1) * (q - 1)) # privater Schlüssel
m = 65 # Klartext (Buchstabe 'A')
c = pow(m, e, n) # verschlüsseln
m_decrypted = pow(c, d, n) # entschlüsseln
print(f"Klartext: {m}, Cipher: {c}, Entschlüsselt: {m_decrypted}")Klartext: 65, Cipher: 1948, Entschlüsselt: 65Funktional einsetzen mit map()
Da pow() eine ganz normale Funktion ist (anders als der **-Operator), lässt sie sich problemlos an höhere Funktionen übergeben:
basen = [2, 3, 5, 7]
exponenten = [10, 5, 3, 2]
results = list(map(pow, basen, exponenten))
print(results)[1024, 243, 125, 49]Praktische Hinweise
pow()mitmod-Argument ist gewaltig schneller als(x ** y) % zfür große Zahlen — fast unerlässlich in Kryptografie.- Modulares Inverses:
pow(x, -1, m)setzt voraus, dassgcd(x, m) == 1(teilerfremd). - Float-Genauigkeit: für ganzzahlige Berechnungen
int-Argumente bevorzugen; Floats können Rundungsfehler einführen. - Komplexe Zahlen sind erlaubt:
pow(1j, 2)→(-1+0j). - Verwandte Funktionen:
math.sqrt(),math.log(),math.pow()(immer Float),math.gcd()für Teilerfremde.