Sign in Subscribe
By Thisara Priyamal —

Django Introduction Sinhala | Python Web Development | Beginners Guide

Django Introduction Sinhala | Python Web Development | Beginners Guide

ආයුබෝවන් හැමෝටම! අද අපි කතා කරන්න යන්නේ Python Web Development වලට අලුතින්ම එන අයටත්, දැනටමත් Python දන්න අයටත් ගොඩක් වැදගත් වෙන මාතෘකාවක් ගැන. ඒ තමයි Django!

වෙබ් අඩවි සහ වෙබ් ඇප්ලිකේෂන් (web applications) හදනවා කියන්නේ අද වෙනකොට ලෝකයේම ඉහළ ඉල්ලුමක් තියෙන ක්ෂේත්‍රයක්. ඒ අතරින් Python වලට තියෙන ජනප්‍රියත්වයත් එක්ක, Django කියන්නේ Developers ලා අතර ගොඩක් ප්‍රසිද්ධ සහ බලගතු (powerful) Web Framework එකක්. මේකෙන් පුළුවන් ඉක්මනට, ආරක්ෂාකාරීව සහ පහසුවෙන් වෙබ් සේවාවන් ගොඩනගන්න.

මේ Sinhala Guide එකෙන් අපි Django කියන්නේ මොකක්ද, ඒක වැඩ කරන්නේ කොහොමද, Project එකක් සහ App එකක් කොහොමද හදන්නේ කියලා මුල සිටම කතා කරනවා. එහෙනම්, අපි පටන් ගමු!

Django කියන්නේ මොකක්ද? (What is Django?)

Django කියන්නේ Python Web Framework එකක්. ඒ කියන්නේ වෙබ් අඩවි හෝ වෙබ් ඇප්ලිකේෂන් හදන්න ඕන කරන මූලික මෙවලම් (tools), ව්‍යුහය (structure) සහ ශ්‍රිත (functions) මේකේ අන්තර්ගතයි. Django වල ප්‍රධානම දර්ශනයක් (philosophy) තමයි "Batteries Included" කියන එක.

"Batteries Included" කියන්නේ මොකක්ද?

සාමාන්‍යයෙන් වෙබ් ඇප්ලිකේෂන් එකක් හදනකොට අපිට Authentication (user login/logout), Database connectivity (දත්ත ගබඩා කිරීම), Admin Panel (පරිපාලන අතුරුමුහුණත), URL Routing (ලිපින කළමනාකරණය) වගේ දේවල් ගොඩක් අවශ්‍ය වෙනවා. මේ හැමදේටම වෙන වෙනම Library හරි Package හරි හොයලා එකතු කරන්න වෙනවා. ඒත් Django වල මේ හැමදේම built-in විදියට, ඒ කියන්නේ රාමුව (framework) ඇතුලෙන්ම එනවා. ඒක නිසා වෙබ් ඇප්ලිකේෂන් එකක් හදන ක්‍රියාවලිය ගොඩක් වේගවත් වෙනවා. ආරම්භයේ ඉඳන්ම ගොඩක් දේවල් සූදානම් කරලා තියෙන නිසා, ඔබට අවධානය යොමු කරන්න වෙන්නේ ඔබේ ඇප්ලිකේෂන් එකේ තියෙන විශේෂිත අවශ්‍යතාවයන් (specific requirements) ගැන විතරයි.

Django වල ප්‍රධාන ලක්ෂණ කිහිපයක් මෙන්න:

  • Fast (වේගවත්): ඉක්මනට වෙබ් ඇප්ලිකේෂන් develop කරන්න පුළුවන්.
  • Secure (ආරක්ෂාකාරී): ගොඩක් පොදු ආරක්ෂක ගැටළු (common security vulnerabilities) වලින් ආරක්ෂාව සපයනවා (උදා: CSRF, XSS).
  • Scalable (විශාල කළ හැකි): කුඩා ව්‍යාපෘතියක සිට විශාල, සංකීර්ණ ව්‍යාපෘති දක්වා ඕනෑම ප්‍රමාණයක ඇප්ලිකේෂන් හදන්න පුළුවන්.
  • Maintainable (නඩත්තු කළ හැකි): කේතය (code) ලියලා තියෙන්නේ පිරිසිදු සහ පහසුවෙන් තේරුම් ගන්න පුළුවන් විදියට.

Django's MVT Architecture (MVT Architecture එක තේරුම් ගනිමු)

Django වැඩ කරන්නේ Model-View-Template (MVT) architecture කියන රටාවට අනුවයි. මේක Model-View-Controller (MVC) රටාවට සමාන වුවත්, Django වලදී Controller එකේ කොටස Framework එකෙන්ම හසුරුවන නිසා, අපිට වැඩ කරන්න තියෙන්නේ Model, View, Template කියන කොටස් තුන එක්කයි.

Template

Template එක තමයි user ට පේන HTML පිටුව හදන්නේ. මේකේ HTML, CSS, JavaScript අඩංගු වෙනවා. Django Template Language (DTL) එක භාවිතා කරලා View එකෙන් එවන data මේ HTML එකට දාලා dynamic pages හදන්න පුළුවන්.උදාහරණයක්: Blog posts ලැයිස්තුව පෙන්වන Template එකක්.

<!-- myapp/templates/myapp/post_list.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Blog Posts</title>
</head>
<body>
    <h1>Our Blog Posts</h1>
    <ul>
        {% for post in posts %}
            <li>
                <h2>{{ post.title }}</h2&n>
                <p>{{ post.content|truncatechars:100 }}</p>
                <small>Published on: {{ post.published_date }}</small>
            </li>
        {% empty %}
            <li>No posts available yet.</li>
        {% endfor %}
    </ul>
</body>
</html>

View

View එකකින් තීරණය කරන්නේ මොන දත්තද පෙන්වන්න ඕනේ, ඒවා කොහොමද පෙන්වන්නේ, සහ user කෙනෙක් ඉල්ලීමක් (request) කරාම ඒකට ප්‍රතිචාර දක්වන්නේ කොහොමද කියලා. සරලවම, මේක තමයි business logic එක තියෙන තැන. View එකකින් Model එකෙන් data අරගෙන, Template එකට යවනවා.උදාහරණයක්: සියලුම Blog posts පෙන්වන View එකක්.

# myapp/views.py
from django.shortcuts import render
from .models import Post

def post_list(request):
    posts = Post.objects.all().order_by('-published_date')
    return render(request, 'myapp/post_list.html', {'posts': posts})

Model

Model එකකින් නිරූපණය වෙන්නේ ඔබේ ඇප්ලිකේෂන් එකේ data structure එක. ඒ කියන්නේ දත්ත ගබඩාවේ (database) දත්ත කොහොමද ගබඩා කරන්නේ, ඒවායේ සම්බන්ධතා මොනවාද කියන එක. Django වල ORM (Object-Relational Mapper) එකක් තියෙනවා. ඒකෙන් පුළුවන් SQL query ලියන්නේ නැතුව Python code වලින්ම database එක්ක වැඩ කරන්න.උදාහරණයක්: ඔබට Blog post එකක් සඳහා Model එකක් හදන්න පුළුවන්.

# myapp/models.py
from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    published_date = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

Project එකක් සහ App එකක් පටන් ගමු (Let's Start a Project and an App)

හරි, දැන් අපි Django ගැන theoretical දැනුමක් ගත්තා. දැන් අපි practical විදියට Django Project එකක් පටන් ගමු!

1. Virtual Environment එකක් හදමු (Create a Virtual Environment)

මෙය අනිවාර්ය නොවුනත්, හොඳම පුරුද්දක් (best practice) විදියට අපි හැමවිටම Python ව්‍යාපෘති සඳහා Virtual Environment එකක් භාවිතා කරනවා. මේකෙන් පුළුවන් ඔබේ ව්‍යාපෘතියට අවශ්‍ය Packages වෙනත් ව්‍යාපෘතිවලින් ස්වාධීනව තියාගන්න.

# Project එකට ෆෝල්ඩරයක් හදමු
mkdir mydjangosite
cd mydjangosite

# Virtual environment එකක් හදමු
python -m venv myenv

# Virtual environment එක activate කරමු
# Windows වල නම්:
myenv\Scripts\activate
# macOS / Linux වල නම්:
source myenv/bin/activate

ඔබේ Terminal එකේ මුලට (myenv) කියලා ආවොත්, Virtual Environment එක successful activate වෙලා තියෙන්නේ.

2. Django Install කරමු (Install Django)

Virtual Environment එක activate කරලා තියෙන ගමන්ම, අපි දැන් Django Install කරමු:

(myenv) pip install django

Installation එක සාර්ථකද කියලා බලන්න django-admin --version කියලා type කරලා බලන්න. Version එක පෙන්නුවොත් හරි.

3. Project එකක් හදමු (Create a Project)

දැන් අපි Django Project එකක් හදමු. mydjangosite කියන ෆෝල්ඩරය ඇතුලේම මේක කරමු.

(myenv) django-admin startproject mysite .

. (dot) එක දැම්මේ Project එක current directory එක ඇතුලෙම හදන්න. නැත්නම් mysite කියලා තව ෆෝල්ඩරයක් ඇතුලේ Project එක හැදෙනවා.

මේක කරාම ඔබේ ෆෝල්ඩර structure එක මේ වගේ වෙයි:

mydjangosite/
├── myenv/
├── manage.py
└── mysite/
    ├── __init__.py
    ├── asgi.py
    ├── settings.py
    ├── urls.py
    └── wsgi.py

4. Development Server එක Run කරමු (Run the Development Server)

අපි හදපු Project එක වැඩද කියලා බලන්න, Django වල built-in development server එක Run කරමු.

(myenv) python manage.py runserver

මේක Run කරාම ඔබට Terminal එකේ මේ වගේ Link එකක් පෙනෙයි: http://127.0.0.1:8000/. ඒ Link එකට ගියාම "The install worked successfully! Congratulations!" කියලා පණිවිඩයක් ආවොත්, ඔබේ Django Project එක සාර්ථකව නිර්මාණය වෙලා!

5. App එකක් හදමු (Create an App)

Django Project එක කියන්නේ ඔබේ වෙබ් අඩවියේ සම්පූර්ණ Container එක. ඒ Container එක ඇතුලේ අපි වෙන වෙනම Apps හදනවා. App එකක් කියන්නේ වෙබ් අඩවියේ තියෙන specific feature එකක්. උදාහරණයක් විදියට, Blog post manage කරන්න App එකක්, User accounts manage කරන්න තව App එකක් වගේ.

අපි blog කියලා App එකක් හදමු:

(myenv) python manage.py startapp blog

දැන් ඔබේ ෆෝල්ඩර structure එකට blog කියන ෆෝල්ඩරය එකතු වෙලා තියේවි:

mydjangosite/
├── myenv/
├── blog/
│   ├── migrations/
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── models.py
│   ├── tests.py
│   └── views.py
├── manage.py
└── mysite/
    ├── ... (project files)

6. App එක Project එකට register කරමු (Register the App with the Project)

අපි හදපු blog App එක Django Project එකට දන්නන්න ඕනේ. ඒකට, mysite/settings.py ෆයිල් එක open කරලා, INSTALLED_APPS කියන ලැයිස්තුවට අපේ App එකේ නම එකතු කරන්න.

# mysite/settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'blog',  # අපේ අලුත් App එක මෙතනට එකතු කරන්න
]

7. View එකක් සහ URL එකක් හදමු (Create a View and URL)

අපි දැන් blog App එක ඇතුලේ සරල වෙබ් පිටුවක් පෙන්වමු. මුලින්ම blog/views.py ෆයිල් එක open කරලා මේ code එක එකතු කරන්න:

# blog/views.py
from django.http import HttpResponse

def home(request):
    return HttpResponse("<h1>Welcome to My Blog!</h1><p>This is my first Django app.</p>")

ඊළඟට, මේ View එකට Link එකක් (URL) දෙන්න ඕනේ. blog ෆෝල්ඩරය ඇතුලේ urls.py කියලා අලුත් ෆයිල් එකක් හදන්න.

# blog/urls.py (අලුතින් හදන්න)
from django.urls import path
from . import views

urlpatterns = [
    path('', views.home, name='home'),
]

දැන් Project එකේ ප්‍රධාන urls.py (mysite/urls.py) ෆයිල් එකට මේ blog App එකේ URLs ටික එකතු කරන්න.

# mysite/urls.py
from django.contrib import admin
from django.urls import path, include # include එක import කරගන්න

urlpatterns = [
    path('admin/', admin.site.urls),
    path('blog/', include('blog.urls')), # අපේ blog App එකේ URLs මෙතනට එකතු කරන්න
]

දැන් ආයෙත් Development Server එක Run කරලා (python manage.py runserver), http://127.0.0.1:8000/blog/ කියන Link එකට ගියාම "Welcome to My Blog!" කියලා පණිවිඩය පෙනෙයි.

වැදගත් කරුණු සහ Troubleshooting (Important Points and Troubleshooting)

Project එකක් සහ App එකක් අතර වෙනස (Project vs. App Distinction)

මේක ගොඩක් අයට මුලදී වරදින තැනක්. මතක තියාගන්න:

  • Project: සම්පූර්ණ වෙබ් සයිට් එකේ settings, configurations, සහ overall URLs තියෙන තැන. Project එකකින් එක App එකක් හෝ App ගණනාවක් manage කරන්න පුළුවන්.
  • App: වෙබ් සයිට් එකේ තියෙන ස්වාධීන (independent) functionality එකක්. උදා: Blog එකක්, Shopping cart එකක්, User profile එකක් වගේ. App එකක් හැමවිටම reusable වෙන්න ඕනේ. ඒ කියන්නේ ඒක වෙනත් Django Project එකක වුණත් භාවිතා කරන්න පුළුවන් වෙන්න ඕනේ.

පොදු ආරම්භක දෝෂ (Common Initial Errors)

  • ModuleNotFoundError: No module named 'django': මේක වෙන්නේ Django install කරලා නැත්නම්, නැත්නම් ඔබ Django install කරපු Virtual Environment එක activate කරලා නැත්නම්.
  • AttributeError: module 'blog.urls' has no attribute 'urlpatterns': blog/urls.py ෆයිල් එකේ urlpatterns කියන Variable එක නිවැරදිව define කරලා නැත්නම් හෝ වැරදි නමක් දීලා තියෙනවා නම්.
  • ImproperlyConfigured: The INSTALLED_APPS setting must be a list of strings...: settings.py ෆයිල් එකේ INSTALLED_APPS වලට App එකේ නම එකතු කරන්නේ වැරදි විදියට නම් (උදා: string එකක් විදියට නොවෙයි නම්).
  • TypeError: object of type 'HttpResponse' is not JSON serializable: HttpResponse එකට යවන දත්ත HTML හෝ String එකක් විය යුතුයි.

Best Practices: Reusable Apps (Reusability එක ගැන හිතමු)

Django Apps හදනකොට මතක තියාගන්න ඕන වැදගත්ම දෙයක් තමයි reusability. හොඳට design කරපු App එකක් වෙනත් Project එකකත් පහසුවෙන් භාවිතා කරන්න පුළුවන්.

  • App එකේ අවධානය (Focus of the App): App එකක් හදනකොට, ඒක single responsibility principle එකට අනුව හදන්න උත්සාහ කරන්න. ඒ කියන්නේ එක App එකකින් එකම වර්ගයේ functionality එකක් විතරක් කරන්න ඕනේ. උදා: blog App එක Blog posts ගැන විතරක් handle කරනවා. accounts App එක User account management විතරක් handle කරනවා.
  • Dependency අඩු කරන්න (Minimize Dependencies): ඔබේ App එකට බාහිර Packages (external packages) ගොඩක් අවශ්‍ය වෙන්න එපා. එහෙම වුණොත් App එක වෙන Project එකකට ගෙනියනකොට ගැටළු ඇති වෙන්න පුළුවන්.
  • Configuration පහසු කරන්න (Make it Configurable): ඔබේ App එකේ ක්‍රියාකාරීත්වය (behavior) වෙනස් කරන්න පුළුවන් විදියට settings.py හරහා Options දෙන්න පුළුවන් නම් හොඳයි.
  • Documentation (ලේඛනගත කිරීම): ඔබේ App එක ගැන හොඳට Documentation ලියන්න. ඒක වෙන කෙනෙක්ට, නැත්නම් ඔබටම අනාගතයේදී App එක තේරුම් ගන්න උදව් වෙනවා.

නිගමනය (Conclusion)

අද අපි Django කියන්නේ මොකක්ද, ඒකේ තියෙන "Batteries Included" දර්ශනය සහ MVT Architecture එක ගැන ඉගෙන ගත්තා. ඒ වගේම, මුල සිටම Django Project එකක් සහ App එකක් හදලා, Development Server එක Run කරලා, සරල View එකක් සහ URL එකක් නිර්මාණය කරගත්තා. Project එකක් සහ App එකක් අතර වෙනසත්, පොදු ගැටළු වළක්වාගන්න හැටිත් අපි සාකච්ඡා කළා.

මේක Django ලෝකයට ඔබේ පළමු පියවර විතරයි. තව ගොඩක් දේවල් ඉගෙන ගන්න තියෙනවා. Models හදලා Database එක්ක වැඩ කරන හැටි, Templates ලස්සන කරන හැටි, Forms භාවිතා කරන හැටි වගේ තව දේවල් ගොඩක් අපි අනාගත Guide වලින් කතා කරමු.

මතක තියාගන්න, Programming කියන්නේ නිරන්තරයෙන් අලුත් දේවල් ඉගෙන ගන්න ඕන ක්ෂේත්‍රයක්. ඒ නිසා, අද ඉගෙන ගත්ත දේවල් ඔබේම Project එකක භාවිතා කරලා බලන්න. පොඩි පොඩි අත්හදා බැලීම් කරන්න. ඒකෙන් ඔබේ දැනුම තවත් දියුණු වෙනවා.

ඔබට Django ගැන තවත් දැනගන්න අවශ්‍ය නම්, පහලින් Comment එකක් දාන්න. අපි ඒ ගැනත් කතා කරමු! ඔබේ අදහස් සහ අත්දැකීම් බෙදා ගන්න එකෙන් අනිත් අයටත් ගොඩක් උදව්වක් වෙයි. එහෙනම්, ඊළඟ Guide එකෙන් හමුවෙමු!

Previous

Django Web Development Introduction | Python Sinhala Tutorial

 Next

AI සඳහා ගණිතය: Linear Algebra, Calculus, Probability, Statistics | Sinhala Guide