Calcular campos dinámicos con SerializerMethodField

Contenido del curso

Fundamentos de Django Rest Framework

Vistas y Endpoints

Serializadores Avanzados

Testing y Desempeño

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:005:40

Calcular campos dinámicos con SerializerMethodField

Curso de Django Rest Framework

Clase 18 de 21

Clase 18 / 21

Recursos

Cuando trabajas con APIs en Django REST Framework, a veces necesitas mostrar un valor que no existe directamente en tu modelo, sino que se calcula a partir de otros campos. Aquí entra en juego SerializerMethodField, una herramienta que te permite agregar campos calculados sin modificar tu base de datos.

Qué es SerializerMethodField y para qué sirve

Imagina que tienes un modelo Patient con la fecha de nacimiento, pero en tu endpoint quieres mostrar la edad. No tiene sentido guardar la edad en la base de datos porque cambia cada año. La solución es calcularla al momento de serializar.

SerializerMethodField es un campo de solo lectura que ejecuta un método de tu clase serializer y retorna el valor calculado. Recibe la instancia del modelo y desde ahí puedes acceder a cualquier atributo para hacer la lógica que necesites [1:00].

¿Qué es SerializerMethodField en DRF? Es un campo de serializer que permite calcular y retornar valores dinámicos a partir de la instancia del modelo, sin necesidad de almacenarlos en la base de datos.

Cómo calcular la edad de un paciente desde la fecha de nacimiento

El objetivo es transformar un campo date_of_birth en un valor numérico que represente la edad del paciente. Para lograrlo, necesitas dos piezas: el módulo date de Python y un método dentro del serializer.

Cómo importar el módulo correcto en Python

La importación que necesitas es específica. Como el campo en el modelo es de tipo Date y no Datetime, importas solo date:

python from datetime import date

Con esto puedes usar date.today() para obtener la fecha actual y restar la fecha de nacimiento [2:30].

Cómo definir el campo age en el serializer

Dentro de tu clase serializer, declara el nuevo campo y crea el método correspondiente. Si dejas vacío el parámetro method_name, Django REST Framework genera el nombre automáticamente con el prefijo get_ seguido del nombre del campo.

python from rest_framework import serializers from datetime import date

class PatientSerializer(serializers.ModelSerializer): age = serializers.SerializerMethodField()

def get_age(self, obj):
    age_timedelta = date.today() - obj.date_of_birth
    return age_timedelta.days // 365

class Meta:
    model = Patient
    fields = ['id', 'name', 'date_of_birth', 'age']

El detalle clave está en age_timedelta.days. Cuando restas dos fechas obtienes un objeto timedelta, no un número. Para convertirlo en un valor numérico debes acceder al atributo days y dividirlo entre 365 [3:45].

Por qué no debes retornar texto desde una API REST

Es tentador devolver algo como "45 años" directamente desde el serializer usando un f-string. Técnicamente funciona, pero es mala práctica.

Las APIs deben retornar valores puros y consistentes.
El formato y los textos pertenecen al front-end.
Muchas aplicaciones manejan varios idiomas y necesitan adaptar el texto.
Mezclar lógica de presentación en el backend complica el mantenimiento.

Lo ideal es retornar el número y documentar la unidad: la edad va en años, la duración en minutos, el precio en centavos. El cliente decide cómo mostrarlo.

¿Por qué no devolver strings con formato desde el backend? Porque rompe la separación de responsabilidades. El backend entrega datos, el frontend decide cómo presentarlos según el idioma o el contexto del usuario.

Cuándo conviene usar SerializerMethodField en lugar de modificar el modelo

No todo cálculo merece una columna nueva en la base de datos. SerializerMethodField brilla cuando el valor depende del momento de la consulta o se deriva de datos ya existentes.

Úsalo cuando:

El valor cambia con el tiempo, como la edad o la antigüedad.
Es una combinación simple de campos que ya tienes.
Solo se necesita en la respuesta del endpoint, no para filtrar ni ordenar.
Quieres evitar migraciones innecesarias.

Si en cambio el valor se va a consultar con frecuencia, se usa para filtros o se calcula con lógica pesada, probablemente convenga guardarlo en el modelo o usar una property combinada con caché.

Reto: calcula la experiencia de un doctor

Ahora aplica lo aprendido. Crea un método dentro del serializer del modelo Doctor que calcule los años de experiencia basándose en la fecha en la que empezó a trabajar. La lógica es la misma que usaste con la edad del paciente: resta de fechas, acceso a days y división entre 365.

¿Cómo resolviste el reto? Comparte tu implementación en los comentarios y cuéntame si encontraste alguna variación interesante para manejar años bisiestos.

Bryan Castano

Hace 8 meses•editado

This is Mine :

from rest_framework import serializers
from .models import Physician, Department, PhyisicanAvailability, MedicalNote
from datetime import date
from patients.models import Patient
from physicians.models import Physician
from bookings.serializers import AppointmentSerializer

class DepartmentSerializer(serializers.ModelSerializer):
    
    class Meta: 
        
        model = Department
        fields = [
              'id',
            'name',
            'description'
        ]
        
class PhyisicanAvailabilitySerializer(serializers.ModelSerializer):
    
    class Meta: 
        
        model = PhyisicanAvailability
        fields = [
            'id',
            'phyisican',
            'start_date',
            'end_date',
            'start_time',
            'end_time'
        ]
        
class MedicalNoteSerializer(serializers.ModelSerializer):
    
    class Meta: 
        
        model = MedicalNote
        fields = [
            'id',
            'phyisican',
            'note',
            'date'
        ]

class PhysicianSerializer(serializers.ModelSerializer):

    department = DepartmentSerializer(read_only=True)
    doctor_availability = PhyisicanAvailabilitySerializer(many=True, read_only=True, source='availabilities') # 
  
    medical_notes = MedicalNoteSerializer(many=True, read_only=True)
    appointments = AppointmentSerializer(many=True, read_only=True)
    work_time_exp = serializers.SerializerMethodField()

    class Meta:
        
        model = Physician
        fields = [
            'id',
            'first_name',
            'last_name',
            'qualification',
            'contact_number',
            'email',
            'address',
            'biography',
            'department',
            'doctor_availability',
            'medical_notes',
            'appointments',
            'work_time_exp'
        ]
        
    def validate_email(self, value):
        if "@example.com" in value:
            return value
        raise serializers.ValidationError("Invalid email address")
    
    def validate(self, attrs):
        # Check if keys exist in attrs , object.
        if 'contact_number' in attrs and 'is_on_vacation' in attrs:
            if len(attrs['contact_number']) < 10 and attrs['is_on_vacation']:
                raise serializers.ValidationError("Contact number is required before vacations")
        
        return super().validate(attrs)

    def get_work_time_exp(self, obj):
        # USE Create _at date because it is the date the doctor was created on db system.
        if obj.created_at:
            experience_td = date.today() - obj.created_at.date()  
            years = experience_td.days // 365  
            return years
        return 0

Fundamentos de Django Rest Framework

Django REST Framework para APIs escalables

Qué es una API REST y cómo usar JSON

Configuración de Django REST Framework paso a paso

Django Rest: qué reutiliza de Django

Serializers Django: modelos a JSON fácil

Listado de pacientes con serializers en DRF

POST y GET en el mismo endpoint con Django REST

CRUD completo con PUT y DELETE en Django Rest

Cómo probar APIs con Postman y curl

Django Rest Framework: de funciones a vistas genéricas

Vistas genéricas en Django Rest Framework

Documentación automática de APIs con drf-spectacular

Vistas y Endpoints

ViewSets vs APIView: refactor automático de URLs

Acciones personalizadas en ViewSets REST

Autenticación y permisos en Django Rest Framework

Validaciones custom en Django Rest Framework

Serializadores Avanzados

Serializadores anidados en Django REST Framework

Calcular campos dinámicos con SerializerMethodField

Endpoint anidado para citas en Django REST

Testing y Desempeño

Tests de API con APIClient en Django

Throttling en Django Rest para evitar ataques DOS

Calcular campos dinámicos con SerializerMethodField

Progreso del curso

Fundamentos de Django Rest Framework

Vistas y Endpoints

Serializadores Avanzados

Testing y Desempeño

Recursos

Recursos