Defining models with fields in Django - Step-by-Step Execution

Concept Flow - Defining models with fields

Start: Define model class

↓

Add field attributes

↓

Set field types and options

↓

Save model file

↓

Run migrations to create DB table

↓

Model ready for use in app

This flow shows how you create a Django model by defining a class with fields, then prepare it for database use.

Execution Sample

Django

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=100)
    pages = models.IntegerField()

Defines a Book model with a title and number of pages as fields.

Execution Table

Step	Action	Code Line	Effect	Resulting Model State
1	Import models module	from django.db import models	models module available	No model defined yet
2	Define Book class inheriting models.Model	class Book(models.Model):	Book model class created	Empty Book model
3	Add title field as CharField	title = models.CharField(max_length=100)	title field added with max_length=100	Book model has title field
4	Add pages field as IntegerField	pages = models.IntegerField()	pages field added as integer	Book model has title and pages fields
5	Save file and run migrations	python manage.py makemigrations	Migration file created	Database ready to create Book table
6	Apply migrations	python manage.py migrate	Book table created in DB	Model fully ready for use
7	Exit	-	Model defined and synced with DB	Ready to create Book instances

💡 Model class defined and database table created after migrations

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
Book model	undefined	class with title field	class with title and pages fields	class with both fields ready for DB

Key Moments - 3 Insights

Why do we inherit from models.Model?

In step 2, inheriting from models.Model tells Django this class is a database model, enabling field definitions and DB table creation.

What does max_length=100 mean in CharField?

Step 3 shows max_length=100 limits the title field to 100 characters, which Django enforces in the database schema.

Why run makemigrations and migrate after defining fields?

Steps 5 and 6 create and apply database changes so the model fields exist as columns in the database table.

Visual Quiz - 3 Questions

Look at the execution table, what fields does the Book model have after step 4?

A Only pages

B title and pages

C Only title

D No fields yet

💡 Hint

Check the 'Resulting Model State' column at step 4 in the execution table.

At which step is the database table for the Book model created?

A Step 3

B Step 5

C Step 6

D Step 2

💡 Hint

Look for when 'Book table created in DB' appears in the 'Effect' column.

If you forget to inherit from models.Model, what happens?

A Django won't recognize the class as a model

B Model works fine without inheritance

C Fields become database columns anyway

D Migrations run without errors

💡 Hint

Refer to the key moment about inheritance and step 2 in the execution table.

Concept Snapshot

Define a Django model by creating a class inheriting from models.Model.
Add fields as class attributes using field types like CharField or IntegerField.
Set options like max_length to control field behavior.
Run makemigrations and migrate to create database tables.
Models represent database tables in your app.

Full Transcript

To define a model in Django, start by importing models from django.db. Then create a class that inherits from models.Model. Inside this class, add fields as attributes using Django's field types, such as CharField for text and IntegerField for numbers. Each field can have options like max_length to limit text size. After saving your model, run 'python manage.py makemigrations' to create migration files that describe database changes. Then run 'python manage.py migrate' to apply these changes and create the corresponding database table. This process connects your Python model class to a real database table, ready for storing data.