Django sekilas

Karena Django dikembangkan dalam lingkungan ruang redaksi yang serba cepat, itu dirancang untuk membuat tugas-tugas pengembangan jaringan umum cepat dan mudah. Ini adalah sebuah tinjauan tidak resmi dari bagaimana menulis sebuah aplikasi jaringan berbasis basisdata dengan Django.

Tujuan dari dokumen ini adalah memberikan anda spesifik teknik yang cukup untuk memahami bagaimana Django bekerja, tetapi ini tidak diperuntukkan menjadi tutorial atau acuan -- tetapi kami telah mendapatkan keduanya! Ketika anda siap memulai proyek, anda dapat:doc:start with the tutorial </intro/tutorial01> atau dive right into more detailed documentation.

Rancang model anda

Meskipun anda dapat menggunakan Django tanpa basisdata, dia datang dengan object-relational mapper dimana anda menggambarkan tata letak basisdata anda di kode Phyton.

data-model syntax menawarkan banyak jalan kaya dari mewakilkan model anda -- sejauh ini, dia telah menyelesaikan banyak tahun berharga dari masalah skema-basisdata. Ini adalah contoh cepat:

mysite/news/models.py

from django.db import models


class Reporter(models.Model):
    full_name = models.CharField(max_length=70)

    def __str__(self):
        return self.full_name


class Article(models.Model):
    pub_date = models.DateField()
    headline = models.CharField(max_length=200)
    content = models.TextField()
    reporter = models.ForeignKey(Reporter, on_delete=models.CASCADE)

    def __str__(self):
        return self.headline

Pasang dia

Selanjutnya, jalankan peralatan baris-perintah Django untuk membuat tabel basisdata secara otomatis:

Linux/macOS

$ python manage.py makemigrations
$ python manage.py migrate

Windows

...\> py manage.py makemigrations
...\> py manage.py migrate

Perintah makemigrations mencari semua model anda yang tersedia dan membuat perpindahan untuk tabel-tabel mana saja yang tidak ada. migrate menjalan perpindahan dan membuat tabel-tabel dalam basisdata anda, dan juga pilihan menyediakan much richer schema control.

Nikmati API bebas

Dengan itu, anda telah mendapatkan bebas, dan kaya, API Python untuk mengakses data anda. API dibuat dengan cepat, tidak ada pembangkitan kode yang dibutuhkan:

# Import the models we created from our "news" app
>>> from news.models import Article, Reporter

# No reporters are in the system yet.
>>> Reporter.objects.all()
<QuerySet []>

# Create a new Reporter.
>>> r = Reporter(full_name="John Smith")

# Save the object into the database. You have to call save() explicitly.
>>> r.save()

# Now it has an ID.
>>> r.id
1

# Now the new reporter is in the database.
>>> Reporter.objects.all()
<QuerySet [<Reporter: John Smith>]>

# Fields are represented as attributes on the Python object.
>>> r.full_name
'John Smith'

# Django provides a rich database lookup API.
>>> Reporter.objects.get(id=1)
<Reporter: John Smith>
>>> Reporter.objects.get(full_name__startswith="John")
<Reporter: John Smith>
>>> Reporter.objects.get(full_name__contains="mith")
<Reporter: John Smith>
>>> Reporter.objects.get(id=2)
Traceback (most recent call last):
    ...
DoesNotExist: Reporter matching query does not exist.

# Create an article.
>>> from datetime import date
>>> a = Article(
...     pub_date=date.today(), headline="Django is cool", content="Yeah.", reporter=r
... )
>>> a.save()

# Now the article is in the database.
>>> Article.objects.all()
<QuerySet [<Article: Django is cool>]>

# Article objects get API access to related Reporter objects.
>>> r = a.reporter
>>> r.full_name
'John Smith'

# And vice versa: Reporter objects get API access to Article objects.
>>> r.article_set.all()
<QuerySet [<Article: Django is cool>]>

# The API follows relationships as far as you need, performing efficient
# JOINs for you behind the scenes.
# This finds all articles by a reporter whose name starts with "John".
>>> Article.objects.filter(reporter__full_name__startswith="John")
<QuerySet [<Article: Django is cool>]>

# Change an object by altering its attributes and calling save().
>>> r.full_name = "Billy Goat"
>>> r.save()

# Delete an object with delete().
>>> r.delete()

Sebuah antarmuka admin dinamisL ini bukan hanya perancah -- ini adalah keseluruhan rumah

Sekali model anda telah ditentukan, Django dapat otomatis membuat profesional, siap produksi administrative interface -- sebuah situs jaringan yang membuat pengguna terautentifikasi menambah, merubah dan menghapus objek. Satu-satunya langkah dibutuhkan adalah mendaftarkan model anda dalam situs admin:

mysite/news/models.py

from django.db import models


class Article(models.Model):
    pub_date = models.DateField()
    headline = models.CharField(max_length=200)
    content = models.TextField()
    reporter = models.ForeignKey(Reporter, on_delete=models.CASCADE)

mysite/news/admin.py

from django.contrib import admin

from . import models

admin.site.register(models.Article)

Filosofi disini adalah bahwa situs anda disunting oleh staf, atau klien, atau mungkin hanya anda -- dan anda tidak ingin berhubungan dengan membuat antarmuka backend hanya untuk mengelola isi.

Satu alurkerja khas dalam membuat aplikasi Django adalah membuat model dan mendapatkan situs admin hidup dan berjalan secepat mungkin, jadi staf anda 9atau klien) dapat mulai mengumpulkan data. Lalu, mengembangkan jalur data dihadirkan ke umum.

Rancang URL anda

Bersih, skema URL elegan adalah rincian penting dalam aplikasi jaringan berkualitas tinggi. Django mendorong rancangan URL cantik dan tidak menaruh kata kasar apapun dalam URL, seperti .php atau .asp.

Untuk merancang URL untuk sebuah aplikasi, anda buat sebuah modul Python dipanggil URLconf. Sebuah tabel dari isi aplikasi anda, itu mengandung pemetaan diantara pola URL dan fungsi panggilan kembali Python. URLconfs juga melayani untuk memisahkan URL dari kode Python.

Ini adalah apa URLconf mungkin terlihat seperti untuk Reporter/Article contoh diatas:

mysite/news/urls.py

from django.urls import path

from . import views

urlpatterns = [
    path("articles/<int:year>/", views.year_archive),
    path("articles/<int:year>/<int:month>/", views.month_archive),
    path("articles/<int:year>/<int:month>/<int:pk>/", views.article_detail),
]

Kode diatas memetakan jalur URL pada fungsi callback Python ("views"). String jalur menggunakan etiket parameter untuk "menangkap" nilai-nilai dari URL. Ketika seorang pengguna meminta sebuah halaman, Django menjalankan setiap jalur, dalam urutan, dan berhenti pada satu pertama uang cocok dengan URL diminta. (Jika tidak ada dari mereka cocok, Django memanggil tampilan kasus-khusus 404). Ini sangat cepat, karena jalur disusun kedalam reguler expression pada waktu muat.

Ketika satu dari pola URL cocok, Django memanggil tampilan yang diberikan, yaitu sebuah fungsi Python. Setiap tampilan mendapatkan perlewatan sebuah permintaan obyek -- yang mengandung permintaan metadata -- dan nilai-nilai ditangkap dalam pola.

Sebagai contoh, jika sebuah pengguna meminta URL "/articles/2005/05/39323/", Django akan memanggil fungsi news.views.article_detail(request, year=2005, month=5, pk=39323).

Tulis tampilan anda

Setiap tampilan bertanggung jawab untuk melalukan satu dari dua hal: Mengembalikan sebuah obyek HttpResponse mengandung isi untuk halaman diminta, atau menerbitkan pengecualian seperti Http404. Sisanya terserah anda.

Umumnya, tampilan mengambil data menurut parameter, memuat cetakan dan menjadikan cetakan dengan data terambil. Disini adalah sebuah contoh tampilan untuk year_archive dari atas:

mysite/news/views.py

from django.shortcuts import render

from .models import Article


def year_archive(request, year):
    a_list = Article.objects.filter(pub_date__year=year)
    context = {"year": year, "article_list": a_list}
    return render(request, "news/year_archive.html", context)

Ini contoh menggunakan template system Django, yang mempunyai beberapa fitur kuat tetapi bekerja keras untuk tetap cukup sederhana untuk digunakan bagi bukan-programmer.

Rancang cetakan anda

Kode diatas memuat cetakan news/year_archive.html.

Django mempunyai sebuah cetakan jalur pencarian, yang mengizinkan anda mengecilkan kelebihan antara cetakan. Di pengaturan Django anda, anda menjelaskan daftar direktori untuk memeriksa untuk cetakan dengan DIRS. Jika cetakan tidak ada di direktori pertama, dia memeriksa yang kedua, dan selanjutnya.

Mari kita katakan cetakan news/year_archive.html telah ditemukan. Disini apa yang mungkin terlihat seperti:

mysite/news/templates/news/year_archive.html

{% extends "base.html" %}

{% block title %}Articles for {{ year }}{% endblock %}

{% block content %}
<h1>Articles for {{ year }}</h1>

{% for article in article_list %}
    <p>{{ article.headline }}</p>
    <p>By {{ article.reporter.full_name }}</p>
    <p>Published {{ article.pub_date|date:"F j, Y" }}</p>
{% endfor %}
{% endblock %}

Variabel dikelilingi oleh kurung kurawal ganda. {{ article.headline }} berarti "Nilai keluaran dari atribut kepala berita artikel." Tetapi titik tidak digunakan hanya untuk mencari atribut. Mereka juga dapat melakukan mencari kuncu-kamus, mencari index dan pemanggilan fungsi.

Catat {{ article.pub_date|date:"F j, Y" }} menggunakan gaya-Unix "pipe" (karakter "|"). Ini dipanggil saringan cetakan, dan itu adalah jalan untuk menyaring nilai dari variabel. Di kasus ini, tanggal menyaring membentuk obyek tanggal waktu Phyton di bentuk yang fiberikan (seperti ditemukan di fungsi tanggal PHP).

Anda dapat merantai bersama sebanyak saringan yang anda suka. Anda dapat menulis saringan cetakan penyesuaian. Anda dapat menulis label cetakan penyesuaian, yang menjalankan kode Phyton disesuaikan dibelakang layar.

Akhirnya, Django menggunakan konsep dari "cetakan turunan". Itu apa yang {% extends "base.html" %} lakukan. Dia berarti "Pertama muat cetakan disebut 'base', yang menentukan segerombolan blok, dan isi blok dengan blok berikut." Pendeknya, itu membiarkan anda secara dramatis memotong kelebihan di cetakan: setiap cetakan harus menentukan hanya apa yang unik ke cetakan tersebut.

Disini adalah apa cetakan "base.html", termasuk penggunaan berkas statis, mungkin terlihat seperti:

mysite/templates/base.html

{% load static %}
<html>
<head>
    <title>{% block title %}{% endblock %}</title>
</head>
<body>
    <img src="{% static 'images/sitelogo.png' %}" alt="Logo">
    {% block content %}{% endblock %}
</body>
</html>

Secara sederhana, itu menentukan lihat-dan-rasakan dari situs (dengan logo situs), dan menyediakan "holes" untuk cetakan anak untuk diisi. Ini berarti bahwa sebuah situs dirancang kembali dapat dilakukan dengan merubah berkas tunggal -- cetakan dasar.

Ini juga memungkinkan anda membuat banyak versi situs, dengan cetakan dasar berbada, selagi menggunakan kembali cetakan anak. Pembuar Django harus menggunakan teknik ini untuk membuat sangat mencolok versi ponsel yang berbeda dari situs dengan hanya membuat sebuah cetakan dasar baru.

Catatan bahwa anda tidak harus menggunakan sistem cetakan Django jika anda memilih sistem lain. Selama sistem cetakan Django terutama terpadu-baik dengan lapisan model Django, tidak ada paksaan anda menggunakannya. untuk keadaan itu, anda tidak harus menggunakan API basisdata Django, salah satu. Anda dapat menggunakan lapisan abstraksi basisdata lain, anda dapat membaca berkas XML, anda dapat membaca berkas cakram. Setiap potongan Django -- model, tampilan, cetakan -- dipisahkan dari selanjutnya.

Ini hanya permukaan

Ini hanya ikhtisar cepat dari fungsi Django. Beberapa fitur lebih berguna:

• Sebuah kerangka tembolok yang dipadukan dengan memcache atau backend lain.
• syndication framework yang memungkinkan anda membuat umpan RSS dan Atom dengan menulis sebuah kelas kecil Python.
• Lebih atraktif fitur-fitur admin dibangkitkan-otomatis -- gambaran ini nyaris tidak tergores di permukaan.

Langkah selanjutnya adalah untuk anda download Django, baca the tutorial dan gabung the community. Terima kasih untuk minat anda!