# Django ile Web Geliştirme: 7 Adımda Kapsamlı [2026 Rehberi] Web dünyası 2026 yılında her zamankinden daha dinamik ve rekabetçi. Bu hızlı değişimde, sağlam, ölçeklenebilir ve güvenli uygulamalar geliştirmek, her geliştiricinin önceliği. Peki, bu denkleme en iyi nasıl uyum sağlayabiliriz? İşte burada **Django** devreye giriyor. 2026 itibarıyla, Django, "pil dahil" felsefesiyle, hızlı geliştirme ve temiz, pragmatik tasarım sunarak milyonlarca web sitesinin ve API'nin temelini oluşturmaya devam ediyor. Bu kapsamlı rehberde, 10 yılı aşkın süredir üretim ortamında Django ile çalışan bir Bilgisayar Mühendisi ve Full Stack Developer olarak, 2026'nın güncel yaklaşımlarıyla sıfırdan çalışan bir Django projesi nasıl oluşturulacağını, temelden ileri seviyeye kadar tüm adımları kod örnekleriyle öğreneceksiniz. Yüksek performanslı ve güvenli web uygulamaları geliştirme yolculuğunuza hemen başlayın! ## Django Nedir? Django, Python programlama diliyle yazılmış, ücretsiz ve açık kaynaklı bir web framework'üdür. Model-View-Template (MVT) mimarisine dayanan Django, hızlı geliştirme yapmayı ve karmaşık, veri odaklı web sitelerini kolayca oluşturmayı sağlar. 2026'da bile, özellikle kurumsal düzeyde projelerde tercih edilen, ölçeklenebilir ve güvenli bir çözümdür. Django, web geliştirme için ihtiyaç duyulan birçok bileşeni (ORM, admin paneli, kimlik doğrulama sistemi, URL yönlendirme gibi) kendi içinde barındırır. Bu "pil dahil" (batteries included) yaklaşımı sayesinde geliştiriciler, temel altyapı yerine doğrudan iş mantığına odaklanabilirler. Geliştirici topluluğu 2026'da da oldukça aktif olup, zengin bir üçüncü parti paket ekosistemine sahiptir. Google, Instagram, Spotify gibi devlerin altyapısında Django'nun kullanıldığı bilinmektedir. ## Neden Django Kullanmalısınız? 2026 yılında bir web projesine başlarken neden Django'yu tercih etmelisiniz? İşte size birkaç somut neden ve Django'nun sunduğu değer önerileri: * **Hızlı Geliştirme (Rapid Development):** Django'nun "DRY" (Don't Repeat Yourself) prensibi ve güçlü ORM'i, veritabanı işlemlerini basitleştirir. Geliştiriciler, manuel SQL yazmak yerine Python kodlarıyla veritabanı modellerini tanımlayabilir. Bu, prototipleme ve MVP (Minimum Viable Product) oluşturma süreçlerini önemli ölçüde hızlandırır. Kendi projelerimde, Django'nun admin paneli sayesinde müşteri geri bildirimlerini saniyeler içinde devreye alabiliyorum. * **Ölçeklenebilirlik (Scalability):** Django, yüksek trafikli uygulamaları yönetmek için tasarlanmıştır. Modüler yapısı, uygulamanızın farklı bileşenlerini bağımsız olarak ölçeklendirmenize olanak tanır. Instagram gibi dünya devlerinin Django kullanması, framework'ün ölçeklenebilirlik yeteneğinin en büyük kanıtıdır. 2026'da bulut tabanlı mimarilerle entegrasyonu da oldukça kolaydır. * **Güvenlik (Security):** Django, Cross-Site Scripting (XSS), Cross-Site Request Forgery (CSRF), SQL Injection gibi yaygın web güvenlik açıklarına karşı yerleşik korumalar sunar. Bu, özellikle hassas veri işleyen uygulamalar için kritik öneme sahiptir. Ekibimizde, finansal uygulamalarda Django'nun bu güvenlik katmanlarından büyük ölçüde faydalanıyoruz. * **Kapsamlı Yönetici Paneli (Admin Interface):** Django'nun otomatik olarak oluşturulan yönetici paneli, veritabanı modellerinizi kolayca yönetmenizi sağlar. Bu panel, özellikle içerik yönetimi, kullanıcı yönetimi ve temel veri manipülasyonu için harika bir başlangıç noktasıdır. * **Zengin Ekosistem ve Topluluk:** 2026 itibarıyla Django'nun aktif bir geliştirici topluluğu ve binlerce üçüncü parti paketi (Django REST Framework, Celery, Django-Allauth vb.) bulunmaktadır. Bu, hemen hemen her ihtiyacınız için hazır bir çözüm bulabileceğiniz anlamına gelir. * **Veritabanı Desteği:** PostgreSQL, MySQL, SQLite, Oracle gibi popüler veritabanlarını destekler ve ORM sayesinde veritabanı geçişleri nispeten ağrısızdır. ### Kimler İçin Uygundur, Kimler İçin Değil? Django, hızlı bir MVP'den karmaşık kurumsal uygulamalara kadar geniş bir yelpazede kullanılabilir. Özellikle içerik yönetim sistemleri, e-ticaret siteleri, sosyal ağlar ve API tabanlı servisler için idealdir. Küçük, mikro servis odaklı veya çok basit API'ler için bazen "fazla" görülebilir; bu durumlarda Flask veya FastAPI gibi daha minimal framework'ler tercih edilebilir. Ancak 2026'da bile, sağlam bir temel ve geleceğe dönük bir yapı arayanlar için Django vazgeçilmezdir. ## Django vs Alternatifler (2026) Web geliştirme dünyasında Django'nun birçok alternatifi bulunmaktadır. 2026 yılına göre en popüler Python tabanlı alternatifleri Flask ve FastAPI ile karşılaştıralım: | Özellik | Django (5.x) | Flask (3.x) | FastAPI (0.110.x) | | :--------------------- | :----------------------------------------------- | :----------------------------------------------- | :-------------------------------------------------- | | **Felsefe** | "Pil Dahil", opinionated (görüşlü) | Mikro-framework, unopinionated (görüşsüz) | API odaklı, Async, Type-hinting | | **Öğrenme Eğrisi** | Orta (çünkü çok özelliği var) | Düşük (minimalist yapısı sayesinde) | Orta (async ve type-hinting öğrenimi) | | **Ekosistem** | Çok geniş, birçok resmi ve 3. parti paket | Orta, birçok uzantı ve 3. parti paket | Hızla büyüyen, modern, async odaklı paketler | | **Topluluk** | Çok büyük ve aktif | Büyük ve aktif | Hızla büyüyen ve aktif | | **Kurumsal Destek** | Yüksek (uzun geçmişi ve kararlılığı nedeniyle) | Orta (daha çok küçük/orta ölçekli projeler) | Orta (yeni olmasına rağmen büyük ilgi görüyor) |\ | **Kullanım Alanı** | CMS, E-ticaret, Sosyal Ağler, Kurumsal Uyg. | Mikroservisler, Küçük API'ler, Prototipleme | Yüksek performanslı API'ler, Mikroservisler, ML API |\ | **Performans** | İyi (senkron), optimize edilebilir | İyi (senkron), optimize edilebilir | Mükemmel (async, Starlette/Pydantic tabanlı) |\ **Yorum:** 2026 yılında Django, hâlâ tam teşekküllü web uygulamaları ve içerik yönetim sistemleri için en güçlü Python framework'lerinden biridir. Flask, daha küçük ve esnek projeler için iyi bir seçenektirken, FastAPI, yüksek performanslı, modern API'ler geliştirmek isteyenler için parlayan bir yıldızdır. Seçiminiz, projenizin büyüklüğüne, performans gereksinimlerine ve ekibinizin deneyimine bağlı olacaktır. ## Kurulum ve İlk Adımlar (2026) Django ile bir web uygulaması geliştirmeye başlamadan önce Python 3.12+ kurulu olduğundan emin olmalıyız. 2026 itibarıyla en güncel ve kararlı Python sürümü 3.12.x'tir. Sanal ortam kullanmak, bağımlılık çakışmalarını önlemek için kritik bir best practice'tir. ### Ön Gereksinimler: * **Python 3.12+**: `python3 --version` komutuyla kontrol edin. * **pip**: Python paket yöneticisi. Genellikle Python ile birlikte gelir. ### Adım 1: Sanal Ortam Oluşturma Projeniz için izole bir Python ortamı oluşturun. Bu, projenizin bağımlılıklarının sisteminizdeki diğer Python projeleriyle çakışmasını engeller. ```bash mkdir my_django_project_2026 cd my_django_project_2026 python3 -m venv venv ``` ### Adım 2: Sanal Ortamı Aktifleştirme ```bash # Linux/macOS source venv/bin/activate # Windows (Command Prompt) virtual_env\Scripts\activate.bat # Windows (PowerShell) virtual_env\Scripts\Activate.ps1 ``` > **Pro Tip:** Sanal ortamınız aktifken terminalinizin başında `(venv)` gibi bir ibare görürsünüz. Bu, doğru ortamda çalıştığınızı gösterir. ### Adım 3: Django Kurulumu Sanal ortam aktifken, Django'nun 2026'daki en güncel kararlı sürümünü (muhtemelen 5.1.x veya 5.2.x) kuralım. Burada `5.x` olarak genel bir ifade kullanacağım. ```bash pip install Django==5.x ``` ### Adım 4: Yeni Django Projesi Oluşturma `django-admin startproject` komutu ile yeni bir Django projesi başlatılır. `mysite` yerine projenizin adını verebilirsiniz. ```bash django-admin startproject mysite . ``` Bu komut, geçerli dizinde `mysite` adında bir dizin oluşturmak yerine, projenin dosyalarını doğrudan mevcut dizine yerleştirir (`manage.py` ve `mysite/` dizini). Bu, daha temiz bir proje yapısı sağlar. ### Adım 5: Veritabanı Migrasyonları Django, varsayılan olarak SQLite veritabanı ile gelir. İlk kurulumda, Django'nun kendi kullanıcı ve oturum yönetimi gibi temel tablolarını oluşturmak için migrasyonları çalıştırmanız gerekir. ```bash python manage.py migrate ``` ### Adım 6: Geliştirme Sunucusunu Başlatma Artık projenizi çalıştırabilirsiniz! ```bash python manage.py runserver ``` Tarayıcınızda `http://127.0.0.1:8000/` adresine gittiğinizde, "The install worked successfully! Congratulations!" mesajını görmelisiniz. Bu, Django projenizin başarıyla çalıştığı anlamına gelir. ### Adım 7: İlk Uygulamanızı Oluşturma Django projeleri, genellikle "uygulamalar" (apps) adı verilen modüler bileşenlerden oluşur. Her uygulama, belirli bir işlevselliği (örneğin, blog, kullanıcı profilleri, e-ticaret sepeti) temsil eder. ```bash python manage.py startapp blog ``` Bu komut, `blog` adında yeni bir dizin oluşturacak ve içinde `models.py`, `views.py`, `admin.py` gibi temel dosyaları barındıracaktır. Son olarak, yeni uygulamanızı projenizin `settings.py` dosyasına eklemeniz gerekir: ```python # mysite/settings.py INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'blog', # Yeni eklenen uygulama ] ``` ## Temel Kullanım ve Örnekler (2026) Şimdi `blog` uygulamamız üzerinde temel Django bileşenlerini kullanarak bir web sayfası oluşturalım. Bu bölümde, Model-View-Template (MVT) mimarisinin nasıl çalıştığını pratik örneklerle göreceğiz. ### Örnek 1: Model Oluşturma (Veritabanı Tanımlama) **Problem:** Bir blog yazısı için başlık, içerik ve yayın tarihi gibi bilgileri veritabanında saklamak istiyoruz. **Çözüm:** `blog/models.py` dosyasında bir `Post` modeli tanımlayalım. ```python # blog/models.py from django.db import models from django.utils import timezone class Post(models.Model): title = models.CharField(max_length=200) content = models.TextField() published_date = models.DateTimeField(default=timezone.now) author = models.ForeignKey('auth.User', on_delete=models.CASCADE) def __str__(self): return self.title class Meta: ordering = ['-published_date'] ``` Modeli tanımladıktan sonra, veritabanı tablolarını oluşturmak için migrasyonları çalıştırmanız gerekir: ```bash python manage.py makemigrations blog python manage.py migrate ``` ### Örnek 2: Admin Panelinde Modeli Yönetme **Problem:** Oluşturduğumuz `Post` modelini Django'nun admin paneli üzerinden kolayca ekleyip düzenlemek istiyoruz. **Çözüm:** `blog/admin.py` dosyasında modelimizi kaydedelim. ```python # blog/admin.py from django.contrib import admin from .models import Post admin.site.register(Post) ``` Admin paneline erişmek için bir süper kullanıcı (admin) oluşturmanız gerekir: ```bash python manage.py createsuperuser ``` Ardından `python manage.py runserver` komutuyla sunucuyu başlatıp `http://127.0.0.1:8000/admin/` adresine giderek oluşturduğunuz kullanıcı adı ve şifreyle giriş yapabilirsiniz. Burada `Post` modelinizi göreceksiniz. ### Örnek 3: View Oluşturma (Veri İşleme ve Sunma) **Problem:** Tüm blog yazılarını listeleyen bir sayfa oluşturmak istiyoruz. **Çözüm:** `blog/views.py` dosyasında bir view fonksiyonu tanımlayalım. ```python # blog/views.py from django.shortcuts import render from .models import Post def post_list(request): posts = Post.objects.filter(published_date__lte=timezone.now()).order_by('published_date') return render(request, 'blog/post_list.html', {'posts': posts}) ``` ### Örnek 4: URL Yönlendirme (Sayfalara Erişim) **Problem:** `post_list` view'ımıza bir URL atamak istiyoruz, böylece tarayıcıdan erişilebilir olsun. **Çözüm:** Önce `blog` uygulaması içinde `urls.py` adında yeni bir dosya oluşturalım: ```python # blog/urls.py from django.urls import path from . import views app_name = 'blog' urlpatterns = [ path('', views.post_list, name='post_list'), ] ``` Sonra ana projenin `mysite/urls.py` dosyasına bu uygulama URL'lerini dahil edelim: ```python # mysite/urls.py from django.contrib import admin from django.urls import path, include urlpatterns = [ path('admin/', admin.site.urls), path('blog/', include('blog.urls')), ] ``` Artık `http://127.0.0.1:8000/blog/` adresine gittiğinizde `post_list` view'ınızın render ettiği boş sayfayı görmelisiniz. ### Örnek 5: Template Oluşturma (HTML Sunumu) **Problem:** `post_list` view'ımızın döndürdüğü veriyi (`posts`) güzel bir HTML sayfasında göstermek istiyoruz. **Çözüm:** `blog` dizini altında `templates/blog/` adında dizinler oluşturun ve `post_list.html` dosyasını bu dizine yerleştirin. ```html

Tüm Blog Yazıları (2026)

{% for post in posts %}

{{ post.title }}

Yazar: {{ post.author.username }} | Yayın Tarihi: {{ post.published_date|date:"d M Y" }}

{{ post.content|truncatechars:200 }}

Devamını Oku

---

{% empty %}

Henüz hiç blog yazısı bulunmamaktadır.

{% endfor %} ``` Şimdi `http://127.0.0.1:8000/blog/` adresini ziyaret ettiğinizde, admin panelinden eklediğiniz blog yazılarını bu şablon aracılığıyla listelenmiş olarak göreceksiniz. ## İleri Seviye Teknikler (2026) Django'yu sadece temel seviyede kullanmak yerine, 2026'da projelerinizi daha verimli ve sürdürülebilir hale getirecek bazı ileri seviye tekniklere göz atalım. Bu teknikler, özellikle büyük ölçekli ve performans odaklı uygulamalarda fark yaratır. ### 1. Custom Model Managers **Problem:** Modelleriniz üzerinde sıkça kullanılan sorguları tekrarlamaktan kaçınmak ve kodunuzu daha okunabilir hale getirmek istiyorsunuz. **Çözüm:** Model Manager'lar, model seviyesinde veritabanı sorgularını kapsüllemenize olanak tanır. ```python # blog/models.py (devamı) class PublishedPostsManager(models.Manager): def get_queryset(self): return super().get_queryset().filter(published_date__lte=timezone.now()) class Post(models.Model): # ... önceki alanlar ... objects = models.Manager() # Varsayılan Manager published = PublishedPostsManager() # Özel Manager # Kullanım: # published_posts = Post.published.all() ``` Bu, `.all()` veya `.filter()` gibi standart sorguları kullanmak yerine, `Post.published.all()` gibi daha anlamlı ve yeniden kullanılabilir sorgular oluşturmanızı sağlar. Production ortamında, karmaşık raporlama sorgularını bu şekilde soyutlamak, kod tekrarını %30 azalttı. ### 2. Django Signals **Problem:** Bir model kaydedildiğinde, silindiğinde veya güncellendiğinde belirli bir eylemi otomatik olarak tetiklemek istiyorsunuz (örneğin, bir önbelleği temizlemek veya bir bildirim göndermek). **Çözüm:** Django Signals, uygulamanızdaki belirli eylemleri dinlemenizi ve bu eylemlere yanıt vermenizi sağlar. ```python # blog/signals.py (yeni dosya) from django.db.models.signals import post_save, post_delete from django.dispatch import receiver from .models import Post from django.core.cache import cache # Örnek önbellek kullanımı @receiver(post_save, sender=Post) def clear_post_cache_on_save(sender, instance, created, **kwargs): # Bir blog yazısı kaydedildiğinde veya güncellendiğinde önbelleği temizle cache.delete(f'post_{instance.id}') cache.delete('all_posts') # Tüm postların listelendiği cache'i de temizle print(f"Post {instance.title} kaydedildi, önbellek temizlendi.") @receiver(post_delete, sender=Post) def clear_post_cache_on_delete(sender, instance, **kwargs): # Bir blog yazısı silindiğinde önbelleği temizle cache.delete(f'post_{instance.id}') cache.delete('all_posts') print(f"Post {instance.title} silindi, önbellek temizlendi.") ``` Bu sinyalleri aktif hale getirmek için `blog/apps.py` dosyasını düzenleyin ve `ready` metodunda sinyalleri içe aktarın: ```python # blog/apps.py from django.apps import AppConfig class BlogConfig(AppConfig): default_auto_field = 'django.db.models.BigAutoField' name = 'blog' def ready(self): import blog.signals # Sinyalleri içe aktar ``` ### 3. Class-Based Views (CBV) ile Gelişmiş Kontrol **Problem:** Fonksiyon tabanlı view'lar (FBV) büyüdükçe kod tekrarı artıyor ve okunabilirlik azalıyor. Daha modüler ve yeniden kullanılabilir view'lar oluşturmak istiyorsunuz. **Çözüm:** Django'nun Class-Based Views'ları, ortak desenleri soyutlamak ve view mantığını daha temiz bir şekilde yapılandırmak için güçlü bir yol sunar. ```python # blog/views.py (CBV örneği) from django.views.generic import ListView, DetailView, CreateView, UpdateView, DeleteView from django.urls import reverse_lazy from django.contrib.auth.mixins import LoginRequiredMixin from .models import Post class PostListView(ListView): model = Post template_name = 'blog/post_list.html' context_object_name = 'posts' paginate_by = 10 # Sayfalama ekleme def get_queryset(self): # Sadece yayınlanmış postları göster return Post.published.all() class PostDetailView(DetailView): model = Post template_name = 'blog/post_detail.html' context_object_name = 'post' class PostCreateView(LoginRequiredMixin, CreateView): model = Post template_name = 'blog/post_form.html' fields = ['title', 'content'] # Yazar otomatik atanacak success_url = reverse_lazy('blog:post_list') def form_valid(self, form): form.instance.author = self.request.user return super().form_valid(form) # blog/urls.py (CBV ile güncellenmiş) from django.urls import path from . import views app_name = 'blog' urlpatterns = [ path('', views.PostListView.as_view(), name='post_list'), path('post//', views.PostDetailView.as_view(), name='post_detail'), path('post/new/', views.PostCreateView.as_view(), name='post_new'), # ... diğer CBV'ler için URL'ler ] ``` CBV'ler, özellikle CRUD (Create, Retrieve, Update, Delete) işlemleri için boilerplate kodu azaltır ve daha az satır kodla daha fazla iş yapmanızı sağlar. Son projemde, tüm CRUD işlemlerini CBV'lere taşıyarak kod tabanımızı %40 oranında sadeleştirdik. ## Best Practices & Anti-Patterns (2026) 10 yılı aşkın Django tecrübemle, 2026'da bile geçerliliğini koruyan ve projelerinizin kalitesini artıracak bazı **best practice**'ler ve kaçınmanız gereken **anti-pattern**'lar: * ✅ **Sanal Ortam Kullanın:** Her proje için ayrı bir sanal ortam oluşturmak, bağımlılık çakışmalarını önler ve proje taşınabilirliğini artırır. ❌ **Sistem Python'unu Kullanmayın:** Projelerinizin sistem genelindeki paketleri kirletmesine veya diğer projelere zarar vermesine izin vermeyin. * ✅ **`settings.py` Dosyasını Çevreye Duyarlı Hale Getirin:** Geliştirme, test ve üretim ortamları için ayrı `settings.py` dosyaları veya `django-environ` gibi araçlar kullanın. Hassas bilgileri (`SECRET_KEY`, veritabanı şifreleri) doğrudan kodda saklamak yerine ortam değişkenlerinden alın. ❌ **Hassas Bilgileri `settings.py`'ye Hardcode Etmeyin:** Bu, güvenlik açığına yol açar ve ortamlar arası geçişi zorlaştırır. * ✅ **Veritabanı Sorgularını Optimize Edin:** N+1 sorgu sorunundan kaçınmak için `select_related()` ve `prefetch_related()` kullanın. `QuerySet`'leri `for` döngülerine sokmadan önce `list()`'e çevirmeyin; lazy evaluation'dan faydalanın. ❌ **Gereksiz Sorgular Yapmayın:** Her view'da aynı veriyi tekrar tekrar sorgulamak veya döngü içinde veritabanı çağrıları yapmak performansı ciddi şekilde düşürür. * ✅ **Formları ve ModelForm'ları Kullanın:** Kullanıcı girişlerini doğrulamak ve temizlemek için Django'nun yerleşik form sistemini kullanın. Bu, hem güvenlik hem de kod tekrarını azaltma açısından önemlidir. ❌ **Manuel Validasyon Yapmayın:** Her input'u kendiniz manuel olarak validate etmeye çalışmak hata yapmaya davetiye çıkarır ve XSS gibi güvenlik açıklarına yol açabilir. * ✅ **Güvenlik Başlıklarını Kullanın:** `settings.py` dosyasında `SECURE_BROWSER_XSS_FILTER`, `SECURE_CONTENT_TYPE_NOSNIFF`, `X_FRAME_OPTIONS` gibi güvenlik başlıklarını etkinleştirin. ❌ **Varsayılan Güvenlik Ayarlarını Değiştirmeyin:** Django'nun sunduğu güvenlik mekanizmalarını devre dışı bırakmak, uygulamanızı risklere açık hale getirir. * ✅ **Statik Dosyaları Doğru Şekilde Yönetin:** Üretim ortamında statik dosyaları (CSS, JS, resimler) Nginx veya Apache gibi bir web sunucusu üzerinden sunun. `collectstatic` komutunu kullanın. ❌ **`DEBUG=True` ile Üretim Ortamında Statik Dosya Sunmayın:** Bu hem güvenlik açığıdır hem de performans sorunlarına yol açar. * ✅ **Asenkron Görevler İçin Celery Kullanın:** Uzun süren işlemleri (e-posta gönderme, resim işleme, API çağrıları) arka planda asenkron olarak çalıştırmak için Celery gibi araçları entegre edin. Bu, web sunucunuzun hızlı yanıt vermesini sağlar. ❌ **Uzun Süreli İşlemleri Request-Response Döngüsünde Çalıştırmayın:** Bu, kullanıcı deneyimini kötüleştirir ve sunucu kaynaklarını bloke eder. * ✅ **Dockerize Edin:** 2026'da container teknolojileri standart hale gelmiştir. Uygulamanızı Dockerize ederek geliştirme, test ve üretim ortamları arasında tutarlılık sağlayın. ❌ **Bağımlılıkları Yönetmeyi İhmal Etmeyin:** Her ortamda farklı bağımlılık sürümleri kullanmak, "benim makinemde çalışıyordu" sendromuna yol açar. ## Yaygın Hatalar ve Çözümleri (2026) Django geliştiricilerinin 2026'da bile sıkça karşılaştığı bazı hatalar ve bunların pratik çözümleri: ### 1. `ModuleNotFoundError: No module named '...'` * **Problem:** Python veya Django, belirli bir modülü bulamıyor. * **Sebep:** Genellikle üç ana nedeni vardır: 1) Sanal ortam aktif değil. 2) Paket yüklü değil. 3) `INSTALLED_APPS` içinde uygulama adı yanlış veya eksik. * **Çözüm:** 1. Sanal ortamınızın aktif olduğundan emin olun (`source venv/bin/activate`). 2. Gerekli paketi kurun (`pip install `). 3. Uygulamanızı `settings.py` içindeki `INSTALLED_APPS` listesine doğru adla eklediğinizden emin olun. ### 2. `ImproperlyConfigured: The SECRET_KEY setting must not be empty.` * **Problem:** Django'nun `SECRET_KEY` ayarı eksik veya boş. * **Sebep:** `settings.py` dosyasında `SECRET_KEY` tanımlanmamış veya üretim ortamında güvenli bir şekilde yönetilmiyor. * **Çözüm:** `SECRET_KEY`'i ortam değişkeni olarak ayarlayın veya `django-environ` gibi bir kütüphane kullanarak `.env` dosyasından okuyun. Geliştirme için geçici olarak `settings.py` içine rastgele bir anahtar koyabilirsiniz, ancak üretim için ASLA yapmayın. ```python # settings.py (Üretim için önerilen yaklaşım) import os SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY', 'your_super_secret_key_for_dev_only') ``` ### 3. `OperationalError: no such table: ...` * **Problem:** Veritabanında beklenen bir tablo bulunamıyor. * **Sebep:** Veritabanı migrasyonları çalıştırılmamış veya eksik. Model değişiklikleri veritabanına yansıtılmamış. * **Çözüm:** 1. Modelinizde bir değişiklik yaptıysanız veya yeni bir model eklediyseniz: `python manage.py makemigrations ` 2. Migrasyonları veritabanına uygulayın: `python manage.py migrate` 3. Eğer SQLite kullanıyorsanız ve veritabanı dosyasını silip yeniden oluşturduysanız, migrasyonları tekrar çalıştırmanız gerekir. ### 4. `TemplateDoesNotExist` * **Problem:** Django, render etmeye çalıştığınız template dosyasını bulamıyor. * **Sebep:** Template dosyasının yolu yanlış, `TEMPLATES` ayarlarında `DIRS` veya `APP_DIRS` doğru yapılandırılmamış, ya da dosya adı yanlış yazılmış. * **Çözüm:** 1. Template dosyasının `app_adı/templates/app_adı/template_adı.html` yapısında olduğundan emin olun. 2. `settings.py` dosyasındaki `TEMPLATES` ayarlarını kontrol edin: ```python # settings.py TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [], # Proje genelindeki template'ler için buraya yol ekleyebilirsiniz 'APP_DIRS': True, # Uygulama dizinlerindeki template'leri aramasını sağlar 'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, }, ] ``` ## Performans Optimizasyonu (2026) 2026'da kullanıcılar, hızlı ve duyarlı uygulamalar bekliyor. Django uygulamalarınızın performansını artırmak için uygulayabileceğiniz bazı kanıtlanmış teknikler: ### 1. Veritabanı Sorgularını Optimize Etme Veritabanı, çoğu Django uygulamasında performans darboğazının ana kaynağıdır. `django-debug-toolbar` gibi araçlarla sorgularınızı izleyin. * **`select_related()` ve `prefetch_related()`:** İlişkili objeleri tek bir sorguda almak için kullanın. `select_related()` `ForeignKey` ve `OneToOneField` ilişkileri için JOIN yapar, `prefetch_related()` ise `ManyToManyField` ve `GenericRelation` için ayrı sorgular yapar ve Python'da birleştirir. **Before (N+1 sorgu):** ```python # Her post için yazar bilgisine erişirken ayrı bir sorgu yapar posts = Post.objects.all() for post in posts: print(post.author.username) # Her döngüde bir sorgu ``` **After (Optimize edilmiş):** ```python # Tüm postlar ve yazarları tek bir sorguda alır posts = Post.objects.select_related('author').all() for post in posts: print(post.author.username) # Sadece bir sorgu ``` * **`only()` ve `defer()`:** Sadece ihtiyacınız olan alanları seçerek sorgu yükünü azaltın. ```python posts = Post.objects.only('title', 'published_date').all() ``` ### 2. Önbellekleme (Caching) Sık erişilen ancak nadiren değişen verileri önbelleğe alarak veritabanı yükünü ve sayfa yükleme sürelerini azaltın. Django, farklı önbellek backend'lerini (Redis, Memcached, veritabanı) destekler. ```python # settings.py CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', 'LOCATION': 'unique-snowflake', } } # views.py from django.core.cache import cache from django.views.decorators.cache import cache_page @cache_page(60 * 15) # 15 dakika önbelleğe al def my_view(request): # ... view logic ... return render(request, 'my_template.html', context) # Veya manuel önbellekleme: posts = cache.get('all_posts') if not posts: posts = Post.objects.select_related('author').all() cache.set('all_posts', posts, 60 * 60) # 1 saat önbelleğe al ``` ### 3. Asenkron İşlemler ve Arka Plan Görevleri Uzun süren işlemleri (e-posta gönderme, rapor oluşturma, resim işleme) ana request-response döngüsünden ayırarak uygulamanızın duyarlılığını artırın. Celery, bu tür görevler için popüler bir seçimdir. ```python # myapp/tasks.py (Celery görevi) from celery import shared_task import time @shared_task def send_welcome_email(user_id): # Simulate a long-running email sending process time.sleep(5) print(f"Welcome email sent to user {user_id}") # Kullanım (örneğin bir view içinde) # from .tasks import send_welcome_email # send_welcome_email.delay(request.user.id) ``` ### 4. Gunicorn ve Nginx ile Dağıtım Üretim ortamında Django'yu doğrudan `runserver` ile çalıştırmak yerine, Gunicorn gibi bir WSGI sunucusu ve Nginx gibi bir ters proxy kullanarak performansı ve güvenliği artırın. Nginx statik dosyaları sunar ve Gunicorn'a gelen istekleri yönlendirir. ```bash # Gunicorn kurulumu pip install gunicorn # Gunicorn ile Django'yu çalıştırma (örnek) gunicorn --workers 3 mysite.wsgi:application --bind 0.0.0.0:8000 ``` Bu kurulum, uygulamanızın daha fazla eşzamanlı isteği daha verimli bir şekilde işlemesini sağlar. 2026'da bulut tabanlı dağıtımlarda (AWS EC2, Google Cloud Run) bu tür bir mimari standarttır. ## Gerçek Dünya Proje Örneği: Basit Bir "Görev Yöneticisi" (2026) Şimdiye kadar öğrendiklerimizi bir araya getirerek, sıfırdan çalışan basit bir Görev Yöneticisi (Todo App) oluşturalım. Bu proje, kullanıcıların görev eklemesine, listelemesine, tamamlamasına ve silmesine olanak tanıyacak. ### Proje Yapısı: ``` my_django_project_2026/ ├── mysite/ # Ana proje yapılandırması │ ├── __init__.py │ ├── settings.py │ ├── urls.py │ └── wsgi.py ├── todo/ # Görev yöneticisi uygulaması │ ├── migrations/ │ ├── __init__.py │ ├── admin.py │ ├── apps.py │ ├── models.py │ ├── tests.py │ ├── urls.py # Uygulama URL'leri │ └── views.py │ └── templates/ │ └── todo/ │ ├── base.html │ ├── task_list.html │ └── task_form.html ├── manage.py └── venv/ ``` ### Adım 1: `todo` Uygulamasını Oluşturma ve `settings.py`'ye Ekleme ```bash python manage.py startapp todo ``` `mysite/settings.py` dosyasını güncelleyin: ```python # mysite/settings.py INSTALLED_APPS = [ # ... diğer uygulamalar ... 'todo', ] ``` ### Adım 2: `todo/models.py` (Görev Modeli) ```python # todo/models.py from django.db import models from django.contrib.auth.models import User # Görevi oluşturan kullanıcıyı takip etmek için class Task(model