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 peralatan baris-perintah Django untuk membuat tabel basisdata secara otomatis:

$ python manage.py makemigrations
$ python manage.py migrate
...\> py manage.py makemigrations
...\> py manage.py migrate

The makemigrations command looks at all your available models and creates migrations for whichever tables don't already exist. migrate runs the migrations and creates tables in your database, as well as optionally providing much richer schema control.

Nikmati API bebas

With that, you've got a free, and rich, Python API to access your data. The API is created on the fly, no code generation necessary:

# 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

Once your models are defined, Django can automatically create a professional, production ready administrative interface -- a website that lets authenticated users add, change and delete objects. The only step required is to register your model in the admin site:

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)

The philosophy here is that your site is edited by a staff, or a client, or maybe just you -- and you don't want to have to deal with creating backend interfaces only to manage content.

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.

To design URLs for an app, you create a Python module called a URLconf. A table of contents for your app, it contains a mapping between URL patterns and Python callback functions. URLconfs also serve to decouple URLs from Python code.

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>

Simplistically, it defines the look-and-feel of the site (with the site's logo), and provides "holes" for child templates to fill. This means that a site redesign can be done by changing a single file -- the base template.

It also lets you create multiple versions of a site, with different base templates, while reusing child templates. Django's creators have used this technique to create strikingly different mobile versions of sites by only creating a new base template.

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.
  • A syndication framework that lets you create RSS and Atom feeds by writing a small Python class.
  • Lebih atraktif fitur-fitur admin dibangkitkan-otomatis -- gambaran ini nyaris tidak tergores di permukaan.

The next steps are for you to download Django, read the tutorial and join the community. Thanks for your interest!

Back to Top