So verwenden Sie eine PostgreSQL-Datenbank in einer Flask-Anwendung

Tutorials
Flask PostgreSQL Python

Der Autor hat den Free and Open Source Fund ausgewählt, um eine Spende im Rahmen des Write for DOnations-Programms zu erhalten.

Einführung

In Webanwendungen benötigen Sie in der Regel eine Datenbank, die eine organisierte Sammlung von Daten ist. Sie verwenden eine Datenbank, um persistente Daten zu speichern und zu pflegen, die effizient abgerufen und manipuliert werden können. Zum Beispiel haben Sie in einer Social-Media-Anwendung eine Datenbank, in der Benutzerdaten (persönliche Informationen, Beiträge, Kommentare, Follower) so gespeichert sind, dass sie effizient manipuliert werden können. Sie können Daten einer Datenbank hinzufügen, abrufen, ändern oder löschen, abhängig von verschiedenen Anforderungen und Bedingungen. In einer Webanwendung können diese Anforderungen darin bestehen, dass ein Benutzer einen neuen Beitrag hinzufügt, einen Beitrag löscht oder sein Konto löscht, wobei möglicherweise seine Beiträge gelöscht werden oder auch nicht. Die Aktionen, die Sie zur Manipulation von Daten ausführen, hängen von bestimmten Funktionen in Ihrer Anwendung ab. Zum Beispiel möchten Sie möglicherweise nicht, dass Benutzer Beiträge ohne Titel hinzufügen.

Flask ist ein leichtgewichtiges Python-Webframework, das nützliche Werkzeuge und Funktionen für die Erstellung von Webanwendungen in der Python-Sprache bereitstellt. PostgreSQL oder Postgres ist ein relationales Datenbankverwaltungssystem, das eine Implementierung der SQL-Abfragesprache bietet. Es ist standardkonform und verfügt über viele erweiterte Funktionen wie zuverlässige Transaktionen und Nebenläufigkeit ohne Lese-Sperren.

In diesem Tutorial erstellen Sie eine kleine Webanwendung zur Buchbewertung, die zeigt, wie Sie die psycopg2-Bibliothek verwenden, ein PostgreSQL-Datenbankadapter, mit dem Sie in Python mit Ihrer PostgreSQL-Datenbank interagieren können. Sie verwenden sie mit Flask, um grundlegende Aufgaben wie das Verbinden mit einem Datenbankserver, das Erstellen von Tabellen, das Einfügen von Daten in eine Tabelle und das Abrufen von Daten aus einer Tabelle durchzuführen.

Voraussetzungen

Schritt 1 — Erstellen der PostgreSQL-Datenbank und des Benutzers

In diesem Schritt erstellen Sie eine Datenbank namens flask_db und einen Datenbankbenutzer namens sammy für Ihre Flask-Anwendung.

Während der Postgres-Installation wurde ein Betriebssystembenutzer mit dem Namen postgres erstellt, der dem administrativen PostgreSQL-Benutzer postgres entspricht. Sie müssen diesen Benutzer verwenden, um administrative Aufgaben auszuführen. Sie können sudo verwenden und den Benutzernamen mit der Option -iu übergeben.

Melden Sie sich bei einer interaktiven Postgres-Sitzung mit dem folgenden Befehl an:

  1. sudo -iu postgres psql

Sie erhalten eine PostgreSQL-Eingabeaufforderung, in der Sie Ihre Anforderungen einrichten können.

Erstellen Sie zunächst eine Datenbank für Ihr Projekt:

  1. CREATE DATABASE flask_db;

Hinweis: Jeder Postgres-Befehl muss mit einem Semikolon enden. Stellen Sie daher sicher, dass Ihr Befehl damit endet, wenn Sie Probleme haben.

Als nächstes erstellen Sie einen Datenbankbenutzer für unser Projekt. Achten Sie darauf, ein sicheres Passwort auszuwählen:

  1. CREATE USER sammy WITH PASSWORD 'password';

Dann geben Sie diesem neuen Benutzer Zugriff, um Ihre neue Datenbank zu verwalten:

  1. GRANT ALL PRIVILEGES ON DATABASE flask_db TO sammy;

Um zu bestätigen, dass die Datenbank erstellt wurde, erhalten Sie die Liste der Datenbanken, indem Sie den folgenden Befehl eingeben:

  1. \l

Sie werden flask_db in der Liste der Datenbanken sehen.

Wenn Sie fertig sind, verlassen Sie die PostgreSQL-Eingabeaufforderung, indem Sie eingeben:

  1. \q

Postgres ist nun so eingerichtet, dass Sie eine Verbindung herstellen und seine Datenbankinformationen über Python mithilfe der psycopg2-Bibliothek verwalten können. Als nächstes installieren Sie diese Bibliothek zusammen mit dem Flask-Paket.

Schritt 2 — Installation von Flask und psycopg2

In diesem Schritt installieren Sie Flask und die psycopg2-Bibliothek, damit Sie über Python mit Ihrer Datenbank interagieren können.

Wenn Ihre virtuelle Umgebung aktiviert ist, verwenden Sie pip, um Flask und die psycopg2-Bibliothek zu installieren:

  1. pip install Flask psycopg2-binary

Nach erfolgreicher Installation sehen Sie am Ende der Ausgabe eine Zeile ähnlich wie die folgende:

Output

Successfully installed Flask-2.0.2 Jinja2-3.0.3 MarkupSafe-2.0.1 Werkzeug-2.0.2 click-8.0.3 itsdangerous-2.0.1 psycopg2-binary-2.9.2

Sie haben jetzt die erforderlichen Pakete in Ihrer virtuellen Umgebung installiert. Als nächstes werden Sie eine Verbindung herstellen und Ihre Datenbank einrichten.

Schritt 3 – Einrichten einer Datenbank

In diesem Schritt erstellen Sie eine Python-Datei in Ihrem Projektverzeichnis flask_app, um eine Verbindung zur Datenbank flask_db herzustellen, eine Tabelle zum Speichern von Büchern zu erstellen und einige Bücher mit Bewertungen einzufügen.

Zuerst, mit Ihrer Programmierumgebung aktiviert, öffnen Sie eine neue Datei namens init_db.py in Ihrem Verzeichnis flask_app.

  1. nano init_db.py

Diese Datei wird eine Verbindung zur Datenbank flask_db herstellen, eine Tabelle namens books erstellen und die Tabelle mit Beispieldaten bevölkern. Fügen Sie den folgenden Code hinzu:

flask_app/init_db.py
import os
import psycopg2

conn = psycopg2.connect(
        host="localhost",
        database="flask_db",
        user=os.environ['DB_USERNAME'],
        password=os.environ['DB_PASSWORD'])

# Öffnen eines Cursors zum Ausführen von Datenbankoperationen
cur = conn.cursor()

# Befehl ausführen: Dies erstellt eine neue Tabelle
cur.execute('DROP TABLE IF EXISTS books;')
cur.execute('CREATE TABLE books (id serial PRIMARY KEY,'
                                 'title varchar (150) NOT NULL,'
                                 'author varchar (50) NOT NULL,'
                                 'pages_num integer NOT NULL,'
                                 'review text,'
                                 'date_added date DEFAULT CURRENT_TIMESTAMP);'
                                 )

# Daten in die Tabelle einfügen

cur.execute('INSERT INTO books (title, author, pages_num, review)'
            'VALUES (%s, %s, %s, %s)',
            ('A Tale of Two Cities',
             'Charles Dickens',
             489,
             'A great classic!')
            )


cur.execute('INSERT INTO books (title, author, pages_num, review)'
            'VALUES (%s, %s, %s, %s)',
            ('Anna Karenina',
             'Leo Tolstoy',
             864,
             'Another great classic!')
            )

conn.commit()

cur.close()
conn.close()

Speichern Sie die Datei und schließen Sie sie.

In dieser Datei importieren Sie zunächst das os-Modul, das Sie verwenden werden, um auf Umgebungsvariablen zuzugreifen, in denen Sie Ihren Datenbankbenutzernamen und Ihr Passwort speichern, damit sie nicht in Ihrem Quellcode sichtbar sind.

Sie importieren die psycopg2-Bibliothek. Dann öffnen Sie eine Verbindung zur Datenbank flask_db mit der Funktion psycopg2.connect(). Sie geben den Host an, der in diesem Fall localhost ist. Sie übergeben den Datenbanknamen dem Parameter database.

Sie geben Ihren Benutzernamen und Ihr Passwort über das Objekt os.environ an, das Ihnen Zugriff auf Umgebungsvariablen gewährt, die Sie in Ihrer Programmierumgebung festgelegt haben. Sie speichern den Datenbankbenutzernamen in einer Umgebungsvariable namens DB_USERNAME und das Passwort in einer Umgebungsvariable namens DB_PASSWORD. Dies ermöglicht es Ihnen, Ihren Benutzernamen und Ihr Passwort außerhalb Ihres Quellcodes zu speichern, damit Ihre sensiblen Informationen nicht preisgegeben werden, wenn der Quellcode in der Quellcodeverwaltung gespeichert oder auf einen Server im Internet hochgeladen wird. Selbst wenn ein Angreifer Zugriff auf Ihren Quellcode erhält, erhält er keinen Zugriff auf die Datenbank.

Sie erstellen einen Cursor namens cur mit der Methode connection.cursor(), die es Python-Code ermöglicht, PostgreSQL-Befehle in einer Datenbanksitzung auszuführen.

Sie verwenden die Methode execute() des Cursors, um die Tabelle books zu löschen, falls sie bereits existiert. Dies vermeidet die Möglichkeit, dass eine andere Tabelle mit dem Namen books existiert, was zu verwirrendem Verhalten führen könnte (zum Beispiel, wenn sie unterschiedliche Spalten hat). Dies ist hier nicht der Fall, weil Sie die Tabelle noch nicht erstellt haben, daher wird der SQL-Befehl nicht ausgeführt. Beachten Sie, dass dadurch alle vorhandenen Daten gelöscht werden, wenn Sie diese Datei init_db.py ausführen. Für unsere Zwecke werden Sie diese Datei nur einmal ausführen, um die Datenbank zu initialisieren, aber Sie könnten sie erneut ausführen wollen, um die eingefügten Daten zu löschen und wieder mit den ursprünglichen Beispieldaten zu beginnen.

Danach verwenden Sie CREATE TABLE books, um eine Tabelle mit dem Namen books mit den folgenden Spalten zu erstellen:

  • id: Eine ID vom Typ serial, die ein automatisch inkrementierender Integer ist. Diese Spalte repräsentiert einen Primärschlüssel, den Sie mit den Schlüsselwörtern PRIMARY KEY festlegen. Die Datenbank weist diesem Schlüssel für jeden Eintrag einen eindeutigen Wert zu.
  • title: Der Titel des Buches vom Typ varchar, ein Zeichentyp variabler Länge mit einer Begrenzung. varchar (150) bedeutet, dass der Titel bis zu 150 Zeichen lang sein kann. NOT NULL bedeutet, dass diese Spalte nicht leer sein kann.
  • author: Der Autor des Buches, mit einer Begrenzung von 50 Zeichen. NOT NULL bedeutet, dass diese Spalte nicht leer sein kann.
  • pages_num: Eine Ganzzahl, die die Anzahl der Seiten des Buches darstellt. NOT NULL bedeutet, dass diese Spalte nicht leer sein kann.
  • review: Die Buchrezension. Der text-Typ bedeutet, dass die Rezension Text von beliebiger Länge sein kann.
  • date_added: Das Datum, an dem das Buch zur Tabelle hinzugefügt wurde. DEFAULT legt den Standardwert der Spalte auf CURRENT_TIMESTAMP fest, was die Zeit ist, zu der das Buch in die Datenbank eingefügt wurde. Genau wie bei id müssen Sie für diese Spalte keinen Wert angeben, da er automatisch ausgefüllt wird.

Nachdem Sie die Tabelle erstellt haben, verwenden Sie die execute()-Methode des Cursors, um zwei Bücher in die Tabelle einzufügen, A Tale of Two Cities von Charles Dickens und Anna Karenina von Leo Tolstoy. Sie verwenden den Platzhalter %s, um die Werte an die SQL-Anweisung zu übergeben. psycopg2 behandelt die Einfügung im Hintergrund so, dass SQL-Injection-Angriffe verhindert werden.

Nachdem Sie die Buchdaten in Ihre Tabelle eingefügt haben, verwenden Sie die connection.commit()-Methode, um die Transaktion zu bestätigen und die Änderungen an der Datenbank anzuwenden. Dann bereinigen Sie, indem Sie den Cursor mit cur.close() und die Verbindung mit conn.close() schließen.

Um die Datenbankverbindung herzustellen, setzen Sie die Umgebungsvariablen DB_USERNAME und DB_PASSWORD, indem Sie die folgenden Befehle ausführen. Denken Sie daran, Ihren eigenen Benutzernamen und Ihr Passwort zu verwenden:

  1. export DB_USERNAME="sammy"

  2. export DB_PASSWORD="password"

Führen Sie nun Ihre init_db.py-Datei im Terminal mit dem Befehl python aus:

  1. python init_db.py

Sobald die Datei die Ausführung ohne Fehler beendet hat, wird eine neue books-Tabelle zu Ihrer flask_db-Datenbank hinzugefügt.

Melden Sie sich bei einer interaktiven Postgres-Sitzung an, um die neue books-Tabelle zu überprüfen.

  1. sudo -iu postgres psql

Verbinden Sie sich mit der flask_db-Datenbank mithilfe des Befehls \c:

  1. \c flask_db

Verwenden Sie dann eine SELECT-Anweisung, um die Titel und Autoren von Büchern aus der books-Tabelle abzurufen:

  1. SELECT title, author FROM books;

Sie sehen eine Ausgabe wie folgt:

        title         |      author
----------------------+------------------
 A Tale of Two Cities | Charles Dickens
 Anna Karenina        | Leo Tolstoy

Beenden Sie die interaktive Sitzung mit \q.

Als nächstes erstellen Sie eine kleine Flask-Anwendung, verbinden sich mit der Datenbank, rufen die beiden Buchrezensionen ab, die Sie in die Datenbank eingefügt haben, und zeigen sie auf der Indexseite an.

Schritt 4 — Bücher anzeigen

In diesem Schritt erstellen Sie eine Flask-Anwendung mit einer Indexseite, die die Bücher abruft, die sich in der Datenbank befinden, und sie anzeigt.

Mit Ihrer aktivierten Programmierumgebung und Flask installiert öffnen Sie eine Datei namens app.py zur Bearbeitung in Ihrem flask_app-Verzeichnis:

  1. nano app.py

In diese Datei wird Ihre Datenbankverbindung eingerichtet und eine einzige Flask-Route erstellt, um diese Verbindung zu nutzen. Fügen Sie den folgenden Code zur Datei hinzu:

flask_app/app.py
import os
import psycopg2
from flask import Flask, render_template

app = Flask(__name__)

def get_db_connection():
    conn = psycopg2.connect(host='localhost',
                            database='flask_db',
                            user=os.environ['DB_USERNAME'],
                            password=os.environ['DB_PASSWORD'])
    return conn


@app.route('/')
def index():
    conn = get_db_connection()
    cur = conn.cursor()
    cur.execute('SELECT * FROM books;')
    books = cur.fetchall()
    cur.close()
    conn.close()
    return render_template('index.html', books=books)

Speichern und schließen Sie die Datei.

Hier importieren Sie das os-Modul, die psycopg2-Bibliothek und die Flask-Klasse sowie die render_template()-Funktion aus dem flask-Paket. Sie erstellen eine Flask-Anwendungsinstanz namens app.

Sie definieren eine Funktion namens get_db_connection(), die eine Verbindung zur Datenbank flask_db unter Verwendung des Benutzernamens und des Passworts öffnet, die Sie in Ihren Umgebungsvariablen DB_USERNAME und DB_PASSWORD speichern. Die Funktion gibt das Verbindungsobjekt conn zurück, das Sie zur Datenbankzugriff verwenden werden.

Dann erstellen Sie eine Hauptroute / und eine index()-Ansichtsfunktion mit dem app.route()-Dekorator. In der index()-Ansichtsfunktion öffnen Sie eine Datenbankverbindung mit der get_db_connection()-Funktion, Sie erstellen einen Cursor und führen die SQL-Anweisung SELECT * FROM books; aus, um alle Bücher abzurufen, die sich in der Datenbank befinden. Sie verwenden die Methode fetchall(), um die Daten in einer Variable namens books zu speichern. Dann schließen Sie den Cursor und die Verbindung. Schließlich geben Sie einen Aufruf an die Funktion render_template() zurück, um eine Vorlagendatei namens index.html zu rendern und ihr die Liste der aus der Datenbank abgerufenen Bücher in der Variablen books zu übergeben.

Um die Bücher, die sich in Ihrer Datenbank befinden, auf der Indexseite anzuzeigen, erstellen Sie zunächst eine Basisschablone, die den gesamten grundlegenden HTML-Code enthält, den auch andere Schablonen verwenden, um Code-Wiederholungen zu vermeiden. Anschließend erstellen Sie die Vorlagendatei index.html, die Sie in Ihrer Funktion index() gerendert haben. Um mehr über Vorlagen zu erfahren, siehe So verwenden Sie Vorlagen in einer Flask-Anwendung.

Erstellen Sie ein templates-Verzeichnis und öffnen Sie dann eine neue Vorlage namens base.html:

  1. mkdir templates

  2. nano templates/base.html

Fügen Sie den folgenden Code in die Datei base.html ein:

flask_app/templates/base.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>{% block title %} {% endblock %}- FlaskApp</title>
    <style>
        nav a {
            color: #d64161;
            font-size: 3em;
            margin-left: 50px;
            text-decoration: none;
        }

        .book {
            padding: 20px;
            margin: 10px;
            background-color: #f7f4f4;
        }

        .review {
                margin-left: 50px;
                font-size: 20px;
        }

    </style>
</head>
<body>
    <nav>
        <a href="{{ url_for('index') }}">FlaskApp</a>
        <a href="#">About</a>
    </nav>
    <hr>
    <div class="content">
        {% block content %} {% endblock %}
    </div>
</body>
</html>

Speichern und schließen Sie die Datei.

Diese Basisschablone enthält den gesamten HTML-Boilerplate-Code, den Sie in Ihren anderen Vorlagen wiederverwenden müssen. Der title-Block wird ersetzt, um einen Titel für jede Seite festzulegen, und der content-Block wird durch den Inhalt jeder Seite ersetzt. Die Navigationsleiste enthält zwei Links, einen für die Indexseite, auf der Sie die url_for()-Hilfsfunktion verwenden, um auf die index()-Ansichtsfunktion zu verlinken, und den anderen für eine Über uns-Seite, falls Sie eine in Ihrer Anwendung einbeziehen möchten.

Öffnen Sie als nächstes eine Vorlage namens index.html. Dies ist die Vorlage, auf die Sie in der Datei app.py verwiesen haben:

  1. nano templates/index.html

Fügen Sie den folgenden Code hinzu:

flask_app/templates/index.html

{% extends 'base.html' %}

{% block content %}
    <h1>{% block title %} Books {% endblock %}</h1>
    {% for book in books %}
        <div class='book'>
            <h3>#{{ book[0] }} - {{ book[1] }} BY {{ book[2] }}</h3>
            <i><p>({{ book[3] }} pages)</p></i>
            <p class='review'>{{ book[4] }}</p>
            <i><p>Added {{ book[5] }}</p></i>
        </div>
    {% endfor %}
{% endblock %}

Speichern und schließen Sie die Datei.

In dieser Datei erweitern Sie die Basisschablone und ersetzen den Inhalt des content-Blocks. Sie verwenden eine <h1>-Überschrift, die auch als Titel dient.

Du verwendest eine Jinja for-Schleife in der Zeile {% for book in books %}, um jedes Buch in der books-Liste zu durchlaufen. Du zeigst die Buch-ID an, die das erste Element mit book[0] ist. Anschließend zeigst du den Buchtitel, den Autor, die Anzahl der Seiten, die Bewertung und das Datum an, an dem das Buch hinzugefügt wurde.

Wenn du dich in deinem flask_app-Verzeichnis mit aktivierter virtueller Umgebung befindest, teile Flask über die Anwendung (app.py in diesem Fall) mit, indem du die Umgebungsvariable FLASK_APP verwendest. Setze dann die Umgebungsvariable FLASK_ENV auf development, um die Anwendung im Entwicklungsmodus auszuführen und Zugriff auf den Debugger zu erhalten. Weitere Informationen zum Flask-Debugger findest du in Wie man Fehler in einer Flask-Anwendung behandelt. Verwende die folgenden Befehle, um dies zu tun:

  1. export FLASK_APP=app

  2. export FLASK_ENV=development

Vergewissere dich, dass du die Umgebungsvariablen DB_USERNAME und DB_PASSWORD festlegst, wenn du dies noch nicht getan hast:

  1. export DB_USERNAME="sammy"

  2. export DB_PASSWORD="password"

Anschließend führe die Anwendung aus:

  1. flask run

Wenn der Entwicklungsserver läuft, besuche die folgende URL mit deinem Browser:

http://127.0.0.1:5000/

Dort siehst du die Bücher, die du bei der ersten Initialisierung zur Datenbank hinzugefügt hast.

Du hast die Bücher in deiner Datenbank auf der Indexseite angezeigt. Jetzt musst du Benutzern ermöglichen, neue Bücher hinzuzufügen. Du wirst als nächstes einen neuen Routen für das Hinzufügen von Büchern hinzufügen.

Schritt 5 — Hinzufügen neuer Bücher

In diesem Schritt erstellen Sie eine neue Route zum Hinzufügen neuer Bücher und Bewertungen zur Datenbank.

Sie werden eine Seite mit einem Webformular hinzufügen, auf der Benutzer den Buchtitel, den Buchautor, die Anzahl der Seiten und die Buchbewertung eingeben können.

Lassen Sie den Entwicklungsserver weiterhin ausgeführt und öffnen Sie ein neues Terminalfenster.

Zuerst öffnen Sie Ihre app.py-Datei:

  1. nano app.py

Für die Bearbeitung des Webformulars müssen Sie einige Dinge aus dem flask-Paket importieren:

  • Das globale request-Objekt, um übermittelte Daten abzurufen.
  • Die Funktion url_for() zum Generieren von URLs.
  • Die Funktion redirect() zum Umleiten von Benutzern auf die Indexseite nach dem Hinzufügen eines Buchs zur Datenbank.

Fügen Sie diese Imports in die erste Zeile der Datei ein:

flask_app/app.py

from flask import Flask, render_template, request, url_for, redirect

# ...

Fügen Sie dann die folgende Route am Ende der Datei app.py hinzu:

flask_app/app.py

# ...


@app.route('/create/', methods=('GET', 'POST'))
def create():
    return render_template('create.html')

Speichern und schließen Sie die Datei.

In dieser Route übergeben Sie das Tupel ('GET', 'POST') dem methods-Parameter, um sowohl GET- als auch POST-Anfragen zu ermöglichen. GET-Anfragen werden verwendet, um Daten vom Server abzurufen. POST-Anfragen werden verwendet, um Daten an eine bestimmte Route zu senden. Standardmäßig sind nur GET-Anfragen erlaubt. Wenn der Benutzer zuerst die Route /create mit einer GET-Anfrage aufruft, wird eine Vorlagendatei namens create.html gerendert. Diese Route wird später bearbeitet, um POST-Anfragen zu behandeln, wenn Benutzer das Webformular für das Hinzufügen neuer Bücher ausfüllen und senden.

Öffnen Sie die neue Vorlagendatei create.html:

  1. nano templates/create.html

Fügen Sie den folgenden Code hinzu:

flask_app/templates/create.html
{% extends 'base.html' %}

{% block content %}
    <h1>{% block title %} Add a New Book {% endblock %}</h1>
    <form method="post">
        <p>
            <label for="title">Title</label>
            <input type="text" name="title"
                   placeholder="Book title">
            </input>
        </p>

        <p>
            <label for="author">Author</label>
            <input type="text" name="author"
                   placeholder="Book author">
            </input>
        </p>

        <p>
            <label for="pages_num">Number of pages</label>
            <input type="number" name="pages_num"
                   placeholder="Number of pages">
            </input>
        </p>
        <p>
        <label for="review">Review</label>
        <br>
        <textarea name="review"
                  placeholder="Review"
                  rows="15"
                  cols="60"
                  ></textarea>
        </p>
        <p>
            <button type="submit">Submit</button>
        </p>
    </form>
{% endblock %}

Speichern Sie die Datei und schließen Sie sie.

Sie erweitern die Basenvorlage, setzen eine Überschrift als Titel und verwenden ein <form>-Tag mit dem Attribut method, das auf post gesetzt ist, um anzuzeigen, dass das Formular eine POST-Anfrage sendet.

Sie haben ein Textfeld mit dem Namen title, das Sie verwenden werden, um auf die Titeldaten in Ihrer Route /create zuzugreifen.

Sie haben ein Textfeld für den Autor, ein Zahlenfeld für die Anzahl der Seiten und ein Textfeld für die Buchrezension.

Zuletzt haben Sie einen Absenden-Button am Ende des Formulars.

Jetzt, während der Entwicklungsserver läuft, navigieren Sie mit Ihrem Browser zur Route /create:

http://127.0.0.1:5000/create

Sie sehen eine Neues Buch hinzufügen-Seite mit einem Eingabefeld für einen Buchtitel, einem für den Autor, einem für die Anzahl der Seiten des Buches, einem Textbereich für die Buchrezension und einem Absenden-Button.

Wenn Sie das Formular ausfüllen und absenden, indem Sie eine POST-Anfrage an den Server senden, passiert nichts, weil Sie POST-Anfragen auf der Route /create nicht behandelt haben.

Öffnen Sie app.py, um die vom Benutzer übermittelte POST-Anfrage zu bearbeiten:

  1. nano app.py

Bearbeiten Sie die /create-Route wie folgt:

flask_app/app.py

# ...

@app.route('/create/', methods=('GET', 'POST'))
def create():
    if request.method == 'POST':
        title = request.form['title']
        author = request.form['author']
        pages_num = int(request.form['pages_num'])
        review = request.form['review']

        conn = get_db_connection()
        cur = conn.cursor()
        cur.execute('INSERT INTO books (title, author, pages_num, review)'
                    'VALUES (%s, %s, %s, %s)',
                    (title, author, pages_num, review))
        conn.commit()
        cur.close()
        conn.close()
        return redirect(url_for('index'))

    return render_template('create.html')

Speichern und schließen Sie die Datei.

Sie behandeln POST-Anfragen innerhalb der Bedingung if request.method == 'POST'. Sie extrahieren den Titel, den Autor, die Anzahl der Seiten und die Bewertung, die der Benutzer aus dem Objekt request.form übermittelt.

Sie öffnen eine Datenbank mithilfe der Funktion get_db_connection() und erstellen einen Cursor. Dann führen Sie eine INSERT INTO-SQL-Anweisung aus, um den Titel, den Autor, die Anzahl der Seiten und die Bewertung, die der Benutzer in die Tabelle books eingibt, einzufügen.

Sie bestätigen die Transaktion und schließen den Cursor und die Verbindung.

Zuletzt leiten Sie den Benutzer zur Indexseite weiter, auf der er das neu hinzugefügte Buch unter den vorhandenen Büchern sehen kann.

Wenn der Entwicklungsserver läuft, verwenden Sie Ihren Browser, um zur Route /create zu navigieren:

http://127.0.0.1:5000/create

Füllen Sie das Formular mit einigen Daten aus und senden Sie es ab.

Sie werden zur Indexseite weitergeleitet, auf der Sie Ihre neue Buchbewertung sehen werden.

Als nächstes fügen Sie einen Link zur Erstellungsseite in die Navigationsleiste ein. Öffnen Sie base.html:

  1. nano templates/base.html

Bearbeiten Sie die Datei wie folgt:

flask_app/templates/base.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>{% block title %} {% endblock %} - FlaskApp</title>
    <style>
        nav a {
            color: #d64161;
            font-size: 3em;
            margin-left: 50px;
            text-decoration: none;
        }

        .book {
            padding: 20px;
            margin: 10px;
            background-color: #f7f4f4;
        }

        .review {
                margin-left: 50px;
                font-size: 20px;
        }

    </style>
</head>
<body>
    <nav>
        <a href="{{ url_for('index') }}">FlaskApp</a>
        <a href="{{ url_for('create') }}">Create</a>
        <a href="#">About</a>
    </nav>
    <hr>
    <div class="content">
        {% block content %} {% endblock %}
    </div>
</body>
</html>

Speichern und schließen Sie die Datei.

Hier fügen Sie einen neuen <a>-Link zur Navigationsleiste hinzu, der zur Seite „Erstellen“ verweist.

Aktualisieren Sie Ihre Indexseite und Sie werden den neuen Link in der Navigationsleiste sehen.

Sie haben jetzt eine Seite mit einem Webformular zum Hinzufügen neuer Buchrezensionen. Weitere Informationen zu Webformularen finden Sie unter Wie man Webformulare in einer Flask-Anwendung verwendet. Für eine fortgeschrittenere und sicherere Methode zur Verwaltung von Webformularen siehe Wie man Webformulare mit Flask-WTF verwendet und validiert.

Fazit

Sie haben eine kleine Webanwendung für Buchrezensionen erstellt, die mit einer PostgreSQL-Datenbank kommuniziert. Sie verfügen über grundlegende Datenbankfunktionen in Ihrer Flask-Anwendung, wie das Hinzufügen neuer Daten zur Datenbank, das Abrufen von Daten und deren Anzeige auf einer Seite.

Wenn Sie mehr über Flask erfahren möchten, schauen Sie sich die anderen Tutorials in der Flask-Serie an.

Source:
https://www.digitalocean.com/community/tutorials/how-to-use-a-postgresql-database-in-a-flask-application