Django sekilas

Karena Django dikembangkan dalam lingkungan cepat, dia telah dirancang untuk membuat tugas Pengembangan-jaringan umum cepat dan mudah. Ini adalah sebuah ikhstisar tidak resmi dari bagaimana menulis aplikasi Jaringan 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 kegunaan baris-perintah Django untuk membuat tabel basisdata otomatis:

$ python manage.py migrate

Perintah migrate mencari semua model tersedia anda dan membuat tabel di basisdata anda untuk tabel manapun yang tidak ada, serta pilihan menyediakan lebih kaya kendali skema.

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 Reporter, Article

# 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 ditentukan, Django dapat otomatis membuat profesional, siap produksi administrative interface -- sebuah situs jaringan yang membiarkan pengguna dibuktikan menambah, merubah dan menghapus obyek. Dia semudah mendaftarkan model anda di 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 mempunyai persetujuan dengan membuat antarmuka belakang 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 anggun adalah rincian penting dalam aplikasi Jaringan kualitas-tinggi. Django mendorong perancangan URL indah dan tidak menaruh sesuatu yang ada di URL, seperti .php or .asp.

Untuk merancang URL untuk sebuah apliaksi, anda membuat modul Phyton disebut URLconf. Sebuah tabel isi untuk aplikasi anda, dia mengandung pemetaan sederhana diantara pola URL dan fungsi Phyton memanggil kembali. URLconf juga melayani untuk memisahkan URL dari kode Phyton.

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),
]

The code above maps URL paths to Python callback functions ("views"). The path strings use parameter tags to "capture" values from the URLs. When a user requests a page, Django runs through each path, in order, and stops at the first one that matches the requested URL. (If none of them matches, Django calls a special-case 404 view.) This is blazingly fast, because the paths are compiled into regular expressions at load time.

Once one of the URL patterns matches, Django calls the given view, which is a Python function. Each view gets passed a request object -- which contains request metadata -- and the values captured in the pattern.

For example, if a user requested the URL "/articles/2005/05/39323/", Django would call the function 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 kelihatan-dan-rasa dari situs (dengan logo situs), dan menyediakan lubang untuk cetakan anak untuk diisi. Ini membuat situs dirancang kembali semudah merubah berkas tunggal -- cetakan dasar.

Dia juga membiarkan anda membuat versi banyak dari situs, dengan cetakan dasar berbeda, selama menggunakan kembali cetakan anak. Pembuat Django telah menggunakan teknik ini untuk membuat dengan cara menyolok versi berjalan berbeda dari situs -- mudah dengan membuat 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.
  • Sebuah kerangka kongsi yang membuat menciptakan RSS dan umpan Atom semudah menulis kelas Phyton kecil.
  • Lebih otomatis menggairahkan-fitur admin dibangkitkan -- ikhtisar ini hampir tidak tergores permukaan.

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

Back to Top