# dokumentasi Django 2.0.8

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

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 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!