TypeScript vs Python: tipagem, velocidade e usos comparados

TypeScript e Python são linguagens de alto nível com garbage collector, funções de primeira classe e grandes ecossistemas de pacotes. A principal diferença é a tipagem: os tipos do TypeScript são verificados pelo compilador antes de o programa rodar, e os type hints do Python são anotações opcionais que o interpretador ignora. Elas também rodam em engines diferentes e dominam tipos diferentes de software: o TypeScript, a web; o Python, o trabalho com dados e os scripts.

Aqui está um pequeno programa em TypeScript. Clique em 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);

Saída:

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

O mesmo programa em Python, com 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']

A estrutura é parecida: um tipo para o registro, uma função com parâmetros tipados, uma lista de valores. As diferenças visíveis são a sintaxe (chaves e ponto e vírgula contra indentação), interface contra um @dataclass, e arrow functions com filter/reduce contra uma generator expression.

TypeScript vs Python em resumo

Sintaxe lado a lado

Se você conhece os type hints do Python, a maioria das anotações do TypeScript tem uma equivalente direta:

Tipos estáticos vs type hints

As duas linguagens permitem escrever a mesma anotação, a: number ou a: int. O que acontece depois é diferente.

No TypeScript, o compilador verifica cada chamada antes de qualquer coisa rodar. Um argumento errado impede o 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'.

No Python, os hints são metadados. O interpretador executa a chamada e retorna uma string:

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

A verificação é um passo separado, com uma ferramenta como o 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)

Então a tipagem do Python é gradual por design: código sem anotação simplesmente não é verificado, e você acrescenta hints onde eles ajudam. O TypeScript também pode ser frouxo (any desliga a verificação de um valor), mas com strict ligado, que é o padrão, um parâmetro sem anotação é um erro, e não um passe livre.

Uma coisa as duas têm em comum: nenhuma verifica tipos enquanto o programa roda. O TypeScript apaga os tipos, e o Python ignora os hints. Dados que chegam em tempo de execução, como o JSON de uma API, precisam de validação nas duas linguagens (bibliotecas como Zod no TypeScript e Pydantic no Python fazem isso a partir de um schema).

Os números se comportam de forma diferente

O TypeScript tem os números do JavaScript: number é um valor de ponto flutuante de 64 bits, tanto para inteiros quanto para frações, e bigint é um tipo separado para inteiros grandes. O int do Python cresce até qualquer tamanho sozinho.

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

Saída:

0.30000000000000004
9007199254740992
3.5 3
1267650600228229401496703205376n

O Python imprime 9007199254740993 para 2**53 + 1, já que seus inteiros são exatos em qualquer tamanho, e tem um operador próprio de divisão inteira, 7 // 2, que dá 3. Não existe tipo int no TypeScript; um inteiro é um number que por acaso não tem parte fracionária.

Runtime e desempenho

O TypeScript roda como JavaScript. O V8 (no Chrome e no Node.js), o JavaScriptCore (no Safari e no Bun) e o SpiderMonkey (no Firefox) compilam o código mais usado para código de máquina enquanto ele roda, então loops apertados em TypeScript costumam ser bem mais rápidos que os mesmos loops no CPython, que executa bytecode.

Essa diferença importa menos do que parece em muitos programas:

• As bibliotecas numéricas e de machine learning do Python (NumPy, pandas, PyTorch) fazem o trabalho pesado em código compilado de C, C++ ou CUDA, então um programa Python que as chama não roda seus loops internos em Python.
• Servidores web nas duas linguagens passam boa parte do tempo esperando bancos de dados e a rede.

As duas linguagens usam uma thread principal para a maior parte do código. O TypeScript no Node.js lida com concorrência usando um event loop e async/await, e usa worker threads para trabalho paralelo de CPU. O Python tem asyncio para o mesmo estilo de concorrência, além de threads e processos.

Ecossistemas e casos de uso

TypeScript é o padrão para:

• Front ends web: React, Angular, Vue e Svelte têm suporte, e ele compila para o JavaScript que os navegadores rodam.
• Código de servidor em Node.js, Deno e Bun: APIs com Express, Fastify, NestJS ou Hono.
• Apps full stack em que o servidor e o navegador compartilham definições de tipo, como projetos Next.js.
• Ferramentas, ferramentas de linha de comando e apps desktop com Electron.

Python é o padrão para:

• Análise e visualização de dados (pandas, NumPy, Matplotlib, notebooks Jupyter).
• Machine learning e IA (PyTorch, scikit-learn e a maior parte do código de treinamento de modelos).
• Scripts e automação: processamento de arquivos, administração de sistemas, código de integração.
• Back ends web com Django, Flask ou FastAPI.
• Computação científica e ensino.

O desenvolvimento de back end web é onde elas mais se sobrepõem. Times costumam escolher pelo que o resto da stack usa: TypeScript para compartilhar código com um front end em TypeScript, Python para ficar perto do código de dados e ML.

Qual aprender?

• Vai construir para a web? Aprenda JavaScript e depois TypeScript. Tudo o que roda no navegador é JavaScript no fim das contas, e TypeScript é como a maior parte do código profissional de front end é escrita.
• Vai trabalhar com dados, IA ou automação? Aprenda Python. As bibliotecas dele nessas áreas não têm equivalente real no mundo JavaScript.
• Primeira linguagem, sem objetivo definido? Python tem menos sintaxe para aprender antes de você escrever programas úteis. O TypeScript acrescenta um sistema de tipos ao JavaScript, o que é mais coisa para aprender no começo e compensa à medida que os programas crescem.

Muitos desenvolvedores usam as duas: Python para dados e scripts, TypeScript para o código web do produto. Se você já conhece os type hints do Python, as anotações do TypeScript vão parecer familiares; as novidades são que o compilador as aplica por padrão e que o runtime por baixo é JavaScript.