# Dokumentasi Django 6.0.7

# Menulis aplikasi Django pertama anda, bagian 3

Tutorial ini memulai dimana Tutorial 2 ditinggalkan. Kami akan melanjutkan aplikasi poling jaringan dan akan fokus pada membuat antarmuka umum -- "views."

Dimana mendapatkan bantuan:

Jika anda memiliki masalah melalui tutorial ini, harap geser ke Getting Help bagian dari FAQ.

## Ikhtisar

Sebuah tampilan adalah "type" dari halaman jaringan dalam aplikasi Django anda yang umumnya melayani fungsi khusus dan mempunyai cetakan khusus. Sebagai contoh, dalam sebuah aplikasi blog, anda mungkin memiliki tampilan berikut:

- Halaman rumah Blog -- menampilkan sedikit masukan terakhir.

- Halaman "rincian" masukan -- halaman permalink untuk masukan tunggal.

- Halaman arsip berdasarkan-tahun -- menampilkan semua bulan dengan masukan di tahun yang diberikan.

- Halaman arsip berdasarkan-bulan -- menampilkan semua hari dengan masukan di bulan yang diberikan.

- Halaman arsip berdasarkan-hari -- menampilkan semua masukan di hari yang diberikan.

- Tindakan komentar -- menangani penempatan komentar pada masukan yang diberikan.

Di aplikasi jejak pendapat kami, kami akan mempunyai empat tampilan berikut:

- Halaman "index" pertanyaan -- menampilkan sedikit pertanyaan terakhir.

- Halaman "index" pertanyaan -- menampilkan teks pertanyaan, dengan tidak ada hasil tetapi dengan formulir untuk memilih.

- Halaman "hasil" pertanyaan -- menampilkan hasil untuk pertanyaan tertentu.

- Tindakan pilih -- menangani pemilihan untuk pilihan tertentu di pertanyaan tertentu.

Di Django, halaman jaringan dan isi lain dikirimkan oleh tampilan. Setiap tampilan diwakulkan oleh fungsi Python (atau metode, dalam kasus tampilan berdasarkan-kelas). Django akan memilih sebuah tampilan dengan mencoba URL yang diminta (tepatnya, bagian dari URL setelah nama ranah).

Sekarang dalam waktu anda di jaringan anda mungkin menemukan keindahan seperti `ME2/Sites/dirmod.htm?sid=&type=gen&mod=Core+Pages&gid=A6CD4967199A42D9B65B1B`. Anda akan senang mengetahuinya bahwa Django mengizinkan kami lebih elegan URL patterns daripada itu.

Sebuah pola URL adalah bentuk umum dari URL - sebagai contoh: `/newsarchive/<year>/<month>/`.

Untuk mendapatkan URL dari tampilan (view), Django menggunakan yang disebut 'URLconfs'. Sebuah URLconf memetakan pola URL ke views.

Tutorial ini menyediakan perintah dasar dalam menggunakan URLconf, dan anda dapat mengacu pada Pengirim URL untuk informasi lebih.

## Menulis tampilan lebih

Sekarang mari kita menambahkan tampilan lebih pada `polls/views.py`. Tampilan ini sedikit berbeda karena mereka mangambil argumen:

`polls/views.py`

    def detail(request, question_id):
        return HttpResponse("You're looking at question %s." % question_id)

    def results(request, question_id):
        response = "You're looking at the results of question %s."
        return HttpResponse(response % question_id)

    def vote(request, question_id):
        return HttpResponse("You're voting on question %s." % question_id)

Ikat tampilan-tampilan baru ini kedalam modul `polls.urls` dengan menambahkan panggilan `path()` berikut:

`polls/urls.py`

    from django.urls import path

    from . import views

    urlpatterns = [
        # ex: /polls/
        path("", views.index, name="index"),
        # ex: /polls/5/
        path("<int:question_id>/", views.detail, name="detail"),
        # ex: /polls/5/results/
        path("<int:question_id>/results/", views.results, name="results"),
        # ex: /polls/5/vote/
        path("<int:question_id>/vote/", views.vote, name="vote"),
    ]

Take a look in your browser, at "/polls/34/". It'll run the `detail()` function and display whatever ID you provide in the URL. Try "/polls/34/results/" and "/polls/34/vote/" too -- these will display the placeholder results and voting pages.

When somebody requests a page from your website -- say, "/polls/34/", Django will load the `mysite.urls` Python module because it's pointed to by the `ROOT_URLCONF` setting. It finds the variable named `urlpatterns` and traverses the patterns in order. After finding the match at `'polls/'`, it strips off the matching text (`"polls/"`) and sends the remaining text -- `"34/"` -- to the 'polls.urls' URLconf for further processing. There it matches `'<int:question_id>/'`, resulting in a call to the `detail()` view like so:

    detail(request=<HttpRequest object>, question_id=34)

Bagian `question_id=34` datang dari `<int:question_id>`. Menggunakan kurung sudut "menangkap" bagian dari URL dan mengirimnya sebagai argumen kata kunci ke fungsi tampilan. Bagian``question_id`` dari string menentukan nama yang akan digunakan untuk mencirikan pola cocok, dan bagian `int` adalah merubah yang menentukan pola apa yang harus cocok pada bagian ini dari jalur URL. Titik dua (`:`) memisahkan perubah dan pola nama.

## Tulis tampilan yang sebenarnya melakukan sesuatu

Setiap tampilan bertanggung jawab untuk melakukan satu dari dua hal: mengembalikan sebuah obyek `HttpResponse` mengandung isi untuk halaman diminta, atau menimbulkan sebuah pengecualian seperti `Http404`. Sisanya terserah anda.

Tampilan anda dapat membaca rekaman dari basisdata, atau tidak. Dia dapat menggunakan cetakan sistem seperti DJango -- atau sistem cetakan Phyton pihak-ketiga -- atau tidak. Dia dapat membangkitkan berkas PDF, mengeluarkan XML, membuat berkas ZIP dengan cepat, apapun anda inginkan, menggunakan pustaka Phyton apapun anda inginkan.

Semua Django inginkan adalah `HttpResponse`. Atau sebuah pengecualian.

Karena sangat nyaman, mari kita menggunakan API basisdata Django sendiri, yang akan melingkupi di Tutorial 2. Ini satu tikaman pada tampilan `index()` baru, yang menampilka pertanyaan jejak pendapat 5 terakhir di sistem, dipisahkan oleh koma, menurut tanggal penerbitan:

`polls/views.py`

    from django.http import HttpResponse

    from .models import Question

    def index(request):
        latest_question_list = Question.objects.order_by("-pub_date")[:5]
        output = ", ".join([q.question_text for q in latest_question_list])
        return HttpResponse(output)

    # Leave the rest of the views (detail, results, vote) unchanged

There's a problem here, though: the page's design is hardcoded in the view. If you want to change the way the page looks, you'll have to edit this Python code. So let's use Django's template system to separate the design from Python by creating a template that the view can use.

Pertama, buat direktori disebut `templates` di direktori``polls``. Django akan mencari cetakan disana.

Pengaturan `TEMPLATES` proyek anda menggambarkan bagaimana Django akan memuat dan membuat halaman. Pengaturan awal berkas mengkonfigurasikan backend `DjangoTemplates` yang pilihan `APP_DIRS` adalah disetel ke `True`. Berdasarkan kaidah `DjangoTemplates` mencari untuk subdirektori :cetakan" dalam setiap `INSTALLED_APPS`.

Dalam direktori `templates` anda telah buat, buat direktori lain disebut `polls`, dan didalamnya buat sebuah berkas dipanggil `index.html`. Dengan kata lain, cetakan anda harus di `polls/templates/polls/index.html`. Karena bagaimana pemuat cetakan `app_directories` bekerja seperti digambarkan diatas, anda dapat mengacu pada cetakan ini dalam Django sebagai `polls/index.html`.

Namespacing cetakan

Sekarang kami mungkin dapat lolos dengan menaruh cetakan kami secara langsung dalam `polls/templates` (daripada membuat subdirektori `polls` lain). tetapi itu sebenarnya ide buruk. Django akan memilih cetakan pertama dia temukan yang namanya cocok, dan jika anda memiliki cetakan dengan nama sana dalam aplikasi berbeda, Django tidak dapat membedakan mereka. Kami butuh dapat menunjuk Django pada satuyang benar, dan cara terbaik adalah memastikan ini dengan namespace merena. Yaitu, dengan menaruh cetakan tersebut didalam direktori lain bernama aplikasi itu sendiri.

Taruh kode berikut di cetakan itu:

`polls/templates/polls/index.html`

    {% if latest_question_list %}
        <ul>
        {% for question in latest_question_list %}
            <li><a href="/polls/{{ question.id }}/">{{ question.question_text }}</a></li>
        {% endfor %}
        </ul>
    {% else %}
        <p>No polls are available.</p>
    {% endif %}

Catatan

Untuk membuat tutorial lebih pendek, semua contoh cetakan menggunakan HTML tidak lengkap. Dalam proyek anda sendiri anda harus menggunakan complete HTML documents.

Sekarang mari kita perbaharui tampilan `index` di `polls/views.py` untuk menggunakan cetakan:

`polls/views.py`

    from django.http import HttpResponse
    from django.template import loader

    from .models import Question

    def index(request):
        latest_question_list = Question.objects.order_by("-pub_date")[:5]
        template = loader.get_template("polls/index.html")
        context = {"latest_question_list": latest_question_list}
        return HttpResponse(template.render(context, request))

Kode memuat cetakan disebut `polls/index.html` dan melewatkannya ke konteks. Konteks adalah kamus variabel cetakan pemetaan dinamai untuk obyek Phyton.

Muat halaman dengan menunjuk perambah anda pada "/polls/", dan anda akan melihat daftar-bullet mengandung pertanyaan "Ada apa" dari Tutorial 2. Tautan menunjuk ke halaman rincian pertanyaan.

### Jalan pintas: `render()`

Itu adalah dialek umum untuk memuat cetakan, isi konteks dan mengembalikan sebuah obyek `HttpResponse` dengan hasil dari cetakan dibuat. Django menyediakan jalan pintas. Disini tampilan `index()` penuh, ditulis kembali:

`polls/views.py`

    from django.shortcuts import render

    from .models import Question

    def index(request):
        latest_question_list = Question.objects.order_by("-pub_date")[:5]
        context = {"latest_question_list": latest_question_list}
        return render(request, "polls/index.html", context)

Catat bahwa sekali kami telah selesaikan ini di semua tampilan ini, kami tidak lagi butuh mengimpor `loader` dan `HttpResponse` (anda akan ingin menjaga `HttpResponse` jika anda masih mempunyai potongan cara untuk `detail`, `results`, dan `vote`).

Fungsi `render()` mengambil permintaan obyek sebagai argumen pertamanya, nama cetakan sebagai argumen keduanya dan kamus sebagai pilihan argumen ketiganya. Dia mengembalikan sebuah obyek `HttpResponse` dari cetakan diberikan dibangun dengan konteks yang diberikan.

## Menaikkan kesalahan 404

Sekarang, mari kita mengerjakan tampilan rincian pertanyaan -- halaman yang menampilkan teks pertanyaan untuk jejak pertanyaan yang diberikan. Inilah tampilan:

`polls/views.py`

    from django.http import Http404
    from django.shortcuts import render

    from .models import Question

    # ...
    def detail(request, question_id):
        try:
            question = Question.objects.get(pk=question_id)
        except Question.DoesNotExist:
            raise Http404("Question does not exist")
        return render(request, "polls/detail.html", {"question": question})

Konsep baru disini: Tapilan memunculkan pengecualian `Http404` jika sebuah pertanyaan dengan ID diminta tidak ada.

Kami akan berunding apa anda dapat taruh di cetakan `polls/detail.html` itu kemudian, tetapi jika anda suka mendapatkan cepat contoh diatas bekerja, sebuah berkas mengandung hanya:

`polls/templates/polls/detail.html`

    {{ question }}

akan membantu anda mulai untuk sekarang.

### Jalan pintas: `get_object_or_404()`

Adalah dialek umum untuk menggunakan `get()` dan menimbulkan `Http404` jika obyek tidak ada. Django menyediakan jalan pintas. Ini tampilan detail()`, ditulis kembali:

`polls/views.py`

    from django.shortcuts import get_object_or_404, render

    from .models import Question

    # ...
    def detail(request, question_id):
        question = get_object_or_404(Question, pk=question_id)
        return render(request, "polls/detail.html", {"question": question})

Fungsi `get_object_or_404()` mengambil model Django sebagai argumen pertamanya dan angka sewenang-wenang dari kata kunci argumen, yang dia melalui fungsi `get()` dari pengelola model. Dia menimbulkan `Http404` jika obyek tidak ada.

Filosofi

Kenapa kami menggunakan fungsi pembantu `get_object_or_404()` daripada otomatis menangkap pengecualian `ObjectDoesNotExist` pada tingkatan lebih tinggi, atau mempunyai API model menimbulkan `Http404` daripada `ObjectDoesNotExist`?

Karena itu akan memasangkan lapisan model ke lapisan tampilan. Satu dari terutama sasaran rancangan dari Django adalah merawat sambungan longgar. Beberapa sambungan terkendali diperkenalkan di modul `django.shortcuts`.

Terdapat juga sebuah fungsi `get_list_or_404()`, yang bekerja hanya sebagai `get_object_or_404()` -- kecuali menggunakan `filter()` daripada `get()`. Itu memunculkan `Http404` jika daftar kosong.

## Gunakan sistem cetakan

Kembali ke tampilan `detail()` untuk aplikasi jejak pendapat kami. Diberikan variabel konteks `question`, disini adalah apa cetakan `polls/detail.html` mungkin kelihatan seperti:

`polls/templates/polls/detail.html`

    <h1>{{ question.question_text }}</h1>
    <ul>
    {% for choice in question.choice_set.all %}
        <li>{{ choice.choice_text }}</li>
    {% endfor %}
    </ul>

Sistem cetakan menggunakan sintaks dot-lookup untuk mengakses atribut variabel. Di contoh dari `{{ question.question_text }}`, pertama Django melakukan lookup perkamusan pada obyek `question`. Kegagalan itu, dia mencoba sebuah atribut lookup -- yang bekerja, di kasus ini. Jika atribut lookup telah gagal, dia akan mencoba list-index lookup.

Pemanggilan-cara terjadi di `{% for %}` loop: `question.choice_set.all` adalah ditafsirkan sebagai kode Phyton `question.choice_set.all()`, yang mengembalikan berulang obyek `Choice` dan cocok untuk digunakan di etiket `{% for %}`.

Lihat panduan cetakan untuk lebih tentang cetakan.

## Memindahkan URL kode keras di cetakan

Ingat, ketika kami menulis tautan ke pertanyaan di cetakan `polls/index.html`, tautan sebagian dikodekan keras seperti ini:

    <li><a href="/polls/{{ question.id }}/">{{ question.question_text }}</a></li>

The problem with this hardcoded, tightly-coupled approach is that it becomes challenging to change URLs on projects with a lot of templates. However, since you defined the `name` argument in the `path()` functions in the `polls.urls` module, you can remove a reliance on specific URL paths defined in your url configurations by using the `{% url %}` template tag:

    <li><a href="{% url 'detail' question.id %}">{{ question.question_text }}</a></li>

Cara ini bekerja adalah dengan mencari pengertian URL seperti yang ditentukan di modul `polls.urls`. Anda dapat melihat sebenarnya dimana nama URL dari 'rincian' ditentukan dibawah:

    ...
    # the 'name' value as called by the {% url %} template tag
    path("<int:question_id>/", views.detail, name="detail"),
    ...

Jika anda ingin merubah URL dari tampilan rinci jejak pendapat ke sesuatu lain, mungkin ke sesuatu seperti `polls/specifics/12/` dibandingkan melakukannya di cetakan (atau cetakan-cetakan) anda akan merubahnya di `polls/urls.py`:

    ...
    # added the word 'specifics'
    path("specifics/<int:question_id>/", views.detail, name="detail"),
    ...

## Nama URL namespacing

Proyek tutorial hanya punya satu aplikasi, `polls`. Di proyek Django nyata, mungkin ada lima, sepuluh, dua puluh aplikasi atau lebih. Bagaimana Django membedakan nama URL diantara mereka? Sebagai contoh, aplikasi `polls` mempunyai tampilan `detail`, dan mungkin sebuah aplikasi di proyek sama yaitu untuk sebuah blog. Bagaimana satu membuatnya sehingga Django mengetahui tampilan aplikasi mana untuk membuat untuk sebuah url ketika menggunakan etiket cetakan `{% url %}`?

Jawabannya adalah menambahkan namespace ke URLconf anda. Di berkas `polls/urls.py`, lanjutkan dan tambah `app_name` untuk mengatur namespace aplikasi:

`polls/urls.py`

    from django.urls import path

    from . import views

    app_name = "polls"
    urlpatterns = [
        path("", views.index, name="index"),
        path("<int:question_id>/", views.detail, name="detail"),
        path("<int:question_id>/results/", views.results, name="results"),
        path("<int:question_id>/vote/", views.vote, name="vote"),
    ]

Sekarang rubah cetakan `polls/index.html` anda dari:

`polls/templates/polls/index.html`

    <li><a href="{% url 'detail' question.id %}">{{ question.question_text }}</a></li>

untuk menunjuk tampilan rincian namespace:

`polls/templates/polls/index.html`

    <li><a href="{% url 'polls:detail' question.id %}">{{ question.question_text }}</a></li>

Ketika anda nyaman dengan menulis tampilan, baca part 4 of this tutorial untuk mempelajari dasar tentang pengolahan formulir dan tampilan umum.