Django Dinamik Routing (Dynamic URL Routing)

Django'da Dinamik Routing (Dinamik Yönlendirme), URL yapılarının sabit metinler yerine değişken veriler (ID, kullanıcı adı, slug vb.) kabul etmesini sağlayan güçlü bir özelliktir. Bu makalede, Django projelerinizde dinamik URL'leri nasıl tanımlayacağınızı ve bu verileri view fonksiyonlarında nasıl işleyeceğinizi adım adım inceleyeceğiz.

Dinamik Routing Nedir?

Dinamik routing, URL (adres) içinde değişken parametreler kullanarak farklı içeriklere ulaşmayı sağlayan yapıdır.
Örneğin:

/blog/1/
/blog/2/
/urun/telefon/
/kullanici/nuri/

Bu URL’lerin tamamı tek bir view tarafından yönetilebilir.

Django’da bu sistem, urls.py dosyasında path converters kullanılarak yapılır.

Django’da Routing Mantığı

Django şu dosya yapısını kullanır:

project/
 ├─ project/
 │   ├─ urls.py   ← ANA YÖNLENDİRME
 ├─ app/
 │   ├─ urls.py   ← UYGULAMA YÖNLENDİRMESİ
 │   ├─ views.py

Akış sırası:

URL → urls.py → view → template → response

Statik vs Dinamik URL

Statik URL

path("about/", views.about)

➡️ Sadece tek bir sayfa açar

Dinamik URL

path("blog/<int:id>/", views.blog_detail)

➡️ ID’ye göre farklı içerikler açar

Django Path Converter Türleri

Converter	Açıklama	Örnek
`int`	Tam sayı	`<int:id>`
`str`	Metin (boşluk hariç)	`<str:username>`
`slug`	SEO uyumlu	`<slug:slug>`
`uuid`	UUID	`<uuid:uid>`
`path`	/ dahil her şey	`<path:route>`

Basit Dinamik Routing Örneği

urls.py

from django.urls import path
from . import views

urlpatterns = [
    path("hello/<str:name>/", views.say_hello),
]

views.py

from django.http import HttpResponse

def say_hello(request, name):
    return HttpResponse(f"Merhaba {name}")

📌 URL:

/hello/Ali/

📌 Çıktı:

Merhaba Ali

Birden Fazla Parametre Kullanımı

urls.py

path("not/<str:ders>/<int:puan>/", views.not_goster)

views.py

def not_goster(request, ders, puan):
    return HttpResponse(f"{ders} dersinden {puan} aldın")

📌 URL:

/not/matematik/85/

Template İçinde Dinamik URL Kullanımı

urls.py

path("ogrenci/<int:id>/", views.ogrenci_detay, name="ogrenci")

template.html

<a href="{% url 'ogrenci' 5 %}">Öğrenci Detay</a>

➡️ Django otomatik olarak:

/ogrenci/5/

URL’sini üretir.

Model + Dinamik Routing (Gerçek Hayat Örneği)

models.py

class Blog(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()

urls.py

path("blog/<int:id>/", views.blog_detail)

views.py

from .models import Blog

def blog_detail(request, id):
    blog = Blog.objects.get(id=id)
    return render(request, "blog_detail.html", {"blog": blog})

slug Kullanımı (SEO Dostu)

urls.py

path("blog/<slug:slug>/", views.blog_detail)

models.py

slug = models.SlugField(unique=True)

📌 URL:

/blog/django-routing-egitimi/

Hata Yönetimi (404 Önleme)

from django.shortcuts import get_object_or_404

def blog_detail(request, id):
    blog = get_object_or_404(Blog, id=id)

✔️ Kayıt yoksa otomatik 404 döner

Dinamik Routing – Veri Akışı Diyagramı

Tarayıcı
   ↓
/blog/3/
   ↓
urls.py  → <int:id>
   ↓
views.py → id = 3
   ↓
Model (Blog)
   ↓
Template

En Sık Yapılan Hatalar

❌ Parametre adını view’da unutmak
❌ int yerine str kullanmak
❌ Template’te {% url %} parametre sayısını yanlış vermek
❌ Slug benzersiz yapmamak

Özet

✔ Django’da dinamik routing
✔ URL’den veri alma
✔ View’a parametre gönderme
✔ Template’te URL üretme
✔ SEO uyumlu slug kullanımı

1. Dinamik Routing Nedir?

Statik bir URL sadece belirli bir sayfaya gider (örn: /hakkimizda/). Ancak bir e-ticaret sitesinde binlerce ürün olduğunu düşünürsek, her ürün için ayrı bir URL kuralı yazmak imkansızdır. Bunun yerine /urun/1/, /urun/2/ gibi değişken yapıları tek bir kalıpla yakalarız.

Django'da bu işlem path() fonksiyonu içinde Angle Brackets < > kullanılarak yapılır.

2. Temel Yazım Kuralı ve Veri Tipleri

Dinamik bir URL tanımlarken şu formatı kullanırız:

path('sayfa/<veri_tipi:degisken_adi>/', views.fonksiyon_adi)

Django'da en sık kullanılan Path Converters (Yol Dönüştürücüler) şunlardır:

Dönüştürücü	Açıklama	Örnek
`str`	`/` işareti hariç her türlü metni kabul eder (Varsayılandır).	`<str:kullanici_adi>`
`int`	Sadece tam sayıları kabul eder. ID işlemleri için idealdir.	`<int:urun_id>`
`slug`	Harf, rakam, tire ve alt çizgi içeren metinleri kabul eder.	`<slug:yazi_basligi>`
`uuid`	Benzersiz tanımlayıcıları (UUID) kabul eder.	`<uuid:token>`
`path`	`/` işareti dahil tüm dizin yapısını kabul eder.	`<path:dosya_yolu>`

3. Uygulama Örneği

Bir blog uygulaması senaryosu üzerinden ilerleyelim.

Adım 1: `urls.py` Yapılandırması

urls.py dosyanızda dinamik parametreyi tanımlayın:

Python:
from django.urls import path
from . import views

urlpatterns = [
    # Sayısal bir ID bekleyen dinamik URL
    path('makale/<int:id>/', views.makale_detay, name='makale_detay'),
    
    # Metin tabanlı (slug) bir dinamik URL
    path('kategori/<slug:slug_adi>/', views.kategori_listesi, name='kategori_filtre'),
]

Adım 2: `views.py` İçinde Veriyi Karşılama

URL'de tanımladığınız değişken adını, view fonksiyonuna parametre olarak geçmeniz gerekir.

Python:
from django.shortcuts import render
from django.http import HttpResponse

def makale_detay(request, id):
    # Burada veritabanından 'id' değerine göre sorgu yapılabilir
    return HttpResponse(f"{id} numaralı makalenin detayları gösteriliyor.")

def kategori_listesi(request, slug_adi):
    return HttpResponse(f"{slug_adi} kategorisindeki yazılar listeleniyor.")

4. Dinamik URL'lerin Avantajları

Kod Tekrarını Önler: Tek bir view ile binlerce farklı sayfayı yönetebilirsiniz.
SEO Dostu Yapılar: ?id=5 yerine /rehber/django-dersleri/ gibi okunabilir URL'ler oluşturmanıza olanak tanır.
Veri Güvenliği: int gibi dönüştürücüler kullanarak, beklenen veri tipinin dışında bir giriş yapıldığında Django otomatik olarak 404 Hatası döndürür.

5. Özet ve İpucu

Dinamik yönlendirme yaparken değişken isimlerinin urls.py ve views.py içerisinde birebir aynı olduğundan emin olun.

Not: Eğer bir URL içerisinde birden fazla dinamik alan kullanmak isterseniz bunu şu şekilde yapabilirsiniz:
path('arsiv/<int:yil>/<str:ay>/', views.arsiv_gorunumu)

Harika! Blog sayfanız için içeriği bir adım öteye taşıyalım. Dinamik URL'den gelen veriyi (örneğin bir ID) kullanarak veritabanından nasıl gerçek veri çekebileceğimizi ve bunu bir template (şablon) içine nasıl aktaracağımızı inceleyelim.

6. Dinamik URL ile Veritabanı Entegrasyonu (Models)

Dinamik routing'in asıl gücü, URL'den gelen parametreyi veritabanı sorgularında filtre olarak kullanabilmemizdir.

Adım 1: Bir Modelimiz Olduğunu Varsayalım

models.py dosyanızda basit bir makale modeliniz olduğunu düşünelim:

Python
from django.db import models

class Makale(models.Model):
    baslik = models.CharField(max_length=200)
    icerik = models.TextField()
    eklenme_tarihi = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.baslik

Adım 2: View İçinde Dinamik Sorgulama

URL'den gelen id değerini kullanarak veritabanından ilgili kaydı getireceğiz. Eğer kayıt yoksa, Django'nun meşhur get_object_or_404 fonksiyonu ile güvenli bir hata döndüreceğiz.

views.py:

Python
from django.shortcuts import render, get_object_or_404
from .models import Makale

def makale_detay(request, id):
    # URL'den gelen id ile veritabanında sorgu yapıyoruz
    # Kayıt bulunamazsa otomatik 404 sayfası döner
    makale = get_object_or_404(Makale, id=id)
    
    context = {
        'makale': makale
    }
    return render(request, 'makale_detay.html', context)

Adım 3: Template (HTML) İçinde Gösterim

Dinamik olarak çekilen veriyi kullanıcıya gösterelim.

templates/makale_detay.html:

HTML
<!DOCTYPE html>
<html>
<head>
    <title>{{ makale.baslik }}</title>
</head>
<body>
    <h1>{{ makale.baslik }}</h1>
    <p><em>Yayınlanma: {{ makale.eklenme_tarihi }}</em></p>
    <hr>
    <div>
        {{ makale.icerik }}
    </div>
    <a href="/">Anasayfaya Dön</a>
</body>
</html>

7. Kritik İpucu: URL İsimlendirme ve Dinamik Linkler

Blogunuzda bir makaleye link verirken URL'yi elle yazmak (/makale/5/ gibi) yerine, Django'nun url etiketini kullanmalısınız. Bu sayede ileride URL yapısını değiştirseniz bile linkleriniz bozulmaz.

Template içinde link oluşturma:

HTML
<a href="{% url 'makale_detay' id=makale.id %}">Makaleyi Oku</a>

8. Özet Akış Şeması

İstek Gelir: Kullanıcı /makale/12/ adresine gider.
Routing: urls.py içindeki <int:id> kuralı 12 değerini yakalar.
View Çalışır: makale_detay(request, id=12) fonksiyonu tetiklenir.
Sorgu: Veritabanında ID'si 12 olan satır bulunur.
Yanıt: Veriler HTML şablonuna yerleştirilir ve kullanıcıya sunulur.

Profesyonel Tavsiye: SEO uyumlu bir blog için int yerine slug kullanmanızı öneririm. Örneğin /makale/12/ yerine /makale/django-ogreniyorum/ çok daha profesyonel duracaktır.

Harika! Pardus da öğrencilerin kendi notlarına veya performanslarına kolayca erişebileceği bir "Öğrenci Bilgi Sistemi" senaryosu, konuyu pekiştirmek için mükemmel bir örnek olacaktır.

9. Uygulama: Pardus İçin Öğrenci Not Sorgulama Sistemi

Bu örnekte, bir öğretmenin Pardus ETAP yüklü akıllı tahtada, öğrencilerin okul numaralarına göre notlarını dinamik olarak nasıl listeleyebileceğini kurgulayalım.

Adım 1: URL Yapısını Belirleme

Öğrencinin okul numarasını URL'den alacak şekilde urls.py dosyamızı güncelleyelim:

Python
from django.urls import path
from . import views

urlpatterns = [
    # Örn: /ogrenci/1453/ -> 1453 numaralı öğrencinin notlarını getirir
    path('ogrenci/<int:okul_no>/', views.ogrenci_not_detay, name='ogrenci_detay'),
]

Adım 2: Veritabanı Sorgusu ve Logic (Views)

Pardus ETAP üzerinde çalışan bu sistemde, gelen okul_no parametresi ile öğrenciyi bulup bilgilerini template'e göndereceğiz.

views.py:

Python
from django.shortcuts import render, get_object_or_404
from .models import Ogrenci

def ogrenci_not_detay(request, okul_no):
    # Okul numarasına göre öğrenciyi getiriyoruz
    ogrenci = get_object_or_404(Ogrenci, numara=okul_no)
    
    context = {
        'ogrenci': ogrenci,
        'baslik': f"{ogrenci.ad_soyad} - Not Çizelgesi"
    }
    return render(request, 'ogrenci_not.html', context)

Adım 3: ETAP Uyumlu Arayüz (Template)

Akıllı tahtalarda (ETAP) okunabilirliği artırmak için büyük puntolar ve net tablolar kullanmak önemlidir.

templates/ogrenci_not.html:

HTML
<div style="font-family: 'Pardus', sans-serif; padding: 20px;">
    <h2 style="color: #2c3e50;">{{ baslik }}</h2>
    
    <table border="1" style="width: 100%; text-align: center; font-size: 24px;">
        <tr style="background-color: #f8f9fa;">
            <th>Ders</th>
            <th>1. Yazılı</th>
            <th>2. Yazılı</th>
            <th>Performans</th>
        </tr>
        <tr>
            <td>Nesne Tabanlı Programlama</td>
            <td>{{ ogrenci.not1 }}</td>
            <td>{{ ogrenci.not2 }}</td>
            <td>{{ ogrenci.perf }}</td>
        </tr>
    </table>
    
    <br>
    <a href="/" style="font-size: 20px;">⬅️ Listeye Geri Dön</a>
</div>

10. Pardus ETAP 23 İçin İpucu

Pardus ETAP 23 üzerinde geliştirdiğiniz bu projeyi dokunmatik ekranda test ederken, dinamik linklerin (butonların) tıklama alanını büyük tutmaya özen gösterin. CSS tarafında padding değerlerini artırmak, tahta başında işlem yapan öğrenciler ve öğretmenler için büyük kolaylık sağlayacaktır.

Sonuç

Django'da dinamik routing sayesinde:

Her veri için ayrı sayfa yapma zahmetinden kurtulduk.
Veritabanı ile URL'leri birbirine bağladık.
Hem blog siteleri hem de okul içi projeler için profesyonel bir yapı kurduk.