Introduction of Django

Django is a back-end server side web framework.

Django is free, open source and written in Python.

Django makes it easier to build web pages using Python.

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:

<h1>My Homepage</h1>

<p>My name is {{ firstname }}.</p>

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.

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

Django receives the URL, checks the urls.py file, and calls the
view that matches the URL.

 The view, located in views.py, checks for relevant models.

 The models are imported from the models.py file.
 The view then sends the data to a specified template in the
template folder.
 The template contains HTML and Django tags, and with the
data it returns finished HTML content back to the browser.
Django History

Django was invented by Lawrence Journal-World in 2003, to

meet the short deadlines in the newspaper and at the same
time meeting the demands of experienced web developers.

Initial release to the public was in July 2005.

Latest version of Django is 4.0.3 (March 2022).

To install Django, you must have Python installed, and a package manager like
PIP.

PIP is included in Python from version 3.4.

Django Requires Python

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

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.

For me, on a windows machine, the result looks like this:

pip 20.2.3 from c:\python39\lib\site-packages\pip (python 3.9)

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.

With venv, you can create a virtual environment by typing this in the command prompt,
remember to navigate to where you want to create your project:

Windows:

py -m venv myproject
Unix/MacOS:

python -m venv myproject

This will set up a virtual environment, and create a folder named "myproject" with
subfolders and files, like this:

myproject
Include
Lib
Scripts
pyvenv.cfg
Then you have to activate the environment, by typing this command:
Windows:

myproject\Scripts\activate.bat
Unix/MacOS:

source myproject/bin/activate
Once the environment is activated, you will see this result in the command
prompt:

Windows:

(myproject) C:\Users\Your Name>

Unix/MacOS:

(myproject) ... $
Install Django
Finally, we can install Django.

Remember to install Django while you are in the virtual

environment!

Django is installed using pip, with this command:

Windows:

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

Unix/MacOS:

(myproject) ... $ python -m pip install Django

Check Django Version

You can check if Django is installed by asking for its version

number like this:

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

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

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

django-admin startproject myworld

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

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

These are all files and folders with a specific meaning, it is more important to
know that this is the location of your project, and that you can start building
applications in it.
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 /myworld folder and execute this command in the command prompt:

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.
December 02, 2021 - 13:14:51
Django version 3.2.9, using settings 'myworld.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.

The result:
Django Create App

Create App
I will name my app members.

Start by navigating to the selected location where you want to store

the app, and run the command below.

If the server is still running, and you are not able to write commands,
press [CTRL] [BREAK] 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:
myworld
manage.py
myworld/
members/
migrations/
__init__.py
__init__.py
admin.py
apps.py
models.py
tests.py
views.py
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:

members/views.py:

from django.shortcuts import render

# Create your views here.

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

members/views.py:

from django.shortcuts import render

from django.http import HttpResponse

def index(request):
return HttpResponse("Hello world!")
URLs
Create a file named urls.py in the same folder as the
views.py file, and type this code in it:

members/urls.py:

from django.urls import path

from . import views

urlpatterns = [
path('', views.index, name='index'),
]
The urls.py file you just created is specific for the members
application. We have to do some routing in the root
directory myworld as well.
There is a file called urls.py on the myworld 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/members/.

Then your file will look like this:

myworld/urls.py:

from django.contrib import admin

from django.urls import include, path

urlpatterns = [
path('members/', include('members.urls')),
path('admin/', admin.site.urls),
]
In the browser window, type 127.0.0.1:8000/members/ in the address bar.
Create a templates folder inside the members folder, and create a
HTML file named myfirst.html.

The file structure should be something like this:

myworld
manage.py
myworld/
members/
templates/
myfirst.html
Open the HTML file and insert the following:

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 index view with this:

members/views.py:

from django.http import HttpResponse

from django.template import loader

def index(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 myworld folder.

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

myworld/settings.py:

INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'members.apps.MembersConfig'
]
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
(myproject)C:\Users\Your Name\myproject\myworld>
Start the server by navigating to the /myworld folder and execute this command:

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

The result should look like this:

A Django model is a table in your database.

SQLite Database
When we created the Django project, we got an empty SQLite database. It was
created in the myworld root folder.

We will use this database in this tutorial.

Create Table (Model)

To create a new table, we must create a new model.

In the /members/ folder, open the models.py file. It is almost empty by default,
with only an import statement and a comment:

members/models.py:

from django.db import models

# Create your models here.

To add a Members table in our database, start by creating a Members
class, and describe the table fields in it:

members/models.py:

from django.db import models

class Members(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 members' last
name.

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

characters.
Then navigate to the /myworld/ 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 Members

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

Django creates a file with any new changes and stores the file in the /migrations/
folder.

Next time you run py manage.py migrate 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

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

The SQL statement created from the model is:

CREATE TABLE "members_members" (

"id" INT NOT NULL PRIMARY KEY AUTOINCREMENT,
"firstname" varchar(255) NOT NULL,
"lastname" varchar(255) NOT NULL);
Now you have a Members table in you database!
Add Records
The Members table is empty, we should add some members to it.
To open a Python shell, type this command:

py manage.py shell

Add a record to the table, by executing these two lines:

>>> member = Members(firstname='Emil', lastname='Refsnes')

>>> member.save()
Execute this command to see if the Members table got a member:

>>> Members.objects.all().values()
Hopefully, the result will look like this:

<QuerySet [{'id': 1, 'firstname': 'Emil', 'lastname': 'Refsnes'}]>

Add Multiple Records
You can add multiple records by making a list of Members objects, and
execute .save() on each entry:

>>> member1 = Members(firstname='Tobias', lastname='Refsnes')

>>> member2 = Members(firstname='Linus', lastname='Refsnes')
>>> member3 = Members(firstname='Lene', lastname='Refsnes')
>>> member4 = Members(firstname='Stale', lastname='Refsnes')
>>> members_list = [member1, member2, member3, member4]
>>> for x in members_list:
>>> x.save()
Modify the View
Change the index view to include the template:

members/views.py:

from django.http import HttpResponse

from django.template import loader
from .models import Members

def index(request):
mymembers = Members.objects.all().values()
template = loader.get_template('index.html')
context = {
'mymembers': mymembers,
}
return HttpResponse(template.render(context, request))
Add a new template in the templates folder, named add.html:

members/templates/add.html:

<h1>Add member</h1>

<form action="addrecord/" method="post">

{% csrf_token %}
First Name:<br>
<input name="first">
<br><br>
Last Name:<br>
<input name="last">
<br><br>
<input type="submit" value="Submit">
</form>
Add a "delete" column in the members template:

members/templates/index.html:

<h1>Members</h1>

<table border="1">
{% for x in mymembers %}
<tr>
<td>{{ x.id }}</td>
<td>{{ x.firstname }}</td>
<td>{{ x.lastname }}</td>
<td><a href="delete/{{ x.id }}">delete</a></td>
</tr>
{% endfor %}
</table>

<p>
<a href="add/">Add member</a>
</p>