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.

Practice

1. What is the purpose of defining fields in a Django model?

easy

A. To create views for the web application

B. To specify the type of data each column will store in the database

C. To write HTML templates for the frontend

D. To handle user authentication automatically

Solution

1. Step 1: Understand Django model fields

   Fields in a Django model define what kind of data each column in the database will hold, such as text, numbers, or dates.

2. Step 2: Differentiate from other components

   Views handle logic, templates handle display, and authentication is separate; fields specifically define data structure.

3. Final Answer:

   To specify the type of data each column will store in the database -> Option B

4. Quick Check:

   Model fields = Data columns [OK]

Hint: Fields define data types in models, not views or templates [OK]

Common Mistakes:

• Confusing fields with views or templates
• Thinking fields handle user login
• Assuming fields control page layout

2. Which of the following is the correct way to define a character field named title with a maximum length of 100 in a Django model?

easy

A. title = models.IntegerField(max_length=100)

B. title = models.TextField(max_length=100)

C. title = models.CharField(length=100)

D. title = models.CharField(max_length=100)

Solution

1. Step 1: Identify correct field type and argument

   For text with length limit, CharField with max_length is correct.

2. Step 2: Check syntax correctness

   TextField does not use max_length, IntegerField is for numbers, and CharField requires max_length, not length.

3. Final Answer:

   title = models.CharField(max_length=100) -> Option D

4. Quick Check:

   CharField + max_length = correct syntax [OK]

Hint: Use CharField with max_length for short text fields [OK]

Common Mistakes:

• Using TextField with max_length
• Using IntegerField for text
• Writing length instead of max_length

3. Given the model definition below, what will be the default value of the is_active field for a new instance if not specified?

class User(models.Model):
    username = models.CharField(max_length=50)
    is_active = models.BooleanField(default=true)

medium

A. true

B. false

C. Raises an error

D. null

Solution

1. Step 1: Check Python syntax for booleans

   In Python and Django, booleans are True and False (capitalized). true is undefined.

2. Step 2: Model definition outcome

   Defining default=true raises NameError at model definition time, preventing instance creation.

3. Final Answer:

   Raises an error -> Option C

4. Quick Check:

   default=true -> NameError [OK]

Hint: Python/Django booleans: True/False (capitalized), not true/false [OK]

Common Mistakes:

• Assuming default is true despite syntax error
• Expecting null as default for BooleanField
• Using lowercase true/false in default

4. Identify the error in the following Django model field definition:

class Product(models.Model):
    price = models.DecimalField(max_digits=5, decimal_places=2, max_length=10)

medium

A. DecimalField does not accept max_length argument

B. max_digits should be less than decimal_places

C. DecimalField requires a default value

D. Field name 'price' is a reserved keyword

Solution

1. Step 1: Check DecimalField arguments

   DecimalField accepts max_digits and decimal_places, but not max_length.

2. Step 2: Validate argument usage

   Including max_length causes a syntax error because it's invalid for DecimalField.

3. Final Answer:

   DecimalField does not accept max_length argument -> Option A

4. Quick Check:

   DecimalField = max_digits + decimal_places only [OK]

Hint: DecimalField uses max_digits and decimal_places, not max_length [OK]

Common Mistakes:

• Adding max_length to DecimalField
• Mixing max_digits and decimal_places values incorrectly
• Assuming field names are reserved keywords

5. You want to create a Django model BlogPost with a title (max 200 chars), content (unlimited text), and a published date that can be empty. Which of the following is the best model definition?

hard

A. class BlogPost(models.Model):\n title = models.CharField(max_length=200)\n content = models.TextField()\n published_date = models.DateTimeField(blank=True, null=True)

B. class BlogPost(models.Model):\n title = models.TextField(max_length=200)\n content = models.CharField()\n published_date = models.DateTimeField()

C. class BlogPost(models.Model):\n title = models.CharField(max_length=200, blank=true)\n content = models.TextField()\n published_date = models.DateTimeField()

D. class BlogPost(models.Model):\n title = models.CharField(max_length=200)\n content = models.TextField()\n published_date = models.DateTimeField(default='')

Solution

1. Step 1: Match field types to requirements

   Title needs limited length, so CharField(max_length=200) is correct. Content is unlimited text, so TextField fits.

2. Step 2: Allow published_date to be empty

   To allow empty dates, use blank=True and null=True on DateTimeField.

3. Step 3: Check other options for errors

   class BlogPost(models.Model):\n title = models.TextField(max_length=200)\n content = models.CharField()\n published_date = models.DateTimeField() misuses TextField with max_length and swaps content types. class BlogPost(models.Model):\n title = models.CharField(max_length=200, blank=true)\n content = models.TextField()\n published_date = models.DateTimeField() does not allow empty published_date. class BlogPost(models.Model):\n title = models.CharField(max_length=200)\n content = models.TextField()\n published_date = models.DateTimeField(default='') uses invalid default for DateTimeField.

4. Final Answer:

   Correct field types with blank and null for published_date -> Option A

5. Quick Check:

   CharField + TextField + DateTimeField(blank=True, null=True) [OK]

Hint: Use blank=true and null=true to allow empty date fields [OK]

Common Mistakes:

• Using TextField with max_length
• Not allowing null for optional DateTimeField
• Setting invalid default values for DateTimeField