Learning Django: A Step-by-Step Guide to Models and Databases

Learning Django: A Step-by-Step Guide to Models and Databases

Introduction

Django is a high-level Python web framework that encourages rapid development and clean, pragmatic design. One of its core features is the Object-Relational Mapping (ORM) system, which allows developers to interact with databases using Python code. In this guide, we will explore Django models, migrations, and databases from basic to advanced.

1. Setting Up Your Django Project

  1. Install Django
pip install django
  1. Create a Django Project
django-admin startproject myproject
cd myproject
  1. Start the Development Server
python manage.py runserver
  • Open http://127.0.0.1:8000/ in your browser to see the Django welcome page.

2. Creating a Simple Django App

  1. Create an App
python manage.py startapp myapp
  1. Register the App in settings.py
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'myapp',  # Add your app here
]

3. Creating Your First Model

  1. Define a Model (models.py)
from django.db import models

class Person(models.Model):
    name = models.CharField(max_length=100)  # Text field with max length 100
    lastname = models.CharField(max_length=100)  # Text field with max length 100
    age = models.IntegerField()  # Integer field
    address = models.CharField(max_length=255)  # Text field for address
    email = models.EmailField(unique=True)  # Unique email field
    enrollment_date = models.DateField(auto_now_add=True)  # Auto-filled date field
    is_active = models.BooleanField(default=True)  # Boolean field to check if the person is active

    def __str__(self):
        return f"{self.name} {self.lastname}"

4. Working with Migrations in Django

What are Migrations?

Migrations are Django's way of propagating changes you make to your models (adding a field, deleting a model, etc.) into your database schema.

1. Creating Migrations (makemigrations)

python manage.py makemigrations
  • Analyzes your models and creates migration files.
  • Example output:
Migrations for 'myapp':
  myapp/migrations/0001_initial.py
    - Create model Person

2. Applying Migrations (migrate)

python manage.py migrate
  • Applies the changes described in migration files to the actual database.
  • Example output:
Applying myapp.0001_initial... OK

3. Checking Migration Status

python manage.py showmigrations
  • Shows which migrations are applied and which are pending.

4. Rolling Back Migrations

python manage.py migrate myapp 0001
  • Rolls back to a specific migration.

Best Practices

  • Always run makemigrations and migrate after model changes.
  • Check migration status with showmigrations.

5. Adding Data Using Django Shell

  1. Open the Django Shell
python manage.py shell
  1. Add Data to the Model
from myapp.models import Person

# Create a new person
person = Person(name="John", lastname="Doe", age=25, address="New York", email="john@example.com", is_active=True)
person.save()

# Verify the data
Person.objects.all()
  • This will output the saved data, showing the person in the database.

6. Using Django Admin Panel

  1. Create a Superuser
python manage.py createsuperuser
  1. Register the Model in Admin (admin.py)
from django.contrib import admin
from .models import Person

admin.site.register(Person)
  1. Access the Admin Panel
  • Visit http://127.0.0.1:8000/admin/ and log in with your superuser credentials.

7. Displaying Data on a Webpage

  1. Create a View (views.py)
from django.http import HttpResponse
from .models import Person

def person_list(request):
    persons = Person.objects.all()
    output = ''
    for p in persons:
        output += f"Name: {p.name} {p.lastname} (Age: {p.age}), Address: {p.address}, Email: {p.email}, Enrolled on: {p.enrollment_date}, Active: {p.is_active}<br>"
    return HttpResponse(output)
  1. Set Up a URL (urls.py)
from django.urls import path
from .views import person_list

urlpatterns = [
    path('persons/', person_list, name='person_list'),
]
  1. Connect App URLs in Project (myproject/urls.py)
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('myapp.urls')),
]
  1. Test in Browser
  • Visit http://127.0.0.1:8000/persons/ to see the list of persons.

8. Next Steps

  • Learn Django Templates
  • Django Forms and Validation
  • CRUD Operations (Create, Read, Update, Delete)
  • Model Relationships
  • Advanced Querying and Model Methods

Conclusion

This guide covers the basics of creating models, working with migrations, and displaying data in Django. As you become more comfortable with the basics, you can explore more advanced features of Django models and the ORM to build robust and dynamic web applications.

Comments

Post a Comment

Popular posts from this blog

Mastering Django: Project and App Folder Structure

Mastering Django: Project and App Folder Structure 1. Django Project Folder Structure When you create a Django project, it follows a structured format, ensuring an organized development environment. projectname/ │── manage.py # Command-line utility to manage the project │── db.sqlite3 # Default SQLite database file (if used) │── projectname/ # Main project directory containing settings │ │── __init__.py # Marks this directory as a Python package │ │── settings.py # Project-wide configuration settings │ │── urls.py # Main URL routing for the project │ │── asgi.py # Entry point for ASGI-compatible web servers (optional) │ │── wsgi.py # Entry point for WSGI-compatible web servers │── appname/ # A Django app directory (e.g., blog, users, etc.) │ │── __init__.py # Marks this directory as a Python package │ │── admin.py # Configuration for Django admin panel │ │── apps.py # Application configuration │...
Read more

Mastering Django Template Language (DTL): A Step-by-Step Guide

  Mastering Django Template Language (DTL): A Step-by-Step Guide Django's Template Language (DTL) is a powerful tool for rendering dynamic data on web pages using HTML templates . This guide will cover how to pass data from views to templates , display variables, use conditional statements, apply loops, and implement filters with practical examples. ✅ 1. Passing Data from Views to Templates 🧠 How to Pass Data: Data is passed using the context dictionary in the render() function. # views.py from django.shortcuts import render # Simple Template Rendering def home(request): return render(request, 'myapp/home.html') # Dynamic Data Rendering def user_info(request): context = { 'name': 'John Doe', 'age': 25, 'fruits': ['Apple', 'Banana', 'Cherry'], 'is_logged_in': True, 'score': 85, 'hobbies': ['Reading', 'Gaming', ...
Read more

How to Add Templates in Django: Step-by-Step Guide

  How to Add Templates in Django: Step-by-Step Guide Django's Template System allows developers to create web pages by using HTML templates. Adding templates to a Django project involves setting up the template directory , configuring settings.py , and rendering templates through views. This guide will focus solely on how to add templates without involving dynamic data. ✅ 1. Setting Up Your Django Project # Step 1: Create a new Django project and app django-admin startproject myproject cd myproject python manage.py startapp myapp 📂 Project Directory Structure: myproject/ ├── myapp/ │ ├── templates/ │ │ └── myapp/ │ │ ├── home.html │ └── views.py ├── manage.py └── settings.py myapp/templates/myapp/ : This is where all app-specific templates will reside. Keeping templates within the app directory is a best practice to avoid conflicts when multiple apps are used. ✅ 2. Configuring Templates in settings.py TEMPLATES = [ { 'BACKEND...
Read more