Web frameworks django
Download
1 / 93

Web Frameworks: Django - PowerPoint PPT Presentation


  • 112 Views
  • Uploaded on

Web Frameworks: Django. Department of Biomedical Informatics University of Pittsburgh School of Medicine http://www.dbmi.pitt.edu. The Purpose of the Lecture. Introduce the basic steps for web programming using Django.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Web Frameworks: Django' - tameka


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Web frameworks django

Web Frameworks: Django

Department of Biomedical Informatics

University of Pittsburgh School of Medicine

http://www.dbmi.pitt.edu


The purpose of the lecture
The Purpose of the Lecture

Introduce the basic steps for web programming using Django.

This is done by walking you though the steps that takes to create an web blog: “jiangblog”

“jiangblog” is designed to allow a user to make comments online about some topics such as a presidential debate, and save these comments in a database.



Download and install django
Download and Install Django django!

  • Download Django 1.4.2 from the following website:

    https://www.djangoproject.com/download/.

    2. Install Django:

    tar xzvf Django-1.4.2.tar.gz

    cd Django-1.4.2

    sudo python setup.py install


Create a django project
Create a Django Project django!

Django provides a utility called django-admin.py that can streamline the tasks for you when you create a django project. (Note that I use red color for the terminal output.)

xjiang-lp:django xij6$ django-admin.py startproject jiangblog

xjiang-lp:django xij6$ ls -l

total 0

drwxr-xr-x 4 xij6 PITT\domain users 136 Nov 8 11:28 jiangblog

drwxr-xr-x 7 xij6 PITT\domain users 238 Nov 8 11:05 mysite


Check what have been created in jiangblog
Check What have been Created in jiangblog django!

xjiang-lp:django xij6$ cd jiangblog

xjiang-lp:jiangblog xij6$ ls -l

total 8

drwxr-xr-x 6 xij6 PITT\domain users 204 Nov 8 11:28 jiangblog

-rwxr-xr-x 1 xij6 PITT\domain users 252 Nov 8 11:28 manage.py

xjiang-lp:jiangblog xij6$


Check what have been created in jiangblog1
Check What have been Created in jiangblog django!

xjiang-lp:jiangblog xij6$ ls -l jiangblog

total 32

-rw-r--r-- 1 xij6 PITT\domain users 0 Nov 8 11:28 __init__.py

-rw-r--r-- 1 xij6 PITT\domain users 5221 Nov 8 11:28 settings.py

-rw-r--r-- 1 xij6 PITT\domain users 565 Nov 8 11:28 urls.py

-rw-r--r-- 1 xij6 PITT\domain users 1140 Nov 8 11:28 wsgi.py


The files created by django admin py startproject
The Files Created by Django-Admin.py startproject django!

manage.py: Command-line interface for applications.

__init__.py: Specifies to Python that this is a package.

urls.py: Global URL configuration (“URLconf”).

settings.py: Project-specific configuration

wsgi.py: ???


The pure python philosophy
The django!“pure Python” philosophy

Note that every file created by the startproject command is Python code with an extension .py

Django tries to stay with Python code wherever possible. This certainly reduces the complexity to the framework for a python programmer.


Running the development server
Running the Development Server django!

The development server is a server designed for the development phase that runs on your local computer.

xjiang-lp:jiangblog xij6$ python ./manage.py runserver

Validating models…

0 errors found

Django version 1.4.2, using settings 'jiangblog.settings'

Development server is running at http://127.0.0.1:8000/

Quit the server with CONTROL-C.

Error: [Errno 48] Address already in use


Running the development server1
Running the Development Server django!

Note that if you want to run your server on a different port, you can specify that on the command line:

python ./manage.pyrunserver


xjiang-lp:jiangblog django! xij6$ ./manage.pyrunserver 8080

Validating models...

0 errors found

Django version 1.4.2, using settings 'jiangblog.settings'

Development server is running at http://127.0.0.1:8080/

Quit the server with CONTROL-C.


DBMIAdmins-MacBook-Pro:jiangblog django! xij6$ ./manage.pystartapppresdebate

DBMIAdmins-MacBook-Pro:jiangblog xij6$ ls -l

total 8

drwxr-xr-x 10 xij6 PITT\domain users 340 Nov 8 12:32 jiangblog

-rwxr-xr-x 1 xij6 PITT\domain users 252 Nov 8 11:28 manage.py

drwxr-xr-x 6 xij6 PITT\domain users 204 Nov 8 13:33 presdebate

DBMIAdmins-MacBook-Pro:jiangblog xij6$


Create an application within a project
Create an Application within a Project django!

We want to create an application named as “presdebate”, which can be used to collect comments from web users about a presidential debate.

./manage.py startapp presdebate


Again, we want to know what files have been created for our application.

DBMIAdmins-MacBook-Pro:jiangblog xij6$ ls -l presdebate

total 24

-rw-r--r-- 1 xij6 PITT\domain users 0 Nov 8 13:33 __init__.py

-rw-r--r-- 1 xij6 PITT\domain users 57 Nov 8 13:33 models.py

-rw-r--r-- 1 xij6 PITT\domain users 383 Nov 8 13:33 tests.py

-rw-r--r-- 1 xij6 PITT\domain users 26 Nov 8 13:33 views.py

DBMIAdmins-MacBook-Pro:jiangblog xij6$


The files created for our application presdebate
The Files Created for our Application “presdebate” application.

__init__.py: Specifies to Python that this is a package

models.py: Data models

views.py: view functions

tests.py: unit tests

What is missing?

urls.py: The app’s URL configuration (“URLconf”). This is not automatically created.


To inform Django that the new app application.“presdebate” is part of our project, we need to edit settings.py.

We need to open the settings.py with an editor and find the INSTALLED_APPS tuple near the bottom, then add our application name (presdebate) as a member of that tuple.

In Mac I typically use either textmate or coda2 to do the editing work.



Creating a data model
Creating a Data Model application.

We need to create a data model via editing the file called models.py, which is automatically generated for application presdebate.

This data model defines the data structures of presdebate.

Django provides a variety of fields that map to our application data.

In application presdebate, we will use three different field types.




The newly created class, application.PresDebate, is a subclass of django.db.models.Model.

That’s Django standard base class for data models, which is the core of Django’s powerful ORM.

The fields are defined like regular class attributes, with each one being an instance of a particular field class.


A application.CharField is appropriate for short, single lines of text.

A TextField type is good for a large chunk of text, such as a large paragraph of comments we may collect from a user.

A DateTimeField is represented by a Python datetime.datetime object.

For a list of field types provided by Django, refer to the documentation at:

https://docs.djangoproject.com/en/dev/ref/models/fields/#field-types


Setting up the database
Setting Up the Database application.

Using SQLite with the local host, you only need to do two things:

  • Update the engine.

  • Specify the name (use full pathname to avoid confusion) of the database that will be created in the settings.py file.


Databases entry in settings py before editing
DATABASES application. entry in settings.py before editing


Databases entry in settings py after editing
application.DATABASES”entry in settings.py after editing


Setting up the database1
Setting Up the Database application.

Now we need to tell Django to use the information (the pathname of our database) you’ve given it to connect to the database and set up tables that our application needs.

We use the syncdb command of manage.py to do this.


Setting up the database2
Setting Up the Database application.

When the syncdb command is issued, Django looks for a models.py file in each of the INSTALLED_APPS entry.

For each model it finds, it creates a database table.

Adding a super user is useful, especially when we add the Django’s automatic admin application later.


Creating the predebate s user interface
Creating the application.predebate’s User Interface

With Django, a Web page has the following typical components:

  • A template that defines how it looks, and displays information passed to it.

    2. A view function that performs the core logic for a request, fetch the information to be displayed from a database, and store new information entered by a users to the database.


Creating the predebate s user interface1
Creating the Predebate’s User Interface application.

3. A URL pattern that matches an incoming request with the corresponding view.

We will build our application according to the following order:

  • Build a template.

  • Design an Url Pattern.

  • Develop the view function.


Creating a django template
Creating a Django Template application.

We will introduce two constructs of django’s templating language:

  • A variable tag that is delimited by pairs of curly braces: {{ … }}.

    A variable tag displays the contents of the object within the braces, which can be pure data or callables.

    Inside a variable tag, you can use Python-style dot-notation to access attributes of the tag variables.


Creating a django template1
Creating a Django Template application.

  • A block tag that is delimited by curly braces and percent symbols : {% … %}.

    A block tag is used to embed logic such as loops and conditions into a django html template.


A preliminary template created for presdebate application
A Preliminary Template Created for application.presdebate Application


Creating a django template2
Creating a Django Template application.

Save the HTML template code shown in the previous slide into a directory called templates inside the application folder, which we need to create.

So the path to the template we just created is:

/users/xij6/django/jiangblog/presdebate/templates/mytemplate.html

Note that the name of the template is arbitrary, but the name of the templates directory is mandatory.


Creating a url pattern
Creating a URL Pattern application.

The pathnames of an URL in a users’ browsers are mapped to various parts of an applicaton.

The IP address will be mapped to an Internet host (server), and the port number will be mapped to a port on the server.

Once the message arrives at the Internet host, the serve will match the remainder of the URL to the corresponding project. Then the remainder of the URL (with the project name excluded) will be passed to the project url configuration file.


Creating a url pattern1
Creating a URL Pattern application.

In our case in which we use a local host as the server, the type of request and the remainder of the URL (with the IP and port number excluded) will be passed to a django project URLconf (jiangblog/urls.py).

We therefore need to edit the URLconf so that when a valid pattern (regular expression) matches to the remainder of the URL received, the request will be further passed to the next receiver, which is the application URLconf we shell create later.




Creating a url pattern2
Creating a URL Pattern application.

The patterns() function takes as input a tuple (URL regular expression, destination).

The destination is either a view function that is called for URLs that match the pattern, or it’s a call to another URLconf file via include() function.

When include() is used, the current URL path head is removed and the remainder of the path is passed to the another URLconf file.


Creating a url pattern3
Creating a URL Pattern application.

For example, for http://localhost:8080/presdebate/xxx/yyy/zzz, the xxx/yyy/zzz will be passed to presdebate/urls.py as specified by include (“presdebate.urls”), by excluding the matching regex presdebate/


Creating a url pattern4
Creating a URL Pattern application.

The added line in the urlpattens entry of the project URLconf says that we are catching requests that begin with presdebate/ and passing them on to the presdebate/urls.py.

Recall that the presdebatedoes not contain a urls.py, thus we need to create this file from scratch.


Presdebate urls py
presdebate/urls.py application.


Creating a view function create a fake view first
Creating a View Function-Create a Fake View First application.

The purpose of creating a fake view is to test quickly whether we’ve done so fast are correct.

To do this, we need to edit the jiangblog/presdebate/view.py file.




Creating our real view function
Creating Our Real View Function application.

Now we will create a view function that will fetch all of the comments stored in the database (mydb.db)and display them to users via our template.


Jiangblog presdebate view py after editing1
jiangblog/presdebate/view.py application.after editing


Creating our real view function1
Creating Our Real View Function application.

If there is no records in mydb.db, we will receive an error. Thus, we need to initialize the mydb.db.

This can be done in several ways. One way is to add a review function in the view.py file called initializingdb()


Jiangblog presdebate view py after editing2
jiangblog/presdebate/view.py application.after editing


Working with user input
Working with User Input application.

Major Steps:

  • Adding an HTML form to our template.

  • Editing the application URLconf.

  • Adding a new view function that processes user input.




Cross site request forgery
Cross-Site Request Forgery application.

Django comes with a data-preserving feature that disallows POSTs which are not secure against cross-site request forgery (CSRF) attacks.

You can read more about CSRF at the following website:

https://docs.djangoproject.com/en/dev/ref/contrib/csrf/


Cross site request forgery1
Cross-Site Request Forgery application.

For our simple application, two fixes:

1. Add a CSFR token ({% csrf_token %} to forms that POST back to your site

2. Send the request context instance to the token via the template.






Trying out the django admin
Trying Out the Django Admin application.

Django provides a automatic back-end administration application, or Admin for short.

Why do we need the Admin?

1. Testing during the development stage, even before the UI has been developed.

2. Manage the site easily.


Steps to set up the admin for a django project
Steps to Set up the Admin for a Django Project application.

1. Update the settings.py. Note that the Admin is also an application.

2. Run syncdb.

3. Editing the project URLconf file.

4. Register the PresDebate model with Admin.



Run syncdb
Run application.syncdb




Register the presdebate model with the admin
Register the PresDebate Model with the Admin application.

We need to inform Django which models should show up for editing in the Admin screens.

To do this, we will create a file named as admin.py in the presdebate directory.


Admin py
Admin.py application.




Editing admin py to fix the display issue
Editing Admin.py to Fix the application.“Display Issue”


Using python shell with django application
Using Python Shell with Django Application application.

1. Run ./manage.py shell

This will bring up Ipython, which can be downloaded at: http://ipython.org/download.html

2. Run ./manage.py shell --plain

This will bring up python.


ad