Django, the high-level Python web framework, is renowned for its “batteries-included” philosophy, enabling rapid development of robust and scalable web applications.
If you’re eager to dive into web development with Python, Django is an excellent starting point.
This blog post will guide you through the process of creating your first Django project, step-by-step.
1. Setting Up Your Environment:
Before we begin, ensure you have Python installed on your system. Django works best with Python 3.6 or later. You can download the latest version from the official Python website (python.org).
Next, we’ll create a virtual environment. Virtual environments isolate your project’s dependencies, preventing conflicts with other Python projects. This is crucial for maintaining a clean and organized development workflow.
Open your terminal or command prompt and navigate to the directory where you want to create your project.
Then, execute the following commands:
# Create a virtual environment named "myenv"
python -m venv myenv
# Activate the virtual environment (Windows)
myenv\Scripts\activate
# Activate the virtual environment (macOS/Linux)
source myenv/bin/activate
Once activated, your terminal prompt will indicate that you’re working within the virtual environment.
2. Installing Django:
With the virtual environment active, you can now install Django using pip, the Python package installer:
pip install Django
This command will download and install the latest stable version of Django and its dependencies.
To verify the installation, run:
python -m django --version
This should display the installed Django version.
3. Creating a Django Project:
Now, it’s time to create your Django project. A Django project is a collection of settings and configurations for a particular website. To create a project named “myproject,” execute the following command:
django-admin startproject myproject
This command will create a directory named “myproject” with the following structure:
myproject/
manage.py
myproject/
__init__.py
asgi.py
settings.py
urls.py
wsgi.py
manage.py: A command-line utility for interacting with your Django project.myproject/: The project’s inner directory containing configuration files.__init__.py: An empty file that tells Python this directory should be considered a Python package.asgi.py: An entry-point for ASGI-compatible web servers to serve your project.settings.py: Contains settings and configurations for your project.urls.py: Defines the URL patterns for your project.wsgi.py: An entry-point for WSGI-compatible web servers to serve your project.
4. Running the Development Server:
Django comes with a built-in development server that allows you to test your application without deploying it to a production environment. To start the server, navigate to the project’s root directory (where manage.py is located) and execute:
python manage.py runserver
This will start the development server on http://127.0.0.1:8000/. Open your web browser and navigate to this address. You should see the default Django “It worked!” page.
5. Creating a Django App:
A Django project can contain multiple apps. An app is a self-contained module that represents a specific functionality of your website.
For example, you might have an app for managing blog posts, another for user authentication, and another for handling e-commerce transactions and one for an API.
To create an app named “myapp,” execute the following command:
python manage.py startapp myapp
This will create a directory named “myapp” with the following structure:
myapp/
__init__.py
admin.py
apps.py
migrations/
__init__.py
models.py
tests.py
views.py
admin.py: Defines the models that should be displayed in the Django admin interface.apps.py: Contains configuration for the app.migrations/: Stores database schema migrations.models.py: Defines the data models for the app.tests.py: Contains unit tests for the app.views.py: Defines the views (functions or classes) that handle HTTP requests and responses.
6. Defining a Model:
In myapp/models.py, you can define your data models. For example, let’s create a simple model for a “Post” with a title and content:
from django.db import models
class Post(models.Model):
title = models.CharField(max_length=200)
content = models.TextField()
def __str__(self):
return self.title
This defines a Post model with two fields: title (a character field with a maximum length of 200 characters) and content (a text field). The __str__ method defines how the model should be represented as a string.
7. Creating and Applying Migrations:
To apply the changes made to your models to the database, you need to create and apply migrations. Migrations are files that track changes to your database schema.
First, create the migrations:
python manage.py makemigrations
This will create migration files in the myapp/migrations/ directory.
Then, apply the migrations:
python manage.py migrate
This will apply the migrations to your database, creating the necessary tables.
8. Creating a View:
In myapp/views.py, you can define views that handle HTTP requests and responses.
For example, let’s create a view that displays a list of posts:
from django.shortcuts import render
from .models import Post
def post_list(request):
posts = Post.objects.all()
return render(request, 'myapp/post_list.html', {'posts': posts})
This view retrieves all Post objects from the database and passes them to the myapp/post_list.html template.
9. Creating a Template:
Create a directory named templates inside your myapp directory. Inside templates create another directory named myapp. Create a file named post_list.html inside myapp/templates/myapp.
<h1>Posts</h1>
<ul>
{% for post in posts %}
<li>{{ post.title }}</li>
{% endfor %}
</ul>
This template displays a list of post titles.
10. Configuring URLs:
In myapp/urls.py, you can define the URL patterns for your app. Create the file and add the following:
# myapp/urls.py
from django.urls import path
from . import views
urlpatterns = [
path('', views.post_list, name='post_list'),
]
Then, include these URLs in your project’s urls.py file:
# myproject/urls.py
from django.contrib import admin
from django.urls import include, path
urlpatterns = [
path('myapp/', include('myapp.urls')),
path('admin/', admin.site.urls),
]
Now, when you navigate to http://127.0.0.1:8000/myapp/, you should see the list of posts.
11. Using the Django Admin:
Django provides a built-in admin interface that allows you to manage your data. To register your Post model with the admin, add the following to myapp/admin.py:
from django.contrib import admin
from .models import Post
admin.site.register(Post)
Create a superuser to access the admin interface:
python manage.py createsuperuser
Then, navigate to http://127.0.0.1:8000/admin/ and log in with your superuser credentials. You should be able to create, edit, and delete posts through the admin interface.
This blog post has given you the fundamental knowledge to create and manage Django projects.
From setting up your environment to creating models, views, and templates, you’ve taken the first steps towards building powerful web applications with Django.
Remember that this is just the beginning, and Django offers a vast array of features and capabilities to explore.
Happy coding!
