Python Dataclasses: 10 Advanced Features That Make __init__ Obsolete

from dataclasses import dataclass, field
from typing import ClassVar

@dataclass
class APIRequest:
 url: str
 method: str = 'GET'
 
 # field() with factory — ALWAYS use for mutable defaults
 headers: dict = field(default_factory=dict) # ✅ new dict per instance
 # headers: dict = {} # ❌ shared across all instances!
 
 # field() with repr=False — hide sensitive data from print()
 api_key: str = field(default='', repr=False)
 
 # field() with compare=False — exclude from == comparison
 request_id: str = field(default='', compare=False)
 
 # field() with metadata — attach schema info, validation rules, etc.
 timeout: int = field(default=30, metadata={'min': 1, 'max': 300, 'unit': 'seconds'})
 
 # field() with init=False — computed, not passed to __init__
 _session_id: str = field(default='', init=False, repr=False)

# Access metadata programmatically:
from dataclasses import fields
for f in fields(APIRequest):
 if f.metadata.get('unit'):
 print(f"{f.name}: {f.metadata}") # timeout: {'min': 1, 'max': 300, 'unit': 'seconds'}

from dataclasses import dataclass, field
from datetime import datetime
import re

@dataclass
class User:
 name: str
 email: str
 age: int
 # Computed field — set in __post_init__, not __init__
 username: str = field(init=False)
 created_at: datetime = field(init=False)

 def __post_init__(self):
 # Validation
 if self.age < 0 or self.age > 150:
 raise ValueError(f"Invalid age: {self.age}")
 if not re.match(r'^[^@]+@[^@]+.[^@]+$', self.email):
 raise ValueError(f"Invalid email: {self.email}")
 
 # Computed fields
 self.username = self.email.split('@')[0].lower()
 self.created_at = datetime.utcnow()
 
 # Transform inputs
 self.name = self.name.strip().title()
 self.email = self.email.lower()

u = User(name=" alice smith ", email="Alice@Example.COM", age=30)
print(u.name) # Alice Smith (transformed)
print(u.email) # alice@example.com (normalized)
print(u.username) # alice (computed)
print(u.created_at) # 2026-04-05 ... (auto-set)

from dataclasses import dataclass

@dataclass(frozen=True)
class Point:
 x: float
 y: float

 # You CAN add methods to frozen dataclasses
 def distance_to(self, other: 'Point') -> float:
 return ((self.x - other.x)**2 + (self.y - other.y)**2) ** 0.5

p1 = Point(1.0, 2.0)
p2 = Point(3.0, 4.0)

# Immutable — assignment raises FrozenInstanceError
p1.x = 5.0 # ❌ FrozenInstanceError: cannot assign to field 'x'

# Hashable — can be used as dict keys or in sets!
cache = {p1: 'computed_value', p2: 'other_value'}
point_set = {p1, p2} # Works because frozen=True generates __hash__

# Equal objects have equal hashes
p3 = Point(1.0, 2.0)
print(p1 == p3) # True
print(hash(p1) == hash(p3)) # True — safe for dict keys

import sys
from dataclasses import dataclass

@dataclass
class PointNormal:
 x: float
 y: float
 z: float

@dataclass(slots=True) # Python 3.10+
class PointSlotted:
 x: float
 y: float
 z: float

p1 = PointNormal(1.0, 2.0, 3.0)
p2 = PointSlotted(1.0, 2.0, 3.0)

print(sys.getsizeof(p1)) # 48 bytes
print(sys.getsizeof(p1.__dict__)) # 232 bytes (hidden dict overhead)
print(sys.getsizeof(p2)) # 64 bytes — no __dict__!

# 1 million instances:
# Normal: ~280MB
# Slotted: ~64MB ← 77% less memory

# Combine with frozen for hashable, memory-efficient, immutable objects:
@dataclass(frozen=True, slots=True)
class Vector3D:
 x: float
 y: float
 z: float

from dataclasses import dataclass
from typing import ClassVar

@dataclass
class DatabaseModel:
 # ClassVar fields are NOT included in __init__, __repr__, or __eq__
 # They're class-level, shared across all instances
 table_name: ClassVar[str] = 'base_table'
 connection_pool: ClassVar[object] = None
 instance_count: ClassVar[int] = 0

 # These ARE instance fields (included in __init__)
 id: int
 name: str

 def __post_init__(self):
 DatabaseModel.instance_count += 1

 @classmethod
 def set_pool(cls, pool):
 cls.connection_pool = pool

@dataclass
class User(DatabaseModel):
 table_name: ClassVar[str] = 'users' # Override class variable
 email: str = ''

u1 = User(id=1, name='Alice', email='alice@example.com')
u2 = User(id=2, name='Bob', email='bob@example.com')
print(User.instance_count) # 2 — shared across instances
print(User.table_name) # 'users' — overridden in subclass

from dataclasses import dataclass

@dataclass
class Base:
 id: int
 name: str = 'default' # field with default

# ❌ This fails: non-default field after default field
@dataclass
class Child(Base):
 email: str # No default — TypeError: non-default argument after default

# ✅ Fix 1: Give email a default
@dataclass
class Child(Base):
 email: str = ''

# ✅ Fix 2: Use KW_ONLY (Python 3.10+) to make trailing fields keyword-only
from dataclasses import KW_ONLY
@dataclass
class Child(Base):
 _: KW_ONLY
 email: str # Now keyword-only — no ordering constraint

c = Child(id=1, email='alice@example.com') # name=default, email required as kwarg