TypeScript vs Python: Typisierung, Tempo und Einsatz im Vergleich

TypeScript und Python sind beide Hochsprachen mit Garbage Collection, Funktionen als vollwertigen Werten und großen Paket-Ökosystemen. Der Hauptunterschied ist die Typisierung: Die Typen von TypeScript prüft der Compiler, bevor das Programm läuft, und die Type Hints von Python sind optionale Annotationen, die der Interpreter ignoriert. Außerdem laufen sie auf unterschiedlichen Engines und dominieren unterschiedliche Arten von Software: TypeScript das Web, Python die Arbeit mit Daten und Skripte.

Hier ein kleines Programm in TypeScript. Klick auf Run:

interface Order {
    customer: string;
    amount: number;
    paid: boolean;
}

function totalPaid(orders: Order[]): number {
    return orders.filter((o) => o.paid).reduce((sum, o) => sum + o.amount, 0);
}

const orders: Order[] = [
    { customer: "Ada", amount: 120, paid: true },
    { customer: "Grace", amount: 80.5, paid: false },
    { customer: "Linus", amount: 42.25, paid: true },
];

const byAmount = [...orders].sort((a, b) => b.amount - a.amount).map((o) => o.customer);
console.log(totalPaid(orders));
console.log(byAmount);

Ausgabe:

162.25
[ 'Ada', 'Grace', 'Linus' ]

Dasselbe Programm in Python, mit Type Hints:

from dataclasses import dataclass


@dataclass
class Order:
    customer: str
    amount: float
    paid: bool


def total_paid(orders: list[Order]) -> float:
    return sum(o.amount for o in orders if o.paid)


orders = [
    Order("Ada", 120.0, True),
    Order("Grace", 80.5, False),
    Order("Linus", 42.25, True),
]

by_amount = [o.customer for o in sorted(orders, key=lambda o: o.amount, reverse=True)]
print(total_paid(orders))
print(by_amount)

162.25
['Ada', 'Grace', 'Linus']

Der Aufbau ist ähnlich: ein Typ für den Datensatz, eine Funktion mit typisierten Parametern, eine Liste von Werten. Die sichtbaren Unterschiede sind die Syntax (geschweifte Klammern und Semikolons gegenüber Einrückung), interface gegenüber einer @dataclass und Arrow Functions mit filter/reduce gegenüber einem Generatorausdruck.

TypeScript vs Python im Überblick

Syntax im direkten Vergleich

Wenn du die Type Hints von Python kennst, haben die meisten TypeScript-Annotationen ein direktes Gegenstück:

Statische Typen vs Type Hints

In beiden Sprachen kannst du dieselbe Annotation schreiben, a: number oder a: int. Was danach passiert, ist verschieden.

In TypeScript prüft der Compiler jeden Aufruf, bevor irgendetwas läuft. Ein falsches Argument stoppt den Build:

// This does not compile: TypeScript checks the call before running it.
function add(a: number, b: number): number {
    return a + b;
}

console.log(add(2, 3));
console.log(add("2", "3"));

index.ts(7,17): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.

In Python sind die Hints Metadaten. Der Interpreter führt den Aufruf aus und gibt einen String zurück:

def add(a: int, b: int) -> int:
    return a + b


print(add(2, 3))      # 5
print(add("2", "3"))  # 23, the hints are not enforced

Die Prüfung ist ein eigener Schritt mit einem Tool wie mypy:

$ mypy hints.py
hints.py:6: error: Argument 1 to "add" has incompatible type "str"; expected "int"  [arg-type]
hints.py:6: error: Argument 2 to "add" has incompatible type "str"; expected "int"  [arg-type]
Found 2 errors in 1 file (checked 1 source file)

Die Typisierung in Python ist also bewusst graduell: Code ohne Annotationen wird einfach nicht geprüft, und du ergänzt Hints dort, wo sie helfen. TypeScript kann auch locker sein (any schaltet die Prüfung für einen Wert ab), aber mit eingeschaltetem strict, dem Standard, ist ein Parameter ohne Annotation ein Fehler und kein Freifahrtschein.

Eines haben beide gemeinsam: Keine der beiden prüft Typen, während das Programm läuft. TypeScript entfernt seine Typen, und Python ignoriert seine Hints. Daten, die zur Laufzeit ankommen, etwa JSON von einer API, müssen in beiden Sprachen validiert werden (Bibliotheken wie Zod in TypeScript und Pydantic in Python erledigen das anhand eines Schemas).

Zahlen verhalten sich unterschiedlich

TypeScript hat die Zahlen von JavaScript: number ist ein 64-Bit-Gleitkommawert für ganze Zahlen und Brüche, und bigint ist ein eigener Typ für große ganze Zahlen. Das int von Python wächst von selbst auf jede Größe.

console.log(0.1 + 0.2);        // float rounding, same as Python
console.log(2 ** 53 + 1);      // beyond 2^53, not every integer fits in a number
console.log(7 / 2, Math.trunc(7 / 2));
console.log(2n ** 100n);       // bigint: exact, like Python's int

Ausgabe:

0.30000000000000004
9007199254740992
3.5 3
1267650600228229401496703205376n

Python gibt für 2**53 + 1 den Wert 9007199254740993 aus, weil seine ganzen Zahlen in jeder Größe exakt sind, und es hat einen eigenen Operator für ganzzahlige Division, 7 // 2, der 3 ergibt. In TypeScript gibt es keinen int-Typ; eine ganze Zahl ist ein number, das zufällig keinen Nachkommaanteil hat.

Laufzeit und Performance

TypeScript läuft als JavaScript. V8 (in Chrome und Node.js), JavaScriptCore (in Safari und Bun) und SpiderMonkey (in Firefox) kompilieren häufig ausgeführten Code während der Laufzeit in Maschinencode, also sind enge Schleifen in TypeScript meist deutlich schneller als dieselben Schleifen in CPython, das Bytecode ausführt.

Für viele Programme spielt dieser Abstand weniger eine Rolle, als es klingt:

• Die Bibliotheken von Python für Numerik und Machine Learning (NumPy, pandas, PyTorch) erledigen die schwere Arbeit in kompiliertem C-, C++- oder CUDA-Code. Ein Python-Programm, das sie aufruft, führt seine inneren Schleifen also nicht in Python aus.
• Webserver verbringen in beiden Sprachen viel Zeit mit Warten auf Datenbanken und Netzwerke.

Beide Sprachen nutzen für den meisten Code einen Hauptthread. TypeScript auf Node.js regelt Nebenläufigkeit mit einer Event Loop und async/await und nutzt Worker Threads für parallele Rechenarbeit. Python hat asyncio für denselben Stil der Nebenläufigkeit, dazu Threads und Prozesse.

Ökosysteme und Einsatzgebiete

TypeScript ist der Standard für:

• Web-Frontends: React, Angular, Vue und Svelte unterstützen es alle, und es wird zu dem JavaScript kompiliert, das Browser ausführen.
• Servercode auf Node.js, Deno und Bun: APIs mit Express, Fastify, NestJS oder Hono.
• Full-Stack-Apps, in denen Server und Browser Typdefinitionen teilen, etwa Next.js-Projekte.
• Tooling, Kommandozeilen-Tools und Desktop-Apps mit Electron.

Python ist der Standard für:

• Datenanalyse und Visualisierung (pandas, NumPy, Matplotlib, Jupyter Notebooks).
• Machine Learning und KI (PyTorch, scikit-learn und der Großteil des Codes zum Trainieren von Modellen).
• Skripte und Automatisierung: Dateiverarbeitung, Systemadministration, Glue Code.
• Web-Backends mit Django, Flask oder FastAPI.
• Wissenschaftliches Rechnen und Lehre.

Die Backend-Webentwicklung ist der Bereich, in dem sie sich am meisten überschneiden. Teams wählen oft nach dem Rest des Stacks: TypeScript, um Code mit einem TypeScript-Frontend zu teilen, Python, um neben Daten- und ML-Code zu stehen.

Welche Sprache solltest du lernen?

• Du baust für das Web? Lerne JavaScript und dann TypeScript. Alles, was im Browser läuft, ist am Ende JavaScript, und TypeScript ist die Sprache, in der der meiste professionelle Frontend-Code geschrieben wird.
• Du arbeitest mit Daten, KI oder Automatisierung? Lerne Python. Seine Bibliotheken in diesen Bereichen haben in der JavaScript-Welt kein echtes Gegenstück.
• Erste Sprache, kein festes Ziel? Bei Python musst du weniger Syntax lernen, bevor du nützliche Programme schreiben kannst. TypeScript legt ein Typsystem über JavaScript, das am Anfang zusätzlichen Lernaufwand bedeutet und sich auszahlt, wenn Programme wachsen.

Viele Entwickler nutzen beide: Python für Daten und Skripte, TypeScript für den Webcode des Produkts. Wenn du die Type Hints von Python schon kennst, werden dir die Annotationen von TypeScript vertraut vorkommen; neu ist, dass der Compiler sie standardmäßig durchsetzt und dass darunter JavaScript als Laufzeit liegt.