איך להשתמש במסד נתונים של PostgreSQL באפליקציית Flask

המחבר בחר בקרן הקוד הפתוח והחופשי לקבל תרומה כחלק מתוכנית "כתוב לתרומות".

הקדמה

ביישומי אינטרנט, כללית צורך במסד נתונים, שהוא אוסף מאורגן של נתונים. אתה משתמש במסד נתונים כדי לאחסן ולשמור נתונים עמידים בזמן שניתן לאחזר ולעבוד בהם ביעילות. לדוגמה, ביישום למדיה חברתית יש לך מסד נתונים שבו נתוני המשתמש (מידע אישי, פוסטים, תגובות, עוקבים) מאוחסנים בדרך שניתן לעבוד איתם ביעילות. ניתן להוסיף נתונים למסד נתונים, לאחזר אותם, לשנות אותם או למחוק אותם, תלוי בדרישות ובתנאים שונים. ביישום אינטרנט, דרישות אלו עשויות להיות הוספת פוסט חדש על ידי משתמש, מחיקת פוסט או מחיקת החשבון שלו, שעשויים או לא למחוק את הפוסטים שלו. הפעולות שאתה בוצע כדי לעבוד עם הנתונים יתנהגו על פי התכונות המסוימות ביישום שלך. לדוגמה, תכונה שאולי לא תרצה למשתמשים להוסיף פוסטים בלי כותרות.

Flask הוא סביבת פיתוח קלה בשפת פייתון המספקת כלים ותכונות שימושיים ליצירת אפליקציות רשת בשפת פייתון. PostgreSQL, או Postgres, הוא מערכת לניהול מסדי נתונים רצופיים המספקת יישום של שפת השאילתא SQL. הוא תואם תקנים וכולל מספר תכונות מתקדמות כגון עסקאות אמינות וקידומת בלי נעילות קריאה.

במדריך זה, תצור יישום אינטרנט קטן לביקורת ספרים המדגים כיצד להשתמש בספריית psycopg2, מתאם מסד נתונים PostgreSQL המאפשר לך לפעול עם מסד הנתונים שלך ב- Python. תשתמש בו עם Flask כדי לבצע משימות בסיסיות, כגון התחברות לשרת מסד נתונים, יצירת טבלאות, הכנסת נתונים לטבלה, ואיחזור נתונים מטבלה.

דרישות מוקדמות

• סביבת פיתוח Python 3 מקומית. עקוב אחר המדריך להתקנה והגדרת סביבת פיתוח מקומית עבור Python 3 בסדרת המדריכים כיצד להתקין ולהגדיר סביבת פיתוח מקומית עבור Python 3. במדריך זה, ספריית הפרויקט נקראת flask_app.

• הבנת מושגים בסיסיים של Flask, כמו נתיבים, פונקציות תצוגה ותבניות. אם אינך מכיר את Flask, עיין במאמר "איך ליצור אפליקציית אינטרנט ראשונה שלך באמצעות Flask ו-Python" ובמאמר "כיצד להשתמש בתבניות באפליקציית Flask".

• הבנת מושגים בסיסיים של HTML. תוכל לעיין בסדרת המדריכים שלנו "כיצד לבנות אתר באמצעות HTML" לידע רקע.

• PostgreSQL מותקן על המחשב המקומי שלך, ויש לך גישה ל-Prompt של PostgreSQL. עקוב אחר איך להתקין ולהשתמש ב-PostgreSQL על Ubuntu 20.04 כדי להגדיר את מסד הנתונים שלך ב-PostgreSQL.

שלב 1 — יצירת מסד הנתונים ומשתמש ב-PostgreSQL

בשלב זה, תיצור מסד נתונים בשם flask_db ומשתמש במסד נתונים בשם sammy עבור אפליקציית Flask שלך.

במהלך ההתקנה של Postgres, נוצר משתמש מערכת בשם postgres כדי להתאים למשתמש המנהלי postgres של PostgreSQL. עליך להשתמש במשתמש זה כדי לבצע משימות מנהליות. ניתן להשתמש ב-sudo ולהעביר את שם המשתמש עם האפשרות -iu.

התחבר למפגש אינטראקטיבי של Postgres באמצעות הפקודה הבאה:

sudo -iu postgres psql

תקבל מודעת PostgreSQL בה תוכל להגדיר את הדרישות שלך.

ראשית, צור מסד נתונים עבור הפרויקט שלך:

CREATE DATABASE flask_db;

לאחר מכן, צור משתמש מסד נתונים עבור הפרויקט שלנו. וודא שאתה בוחר סיסמה מאובטחת:

CREATE USER sammy WITH PASSWORD 'password';

לאחר מכן הענק גישה למשתמש החדש לנהל את מסד הנתונים החדש שלך:

GRANT ALL PRIVILEGES ON DATABASE flask_db TO sammy;

כדי לאשר שהמסד נוצר, קבל את רשימת מסדי הנתונים על ידי הקלדת הפקודה הבאה:

\l

תראה את flask_db ברשימת מסדי הנתונים.

כאשר תסיים, צא מהפקודה של PostgreSQL על ידי הקלדה של:

\q

Postgres מוכן כעת כך שתוכל להתחבר ולנהל את מידע מסד הנתונים שלך באמצעות Python באמצעות ספריית psycopg2. בשלב הבא, תתקין את הספרייה הזו לצד חבילת Flask.

שלב 2 — התקנת Flask ו־psycopg2

בשלב זה, תתקין את Flask ואת ספריית psycopg2 כך שתוכל להתקשר למסד הנתונים שלך באמצעות Python.

עם הסביבה הווירטואלית שלך מופעלת, השתמש ב־pip כדי להתקין את Flask ואת ספריית psycopg2:

pip install Flask psycopg2-binary

כאשר ההתקנה מסתיימת בהצלחה, תראה שורה דומה לזו בסוף הפלט:

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

עכשיו יש לך את החבילות הנדרשות מותקנות על הסביבה הווירטואלית שלך. בשלב הבא, תתחבר ותגדיר את מסד הנתונים שלך.

שלב 3 — הגדרת מסד נתונים

בשלב זה, תיצור קובץ Python בספריית פרוייקט flask_app כדי להתחבר למסד הנתונים flask_db, ליצור טבלה לאחסון ספרים ולהכניס מספר ספרים עם ביקורות אליה.

תחילה עם הסביבת התכנות שלך מופעלת, פתח קובץ חדש בשם init_db.py בספריית flask_app שלך.

nano init_db.py

קובץ זה יפתח חיבור למסד הנתונים flask_db, ייצור טבלה בשם books וימלא את הטבלה בנתוני דוגמה. הוסף את הקוד הבא לקובץ:

import os
import psycopg2

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

# פתח סמן לבצע פעולות במסד נתונים
cur = conn.cursor()

# הרץ פקודה: זה ייצור טבלה חדשה
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);'
                                 )

# הכנס נתונים לטבלה

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()

שמור וסגור את הקובץ.

בקובץ זה, תתייבא תחילה את המודול os שתשתמש בו כדי לגשת למשתני הסביבה שבהם תאחסן את שם המשתמש והסיסמה של מסד הנתונים שלך כך שהם לא יהיו גלויים בקוד המקור שלך.

אתה מייבא את הספרייה psycopg2. לאחר מכן אתה פותח חיבור למסד הנתונים flask_db באמצעות פונקציית psycopg2.connect(). אתה מציין את המארח, שהוא המחשב המקומי במקרה זה. אתה מעביר את שם המסד נתונים לפרמטר database.

אתה מספק את שם המשתמש והסיסמה שלך דרך אובייקט os.environ, שמאפשר לך גישה למשתני סביבת העבודה שהגדרת בסביבת התכנות שלך. תאפשר לאחסן את שם המשתמש במסד הנתונים במשתנה סביבת עבודה הנקרא DB_USERNAME ואת הסיסמה במשתנה סביבת עבודה הנקרא DB_PASSWORD. זה מאפשר לך לאחסן את שם המשתמש והסיסמה מחוץ לקוד המקור שלך, כך שהמידע הרגיש שלך לא יחשף כאשר קוד המקור נשמר בבקרת גרסאות או מועלה לשרת באינטרנט. גם אם התוקפן משיג גישה לקוד המקור שלך, הוא לא יקבל גישה למסד הנתונים.

אתה יוצר קורסור בשם cur באמצעות השיטה connection.cursor(), שמאפשרת לקוד פייתון לבצע פקודות PostgreSQL במהלך סשן מסד נתונים.

אתה משתמש בשיטת execute() של הסדר אית העכבר כדי למחוק את טבלת books אם היא כבר קיימת. זה מונע את האפשרות של קיום טבלה נוספת בשם books, שעשוי להוביל להתנהגות מבלבלת (לדוגמה, אם יש לה עמודות שונות). זה אינו המקרה כאן, מכיוון שלא יצרת את הטבלה עדיין, כך שהפקודה SQL לא תופעל. שים לב שזה ימחק את כל הנתונים הקיימים בכל פעם שתפעיל את קובץ init_db.py זה. לצרכים שלנו, תפעיל את הקובץ הזה רק פעם אחת כדי להתחיל את הבסיס נתונים, אך עשוי להיות רצונך להפעיל אותו שוב כדי למחוק את כל הנתונים שהוספת ולהתחיל שוב עם הנתונים המדוגמים הראשוניים.

לאחר מכן, אתה משתמש ב- CREATE TABLE books כדי ליצור טבלה בשם books עם העמודות הבאות:

• id: זיהוי מסוג serial, שהוא מספר שמתרבה באופן אוטומטי. עמודה זו מייצגת מפתח ראשי שאתה מציין באמצעות מילות המפתח PRIMARY KEY. מסד הנתונים יחייב ערך ייחודי עבור מפתח זה לכל ערך.
• title: כותרת הספר מסוג varchar, שהוא סוג תווים משתנה עם הגבלה. varchar (150) אומר שהכותרת יכולה להיות באורך של עד 150 תווים. NOT NULL מציין שעמודה זו לא יכולה להיות ריקה.
• author: מחבר הספר, עם הגבלה של 50 תווים. NOT NULL מציין שעמודה זו לא יכולה להיות ריקה.
• pages_num: מספר שלם המייצג את מספר העמודים בספר. NOT NULL מציין שעמודה זו לא יכולה להיות ריקה.
• review: הביקורת על הספר. סוג ה־text מציין שהביקורת יכולה להיות מלל של כל אורכה.
• date_added: תאריך ההוספה של הספר לטבלה. DEFAULT מגדיר את הערך המוגדר כברירת מחדל של העמודה ל־CURRENT_TIMESTAMP, שהוא הזמן שבו הספר נוסף למסד הנתונים. כמו id, אין צורך לציין ערך עבור עמודה זו, מאחר והיא תתמלא אוטומטית.

לאחר יצירת הטבלה, אתה משתמש ב־execute() של הסמן כדי להוסיף שני ספרים לטבלה, A Tale of Two Cities של צ'ארלס דיקנס, ו־Anna Karenina של ליאו טולסטוי. אתה משתמש בפלטפורמת psycopg2 לטיפול בהכנסה ברקע בדרך שמונעת תקיפות הכנסת SQL.

לאחר שסיימת להכניס נתוני ספרים לטבלה שלך, אתה משתמש ב־connection.commit() כדי לבצע את העסקה ולהחיל את השינויים למסד הנתונים. לאחר מכן, אתה מנקה דברים על ידי סגירת הסמן עם cur.close(), והחיבור עם conn.close().

כדי שהחיבור למסד הנתונים יתקיים, הגדר את משתני הסביבה DB_USERNAME ו־DB_PASSWORD על ידי הרצת הפקודות הבאות. זכור להשתמש בשם משתמש ובסיסמה שלך:

export DB_USERNAME="sammy"
export DB_PASSWORD="password"

עכשיו, הפעל את קובץ ה־init_db.py שלך בטרמינל באמצעות הפקודה python:

python init_db.py

כאשר הקובץ מסיים את הרצתו ללא שגיאות, טבלת books חדשה תתווסף לבסיס הנתונים שלך flask_db.

התחבר להתנהגות הפוסטגרס האינטראקטיבית כדי לבדוק את טבלת הספרים החדשה books.

sudo -iu postgres psql

התחבר לבסיס הנתונים flask_db באמצעות הפקודה \c:

\c flask_db

אז השתמש בהצהרת SELECT כדי לקבל את הכותרים והסופרים של הספרים מטבלת הספרים books:

SELECT title, author FROM books;

תראה פלט כמו הבא:

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

צא מההתנהגות האינטראקטיבית עם \q.

לבא תיצור אפליקציה פלאסק קטנה, תתחבר לבסיס הנתונים, תאחזר את שני הביקורות של הספר שהוכנסו לבסיס הנתונים, ותציג אותם בעמוד האינדקס.

שלב 4 — הצגת ספרים

בשלב זה, תיצור אפליקציה פלאסק עם עמוד אינדקס שמאחזר את הספרים שנמצאים בבסיס הנתונים, ומציג אותם.

עם הסביבה שלך לתכנות מופעלת ופלאסק מותקן, פתח קובץ בשם app.py לעריכה בתוך התיקייה flask_app:

nano 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)

שמור וסגור את הקובץ.

כאן, אתה מייבא את המודול os, את הספרייה psycopg2, ואת המחלקה Flask ואת הפונקציה render_template() מחבילת flask. אתה יוצר מופע של אפליקציית Flask בשם app.

אתה מגדיר פונקציה בשם get_db_connection(), שפותחת חיבור למסד הנתונים flask_db באמצעות שם המשתמש והסיסמה שאתה מאחסן במשתני הסביבה DB_USERNAME ו- DB_PASSWORD. הפונקציה מחזירה את אובייקט החיבור conn שתשתמש בו כדי לגשת למסד הנתונים.

אז אתה יוצר נתיב ראשי / ופונקציית תצוגה index() באמצעות המקשין app.route(). בפונקציית התצוגה index(), אתה פותח חיבור למסד הנתונים באמצעות הפונקציה get_db_connection(), אתה יוצר קרסור, ומבצע את ההוראה ה-SQL SELECT * FROM books; כדי לקבל את כל הספרים שנמצאים במסד הנתונים. אתה משתמש בשיטת fetchall() כדי לשמור את הנתונים במשתנה בשם books. אז אתה סוגר את הקרסור ואת החיבור. לבסוף, אתה מחזיר קריאה לפונקציה render_template() כדי לעצב קובץ תבנית בשם index.html ולהעביר אליו את רשימת הספרים שקיבלת ממסד הנתונים במשתנה books.

כדי להציג את הספרים שיש לך במסד הנתונים שלך בדף הבית, תיצור תבנית בסיס, שתכיל את כל קוד ה-HTML הבסיסי שבו תשתמש תבניות אחרות כדי למנוע חזרה על הקוד. לאחר מכן תיצור את קובץ התבנית index.html שאתה מציג בפונקציית ה-index() שלך. כדי למד עוד על תבניות, ראה איך להשתמש בתבניות ביישומון Flask.

צור ספריית templates, ואז פתח תבנית חדשה בשם base.html:

mkdir templates
nano templates/base.html

הוסף את הקוד הבא לתוך קובץ ה-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>

שמור וסגור את הקובץ.

תבנית הבסיס הזו מכילה את כל הקוד הבסיסי של HTML שתצטרך לשקול לשימוש חוזר בתבניות האחרות שלך. הבלוק title יוחלף כדי להגדיר כותרת לכל דף, והבלוק content יוחלף עם התוכן של כל דף. סרגל הניווט מכיל שני קישורים, אחד לדף הבית שבו אתה משתמש בפונקציית העזר url_for() כדי לקשר לפונקציית התצוגה index(), והשני לדף אודות אם בחרת לכלול אחד ביישומון שלך.

בשלב הבא, פתח תבנית בשם index.html. זו התבנית שהתייחסת אליה בקובץ ה-app.py:

nano 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 %}

שמור וסגור את הקובץ.

בקובץ זה, אתה מרחיב את תבנית הבסיס, ומחליף את תוכן הבלוק content. אתה משתמש בכותרת <h1> שגם משמשת ככותרת.

אתה משתמש בלולאת Jinja for loop בשורה {% for book in books %} כדי לעבור דרך כל ספר ברשימת books. אתה מציג את מזהה הספר, שהוא הפריט הראשון באמצעות book[0]. לאחר מכן, אתה מציג את כותרת הספר, המחבר, מספר העמודים, הביקורת, ותאריך ההוספה של הספר.

בעת שהתיקייה שלך flask_app עם סביבת העבודה הווירטואלית שלך מופעלת, ספר ל־Flask על היישום (app.py במקרה זה) באמצעות משתנה הסביבה FLASK_APP. לאחר מכן הגדר את משתנה הסביבה FLASK_ENV ל־development כדי להריץ את היישום במצב פיתוח וכדי לקבל גישה למנפק שגיאות. למידע נוסף על מנפק השגיאות של Flask, ראה איך לטפל בשגיאות ביישום Flask. השתמש בפקודות הבאות כדי לבצע זאת:

export FLASK_APP=app
export FLASK_ENV=development

ודא שהגדרת את משתני הסביבה DB_USERNAME ו־DB_PASSWORD אם לא עשית זאת כבר:

export DB_USERNAME="sammy"
export DB_PASSWORD="password"

לאחר מכן, הפעל את היישום:

flask run

עם שרת הפיתוח פועל, בקר לכתובת האינטרנט הבאה באמצעות הדפדפן שלך:

http://127.0.0.1:5000/

תראה את הספרים שהוספת למסד הנתונים באתחול הראשון.

הצגת את הספרים במסד הנתונים שלך על הדף הראשי. עכשיו עליך לאפשר למשתמשים להוסיף ספרים חדשים. תוסיף נתיב חדש להוספת ספרים בשלב הבא.

שלב 5 — הוספת ספרים חדשים

בשלב זה, תיצור מסלול חדש להוספת ספרים חדשים וביקורות למסד הנתונים.

תוסיף דף עם טופס אינטרנטי שבו משתמשים יזינו את כותרת הספר, את הסופר, את מספר העמודים ואת ביקורת הספר.

השאר את שרת הפיתוח רץ ופתח חלון טרמינל חדש.

ראשית, פתח את קובץ app.py:

nano app.py

עבור טיפול בטופס האינטרנטי, יהיה עליך לייבא כמה דברים מחבילת flask:

• אובייקט הגלובלי request כדי לגשת לנתונים שהוגשו.
• פונקציית url_for() ליצירת כתובות URL.
• פונקציית redirect() כדי להפנות משתמשים לדף הבית לאחר הוספת ספר למסד הנתונים.

הוסף את הייבואים האלה לשורה הראשונה בקובץ:

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

# ...

לאחר מכן, הוסף את המסלול הבא בסופו של קובץ app.py:

# ...


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

שמור וסגור את הקובץ.

במסלול זה, אתה מעביר את הטייפל ('GET', 'POST') לפרמטר methods כדי לאפשר בקשות GET ו-POST גם. בקשות GET משמשות לאיחזור נתונים מהשרת. בקשות POST משמשות לפרסום נתונים למסלול מסוים. כברירת מחדל, מותרות רק בקשות GET. כאשר המשתמש פונה לראשונה את המסלול /create באמצעות בקשת GET, קובץ תבנית בשם create.html יוצג. תערוך מאוחר יותר את המסלול הזה כדי לטפל בבקשות POST כאשר המשתמשים ממלאים ושולחים את טופס האינטרנט להוספת ספרים חדשים.

פתח את תבנית ה-create.html החדשה:

nano 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 %}

שמור וסגור את הקובץ.

אתה מרחיב את תבנית הבסיס, מגדיר כותרת ככותרת, ומשתמש בתגית <form> עם המאפיין method שמוגדר כ-post כדי לציין כי הטופס ישלח בקשת POST.

יש לך שדה טקסט בשם title, שתשתמש בו כדי לגשת לנתוני הכותרת במסלול ה-/create שלך.

יש לך שדה טקסט עבור המחבר, שדה מספרים עבור מספר העמודים, ואזור טקסט עבור ביקורת הספר.

לבסוף, יש לך כפתור Submit בסופו של הטופס.

כעת, עם שרת הפיתוח פועל, השתמש בדפדפן שלך כדי לנווט אל המסלול /create:

http://127.0.0.1:5000/create

תראה עמוד הוספת ספר חדש עם שדה קלט לכותרת הספר, אחד עבור המחבר שלו, ואחד עבור מספר העמודים של הספר, אזור טקסט עבור ביקורת הספר, וכפתור Submit.

אם תמלא את הטופס ותשלח אותו, שולח בקשת POST לשרת, אז כלום לא יקרה מאחר ולא טיפלת בבקשות POST על הנתיב /create.

פתח app.py כדי לטפל בבקשת ה-POST שהמשתמש שולח:

nano app.py

ערוך את הנתיב /create כך:

# ...

@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')

שמור וסגור את הקובץ.

תטפל בבקשות POST בתוך התנאי if request.method == 'POST'. תחלץ את הכותרת, המחבר, מספר העמודים והביקורת שהמשתמש שולח מהעצם request.form.

פתח מסד נתונים באמצעות הפונקציה get_db_connection() וצור קרסור. לאחר מכן, הפעל פקודת SQL INSERT INTO כדי להכניס את הכותרת, המחבר, מספר העמודים והביקורת שהמשתמש שלח לתוך טבלת books.

בצע את העסקה וסגור את הקרסור והחיבור.

לבסוף, הפנה את המשתמש לדף האינדקס כאשר הוא יכול לראות את הספר החדש שנוסף ליד הספרים הקיימים.

עם השרת לפיתוח פועל, השתמש בדפדפן שלך כדי לנווט אל הנתיב /create:

http://127.0.0.1:5000/create

מלא את הטופס עם מידע כלשהו ושלח אותו.

תופנה לדף האינדקס כאשר תראה את הביקורת החדשה שלך.

בשלב הבא, תוסיף קישור לדף יצירה בתפריט הניווט. פתח base.html:

nano 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>

שמור וסגור את הקובץ.

כאן, אתה מוסיף קישור חדש <a> לתיבת הניווט שמצביע לדף "צור".

רענן את דף האינדקס ותראה את הקישור החדש בתיבת הניווט.

כעת יש לך דף עם טופס אינטרנטי להוספת ביקורות ספרים חדשות. למידע נוסף על טפסים אינטרנטיים, ראה כיצד להשתמש בטפסים אינטרנטיים ביישום Flask. עבור שיטה מתקדמת יותר ומאובטחת יותר לניהול טפסים אינטרנטיים, ראה כיצד להשתמש ולאמת טפסים אינטרנטיים עם Flask-WTF.

מסקנה

בנית יישום אינטרנט קטן לביקורות ספרים המתקשר עם מסד נתונים PostgreSQL. יש לך פונקציונליות בסיסית של מסד נתונים ביישום Flask שלך, כגון הוספת נתונים חדשים למסד הנתונים, איחזור נתונים והצגתם בדף.

אם ברצונך לקרוא עוד על Flask, עיין במדריכים האחרים ב סדרת המדריכים של Flask.