บทช่วยสอน Django: เริ่มต้นด้วย Django 2.0

Django เป็นเว็บเฟรมเวิร์ก Python ขนาดเดียวที่เหมาะกับทุกคนซึ่งได้รับแรงบันดาลใจจาก Ruby on Rails และใช้คำอุปมาอุปมัยเดียวกันหลายตัวเพื่อให้การพัฒนาเว็บเป็นไปอย่างรวดเร็วและง่ายดาย Django เต็มไปด้วยความยืดหยุ่นและเป็นหนึ่งในเว็บเฟรมเวิร์กที่ใช้กันอย่างแพร่หลายที่สุดของ Python

Django มีแทบทุกอย่างที่คุณต้องการในการสร้างเว็บแอปพลิเคชันทุกขนาดและความนิยมทำให้ง่ายต่อการค้นหาตัวอย่างและความช่วยเหลือสำหรับสถานการณ์ต่างๆ Plus Django มีเครื่องมือที่ช่วยให้แอปพลิเคชันของคุณพัฒนาและเพิ่มคุณสมบัติได้อย่างสง่างามและเพื่อโยกย้ายสคีมาข้อมูล (หากมี)

Django ยังมีชื่อเสียงในด้านความซับซ้อนโดยมีส่วนประกอบมากมายและต้องมีการกำหนดค่า "ภายใต้ประทุน" ที่ดี ในความเป็นจริงคุณสามารถเปิดใช้งานแอปง่ายๆในลำดับที่ค่อนข้างสั้นจากนั้นขยายฟังก์ชันการทำงานจากที่นั่นได้ตามต้องการ

ในคู่มือนี้เราจะอธิบายถึงการสร้างแอพ Django 2.0 พื้นฐานและสัมผัสสั้น ๆ เกี่ยวกับคุณสมบัติที่สำคัญที่สุดที่มีให้สำหรับนักพัฒนาเว็บ

การอัพเกรดจาก Django 1.x

หากคุณมีประสบการณ์กับ Django รุ่นก่อนหน้า 1.x สิ่งเหล่านี้คือการเปลี่ยนแปลงที่สำคัญที่สุดที่ควรคำนึงถึง:

  • Django 2.0 รองรับเฉพาะ Python 3.4 ขึ้นไป Python 2.x จะไม่ได้รับการสนับสนุนใน Django เวอร์ชันอนาคต
  • Django 2 เป็นไปตามรูปแบบของ Python 3 ในการใช้สตริง Unicode ดั้งเดิมทุกที่ที่เป็นไปได้ ฟังก์ชัน Django บางฟังก์ชันจะไม่ยอมรับ bytestrings เป็นอินพุตอีกต่อไป 

มีการเปลี่ยนแปลงย้อนหลังอื่น ๆ ที่เข้ากันไม่ได้อีกมากมาย แต่สิ่งเหล่านี้เป็นสองสิ่งที่สำคัญที่สุดโดยเฉพาะอย่างยิ่งเมื่อเริ่มโครงการใหม่

การติดตั้งไลบรารีหลักของ Django

ในการติดตั้ง Django 2.0 คุณจะต้องใช้ Python 3.4 หรือดีกว่า วิธีที่ง่ายที่สุดในการติดตั้ง Django คือผ่านpipยูทิลิตี้ของ Python :

pip install django

สิ่งนี้จะติดตั้งไลบรารี Django หลักและdjango-adminยูทิลิตี้บรรทัดคำสั่งที่ใช้สำหรับจัดการโครงการ Django

หากคุณต้องการทำงานร่วมกับ Django หลายเวอร์ชันเคียงข้างกันให้สร้างสภาพแวดล้อมเสมือนจริงติดตั้ง Django เวอร์ชันที่คุณต้องการที่นั่นและใช้สำหรับโครงการ Django ที่เป็นปัญหา

โปรดทราบว่าคุณไม่จำเป็นต้องใช้สภาพแวดล้อมเสมือนเพื่อสร้างหลายโปรเจ็กต์ด้วย Django อินสแตนซ์เดียว คุณเพียงต้องการให้พวกเขาใช้การแก้ไขจุดต่างๆของเฟรมเวิร์ก Django  กับโปรเจ็กต์ต่างๆ

การสร้างโครงการ Django ใหม่

อินสแตนซ์ Django จัดเป็นสองระดับ ได้แก่โปรเจ็กต์และแอ

  • โครงการเป็นตัวอย่างของ Django กับการกำหนดค่าฐานข้อมูลของตัวเองการตั้งค่าและแอพพลิเค ขอแนะนำให้คิดว่าโครงการเป็นสถานที่จัดเก็บการกำหนดค่าระดับไซต์ทั้งหมดที่คุณจะใช้
  • แอปเป็นแผนกหนึ่งของโครงการที่มีเส้นทางและการแสดงผลตรรกะของตัวเอง สามารถวางแอพหลายตัวไว้ในโปรเจ็กต์ Django เดียว 

ในการสร้างโครงการ Django ใหม่ตั้งแต่ต้นให้ป้อนไดเร็กทอรีที่คุณต้องการจัดเก็บโปรเจ็กต์และพิมพ์:

django-admin startproject

ที่เป็นชื่อของทั้งสองโครงการและไดเรกทอรีย่อยที่โครงการจะถูกเก็บไว้ อย่าลืมเลือกชื่อที่ไม่น่าจะชนกับชื่อที่ Python หรือ Django ใช้เป็นการภายใน ชื่อที่ชอบmyprojจะใช้งานได้ดี

ไดเร็กทอรีผลลัพธ์ควรมี  manage.pyไฟล์ซึ่งใช้เพื่อควบคุมพฤติกรรมของแอพจากบรรทัดคำสั่งและไดเร็กทอรีย่อยอื่น (รวมถึงชื่อโปรเจ็กต์ด้วย) ที่มีไฟล์ต่อไปนี้:

  • __init__.pyไฟล์ซึ่งถูกใช้โดยงูหลามเพื่อกำหนดไดเรกทอรีย่อยเป็นโมดูลรหัสที่
  • settings.pyซึ่งเก็บการตั้งค่าที่ใช้สำหรับโครงการ การตั้งค่าทั่วไปส่วนใหญ่จำนวนมากจะถูกเติมไว้ล่วงหน้าสำหรับคุณ
  • urls.pyซึ่งแสดงรายการเส้นทางหรือ URL ที่พร้อมใช้งานสำหรับโครงการ Django ของคุณหรือโครงการจะส่งคืนการตอบกลับ
  • wsgi.pyซึ่งใช้โดยเว็บเซิร์ฟเวอร์ที่เข้ากันได้กับ WSGI เช่น Apache HTTP หรือ Nginx เพื่อให้บริการแอปของโครงการของคุณ

ก่อนอื่นใดให้ทดสอบโครงการเพื่อให้แน่ใจว่าทำงานได้ จากบรรทัดคำสั่งในไดเร็กทอรีที่มีmanage.pyไฟล์ของโปรเจ็กต์ของคุณให้รัน:

python manage.py runserver

//127.0.0.1:8000/นี้ควรเริ่มต้นพัฒนาเว็บเซิร์ฟเวอร์ที่มีอยู่ใน ไปที่ลิงค์นั้นและคุณจะเห็นหน้าต้อนรับง่ายๆที่แจ้งให้คุณทราบว่าการติดตั้งสำเร็จแล้ว

โปรดทราบว่าไม่ควรใช้เว็บเซิร์ฟเวอร์การพัฒนาเพื่อให้บริการโครงการ Django ต่อสาธารณะ จะไม่ปรับขนาดเพื่อรองรับปริมาณการใช้งานที่จำเป็น

การสร้างแอป Django

Next we need to create an app inside this project. Navigate to the same directory as manage.py and issue this command:

python manage.py startapp myapp

This creates a subdirectory for an app named myapp that contains the following:

  • A migrations directory. Contains code used to migrate the site between versions of its data schema.
  • admin.py. Contains objects used by Django’s built-in administration tools. If your app has an admin interface or privileged users, you would configure the related objects here.
  • apps.py. Provides configuration information about the app to the project at large, by way of an AppConfig object.
  • models.py. Contains objects that define data structures used by your app to interface with databases.
  • tests.py. Contains any tests used to ensure that your site’s functions and modules are working as intended.
  • views.py. Contains functions that render and return responses.

To start working with the app, we must first register it with the project. To do this, edit myproj/settings.py and add a line to the top of the INSTALLED_APPS list:

INSTALLED_APPS = [ ‘myapp.apps.MyappConfig’, ‘django.contrib.admin’, ... 

If you look in myapp.apps, you’ll see a pre-generated object named MyappConfig, which is what we’re referencing here.

Adding routes and views to your Django app

Django apps follow a basic pattern for processing requests:

  • When an incoming request is received, Django parses the URL for a route to apply it to.
  • Routes are defined in urls.py, with each route linked to a view, i.e. a function that returns data to be sent back to the client. Views can be located anywhere in a Django project, but they’re best organized into their own modules.
  • Views can contain the results of a template, i.e. code that formats requested data according to a certain design.

To get an idea of how all these pieces fit together, let’s modify the default route of our sample app to return a custom message.

Routes are defined in urls.py in a list named urlpatterns. If you open the sample urls.py, you’ll see urlpatterns already predefined:

urlpatterns = [ path(‘admin/’, admin.site.urls), ] 

The path function—a Django built-in—takes a route and a view function as arguments and generates a reference to a URL path. By default, Django creates an admin path that is used for site administration, but we need to create our own routes.

Add another entry, so that the whole file looks like:

from django.contrib import admin from django.urls import include, path urlpatterns = [ path(‘admin/’, admin.site.urls), path(‘myapp/’, include(‘myapp.urls’)) ] 

The include function tells Django to look for more route pattern information in the file myapp.urls. All of the routes found in that file will be attached to the top-level route myapp (e.g., //127.0.0.1:8080/myapp).

Next, create a new urls.py in myapp and add the following:

from django.urls import path from . import views urlpatterns = [ path(‘’, views.index) ] 

Django prepends a slash to the beginning of each URL, so to specify the root of the site (/), we just supply a blank string as the URL.

Now edit the file myapp/views.py so it looks like this:

from django.http import HttpResponse def index(request): return HttpResponse(“Hello, world!”) 

django.http.HttpResponse is a Django built-in that generates an HTTP response from a supplied string. Note that request, which contains the information for an incoming HTTP request, must be passed as the first parameter to a view function.

Stop and restart the development server, and navigate to //127.0.0.1:8000/myapp/. You should see Hello, world! appear in the browser.

Adding routes with variables in Django

Django can accept routes that incorporate variables as part of their syntax. Let’s say you wanted to accept URLs that had the format year/. You could accomplish that by adding the following entry to urlpatterns:

path(‘year/’, views.year) 

The view function views.year would then be invoked through routes like year/1996, year/2010, and so on, with the variable year passed as a parameter to views.year.

To try this out for yourself, add the above urlpatterns entry to myapp/urls.py, then add this function to myapp/views.py:

def year(request, year): return HttpResponse(‘Year: {}’.format(year)) 

If you navigate to /myapp/year/2010 on your site, you should see Year: 2010 displayed in response. Note that routes like /myapp/year/rutabaga will yield an error, because the int: constraint on the variable year allows only an integer in that position. Many other formatting options are available for routes.

Earlier versions of Django had a more complex and difficult-to-parse syntax for routes. If you still need to add routes using the old syntax—for instance, for backward compatibility with an old Django project—you can do so by using the django.urls.re_path function.

Django templates

Django’s built-in template language can be used to generate web pages from data.

Templates used by Django apps are stored in a directory that is central to the project: /templates//. For our myapp project, the directory would be myapp/templates/myapp/. This directory structure may seem a little awkward, but Django can look for templates in multiple places, so this avoids name collisions between templates with the same names across multiple apps.

In your myapp/templates/myapp/ directory, create a file named year.html with the following content:

Year: {{year}} 

Any value within double curly braces in a template is treated as a variable. Everything else is treated literally.

Modify myapp/views.py to look like this:

from django.shortcuts import render from django.http import HttpResponse def index(request): return HttpResponse(“Hello, world!”) def year(request, year): data = {’year’:year} return render(request, ‘myapp/year.html’, data) 

The render function, a Django “shortcut” (a combination of multiple built-ins for convenience), takes the existing request object, looks for the template myapp/year.html in the list of available template locations, and passes the dictionary data to it as context for the template.

The amount of processing you can perform on data within Django templates is intentionally quite limited. Django’s philosophy is to enforce separation of presentation and business logic whenever possible. Thus you can loop through an iterable object, and you can perform if/then/else tests, but modifying the data within a template is frowned upon.

For instance, a simple “if” test can be encoded this way:

{% if year > 2000 %} 21st century year: {{year}} {% else %} Pre-21st century year: {{year}} {% endif %} 

The {% and %} markers delimit blocks of code that can be executed in Django’s template language.

If you want to use a more sophisticated template processing language, you can swap in others, such as Jinja2 or Mako. Django includes back-end integration for Jinja2, but any template language that returns a string can be used—for instance, by returning that string in a HttpResponse object as in the case of our ”Hello, world!” route.

Next steps with Django

What we’ve seen here covers only the most basic elements of a Django application. Django includes a great many other components that can be employed in a web project. All of these are worth discussing in detail separately, but I will leave you with a brief overview:

  • Databases and data models. Django’s built-in ORM can be used to define data structures and relationships between them for your app, as well as migration paths between versions of those structures.

  • รูปแบบ Django มีวิธีที่สอดคล้องกันสำหรับมุมมองในการจัดหาแบบฟอร์มอินพุตให้กับผู้ใช้ดึงข้อมูลทำให้ผลลัพธ์เป็นปกติและจัดทำรายงานข้อผิดพลาดที่สอดคล้องกัน

  • การรักษาความปลอดภัยและระบบสาธารณูปโภค Django มีฟังก์ชันในตัวมากมายสำหรับการแคชการบันทึกการจัดการเซสชันการจัดการไฟล์คงที่และการปรับ URL ให้เป็นมาตรฐาน นอกจากนี้ยังรวมเครื่องมือสำหรับความต้องการด้านความปลอดภัยทั่วไปเช่นการใช้ใบรับรองการเข้ารหัสหรือการป้องกันการปลอมแปลงข้ามไซต์หรือการคลิกแจ็ค