Komplette Webanwendungen mit Python entwickeln

• Einführung
• Kapitel 1 Einrichten Ihrer Python-Entwicklungsumgebung
• Kapitel 2 Grundlegende Python-Konzepte für die Webentwicklung
• Kapitel 3 Das Web verstehen: HTTP, Server und Clients
• Kapitel 4 Wahl Ihres Web-Frameworks: Ein Überblick über Django und Flask
• Kapitel 5 Ihre erste Webanwendung mit Flask
• Kapitel 6 Routing, Views und URL-Verarbeitung
• Kapitel 7 Templating mit Jinja2 zur Darstellung dynamischer Daten
• Kapitel 8 Einführung in Datenbanken und SQLAlchemy
• Kapitel 9 Entwerfen und Verwalten von Datenbankmodellen
• Kapitel 10 Verarbeiten von Benutzereingaben mit Webformularen
• Kapitel 11 Implementieren von Benutzerauthentifizierung und Sitzungsverwaltung
• Kapitel 12 Erstellen einer RESTful-API für Ihre Anwendung
• Kapitel 13 Nutzung von APIs auf der Serverseite
• Kapitel 14 Frontend-Grundlagen: HTML, CSS und modernes JavaScript
• Kapitel 15 Asynchrone Operationen mit JavaScript und der Fetch API
• Kapitel 16 Integration eines JavaScript-Frameworks mit Ihrem Python-Backend
• Kapitel 17 Hintergrundaufgaben und Job-Warteschlangen mit Celery und Redis
• Kapitel 18 Echtzeitkommunikation mit WebSockets
• Kapitel 19 Schreiben von Tests für Ihre Webanwendung
• Kapitel 20 Wesentliche Web-Sicherheitspraktiken
• Kapitel 21 Anwendungskonfiguration und Umgebungsverwaltung
• Kapitel 22 Containerisierung Ihrer Anwendung mit Docker
• Kapitel 23 Einrichten einer CI/CD-Pipeline für Automatisierung
• Kapitel 24 Bereitstellen Ihrer Anwendung auf einem Produktionsserver
• Kapitel 25 Überwachung, Protokollierung und Skalierung Ihrer Anwendung

Willkommen zur großen Tour durch das Erstellen von Dingen für jenes riesige, vernetzte und gelegentlich verwirrende Netzwerk, das wir das Web nennen. Wenn Sie je eine Website oder eine Webanwendung angesehen und gedacht haben: „Ich frage mich, wie das funktioniert“, oder noch ehrgeiziger: „Ich glaube, ich könnte das bauen“, dann sind Sie hier genau richtig. Dieses Buch ist Roadmap, Werkzeugkasten und freundlicher Führer in einem, konzipiert, um Sie vom neugierigen Beobachter zu einem fähigen Schöpfer moderner Webanwendungen zu führen. Unser Werkzeug der Wahl für diese Reise ist Python, eine Sprache, die für ihre Einfachheit, Kraft und überraschende Vielseitigkeit bekannt ist.

Stellen Sie sich den Bau einer Webanwendung wie den Bau eines Hauses vor. Sie würden nicht einfach anfangen, Bretter wahllos zusammenzunageln. Sie bräuchten einen Bauplan, ein solides Fundament, einen stabilen Rahmen, funktionierende Sanitär- und Elektrosysteme und schließlich das Innendesign und den Außenanstrich, die es zu einem Ort machen, in dem jemand tatsächlich leben möchte. Jede Komponente ist einzigartig, doch sie müssen alle nahtlos zusammenarbeiten. Ein Haus mit perfekter Sanitärinstallation, aber ohne Dach, ist kein Haus – es ist ein Problem. Ähnlich ist eine Webanwendung mehr als nur eine Ansammlung von Codedateien; es ist ein vollständiges System, und unser Ziel ist es, Ihnen beizubringen, wie Sie Architekt, Ingenieur und Innendesigner Ihrer eigenen digitalen Kreationen werden.

Diese Reise geht nicht darum, einfach eine Liste von Befehlen zu lernen oder Syntax auswendig zu lernen. Es geht darum, die Prinzipien zu verstehen, die das Web regeln. Es geht darum, zu lernen, wie ein Entwickler zu denken, komplexe Probleme in handhabbare Teile zu zerlegen und robuste, sichere und skalierbare Lösungen zu bauen. Wir werden über die „Hallo Welt!“-Beispiele hinausgehen und tief in die Konstruktion von Anwendungen eintauchen, die Benutzerkonten verwalten, Daten managen, mit anderen Diensten kommunizieren und dem Endbenutzer ein poliertes, interaktives Erlebnis bieten. Das ist eine große Aufgabe, aber jede komplexe Fähigkeit ist nur eine Reihe einfacherer Fähigkeiten, die aufeinander aufbauen.

Warum Python, fragen Sie sich vielleicht? In einer Welt voller unzähliger Programmiersprachen, was macht Python so besonders für die Webentwicklung? Die Antwort liegt in seiner Kernphilosophie. Python wurde so entworfen, dass es lesbar und unkompliziert ist. Seine Syntax ist sauber und intuitiv, oft dem einfachen Englisch ähnlich, was Entwicklern erlaubt, komplexe Ideen mit weniger Codezeilen auszudrücken. Diese Einfachheit geht nicht auf Kosten der Macht. Python ist eine hochgradig vielseitige und effiziente Sprache, die alles bewältigen kann – von einfachen Skripten bis hin zur komplexen Backend-Logik, die einige der weltweit beliebtesten Websites und Dienste antreibt, darunter Giganten wie Google, Instagram und Spotify.

Dieser Fokus auf Lesbarkeit und Einfachheit macht Python zu einer ausgezeichneten Sprache für Anfänger, aber es ist auch der Grund, warum es von erfahrenen Profis vertraut wird. Wenn Sie an einem großen Projekt arbeiten oder mit einem Team von Entwicklern zusammenarbeiten, ist Code, der leicht zu lesen und zu verstehen, unschätzbar wertvoll. Darüber hinaus verfügt Python über eine riesige und aktive Community. Das bedeutet, Sie haben Zugriff auf ein gewaltiges Ökosystem an Bibliotheken, Frameworks und Tools, die den Entwicklungsprozess erheblich beschleunigen können. Sie müssen das Rad nicht jedes Mal neu erfinden, wenn Sie eine häufige Aufgabe erledigen müssen; die Chancen stehen gut, dass jemand in der Python-Community bereits eine zuverlässige Lösung dafür gebaut hat.

Die Sprache ist auch unglaublich flexibel. Sie passt sich verschiedenen Programmierstilen an, egal ob Sie einen objektorientierten, funktionalen oder imperativen Ansatz bevorzugen. Diese Anpassungsfähigkeit bedeutet, dass Sie den besten Stil für die jeweilige Aufgabe wählen können. Im Kontext der Webentwicklung wird diese Flexibilität durch mächtige Web-Frameworks wie Django und Flask unterstützt, die die Struktur und Werkzeuge bereitstellen, die nötig sind, um Webanwendungen effizient zu bauen. Diese Frameworks übernehmen viele der mühsamen, repetitiven Aufgaben der Webentwicklung, sodass Sie sich auf die einzigartige Logik und die Features Ihrer Anwendung konzentrieren können. Im gesamten Buch werden wir diese Stärken nutzen, um unsere Anwendungen von Grund auf zu bauen.

Was genau meinen wir also mit einer „vollständigen“ Webanwendung? Der Begriff wird oft verwendet, aber er bezeichnet eine entscheidende Unterscheidung. Eine einfache Website zeigt vielleicht nur statische Informationen an, wie eine Broschüre. Eine Webanwendung hingegen ist interaktiv. Es ist ein Programm, das auf einem Server läuft und über einen Webbrowser aufgerufen wird, und es erlaubt Benutzern nicht nur, Inhalte zu konsumieren, sondern sie zu erstellen, zu manipulieren und mit ihnen zu interagieren. Denken Sie an den Unterschied zwischen dem Lesen eines Nachrichtenartikels online (eine Website) und dem Verfassen und Versenden einer E-Mail über einen Dienst wie Gmail (eine Webanwendung).

Eine vollständige Anwendung umfasst zwei Hauptkomponenten: das Frontend und das Backend. Das Frontend ist das, was der Benutzer sieht und mit dem er interagiert – das Layout, die Schaltflächen, die Formulare. Es ist die Client-Seite der Anwendung. Das Backend ist die Server-Seite, der Maschinenraum, in dem die Kernlogik der Anwendung lebt. Es verarbeitet Anfragen des Benutzers, interagiert mit der Datenbank, um Informationen zu speichern und abzurufen, und verarbeitet Daten. Ein Full-Stack-Entwickler ist jemand, der sich auf beiden Seiten dieser Trennlinie wohlfühlt, und genau das will Sie dieses Buch machen.

Aber „vollständig“ geht noch weiter. Eine wirklich vollständige Anwendung ist auch eine, die für die reale Welt bereit ist. Das bedeutet, sie muss getestet werden, um sicherzustellen, dass sie wie erwartet funktioniert und frei von Fehlern ist. Sie muss sicher sein, um sowohl die Anwendung als auch ihre Benutzer vor bösartigen Angriffen zu schützen. Sie muss konfigurierbar sein, damit sie in verschiedenen Umgebungen laufen kann, wie Ihrem lokalen Entwicklungsrechner und einem echten Produktionsserver. Und schließlich muss sie bereitstellbar sein, was bedeutet, dass Sie einen Prozess haben, um Ihre Anwendung auf einen Server zu bringen, wo Benutzer darauf zugreifen können, sowie eine Strategie zur Überwachung ihrer Leistung und Skalierung, während Ihre Benutzerbasis wächst. Unsere Reise wird all diese Phasen abdecken.

Dieses Buch ist so strukturiert, dass es Sie logisch durch diesen gesamten Prozess führt, wobei jedes Kapitel auf dem Wissen und den Fähigkeiten der vorherigen aufbaut. Wir beginnen unsere Reise ganz am Anfang und stellen sicher, dass Sie ein solides Fundament haben, bevor wir anfangen, komplexere Komponenten zu bauen. Der erste Teil des Buches dreht sich ganz um das Vorbereiten der Bühne. In Kapitel Eins werden wir die Einrichtung Ihrer Python-Entwicklungsumgebung durchgehen. Das ist ein entscheidender erster Schritt, der sicherstellt, dass Sie alle notwendigen Werkzeuge installiert und korrekt konfiguriert haben. Wir werden Konzepte wie virtuelle Umgebungen entmystifizieren, die für die Verwaltung von Projektabhängigkeiten unerlässlich sind.

Mit unserer fertigen Umgebung taucht Kapitel Zwei in die Kernkonzepte von Python ein, die für die Webentwicklung am relevantesten sind. Wir werden nicht versuchen, Ihnen die gesamte Python-Sprache beizubringen, sondern uns auf die spezifischen Features und Muster konzentrieren, die Sie immer wieder beim Bau von Webanwendungen verwenden werden. Kapitel Drei macht einen Schritt zurück vom Code, um die fundamentalen Prinzipien des Webs selbst zu erklären. Wir werden das Hypertext Transfer Protocol (HTTP) und das Client-Server-Modell erforschen, das der gesamten Kommunikation im Web zugrunde liegt. Diese Konzepte zu verstehen, ist für jeden Webentwickler lebenswichtig, da sie diktieren, wie Ihre Anwendung mit den Browsern der Benutzer interagieren wird.

Der zweite Teil des Buches markiert unseren Übergang von der Theorie zur Praxis, während wir beginnen, den Kern unserer Webanwendung zu bauen. Kapitel Vier bietet einen Überblick über die zwei beliebtesten Python-Web-Frameworks: Django und Flask. Wir werden ihre Philosophien, Stärken und Schwächen diskutieren, um Ihnen zu helfen zu verstehen, warum Sie sich für das eine oder das andere entscheiden könnten. Mit diesem Wissen wird Kapitel Fünf Sie durch den Bau Ihrer allerersten Webanwendung mit Flask führen, einem leichten und flexiblen Framework, das hervorragend zum Erlernen der Grundlagen geeignet ist.

Von dort aus werden wir anfangen, Funktionalitätsebenen hinzuzufügen. Kapitel Sechs befasst sich mit Routing und wie man URLs auf spezifische Funktionen in Ihrem Code abbildet, die Benutzeranfragen bearbeiten. Kapitel Sieben führt das Konzept des Templating mit Jinja2 ein, das es Ihnen erlaubt, dynamische HTML-Inhalte zu generieren, indem Sie Logik und Daten direkt in Ihre Templates einbetten. So gelangen Sie vom Ausliefern statischer Seiten zur Erstellung personalisierter Benutzererlebnisse.

Keine bedeutende Webanwendung ist komplett ohne eine Möglichkeit, Daten zu speichern, was uns zum dritten Teil unserer Reise bringt: Datenbanken und Benutzerinteraktion. Kapitel Acht bietet eine Einführung in Datenbanken und SQLAlchemy, einen mächtigen Object-Relational Mapper (ORM), der es Ihnen erlaubt, mit Ihrer Datenbank mithilfe von Python-Objekten statt roher SQL-Abfragen zu interagieren. In Kapitel Neun werden wir dieses Wissen nutzen, um die Datenbankmodelle zu entwerfen und zu verwalten, die das Rückgrat der Datenstruktur unserer Anwendung bilden.

Sobald wir Daten speichern können, ist der nächste logische Schritt, Benutzern zu erlauben, sie zu übermitteln. Kapitel Zehn behandelt die Verarbeitung von Benutzereingaben über Webformulare, eine kritische Komponente für alles, von einfachen Kontaktformularen bis hin zu komplexer Dateneingabe. Mit Benutzereingaben kommt der Bedarf an Benutzerkonten, und Kapitel Elf widmet sich den wichtigen Themen Benutzerauthentifizierung und Sitzungsmanagement und lehrt Sie, wie Sie Benutzeranmeldungen sicher verwalten und sensible Bereiche Ihrer Anwendung schützen.

Der vierte Abschnitt des Buches erweitert die Fähigkeiten unserer Anwendung, indem er Application Programming Interfaces, kurz APIs, erforscht. In Kapitel Zwölf lernen Sie, wie Sie eine RESTful API für Ihre eigene Anwendung bauen. Dies wird es anderen Programmen, wie einer mobilen App oder einem anderen Webdienst, erlauben, programmatisch mit den Daten Ihrer Anwendung zu interagieren. Kapitel Dreizehn kehrt den Spieß um und zeigt Ihnen, wie Sie Drittanbieter-APIs aus Ihrem Server-seitigen Code konsumieren, wodurch Sie Daten und Funktionalität anderer Dienste in Ihre eigene Anwendung integrieren können.

Mit einem mächtigen Backend an Ort und Stelle wendet der fünfte Teil unseres Buches seine Aufmerksamkeit dem Frontend zu, dem Teil der Anwendung, den Benutzer sehen und anfassen. Kapitel Vierzehn deckt die Grundlagen der modernen Frontend-Entwicklung ab, einschließlich HTML für Struktur, CSS für Styling und die Grundlagen von JavaScript für Interaktivität. Kapitel Fünfzehn taucht in asynchrone Operationen mit JavaScript und der Fetch API ein, die es Ihnen erlaubt, Daten von Ihrer Backend-API anzufordern, ohne die gesamte Seite neu laden zu müssen, was ein flüssigeres und reaktionsschnelleres Benutzererlebnis schafft.

Um unser Frontend auf die nächste Stufe zu heben, erforscht Kapitel Sechzehn, wie man ein modernes JavaScript-Framework wie React oder Vue.js mit Ihrem Python-Backend integriert. Diese Kombination aus einer mächtigen Python-API und einem dynamischen JavaScript-Frontend ist das Fundament vieler der heute anspruchsvollsten Webanwendungen. Hier überbrücken wir wirklich die Kluft zwischen Backend-Logik und einem reichen, client-seitigen Benutzererlebnis.

Der sechste Teil des Buches wagt sich in fortgeschrittenere Themen der realen Welt vor, die professionelle Anwendungen von einfachen Hobbyprojekten unterscheiden. Kapitel Siebzehn führt Hintergrundaufgaben und Job-Warteschlangen mit Celery und Redis ein. Diese Technologie ist essenziell für den Umgang mit zeitaufwendigen Operationen, wie dem Versenden von E-Mails oder der Verarbeitung großer Dateien, ohne den Benutzer warten zu lassen. In Kapitel Achtzehn erforschen wir Echtzeitkommunikation mit WebSockets, die eine sofortige, bidirektionale Kommunikation zwischen Client und Server ermöglicht – perfekt für Anwendungen wie Chatrooms oder Live-Benachrichtigungen.

Kein professioneller Entwickler kann effektiv sein ohne ein solides Verständnis von Testing und Sicherheit. Daher ist Kapitel Neunzehn dem Schreiben von Tests für Ihre Webanwendung gewidmet. Sie lernen verschiedene Testarten kennen und wie Sie sie nutzen, um sicherzustellen, dass Ihre Anwendung zuverlässig ist und Fehler auffängt, bevor sie Ihre Benutzer erreichen. Kapitel Zwanzig folgt mit einer entscheidenden Diskussion über essenzielle Web-Sicherheitspraktiken, die gängige Schwachstellen und die Schritte abdeckt, die Sie unternehmen müssen, um Ihre Anwendung und ihre Daten vor Angriffen zu schützen.

Schließlich ist der siebte und letzte Teil des Buches ganz darauf ausgerichtet, Ihre Anwendung aus der Entwicklungsumgebung in die reale Welt zu bringen – ein Prozess, der als Deployment und Operations bekannt ist. Kapitel Einundzwanzig behandelt Anwendungs-Konfiguration und Umgebungsmanagement und lehrt Sie, wie Sie mit sensiblen Informationen wie API-Schlüsseln umgehen und Ihre Anwendung so konfigurieren, dass sie in verschiedenen Settings läuft. Kapitel Zweiundzwanzig führt Docker ein, eine Containerisierungstechnologie, die es Ihnen erlaubt, Ihre Anwendung und all ihre Abhängigkeiten in eine standardisierte Einheit zu verpacken für einfaches Deployment.

Darauf aufbauend führt Sie Kapitel Dreiundzwanzig durch die Einrichtung einer Continuous Integration und Continuous Deployment (CI/CD) Pipeline. Dieser automatisierte Prozess wird Ihre Anwendung bei jeder Änderung automatisch bauen, testen und deployen, was Ihren Entwicklungs-Workflow dramatisch beschleunigt. In Kapitel Vierundzwanzig werden wir alles zusammenbringen und Ihre containerisierte Anwendung auf einen Produktionsserver deployen, wodurch sie für Benutzer weltweit zugänglich wird. Unsere Reise endet mit Kapitel Fünfundzwanzig, das die laufenden Aufgaben von Monitoring, Logging und Skalierung Ihrer Anwendung abdeckt, um sicherzustellen, dass sie gesund, performant bleibt und eine wachsende Zahl von Benutzern bewältigen kann.

Dieses Buch richtet sich an jeden, der ein grundlegendes Verständnis von Programmierkonzepten hat und diese auf den Bau von Webanwendungen mit Python anwenden möchte. Vielleicht sind Sie ein Student, der die Grundlagen von Python gelernt hat und sich fragt, was als Nächstes zu bauen ist. Vielleicht sind Sie ein Entwickler, der von einer anderen Sprache kommt und sehen möchte, was das Python-Ökosystem zu bieten hat. Oder Sie könnten ein autodidaktischer Programmierer sein, der nach einem strukturierten Pfad sucht, um den gesamten Stack der für moderne Webentwicklung erforderlichen Technologien zu erlernen. Während wir eine gewisse grundlegende Programmiererfahrung voraussetzen, werden wir alle web-spezifischen Konzepte von Grund auf erklären.

Die Welt der Webentwicklung ist eine riesige und sich ständig weiterentwickelnde Landschaft. Neue Frameworks, Bibliotheken und Werkzeuge tauchen ständig auf. Es kann einschüchternd sein zu wissen, wo man anfangen soll. Das Ziel dieses Buches ist nicht, Ihnen jedes einzelne verfügbare Werkzeug beizubringen, sondern Ihnen ein tiefes Verständnis der fundamentalen Prinzipien und Muster zu vermitteln, die den Test der Zeit bestanden haben. Die spezifischen Technologien, die wir nutzen – Flask, SQLAlchemy, Docker – sind mächtig und beliebt, aber die Konzepte dahinter sind universell. Indem wir uns auf diese Kernideen konzentrieren, werden Sie bestens gerüstet sein, um sich anzupassen und neue Technologien zu lernen, sobald sie auftauchen.

Wir ermutigen Sie, dieses Buch nicht nur als etwas zu betrachten, das man liest, sondern als etwas, das man tut. Der beste Weg, zu lernen, wie man Webanwendungen baut, ist, sie zu bauen. Folgen Sie den Beispielen mit, tippen Sie den Code selbst ein, anstatt ihn zu kopieren und einzufügen, und scheuen Sie sich nicht zu experimentieren. Machen Sie Dinge kaputt, reparieren Sie sie, und versuchen Sie zu verstehen, warum sie überhaupt kaputtgegangen sind. Der Code für alle Projekte in diesem Buch wird Ihnen als Referenz zur Verfügung stehen, aber das echte Lernen wird passieren, wenn Sie die Projekte zu Ihren eigenen machen. Ändern Sie die Features, fügen Sie neue hinzu, und nutzen Sie das, was Sie hier lernen, als Sprungbrett für Ihre eigenen Ideen.

Also, krempeln Sie die Ärmel hoch und bereiten Sie sich darauf vor, die Hände beim Coden schmutzig zu machen. Wir haben einen langen und aufregenden Weg vor uns, gefüllt mit Herausforderungen, Entdeckungen und der immensen Befriedigung, etwas aus dem Nichts zu erschaffen. Am Ende dieses Buches werden Sie nicht nur eine vollständige, funktionsreiche Webanwendung gebaut haben, sondern – was noch wichtiger ist – das Wissen und das Vertrauen gewonnen haben, um jede Webanwendung zu bauen, die Sie sich vorstellen können. Legen wir los.

Willkommen im Maschinenraum. Bevor wir mit dem Architekturbau und der Entwicklung unserer großen Webanwendung beginnen können, müssen wir unsere Werkzeuge zusammenstellen und unsere Werkstatt vorbereiten. Diese initiale Einrichtungsphase ist wohl einer der wichtigsten Schritte im gesamten Entwicklungsprozess. Eine gut organisierte und korrekt konfigurierte Entwicklungsumgebung ist das Fundament, auf dem all Ihre zukünftige Arbeit aufbauen wird. Sie stellt sicher, dass Ihre Projekte stabil, reproduzierbar und frei von den frustrierenden, schwer zu diagnostizierenden Problemen sind, die aus konfligierenden Softwareversionen entstehen können. Betrachten Sie es als das Stimmen Ihrer Instrumente vor einem Konzert; die Zeit, die Sie jetzt investieren, wird sich immens auszahlen, da sie es Ihnen ermöglicht, sich auf den kreativen Prozess des Programmierens zu konzentrieren, anstatt mit Ihren Werkzeugen zu ringen. Unser Ziel in diesem Kapitel ist es, diesen Einrichtungsprozess Schritt für Schritt durchzugehen – von der Installation von Python selbst bis zur Konfiguration eines modernen Code-Editors. Am Ende werden Sie über einen professionellen Arbeitsplatz verfügen, der bereit ist für die Projekte in diesem Buch und jedes andere Python-Projekt, das Sie sich vorstellen können.

Python installieren

Unsere erste Aufgabe ist es, Python auf Ihren Rechner zu bekommen. Obwohl dies wie ein einfacher Download-und-Installieren-Vorgang klingen mag, gibt es je nach Betriebssystem ein paar Feinheiten zu beachten. Viele Systeme, insbesondere macOS und diverse Linux-Distributionen, werden mit einer vorinstallierten Python-Version ausgeliefert. Diese „System-Python“-Version ist jedoch oft älter (manchmal die mittlerweile nicht mehr unterstützte Python 2) und sollte am besten unangetastet bleiben. Das Betriebssystem selbst könnte auf diese spezifische Version für seine eigenen Skripte angewiesen sein, und Eingriffe daran können zu unvorhersehbaren Problemen führen. Wir werden immer unsere eigene, separate, aktuelle Python-Version installieren, die uns die volle Kontrolle gibt, ohne die Stabilität unseres Systems zu gefährden. Für alle Projekte in diesem Buch werden wir Python 3 verwenden. Sie sollten darauf abzielen, ein aktuelles, stabiles Release zu installieren, beispielsweise Python 3.8 oder neuer.

Installation unter Windows

Für Windows-Nutzer gibt es zwei primäre Methoden zur Installation von Python: die Nutzung des offiziellen Installers von der Python-Website oder die Installation über den Microsoft Store. Die zuverlässigste und flexibelste Methode ist die Verwendung des offiziellen Installers.

1. Navigieren Sie mit Ihrem Webbrowser zur offiziellen Python-Website unter python.org.
2. Gehen Sie zum Bereich „Downloads“, der automatisch erkennen sollte, dass Sie Windows verwenden, und einen Button zum Herunterladen der neuesten stabilen Version anzeigt.
3. Laden Sie den ausführbaren Installer herunter (beispielsweise eine Datei namens python-3.X.Y-amd64.exe).
4. Führen Sie den Installer aus, sobald der Download abgeschlossen ist. Dies ist ein entscheidender Schritt: Auf dem ersten Bildschirm des Installationsassistenten stellen Sie sicher, dass Sie das Häkchen bei „Add python.exe to PATH“ setzen. Diese kleine Aktion wird Ihnen später viele Kopfschmerzen ersparen, da sie es Ihnen ermöglicht, Python von der Eingabeaufforderung aus von jedem Verzeichnis heraus aufzurufen.
5. Wählen Sie „Install Now“, um mit der empfohlenen Installation fortzufahren, die IDLE (Pythons grundlegende integrierte Entwicklungsumgebung), pip (den Paketinstaller) und die Dokumentation enthält.
6. Der Installer kopiert die notwendigen Dateien. Sobald er fertig ist, sehen Sie möglicherweise die Option „Disable path length limit“. Es wird dringend empfohlen, diese anzuklicken, da sie potenzielle Probleme mit langen Dateipfaden verhindert, die in komplexen Projekten manchmal auftreten können.

Installation unter macOS

Unter macOS haben Sie ebenfalls ein paar gute Optionen. Während Sie den offiziellen Installer von python.org genauso verwenden können wie unter Windows, ist der empfohlene Ansatz für viele Entwickler die Nutzung eines Paketmanagers namens Homebrew. Homebrew vereinfacht die Installation und Verwaltung von Entwicklerwerkzeugen unter macOS.

1. Zunächst müssen Sie Homebrew installieren, falls Sie es noch nicht haben. Öffnen Sie die Terminal-Anwendung (zu finden in /Applications/Utilities/ oder über die Spotlight-Suche) und fügen Sie den Installationsbefehl von der Homebrew-Website (brew.sh) ein. Er wird Sie durch den Prozess führen.
2. Sobald Homebrew installiert ist, können Sie Python mit einem einzigen Befehl in Ihrem Terminal installieren: brew install python.
3. Homebrew übernimmt das Herunterladen der neuesten Python-3-Version, die Installation und das Erstellen der notwendigen Verknüpfungen, damit Sie es über die Befehlszeile nutzen können.

Wenn Sie Homebrew nicht verwenden möchten, können Sie das macOS-Installer-Paket (.pkg-Datei) direkt von python.org herunterladen und den Anweisungen auf dem Bildschirm folgen, was ein dem Windows-Vorgang sehr ähnlicher Prozess ist.

Installation unter Linux

Die meisten Linux-Distributionen werden mit Python 3 bereits vorinstalliert ausgeliefert, aber es handelt sich möglicherweise nicht um die aktuellste Version. Der einfachste und gängigste Weg, Python zu installieren oder zu aktualisieren, führt über den Paketmanager Ihrer Distribution.

• Auf Debian-basierten Systemen wie Ubuntu können Sie apt verwenden. Öffnen Sie ein Terminal und führen Sie aus:

  sudo apt update
  sudo apt install python3

• Auf Fedora, RHEL oder CentOS können Sie dnf verwenden:

  sudo dnf install python3

Nach der Ausführung dieser Befehle übernimmt der Paketmanager Ihrer Distribution die Installation. In einigen Fällen, wenn Sie eine sehr spezifische oder die absolut neueste Python-Version benötigen, die in den Repositorys Ihrer Distribution nicht verfügbar ist, können Sie Python auch aus dem Quellcode kompilieren, was jedoch ein fortgeschritteneres Verfahren ist.

Installation verifizieren

Sobald der Installationsvorgang abgeschlossen ist, ist es eine gute Idee zu überprüfen, ob alles korrekt funktioniert. Öffnen Sie Ihre Befehlszeilenschnittstelle – dies wird die Eingabeaufforderung (Command Prompt) oder PowerShell unter Windows sein, und Terminal unter macOS und Linux. Geben Sie den folgenden Befehl ein und drücken Sie Enter:

python3 --version

Unter Windows müssen Sie möglicherweise python anstelle von python3 verwenden:

python --version

War die Installation erfolgreich, sollten Sie die Versionsnummer des gerade installierten Python auf dem Bildschirm sehen, zum Beispiel Python 3.11.4. Sie sollten auch überprüfen, ob pip, der Python-Paketmanager, korrekt installiert wurde. Pip ist ein unverzichtbares Werkzeug, das wir ständig verwenden werden, um Drittanbieter-Bibliotheken zu installieren. Testen Sie diesen Befehl (auch hier müssen Sie unter Windows eventuell pip anstelle von pip3 verwenden):

pip3 --version

Dies sollte die Version von pip und den Installationsort ausgeben. Dass sowohl Python als auch pip über die Befehlszeile einsatzbereit sind, bedeutet, dass unsere Basisinstallation abgeschlossen ist.

Virtuelle Umgebungen: Der beste Freund eines Projekts

Nun, da wir Python installiert haben, könnten wir theoretisch anfangen, Code zu schreiben und Pakete zu installieren. Doch zuvor müssen wir eine kritisch wichtige Praxis einführen: die Verwendung virtueller Umgebungen. Stellen Sie sich vor, Sie arbeiten an zwei verschiedenen Projekten. Projekt A benötigt Version 1.0 einer bestimmten Bibliothek, Projekt B jedoch die neuere Version 2.0 genau derselben Bibliothek. Wenn Sie diese Bibliotheken global auf Ihrem System installieren, laufen Sie in einen Konflikt. Die Installation von Version 2.0 würde Version 1.0 überschreiben und potenziell Projekt A beschädigen. Dies ist ein häufiges Problem, das virtuelle Umgebungen lösen sollen.

Eine virtuelle Umgebung ist ein in sich geschlossenes Verzeichnis, das einen bestimmten Python-Interpreter und seinen eigenen Satz installierter Pakete enthält. Es ist, als würden Sie für jedes Ihrer Projekte einen sauberen, isolierten Arbeitsbereich schaffen. Wenn Sie eine virtuelle Umgebung aktivieren, wird Ihrem System temporär mitgeteilt, den Python-Interpreter und die Pakete innerhalb dieser Umgebung zu verwenden, anstatt der globalen. Dies ermöglicht es Ihnen, unterschiedliche Bibliotheksversionen für verschiedene Projekte auf demselben Rechner zu haben, ganz ohne Konflikte. Es ist eine fundamentale Best Practice in der modernen Python-Entwicklung und stellt sicher, dass Ihre Projekte portabel sind und reproduzierbare Abhängigkeiten haben.

Seit Python 3.3 ist ein Modul zum Erstellen virtueller Umgebungen namens venv in der Standardbibliothek enthalten, sodass wir nichts Extra installieren müssen, um es zu nutzen. Lassen Sie uns durchgehen, wie man eine erstellt und verwendet.

1. Erstellen Sie zunächst ein neues Verzeichnis für Ihr Projekt. Navigieren Sie in Ihrem Terminal dorthin. Zum Beispiel:

   mkdir meine-web-app
   cd meine-web-app

2. Erstellen Sie nun die virtuelle Umgebung innerhalb dieses Verzeichnisses. Die gängige Konvention ist, den Umgebungsordner venv oder .venv zu nennen. Wir werden das venv-Modul dafür verwenden.

   python3 -m venv venv

   Unter Windows wäre dies:

   python -m venv venv

   Dieser Befehl weist Python an, das venv-Modul auszuführen und eine virtuelle Umgebung in einem neuen Ordner namens venv zu erstellen.

3. Sie haben nun ein venv-Verzeichnis in Ihrem Projektordner. Dieses Verzeichnis enthält eine Kopie des Python-Interpreters und einen Ort zur Installation von Bibliotheken. Bevor Sie es nutzen können, müssen Sie es „aktivieren“. Der Aktivierungsbefehl unterscheidet sich je nach Betriebssystem.

   • Unter macOS und Linux:

     source venv/bin/activate

   • Unter Windows (Eingabeaufforderung):

     venv\Scripts\activate.bat

   • Unter Windows (PowerShell):

     venv\Scripts\Activate.ps1

4. Nach Ausführen des Aktivierungsbefehls werden Sie feststellen, dass sich das Präfix Ihrer Befehlszeile ändert und den Namen der aktiven Umgebung anzeigt, beispielsweise (venv). Dies signalisiert, dass die virtuelle Umgebung aktiv ist. Alle Python-Pakete, die Sie jetzt installieren, werden in den venv-Ordner gelegt, und alle Skripte, die Sie ausführen, werden den Python-Interpreter dieser Umgebung verwenden.

5. Wenn Sie mit der Arbeit an Ihrem Projekt fertig sind, können Sie die virtuelle Umgebung einfach durch Eingabe von:

   deactivate

   verlassen. Ihre Befehlszeile kehrt zum Normalzustand zurück. So einfach ist das. Von nun an sollten Sie es sich zur Gewohnheit machen, für jedes neue Python-Projekt, das Sie starten, eine virtuelle Umgebung zu erstellen und zu aktivieren.

Pakete mit pip verwalten

Mit unserer aktiven virtuellen Umgebung haben wir nun eine saubere Basis, um die Bibliotheken zu installieren, die unser Projekt benötigt. Das Werkzeug dafür ist pip, der Python Package Installer. Pip verbindet sich mit einem zentralen Repository für Python-Software, dem Python Package Index (PyPI), wo zehntausende Open-Source-Bibliotheken für Sie bereitstehen.

Der grundlegende Befehl zur Installation eines Pakets lautet pip install. Lassen Sie uns beispielsweise die Bibliothek requests installieren, ein sehr beliebtes Werkzeug für HTTP-Anfragen (das wir später im Detail behandeln). Führen Sie mit aktivierter virtueller Umgebung Folgendes aus:

pip install requests

Pip sucht die neueste Version des requests-Pakets auf PyPI, lädt sie herunter und installiert auch alle anderen Pakete, von denen requests abhängt, um korrekt zu funktionieren. Sie können eine Liste aller in Ihrer aktuellen Umgebung installierten Pakete mit folgendem Befehl anzeigen:

pip list

Sie werden requests und seine Abhängigkeiten in dieser Liste sehen. Wenn Sie ein Paket jemals entfernen müssen, können Sie den uninstall-Befehl verwenden:

pip uninstall requests

Um ein Paket auf seine neueste Version zu aktualisieren, können Sie das Flag --upgrade nutzen:

pip install --upgrade requests

Pip ist ein mächtiges Werkzeug, und diese Befehle sind die, die Sie am häufigsten zur Verwaltung der Abhängigkeiten Ihres Projekts verwenden werden.

Reproduzierbare Umgebungen mit requirements.txt

Während Sie Ihre Anwendung bauen, werden Sie mehrere Abhängigkeiten installieren. Wenn Sie Ihr Projekt mit einem anderen Entwickler teilen möchten oder bereit sind, es auf einem Server zu deployen – wie stellen Sie sicher, dass dieser exakt dieselben Versionen all der Pakete hat, die Sie verwendet haben? Hier kommt die Datei requirements.txt ins Spiel. Es handelt sich um eine einfache Textdatei, die alle Abhängigkeiten des Projekts und ihre spezifischen Versionen auflistet.

Das Erzeugen dieser Datei ist mit pip unglaublich einfach. Führen Sie bei aktivierter virtueller Umgebung und installierten Paketen folgenden Befehl aus:

pip freeze > requirements.txt

Dieser Befehl nimmt die Ausgabe von pip freeze (eine Liste aller installierten Pakete mit ihren Versionen) und leitet sie in eine neue Datei namens requirements.txt um. Öffnen Sie diese Datei, werden Sie etwas Ähnliches sehen wie:

certifi==2023.7.22
chardet==5.2.0
idna==3.4
requests==2.31.0
urllib3==2.0.7

Diese Datei dient als Blaupause für die Umgebung Ihres Projekts. Nun kann eine andere Person (oder ein Deployment-Skript) eine identische Umgebung einrichten, indem sie eine neue virtuelle Umgebung erstellt und diesen Befehl ausführt:

pip install -r requirements.txt

Pip liest die Datei und installiert die exakten Versionen aller aufgelisteten Pakete. Diese Praxis ist fundamental für Zusammenarbeit und zuverlässige Deployments, und Sie sollten für jedes Projekt eine requirements.txt-Datei pflegen.

Den Code-Editor wählen

Der letzte Baustein unserer Entwicklungsumgebung ist der Ort, an dem wir unseren Code tatsächlich schreiben werden: ein Code-Editor oder eine integrierte Entwicklungsumgebung (IDE). Obwohl Sie Python-Code theoretisch in einem einfachen Texteditor wie Notepad schreiben könnten, wird Sie ein spezialisierter Code-Editor mit Funktionen wie Syntax-Highlighting, Code-Vervollständigung, Fehlerprüfung und Debugging-Werkzeugen unendlich unterstützen. Die Wahl des Editors ist eine persönliche, und es gibt keine einzelne „beste“ Option. Hier sind einige der beliebtesten Optionen in der Python-Community:

• Visual Studio Code (VS Code): Ein kostenloser, leichter und hochgradig erweiterbarer Code-Editor von Microsoft. Er ist für alle Arten der Entwicklung, einschließlich Python, unglaublich beliebt geworden, dank seiner hervorragenden Performance und einer riesigen Bibliothek an Erweiterungen, die jede gewünschte Funktionalität hinzufügen können.
• PyCharm: Eine voll ausgestattete IDE, speziell für Python-Entwicklung von JetBrains entwickelt. Sie bringt eine Vielzahl an Werkzeugen direkt mit, darunter einen mächtigen Debugger, Test-Unterstützung und Integrationen für Web-Frameworks und Datenbanken. Es gibt eine kostenlose Community-Edition und eine kostenpflichtige Professional-Edition mit erweiterten Features.
• Sublime Text: Ein schneller und hochgradig anpassbarer Code-Editor, bekannt für sein „Goto Anything“-Feature und mächtige Bearbeitungsfunktionen. Er ist nicht kostenlos, bietet aber einen sehr großzügigen Evaluierungszeitraum.
• Atom: Ein Open-Source- und hochgradig anpassbarer Editor von GitHub. Er hat eine große Community und eine breite Palette an Paketen zur Erweiterung seiner Funktionalität.

Für Einsteiger und erfahrene Entwickler gleichermaßen bietet Visual Studio Code eine fantastische Balance aus Leistung, Performance und Benutzerfreundlichkeit. Für die Zwecke dieses Buches werden wir VS Code in unseren Beispielen verwenden, die Konzepte lassen sich jedoch auf jeden anderen modernen Editor übertragen.

Visual Studio Code konfigurieren

Lassen Sie uns zum Abschluss VS Code für die Python-Entwicklung einrichten.

1. VS Code installieren: Laden Sie es von der offiziellen Website code.visualstudio.com herunter und installieren Sie es.
2. Python-Erweiterung installieren: Sobald VS Code geöffnet ist, navigieren Sie zur Erweiterungsansicht, indem Sie auf das Symbol in der linken Seitenleiste klicken oder Strg+Umschalt+X drücken. Suchen Sie nach „Python“ und installieren Sie die offizielle Erweiterung von Microsoft. Dieses Erweiterungspaket stellt die Kernfunktionen für die Python-Entwicklung bereit, einschließlich IntelliSense (Code-Vervollständigung), Linting (Fehlerprüfung) und Debugging.
3. Python-Interpreter auswählen: Nun müssen wir VS Code mitteilen, dass es den Python-Interpreter verwenden soll, der sich in der virtuellen Umgebung unseres Projekts befindet. Öffnen Sie Ihren Projektordner (meine-web-app) in VS Code. Öffnen Sie dann die Befehlspalette mit Strg+Umschalt+P (oder Cmd+Umschalt+P unter macOS). Geben Sie „Python: Select Interpreter“ ein und wählen Sie diesen Eintrag. Eine Liste der verfügbaren Python-Interpreter erscheint. Sie sollten einen sehen, der '.venv' oder 'venv' in seinem Pfad enthält. Wählen Sie diesen aus. Damit wird sichergestellt, dass bei jedem Ausführen oder Debuggen Ihres Codes aus VS Code heraus die korrekte, isolierte Umgebung verwendet wird.
4. Linter konfigurieren: Ein Linter ist ein Werkzeug, das Ihren Code auf potenzielle Fehler und stilistische Probleme analysiert. Die Python-Erweiterung für VS Code unterstützt verschiedene Linter wie Pylint und Flake8. Lassen Sie uns Flake8 aktivieren. Öffnen Sie die Befehlspalette erneut, geben Sie „Python: Select Linter“ ein und wählen Sie Flake8. VS Code wird Sie möglicherweise auffordern, es zu installieren; klicken Sie in diesem Fall auf „Installieren“. Linting bietet Ihnen Echtzeit-Feedback im Editor, unterstreicht problematischen Code und hilft Ihnen, sauberen, standardkonformen Code zu schreiben.

Mit installiertem Python, dem Verständnis für virtuelle Umgebungen und pip sowie einem Code-Editor, der diese nutzt, ist unsere Werkstatt nun offiziell für den Betrieb geöffnet. Wir verfügen über ein robustes, professionelles und organisiertes Fundament. Jetzt sind wir endlich bereit, die Python-Sprachfeatures zu erkunden, die für den Bau der Webanwendungen der Zukunft am wichtigsten sind.