Создание именованных типов в Python: от кортежа до класса данных

Расширенные примеры использования именованных типов

Пример 1: NamedTuple с методами и вычисляемыми полями.

from typing import NamedTuple
import math

class Point(NamedTuple):
    x: float
    y: float

    def distance_to_origin(self) -> float:
        return math.hypot(self.x, self.y)

    def distance_to(self, other: 'Point') -> float:
        return math.hypot(self.x - other.x, self.y - other.y)

p1 = Point(3.0, 4.0)
p2 = Point(0.0, 0.0)
print(f'Distance to origin: {p1.distance_to_origin():.2f}')
print(f'Distance between p1 and p2: {p1.distance_to(p2):.2f}')

Distance to origin: 5.00
Distance between p1 and p2: 5.00

Пример 2: Наследование NamedTuple для расширения структуры.

from typing import NamedTuple

class Point2D(NamedTuple):
    x: int
    y: int

class Point3D(Point2D):
    z: int

p3 = Point3D(1, 2, 3)
print(p3)
print(p3.x, p3.y, p3.z)
print(p3[:2])  # срез как у кортежа

Point3D(x=1, y=2, z=3)
1 2 3
(1, 2)

Пример 3: Работа с collections.namedtuple: _make, _asdict, _fields, _replace.

from collections import namedtuple

Color = namedtuple('Color', ['red', 'green', 'blue'])
c = Color(255, 0, 0)
print(c._asdict())          # OrderedDict([('red', 255), ('green', 0), ('blue', 0)])
print(c._fields)            # ('red', 'green', 'blue')
c2 = Color._make([128, 128, 0])  # из итерируемого
print(c2)                   # Color(red=128, green=128, blue=0)
c3 = c._replace(blue=255)   # новая копия с изменённым полем
print(c3)                   # Color(red=255, green=0, blue=255)

OrderedDict([('red', 255), ('green', 0), ('blue', 0)])
('red', 'green', 'blue')
Color(red=128, green=128, blue=0)
Color(red=255, green=0, blue=255)

Пример 4: Dataclass с полями по умолчанию и вычисляемым полем через __post_init__.

from dataclasses import dataclass, field
from typing import List

@dataclass
class Student:
    name: str
    grades: List[float] = field(default_factory=list)
    average: float = field(init=False)

    def __post_init__(self):
        if self.grades:
            self.average = sum(self.grades) / len(self.grades)
        else:
            self.average = 0.0

s = Student('Alice', [4.0, 4.5, 3.8])
print(f'{s.name}, avg: {s.average:.2f}')
s.grades.append(5.0)  # можно изменять список
print(f'After append: grades={s.grades}')

Alice, avg: 4.10
After append: grades=[4.0, 4.5, 3.8, 5.0]

Пример 5: TypedDict в комбинации с функцией.

from typing import TypedDict

class Person(TypedDict, total=False):
    name: str
    age: int
    email: str

def create_person(data: Person) -> str:
    return f"{data.get('name', 'Unknown')} is {data.get('age', '?')} years old"

p1: Person = {'name': 'Max', 'age': 30}
print(create_person(p1))

p2: Person = {'email': 'test@example.com'}  # все поля опциональны
print(create_person(p2))

Max is 30 years old
Unknown is ? years old

Пример 6: Класс с __slots__ и сравнение памяти с обычным классом.

import sys

class SlottedPoint:
    __slots__ = ('x', 'y')
    def __init__(self, x, y):
        self.x = x
        self.y = y

class RegularPoint:
    def __init__(self, x, y):
        self.x = x
        self.y = y

slotted = SlottedPoint(10, 20)
regular = RegularPoint(10, 20)
print(f"Slotted size: {sys.getsizeof(slotted)} bytes")
print(f"Regular size: {sys.getsizeof(regular)} bytes")
print(f"Slotted __dict__ exists: {hasattr(slotted, '__dict__')}")
print(f"Regular __dict__ exists: {hasattr(regular, '__dict__')}")

Slotted size: 48 bytes
Regular size: 56 bytes
Slotted __dict__ exists: False
Regular __dict__ exists: True