Django – The Origins

Django is a high-level Python web framework that encourages rapid development and clean, pragmatic design. It’s open source and allows you to create web applications quickly and easily. One of the most powerful features of Django is its ability to generate dynamic web pages using templates, which can be customized to suit the needs of your application.

In this tutorial, we will go over the basics of Django and show you how to create a simple web application with Django. We will walk you through the process of setting up your Django project, creating a database, defining models, setting up URLs, and creating templates. By the end of this tutorial, you should have a good understanding of how Django works and be able to create your own web applications.

Genèse is a French word that means "genesis" or "beginning". In the context of Django, Genèse refers to the initial setup and configuration of a Django project. It’s the first step in creating a web application with Django and involves creating the necessary files and folders, setting up a database, defining models, and configuring the project settings.

To get started with Genèse, you will need to have Python installed on your system. You can download Python from the official website and follow the installation instructions. Once Python is installed, you can install Django using the following command:

pip install django

After Django is installed, you can create a new Django project by running the following command in your terminal:

django-admin startproject myproject

This will create a new folder called myproject with the following files and folders inside:

myproject/
    manage.py
    myproject/
        __init__.py
        settings.py
        urls.py
        wsgi.py

• manage.py: A command-line utility that allows you to interact with your Django project, such as running development servers, creating superusers, and running database migrations.
• myproject/: The main project folder that contains the settings for your Django project.
• myproject/__init__.py: An empty file that tells Python that this directory should be considered a Python package.
• myproject/settings.py: A file that contains the settings for your Django project, such as database configuration, static files configuration, and installed apps.
• myproject/urls.py: A file that contains the URL patterns for your Django project.
• myproject/wsgi.py: A file that contains the WSGI application object for your Django project.

Next, you will need to create a new app within your Django project. An app is a web application that performs a specific function, such as handling user authentication or displaying blog posts. To create a new app, run the following command in your terminal:

python manage.py startapp myapp

This will create a new folder called myapp within your Django project with the following files and folders inside:

myapp/
    migrations/
        __init__.py
    __init__.py
    admin.py
    apps.py
    models.py
    tests.py
    views.py

• migrations/: A folder that contains database migration files generated by Django when you make changes to your models.
• myapp/__init__.py: An empty file that tells Python that this directory should be considered a Python package.
• myapp/admin.py: A file that contains the configuration for the Django admin interface for your app.
• myapp/apps.py: A file that contains the configuration for your app.
• myapp/models.py: A file that defines the models for your app.
• myapp/tests.py: A file that contains tests for your app.
• myapp/views.py: A file that contains the views for your app.

Now that you have created a new app within your Django project, you can define your models. Models are Python classes that define the structure of your database tables. Each model class represents a table in your database and each attribute of the model class represents a column in the table.

For example, let’s say you want to create a simple blog application with Django. You could define a Post model in your models.py file like this:

from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

In this example, we define a Post model with three attributes: title, content, and created_at. The title attribute is a CharField with a maximum length of 100 characters, the content attribute is a TextField, and the created_at attribute is a DateTimeField that automatically sets the created_at field to the current date and time when a new Post object is created.

After defining your models, you will need to run the following command to create the database tables for your models:

python manage.py makemigrations
python manage.py migrate

The makemigrations command generates migration files based on the changes you have made to your models, and the migrate command applies those migration files to create the database tables.

Next, you will need to define URLs for your app in the urls.py file within your app folder. URL patterns map URLs to views in your Django project, allowing you to define how different URLs are handled by your app.

For example, you could define a URL pattern for a list of posts in your urls.py file like this:

from django.urls import path
from . import views

urlpatterns = [
    path('posts/', views.post_list, name='post_list'),
]

In this example, we define a URL pattern for the /posts/ URL, which will be handled by the post_list function in the views.py file in the same folder.

Finally, you will need to create templates for your app. Templates are HTML files that define the structure of the web pages in your Django project. You can use template tags and filters in your templates to display dynamic content, such as data from your models.

For example, you could create a post_list.html template in a templates folder within your app folder like this:

<!DOCTYPE html>
<html>
<head>
    <title>Post List</title>
</head>
<body>
    <h1>Post List</h1>
    <ul>
        {% for post in posts %}
            <li>{{ post.title }}</li>
        {% endfor %}
    </ul>
</body>
</html>

In this example, we define a simple HTML template that lists the titles of all posts in a <ul> element. We use a {% for %} loop to iterate over all posts in the posts variable, which will be passed to the template by the view.

To display this template in your app, you will need to create a view in your views.py file that renders the template and passes data to it. For example, you could define a post_list view like this:

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})

In this example, we define a post_list view that gets all Post objects from the database using Post.objects.all() and passes them to the post_list.html template.

Finally, you will need to add your app to the INSTALLED_APPS setting in the settings.py file in your Django project folder:

INSTALLED_APPS = [
    ...
    'myapp',
]

This tells Django to include your app in the list of installed apps and allows Django to find and use your app’s files and folders.

And that’s it! You have now set up a basic Django project with Genèse and created a simple web application with models, views, templates, and URLs. You can now run the development server using the following command:

python manage.py runserver

And visit http://127.0.0.1:8000/posts/ in your web browser to see the list of posts in your blog application.

I hope this tutorial has helped you understand the basics of Django and how to create a web application with Django using Genèse. If you have any questions or need further assistance, please feel free to ask. Thank you for reading!