Python for JS Devs · Fundamentals

Classes & dataclasses

Same OOP concepts, three surprises: explicit self, __init__, and dunder methods. Plus dataclasses, the "just give me a struct" shortcut.

1 · A class, mapped from JS

class User {
  constructor(name) {
    this.name = name;
  }
  greet() {
    return `hi ${this.name}`;
  }
}
new User("kd").greet();

class User:
    def __init__(self, name: str):
        self.name = name        # no `this`; explicit self

    def greet(self) -> str:
        return f"hi {self.name}"

User("kd").greet()          # no `new` keyword

Three deltas:

• __init__ is the constructor (a "dunder" — double-underscore method).
• self is explicit — every method takes it as the first parameter, and you access instance state as self.x. There is no implicit this.
• No new. You call the class like a function: User("kd").

2 · Dunder methods = protocols

Special __name__ methods hook your object into language features — the equivalent of implementing an interface. The two you'll use most:

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __repr__(self):          # dev-friendly string (like toString)
        return f"Point({self.x}, {self.y})"
    def __eq__(self, other):       # makes == compare by value
        return (self.x, self.y) == (other.x, other.y)

3 · dataclasses — skip the boilerplate

Most classes are just data holders. A @dataclass auto-generates __init__, __repr__, and __eq__ from typed fields. Think of it as a typed struct.

interface User {
  name: string;
  age: number;
  active: boolean;
}

from dataclasses import dataclass

@dataclass
class User:
    name: str
    age: int
    active: bool = True   # default

User("kd", 30)          # __init__ generated for you

Check yourself