Purpose:

  • Create a server-client program (is similar to Facebook or Twitter)
  • Composed of several separate but interactive applications, such as accounts, blog posts, etc.

Environment settings

  • Requirements
    • Programming Language: Python
    • Database: sqlite3
    • Operating System: Linux
    • Software Framework: Django

Step 1: Create the project

  1. [root@localhost Python]# django-admin startproject django_project
  2. # django-admin startproject [your desired project name]
  4. # now we have
  5. [root@localhost Python]# tree
  6. .
  7. └── django_project
  8.     ├── django_project
  9.     │   ├── __init__.py
  10.     │   ├── settings.py
  11.     │   ├── urls.py
  12.     │   └── wsgi.py
  13.     └── manage.py
  • setting.py: includes setting variable of the project, such as INSTALLED_APPS, TEMPLATES.
  • urls.py: inlcudes a pattern that directs different url paths into different applications.
  • manage.py: the key program that we need to run the server every time.

Step 2: To run the server

  1. [root@localhost Python]# cd django_project/
  2. [root@localhost django_project]# python manage.py runserver
  • Use the url in “Starting development server at (url)” to view the page.

Step 3: Add apps

  • After the tree is built, now spread branches: ```bash [root@localhost django_project]# python manage.py startapp blog

now we have

[root@localhost djangoproject]# tree . ├── blog │ ├── admin.py │ ├── apps.py │ ├── init.py │ ├── migrations │ │ └── init.py │ ├── models.py │ ├── tests.py │ └── views.py ├── db.sqlite3 ├── djangoproject │ ├── init.py │ ├── pycache │ │ ├── __init.cpython-36.pyc │ │ ├── settings.cpython-36.pyc │ │ ├── urls.cpython-36.pyc │ │ └── wsgi.cpython-36.pyc │ ├── settings.py │ ├── urls.py │ └── wsgi.py └── manage.py

4 directories, 17 files

  2. - in the example blog/ we have: 
  3.    - db.sqlite3: the database of the project after you create the first app. 
  4.    - urls.py: same as urls.py before, direct urls to the correct application. 
  5.    - views.py: what urls.py finally directs to, includes JavaScript code or template variables. 
  7. - to make sure all apps are correctly used, sometimes we need to add new routes or new pages for new apps.
  8. - For example, /blog/urls.py:
  9. ```python
  10. from django.urls import path
  11. from . import views # import from current directory
  13. urlpatterns = [
  14.     path('', views.home, name='blog-home'), # def home
  15.     path('about/', views.about, name='blog-about'), # def about
  16. ]

we have 2 routes, one for the homepage, one for an “about” page.
and they are finally related to functions in /blog/views.py: 

  1. from django.shortcuts import render
  2. from django.http import HttpResponse
  4. def home(request):
  5.     return HttpResponse('<h1>Blog Home</h1>')
  7. # new
  8. def about(request):
  9.     return HttpResponse('<h1>Blog About</h1>')

Step 4: Apply templates

  • Grab the function name in apps.py in the current app folder: ```python from django.apps import AppConfig

class BlogConfig(AppConfig): name = ‘blog’

  2. - paste in INSTALLED_APPS in django_project/settings.py:
  3. ```python
  4. //...
  5. INSTALLED_APPS = [
  6.     'blog.apps.BlogConfig', # path name + function name, divided by dots
  7.     'django.contrib.admin',
  8.     'django.contrib.auth',
  9.     'django.contrib.contenttypes',
  10.     'django.contrib.sessions',
  11.     'django.contrib.messages',
  12.     'django.contrib.staticfiles',
  13. ]
  14. //...

  • create 2 directories to save templates:

    1. [root@localhost django_project]# mkdir blog/templates
    2. [root@localhost django_project]# mkdir blog/templates/blog

  • For example, make a HTML page for home called home.html in blog/templates/blog/

    1. <!DOCTYPE html>
    2. <html>
    3. <head>
    4.   <title></title>
    5. </head>
    6. <body>
    7.   <h1>Blog Home!</h1>
    8. </body>
    9. </html>

  • change blog/views.py to redirect the request to that HTML page, and a template is used: ```python from django.shortcuts import render from django.http import HttpResponse

handle the traffic from homepage to blog

def home(request): return render(request, ‘blog/home.html’)

  1. #return HttpResponse('<h1>Blog Home</h1>')

def about(request): return HttpResponse(‘

Blog About

‘) ```

  • Using templates can help us reuse codes.

Step 5: Modify files for corresponding apps

  • The sequence of clients to use an application:
  1. get into the specific application page for paths in [project_name]/urls.py
  2. use the specific part of the application for paths in [app_name]/urls.py
  3. functions in [app_name]/views.py handle those requests
  4. those functions are shown to clients as webpages in [app_name]/templates/ [app_name]/[method].html
  • According to 4 steps, modify your codes for different requirements.