+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Home / Tutorials / 🐍 python
Part 353 of 365

📘 Django Models: ORM Basics

Master django models: orm basics in Python with practical examples, best practices, and real-world applications 🚀

🚀Intermediate
20 min read

Prerequisites

  • Basic understanding of programming concepts 📝
  • Python installation (3.8+) 🐍
  • VS Code or preferred IDE 💻

What you'll learn

  • Understand the concept fundamentals 🎯
  • Apply the concept in real projects 🏗️
  • Debug common issues 🐛
  • Write clean, Pythonic code ✨

🎯 Introduction

Welcome to the exciting world of Django Models and ORM! 🎉 In this guide, we’ll explore how Django’s Object-Relational Mapping (ORM) lets you work with databases using Python code instead of SQL queries.

You’ll discover how Django Models can transform your web development experience. Whether you’re building e-commerce sites 🛒, social networks 👥, or content management systems 📚, understanding Django’s ORM is essential for creating powerful, database-driven applications.

By the end of this tutorial, you’ll feel confident creating and working with Django Models in your own projects! Let’s dive in! 🏊‍♂️

📚 Understanding Django Models and ORM

🤔 What is Django ORM?

Django’s ORM is like a translator between Python and your database 🌐. Think of it as a friendly interpreter that converts your Python classes into database tables and your Python objects into database rows!

In Django terms, the ORM (Object-Relational Mapping) provides a high-level abstraction over SQL databases. This means you can:

  • ✨ Define database schemas using Python classes
  • 🚀 Query data using Python methods instead of SQL
  • 🛡️ Avoid SQL injection vulnerabilities automatically
  • 🔄 Switch between different databases easily

💡 Why Use Django Models?

Here’s why developers love Django’s ORM:

  1. Pythonic Syntax 🐍: Write database logic in Python, not SQL
  2. Database Agnostic 💻: Works with PostgreSQL, MySQL, SQLite, and more
  3. Built-in Validation 📖: Automatic data validation and constraints
  4. Migration System 🔧: Version control for your database schema

Real-world example: Imagine building an online bookstore 📚. With Django Models, you can represent books, authors, and orders as Python classes!

🔧 Basic Syntax and Usage

📝 Creating Your First Model

Let’s start with a friendly example:

# 👋 Hello, Django Models!
from django.db import models

# 🎨 Creating a simple Book model
class Book(models.Model):
    title = models.CharField(max_length=200)  # 📖 Book title
    author = models.CharField(max_length=100)  # ✍️ Author name
    isbn = models.CharField(max_length=13, unique=True)  # 🔢 ISBN number
    price = models.DecimalField(max_digits=6, decimal_places=2)  # 💰 Price
    published_date = models.DateField()  # 📅 Publication date
    is_available = models.BooleanField(default=True)  # ✅ Availability
    
    def __str__(self):
        return f"📚 {self.title} by {self.author}"

💡 Explanation: Each class attribute represents a database column. Django automatically creates an id field as the primary key!

🎯 Common Field Types

Here are the field types you’ll use daily:

# 🏗️ Common Django field types
class Product(models.Model):
    # 📝 Text fields
    name = models.CharField(max_length=100)  # Short text
    description = models.TextField()  # Long text
    
    # 🔢 Numeric fields
    quantity = models.IntegerField()  # Whole numbers
    price = models.DecimalField(max_digits=10, decimal_places=2)  # Money
    rating = models.FloatField()  # Decimal numbers
    
    # 📅 Date and time
    created_at = models.DateTimeField(auto_now_add=True)  # Set once
    updated_at = models.DateTimeField(auto_now=True)  # Update always
    
    # ✅ Boolean field
    is_active = models.BooleanField(default=True)
    
    # 🔗 Relationships (we'll cover these next!)
    category = models.ForeignKey('Category', on_delete=models.CASCADE)

💡 Practical Examples

🛒 Example 1: E-commerce Product Catalog

Let’s build something real - an e-commerce product system:

# 🛍️ E-commerce models
from django.db import models
from django.contrib.auth.models import User

class Category(models.Model):
    name = models.CharField(max_length=50)
    emoji = models.CharField(max_length=2)  # Every category needs an emoji! 
    
    class Meta:
        verbose_name_plural = "categories"  # 📚 Correct plural form
    
    def __str__(self):
        return f"{self.emoji} {self.name}"

class Product(models.Model):
    # 📦 Basic product info
    name = models.CharField(max_length=200)
    slug = models.SlugField(unique=True)  # 🔗 URL-friendly name
    description = models.TextField()
    price = models.DecimalField(max_digits=10, decimal_places=2)
    
    # 🏷️ Categorization
    category = models.ForeignKey(Category, on_delete=models.PROTECT)
    tags = models.ManyToManyField('Tag', blank=True)
    
    # 📊 Inventory
    stock = models.PositiveIntegerField(default=0)
    
    # 📅 Timestamps
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    
    # 🖼️ Media
    image = models.ImageField(upload_to='products/', blank=True)
    
    def __str__(self):
        return f"🛍️ {self.name} - ${self.price}"
    
    @property
    def is_in_stock(self):
        return self.stock > 0  # ✅ Check availability

class Tag(models.Model):
    name = models.CharField(max_length=30, unique=True)
    
    def __str__(self):
        return f"🏷️ {self.name}"

# 🛒 Shopping cart items
class CartItem(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    product = models.ForeignKey(Product, on_delete=models.CASCADE)
    quantity = models.PositiveIntegerField(default=1)
    added_at = models.DateTimeField(auto_now_add=True)
    
    class Meta:
        unique_together = ['user', 'product']  # 🔒 One product per user in cart
    
    def get_total_price(self):
        return self.product.price * self.quantity  # 💰 Calculate total

🎯 Try it yourself: Add a Review model with rating and comment fields!

🎮 Example 2: Gaming Leaderboard System

Let’s make it fun with a gaming system:

# 🏆 Gaming leaderboard models
class Game(models.Model):
    DIFFICULTY_CHOICES = [
        ('easy', '😊 Easy'),
        ('medium', '😐 Medium'),
        ('hard', '😈 Hard'),
        ('extreme', '🔥 Extreme'),
    ]
    
    title = models.CharField(max_length=100)
    emoji = models.CharField(max_length=2, default='🎮')
    difficulty = models.CharField(max_length=10, choices=DIFFICULTY_CHOICES)
    max_score = models.IntegerField(default=1000)
    
    def __str__(self):
        return f"{self.emoji} {self.title}"

class Player(models.Model):
    username = models.CharField(max_length=50, unique=True)
    avatar = models.CharField(max_length=2, default='🤖')  # Emoji avatar!
    joined_date = models.DateTimeField(auto_now_add=True)
    total_points = models.IntegerField(default=0)
    
    class Meta:
        ordering = ['-total_points']  # 📊 Sort by points
    
    def __str__(self):
        return f"{self.avatar} {self.username}"
    
    @property
    def rank(self):
        # 🏅 Calculate player rank
        if self.total_points >= 10000:
            return "🏆 Legend"
        elif self.total_points >= 5000:
            return "⭐ Expert"
        elif self.total_points >= 1000:
            return "💪 Pro"
        else:
            return "🌱 Rookie"

class Score(models.Model):
    player = models.ForeignKey(Player, on_delete=models.CASCADE)
    game = models.ForeignKey(Game, on_delete=models.CASCADE)
    points = models.IntegerField()
    achieved_at = models.DateTimeField(auto_now_add=True)
    
    class Meta:
        ordering = ['-points', '-achieved_at']  # 🥇 Highest scores first
    
    def __str__(self):
        return f"🎯 {self.player.username} scored {self.points} in {self.game.title}"
    
    def save(self, *args, **kwargs):
        # 🎊 Update player's total points
        super().save(*args, **kwargs)
        self.player.total_points = self.player.score_set.aggregate(
            total=models.Sum('points')
        )['total'] or 0
        self.player.save()

🚀 Advanced Concepts

🧙‍♂️ Model Relationships

When you’re ready to level up, master these relationships:

# 🎯 Advanced relationships
class Author(models.Model):
    name = models.CharField(max_length=100)
    bio = models.TextField()
    
    def __str__(self):
        return f"✍️ {self.name}"

class Publisher(models.Model):
    name = models.CharField(max_length=100)
    website = models.URLField()
    
    def __str__(self):
        return f"📚 {self.name}"

class Book(models.Model):
    title = models.CharField(max_length=200)
    
    # 🔗 One-to-Many: One author, many books
    author = models.ForeignKey(Author, on_delete=models.CASCADE, 
                              related_name='books')
    
    # 🔗 Many-to-Many: Books can have multiple publishers
    publishers = models.ManyToManyField(Publisher, 
                                       related_name='published_books')
    
    # 🔗 One-to-One: Each book has one detail record
    # (defined in BookDetail model below)

class BookDetail(models.Model):
    book = models.OneToOneField(Book, on_delete=models.CASCADE,
                               related_name='details')
    isbn = models.CharField(max_length=13, unique=True)
    pages = models.IntegerField()
    language = models.CharField(max_length=50)

🏗️ Custom Model Methods and Properties

For the brave developers:

# 🚀 Advanced model features
class Article(models.Model):
    STATUS_CHOICES = [
        ('draft', '📝 Draft'),
        ('review', '👀 Under Review'),
        ('published', '✅ Published'),
    ]
    
    title = models.CharField(max_length=200)
    slug = models.SlugField(unique=True)
    content = models.TextField()
    status = models.CharField(max_length=10, choices=STATUS_CHOICES, 
                             default='draft')
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    published_at = models.DateTimeField(null=True, blank=True)
    views = models.IntegerField(default=0)
    
    class Meta:
        ordering = ['-published_at']  # 📅 Newest first
        indexes = [
            models.Index(fields=['slug']),  # 🚀 Speed up slug lookups
            models.Index(fields=['status', '-published_at']),
        ]
    
    def __str__(self):
        return f"{self.get_status_display()} - {self.title}"
    
    @property
    def reading_time(self):
        # ⏱️ Estimate reading time
        word_count = len(self.content.split())
        minutes = word_count // 200  # Average reading speed
        return f"{minutes} min read"
    
    @property
    def popularity_score(self):
        # 🌟 Calculate popularity
        days_old = (timezone.now() - self.published_at).days if self.published_at else 0
        if days_old == 0:
            days_old = 1
        return self.views / days_old
    
    def publish(self):
        # 📢 Publish the article
        self.status = 'published'
        self.published_at = timezone.now()
        self.save()
    
    def get_absolute_url(self):
        # 🔗 Get article URL
        from django.urls import reverse
        return reverse('article_detail', kwargs={'slug': self.slug})

⚠️ Common Pitfalls and Solutions

😱 Pitfall 1: Forgetting Migrations

# ❌ Wrong - Adding field without migration
class Product(models.Model):
    name = models.CharField(max_length=100)
    # Later adding this field...
    description = models.TextField()  # 💥 Database doesn't know about this!

# ✅ Correct - Always make and run migrations
# Terminal commands:
# python manage.py makemigrations
# python manage.py migrate

🤯 Pitfall 2: N+1 Query Problem

# ❌ Inefficient - Causes N+1 queries
books = Book.objects.all()
for book in books:
    print(book.author.name)  # 💥 New query for each book!

# ✅ Efficient - Use select_related for ForeignKey
books = Book.objects.select_related('author').all()
for book in books:
    print(book.author.name)  # ✅ Author already loaded!

# ✅ For ManyToMany use prefetch_related
books = Book.objects.prefetch_related('publishers').all()

🛠️ Best Practices

  1. 🎯 Use Meaningful Names: published_date not pub_dt
  2. 📝 Add Help Text: Guide admin users with help_text parameter
  3. 🛡️ Set Constraints: Use unique=True, db_index=True wisely
  4. 🎨 Override __str__: Make admin interface readable
  5. ✨ Use Model Managers: Create custom querysets for common filters

🧪 Hands-On Exercise

🎯 Challenge: Build a Blog System

Create a complete blog system with these models:

📋 Requirements:

  • ✅ Blog posts with title, content, and publication status
  • 🏷️ Categories and tags for organization
  • 👤 Author profiles with bio and avatar
  • 💬 Comments with nested replies support
  • 🎨 Each post needs a featured emoji!

🚀 Bonus Points:

  • Add view counting functionality
  • Implement draft/published workflow
  • Create a like/bookmark system

💡 Solution

🔍 Click to see solution
# 🎯 Complete blog system!
from django.db import models
from django.contrib.auth.models import User
from django.utils import timezone

class Category(models.Model):
    name = models.CharField(max_length=50, unique=True)
    slug = models.SlugField(unique=True)
    emoji = models.CharField(max_length=2, default='📁')
    
    class Meta:
        verbose_name_plural = "categories"
    
    def __str__(self):
        return f"{self.emoji} {self.name}"

class Tag(models.Model):
    name = models.CharField(max_length=30, unique=True)
    
    def __str__(self):
        return f"#️⃣ {self.name}"

class AuthorProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.TextField(max_length=500)
    avatar = models.CharField(max_length=2, default='👤')
    website = models.URLField(blank=True)
    
    def __str__(self):
        return f"{self.avatar} {self.user.username}"

class BlogPost(models.Model):
    STATUS_CHOICES = [
        ('draft', '📝 Draft'),
        ('published', '✅ Published'),
    ]
    
    # 📝 Basic fields
    title = models.CharField(max_length=200)
    slug = models.SlugField(unique=True)
    content = models.TextField()
    excerpt = models.TextField(max_length=300)
    featured_emoji = models.CharField(max_length=2, default='📖')
    
    # 🔗 Relationships
    author = models.ForeignKey(User, on_delete=models.CASCADE,
                              related_name='blog_posts')
    category = models.ForeignKey(Category, on_delete=models.SET_NULL,
                                null=True, related_name='posts')
    tags = models.ManyToManyField(Tag, blank=True)
    
    # 📊 Metadata
    status = models.CharField(max_length=10, choices=STATUS_CHOICES,
                             default='draft')
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    published_at = models.DateTimeField(null=True, blank=True)
    views = models.PositiveIntegerField(default=0)
    
    # 👍 Engagement
    likes = models.ManyToManyField(User, related_name='liked_posts',
                                  blank=True)
    
    class Meta:
        ordering = ['-published_at', '-created_at']
    
    def __str__(self):
        return f"{self.featured_emoji} {self.title}"
    
    def publish(self):
        self.status = 'published'
        self.published_at = timezone.now()
        self.save()
    
    @property
    def like_count(self):
        return self.likes.count()
    
    @property
    def comment_count(self):
        return self.comments.count()

class Comment(models.Model):
    post = models.ForeignKey(BlogPost, on_delete=models.CASCADE,
                            related_name='comments')
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    content = models.TextField(max_length=500)
    created_at = models.DateTimeField(auto_now_add=True)
    parent = models.ForeignKey('self', on_delete=models.CASCADE,
                              null=True, blank=True,
                              related_name='replies')
    
    class Meta:
        ordering = ['created_at']
    
    def __str__(self):
        emoji = "💬" if self.parent is None else "↩️"
        return f"{emoji} {self.author.username}: {self.content[:50]}..."

class Bookmark(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    post = models.ForeignKey(BlogPost, on_delete=models.CASCADE)
    created_at = models.DateTimeField(auto_now_add=True)
    
    class Meta:
        unique_together = ['user', 'post']
    
    def __str__(self):
        return f"🔖 {self.user.username} → {self.post.title}"

🎓 Key Takeaways

You’ve learned so much! Here’s what you can now do:

  • ✅ Create Django Models with confidence 💪
  • ✅ Define relationships between models 🔗
  • ✅ Use field types appropriately 🎯
  • ✅ Avoid common ORM pitfalls 🛡️
  • ✅ Build real-world database schemas with Django! 🚀

Remember: Django’s ORM is powerful and makes database work enjoyable. Start simple and gradually add complexity! 🤝

🤝 Next Steps

Congratulations! 🎉 You’ve mastered Django Models and ORM basics!

Here’s what to do next:

  1. 💻 Practice creating models for your own project ideas
  2. 🏗️ Learn about Django QuerySets and advanced queries
  3. 📚 Move on to our next tutorial: Django Views and Request Handling
  4. 🌟 Experiment with model inheritance and abstract models

Remember: Every Django expert started with their first model. Keep building, keep learning, and most importantly, have fun! 🚀

Happy coding! 🎉🚀✨

Previous Tutorial
📘 Django Basics: MVT Architecture
Next Tutorial
📘 Django Views: Request Handling

More python Tutorials

Part 352

📘 Django Basics: MVT Architecture

🚀Intermediate • 20 min read
Part 353 - Currently Reading

📘 Django Models: ORM Basics

🚀Intermediate • 20 min read
Part 354

📘 Django Views: Request Handling

🚀Intermediate • 25 min read
View all 365 python tutorials →

Tutorial Info

Series Progress
Part 353 of 365 97%
Category
🐍 python
Difficulty
🚀Intermediate
Duration
20 min read
Published
July 12, 2025