Einrichten einer Django-Entwicklungsumgebung

Django macht es sehr einfach, Ihren eigenen Rechner so einzurichten, dass Sie mit der Entwicklung von Webanwendungen beginnen können. Dieser Abschnitt erklärt, was Sie mit der Entwicklungsumgebung erhalten, und gibt einen Überblick über einige Ihrer Einrichtungs- und Konfigurationsoptionen. Der Rest des Artikels erklärt die empfohlene Methode zur Installation der Django-Entwicklungsumgebung auf Ubuntu, macOS und Windows sowie deren Testmöglichkeiten.

Die Entwicklungsumgebung ist eine Installation von Django auf Ihrem lokalen Computer, die Sie für die Entwicklung und das Testen von Django-Apps verwenden können, bevor Sie diese in einer Produktionsumgebung bereitstellen.

Die wichtigsten Werkzeuge, die Django selbst bereitstellt, sind eine Reihe von Python-Skripten zum Erstellen und Arbeiten mit Django-Projekten sowie ein einfacher Entwicklungs-Webserver, mit dem Sie lokale (d.h. auf Ihrem Computer, nicht auf einem externen Webserver) Django-Webanwendungen im Webbrowser Ihres Computers testen können.

Es gibt weitere Hilfswerkzeuge, die oft Teil der Entwicklungsumgebung sind, die wir hier nicht behandeln werden. Dazu gehören Dinge wie Texteditoren oder IDEs zum Bearbeiten von Code, Lintern zur automatischen Formatierung usw. Wir gehen davon aus, dass Sie bereits einen Texteditor installiert haben.

Django ist extrem flexibel in Bezug darauf, wie und wo es installiert und konfiguriert werden kann. Django kann:

• Auf verschiedenen Betriebssystemen installiert werden.
• Aus dem Quelltext, aus dem Python Package Index (PyPi) und in vielen Fällen über das Paketverwaltungsprogramm des Hostcomputers installiert werden.
• So konfiguriert werden, dass es eine von mehreren Datenbanken verwendet, die möglicherweise ebenfalls separat installiert und konfiguriert werden müssen.
• Im Hauptsystem-Python-Umgebung oder in separaten Python-Virtualumgebungen ausgeführt werden.

Jede dieser Optionen erfordert eine etwas andere Konfiguration und Einrichtung. Die folgenden Unterabschnitte erklären einige Ihrer Möglichkeiten. Für den Rest des Artikels zeigen wir Ihnen, wie Sie Django auf einer kleinen Anzahl an Betriebssystemen einrichten, und davon wird im Rest dieses Moduls ausgegangen.

Welche Betriebssysteme werden unterstützt?

Django-Webanwendungen können auf fast jedem Rechner betrieben werden, der die Programmiersprache Python 3 ausführen kann: Windows, macOS, Linux/Unix, Solaris, um nur einige zu nennen. Fast jeder Computer sollte die notwendige Leistung haben, um Django während der Entwicklung auszuführen.

In diesem Artikel geben wir Anweisungen für Windows, macOS und Linux/Unix.

Welche Python-Version sollte verwendet werden?

Sie können jede Python-Version verwenden, die von Ihrer Zielversion von Django unterstützt wird. Für Django 5.0 sind die zulässigen Versionen Python 3.10 bis 3.12 (siehe FAQ:Installation).

Das Django-Projekt empfiehlt (und "unterstützt offiziell"), die neueste verfügbare Version der unterstützten Python-Version zu verwenden.

Wo können wir Django herunterladen?

Es gibt drei Orte, an denen Sie Django herunterladen können:

• Das Python Package Repository (PyPi) unter Verwendung des pip-Tools. Dies ist der beste Weg, um die neueste stabile Version von Django zu erhalten.
• Verwenden Sie eine Version aus dem Paketmanager Ihres Computers. Mit Betriebssystemen gebündelte Django-Distributionen bieten einen vertrauten Installationsmechanismus. Beachten Sie jedoch, dass die gepackte Version möglicherweise ziemlich alt ist und nur in der System-Python-Umgebung installiert werden kann (was möglicherweise nicht das ist, was Sie möchten).
• Aus dem Quelltext installieren. Sie können die neueste Vorabversion von Django aus dem Quelltext erhalten und installieren. Dies wird für Anfänger nicht empfohlen, ist jedoch erforderlich, wenn Sie bereit sind, selbst zu Django beizutragen.

Dieser Artikel zeigt, wie Sie Django aus PyPi installieren, um die neueste stabile Version zu erhalten.

Welche Datenbank?

Django unterstützt offiziell die Datenbanken PostgreSQL, MariaDB, MySQL, Oracle und SQLite, und es gibt Community-Bibliotheken, die unterschiedliche Unterstützung für andere beliebte SQL- und NoSQL-Datenbanken bieten. Wir empfehlen, dass Sie sowohl für die Produktion als auch für die Entwicklung dieselbe Datenbank auswählen (obwohl Django viele der Datenbankunterschiede mit seinem Objekt-Relationalen Mapper (ORM) abstrahiert, gibt es dennoch potenzielle Probleme, die besser vermieden werden).

Für diesen Artikel (und die meisten Module) verwenden wir die SQLite-Datenbank, die ihre Daten in einer Datei speichert. SQLite ist für den Einsatz als leichte Datenbank gedacht und kann kein hohes Maß an Parallelität unterstützen. Es ist jedoch eine ausgezeichnete Wahl für Anwendungen, die hauptsächlich schreibgeschützt sind.

Systemweit oder in einer Python-Virtualumgebung installieren?

Wenn Sie Python3 installieren, erhalten Sie eine einzige globale Umgebung, die von allen Python3-Codes gemeinsam genutzt wird. Obwohl Sie in der Umgebung beliebige Python-Pakete installieren können, können Sie jeweils nur eine bestimmte Version jedes Pakets installieren.

Wenn Sie Django in der Standard-/globalen Umgebung installieren, können Sie auf dem Computer nur eine Version von Django anvisieren. Dies kann ein Problem darstellen, wenn Sie neue Websites erstellen möchten (unter Verwendung der neuesten Version von Django), während Sie gleichzeitig Websites warten, die auf älteren Versionen basieren.

Daher führen erfahrene Python/Django-Entwickler Python-Apps typischerweise in unabhängigen Python-Virtualumgebungen aus. Dies ermöglicht mehrere verschiedene Django-Umgebungen auf einem einzigen Computer. Das Django-Entwicklerteam selbst empfiehlt, dass Sie Python-Virtualumgebungen verwenden!

In diesem Modul wird angenommen, dass Sie Django in einer virtuellen Umgebung installiert haben, und wir zeigen Ihnen unten, wie das geht.

Um Django nutzen zu können, müssen Sie Python 3 auf Ihrem Betriebssystem installiert haben. Sie benötigen außerdem das Python Package Index-Tool — pip3 —, das zur Verwaltung (Installation, Aktualisierung und Entfernung) von Python-Paketen/Bibliotheken verwendet wird, die von Django und Ihren anderen Python-Apps verwendet werden.

Dieser Abschnitt erklärt kurz, wie Sie überprüfen können, welche Python-Versionen vorhanden sind, und bei Bedarf neue Versionen für Ubuntu Linux 20.04, macOS und Windows 10 installieren.

Ubuntu Linux 22.04 LTS enthält standardmäßig Python 3.10.12. Sie können dies bestätigen, indem Sie den folgenden Befehl im Bash-Terminal ausführen:

python3 -V
# Output: Python 3.10.12

Das Python Package Index Tool (pip3), das Sie zum Installieren von Paketen für Python 3 (einschließlich Django) benötigen, ist jedoch nicht standardmäßig verfügbar. Sie können pip3 im Bash-Terminal mit folgendem Befehl installieren:

sudo apt install python3-pip

macOS beinhaltet standardmäßig nicht Python 3 (Python 2 ist in älteren Versionen enthalten). Sie können dies bestätigen, indem Sie den folgenden Befehl im Terminal ausführen:

python3 -V

Dies zeigt entweder die Python-Versionsnummer an, was darauf hinweist, dass Python 3 installiert ist, oder python3: command not found, was darauf hinweist, dass Python 3 nicht gefunden wurde.

Sie können Python 3 (zusammen mit dem pip3-Tool) einfach von python.org installieren:

1. Laden Sie das erforderliche Installationsprogramm herunter:

   1. Gehen Sie zu https://www.python.org/downloads/macos/.
   2. Laden Sie die stabile Version der neuesten unterstützten Version herunter, die mit Django 5.0 funktioniert. (Zum Zeitpunkt des Schreibens ist dies Python 3.11.8).

2. Suchen Sie die Datei mit Finder und doppelklicken Sie auf die Paketdatei. Befolgen Sie die Installationsanweisungen.

Sie können die erfolgreiche Installation nun bestätigen, indem Sie erneut python3 -V ausführen und die Python-Versionsnummer überprüfen.

Sie können ähnlich überprüfen, ob pip3 installiert ist, indem Sie die verfügbaren Pakete auflisten:

pip3 list

Windows beinhaltet standardmäßig kein Python, aber Sie können es (zusammen mit dem pip3-Tool) ganz einfach von python.org installieren:

1. Laden Sie das erforderliche Installationsprogramm herunter:

   1. Gehen Sie zu https://www.python.org/downloads/windows/.
   2. Laden Sie die stabile Version der neuesten unterstützten Version herunter, die mit Django 5.0 funktioniert. (Zum Zeitpunkt des Schreibens ist dies Python 3.11.8).

2. Installieren Sie Python, indem Sie auf die heruntergeladene Datei doppelklicken und den Installationsanweisungen folgen.

3. Achten Sie darauf, das Kästchen "Python zum Pfad hinzufügen" auszuwählen.

Sie können dann überprüfen, ob Python 3 installiert wurde, indem Sie den folgenden Text in die Eingabeaufforderung eingeben:

py -3 -V

Der Windows-Installer umfasst pip3 (den Python-Paketmanager) standardmäßig. Sie können installierte Pakete wie gezeigt auflisten:

py -3 -m pip list

Sie werden feststellen, dass wir in den vorherigen Abschnitten unterschiedliche Befehle verwenden, um Python 3 und pip auf verschiedenen Betriebssystemen aufzurufen.

Wenn Sie nur Python 3 installiert haben (und nicht Python 2), können die einfachen Befehle python und pip im Allgemeinen verwendet werden, um Python und pip auf jedem Betriebssystem auszuführen. Wenn dies auf Ihrem System erlaubt ist, erhalten Sie einen "3"-Versionsstring, wenn Sie -V mit den einfachen Befehlen ausführen, wie gezeigt:

python -V
pip -V

Wenn Python 2 installiert ist, sollten Sie zur Verwendung von Version 3 Befehle mit python3 und pip3 auf Linux/macOS und py -3 und py -3 -m pip auf Windows voranstellen:

# Linux/macOS
python3 -V
pip3 -V

# Windows
py -3 -V
py -3 -m pip list

Die untenstehenden Anweisungen zeigen die plattformspezifischen Befehle, wie sie auf den meisten Systemen funktionieren.

Die Bibliotheken, die wir zur Erstellung unserer virtuellen Umgebungen verwenden, sind virtualenvwrapper (Linux und macOS) und virtualenvwrapper-win (Windows), die beide das Tool virtualenv verwenden. Die Wrapper-Tools erstellen eine konsistente Schnittstelle zur Verwaltung von Schnittstellen auf allen Plattformen.

Einrichtung der virtuellen Umgebung auf Ubuntu

Nachdem Sie Python und pip installiert haben, können Sie virtualenvwrapper (das virtualenv enthält) installieren. Die offizielle Installationsanleitung finden Sie hier, oder folgen Sie den Anweisungen unten.

Installieren Sie das Tool mit pip3:

sudo pip3 install virtualenvwrapper

Fügen Sie dann die folgenden Zeilen am Ende Ihrer Shell-Startdatei hinzu (diese befindet sich in Ihrem Home-Verzeichnis als versteckte Datei mit dem Namen .bashrc). Diese legen den Speicherort fest, an dem die virtuellen Umgebungen gespeichert werden sollen, den Speicherort Ihrer Entwicklungsprojektverzeichnisse und den Speicherort des mit diesem Paket installierten Skripts:

export WORKON_HOME=$HOME/.virtualenvs
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
export VIRTUALENVWRAPPER_VIRTUALENV_ARGS=' -p /usr/bin/python3 '
export PROJECT_HOME=$HOME/Devel
source /usr/local/bin/virtualenvwrapper.sh

Laden Sie dann die Startdatei neu, indem Sie den folgenden Befehl im Terminal ausführen:

source ~/.bashrc

An diesem Punkt sollten Sie eine Reihe von Skripten sehen, die wie unten gezeigt ausgeführt werden:

virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/premkproject
virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/postmkproject
# …
virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/preactivate
virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/postactivate
virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/get_env_details

Nun können Sie eine neue virtuelle Umgebung mit dem Befehl mkvirtualenv erstellen.

Einrichtung der virtuellen Umgebung auf macOS

Das Einrichten von virtualenvwrapper auf macOS ist fast genau dasselbe wie auf Ubuntu (auch hier können Sie den Anweisungen entweder aus der offiziellen Installationsanleitung oder unten folgen).

Installieren Sie virtualenvwrapper (und Bündelung von virtualenv) mit pip wie gezeigt.

sudo pip3 install virtualenvwrapper

Fügen Sie dann die folgenden Zeilen am Ende Ihrer Shell-Startdatei hinzu (dies sind die gleichen Zeilen wie für Ubuntu). Wenn Sie die zsh shell verwenden, ist die Startdatei eine versteckte Datei namens .zshrc in Ihrem Home-Verzeichnis. Wenn Sie die bash shell verwenden, ist es eine versteckte Datei namens .bash_profile. Sie müssen die Datei möglicherweise erstellen, wenn sie noch nicht vorhanden ist.

export WORKON_HOME=$HOME/.virtualenvs
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
export PROJECT_HOME=$HOME/Devel
source /usr/local/bin/virtualenvwrapper.sh

export WORKON_HOME=$HOME/.virtualenvs
export VIRTUALENVWRAPPER_PYTHON=/Library/Frameworks/Python.framework/Versions/3.7/bin/python3
export PROJECT_HOME=$HOME/Devel
source /Library/Frameworks/Python.framework/Versions/3.7/bin/virtualenvwrapper.sh

Laden Sie dann die Startdatei neu, indem Sie den folgenden Befehl im Terminal aufrufen:

source ~/.bash_profile

An diesem Punkt können Sie möglicherweise eine Reihe von Skripten sehen, die ausgeführt werden (dieselben Skripte wie bei der Installation auf Ubuntu). Sie sollten jetzt in der Lage sein, eine neue virtuelle Umgebung mit dem Befehl mkvirtualenv zu erstellen.

cd ~  # Wechseln Sie zu Ihrem Home-Verzeichnis
ls -la # Listen Sie den Inhalt des Verzeichnisses auf. Sie sollten .bash_profile sehen
nano .bash_profile # Öffnen Sie die Datei im nano-Texteditor innerhalb des Terminals
# Scrollen Sie zum Ende der Datei und fügen Sie die obigen Zeilen ein
# Verwenden Sie Strg + X, um nano zu beenden, und wählen Sie Y, um die Datei zu speichern.

Einrichtung der virtuellen Umgebung unter Windows

Die Installation von virtualenvwrapper-win ist sogar noch einfacher als das Einrichten von virtualenvwrapper, da Sie nicht konfigurieren müssen, wo das Tool Informationen zu virtuellen Umgebungen speichert (es gibt einen Standardwert). Alles, was Sie tun müssen, ist, den folgenden Befehl in der Eingabeaufforderung auszuführen:

py -3 -m pip install virtualenvwrapper-win

Jetzt können Sie eine neue virtuelle Umgebung mit dem Befehl mkvirtualenv erstellen.

Sobald Sie virtualenvwrapper oder virtualenvwrapper-win installiert haben, ist die Arbeit mit virtuellen Umgebungen auf allen Plattformen sehr ähnlich.

Jetzt können Sie eine neue virtuelle Umgebung mit dem Befehl mkvirtualenv erstellen. Während dieses Befehls sehen Sie, wie die Umgebung eingerichtet wird (das, was Sie sehen, hängt leicht von der Plattform ab). Wenn der Befehl abgeschlossen ist, wird die neue virtuelle Umgebung aktiv sein — Sie können dies daran erkennen, dass am Anfang der Eingabeaufforderung der Name der Umgebung in Klammern angezeigt wird (unten zeigen wir dies für Ubuntu, aber die finale Zeile ist auf Windows/macOS ähnlich).

mkvirtualenv my_django_environment

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Running virtualenv with interpreter /usr/bin/python3
# …
virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/t_env7/bin/get_env_details
(my_django_environment) ubuntu@ubuntu:~$

Jetzt, da Sie sich in der virtuellen Umgebung befinden, können Sie Django installieren und mit der Entwicklung beginnen.

Es gibt nur ein paar andere nützliche Befehle, die Sie kennen sollten (es gibt mehr in der Werkzeugdokumentation, aber dies sind die, die Sie regelmäßig verwenden werden):

• deactivate — Beenden Sie die aktuelle Python-Virtualumgebung
• workon — Auflisten der verfügbaren virtuellen Umgebungen
• workon name_of_environment — Aktivieren Sie die angegebene Python-Virtualumgebung
• rmvirtualenv name_of_environment — Entfernen der angegebenen Umgebung.

Sobald Sie eine virtuelle Umgebung erstellt haben und workon aufgerufen haben, um sie zu betreten, können Sie pip3 verwenden, um Django zu installieren.

# Linux/macOS
python3 -m pip install django~=4.2

# Windows
py -3 -m pip install django~=4.2

Sie können testen, ob Django installiert ist, indem Sie den folgenden Befehl ausführen (dies prüft nur, ob Python das Django-Modul finden kann):

# Linux/macOS
python3 -m django --version

# Windows
py -3 -m django --version

py -m django --version

Versionsverwaltung (SCM) und Versionierungstools ermöglichen es Ihnen, zuverlässige Versionen Ihres Quellcodes zu speichern und wiederherzustellen, Änderungen auszuprobieren und Code zwischen Ihren Experimenten und "bekanntem guten Code" bei Bedarf zu teilen.

Es gibt viele verschiedene SCM-Tools, darunter git, Mercurial, Perforce, SVN (Subversion), CVS (Concurrent Versions System) usw., und Cloud-SCM-Hostingquellen wie Bitbucket, GitHub und GitLab. Für dieses Tutorial hosten wir unseren Code auf GitHub, einem der beliebtesten cloudbasierten Dienste zum Hosten von Quellcode, und verwenden das git-Tool, um unseren Quellcode lokal zu verwalten und bei Bedarf an GitHub zu senden.

Git (und GitHub) verwenden Repositories ("Repos") als oberste "Container" zum Speichern von Code, wobei jedes Repo normalerweise den Quellcode für nur eine Anwendung oder ein Modul enthält. Repositories können öffentlich sein, in diesem Fall ist der Code für jeden im Internet sichtbar, oder privat, in diesem Fall sind sie auf das Eigentümerkonto der Organisation oder des Benutzers beschränkt.

Alle Arbeiten werden an einem bestimmten "Zweig" des Codes in Ihrem Repo durchgeführt. Wenn Sie einige Änderungen an einem Zweig sichern möchten, können Sie ein "Commit" erstellen, das alle Änderungen seit Ihrem letzten Commit am aktuellen Zweig speichert.

Das Repo wird mit einem Standardzweig mit dem Namen "main" erstellt. Sie können mit git andere Zweige von diesem abspalten, die zunächst alle Commits des ursprünglichen Zweigs enthalten. Sie können Zweige separat weiterentwickeln, indem Sie Commits hinzufügen und später auf GitHub eine "Pull Request" (PR) verwenden, um Änderungen von einem Zweig in einen anderen zu übernehmen. Sie können auch git verwenden, um zwischen Zweigen auf Ihrem lokalen Rechner zu wechseln, um beispielsweise verschiedene Dinge auszuprobieren.

Zusätzlich zu den Zweigen ist es möglich, Tags auf jedem Zweig zu erstellen und diesen Zweig später zu diesem Punkt wiederherzustellen.

Zuerst erstellen wir ein Konto auf GitHub (dies ist kostenlos). Dann erstellen und konfigurieren wir ein Repository mit dem Namen "django_local_library" zum Speichern der Lokalen Bibliotheks-Website, während wir sie im Rest dieses Tutorials weiterentwickeln.

Die Schritte sind:

1. Besuchen Sie https://github.com/ und erstellen Sie ein Konto.

2. Sobald Sie angemeldet sind, klicken Sie auf den +-Link in der oberen Symbolleiste und wählen Sie Neues Repository.

3. Füllen Sie alle Felder in diesem Formular aus. Obwohl diese nicht verpflichtend sind, werden sie dringend empfohlen.

   • Geben Sie einen Repositorienamen ein: "django_local_library".

   • Geben Sie eine neue Repositorybeschreibung ein: "Lokale Bibliothekswebsite geschrieben in Django".

   • Wählen Sie "Öffentlich" für das Repository (Standard).

     Warnung: Dadurch wird der gesamte Quellcode sichtbar. Denken Sie daran, keine Anmeldedaten oder andere vertrauliche Materialien in Ihrem Repository zu speichern, es sei denn, es ist privat.

   • Wählen Sie Python in der Auswahlkabine Add .gitignore.

   • Wählen Sie Ihre bevorzugte Lizenz in der Auswahlkabine Add license. MDN verwendet "Creative Commons Zero v1.0 Universal" für dieses Beispiel.

   • Aktivieren Sie Initialize this repository with a README.

4. Drücken Sie Repository erstellen.

   Das Repository wird erstellt und enthält nur die Dateien README.txt und .gitignore.

Jetzt, da das Repository ("Repo") auf GitHub erstellt wurde, möchten wir es auf unseren lokalen Computer klonen (kopieren):

1. Klicken Sie auf GitHub auf die grüne Code-Schaltfläche. Wählen Sie im Abschnitt "Klonen" die Registerkarte "HTTPS" und kopieren Sie die URL. Wenn Sie den Repositorynamen "django_local_library" verwendet haben, sollte die URL etwa so aussehen: https://github.com/<Ihr_Git_Benutzer_ID>/django_local_library.git.

2. Installieren Sie git für Ihren lokalen Computer (Sie können Versionen für verschiedene Plattformen hier finden).

3. Öffnen Sie eine Eingabeaufforderung/Terminal und klonen Sie Ihr Repo mit der oben kopierten URL:

   bash

   git clone https://github.com/<your_git_user_id>/django_local_library.git
   

   Dadurch wird das Repository im aktuellen Verzeichnis erstellt.

4. Wechseln Sie in den Repo-Ordner.

   bash

   cd django_local_library
   

Jetzt werden wir die .gitignore-Datei auf dem lokalen Computer ändern, die Änderung commiten und das Repository auf GitHub aktualisieren. Dies ist eine nützliche Änderung, hauptsächlich zeigen wir Ihnen jedoch, wie Sie Änderungen von GitHub abrufen, sie lokal vornehmen und dann an GitHub senden.

1. In der Eingabeaufforderung/Terminal erhalten wir zuerst die neuesten Quellversionen von GitHub und übernehmen sie dann in den aktuellen Zweig:

   Hinweis: Dieser Schritt ist nicht unbedingt erforderlich, da wir den Quellcode gerade geklont haben und wissen, dass er auf dem neuesten Stand ist. Generell sollten Sie jedoch Ihre Quellen von GitHub aktualisieren, bevor Sie Änderungen vornehmen.

   bash

   git fetch origin main
   git pull origin main
   

   Der "origin" ist ein Remote, das den Ort des Repos darstellt, an dem sich die Quelle befindet, und "main" ist der Zweig. Sie können überprüfen, dass "origin" unser Repo auf GitHub ist, indem Sie den Befehl verwenden: git remote -v.

2. Als Nächstes erstellen wir einen neuen Zweig, um unsere Änderungen zu speichern:

   bash

   git checkout -b update_gitignore
   

   Der Befehl checkout wird verwendet, um einen bestimmten Zweig als aktuellen Arbeitszweig auszuwählen. Das -b-Flag zeigt an, dass wir die Absicht haben, einen neuen Zweig namens "update_gitignore" zu erstellen, anstatt einen bestehenden Zweig mit diesem Namen auszuwählen.

3. Öffnen Sie die Datei .gitignore, kopieren Sie die folgenden Zeilen am Ende dieser und speichern Sie:

   # Text backup files
   *.bak
   
   # Database
   *.sqlite3
   

   Beachten Sie, dass .gitignore verwendet wird, um Dateien anzugeben, die nicht automatisch von git gesichert werden sollen, wie temporäre Dateien und andere Build-Artefakte.

4. Verwenden Sie den add-Befehl, um alle geänderten Dateien (die nicht von der .gitignore-Datei ignoriert werden) in den "Staging-Bereich" für den aktuellen Zweig hinzuzufügen.

   bash

   git add -A
   

5. Verwenden Sie den status-Befehl, um zu überprüfen, ob alle Dateien korrekt sind, die Sie commit bereitstellen werden (Sie möchten Quelltexte, keine Binärdateien, temporären Dateien usw. einschließen). Es sollte ungefähr so aussehen:

   bash

   > git status
   On branch main
   Your branch is up-to-date with 'origin/update_gitignore'.
   Changes to be committed:
     (use "git reset HEAD <file>..." to unstage)
   
           modified:   .gitignore
   

6. Wenn Sie zufrieden sind, machen Sie ein commit an die Dateien im lokalen Repo, wobei das -m-Flag verwendet wird, um eine prägnante, aber klare Commit-Nachricht anzugeben. Dies entspricht der Unterzeichnung der Änderungen und der offiziellen Aufnahme in das lokale Repo.

   bash

   git commit -m ".gitignore: add .bak and .sqlite3"
   

7. Zu diesem Zeitpunkt wurde das Remote-Repository nicht geändert. Wir können den Zweig update_gitignore an das "origin"-Repository (GitHub) mit folgendem Befehl senden:

   bash

   git push origin update_gitignore
   

8. Gehen Sie zurück zur Seite auf GitHub, auf der Sie Ihr Repository erstellt haben, und aktualisieren Sie die Seite.

   Ein Banner sollte mit einer Schaltfläche erscheinen, die Sie drückt, wenn Sie den soeben hochgeladenen Zweig "Vergleichen und Pull Request" möchten. Wählen Sie die Schaltfläche und folgen Sie den Anweisungen, um ein Pull Request zu erstellen und dann zu mergen.

   

   Nach dem Mergen enthält der "main"-Zweig im Repository auf GitHub Ihre Änderungen an .gitignore.

9. Sie können Ihr lokales Repo weiterhin aktualisieren, wenn sich Dateien durch diesen Hinzufügs-/Commits-/Push-Zyklus ändern.

Im nächsten Thema verwenden wir dieses Repo, um unseren lokalbibliotheksquellen Code zu speichern.

Erfahrene Python-Entwickler installieren möglicherweise zusätzliche Tools, wie Linters (die helfen, häufige Fehler im Code zu erkennen).

Beachten Sie, dass Sie einen Django-kompatiblen Linter wie pylint-django verwenden sollten, da einige gängige Python-Linters (wie pylint) fälschlicherweise Fehler in den von Django generierten Standarddateien melden.

Der obige Test funktioniert, macht aber nicht viel Spaß. Ein interessanterer Test besteht darin, ein Grundgerüstprojekt zu erstellen und zu sehen, wie es funktioniert. Gehen Sie dazu zunächst zu Ihrem Kommandozeile/Terminal, um den Ort zu bestimmen, an dem Sie Ihre Django-Apps speichern möchten. Erstellen Sie einen Ordner für Ihre Testsite und navigieren Sie hinein.

mkdir django_test
cd django_test

Sie können dann eine neue Grundgerüstsite namens "mytestsite" mit dem django-admin-Tool erstellen, wie gezeigt. Nach der Erstellung der Site können Sie in den Ordner navigieren, in dem sich das Hauptskript zur Verwaltung von Projekten befindet, namens manage.py.

django-admin startproject mytestsite
cd mytestsite

Wir können den Entwicklungs-Webserver aus diesem Ordner mit manage.py und dem runserver-Befehl starten, wie gezeigt.

# Linux/macOS
python3 manage.py runserver

# Windows
py -3 manage.py runserver

Sobald der Server läuft, können Sie die Site anzeigen, indem Sie zu der folgenden URL in Ihrem lokalen Webbrowser navigieren: http://127.0.0.1:8000/. Sie sollten eine Seite sehen, die so aussieht:

Sie haben nun eine Django-Entwicklungsumgebung auf Ihrem Computer eingerichtet.

Im Abschnitt zum Testen haben Sie auch kurz gesehen, wie wir eine neue Django-Website mit django-admin startproject erstellen und sie im Browser mit dem Entwicklungs-Webserver (python3 manage.py runserver) ausführen können. Im nächsten Artikel erweitern wir diesen Prozess und erstellen eine einfache, aber vollständige Webanwendung.

• Kurzanleitung zur Installation (Django-Dokumentation)
• So installieren Sie Django — Vollständige Anleitung (Django-Dokumentation) — behandelt auch, wie Django entfernt wird
• So installieren Sie Django auf Windows (Django-Dokumentation)

• Zurück
• Übersicht: Django-Webframework (Python)
• Weiter