Serializadores (Serializers) no Django Rest Framework (DRF)

✅ Artigo atualizado em Setembro 2026 Todos os exemplos foram executados com Django 6.1.1 e DRF 3.18.1: corrigidos o comando do shell, o passo de migrations que faltava, a saída real da deserialização e a explicação de quando as validações rodam; o exemplo de serializer aninhado agora mostra os models que ele usa.

Salve salve Pythonista!

Neste artigo, vamos explorar Serializadores no Django Rest Framework (DRF).

Você aprenderá sobre os conceitos de serialização e deserialização, como utilizar serializadores (Serializers) no DRF e como desenvolvê-los em uma aplicação prática.

Entender os serializadores é crucial para criar APIs eficientes e robustas em Django, permitindo converter entre tipos de dados complexos e formatos nativos do Python.

Este artigo faz parte do Guia Completo de Django REST Framework. Lá você encontra o caminho inteiro para criar APIs profissionais: serializers, ViewSets, autenticação, filtros, paginação, testes e deploy.

Vá Direto ao Assunto…

• Conceitos de Serialização e Deserialização
• Utilizando Serializadores no Django Rest Framework
• Criando dados e Serializando
• Deserializando Dados
• Serializers Aninhados (Nested)

Conceitos de Serialização e Deserialização

Em termos simples, serialização é o processo de converter instâncias complexas, como QuerySets do Django, em formatos de dados que podem ser facilmente renderizados, como JSON, XML ou outros.

Enquanto isso, deserialização é o processo inverso, de conversão de dados primitivos de entrada (como JSON e XML) em tipos de dados complexos (Models do Django, por exemplo).

Por que isso é importante?

Em uma API, é essencial comunicar-se com diferentes sistemas, converter dados complexos em um formato simples é fundamental para transferência e armazenamento de informações.

Utilizando Serializadores no Django Rest Framework

Vamos criar uma aplicação simples para ilustrar como utilizar serializadores no Django Rest Framework.

Para ver todos os detalhes de como configurar um projeto utilizando Django REST Framework, acesse o artigo “Configurando um projeto Django Rest Framework” clicando aqui

Criando um Projeto Django

Primeiro, vamos criar um simples projeto Django:

1
2
3

django-admin startproject exemplo_serializers
cd exemplo_serializers
python manage.py startapp core

Configurando a App Django no settings.py

Adicione a App Django criada à variável INSTALLED_APPS:

1
2
3
4
5

INSTALLED_APPS = [
    ...
    'rest_framework',
    'core',
]

Criando os Modelos (models.py)

Vamos criar um Model simples que modela um Livro em nosso sistema:

1
2
3
4
5
6
7
8
9

from django.db import models

class Livro(models.Model):
    titulo = models.CharField(max_length=100)
    autor = models.CharField(max_length=100)
    publicado_em = models.DateField()

    def __str__(self):
        return self.titulo

Aqui definimos um Model Livro com:

• titulo: campo de texto com máximo de 100 caracteres
• autor: campo de texto com máximo de 100 caracteres
• publicado_em: campo de data, para armazenar a data de publicação

Serializadores (serializers.py)

Agora, vamos criar a Classe responsável por serializar e deserializar objetos do tipo Livro em nossa API:

1
2
3
4
5
6
7

from rest_framework import serializers
from .models import Livro

class LivroSerializer(serializers.ModelSerializer):
    class Meta:
        model = Livro
        fields = ['id', 'titulo', 'autor', 'publicado_em']

Agora vamos à explicação:

• LivroSerializer herda de serializers.ModelSerializer, que é uma maneira simplificada de criar um serializador para modelos Django.
• class Meta define o modelo de origem e os campos que serão serializados.

Com isso, podemos então testar localmente as funcionalidades da nossa API criando e serializando dados.

Estou desenvolvendo o Ebookr.ai, uma plataforma que transforma suas ideias em ebooks profissionais usando IA - com geração de capa, infográficos e exportação em PDF. Te convido a conhecer!

Criando dados e Serializando

Antes de criar dados, precisamos criar a tabela do Livro no banco (sem isso, o código abaixo falha com no such table: core_livro):

1
2

python manage.py makemigrations core
python manage.py migrate

Para testar localmente o que desenvolvemos, abra o shell do Django executando o comando python manage.py shell na raíz do projeto (com seu ambiente virtual ativado) e digite o seguinte código:

1
2
3
4
5
6
7
8

from core.models import Livro
from core.serializers import LivroSerializer

livro = Livro(titulo="Aprendendo Python", autor="Autor Desconhecido", publicado_em="2023-01-01")
livro.save()

serializer = LivroSerializer(livro)
print(serializer.data)

Ao fazer isso, a saída esperado será:

1

{'id': 1, 'titulo': 'Aprendendo Python', 'autor': 'Autor Desconhecido', 'publicado_em': '2023-01-01'}

Explicação:

• Primeiro, criamos uma instância de Livro e a salvamos no banco de dados com o método save().
• Em seguida, utilizamos o LivroSerializer para serializar o objeto livro.
• Por fim, printamos o resultado da serialização presente no campo serializer.data

Serializar e deserializar bem é a espinha dorsal de qualquer API - e é isso que você pratica de ponta a ponta, com Django e DRF, na Jornada Python:

Domine Python: A Linguagem da Inteligência Artificial, do Desenvolvimento Web e das Carreiras do Futuro.

A mais completa formação para você se tornar um especialista em Python, pronto para construir desde aplicações web robustas com Django até projetos de Inteligência Artificial e Ciência de Dados .

Quero conhecer!

Nota 4,9 de 5 na Hotmart O curso de Python mais bem avaliado da Hotmart!

Deserializando Dados

No exemplo abaixo, veremos como podemos transformar dados de Json para um dict Python e vice-versa (novamente, execute os códigos no shell do Django):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

from rest_framework.renderers import JSONRenderer
from rest_framework.parsers import JSONParser
import io

# Serializando para JSON
json_livro = JSONRenderer().render(serializer.data)
print(json_livro)

# Deserializando de JSON
stream = io.BytesIO(json_livro)
data = JSONParser().parse(stream)
serializer = LivroSerializer(data=data)
if serializer.is_valid():
    livro = serializer.save()
print(livro)

A saída do código acima será:

1
2

b'{"id":1,"titulo":"Aprendendo Python","autor":"Autor Desconhecido","publicado_em":"2023-01-01"}'
Aprendendo Python

Repare em dois detalhes: o print(livro) mostra o retorno do método __str__ do model (o título), e o id que veio no JSON é ignorado na deserialização (no ModelSerializer o id é somente leitura). Por isso o serializer.save() criou um novo registro, com id 2, em vez de atualizar o primeiro.

Explicação:

• Serialização para JSON: JSONRenderer().render(serializer.data) converte os dados serializados no formato JSON.
• Deserialização de JSON: Utilizamos JSONParser() para converter o JSON de volta para um formato que o Django entende, e LivroSerializer para criar e validar uma instância Livro.

Antes de continuar… Está curtindo esse conteúdo?

Que tal receber 30 dias de conteúdo direto na sua Caixa de Entrada?

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

Boas Práticas

Agora que você já entende como converter de tipos simples para complexos e vice-versa, vamos ver algumas boas práticas no desenvolvimento de APIs utilizando Django REST Framework.

Validações

Sempre que possível, utilize validações personalizadas em seus serializadores para garantir a integridade dos dados.

1
2
3
4
5
6
7
8
9

class LivroSerializer(serializers.ModelSerializer):
    class Meta:
        model = Livro
        fields = ['id', 'titulo', 'autor', 'publicado_em']

    def validate_titulo(self, value):
        if 'Python' not in value:
            raise serializers.ValidationError("O título deve conter a palavra 'Python'.")
        return value

No código acima, validate_titulo é um método de validação que garante que a palavra ‘Python’ esteja presente no título do livro.

Esse é um comportamento bastante peculiar do DRF: basta você criar um método no formato validate_<nome do campo> que - automagicamente - o DRF irá executar essa validação quando você chamar serializer.is_valid(), ou seja, na deserialização (dados de entrada). Ao serializar um objeto para a resposta, as validações não rodam.

Incrível!

Otimização

Utilize serializadores parciais para atualização de dados específicos:

1
2
3
4

livro = Livro.objects.get(id=1)
serializer = LivroSerializer(livro, data={'titulo': 'Python Avançado'}, partial=True)
if serializer.is_valid():
    livro = serializer.save()

No código acima, partial=True permite atualizar apenas campos específicos sem a necessidade de enviar todos os dados novamente.

Serializers Aninhados (Nested)

Para este exemplo, imagine um cenário um pouco diferente do anterior: o autor deixa de ser um texto e vira um model próprio, ligado ao livro por uma ForeignKey:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

from django.db import models

class Autor(models.Model):
    nome = models.CharField(max_length=100)
    email = models.EmailField()

    def __str__(self):
        return self.nome

class Livro(models.Model):
    titulo = models.CharField(max_length=100)
    ano = models.PositiveIntegerField()
    autor = models.ForeignKey(Autor, on_delete=models.CASCADE, related_name='livros')

    def __str__(self):
        return self.titulo

Com esses models, o serializer aninhado fica assim:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

from rest_framework import serializers
from .models import Autor, Livro

class AutorSerializer(serializers.ModelSerializer):
    class Meta:
        model = Autor
        fields = ['id', 'nome', 'email']

class LivroComAutorSerializer(serializers.ModelSerializer):
    autor = AutorSerializer(read_only=True)  # Nested serializer
    autor_id = serializers.PrimaryKeyRelatedField(
        queryset=Autor.objects.all(),
        source='autor',
        write_only=True
    )

    class Meta:
        model = Livro
        fields = ['id', 'titulo', 'ano', 'autor', 'autor_id']

# Resposta JSON (criando o livro com {"titulo": "Django na Prática", "ano": 2024, "autor_id": 1}):
# {
#     "id": 1,
#     "titulo": "Django na Prática",
#     "ano": 2024,
#     "autor": {
#         "id": 1,
#         "nome": "João Silva",
#         "email": "[email protected]"
#     }
# }

Conclusão

Neste artigo, exploramos o uso de Serializadores no Django Rest Framework, aprendemos sobre serialização e deserialização, e como implementá-los em uma aplicação Django.

Vimos exemplos práticos e dicas de boas práticas, como validações personalizadas e serializações parciais.

Quer praticar Django REST Framework construindo APIs completas, dos models aos serializers? Conheça a Jornada Python, nosso curso de Python completo.

Fique ligado nos próximos pois ainda abordaremos muito conteúdo fera sobre Django REST Framework!

Te vejo lá!

Por Vinícius Ramos em 10/09/2024

Engenheiro de Computação pela UnB com especialização em Inteligência Artificial. Sr. Software Engineer com 10+ anos de experiência desenvolvendo sistemas críticos em Python e Django. Atuei no Banco do Brasil liderando equipes para monitoramento de mainframe, trabalhei como desenvolvedor sênior em projetos forenses para a Polícia Federal, e atualmente sou engenheiro de software na Labcorp (Estados Unidos), desenvolvendo soluções escaláveis para testes genéticos. Fundador da Python Academy, compartilhando conhecimento técnico com a comunidade brasileira desde 2018.

Bora se conectar no LinkedIn! vinicius-aramos

Minhas redes:

• 
• 
•