Django freigeschaltet: Spawnpunkt für Anfänger

Einführung

Django ist ein leistungsstarkes Web-Framework, mit dem Sie schnell und effizient robuste, skalierbare Webanwendungen erstellen können. Es ist in Python geschrieben und folgt der Philosophie „Batterien im Lieferumfang enthalten“, was bedeutet, dass es über viele integrierte Funktionen verfügt, die die Entwicklung schneller und einfacher machen und es somit für die Prototypenerstellung geeignet machen. Egal, ob Sie ein kleines persönliches Projekt oder eine große Unternehmensanwendung erstellen, Django hat die Tools, die Sie brauchen.

In diesem Leitfaden führe ich Sie durch Djangos MVT-Entwurfsmuster (Modelle, Ansichten und Vorlagen) und biete eine solide Grundlage für die Erstellung Ihrer eigenen Webanwendungen. Am Ende werden Sie ein klares Verständnis davon haben, wie Django funktioniert und wie Sie seine Komponenten effektiv nutzen.

Einrichten eines Django-Projekts mit einer virtuellen Umgebung

Weitere Informationen finden Sie in der offiziellen Dokumentation von Django: Django-Dokumentation

Bevor wir uns mit den Kernkomponenten befassen, richten wir eine virtuelle Umgebung ein, um die Abhängigkeiten Ihres Projekts zu verwalten. Dies hilft, Ihr Projekt isoliert zu halten und Konflikte mit anderen Python-Projekten zu vermeiden.

Hinweis: Ich empfehle dringend, Linux zu verwenden. Wenn Sie Windows verwenden, installieren Sie WSL, um auf die Linux-Umgebung zuzugreifen.

1. Venv-Modul installieren:

sudo apt install python3-venv

2. Erstellen Sie eine virtuelle Umgebung:

python -m venv .venv

3. Aktivieren Sie die virtuelle Umgebung:

source .venv/bin/activate

4. Django installieren:

Installieren Sie Django bei aktivierter virtueller Umgebung:

python -m pip install django

5. Erstellen Sie ein Django-Projekt:

django-admin startproject myproj

Ersetzen Sie myproj durch den gewünschten Projektnamen.

6. Erstellen Sie eine App:

Erstellen Sie in Ihrem Projektverzeichnis eine App.

python manage.py startapp myapp

7. Fügen Sie Ihre neu erstellte App zur Datei „settings.py“ hinzu:

Ihr-Projektname/Ihr-Projektname/settings.py

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

Ihr Projekt ist jetzt mit einer Grundstruktur eingerichtet, einschließlich einer manage.py-Datei, Projekteinstellungen und Ihrer ersten App

Modelle

Modelle definieren die Struktur Ihrer Datenbanktabellen und die Beziehungen zwischen ihnen mithilfe von Python-Klassen. Jede Modellklasse ist einer einzelnen Datenbanktabelle zugeordnet, und jedes Attribut des Modells entspricht einem Datenbankfeld. Django vereinfacht diesen Prozess, indem es Ihnen ermöglicht, Ihr Datenbankschema mithilfe von Klassen zu definieren, die von django.db.models.Model erben.

ORM steht für Object-Relational Mapping. In Django ist ORM eine leistungsstarke Funktion, die es Entwicklern ermöglicht, mithilfe von Python-Code mit der Datenbank zu interagieren, anstatt SQL-Abfragen zu schreiben. Diese Abstraktionsschicht ordnet Python-Klassen (Modelle) Datenbanktabellen und Instanzen dieser Klassen Zeilen in der Tabelle zu.

Wir stellen vor: SQLite

Django verwendet SQLite als Standarddatenbank, da es sehr einfach einzurichten ist. SQLite ist eine schlanke Datenbank, die alle Ihre Daten in einer einfachen Datei speichert, sodass Sie nichts extra installieren müssen, um mit dem Speichern und Verwalten der Daten Ihrer Website zu beginnen. Dies macht es zu einer großartigen Wahl für Entwicklung und Tests, da Sie sich auf die Erstellung Ihrer Anwendung konzentrieren können, ohne sich um komplexe Datenbank-Setups kümmern zu müssen.

In Django wird eine Tabelle namens Airport mit Attributen wie „Code“ und „Stadt“ als Python-Klasse dargestellt, wobei jedes Attribut als Klassenvariable definiert ist.

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

1. Modelle definieren:

Definieren Sie in models.py Ihrer App Ihre Modelle mit Djangos ORM.

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. Migrationen:

Nachdem Sie Ihre Modelle definiert haben, erstellen und wenden Sie Migrationen an, um Ihr Datenbankschema zu aktualisieren.

In einfachen Worten:

• Makemigrations ist wie das Planen der Änderungen, die Sie an Ihrer Datenbank vornehmen möchten.
• migrate führt diese Änderungen tatsächlich in der Datenbank durch. Nach der Planung mit makemigrations erfolgt die Migration also, wenn Sie die Änderungen ausführen und anwenden.

python manage.py makemigrations
python manage.py migrate

3. Interaktion mit Models:

Verwenden Sie Djangos Shell, um mit Ihren Modellen zu interagieren: Python manage.py Shell

Beispiel:

>> from flights.models import Flight

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

Ich habe eine Instanz des Flights-Modells erstellt. Diese Instanz „Flight1“ stellt eine einzelne Zeile in der Flight-Tabelle meiner Datenbank dar. Im Flugmodell sind die Felder Ursprung, Ziel und Dauer definiert.
Wenn Sie die Instanz erstellen. Sie setzen diese Felder auf bestimmte Werte:

• 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

Das obige ist der detaillierte Inhalt vonDjango freigeschaltet: Spawnpunkt für Anfänger. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!