Tutorial Django: Memulai dengan Django 2.0

Django adalah kerangka kerja web Python satu ukuran untuk semua yang terinspirasi oleh Ruby on Rails dan menggunakan banyak metafora yang sama untuk membuat pengembangan web cepat dan mudah. Penuh dan fleksibel, Django telah menjadi salah satu kerangka kerja web Python yang paling banyak digunakan.

Django menyertakan hampir semua yang Anda butuhkan untuk membangun aplikasi web dengan ukuran berapa pun, dan popularitasnya membuatnya mudah untuk menemukan contoh dan bantuan untuk berbagai skenario. Ditambah Django menyediakan alat untuk memungkinkan aplikasi Anda berkembang dan menambahkan fitur dengan baik, dan untuk memindahkan skema datanya (jika ada).

Django juga mempunyai reputasi sebagai yang kompleks, dengan banyak komponen dan banyak konfigurasi “di bawah tenda” diperlukan. Sebenarnya, Anda bisa mengaktifkan dan menjalankan aplikasi sederhana dalam waktu yang relatif singkat, kemudian memperluas fungsinya dari sana sesuai kebutuhan.

Dalam panduan ini kita akan berjalan melalui pembuatan aplikasi Django 2.0 yang belum sempurna, dan menyentuh secara singkat fitur paling penting yang disediakannya untuk pengembang web.

Meningkatkan dari Django 1.x

Jika anda memiliki pengalaman dengan Django edisi 1.x sebelumnya, ini adalah perubahan pemutusan terpenting yang harus diperhatikan:

  • Django 2.0 hanya mendukung Python 3.4 dan yang lebih baru. Python 2.x tidak akan didukung pada versi Django yang akan datang.
  • Django 2 mengikuti pola Python 3 menggunakan string Unicode asli jika memungkinkan. Beberapa fungsi Django tidak akan lagi menerima bytestring sebagai masukan. 

Ada banyak perubahan lain yang tidak kompatibel dengan versi sebelumnya, tetapi itu adalah dua yang paling signifikan, terutama saat memulai proyek baru.

Memasang pustaka inti Django

Untuk memasang Django 2.0, Anda membutuhkan Python 3.4 atau yang lebih baik. Maka cara termudah untuk memasang Django adalah melalui piputilitas Python :

pip install django

Ini memasang pustaka Django inti dan django-adminutilitas baris perintah yang digunakan untuk mengelola proyek Django.

Jika Anda ingin bekerja dengan banyak versi Django berdampingan, buat lingkungan virtual, instal versi Django yang Anda inginkan di sana, dan gunakan itu untuk proyek Django yang dimaksud.

Perhatikan bahwa Anda tidak perlu menggunakan lingkungan virtual untuk membuat banyak proyek dengan satu contoh Django. Anda hanya membutuhkan mereka untuk menggunakan revisi titik berbeda dari kerangka Django  dengan proyek berbeda.

Membuat proyek Django baru

Instans Django diatur dalam dua tingkatan: proyek dan aplikasi .

  • Sebuah proyek adalah turunan dari Django dengan konfigurasi database, pengaturan, dan aplikasinya sendiri. Sebaiknya pikirkan proyek sebagai tempat untuk menyimpan semua konfigurasi tingkat situs yang akan Anda gunakan.
  • Sebuah aplikasi adalah pembagian proyek, dengan rute dan rendering sendiri logikanya. Beberapa aplikasi dapat ditempatkan dalam satu proyek Django. 

Untuk membuat proyek Django baru dari awal, masuk ke direktori tempat Anda ingin menyimpan proyek dan ketik:

django-admin startproject

di mana nama proyek dan subdirektori tempat proyek akan disimpan. Pastikan untuk memilih nama yang tidak mungkin bertabrakan dengan nama yang digunakan oleh Python atau Django secara internal. Nama seperti myprojakan bekerja dengan baik.

Direktori yang dihasilkan harus berisi  manage.pyfile, yang digunakan untuk mengontrol perilaku aplikasi dari baris perintah, dan subdirektori lain (juga dengan nama proyek) yang berisi file berikut:

  • Sebuah __init__.pyfile, yang digunakan oleh Python untuk menunjuk sebuah subdirektori sebagai modul kode.
  • settings.py, yang menyimpan setelan yang digunakan untuk proyek tersebut. Banyak dari pengaturan yang paling umum akan diisi sebelumnya untuk Anda.
  • urls.py, yang mencantumkan rute atau URL yang tersedia untuk proyek Django Anda, atau yang proyek akan kembalikan tanggapannya.
  • wsgi.py, yang digunakan oleh server web yang kompatibel dengan WSGI, seperti Apache HTTP atau Nginx, untuk melayani aplikasi proyek Anda.

Sebelumnya, uji proyek untuk memastikannya berfungsi. Dari baris perintah di direktori yang berisi manage.pyfile proyek Anda , jalankan:

python manage.py runserver

Ini harus memulai server web pengembangan yang tersedia di //127.0.0.1:8000/. Kunjungi tautan itu dan Anda akan melihat halaman selamat datang sederhana yang memberi tahu Anda bahwa penginstalan berhasil.

Perhatikan bahwa server web pengembangan hendaknya tidak digunakan untuk melayani proyek Django kepada publik. Ini tidak akan skala untuk menangani lalu lintas yang dibutuhkan.

Membuat aplikasi Django

Selanjutnya kita perlu membuat aplikasi di dalam proyek ini. Arahkan ke direktori yang sama dengan manage.pydan berikan perintah ini:

python manage.py startapp myapp

Ini membuat subdirektori untuk aplikasi bernama myapp yang berisi berikut ini:

  • Sebuah migrationsdirektori. Berisi kode yang digunakan untuk memigrasi situs di antara versi skema datanya.
  • admin.py. Berisi objek yang digunakan oleh perkakas administrasi bawaan Django. Jika aplikasi Anda memiliki antarmuka admin atau pengguna yang memiliki hak istimewa, Anda akan mengonfigurasi objek terkait di sini.
  • apps.py. Memberikan informasi konfigurasi tentang aplikasi ke project secara luas, melalui sebuah AppConfigobjek.
  • models.py. Berisi objek yang menentukan struktur data yang digunakan oleh aplikasi Anda untuk berinteraksi dengan database.
  • tests.py. Berisi pengujian apa pun yang digunakan untuk memastikan bahwa fungsi dan modul situs Anda berfungsi sebagaimana mestinya.
  • views.py. Berisi fungsi yang merender dan mengembalikan respons.

Untuk mulai bekerja dengan aplikasi, pertama-tama kita harus mendaftarkannya ke proyek. Untuk melakukan ini, edit myproj/settings.pydan tambahkan baris ke bagian atas INSTALLED_APPSdaftar:

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

Jika Anda melihat ke dalam myapp.apps, Anda akan melihat objek yang dibuat sebelumnya bernama MyappConfig, yang kami rujuk di sini.

Menambahkan rute dan tampilan ke aplikasi Django Anda

Aplikasi Django mengikuti pola dasar untuk memproses permintaan:

  • Ketika permintaan masuk diterima, Django mengurai URL untuk rute untuk menerapkannya.
  • Rute ditentukan dalam urls.py, dengan setiap rute ditautkan ke tampilan , yaitu fungsi yang mengembalikan data untuk dikirim kembali ke klien. Tampilan dapat ditempatkan dimana saja dalam proyek Django, tetapi mereka paling baik diatur ke dalam modulnya sendiri.
  • 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.

  • Formulir . Django menyediakan cara yang konsisten untuk tampilan untuk menyediakan formulir masukan kepada pengguna, mengambil data, menormalkan hasil, dan menyediakan pelaporan kesalahan yang konsisten.

  • Keamanan dan utilitas . Django menyertakan banyak fungsi bawaan untuk tembolok, pencatatan, penanganan sesi, menangani berkas statis, dan menormalkan URL. Ini juga menggabungkan alat untuk kebutuhan keamanan umum seperti menggunakan sertifikat kriptografi, atau melindungi dari perlindungan pemalsuan lintas situs atau pembajakan klik.