Django - Level One

Getting Started with Django!

 Django

● We’ve finally reached the moment we’ve been

waiting for - Django!
● Before we dive into the technical details of Django,
let’s learn a little more about it and it's interesting
background!
 Django

● Django is a free and open source web framework.

● It is used by many sites, including Pinterest, PBS,
Instagram, BitBucket, Washington Times, Mozilla,
and more!
 Django

● Django was created in 2003 when the web

developers at the Lawrence Journal-World
newspaper started using Python for their
development.
● The fact that is originated at a newspaper is
important!
 Django

● Because the original developers were surrounded

by writers, good written documentation is a key
part of Django!
● This means you have excellent references to check
on the official Django docs!
 Django

● Django has its own excellent basic tutorial where

you are walked through creating a basic polling
web app.
● The reason it is a poll also extends back to its
newspaper roots!
 Django

● When encountering Django tutorials you will often

read that you should create a virtual environment
or an “venv”
● Let’s talk about what this is and how to use it!
 Django

● A virtual environment allows you to have a virtual

installation of Python and packages on your
computer.
● So why would you ever want or need this?
 Django

● Packages change and get updated often!

● There are changes that break backwards
compatibility.
● So what do you do if you want to test out new
features but not break your web app?
 Django

● You create a virtual environment that contains the

newer version of the package.
● Luckily, Anaconda makes this really easy for us!
● A virtual environment handler is included!
 Django

● To use a virtual environment with conda we use

these commands:
○ conda create --name myEnv django
● Here we created an environment called “myEnv”
with the latest version of Django.
 Django

● You can then activate the environment:

○ activate myEnv
● Now, anything installed with pip or conda when this
environment is activated, will only be installed for
this environment.
 Django

● You can then deactivate the environment

○ deactivate myEnv
● Its encouraged to use virtual environments for your
projects to keep them self-contained and not run into
issues when packages update!
 Django
Creating our first django project!
 Django

● You can install Django with

○ conda install django
● Or for normal python distributions:
○ pip install django
 Django

● When you install Django, it actually also installed a

command line tool called:
○ django-admin
● Let’s create our first project. Type:
○ django-admin startproject first_project
 Django

● You will then get something that looks like this:

 Django

● Let’s explain what is going on here!

Django

● __init__.py
○ This is a blank Python script
that due to its special name
let’s Python know that this
directory can be treated as a
package
Django

● settings.py
○ This is where you will store
all your project settings
Django

● urls.py
○ This is a Python script that
will store all the URL
patterns for your project.
Basically the different pages
of your web application.
Django

● wsgi.py
○ This is a Python script that
acts as the Web Server
Gateway Interface. It will
later on help us deploy our
web app to production
Django

● manage.py
○ This is a Python script that
we will use a lot. It will be
associates with many
commands as we build our
web app!
 Django

● Let’s use manage.py now:

○ python manage.py runserver
● You will see a bunch of stuff but at the bottom you
will see something like:
Django version 1.10.5, using settings
'first_project.settings'
Starting development server at
http://127.0.0.1:8000/
 Django

● Copy and paste that url into your browser

○ http://127.0.0.1:8000/
● You should now see your very first web page being
locally hosted on your computer.
● Congratulations!
 Django

● You should have also noticed a warning about

migrations.
● This has to do with databases and how to connect
them to Django
● What is a Migration?
 Django

● A migration allows you to move databases from one

design to another, this is also reversible.
● So you can “migrate” your database
● We will touch back on this later, for now you can
ignore this warning.
 Django

● That was the basics of getting started with Django!

● Up next we will continue by creating a very simple
Hello World Django Application!
 Django
Creating our first django application!
 Django

● So far we have been able to use runserver to test our

installation of Django.
● Now let’s move on to creating our first Django
Application.
● We’ll learn about views and how to use them.
 Django

● Let’s get some terminology straight:

○ A Django Project is a collection of applications
and configurations that when combined together
will make up the full web application (your
complete website running with Django)
 Django

● Let’s get some terminology straight:

○ A Django Application is created to perform a
particular functionality for your entire web
application. For example you could have a
registration app, a polling app, comments app,
etc.
 Django

● These Django Apps can then be plugged into other

Django Projects, so you can reuse them! (Or use
other people’s apps)
● Let’s create a simple application with:
○ python manage.py startapp first_app
 Django

● Let’s quickly discuss all of these files!

Django

● __init__.py
○ This is a blank Python script
that due to its special name
let’s Python know that this
directory can be treated as a
package
Django

● admin.py
○ You can register your models
here which Django will then
use them with Django’s
admin interface.
Django

● apps.py
○ Here you can place
application specific
configurations
Django

● models.py
○ Here you store the
application’s data models
Django

● tests.py
○ Here you can store test
functions to test your code
Django

● views.py
○ This is where you have
functions that handle requests
and return responses
Django

● Migrations folder
○ This directory stores database
specific information as it
relates to the models
 Django

● Now let’s learn the process of creating a view and

mapping it to a URL!
Django - Challenge!
Time to put your skills to the test!
 Django

● We’ve learned enough now that before we continue

to learn about URL mappings, we should challenge
you to make sure you can test your new skills!
 Django

● Complete the following tasks:

○ Create a New Django Project: “ProTwo”
○ Create a New Django App: “AppTwo”
○ Create an Index View that returns:
■ <em>My Second App </em>
○ Link this view to the urls.py file
 Django

● In the next lecture we will go through the steps of

this challenge task!
● Best of luck, you already have all the knowledge
needed to complete this!
 Django - Challenge
Solutions
Let’s go through the solutions together!
Django - Mapping URLS
Let’s quickly cover some more URL mappings!
 Django

● As we continue on through the course we are going

to be dealing with mapping URLs quite a bit!
● There are several ways of doing this, let’s briefly
touch upon another way!
 Django

● We previously showed a very direct mapping from

the views.py to the urls.py
● Now we want to show the ability of using the
include() function from django.conf.urls
 Django

● The include() function allows us to look for a match

with regular expressions and link back to our
application’s own urls.py file.
● We will have to manually add in this urls.py file
 Django

● So we would add the following to the project’s

urls.py
○ from django.conf.urls import include
○ urlpatterns = [ ...
url(r’^first_app/’,include(‘first_app.urls’)), ..
.]
 Django

● This would allow us to look for any url that has the
pattern:
○ www.domainname.com/first_app/…
● If we match that pattern, the include() function
basically tells Django to go look at the urls.py file
inside of first_app folder
 Django

● This might seem like a lot of work for a simple

mapping, but later on we will want to try to keep our
project’s urls.py clean and modular
● So we set the reference to the app, instead of listing
them all in the main urls
 Django

● Let’s quickly walk through an example of all of this

to show how it works!
● Quick note: We’ve covered everything in Part 1 of
Django’s Official Tutorial, so after this lecture you
may want to go visit Part One and browse through
it!
Django - Templates
Let’s learn how to use Templates!
 Django

● Templates are a key part to understanding how

Django really works and interacts with your
website.
● Later on we will learn about how to connect
templates with models so you can display data
created dynamically.
 Django

● For now, let’s focus on the basics of templates and

template tags.
● The template will contain the static parts of an html
page (parts that are always the same)
 Django

● Then there are template tags, which have their own

special syntax.
● This syntax allows you to inject dynamic content
that your Django App’s views will produce,
effecting the final HTML
 Django

● To get started with templates you first need to create

a templates directory and then a subdirectory for
each specific app’s templates.
● It goes inside of your top level directory:
○ first_project/templates/first_app
 Django

● The next step is to let Django know of the templates

by editing the DIR key inside of the TEMPLATES
dictionary in the settings.py file.
● However, there is an issue we have to deal with
before we do this!
 Django

● We want our Django Project to be easily

transferrable from one computer to another, but the
DIR key will require a “hard-coded” path
● How do we resolve this?
 Django

● We can use Python’s os module to dynamically

generate the correct file path strings, regardless of
computer!
● Import os and try out the following:
○ print(__file__)
○ print(os.path.dirname(__file__)
 Django

● We will use this os module to feed the path to the

DIR key inside of the TEMPLATES dictionary.
● Once we’ve done that we can create an html file
called index.html inside of the templates/first_app
directory
 Django

● Inside this HTML file we will insert template tags

(a.k.a Django Template Variable).
● These template variables will allow us to inject
content into the HTML directly from Django!
 Django

● This is now starting to reveal the power of why we

would use a Web Framework
● Django will be able to inject content into the HTML
● Which means we can later on use Python code to
inject content from a database!
 Django

● In order to achieve this, we will use the render()

function and place it into our original index()
function inside of our views.py file.
● Let’s now code through everything we just
discussed!
Django Templates
Challenge !
Test your knowledge of Templates!
 Django

● Templates is a big leap forward for us, so it is a

good time to quickly practice using them!
● We will use your older ProTwo project (recreate it if
you no longer have it)
● Complete the following tasks...
 Django Templates
Challenge - Solutions
Test your knowledge of Templates!
 Django

● Create a templates directory and connect it to the

settings.py file
● Create a new view called help and use url mapping
to render it for any page with the extension /help
● Add template tags to return “Help Page”
 Django

● Best of luck and in the next lecture we will code

through the solution!
Django - Static Files
Learn how to insert static media files.
 Django

● So far we’ve used templates to insert simple text.

● But we don’t always just want text, what about other
types of media, for example, returning a User’s
Photo?
● Let’s discuss static media files!
 Django

● To do this, we will create a new directory inside of

the project called static ( just like we did for
templates)
● Then we will add this directory path to the project’s
settings.py file
● We will also add a STATIC_URL variable
 Django

● Once we’ve done that we need a place to store our

static image files
● We create a directory inside of static called images
● Place a favorite .jpg file inside this images directory
(or just download one)
 Django

● To test that this all worked you can go to:

○ 127.0.0.1:8000/static/images/pict.jpg
● That will confirm that the paths are set up and
connected properly.
● But what we really want to do is set up a template
tag for this!
 Django

● To do this inside an html file, we add in a few

specific tags, at the top:
○ {% load staticfiles %}
● Then we want to insert the image with an HTML
<img src= > style tag using:
○ <img src={%static “images/pic.jpg” %} />
 Django

● Notice how this template tag is a little different in

that it uses
○ {% %}
● instead of
○ {{ }}
 Django

● We will discuss and show these differences more

clearly in future lectures, but for now consider {{ }}
as being used for simple text injection, and we can
use {% %} for more complex injections and logic
 Django

● Now let’s code through an example of serving up a

static image!
● Afterwards we can dive into models and databases!