Django Unlocked: Beginners&# Spawn Point

Pengenalan

Django ialah rangka kerja web yang berkuasa yang membolehkan anda membina aplikasi web yang teguh dan boleh skala dengan cepat dan cekap. Ia ditulis dalam Python dan mengikut falsafah "termasuk bateri", bermakna ia datang dengan banyak ciri terbina dalam yang menjadikan pembangunan lebih pantas dan mudah, sekali gus menjadikannya sesuai untuk prototaip. Sama ada anda mencipta projek peribadi kecil atau aplikasi perusahaan besar, Django mempunyai alatan yang anda perlukan.

Dalam panduan ini, saya akan membimbing anda melalui corak reka bentuk MVT Django (Model, Paparan dan Templat), menyediakan asas yang kukuh untuk membina aplikasi web anda sendiri. Pada akhirnya, anda akan mendapat pemahaman yang jelas tentang cara Django berfungsi dan cara menggunakan komponennya dengan berkesan.

Menyediakan Projek Django dengan Persekitaran Maya

Rujuk dokumentasi rasmi Django: Django Documentation

Sebelum menyelami komponen teras, mari sediakan persekitaran maya untuk mengurus kebergantungan projek anda. Ini membantu memastikan projek anda terpencil dan menghalang konflik dengan projek Python yang lain.

Nota: Saya sangat menggalakkan menggunakan Linux. Jika anda menggunakan Windows, pasang WSL untuk mengakses persekitaran Linux.

1. Pasang modul venv:

sudo apt install python3-venv

2. Cipta Persekitaran Maya:

python -m venv .venv

3. Aktifkan Persekitaran Maya:

source .venv/bin/activate

4. Pasang Django:

Dengan persekitaran maya diaktifkan, pasang Django:

python -m pip install django

5. Buat Projek Django:

django-admin startproject myproj

Ganti myproj dengan nama projek yang anda inginkan.

6. Buat Apl:

Di dalam direktori projek anda, cipta apl.

python manage.py startapp myapp

7. Tambahkan apl anda yang baru dibuat pada settings.py yang terletak di:

nama-projek-anda/nama-projek-anda/settings.py

INSTALLED_APPS = [
    'myapp',
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

Projek anda kini disediakan dengan struktur asas, termasuk fail manage.py, tetapan projek dan apl pertama anda

Model

Model mentakrifkan struktur jadual pangkalan data anda dan perhubungan antaranya menggunakan kelas Python. Setiap kelas model memetakan kepada satu jadual pangkalan data, dan setiap atribut model sepadan dengan medan pangkalan data. Django memudahkan proses ini dengan membenarkan anda mentakrifkan skema pangkalan data anda menggunakan kelas yang diwarisi daripada django.db.models.Model.

ORM bermaksud Pemetaan Perkaitan Objek. Dalam Django, ORM ialah ciri berkuasa yang membolehkan pembangun berinteraksi dengan pangkalan data menggunakan kod Python dan bukannya menulis pertanyaan SQL. Lapisan abstraksi ini memetakan kelas Python (model) kepada jadual pangkalan data dan kejadian kelas tersebut kepada baris dalam jadual.

Memperkenalkan SQLite

Django menggunakan SQLite sebagai pangkalan data lalainya kerana ia sangat mudah untuk disediakan. SQLite ialah pangkalan data ringan yang menyimpan semua data anda dalam satu fail ringkas, jadi anda tidak perlu memasang apa-apa tambahan untuk mula menyimpan dan mengurus data tapak web anda. Ini menjadikannya pilihan yang bagus untuk pembangunan dan ujian, kerana ia membolehkan anda menumpukan pada membina aplikasi anda tanpa perlu risau tentang persediaan pangkalan data yang rumit.

Dalam Django, jadual bernama Lapangan Terbang dengan atribut seperti 'kod' dan 'bandar' diwakili sebagai kelas Python, di mana setiap atribut ditakrifkan sebagai pembolehubah kelas.

class Airport(models.Model):
    code = models.CharField(max_length=3)
    city = models.CharField(max_length=64)

1. Menentukan Model:

Dalam models.py apl anda, tentukan model anda menggunakan ORM Django.

from django.db import models

class Flight(models.Model):
    # Diri, kada flight naa tay origin kung asa gikan, destination, ug duration
    # Nakabutang sa parameters ilang properties, such as length of the characters

    origin = models.ForeignKey(Airport, on_delete=models.CASCADE, related_name='departures')
    destination = models.ForeignKey(Airport, on_delete=models.CASCADE, related_name='arrivals')
    duration = models.IntegerField()

    def __str__(self):
        return f'{self.id}: {self.origin} to {self.destination} | {self.duration} minutes.'

2. Penghijrahan:

Selepas menentukan model anda, buat dan gunakan migrasi untuk mengemas kini skema pangkalan data anda.

Dalam istilah mudah:

• makemigration adalah seperti merancang perubahan yang anda ingin lakukan pada pangkalan data anda.
• migrate sebenarnya menjalankan perubahan tersebut pada pangkalan data. Jadi, selepas merancang dengan makemigration, migrasi ialah apabila anda melaksanakan dan menggunakan perubahan.

python manage.py makemigrations
python manage.py migrate

3. Berinteraksi dengan Model:

Gunakan shell Django untuk berinteraksi dengan model anda: python manage.py shell

Contoh:

>> from flights.models import Flight

>> flight1 = Flight(origin="Davao", destination="Manila", duration=569)
>> fligh1.save()

Saya mencipta contoh model Penerbangan. Flight1 contoh ini mewakili satu baris dalam jadual Penerbangan pangkalan data saya. Model Penerbangan mempunyai medan asal, destinasi dan tempoh yang ditentukan di dalamnya.
Apabila anda membuat contoh. anda menetapkan medan ini kepada nilai tertentu:

• origin : "Davao"
• destination : "Manila"
• duration : 569 (representing the flight duration in minutes)

Views

Views are a crucial part of the framework that handles the logic behind what a user sees and interacts with in a web application. Views are responsible for processing user requests, retrieving necessary data from the database, and returning the appropriate response (typically an HTML page, JSON data, or a redirect).

In simple terms, Views in Django act as the middleman between the web pages and the data. They take requests from users, process any necessary data, and then send back the appropriate response, like a webpage or a file. Essentially, views decide what content should be shown to the user and how it should be presented.

In this read, we will only be using Function-Based Views

1. Function-Based Views:

These are Python functions that take a web request and return a web response. The most basic view in Django is a function that receives a request object and returns a response object.

from django.http import HttpResponse

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

2. Class-Based Views:

These are Python classes that provide more structure and allow for more complex functionality compared to Function-Based Views.

from django.views import View
from django.http import HttpResponse

class MyView(View):
    def get(self, request):
        return HttpResponse("Hello, World!")

Templates

Templates are used to render HTML and display data to users. They allow you to separate your HTML from Python code. Django templates are a powerful tool for generating dynamic HTML content in your web application. By separating the presentation (HTML) from the backend logic (Python code), templates help keep your code clean, maintainable, and reusable.

In simple terms, Templates in Django are like blueprints that define how data should be displayed on a webpage. They allow you to combine static content (like HTML) with dynamic content (like data from a database) to create a fully rendered page. Instead of hardcoding every detail, you use templates to keep the design and data separate, making it easier to update and manage your website.

1. Creating a Template

Start with creating a directory for your templates inside your app and name the directory as templates. Create another directory inside the templates named myapp.

django-proj/myapp/templates/myapp

Now, you can finally place all your templates inside the inner directory you created:

django-proj/myapp/templates/myapp/base.html

Creating the base.html allows you to define a base template or layout with common structure (headers, navbar, and footer) that other templates can inherit. This feature is useful for maintaining consistency across different pages.

Example:

<!DOCTYPE html>
<html>
<head>
    <title> {% block title %} myApp {% endblock %} </title>
</head>
<body>
    <header>
        <h1>My Site</h1>
    </header>
    <div class="content">
        {% block content %}{% endblock %}
    </div>
    <footer>
        <p>Footer content here</p>
    </footer>
</body>
</html>

Let's create another template called index.html and place it in the same directory of base.html.

Example of extending template index.html:

{% extends "myapp/base.html" %}
{% block content %}
    <h1>Flights</h1>
    <ul>
        {% for flight in flights %}
            <li>Flight: {{ flight.id }} {{ flight.origin }} to {{ flight.destination }}</li>
        {% endfor %}
    </ul>
{% endblock %}

The {% extends "myapp/base.html" %} tells Django to use the base.html as the base layout template. The {% block content %} defines a block of content that will be filled with content from index.html. The content block in base.html will be replaced with the content provided in index.html.

2. Rendering Templates

In a Django view, you typically render a template using the render() function, which combines the template with the context data to produce the final HTML output.

from django.shortcuts import render

def index(request):
    return render(request, 'myapp/index.html')

When Django renders index.html, it will include the structure from base.html, replacing the content block with the content specified in index.html. This allows for consistent design across pages and makes it easy to update the overall layout without changing every individual template.

URLs and Routing

Django uses URL patterns to map URLs to views. These patterns are defined in a file called urls.py within each Django app.

URL patterns are defined with the path() function, mapping specific URL paths to view functions or classes. Dynamic URL segments, such as , allow for capturing variables from the URL to be used in views. The include() function enables modular URL management by including patterns from other apps.

In simple terms, URLs are like street addresses for different pages on your website. Routing is the system that makes sure when someone types in a specific address (URL), they get directed to the right page. You set up these "addresses" in a special file so Django knows where to send people when they visit your site.

1. Configuring URLs:
Define URL patterns in urls.py of your app:

from django.urls import path
from . import views

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

Inlcude your app's URLs in the project's urls.py:

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

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('myapp.urls'))
]

Wrapping up

Congratulations! You've taken the first steps in learning Django. I’ve covered the basics of Models, Views, Templates, and URL routing. With these fundamentals, you’re on your way to building your own Django applications. Keep experimenting, keep coding, and don't hesitate to dive deeper into the Django documentation and community resources.

I hope this guide has made these concepts clearer and that you’ve learned something valuable along the way.

• 0xshr00msz

Atas ialah kandungan terperinci Django Unlocked: Beginners&# Spawn Point. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!