Django Introduction

What is Django?

Django is a Python framework that makes it easier to create web sites using
Python.

Django takes care of the difficult stuff so that you can concentrate on
building your web applications.

Django emphasizes reusability of components, also referred to as DRY (Don't

Repeat Yourself), and comes with ready-to-use features like login system,
database connection and CRUD operations (Create Read Update Delete).

Django is especially helpful for database driven websites.

How does Django Work?

Django follows the MVT design pattern (Model View Template).

• Model - The data you want to present, usually data from a database.
• View - A request handler that returns the relevant template and content -
based on the request from the user.
• Template - A text file (like an HTML file) containing the layout of the web
page, with logic on how to display the data.
Model

The model provides data from the database.

In Django, the data is delivered as an Object Relational Mapping (ORM),

which is a technique designed to make it easier to work with databases.

The most common way to extract data from a database is SQL. One problem
with SQL is that you have to have a pretty good understanding of the
database structure to be able to work with it.

Django, with ORM, makes it easier to communicate with the database,

without having to write complex SQL statements.

The models are usually located in a file called models.py.

View

A view is a function or method that takes http requests as arguments,

imports the relevant model(s), and finds out what data to send to the
template, and returns the final result.

The views are usually located in a file called views.py.

Template

A template is a file where you describe how the result should be

represented.

Templates are often .html files, with HTML code describing the layout of a
web page, but it can also be in other file formats to present other results,
but we will concentrate on .html files.

Django uses standard HTML to describe the layout, but uses Django tags to
add logic:

The templates of an application is located in a folder named templates.

URLs

Django also provides a way to navigate around the different pages in a

website.
When a user requests a URL, Django decides which view it will send it to.

This is done in a file called urls.py.

So, what is going On?

When you have installed Django and created your first Django web
application, and the browser requests the URL, this is basically what
happens:

1. Django receives the URL, checks the urls.py file, and calls the view that
matches the URL.
2. The view, located in views.py, checks for relevant models.
3. The models are imported from the models.py file.
4. The view then sends the data to a specified template in
the template folder.
5. The template contains HTML and Django tags, and with the data it returns
finished HTML content back to the browser.
 Django Getting Started
Django Requires Python: To check if your system has Python installed, run this
command in the command prompt or windows powershell:

python --version

If Python is installed, you will get a result with the version number, like this

Python 3.9.2

If you find that you do not have Python installed on your computer, then you
can download it for free from the following website: https://www.python.org/

PIP

To install Django, you must use a package manager like PIP, which is included
in Python from version 3.4.

To check if your system has PIP installed, run this command in the command
prompt:

pip --version

If PIP is installed, you will get a result with the version number.

On a windows machine, the result looks like this:

pip 20.2.3

If you do not have PIP installed, you can download and install it from this
page: https://pypi.org/project/pip/

Virtual Environment
It is suggested to have a dedicated virtual environment for each Django project,
and one way to manage a virtual environment is venv, which is included in
Python.

The name of the virtual environment is your choice, in this course we will call
it myworld.

Type the following in the command prompt, remember to navigate to where you
want to create your project:

py -m venv myworld
This will set up a virtual environment, and create a folder named "myworld"
with subfolders and files, like this:

myworld
Include
Lib
Scripts
pyvenv.cfg

Then you have to activate the environment, by typing this command:

myworld\Scripts\activate.bat

Once the environment is activated, you will see this result in the command
prompt:

(myworld) C:\Users\Your name>

Note: You must activate the virtual environment every time you open the
command prompt to work on your project.

Install Django
Now, that we have created a virtual environment, we are ready to install
Django.

Note: Remember to install Django while you are in the virtual environment!

Django is installed using pip, with this command:

(myworld) C:\Users\Your Name>py -m pip install Django

Which will give a result that looks like this:

Collecting Django
Downloading Django-4.0.3-py3-none-any.whl (8.0 MB)
|████████████████████████████████| 8.0 MB 2.2 MB/s
Collecting sqlparse>=0.2.2
Using cached sqlparse-0.4.2-py3-none-any.whl (42 kB)
Collecting asgiref<4,>=3.4.1
Downloading asgiref-3.5.0-py3-none-any.whl (22 kB)
Collecting tzdata; sys_platform == "win32"
Downloading tzdata-2021.5-py2.py3-none-any.whl (339 kB)
|████████████████████████████████| 339 kB 6.4 MB/s
Installing collected packages: sqlparse, asgiref, tzdata, Django
Successfully installed Django-4.0.3 asgiref-3.5.0 sqlparse-0.4.2 tzdata-
2021.5
WARNING: You are using pip version 20.2.3; however, version 22.3 is
available.
You should consider upgrading via the 'C:\Users\Your
Name\myworld\Scripts\python.exe -m pip install --upgrade pip' command.

That's it! Now you have installed Django in your new project, running in a
virtual environment!

Check Django Version

You can check if Django is installed by asking for its version number like this:

(myworld) C:\Users\Your Name>django-admin --version

If Django is installed, you will get a result with the version number:

4.1.2
 Django Create Project

My First Project
Once you have come up with a suitable name for your Django project, like
mine: my_tennis_club, navigate to where in the file system you want to store
the code (in the virtual environment), I will navigate to the myworld folder, and
run this command in the command prompt:

(myworld) C:\Users\Your Name>Django-admin startproject my_tennis_club

Django creates a my_tennis_club folder on my computer, with this content:

my_tennis_club
manage.py
my_tennis_club/
__init__.py
asgi.py
settings.py
urls.py
wsgi.py

Run the Django Project

Now that you have a Django project, you can run it, and see what it looks like
in a browser.

Navigate to the /my_tennis_club folder and execute this command in the

command prompt:

(myworld) C:\Users\Your Name>cd my_tennis_club

py manage.py runserver

Which will produce this result:

Watching for file changes with StatReloader

Performing system checks...

System check identified no issues (0 silenced).

You have 18 unapplied migration(s). Your project may not work properly
until you apply the migrations for app(s): admin, auth, contenttypes,
sessions.
Run 'python manage.py migrate' to apply them.
October 27, 2022 - 13:03:14
Django version 4.1.2, using settings 'my_tennis_club.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.

Open a new browser window and type 127.0.0.1:8000 in the address bar.

Django Create App

What is an App?

An app is a web application that has a specific meaning in your project, like a
home page, a contact form, or a members database.

In this tutorial we will create an app that allows us to list and register members
in a database.

But first, let's just create a simple Django app that displays "Hello World!".

Create App

I will name my app members.

Start by navigating to the selected location where you want to store the app, in
my case the my_tennis_club folder, and run the command below.

If the server is still running, and you are not able to write commands, press
[CTRL] [BREAK], or [CTRL] [C] to stop the server and you should be back in the
virtual environment.

py manage.py startapp members

Django creates a folder named members in my project, with this content:

my_tennis_club
manage.py
my_tennis_club/
members/
migrations/
__init__.py
__init__.py
admin.py
apps.py
models.py
 tests.py
views.py

These are all files and folders with a specific meaning. You will learn about most
of them later in this course.

First, take a look at the file called views.py.

This is where we gather the information, we need to send back a proper

response.

Views

Django views are Python functions that takes http requests and returns http
response, like HTML documents.

A web page that uses Django is full of views with different tasks and missions.

Views are usually put in a file called views.py located on your app's folder.

There is a views.py in your members folder that looks like this:

my_tennis_club/members/views.py:

from django.shortcuts import render

# Create your views here.

Find it and open it, and replace the content with this:

my_tennis_club/members/views.py:

from django.shortcuts import render

from django.http import HttpResponse

def members(request):

return HttpResponse("Hello world!")

Note: The name of the view does not have to be the same as the application.

I call it members because I think it fits well in this context.

 Django URLs
URLs

Create a file named urls.py in the same folder as the views.py file, and type
this code in it:

my_tennis_club/members/urls.py:

from django.urls import path

from. import views

urlpatterns = [

path('members/', views.members, name='members'),

The urls.py file you just created is specific for the members application. We have
to do some routing in the root directory my_tennis_club as well. This may seem
complicated, but for now, just follow the instructions below.

There is a file called urls.py on the my_tennis_club folder, open that file and add
the include module in the import statement, and also add a path() function in
the urlpatterns[] list, with arguments that will route users that comes in
via 127.0.0.1:8000/.

Then your file will look like this:

my_tennis_club/my_tennis_club/urls.py:

from django.contrib import admin

from django.urls import include, path

urlpatterns = [

path('', include('members.urls')),

path('admin/', admin.site.urls),

]
If the server is not running, navigate to the /my_tennis_club folder and execute
this command in the command prompt:

py manage.py runserver

In the browser window, type 127.0.0.1:8000/members/ in the address bar.

Django Templates
Templates

In the Django Intro page, we learned that the result should be in HTML, and it
should be created in a template, so let's do that.

Create a templates folder inside the members folder, and create a HTML file
named myfirst.html.

The file structure should be like this:

my_tennis_club
manage.py
my_tennis_club/
members/
templates/
myfirst.html

Open the HTML file and insert the following:

my_tennis_club/members/templates/myfirst.html:

<!DOCTYPE html>

<html>

<body>

<h1>Hello World!</h1>

<p>Welcome to my first Django project!</p>

</body>
</html>

Modify the View

Open the views.py file and replace the members view with this:

my_tennis_club/members/views.py:

from django.http import HttpResponse

from django.template import loader

def members(request):

template = loader.get_template('myfirst.html')

return HttpResponse(template.render())

Change Settings

To be able to work with more complicated stuff than "Hello World!", We have to
tell Django that a new app is created.

This is done in the settings.py file in the my_tennis_club folder.

Look up the INSTALLED_APPS[] list and add the members app like this:

my_tennis_club/my_tennis_club/settings.py:

INSTALLED_APPS = [

'django.contrib.admin',

'django.contrib.auth',

'django.contrib.contenttypes',

'django.contrib.sessions',

'django.contrib.messages',
 'django.contrib.staticfiles',

'members'

Then run this command:

py manage.py migrate

Which will produce this output:

Operations to perform:
Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
Applying contenttypes.0001_initial... OK
Applying auth.0001_initial... OK
Applying admin.0001_initial... OK
Applying admin.0002_logentry_remove_auto_add... OK
Applying admin.0003_logentry_add_action_flag_choices... OK
Applying contenttypes.0002_remove_content_type_name... OK
Applying auth.0002_alter_permission_name_max_length... OK
Applying auth.0003_alter_user_email_max_length... OK
Applying auth.0004_alter_user_username_opts... OK
Applying auth.0005_alter_user_last_login_null... OK
Applying auth.0006_require_contenttypes_0002... OK
Applying auth.0007_alter_validators_add_error_messages... OK
Applying auth.0008_alter_user_username_max_length... OK
Applying auth.0009_alter_user_last_name_max_length... OK
Applying auth.0010_alter_group_name_max_length... OK
Applying auth.0011_update_proxy_permissions... OK
Applying auth.0012_alter_user_first_name_max_length... OK
Applying sessions.0001_initial... OK

(myworld) C:\Users\Your Name\myworld\my_tennis_club>

Start the server by navigating to the /my_tennis_club folder and execute this
command:

py manage.py runserver

In the browser window, type 127.0.0.1:8000/members/ in the address bar.

 Django Models
A Django model is a table in your database.

Django Models

Up until now in this tutorial, output has been static data from Python or HTML
templates.

Now we will see how Django allows us to work with data, without having to
change or upload files in the process.

In Django, data is created in objects, called Models, and is actually tables in a

database.

Create Table (Model)

To create a model, navigate to the models.py file in the /members/ folder.

Open it, and add a Member table by creating a Member class, and describe the
table fields in it:

my_tennis_club/members/models.py:

from django.db import models

class Member(models.Model):

firstname = models.CharField(max_length=255)

lastname = models.CharField(max_length=255)

The first field, firstname, is a Text field, and will contain the first name of the
members.

The second field, lastname, is also a Text field, with the member's last name.

Both firstname and lastname is set up to have a maximum of 255 characters.

SQLite Database

When we created the Django project, we got an empty SQLite database.

It was created in the my_tennis_club root folder, and has the

filename db.sqlite3.

By default, all Models created in the Django project will be created as tables in
this database.

Migrate

Now when we have described a Model in the models.py file, we must run a
command to actually create the table in the database.

Navigate to the /my_tennis_club/ folder and run this command:

py manage.py makemigrations members

Which will result in this output:

Migrations for 'members':

members\migrations\0001_initial.py
- Create model Member

(myworld) C:\Users\Your Name\myworld\my_tennis_club>

Django creates a file describing the changes and stores the file in
the /migrations/ folder:

my_tennis_club/members/migrations/0001_initial.py:

# Generated by Django 4.1.2 on 2022-10-27 11:14

from django.db import migrations, models

class Migration(migrations.Migration):
 initial = True

dependencies = [

operations = [

migrations.CreateModel(

name='Member',

fields=[

('id', models.BigAutoField(auto_created=True,
primary_key=True, serialize=False, verbose_name='ID')),

('firstname', models.CharField(max_length=255)),

('lastname', models.CharField(max_length=255)),

],

),

Note that Django inserts an id field for your tables, which is an auto increment
number (first record gets the value 1, the second record 2 etc.), this is the
default behavior of Django, you can override it by describing your own id field.

The table is not created yet, you will have to run one more command, then
Django will create and execute an SQL statement, based on the content of the
new file in the /migrations/ folder.

Run the migrate command:

py manage.py migrate

Which will result in this output:

Operations to perform:
Apply all migrations: admin, auth, contenttypes, members, sessions
Running migrations:
Applying members.0001_initial... OK

(myworld) C:\Users\Your Name\myworld\my_tennis_club>

Now you have a Member table in you database!

View SQL

As a side-note: you can view the SQL statement that were executed from the
migration above. All you have to do is to run this command, with the migration
number:

py manage.py sqlmigrate members 0001

Which will result in this output:

BEGIN;
--
-- Create model Member
--
CREATE TABLE "members_member" ("id" integer NOT NULL PRIMARY KEY
AUTOINCREMENT, "firstname" varchar(255) NOT NULL, "lastname" varchar(255)
NOT NULL); COMMIT;