DEV Community: yvonne20865

DJANGO MODELS

yvonne20865 — Wed, 02 Jul 2025 20:03:06 +0000

If you're diving into Django, there's no escaping Django Models they're the backbone of any Django powered app. Whether you're building a blog, an e-commerce site, or the next social media giant, you'll be working with models all the way. This post is your comprehensive, human-friendly guide to Django Models, packed with code examples and real-world tips.
A Django Model is a Python class that represents a database table. It defines the fields and behaviors of the data you want to store.Let's get into it.

from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=100)
    birth_date = models.DateField(null=True, blank=True)

    def __str__(self):
        return self.name

Basic Fields
Django gives you a variety of fields to work with:

class Book(models.Model):
    title = models.CharField(max_length=200)
    pages = modelcs.IntegerField()
    price = models.DecimalField(max_digits=5, decimal_places=2)
    release_date = models.DateField()
    in_stock = models.BooleanField(default=True)

Relationships: ForeignKey, ManyToMany, One To One
ForeignKey (Many-to-One)

class Book(models.Model):
    author = models.ForeignKey(Author, on_delete=models.CASCADE)

ManyToManyField

class Genre(models.Model):
    name = models.CharField(max_length=50)

class Book(models.Model):
    genres = models.ManyToManyField(Genre)

OneToOneField

class Profile(models.Model):
    user = models.OneToOneField('auth.User', on_delete=models.CASCADE)
    bio = models.TextField()

Meta Options
You can control behavior like ordering, table names, and verbose names using the Meta class:

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

    class Meta:
        db_table = 'book_publishers'
        ordering = ['name']
        verbose_name = 'Publisher'
        verbose_name_plural = 'Publishers'

Field Options

class Article(models.Model):
    title = models.CharField(
        max_length=200,
        null=True,        # Can be NULL in database
        blank=True,       # Can be empty in forms
        unique=True       # Must be unique
    )

Choices for Fields

class Book(models.Model):
    FORMAT_CHOICES = [
        ('H', 'Hardcover'),
        ('P', 'Paperback'),
        ('E', 'Ebook')
    ]
    format = models.CharField(max_length=1, choices=FORMAT_CHOICES)

Auto Fields

class Audit(models.Model):
    created = models.DateTimeField(auto_now_add=True)
    updated = models.DateTimeField(auto_now=True)

Custom Methods

class Book(models.Model):
    title = models.CharField(max_length=100)
    release_date = models.DateField()

    def is_new_release(self):
        from datetime import date, timedelta)
        return self.release_date >= date.today() - timedelta(days=30

get_absolute_url

from django.urls import reverse

class Book(models.Model):
    def get_absolute_url(self):
        return reverse('book_detail', args=[str(self.id)])

Custom Managers

class BookManager(models.Manager):
    def published(self):
        return self.filter(release_date__isnull=False)

class Book(models.Model):
    title = models.CharField(max_length=100)
    release_date = models.DateField(null=True)

    objects = BookManager()

# Usage
Book.objects.published()

Model Inheritance

class TimestampedModel(models.Model):
    created = models.DateTimeField(auto_now_add=True)
    updated = models.DateTimeField(auto_now=True)

    class Meta:
        abstract = True

class Post(TimestampedModel):
    title = models.CharField(max_length=100)

Multi-table Inheritance

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

class Dog(Animal):
    breed = models.CharField(max_length=50)

Model Signals

from django.db.models.signals import post_save
from django.dispatch import receiver

@receiver(post_save, sender=Author)
def author_saved(sender, instance, **kwargs):
    print(f"Author saved: {instance.name}")

Migrations

python manage.py makemigrations
python manage.py migrate

Querying the Database

# All books
Book.objects.all()

# Filter
Book.objects.filter(title__icontains="django")

# Get one object
Book.objects.get(id=1)

# Create
Book.objects.create(title="New Book", release_date="2025-07-01")

# Update
book = Book.objects.get(id=1)
book.title = "Updated Title"
book.save()

# Delete
book.delete()

Final Thoughts
Django Models are deep, flexible, and incredibly powerful. The best way to master them is to build real projects and tweak your models as you go. This guide gives you a solid foundation but don’t stop here. Play, break things, and learn by doing!
Got questions or want a deep-dive on model relationships drop a comment down below.

MVT ARCHICTURE:Models, Views,Templates,URLs.

yvonne20865 — Wed, 02 Jul 2025 17:27:09 +0000

Django is a powerful, high level web framework built with Python. It’s designed to help developers build clean, efficient, and scalable web apps fast.

At the heart of Django is something called the MVT architecture, which stands for Model, View, Template. It’s pretty similar to the well-known MVC (Model-View-Controller) pattern, just with some tweaks in terminology that make sense in Django’s world.
What is MVT in Django?
Django uses the MVT structure to keep your code organized and maintainable. Let’s break down what that means:
Models — Your Database Tables
In Django, a Model is simply a Python class that defines the structure of your database table. It handles all the data creating, reading, updating, and deleting.

Example:

from django.db import models

class Users(models.Model):
    full_name = models.CharField(max_length=200)
    bio = models.TextField()

    def __str__(self):
        return self.full_name

When you define a model like Users, Django creates a corresponding database table behind the scenes. It’s clean, simple, and powerful.
Views — Your Logic Layer
Views in Django are Python functions or classes that handle incoming requests and return responses — like HTML pages, JSON, redirects, etc.
They interact with your models to get data and pass it to templates for display.
Example:

from django.shortcuts import render
from .models import Users

def user_list(request):
    users = Users.objects.all()
    return render(request, 'users/users_list.html', {'users': users})

This view fetches all users from the database and sends them to a template for display.
Templates — The User Interface
A Template is basically your HTML file. It contains placeholders where dynamic data from your views shows up. Django comes with its own templating language, but you can also use alternatives like Jinja2.

Example Template:

<!DOCTYPE html>
<html>
<head>
    <title>My Users</title>
</head>
<body>
    <h1>All Users</h1>
    {% for user in users %}
        <div>
            <h2>{{ user.full_name }}</h2>
            <p>{{ user.bio }}</p>
        </div>
    {% empty %}
        <p>No users available.</p>
    {% endfor %}
</body>
</html>

Simple, clean, and easy to work with.
URLs — Connecting the Pieces
To make your views accessible via the browser, you define URL patterns like this:

from django.urls import path
from . import views

urlpatterns = [
    path('', views.user_list, name='user_list'),
]

Now when someone visits your site, they’ll hit your view, which talks to your model and renders the template.

Quick Recap
The MVT structure keeps things tidy:
Model: Handles your data
View: Contains your logic
Template: Displays the output
This separation makes your code cleaner and your project easier to scale as it grows.

Hope this clears up how Django apps are structured!
If you have questions or want me to explain anything deeper, drop a comment below.

Setting up my django project.

yvonne20865 — Mon, 30 Jun 2025 18:13:28 +0000

In this article, I’ll walk you through how I set up my Django project with two apps from the terminal to running the project, all the way to pushing it to GitHub. If you're new to Django, this guide might come in handy.
1. Setting Up the Virtual Environment.
First things first, I opened my Git Bash terminal and created a virtual environment to keep my project dependencies isolated:

python -m venv env

To activate the environment:

source env/Scripts/activate

2.Creating the Django Project.
Once the environment was active, I created my Django project using:

django-admin startproject django_project
cd django_project

3.Creating the 2 apps.
Inside the project, I created two apps and called them app1 and app2:

python manage.py startapp app1
python manage.py startapp app2

4.Opening the project in VScode.
Still in Git Bash, I opened the project in VS Code with:

code .

From here, I explored the structure of the project and both apps.
5.Registering the apps in settings.
Then, I made sure to add both apps to theINSTALLED_APPS list in settings.py:

INSTALLED_APPS = [
    ...,
    'app1',
    'app2',
]

6.Configuring URLs.
In the project’s urls.py file, I imported include and set up paths to both apps:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('app1/', include('app1.urls')),
    path('app2/', include('app2.urls')),
]

7. Setting Up Views and URLs for Each App.
For app1:
In app1/views.py:

from django.shortcuts import render

def home(request):
    return render(request, 'home.html')

def about(request):
    return render(request, 'about.html')

In app1/urls.py:

from django.urls import path
from . import views

urlpatterns = [
    path('', views.home, name='home'),
    path('about/', views.about, name='about'),
]

For app2:
In app2/views.py:

from django.shortcuts import render

def contact(request):
    return render(request, 'contact.html')

def services(request):
    return render(request, 'services.html')

Inapp2/urls.py:

From django.urls import path
from . import views

urlpatterns = [
    path('contact/', views.contact, name='contact'),
    path('services/', views.services, name='services'),
]

8.Creating the Templates Folder.
At the root of the project, I created a templates folder to hold my HTML files:

django_project/
├── templates/
│   ├── home.html
│   ├── about.html
│   ├── contact.html
│   ├── services.html

Inside each file, I added some basic HTML to test:
home.html

{% block content %}
         <p>Welcome to my django project.</p>
    {% endblock %}

about.html

{% block content %}
            <p>.</p>Welcome to our learning project. This project is built to help you understand how Django works with multiple apps and templates.
    {% endblock %}
</body>
<style>
    body {
        background-color: chocolate;
    }

contact.html

% block content %}
<h1>Contact Us</h1>
<p>If you have any questions, feel free to reach out to us!</p>

<form method="post">
    {% csrf_token %}
    <label for="name">Your Name:</label><br>
    <input type="text" id="name" name="name" required><br><br>

    <label for="email">Your Email:</label><br>
    <input type="email" id="email" name="email" required><br><br>

    <label for="message">Message:</label><br>
    <textarea id="message" name="message" rows="5" required></textarea><br><br>

    <button type="submit">Send</button>
</form>
{% endblock %}

</body>
<Style>
body {
    font-family: Arial, sans-serif;
    margin: 40px;
    background-color: #f2f2f2;
}

h1 {
    color: #333;
    text-align: center;
}

p {
    color: #555;
    font-size: 16px;
    text-align: center;
}

ul {
    list-style-type: square;
    padding-left: 20px;
    max-width: 600px;
    margin: 20px auto;
    background: #fff;
    padding: 20px;
    border-radius: 8px;
}

li {
    padding: 8px 0;
    color: #333;
}

form {
    max-width: 400px;
    margin: 0 auto;
    background: #fff;
    padding: 20px;
    border-radius: 8px;
}

label {
    font-weight: bold;
    display: block;
    margin-top: 10px;
}

input[type="text"],
input[type="email"],
textarea {
    width: 100%;
    padding: 10px;
    margin-top: 5px;
    border: 1px solid #ccc;
    border-radius: 4px;
    box-sizing: border-box;
}

button {
    margin-top: 15px;
    padding: 10px 20px;
    background-color: #007bff;
    color: white;
    border: none;
    border-radius: 4px;
    cursor: pointer;
    width: 100%;
}

button:hover {
    background-color: #0056b3;
}
</Style>

services.html

{% block content %}
<h1>Our Services</h1>
<ul>
    <li>Website Development Tutorials</li>
    <li>Django Learning Resources</li>
    <li>Practical Project Building</li>
    <li>Step-by-Step Guidance</li>
</ul>
<p>We help you build and understand Django projects through real-world examples.</p>
{% endblock %}

9.Connecting Django to the Templates Folder.
In settings.py, I made sure Django knows where to look for templates by updating the TEMPLATES setting:

TEMPLATES = [
    {
        ...,
        'DIRS': [BASE_DIR / 'templates'],
        ...
    },
]

10.Running the Server.
In the terminal:

python manage.py runserver

I copied the local link (http://127.0.0.1:8000/) and pasted it into my browser. Visiting the correct URLs showed the HTML templates I had created:
%http://127.0.0.1:8000/app1/% → Home page from App 1
%http://127.0.0.1:8000/app1/about/% → About page from App 1
%http://127.0.0.1:8000/app2/contact/% → Contact page from App 2
%http://127.0.0.1:8000/app2/services/%→ Services page from App 2
11 Pushing the Project to GitHub.
To share or back up the project, I pushed it to GitHub:
Created a new repository on Github and named it django_project
In the terminal:

git init
git add .
git commit -m "Initial commit"
git remote add origin <your_repo_link>
git push -u origin master

You can copy and share the repo link with others as needed.%https://github.com/yvonne20865/django_project%
here's my link...

*Final Thoughts *
And that’s how I set up my Django project with two apps, HTML templates, proper URL routing, and pushed it to GitHub. The process is simple once you break it down, and using templates makes your project look and feel like a real website from the start.

Hope this helps! Let me know if you have any questions or tips from your own setup experience.

Beginner's guide to Git and GitHub.

yvonne20865 — Thu, 26 Jun 2025 12:34:05 +0000

Learn the basics of Git and GitHub from version control to collaboration tools like pull requests, merge conflicts, and code reviews. Perfect for beginners!
A Beginner’s Guide to Version Control and Collaboration.
If you’ve ever worked on a project and thought, “Wait, which version is the latest? "you’ve already felt the need for version control. In this guide, we’ll walk through how tools like Git and GitHub help developers manage changes, collaborate with others, and keep projects on track all in simple terms anyone can follow.
What Is Version Control?
Think of it as a giant “undo” button that also lets your whole team work together without stepping on each other’s toes. Version control is a system that helps track and manage changes to files, especially source code it is one of the most popular version control systems out there, and GitHub is where Git-powered collaboration happens.
Forking: Making Your Own Copy
When you fork a project on GitHub, you’re creating your own personal copy of it. You can experiment, make improvements, or fix bugs without affecting the original. Later, you can suggest your changes to the original project by opening something called a pull request.
Pull Requests & Working Together
A pull request (PR) is how you propose your changes to a project. It’s where the magic of collaboration happens you get feedback, have discussions, and improve your code before it becomes part of the main project.
Merge Conflicts: Don’t Panic
Sometimes, two people edit the same file in different ways. When Git doesn’t know which version to keep, you get a merge conflict. It sounds scary, but it just means you’ll need to choose which changes to keep. Git will show you exactly what to fix.
Code Review: Helping Each Other Get Better.
Before your code is accepted, someone might review it. Code reviews are friendly feedback loops. They help catch bugs, improve quality, and let you learn from others.
GitHub Issues: Where Work Gets Organized
GitHub Issues help you keep track of ideas, bugs, tasks, and anything else you need to remember. They’re like a to-do list that’s tied to your code very handy for organizing your work and planning what’s next.
Useful Git Commands

Here’s a small set of commands to get you going:

git clone <url>             # Copy someone’s project to your computer
git checkout -b my-branch   # Start a new branch to make changes
git add .                   # Stage all your edits
git commit -m "My changes"  # Save your changes with a message
git push origin my-branch   # Send your branch to GitHub

To get more commands here's a link to a git cheat sheet.
%https://wac-cdn.atlassian.com/dam/jcr:d60ca565-89db-4f07-98a0-dd35fae97293/git1.jpg?cdnVersion=2803%
Pushing Changes and Making Things Official
After working on your fork and committing your changes, use git push to send your updates to GitHub. From there, open a pull request and wait for feedback. Once approved, your code is merged, and boom you’re an official contributor!
Common Git Mistakes Beginners Make (And How to Avoid Them)
Starting out with Git can feel like learning to dance with two left feet. Mistakes happen but that’s part of the learning process!

Setting up my development environment on windows.

yvonne20865 — Tue, 24 Jun 2025 19:10:51 +0000

Introduction.
I recently took the time to properly set up my development environment on Windows, and I thought it would be useful to share what I did for anyone else looking to do the same. Whether you're a beginner or switching from another setup, having the right tools configured can save you hours of frustration down the line.
Here’s a breakdown of how I got everything working — from WSL to Docker, Git, Python, and even SSH for smooth GitHub integration.
First thing I did was make sure Git was installed and properly configured to work with GitHub over SSH.
Steps:
-Installed Git from https://git-scm.com/downloads
-Checked the installation:
git --version
-Configured my user details:

git config --global user.name "Yvonne"
git config --global user.email "yvonnewambugu20@gmail.com"

-Generated an SSH key for GitHub:
`ssh-keygen -t ed25519 -C "yvonnewambugu20@gmail.com"

Copied the SSH key to my clipboard: `cat ~/.ssh/id_ed25519.pub -Added the SSH key to my GitHub account under Settings > SSH and GPG Keys. -Tested the connection: ssh -T git@github.com No more typing passwords every time I push to GitHub — smooth and secure!

Installing Python 3.10+
I work with Python, so I made sure I had Python 3.10 or higher installed.
Steps:

Downloaded Python from https://www.python.org/downloads/
During installation, I made sure to check the box to add Python to PATH.
Verified the installation: python --version -Installed pip (if not already included) and upgraded it: python -m ensurepip --upgrade python -m pip install --upgrade pip

Choosing a Text Editor
For coding, I use VS Code, but I also recommend PyCharm, especially if you're mainly working with Python projects.
Why VS Code?
-Lightweight, fast, and easy to customise.
-Tons of extensions (Python, Docker, Git integrations).
-Download from: https://code.visualstudio.com/

Setting Up WSL
I use WSL to get a full Linux development environment running inside Windows — this makes working with tools like Docker so much easier.
Steps:
-Installed WSL using:
wsl --install
-Installed Ubuntu as my preferred Linux distro.
-Confirmed everything was working:
wsl --list --verbose
I made sure I was running WSL 2, as it has better performance and Docker compatibility.

Getting Docker Working Inside WSL.
Next up was Docker. I wanted to run containers inside my WSL terminal without hassle.
What I Did:
-Installed Doker Desktop for windows:
https://www.docker.com/products/docker-desktop
Once WSL was running, I wanted to be able to use Docker commands directly inside my Ubuntu terminal. But when I tried running:
docker --version
I got an error saying Docker wasn’t recognised inside WSL.
Here’s how I fixed it:
-Opened Docker Desktop on Windows.

Went to Settings > Resources > WSL Integration.
Enabled integration for my Ubuntu distribution. After that, I restarted my terminal and ran docker --version again — and it worked! Now I can run Docker containers directly from my Ubuntu terminal, without switching back and forth between Windows and Linux environments.

Final Thoughts
Setting up your development environment properly takes time, but it’s worth every minute. With Git, Python, Docker, and WSL working together, everything feels much smoother and more efficient.

If you're thinking about setting up your own, I highly recommend:
-Using WSL to avoid headaches when switching between Windows and Linux tools.
-Connecting Git with SSH from the start to avoid constant password prompts.
-Choosing an editor (VS Code or PyCharm) that suits your workflow.
-Making sure you’re on the latest Python version.
This setup has made coding on Windows way more enjoyable for me. No more battling with permissions, version mismatches, or confusing terminal errors.
Hopefully, this helps someone else get their environment up and running too. If you've gone through this process or have tips to make it easier, I’d love to hear about it!