How to Create Models in Your Django Project
If you're building something with Django, there's one thing you can't skip: creating models. Models are the heart of any Django app. They define how your data is structured, how it's stored in the database, and how Django can interact with it. Now, i...
If you're building something with Django, there's one thing you can't skip: creating models. Models are the heart of any Django app. They define how your data is structured, how it's stored in the database, and how Django can interact with it.
Now, if you're new to Django or still wrapping your head around the basics, don’t worry. I’ve been there too. Models might sound a bit intimidating at first, but they’re pretty straightforward once you see how they work.
I’ll walk you through it all – step by step – so by the end of this post, you’ll not only know how to create models, but also how to use them in real projects.
Let’s get into it.
Here’s what we’ll cover:
What is a Model in Django?
A model in Django is just a Python class that tells Django how you want your data to look. Django takes care of the hard part (talking to the database), so you can focus on describing your data in simple Python code.
Here’s a quick example of a basic model:
from django.db import models
class Book(models.Model):
title = models.CharField(max_length=100)
author = models.CharField(max_length=50)
published_date = models.DateField()
price = models.DecimalField(max_digits=5, decimal_places=2)
Let me break it down:
titleandauthorare just short pieces of text, so I’m usingCharField.published_dateis a date – easy enough, that’s whatDateFieldis for.priceis a number with decimals, soDecimalFielddoes the job.
Each line describes one piece of data I want to store for every book. Simple, right?
How to Create Models in Django
Step 1: Start a Django Project (if you haven’t already)
If you’re brand new, first you need a Django project:
django-admin startproject mysite
cd mysite
python manage.py startapp books
Now you’ve got a Django app called books where you can put your models.
Step 2: Define Your Model
Inside your app folder (books), open models.py. That’s where you’ll define your model.
Here’s a slightly more real-world example:
from django.db import models
class Author(models.Model):
name = models.CharField(max_length=100)
birthdate = models.DateField()
def __str__(self):
return self.name
class Book(models.Model):
title = models.CharField(max_length=200)
author = models.ForeignKey(Author, on_delete=models.CASCADE)
summary = models.TextField()
isbn = models.CharField(max_length=13, unique=True)
published = models.DateField()
price = models.DecimalField(max_digits=6, decimal_places=2)
def __str__(self):
return self.title
What’s happening here:
I’ve created two models:
AuthorandBook.Bookhas a relationship withAuthorusingForeignKey. That means one author can have many books.I’m using
__str__()to return a nice name when I look at objects in the Django admin.
Step 3: Register the App and Create the Database
Before Django can use your models, make sure your app is added to the project settings.
Open mysite/settings.py and find the INSTALLED_APPS list. Add 'books', to it:
INSTALLED_APPS = [
# other apps
'books',
]
Now, run migrations to create the database tables for your models:
python manage.py makemigrations
python manage.py migrate
This is how Django turns your Python code into actual database tables. The first command makes a migration file (basically, instructions for the database), and the second applies it.
Step 4: Create and Use Objects
Now you can use these models in your code. Open the Django shell:
python manage.py shell
Then try this out:
from books.models import Author, Book
from datetime import date
# Create an author
jane = Author.objects.create(name="Jane Austen", birthdate=date(1775, 12, 16))
# Create a book
book = Book.objects.create(
title="Pride and Prejudice",
author=jane,
summary="A novel about manners and marriage in early 19th-century England.",
isbn="1234567890123",
published=date(1813, 1, 28),
price=9.99
)
print(book)
Django will save these to your database automatically.
Extra Model Features That You’ll Use
1. Default Values
You can give a field a default value:
is_published = models.BooleanField(default=False)
2. Auto Timestamps
These are super useful when tracking created or updated times:
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
3. Model Meta Options
You can add class Meta to customize things like the default ordering:
class Book(models.Model):
# fields...
class Meta:
ordering = ['published']
Using Models in Django Admin
Django’s built-in admin panel is one of the best parts of the framework. But your models won’t show up there unless you register them.
In books/admin.py, add:
from django.contrib import admin
from .models import Author, Book
admin.site.register(Author)
admin.site.register(Book)
Now run:
python manage.py createsuperuser
Then go to http://127.0.0.1:8000/admin, log in, and boom – your models are there, with a full interface.
FAQs
Can I change a model after I’ve made it?
Yes, but you’ll need to make a new migration:
python manage.py makemigrations
python manage.py migrate
What databases work with Django?
Django works with PostgreSQL, MySQL, SQLite (default), and more. Most people start with SQLite when learning because it's easy and works out of the box.
What’s the difference between CharField and TextField?
Use CharField for short text with a max length (like a name or title). Use TextField for longer text (like a blog post or summary).
Final Thoughts
Once you understand models, the rest of Django starts to click into place. Everything – forms, views, templates – eventually connects back to the model. It's how your app stores and works with real data.
The best way to learn is by building something. Start small, maybe a book catalog, a task manager, or a personal blog. Add models one at a time and play with them in the admin.
