Model Fields | Models | Django Tutorial

Introduction

In Django, models are Python classes that represent the structure of your database. Each model maps to a single database table. Fields in a model represent the columns of the table. Django provides several field types to help define the data structure.

Common Field Types

Django offers a variety of field types to suit different data needs. Here are some of the most commonly used field types:

CharField: A string field for small- to large-sized strings.
TextField: A large text field for longer strings.
IntegerField: An integer field.
DateField: A date field.
BooleanField: A true/false field.
ForeignKey: A many-to-one relationship field.
ManyToManyField: A many-to-many relationship field.

CharField Example

The CharField is used to store strings. You can specify a maximum length for the field.

from django.db import models

class MyModel(models.Model):
    name = models.CharField(max_length=100)

In this example, the name field will store strings up to 100 characters in length.

TextField Example

The TextField is used to store large text.

from django.db import models

class MyModel(models.Model):
    description = models.TextField()

In this example, the description field will store large text, with no maximum length enforced by the database.

IntegerField Example

The IntegerField is used to store integers.

from django.db import models

class MyModel(models.Model):
    age = models.IntegerField()

In this example, the age field will store integer values.

DateField Example

The DateField is used to store dates.

from django.db import models

class MyModel(models.Model):
    birth_date = models.DateField()

In this example, the birth_date field will store date values.

BooleanField Example

The BooleanField is used to store boolean values (True/False).

from django.db import models

class MyModel(models.Model):
    is_active = models.BooleanField(default=True)

In this example, the is_active field will store boolean values, and its default value is set to True.

ForeignKey Example

The ForeignKey is used to define a many-to-one relationship.

from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=100)

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)

In this example, the Book model has a foreign key to the Author model. The on_delete=models.CASCADE argument specifies that when the referenced Author record is deleted, all related Book records should also be deleted.

ManyToManyField Example

The ManyToManyField is used to define a many-to-many relationship.

from django.db import models

class Student(models.Model):
    name = models.CharField(max_length=100)

class Course(models.Model):
    title = models.CharField(max_length=100)
    students = models.ManyToManyField(Student)

In this example, the Course model has a many-to-many relationship with the Student model. This means a course can have multiple students and a student can enroll in multiple courses.

Conclusion

Understanding Django model fields is crucial for defining your database schema accurately. Each field type serves a specific purpose and helps in maintaining the integrity and structure of your data. By using the appropriate field types, you can ensure that your models are well-defined and easy to manage.

Django Model Fields