Django-യിലേക്കുള്ള ആമുഖം: നിങ്ങളുടെ ആദ്യത്തെ വെബ് ആപ്ലിക്കേഷൻ വേഗത്തിൽ നിർമ്മിക്കുക

Django എന്നത് വേഗത്തിലുള്ള വികസനവും ലളിതമായ രൂപകൽപ്പനയും ലക്ഷ്യമിട്ടുള്ള ഒരു ഹൈ-ലെവൽ പൈത്തൺ വെബ് ഫ്രെയിംവർക്കാണ്. ഇത് മോഡൽ-ടെംപ്ലേറ്റ്-കാഴ്ച (MTV) ആർക്കിടെക്ചറിനെ പിന്തുടരുന്നു, കോഡ് വീണ്ടും ഉപയോഗിക്കുന്നതിനും ഘടകങ്ങളെ കൂട്ടിച്ചേർക്കുന്നതിനും പ്രോത്സാഹിപ്പിക്കുന്നു. ഈ ഗൈഡ് ഒരു ലളിതമായ Django ആപ്ലിക്കേഷൻ ഘട്ടം ഘട്ടമായി എങ്ങനെ നിർമ്മിക്കാമെന്ന് പരിചയപ്പെടുത്തുന്നു.

1. പരിസ്ഥിതി സജ്ജീകരണം

ആദ്യം, നിങ്ങളുടെ സിസ്റ്റത്തിൽ Python ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക. Django, Python 3.6 അല്ലെങ്കിൽ അതിനുശേഷമുള്ള പതിപ്പുകൾ ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നു.

1.1 Python ഇൻസ്റ്റാൾ ചെയ്യുക

നിങ്ങളുടെ സിസ്റ്റത്തിൽ Python ഇൻസ്റ്റാൾ ചെയ്തിട്ടില്ലെങ്കിൽ, നിങ്ങൾക്ക് Python ഔദ്യോഗിക വെബ്സൈറ്റിൽ നിന്ന് ഡൗൺലോഡ് ചെയ്ത് ഇൻസ്റ്റാൾ ചെയ്യാവുന്നതാണ്.

1.2 വെർച്വൽ എൻവയൺമെന്റ് ഉണ്ടാക്കുക (Virtual Environment)

വ്യത്യസ്ത പ്രോജക്റ്റുകൾ തമ്മിലുള്ള ഡിപൻഡൻസികൾ (dependencies) വേർതിരിക്കുന്നതിന്, വെർച്വൽ എൻവയൺമെന്റ് ഉപയോഗിക്കാൻ ശക്തമായി ശുപാർശ ചെയ്യുന്നു.

1. ടെർമിനൽ അല്ലെങ്കിൽ കമാൻഡ് പ്രോംപ്റ്റ് തുറക്കുക.

2. ഒരു പ്രോജക്റ്റ് ഡയറക്ടറി ഉണ്ടാക്കുക, ഉദാഹരണത്തിന് myproject:

   mkdir myproject
   cd myproject
   

3. വെർച്വൽ എൻവയൺമെന്റ് ഉണ്ടാക്കുകയും ആക്ടിവേറ്റ് ചെയ്യുകയും ചെയ്യുക:

   python3 -m venv venv  # അല്ലെങ്കിൽ python -m venv venv
   source venv/bin/activate  # Linux/macOS
   venv\Scripts\activate  # Windows
   

   വെർച്വൽ എൻവയൺമെന്റ് ആക്ടിവേറ്റ് ചെയ്ത ശേഷം, നിങ്ങളുടെ ടെർമിനൽ പ്രോംപ്റ്റിൽ (venv) എന്ന് കാണിക്കും, ഇത് നിങ്ങൾ വെർച്വൽ എൻവയൺമെന്റ് ഉപയോഗിക്കുന്നു എന്ന് സൂചിപ്പിക്കുന്നു.

1.3 Django ഇൻസ്റ്റാൾ ചെയ്യുക

ആക്ടിവേറ്റ് ചെയ്ത വെർച്വൽ എൻവയൺമെന്റിൽ, pip ഉപയോഗിച്ച് Django ഇൻസ്റ്റാൾ ചെയ്യുക:

pip install Django

ഇൻസ്റ്റലേഷൻ വിജയകരമാണോ എന്ന് പരിശോധിക്കുക:

python -m django --version

Django-യുടെ പതിപ്പ് നമ്പർ നിങ്ങൾക്ക് കാണാൻ കഴിയും.

2. Django പ്രോജക്റ്റ് ഉണ്ടാക്കുക

Django ഇൻസ്റ്റാൾ ചെയ്ത ശേഷം, നിങ്ങൾക്ക് ഒരു പുതിയ Django പ്രോജക്റ്റ് ഉണ്ടാക്കാം.

1. നിങ്ങളുടെ പ്രോജക്റ്റ് ഡയറക്ടറിയിൽ (myproject) തന്നെ, താഴെ പറയുന്ന കമാൻഡ് പ്രവർത്തിപ്പിക്കുക:

   django-admin startproject mysite
   

   ഇത് myproject ഡയറക്ടറിക്കുള്ളിൽ mysite എന്ന പേരിൽ ഒരു ഡയറക്ടറി ഉണ്ടാക്കും, അതിൽ Django പ്രോജക്റ്റിന്റെ അടിസ്ഥാന ഫയലുകൾ ഉണ്ടായിരിക്കും.

2. mysite ഡയറക്ടറിയിലേക്ക് പോകുക:

   cd mysite
   

3. Django പ്രോജക്റ്റ് ഡയറക്ടറി ഘടന താഴെ കൊടുക്കുന്നു:

   mysite/
       manage.py
       mysite/
           __init__.py
           settings.py
           urls.py
           asgi.py
           wsgi.py
   

   • manage.py: Django പ്രോജക്റ്റ് കൈകാര്യം ചെയ്യാനുള്ള കമാൻഡ് ലൈൻ ടൂൾ.
   • mysite/: പ്രോജക്റ്റ് കോൺഫിഗറേഷനുകൾ അടങ്ങിയ പൈത്തൺ പാക്കേജ്.
     • __init__.py: ഈ ഡയറക്ടറിയെ ഒരു പൈത്തൺ പാക്കേജായി പരിഗണിക്കണമെന്ന് പൈത്തണിനോട് പറയുന്ന ഒരു ശൂന്യമായ ഫയൽ.
     • settings.py: പ്രോജക്റ്റിന്റെ കോൺഫിഗറേഷൻ ഫയൽ, ഉദാഹരണത്തിന് ഡാറ്റാബേസ് ക്രമീകരണങ്ങൾ, ഡീബഗ് മോഡ് തുടങ്ങിയവ.
     • urls.py: URL റൂട്ടിംഗ് കോൺഫിഗറേഷൻ, URL-കളെ വ്യൂ ഫംഗ്ഷനുകളിലേക്ക് മാപ്പ് ചെയ്യുന്നു.
     • asgi.py: ASGI (Asynchronous Server Gateway Interface) കോൺഫിഗറേഷൻ ഫയൽ, അസിൻക്രണസ് ആപ്ലിക്കേഷനുകൾ വിന്യസിക്കാൻ ഉപയോഗിക്കുന്നു.
     • wsgi.py: WSGI (Web Server Gateway Interface) കോൺഫിഗറേഷൻ ഫയൽ, പരമ്പരാഗത സിൻക്രണസ് ആപ്ലിക്കേഷനുകൾ വിന്യസിക്കാൻ ഉപയോഗിക്കുന്നു.

Django-യിൽ ഒരു ലളിതമായ ഡെവലപ്‌മെന്റ് സെർവർ ഉണ്ട്, അത് ലോക്കലായി ഡെവലപ്പ് ചെയ്യാനും ടെസ്റ്റ് ചെയ്യാനും സഹായിക്കുന്നു.

1.  `mysite` ഡയറക്ടറിയിൽ, താഴെ പറയുന്ന കമാൻഡ് പ്രവർത്തിപ്പിക്കുക:

    ```bash
    python manage.py runserver
    ```

2.  നിങ്ങളുടെ ബ്രൗസർ തുറന്ന് `http://127.0.0.1:8000/` സന്ദർശിക്കുക.  "It worked! Congratulations on your first Django-powered page." എന്ന പേജ് നിങ്ങൾക്ക് കാണാൻ കഴിയും.

## 4. Django ആപ്ലിക്കേഷൻ ഉണ്ടാക്കുക

ഒരു Django പ്രോജക്റ്റിൽ ഒന്നിലധികം ആപ്ലിക്കേഷനുകൾ ഉണ്ടാകാം. നമുക്ക് `myapp` എന്ന് പേരുള്ള ഒരു ആപ്ലിക്കേഷൻ ഉണ്ടാക്കാം.

1.  ഒരു പുതിയ ടെർമിനൽ വിൻഡോ തുറക്കുക (ഡെവലപ്‌മെന്റ് സെർവർ പ്രവർത്തിക്കുന്ന രീതിയിൽ വെക്കുക).
2.  `mysite` ഡയറക്ടറിയിൽ, താഴെ പറയുന്ന കമാൻഡ് പ്രവർത്തിപ്പിക്കുക:

    ```bash
    python manage.py startapp myapp
    ```

    ഇത് `mysite` ഡയറക്ടറിക്കുള്ളിൽ `myapp` എന്ന പേരിൽ ഒരു ഡയറക്ടറി ഉണ്ടാക്കും, അതിൽ Django ആപ്ലിക്കേഷന്റെ അടിസ്ഥാന ഫയലുകൾ ഉണ്ടായിരിക്കും.

3.  Django ആപ്ലിക്കേഷൻ ഡയറക്ടറി ഘടന താഴെ കൊടുക്കുന്നു:

    ```
    myapp/
        __init__.py
        admin.py
        apps.py
        migrations/
            __init__.py
        models.py
        tests.py
        views.py
    ```

    *   `__init__.py`: ഒരു ശൂന്യമായ ഫയൽ, ഈ ഡയറക്ടറിയെ ഒരു Python പാക്കേജായി കണക്കാക്കണമെന്ന് Python-നോട് പറയുന്നു.
    *   `admin.py`: Django അഡ്മിൻ ബാക്കെൻഡ് കോൺഫിഗർ ചെയ്യാൻ ഉപയോഗിക്കുന്നു.
    *   `apps.py`: ആപ്ലിക്കേഷൻ കോൺഫിഗറേഷൻ.
    *   `migrations/`: ഡാറ്റാബേസ് മൈഗ്രേഷനുകൾ കൈകാര്യം ചെയ്യാൻ ഉപയോഗിക്കുന്നു.
    *   `models.py`: ഡാറ്റാ മോഡലുകൾ (ഡാറ്റാബേസ് ടേബിളുകൾ) നിർവചിക്കുന്നു.
    *   `tests.py`: ടെസ്റ്റ് കേസുകൾ എഴുതുന്നു.
    *   `views.py`: വ്യൂ ഫംഗ്ഷനുകൾ നിർവചിക്കുന്നു, അഭ്യർത്ഥനകൾ കൈകാര്യം ചെയ്യുകയും പ്രതികരണങ്ങൾ നൽകുകയും ചെയ്യുന്നു.

4.  `mysite/settings.py`-ൽ, `myapp`-നെ `INSTALLED_APPS` ലിസ്റ്റിലേക്ക് ചേർക്കുക:

    ```python
    INSTALLED_APPS = [
        'django.contrib.admin',
        'django.contrib.auth',
        'django.contrib.contenttypes',
        'django.contrib.sessions',
        'django.contrib.messages',
        'django.contrib.staticfiles',
        'myapp',  # myapp ചേർക്കുക
    ]
    ```

## 5. ഒരു ലളിതമായ വ്യൂ ഉണ്ടാക്കുക

ഇപ്പോൾ നമ്മുക്ക് ഒരു ലളിതമായ വ്യൂ ഉണ്ടാക്കാം, അത് ബ്രൗസറിൽ "Hello, Django!" എന്ന് കാണിക്കും.

1.  `myapp/views.py` ഫയൽ എഡിറ്റ് ചെയ്ത് താഴെ പറയുന്ന കോഡ് ചേർക്കുക:

    ```python
    from django.http import HttpResponse

    def index(request):
        return HttpResponse("Hello, Django!")
    ```

2.  ഒരു `myapp/urls.py` ഫയൽ ഉണ്ടാക്കുക, URL-നെ വ്യൂ ഫംഗ്ഷനിലേക്ക് മാപ്പ് ചെയ്യുക:
    ```python
    from django.urls import path
    from . import views

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

3.  `myapp/urls.py` `mysite/urls.py`-il cherkkuka:

    ```python
    from django.urls import include, path
    from django.contrib import admin

    urlpatterns = [
        path('admin/', admin.site.urls),
        path('myapp/', include('myapp.urls')),  # myapp-inte URL configureration cherthirikunnu
    ]
    ```

4.  `http://127.0.0.1:8000/myapp/` sandarshikkuka. ningalkk "Hello, Django!" ennulla page kaanaan kazhiyum.

## 6. oru model undaakkuka

chila datakal store cheyyaan oru simple model undaakkaam.

1.  `myapp/models.py` file edit cheythu thaazhe kodukkunna code cherkkuka:

    ```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
    ```

ithu `Question` enna oru model define cheyyunnu, athil randu fieldukalundu: `question_text` (CharField) yum `pub_date` (DateTimeField) um.

2.  database migration undaakki apply cheyyuka:

    ```bash
    python manage.py makemigrations myapp
    python manage.py migrate
    ```

    `makemigrations` command ningalude modeline aadharamaakki migration file undaakkum, `migrate` command migration database-il apply cheyyum.

## 7. Django admin backend upayogikkuka

ningalude data sookshikkunnathinu Django shakthamaaya oru admin backend provide cheyyunnu.

1.  oru super user undaakkuka:

    ```bash
    python manage.py createsuperuser
    ```

    user name, email id, password enniva nalkaan aavashyapedum.

2.  `myapp/admin.py` file edit cheythu `Question` model register cheyyuka:

    ```python
    from django.contrib import admin
    from .models import Question

    admin.site.register(Question)
    ```

3.  `http://127.0.0.1:8000/admin/` sandarshikkuka, ningal undaakkiya super user upayogichu login cheyyuka. ningalkk "Questions" module kaanaan kazhiyum, athil prashnangal cherkkaanum, edit cheyyaanum, delete cheyyaanum kazhiyum.

## 8. template upayogikkuka

template upayogichu HTML page-ukal valare flexibilaayi generate cheyyaan kazhiyum.
1. `myapp` ഡയറക്ടറിക്കുള്ളിൽ `templates` എന്നൊരു ഡയറക്ടറി ഉണ്ടാക്കുക. അതിനു ശേഷം `templates` ഡയറക്ടറിക്കുള്ളിൽ `myapp` എന്നൊരു ഡയറക്ടറി കൂടി ഉണ്ടാക്കുക (`myapp/templates/myapp`).

2. `myapp/templates/myapp` ഡയറക്ടറിക്കുള്ളിൽ `index.html` എന്നൊരു ഫയൽ ഉണ്ടാക്കുക. അതിൽ താഴെ കൊടുത്ത കോഡ് ചേർക്കുക:

    ```html
    

    Hello, Django!

    The current time is: {{ current_time }}

    ```

3. `myapp/views.py` ഫയൽ എഡിറ്റ് ചെയ്ത് ടെംപ്ലേറ്റ് ഉപയോഗിക്കുക:

    ```python
    from django.shortcuts import render
    import datetime

    def index(request):
        now = datetime.datetime.now()
        return render(request, 'myapp/index.html', {'current_time': now})
    ```

    `render` ഫങ്ക്ഷൻ ടെംപ്ലേറ്റ് ലോഡ് ചെയ്യുകയും ഡാറ്റ ടെംപ്ലേറ്റിലേക്ക് കൈമാറുകയും ചെയ്യുന്നു.

4. `http://127.0.0.1:8000/myapp/` വീണ്ടും സന്ദർശിക്കുക. ഇപ്പോഴത്തെ സമയം കാണിക്കുന്ന പേജ് നിങ്ങൾക്ക് കാണാൻ സാധിക്കും.

## 9. നിഗമനം

ഈ ഗൈഡിലൂടെ, Django-യുടെ അടിസ്ഥാനപരമായ ആശയങ്ങളും ഉപയോഗിക്കേണ്ട രീതികളും നിങ്ങൾക്ക് മനസ്സിലായിക്കാണും. ഒരു പരിസ്ഥിതി ഉണ്ടാക്കുക, പ്രോജക്റ്റുകളും ആപ്ലിക്കേഷനുകളും ഉണ്ടാക്കുക, മോഡലുകൾ നിർവചിക്കുക, കാഴ്ചകൾ ഉണ്ടാക്കുക, ടെംപ്ലേറ്റുകൾ ഉപയോഗിക്കുക എന്നിവയെല്ലാം ഇതിൽ ഉൾപ്പെടുന്നു. ഇത് തുടക്കം മാത്രമാണ്. Django-യിൽ ധാരാളം ഫീച്ചറുകൾ ഉണ്ട്. കൂടുതൽ പഠിച്ച് വലിയ വെബ് ആപ്ലിക്കേഷനുകൾ ഉണ്ടാക്കാൻ ശ്രമിക്കാവുന്നതാണ്.