Man sagt, dass man mehr Wissen erlangt, wenn man sein Lernen, seine Schwierigkeiten usw. dokumentiert. Deshalb habe ich ab diesem Tag, dem 15. Juli 2024, beschlossen, meine Fortschritte beim Erlernen von Django zu dokumentieren, indem ich eine Blog-App entwickle, ohne ChatGPT, Gemini und andere KI-Chatbots zu verwenden, die Code generieren können.
In den letzten Jahren habe ich mithilfe von ChatGPT Anwendungen erstellt, um Code für mich zu generieren, und das Ergebnis war großartig, ich konnte die Anwendungen erstellen. Allerdings verlasse ich mich zu sehr auf ChatGPT und verstehe die Konzepte der Programmierung nicht wirklich. Ich habe das Gefühl, dass ich bei der Entwicklung von Anwendungen nicht in der Lage bin, von Grund auf zu programmieren, und dass es ohne die Hilfe von ChatGPT nutzlos ist. Von diesem Punkt an werde ich mein Bestes tun, um die Dokumentation zum Erstellen dieser einfachen Blog-App zu lesen und zu verstehen.
Diese Woche habe ich meine Reise zum Erlernen von Django mit der Erstellung einer einfachen Blog-App begonnen. Mein Ziel ist es, jeden Schritt des Prozesses zu dokumentieren und meine Erfahrungen und Erkenntnisse aufzuzeigen.
Einrichten des Projekts
Schritt 1: Erstellen Sie eine virtuelle Umgebung
Zuerst habe ich eine virtuelle Umgebung erstellt, um Projektabhängigkeiten zu verwalten:
python -m venv <myenv> source myenv/bin/activate # On Windows use `myenv\Scripts\activate`
Schritt 2: Django installieren und neues Django-Projekt erstellen
Als nächstes habe ich Django installiert und ein neues Projekt namens blog_app
erstellt
pip install django # Create new django project django-admin startproject blog_app cd blog_app
Schritt 1: Einrichten der App
Ich habe zuerst die Benutzerauthentifizierung
erstellt
# Either of the two django-admin startapp user python manage.py startapp user
Ich habe dann die neue App zur Liste INSTALLED_APPS in der Datei „settings.py“ hinzugefügt.
Schritt 2: Anmelde- und Anmeldeformulare für Benutzer erstellen
Ich habe die Datei „forms.py“ im App-Ordner des Benutzers erstellt. Ich verwende die in Django integrierten AuthenticationForm und UserCreationForm, indem ich sie an die benutzerdefinierte Klasse vererbe. Ich denke, auf diese Weise kann ich später die Benutzerinformationen anpassen.
# user/forms.py from django.contrib.auth.forms import AuthenticationForm, UserCreationForm from django.forms.widgets import PasswordInput, TextInput from django.forms.fields import EmailField from django import forms class LoginForm(AuthenticationForm): username = forms.CharField(widget=TextInput()) password = forms.CharField(widget=PasswordInput()) class SignUpForm(UserCreationForm): username = forms.CharField(max_length=150, required=True) email = forms.EmailField(required=True) password1 = forms.CharField(widget=forms.PasswordInput, required=True) password2 = forms.CharField(widget=forms.PasswordInput, required=True) def save(self, commit=True): user = super().save(commit=False) user.email = self.cleaned_data["email"] if commit: user.save() return user
Schritt 3: Ansichten.py erstellen
Anschließend habe ich eine Ansicht für die Startseite, Anmeldung, Abmeldung und Anmeldung erstellt. Ich werde in diesem Projekt nicht darauf eingehen, wie ich HTML, CSS und Javascript erstellt habe. Wenn Sie es überprüfen möchten, verlinke ich unten mein Github-Repository.
# user/views.py
from django.shortcuts import render, redirect
from django.contrib.auth.decorators import login_required
from django.contrib.auth import logout, authenticate, login
from .forms import *
from django.contrib.auth.models import auth
# I use the decorator `login_required` in order for the application to navigate to the login page if the user has not login or sign up yet.
@login_required
def homeView(request):
return render(request, "home.html")
def loginView(request):
'''
First, I initialized my custom LoginForm then it will check the request of the user.
The user will then input it's username and password. Then it will check if the form is valid then it will get the user's input credential and it will authenticate it by using the built-in Django `authenticate` method. It will then check if the user correctly input it's credential and it will call the `login` method of Django and redirect the user to the homepage.
'''
form = LoginForm()
if request.method == "POST":
form = LoginForm(request, data=request.POST)
if form.is_valid():
username = request.POST.get("username")
password = request.POST.get("password")
user = authenticate(request, username=username, password=password)
if user is not None:
auth.login(request, user)
return redirect("user:home")
return render(request, "login.html", {"form": form})
def signupView(request):
'''
We will get the request from the user and check if the form is valid the we wills ave the user information in our SignUpForm
'''
if request.method == "POST":
form = SignUpForm(request.POST)
if form.is_valid():
form.save()
return redirect("user:login")
else:
form = SignUpForm()
return render(request, "signup.html", {"form": form})
def logoutView(request):
'''
I use the Django built-in `logout` method to logut the user
'''
logout(request)
return redirect("user:login")
Schritt 4: URLs hinzugefügt
Ich habe dann die URLs für den Benutzer hinzugefügt. Zuerst habe ich in blog_app/urls.py eine Startseite/leere URLs hinzugefügt.
# blog_app/urls.py
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path("", include("user.urls", "user")),
path("admin/", admin.site.urls),
]
Dann habe ich eine urls.py im Benutzerverzeichnis erstellt.
# user/urls.py
from django.urls import path, include
from .views import *
app_name = "user"
urlpatterns = [
path("", homeView, name="home"),
path("signup/", signupView, name="sign-up"),
path("login/", loginView, name="login"),
path("logout/", logoutView, name="logout"),
]
Ich habe eine Variable app_name erstellt und den Benutzer zugewiesen. Wie Sie oben in der Datei „views.py“ sehen können, verwende ich hier anstelle von „templates/html.py“ user:login. Ich habe gelernt, dass ich damit, wenn ich ein großes Projekt erstelle, leicht bestimmen kann, in welche App die Funktion der Ansichten ich umleite.
Diese Woche stand ich vor einigen Herausforderungen, wie zum Beispiel:
Allerdings habe ich viel über die Grundlagen von Django und die Strukturierung eines Projekts gelernt. Mir ist auch bewusst, wie wichtig es ist, die Dokumentation gründlich zu lesen. Nun, ich kann immer noch nicht aufhören, ChatGPT zu verwenden, um Fragen zu dem Fehler zu stellen, auf den ich gestoßen bin, aber ich fordere es auf, damit ich keinen Beispielcode, sondern nur einfache Erklärungen bekomme.
Ich habe vor:
Das obige ist der detaillierte Inhalt vonWoche Erste Schritte mit meiner Blog-App. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
