Синтаксис и типы: Python глазами JS/TS-разработчика

Блоки — это отступы; переменные — просто имена

В Python нет фигурных скобок и точек с запятой. Блок — это набор строк с одним отступом под строкой-заголовком, оканчивающейся на :. Отступ и есть синтаксис: смешать табы с пробелами или сбиться на один пробел — это IndentationError, а не косметика. Стандарт сообщества (PEP 8) — четыре пробела.

def classify(n: int) -> str:
    if n < 0:
        return "negative"
    elif n == 0:
        return "zero"
    return "positive"          # тот же уровень, что и if → всё ещё в classify

Переменным не нужно ключевое слово. Нет ни let, ни const, ни var: присваивание одновременно объявляет и связывает. А имя — это ссылка на объект, ровно как ссылка на объект в JS: b = a не копирует список, а заставляет b указывать на тот же список, поэтому мутация через одно имя видна через другое. Встроенного const в Python нет; неизменяемость — свойство значения (кортежи, строки, frozenset неизменяемы), а не связывания.

a = [1, 2, 3]
b = a            # b ссылается на ТОТ ЖЕ список, без копии
b.append(4)
print(a)         # [1, 2, 3, 4] — мутировано через b

Числовая башня: int, float и два оператора деления

В JavaScript один числовой тип — IEEE-754 double, — поэтому 9999999999999999 тихо теряет точность. int в Python — произвольной точности: растёт до любого нужного размера, без переполнения, без тихого округления. float — тот самый IEEE-754 double. Ловушка для JS-разработчика — деление: / всегда даёт float, даже на двух int, а // — это деление с округлением вниз (к минус бесконечности).

type(2 ** 100)        # <class 'int'> — 1267650600228229401496703205376, точно
7 / 2                 # 3.5    (float, всегда)
7 // 2                # 3      (деление вниз, int)
-7 // 2               # -4     (округляет к -бесконечности, не к нулю)
7 % 3                 # 1      (остаток)

Строки — неизменяемые последовательности. Интерполяция — это f-string, шаблонный литерал Python, с {} вместо ${}; внутрь можно класть любое выражение: f"{name} has {len(items)} items". Неявного приведения числа к строке нет: "x" + 1 — это TypeError, а не "x1".

Truthiness, None и ловушка == против is

Как и в JS, в Python есть truthiness, но набор «ложных» значений другой: False, None, 0, 0.0, "" и любая пустая коллекция ([], {}, (), set()) ложны; всё остальное истинно. Поэтому if items: — идиоматичная проверка «список непуст?», без отдельной церемонии length > 0.

None — единственное «никакое» значение Python: оно заменяет оба JS-значения null и undefined. undefined нет; отсутствующий атрибут бросает ошибку, отсутствующий ключ словаря бросает, а отсутствующий аргумент берёт значение по умолчанию, которое ты объявил (часто None). Идиоматичная проверка — if x is None:, а не == None, потому что None — синглтон, и идентичность точна и быстра.

Отсюда главная ловушка. == сравнивает значение; is сравнивает идентичность (указывают ли два имени на буквально один и тот же объект в памяти). В JS нет точного аналога is — === для примитивов всё равно сравнение по значению. Спутать их — классический баг, и он коварен из-за кэширования маленьких int: CPython заранее создаёт целые от −5 до 256, поэтому is случайно возвращает True для маленьких int и False для больших.

a = 256;  b = 256
a is b          # True  — оба указывают на ОДИН кэшированный объект

x = 257;  y = 257
x is y          # False — два разных объекта (равны по значению, не по идентичности)
x == y          # True  — сравнение значений, которое тебе и было нужно

[] == []        # True  — равны по значению
[] is []        # False — два отдельных объекта-списка

Правило: используй is только для None, True, False и объектов-маркеров (sentinel); == — для всего остального. Сами bool — подкласс int: True == 1 и False == 0 дают True, — ещё один острый угол при нестрогих сравнениях.

Type hints описывают, но не принуждают

Если ты пришёл из TypeScript с ожиданием, что аннотация параметра как int реально остановит str в рантайме, — этот раздел сэкономит тебе инцидент в проде.

Это самое глубокое отличие от TypeScript. Type hints в Python (PEP 484) выглядят как аннотации TS — def f(x: int) -> str:, count: int = 0, items: list[str], — но интерпретатор игнорирует их в рантайме. Передать str туда, где аннотирован int, проходит нормально, пока что-нибудь реально не сломается на значении. Hints проверяет статически отдельный инструмент — mypy или pyright, который ты запускаешь в CI; по сути это совещательные метаданные в __annotations__.

def repeat(s: str, n: int) -> str:
    return s * n

repeat("ab", 3)       # 'ababab' — корректно
repeat(3, "x")        # hint сказал int/str; Python не проверяет — узнаешь через баг

Контраст с TS тонкий. Типы TS тоже стираются при компиляции — в рантайме их тоже нет. Разница в экосистеме и принуждении: в TS код, не прошедший проверку типов, обычно не отгружается (сборка падает); в Python программа запускается независимо от того, запускал ли ты mypy. Считай hints документацией, которую может проверить чекер, а не рантайм-защитой. Нужна валидация в рантайме — это библиотека (Pydantic, dataclasses с проверками), а не система типов.