Udhëzues Fillestar për Django: Ndërtoni Shpejt Aplikacionin Tuaj të Parë Web
2/19/2026
7 min read
# Udhëzues Fillestar për Django: Ndërtoni Shpejt Aplikacionin Tuaj të Parë Web
Django është një kornizë e nivelit të lartë Python Web, me qëllim zhvillimin e shpejtë dhe dizajnin e pastër. Ai ndjek arkitekturën Model-Template-View (MTV), duke inkurajuar ripërdorimin e kodit dhe komponentizimin. Ky udhëzues do t'ju udhëzojë hap pas hapi në krijimin e një aplikacioni të thjeshtë Django, duke ju lejuar të filloni shpejt.
## 1. Konfigurimi i Mjedisit
Së pari, duhet të siguroheni që keni Python të instaluar në sistemin tuaj. Django rekomandon përdorimin e Python 3.6 ose më të lartë.
### 1.1 Instalimi i Python
Nëse sistemi juaj nuk ka Python të instaluar, mund ta shkarkoni dhe instaloni nga [Faqja Zyrtare e Python](https://www.python.org/downloads/).
### 1.2 Krijimi i një Mjedisi Virtual (Virtual Environment)
Për të izoluar varësitë midis projekteve të ndryshme, rekomandohet fuqimisht përdorimi i një mjedisi virtual.
1. Hapni terminalin ose komandën e shpejtë.
2. Krijoni një direktori projekti, për shembull `myproject`:
```bash
mkdir myproject
cd myproject
```
3. Krijoni dhe aktivizoni mjedisin virtual:
```bash
python3 -m venv venv # Ose python -m venv venv
source venv/bin/activate # Linux/macOS
venv\Scripts\activate # Windows
```
Pasi të aktivizohet mjedisi virtual, prompti i terminalit tuaj do të shfaqë `(venv)`, duke treguar se po përdorni një mjedis virtual.
### 1.3 Instalimi i Django
Në mjedisin virtual të aktivizuar, përdorni pip për të instaluar Django:
```bash
pip install Django
```
Vërtetoni nëse instalimi ishte i suksesshëm:
```bash
python -m django --version
```
Duhet të jeni në gjendje të shihni numrin e versionit të Django.
## 2. Krijimi i një Projekti Django
Pasi të keni instaluar Django, mund të krijoni një projekt të ri Django.
1. Ende në direktori tuaj të projektit (`myproject`), ekzekutoni komandën e mëposhtme:
```bash
django-admin startproject mysite
```
Kjo do të krijojë një direktori të quajtur `mysite` në direktori `myproject`, që përmban skedarët skelet të projektit Django.
2. Hyni në direktori `mysite`:
```bash
cd mysite
```
3. Struktura e drejtorisë së projektit Django është si më poshtë:
```
mysite/
manage.py
mysite/
__init__.py
settings.py
urls.py
asgi.py
wsgi.py
```
* `manage.py`: Një mjet i linjës së komandës për menaxhimin e projekteve Django.
* `mysite/`: Përmban paketën Python të konfigurimit të projektit.
* `__init__.py`: Një skedar bosh që i tregon Python se kjo direktori duhet të konsiderohet si një paketë Python.
* `settings.py`: Skedari i konfigurimit të projektit, si p.sh. cilësimet e bazës së të dhënave, modaliteti i debugimit, etj.
* `urls.py`: Konfigurimi i rrugëzimit URL, duke hartuar URL-të në funksionet e pamjes.
* `asgi.py`: Skedari i konfigurimit ASGI (Asynchronous Server Gateway Interface), i përdorur për vendosjen e aplikacioneve asinkrone.
* `wsgi.py`: Skedari i konfigurimit WSGI (Web Server Gateway Interface), i përdorur për vendosjen e aplikacioneve tradicionale sinkrone.
## 3. Nisja e Serverit të Zhvillimit
Django vjen me një server të lehtë zhvillimi, i cili është i dobishëm për zhvillim dhe testim lokal.
1. Në drejtorinë
mysite, ekzekuto komandën e mëposhtme:
```bash
python manage.py runserver
```
2. Hap shfletuesin tënd dhe vizito http://127.0.0.1:8000/. Duhet të shohësh faqen "It worked! Congratulations on your first Django-powered page.".
## 4. Krijimi i një Aplikacioni Django
Një projekt Django mund të përmbajë disa aplikacione. Le të krijojmë një aplikacion të quajtur myapp.
1. Hap një dritare të re terminali (mbaje serverin e zhvillimit të ndezur).
2. Në drejtorinë mysite, ekzekuto komandën e mëposhtme:
```bash
python manage.py startapp myapp
```
Kjo do të krijojë një drejtori të quajtur myapp në drejtorinë mysite, që përmban skedarët skelet të aplikacionit Django.
3. Struktura e drejtorisë së aplikacionit Django është si më poshtë:
```
myapp/
__init__.py
admin.py
apps.py
migrations/
__init__.py
models.py
tests.py
views.py
```
* __init__.py: Një skedar bosh, që i tregon Python-it se kjo drejtori duhet të konsiderohet si një paketë Python.
* admin.py: Përdoret për të konfiguruar panelin e administrimit të Django-s.
* apps.py: Konfigurimi i aplikacionit.
* migrations/: Përdoret për të menaxhuar migrimet e bazës së të dhënave.
* models.py: Përcakton modelet e të dhënave (tabelat e bazës së të dhënave).
* tests.py: Shkruan rastet e testimit.
* views.py: Përcakton funksionet e pamjeve, trajton kërkesat dhe kthen përgjigje.
4. Në mysite/settings.py, shto myapp në listën INSTALLED_APPS:
```python
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'myapp', # Shto myapp
]
```
## 5. Krijimi i një Pamje të Thjeshtë
Tani do të krijojmë një pamje të thjeshtë që shfaq "Hello, Django!" në shfletues.
1. Redakto skedarin myapp/views.py dhe shto kodin e mëposhtëm:
```python
from django.http import HttpResponse
def index(request):
return HttpResponse("Hello, Django!")
```
2. Krijo një skedar myapp/urls.py dhe mapo URL-në në funksionin e pamjes:
## 5. Krijimi i Pamjeve dhe URL-ve
Le të krijojmë një pamje të thjeshtë që shfaq një mesazh.
1. Krijoni një skedar të ri të quajtur `myapp/views.py` dhe shtoni kodin e mëposhtëm:
```python
from django.http import HttpResponse
def index(request):
return HttpResponse("Hello, Django!")
```
Kjo definon një pamje të quajtur `index` që kthen një përgjigje HTTP me tekstin "Hello, Django!".
2. Krijoni një skedar të quajtur `myapp/urls.py` dhe shtoni kodin e mëposhtëm:
```python
from django.urls import path
from . import views
urlpatterns = [
path('', views.index, name='index'),
]
```
3. Përfshini `myapp/urls.py` në `mysite/urls.py`:
```python
from django.urls import include, path
from django.contrib import admin
urlpatterns = [
path('admin/', admin.site.urls),
path('myapp/', include('myapp.urls')), # Shto konfigurimin e URL-ve të myapp
]
```
4. Vizitoni `http://127.0.0.1:8000/myapp/`. Ju duhet të shihni faqen "Hello, Django!".
## 6. Krijimi i një Modeli
Le të krijojmë një model të thjeshtë për të ruajtur disa të dhëna.
1. Redaktoni skedarin `myapp/models.py`, shtoni kodin e mëposhtëm:
```python
from django.db import models
class Question(models.Model):
question_text = models.CharField(max_length=200)
pub_date = models.DateTimeField('date published')
def __str__(self):
return self.question_text
```
Kjo definon një model të quajtur `Question`, që përmban dy fusha: `question_text` (CharField) dhe `pub_date` (DateTimeField).
2. Krijoni dhe aplikoni migrimet e bazës së të dhënave:
```bash
python manage.py makemigrations myapp
python manage.py migrate
```
Komanda `makemigrations` do të krijojë skedarët e migrimit bazuar në modelin tuaj, komanda `migrate` do të aplikojë migrimet në bazën e të dhënave.
## 7. Përdorimi i Panelit Administrativ të Django
Django ofron një panel administrativ të fuqishëm, i cili mund të përdoret për të menaxhuar të dhënat tuaja në mënyrë të përshtatshme.
1. Krijoni një superpërdorues:
```bash
python manage.py createsuperuser
```
Ndiqni udhëzimet për të futur emrin e përdoruesit, emailin dhe fjalëkalimin.
2. Redaktoni skedarin `myapp/admin.py`, regjistroni modelin `Question`:
```python
from django.contrib import admin
from .models import Question
admin.site.register(Question)
```
3. Vizitoni `http://127.0.0.1:8000/admin/`, përdorni superpërdoruesin që keni krijuar për t'u futur. Ju duhet të shihni modulin "Questions", ku mund të shtoni, redaktoni dhe fshini pyetje.
## 8. Përdorimi i Shabloneve
Përdorimi i shabloneve mund të gjenerojë faqe HTML në mënyrë më fleksibile.1. Në drejtorinë `myapp`, krijoni një drejtori të quajtur `templates`, dhe brenda drejtorisë `templates`, krijoni një drejtori të quajtur `myapp` ( `myapp/templates/myapp` ).
2. Në drejtorinë `myapp/templates/myapp`, krijoni një fajl të quajtur `index.html`, dhe shtoni kodin e mëposhtëm:
```html
Hello, Django!
The current time is: {{ current_time }}
```
3. Redaktoni fajlin `myapp/views.py`, duke përdorur shabllonin:
```python
from django.shortcuts import render
import datetime
def index(request):
now = datetime.datetime.now()
return render(request, 'myapp/index.html', {'current_time': now})
```
Funksioni `render` do të ngarkojë shabllonin dhe do t'i kalojë të dhënat shabllonit për t'u renderuar.
4. Rivizitoni `http://127.0.0.1:8000/myapp/`. Duhet të jeni në gjendje të shihni faqen që përmban orën aktuale.
## 9. Përfundim
Nëpërmjet këtij udhëzuesi, ju keni kuptuar konceptet themelore të Django dhe mënyrën e përdorimit të tij, duke përfshirë konfigurimin e mjedisit, krijimin e projekteve dhe aplikacioneve, definimin e modeleve, krijimin e pamjeve dhe përdorimin e shablloneve. Ky është vetëm një fillim, Django ofron funksionalitete të pasura, ju mund të vazhdoni të mësoni dhe të eksploroni, duke ndërtuar aplikacione më komplekse Web.Published in Technology
