Mixins are special classes that provide reusable functionality through multiple inheritance. Unlike regular classes, mixins aren’t meant to be instantiated alone — they add specific behaviors to other classes.
Why Django Uses Mixins
Without mixins, Django would need hundreds of view classes for every combination of CRUD operations. Mixins allow you to:
Reduce code duplication
Mix and match functionality like Lego blocks
Keep code maintainable
Test each piece independently
Example:
class ListCreateAPIView(ListModelMixin, CreateModelMixin, GenericAPIView): pass # Combines LIST and CREATE in one view!
The 5 DRF Mixins
1. CreateModelMixin:
Purpose: Creates new objects via POST requests
class ArticleCreateView(mixins.CreateModelMixin, generics.GenericAPIView): queryset = Article.objects.all() serializer_class = ArticleSerializer
# ✅ CORRECT - Mixins first, then GenericAPIView class MyView(CreateModelMixin, UpdateModelMixin, GenericAPIView): pass
# ❌ WRONG - Missing queryset and serializer_class class MyView(mixins.ListModelMixin, GenericAPIView): pass # Will raise errors
Part 2: APIView — The Foundation
What is APIView?
APIView is the base class for all DRF views. It's Django's View class but designed specifically for REST APIs with built-in authentication, permissions, throttling, and content negotiation.
For custom behavior that doesn’t fit generic views
Part 3: GenericAPIView — The Bridge
What is GenericAPIView?
GenericAPIView extends APIView and adds model-specific functionality. It's the bridge between APIView and Mixins.
Core Attributes
class ArticleView(GenericAPIView): queryset = Article.objects.all() # Base queryset serializer_class = ArticleSerializer # Serializer lookup_field = 'slug' # Field for lookups pagination_class = PageNumberPagination # Pagination filter_backends = [DjangoFilterBackend] # Filtering
Core Methods
class ArticleView(GenericAPIView): def get_queryset(self): """Dynamic queryset based on user""" if self.request.user.is_staff: return Article.objects.all() return Article.objects.filter(author=self.request.user)
def get_serializer_class(self): """Different serializers for different actions""" if self.request.method == 'GET': return ArticleListSerializer return ArticleCreateSerializer
def get_serializer_context(self): """Add extra context to serializer""" context = super().get_serializer_context() context['user'] = self.request.user return context
# Simple list view class ArticleListAPIView(generics.ListAPIView): queryset = Article.objects.all() serializer_class = ArticleSerializer
# List and create class ArticleListCreateAPIView(generics.ListCreateAPIView): queryset = Article.objects.all() serializer_class = ArticleSerializer permission_classes = [IsAuthenticatedOrReadOnly]
def perform_create(self, serializer): serializer.save(author=self.request.user)# Full CRUD class ArticleRetrieveUpdateDestroyAPIView(generics.RetrieveUpdateDestroyAPIView): queryset = Article.objects.all() serializer_class = ArticleSerializer permission_classes = [IsAuthenticated, IsAuthorOrAdmin]
Best Practices
Choose the simplest view for your needs
Use perform_create()/perform_update() for custom logic
Always optimize querysets with select_related
Set proper permission_classes
Part 5: ViewSets — Grouping Views
What are ViewSets?
ViewSets group related views into a single class. Instead of separate classes for list, create, retrieve, update, and delete, you write one class.
A serializer converts complex data types (Django models) into Python datatypes that can be rendered into JSON. It also provides deserialization — converting incoming data back to Python objects.
Basic Serializer
class ArticleSerializer(serializers.Serializer): id = serializers.IntegerField(read_only=True) title = serializers.CharField(max_length=200) content = serializers.CharField() author = serializers.CharField(max_length=100) created_at = serializers.DateTimeField(read_only=True)
serializer.initial_data # Raw input data serializer.validated_data # Cleaned data after validation serializer.data # Serialized output serializer.errors # Validation errors serializer.instance # Model instance
Using Serializers in Views
class ArticleCreateView(APIView): def post(self, request): serializer = ArticleSerializer(data=request.data)
# Stage 2: Field validators (automatic from model) # max_length, min_length, unique, choices
# Stage 3: Field-specific validation def validate_title(self, value): if len(value) < 5: raise serializers.ValidationError("Title too short") return value
# Stage 4: Object-level validation def validate(self, data): if data['title'] == data['content']: raise serializers.ValidationError("Title and content must differ") return data
Error Handling
# With manual checking serializer = ArticleSerializer(data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=201) return Response(serializer.errors, status=400)
# With automatic exception serializer = ArticleSerializer(data=request.data) serializer.is_valid(raise_exception=True) # Returns 400 automatically serializer.save()# Error format # { # "title": ["This field is required."], # "content": ["Content too short."] # }
Key Methods
class ArticleSerializer(serializers.ModelSerializer): class Meta: model = Article fields = '__all__'
def to_internal_value(self, data): """Convert input data to Python types.""" # Normalize data before validation data = data.copy() if 'title' in data: data['title'] = data['title'].strip().capitalize() return super().to_internal_value(data)
def to_representation(self, instance): """Format output data for response.""" data = super().to_representation(instance) # Add computed fields data['word_count'] = len(instance.content.split()) # Format dates data['created_at'] = data['created_at'].strftime('%B %d, %Y') return data
Part 10: Validation In-Depth
Types of Validation
1. Field-Level Validation
def validate_title(self, value): if 'spam' in value.lower(): raise serializers.ValidationError("Spam detected") if len(value) < 5: raise serializers.ValidationError("Title too short") return value
2. Object-Level Validation
def validate(self, data): if data['start_date'] > data['end_date']: raise serializers.ValidationError("Start date must be before end date") return data
3. Custom Validators
from rest_framework import serializers
def validate_no_spam(value): if 'spam' in value.lower(): raise serializers.ValidationError("Contains spam") return valueclass ArticleSerializer(serializers.ModelSerializer): title = serializers.CharField(validators=[validate_no_spam])
4. Built-in Validators
from rest_framework.validators import UniqueValidator from django.core.validators import MinLengthValidator
class ArticleSerializer(serializers.ModelSerializer): title = serializers.CharField( validators=[ MinLengthValidator(5), UniqueValidator(queryset=Article.objects.all()) ] )
Execution Order
1. Required field validation 2. Field type conversion 3. Field validators (built-in) 4. Custom field validators 5. validate_<field>() methods 6. Object-level validate()
Production Example
class OrderSerializer(serializers.ModelSerializer): class Meta: model = Order fields = ['items', 'total', 'discount_code']
def validate_items(self, value): if not value: raise serializers.ValidationError("Need at least one item") return value
def validate_discount_code(self, value): if value and not Discount.objects.filter(code=value).exists(): raise serializers.ValidationError("Invalid discount code") return value
def validate(self, data): if data.get('discount_code'): discount = Discount.objects.get(code=data['discount_code']) if data['total'] < discount.min_order: raise serializers.ValidationError("Minimum order required") return data
class OrderSerializer(serializers.ModelSerializer): items = OrderItemSerializer(many=True)
class Meta: model = Order fields = ['id', 'user', 'items', 'total'] read_only_fields = ['id', 'user', 'total']
def create(self, validated_data): items_data = validated_data.pop('items') total = sum(item['price'] * item['quantity'] for item in items_data) validated_data['total'] = total order = Order.objects.create(**validated_data) for item_data in items_data: OrderItem.objects.create(order=order, **item_data) return order
# Update order fields for attr, value in validated_data.items(): setattr(instance, attr, value)
# Update items if provided if items_data is not None: instance.items.all().delete() for item_data in items_data: OrderItem.objects.create(order=instance, **item_data) total = sum(item['price'] * item['quantity'] for item in items_data) instance.total = total
instance.save() return instance
perform_create() in Views
# In Generic View class ArticleCreateView(generics.CreateAPIView): queryset = Article.objects.all() serializer_class = ArticleSerializer
def perform_create(self, serializer): # Called after validation, before save serializer.save(author=self.request.user)
Use prefetch_related() for ManyToMany and reverse relationships
Use only() and defer() for large models
Use exists() instead of count() > 0
Use bulk_create() and bulk_update() for mass operations
Monitor queries with django-debug-toolbar
Part 16: QuerySets — Complete Guide
What is a QuerySet?
A QuerySet represents a collection of database queries. It’s lazy — it doesn’t execute until evaluated.
Lazy Evaluation
# Not executed yet articles = Article.objects.filter(status='published')
# Still not executed articles = articles.filter(created_at__gte=timezone.now() - timedelta(days=7))# Executes here for article in articles: print(article.title)# Or here first_article = articles.first() count = articles.count()
Basic Methods
# Get all articles = Article.objects.all()
# Filter articles = Article.objects.filter(status='published', author=user) articles = Article.objects.filter(title__icontains='python')# Exclude articles = Article.objects.exclude(status='draft')# Get single article = Article.objects.get(id=1) # Raises DoesNotExist if not found# First/Last first = Article.objects.first() last = Article.objects.last()# Check if exists if Article.objects.filter(status='published').exists(): print("Has published articles")# Count count = Article.objects.filter(status='published').count()
from django.db.models import Count, Sum, Avg, Max, Min
# Aggregation (returns dictionary) stats = Article.objects.aggregate( total=Sum('views_count'), avg=Avg('views_count'), max=Max('views_count') )# Annotation (adds computed field to each object) articles = Article.objects.annotate( comment_count=Count('comments'), like_count=Count('likes') )
F Expressions
from django.db.models import F
# Update using current value Article.objects.filter(id=1).update(views_count=F('views_count') + 1)# Compare fields articles = Article.objects.filter(views_count__gt=F('likes_count') * 2)
# Bulk create articles = [ Article(title=f'Article {i}', content=f'Content {i}') for i in range(100) ] Article.objects.bulk_create(articles)
# Bulk update articles = Article.objects.filter(status='published') for article in articles: article.status = 'archived' Article.objects.bulk_update(articles, ['status'])# Update without retrieving Article.objects.filter(status='draft').update(status='published')# Delete Article.objects.filter(status='deleted').delete()
Transactions
from django.db import transaction
@transaction.atomic def process_article(article_id): # All operations in this block are atomic article = Article.objects.select_for_update().get(id=article_id) article.status = 'processing' article.save() # ... more operations article.status = 'completed' article.save()
Performance Best Practices
Use select_related() for ForeignKey fields
Use prefetch_related() for ManyToMany fields
Use only() and defer() for large models
Use exists() instead of count() > 0
Use pagination for large result sets
Use bulk operations for mass updates
Use indexes on frequently filtered fields
Monitor queries with django-debug-toolbar
Avoid filtering in Python — filter in database
Use transactions for atomic operations
Common Mistakes
# ❌ N+1 queries articles = Article.objects.all() for article in articles: print(article.author.name)
# ✅ Solution articles = Article.objects.select_related('author').all()# ❌ Filtering in Python articles = Article.objects.all() published = [a for a in articles if a.status == 'published']# ✅ Solution articles = Article.objects.filter(status='published')# ❌ Using count() for existence if Article.objects.filter(status='published').count() > 0: pass# ✅ Solution if Article.objects.filter(status='published').exists(): pass# ❌ All without pagination articles = Article.objects.all() # Loads everything# ✅ Solution articles = Article.objects.all()[:100]
Final Summary
You’ve now covered the complete Django REST Framework ecosystem:
Mixins — Reusable CRUD building blocks
APIView — Foundation for all DRF views
GenericAPIView — Bridge to model-based views
Generic Views — Ready-to-use CRUD views
ViewSets — Grouping related views
Custom Actions — Extending ViewSets
Serializers — Data conversion and validation
ModelSerializer — Automated serialization
Serializer Lifecycle — Complete data flow
Validation — Data integrity and business rules
create()/update() — Saving data
to_internal_value() — Input processing
to_representation() — Output formatting
Nested Serializers — Handling relationships
Query Optimization — Performance tuning
QuerySets — Database interaction
With this knowledge, you can build production-ready REST APIs that are efficient, maintainable, and scalable.
Get Shahab Uddin’s stories in your inbox
Join Medium for free to get updates from this writer.
Key Takeaways:
Always optimize your queries with select_related/prefetch_related
Validate data thoroughly at multiple levels
Use appropriate views (APIView, GenericAPIView, ViewSets) based on needs
Keep serializers clean with proper separation of concerns
