התחלה עם Flask, פרויקט מיקרו של Python

בכתבה זו, נציג את Flask, מיקרו-פרויקט פופולרי עבור Python המציע חלופה לג'נגו העצום.

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

דברים חשובים לזכור

מה זה Flask?

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

הוא מבוסס על כלי Werkzeug WSGI, שמספק פונקציונליות של שרת רשת הדרושה לטפל בבקשות ותגובות, ואת מנוע התבניות Jinja2, שמאפשר ל-Flask להתמודד עם תבניות HTML, מה שמאפשר למפתחים ליצור אפליקציות רשת דינמיות.

הנה כמה מהמאפיינים המרכזיים של Flask שהופכים אותו לפריימוורק מעולה לעבוד איתו:

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

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

יתרונות של Flask

הבה נבחן עכשיו באופן מפורט יותר חלק מיתרונות השימוש ב-Flask בפיתוח.

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

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

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

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

פיתוח מהיר. הפשטות והגמישות של Flask מקטינים את הבוליםרייף הנדרש להקמת יישום, מה שמאפשר למפתחים להתחיל במהירות.

ברשת, Flask משמש בהרבה דרכים מעניינות. כמה דוגמאות מפורסמות הן:

• PgAdmin. ממשק הניהול של Postgres פועל על מופע של Flask, מה שנותן למפתחים ממשק שבו הם יכולים לנהל את מאגרי ה-Postgres שלהם.
• Twilio. זהו רשת תקשורת שמשתמשת ב-Flask בכמה מה-APIs שלה.
• Pinterest. אפליקציית שיתוף תמונות זו משתמשת ב-Flask בעמוד הכותר של האתר, מה שמאפשר לצוותה ליצור תכונות מותאמות אישית ואינטגרציות בקלות.

מתי להשתמש ב-Flask

הפשטות וקלות השימוש ב-Flask הופכים אותו לבחירה מצוינת למגוון רחב של פרויקטים אינטרנטיים:

• פרוטוטיפים. הקלות שלו בשימוש והגמישות מהוות בחירה מצוינת ליצירת פרוטוטיפים מהירים, מה שמאפשר למפתחים לבנות ולבחון תכונות חדשות במהירות.
• יצירת APIs RESTful. ה-API הפשוט שלו מקל על יצירת ועיבוד בקשות HTTP.
• אפליקציות אינטרנטיות. הוא עובד היטב לבניית שווקים מקוונים ופלטפורמות אינטרנטיות.
• פיננסים. זה שימושי לבניית יישומים פיננסיים, עם ניהול חשבונות, עיבוד עסקאות ומעקב אחר השקעות.
• AI. היא מציעה דרך שימושית ופשוטה לבניית ופרוסובליים של מודלים לאימון AI.

מתי לא להשתמש ב-Flask

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

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

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

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

הקמת סביבת פיתוח Flask

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

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

צריך להתקין את Python על המחשב המשמש לפיתוח. הנה הוראות לכך (אם כי אנו עשויים כבר להתקין אותו).

יצירת סביבת וירטואלית

A virtual environment is an isolated Python environment where we can install packages for a given project without affecting the global Python installation. (Here’s further discussion about why virtual environments are useful.) There are different packages for creating virtual environments in Python, such as virtualenv, venv, or Conda.

במאמר זה, נשתמש ב-virtualenv. נוכל להתקין אותו באמצעות הפקודה הבאה:

pip install virtualenv

ברגע שהתקנו את virtualenv, נוכל ליצור תיקייה שבה ישתתף היישום של Flask. נוכל לקרוא לתיקייה מה שנרצה – למעט Flask, שזה יגרום לסככות. נקרא לשלנו flask_intro:

mkdir flask_intro

לאחר מכן, נעבור לתיקייה זו כדי שנוכל להתחיל להשתמש בה:

cd flask_intro

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

virtualenv myenv

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

. myenv/bin/activate

ב-Windows, השתמשו בפקודה זו:

. myenv\Scripts\activate

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

(myenv)/~(path to your project directory)$

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

pip install Flask

לאחר שהתקנת Flask תסתיים, בואו ניצור יסודות של יישום. ניצור מודול שיכיל את יישום Flask שלנו. לשם פשטות, נקרא לו hello.py. ב-לינוקס או macOS אנו יכולים להשתמש בפקודה הבאה כדי ליצור את הקובץ בספריית flask_intro שלנו:

touch hello.py

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

# hello.py
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
    return 'Hello, World!'

בקוד לעיל, אנו מייבאים את המחלקה Flask מהמודול flask, ואז יוצרים מופע של Flask שאנו קוראים לו app ומעבירים את המשתנה __name__.

לאחר מכן יש לנו את מספר הזיהוי של הנתיב @app.route(“\”), מה שאומר שהפונקציה hello_world() תופעל כשמישהו מבקר בנתיב השורש (root route) של היישום שלנו ברגע שהוא מופעל.

יש דרכים רבות שבהן נוכל להפעיל את היישום, אז בואו נבחן כמה מהן. הדרך הראשונה היא לספק לפקודת flask מספר טיעונים: --app, ואז את שמה של המודול שמכיל את יישום Flask שלנו, ולאחר מכן run. ראה למטה:

flask –app <the name of your module> run

באמצעות הדוגמה לעיל כדי להפעיל את היישום הדוגמא שלנו:

flask –app hello run

זה ירוץ את היישום שלנו על היציאה הברירת מחדל 5000 כך שהיישום יהיה זמין ב-http://localhost:5000/ או ב-http://127.0.0.1:5000/. אם אנו רוצים שהיישום יהיה זמין ביציאה אחרת, אנו יכולים לציין את היציאה באמצעות האפשרות -p או --port. לדוגמה:

flask --app hello run --port=8080

זה ירוץ את השרת על יציאה 8080. הדרך האחרת שבה אנו יכולים להריץ את היישום היא פשוט באמצעות הפקודות flask run. עם זאת, כדי שנוכל לעשות זאת, עלינו לומר ל-Flask את שמו של המודול שיכיל את המופע של Flask, ואנו עושים זאת על ידי הגדרת המשתנה הסביבתי FLASK_APP. אז במקרה שלנו, היישום של Flask מכוסה בקובץ בשם hello.py. אז אנחנו יכולים להגדיר את זה כך:

export FLASK_APP=hello

עכשיו שהגדרנו את המשתנה הסביבתי FLASK_APP, אנו יכולים להריץ את שרת הפיתוח כך:

flask run

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

תבניות Flask

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

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

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

# index.py
from flask import Flask, render_template
app = Flask(__name__)
@app.route('/')
def index():
    title = 'Welcome to my website!'
    message = 'This is an example of using Flask templates.'
    return render_template('index.html', title=title, message=message)

בדוגמא לעיל, יש לנו פונקציית ממשק – index() – שקשורה לכתובת השרת הבסיסית ("/") על ידי המסמר @app.route(). הפונקציה מכילה שני משתנים, title ו-message. לבסוף, אנו מעבירים את התבנית index.html ל-render_template(), יחד עם המשתנים title ו-message.

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

# index.html
<!doctype html>
<html>
<head>
    <title>{{ title }}</title>
</head>
<body>
    <h1>{{ title }}</h1>
    <p>{{ message }}</p>
</body>
</html>

בקובץ index.html, המיקומים המקושרים {{title}} ו-{{ message }} מתחלפים בערכים שהועברו לתבנית בשיטת render_template().

תבניות יכולות גם לכלול תחומים מורכבים יותר כגון הצהרות if ולולאות for, מה שמאפשר יצירת דפים דינמיים יותר.

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

ניתוב ב-Flask

רוב היישומים האינטרנטיים יהיו עם יותר מכתובת URL אחת, ולכן עלינו לדעת מהי הפונקציה שמטפלת בכל כתובת URL. ב-Flask, המיפוי הזה ידוע כ-routing – תהליך של קישור או מיפוי של כתובות URL לפונקציות ממשק. קישור כתובות URL לפונקציות ממשק מאפשר ליישום לטפל בסוגים שונים של בקשות, כגון GET, POST, PUT, DELETE ועוד. זה גם מאפשר ליישום לטפל במספר רב של בקשות מלקוחות שונים.

כדי להגדיר מסלולים ב-Flask, אנו משתמשים בroute() decorator. ה-decorator קושר כתובת URL לפונקציה ממשק – כך שכשמשתמש מבקר בכתובת URL שקיימת ביישום שלנו, Flask מפעיל את הפונקציה הממשק המשויכת לטפל בבקשה.

בואו נראה דוגמא:

# hello.py
from flask import Flask, render_template

app = Flask(__name__)

@app.route("/about")
def about():
    return "This is the about page"

בדוגמה שלעיל, אנו מגדירים כתובת URL על עמוד על (/about). כשהיישום מקבל בקשה לכתובת about, Flask קורא לפונקציה about(), שמחזירה את המחרוזת "זהו עמוד העל".

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

בואו נראה דוגמא לבקשה PUT:

from flask import Flask, request

app = Flask(__name__)

@app.route('/users/<int:user_id>', methods=['PUT'])
def update_user(user_id):
    # השגת נתוני המשתמש מגוף הבקשה
    data = request.get_json()
    # ביצוע פעולה עם נתוני המשתמש, כגון עדכון המשתמש במסד הנתונים
    # ...
    # החזרת תגובה המציינת הצלחה או כישלון
    return {'message': f'User {user_id} updated successfully'}, 200

בדוגמה זו, אנו מגדירים נתיב שמטפל בבקשה PUT לעדכון פרטי המשתמש בהינתן user_id שלהם. אנו משתמשים ב<int:user_id> בנתיב כדי לציין שמזהה המשתמש צריך להיות מספר שלם.

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

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

טופסים ואימות ב-Flask

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

pip install WTForms

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

בואו נראה דוגמא של טפרס להתחברות:

# forms.py
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
from wtforms.validators import DataRequired, Email, Length

class LoginForm(FlaskForm):
    email = StringField('Email', validators=[DataRequired(), Email()])
    password = PasswordField('Password', validators=[DataRequired(), Length(min=6)])
    submit = SubmitField('Log In')

בדוגמא לעיל, אנו מגדירים טפרס להתחברות עם שני שדות – email ו-password – וכפתור של שליחה. יש לנו גם טיעון validators שמשמש לציין כללי ולידה לכל שדה. לדוגמא, במקרה זה אנו דורשים שהשדה email יכיל כתובת דוא״ל תקינה והשדה password יכיל סיסמא שאינה פחותה משישה תווים.

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

# views.py
from flask import render_template, request
from .forms import LoginForm

@app.route('/login', methods=['GET', 'POST'])
def login():
    form = LoginForm()
    if form.validate_on_submit():
        email = form.email.data
        password = form.password.data
        # לעשות משהו עם נתוני הטפרס
    return render_template('login.html', form=form)

בדוגמא לעיל, יש לנו נוף login שמקבל שני שיטות HTTP (GET ו-POST), כך שכאשר משתמשים גולשים לכתובת האתר מדפדפן האינטרנט ה-LoginForm מופיע כטפרס HTML באמצעות השיטה render_template, וכאשר משתמש שולח את הטפרס אנו בודקים אם הטפרס תקין באמצעות השיטה validate_on_submit. אם הטפרס תקין, אנו גולשים את הדוא״ל והסיסמא.

הטפרס login.html יכול להיראות משהו כזה:

# login.html
<h1>Login</h1>
<form method="POST">
  {{ form.csrf_token }}
  <div>
    {{ form.email.label }} {{ form.email() }}
    {% for error in form.email.errors %}
    <span style="color: red;">[{{ error }}]</span>
    {% endfor %}
  </div>
  <div>
    {{ form.password.label }} {{ form.password() }}
    {% for error in form.password.errors %}
      <span style="color: red;">[{{ error }}]</span>
    {% endfor %}
  </div>
  {{ form.submit() }}
</form>

התבנית האמורה תפעיל את השדות email ו-password, יחד עם הכינויים שלהם, וכן כפתור הגשה עם הטקסט "התחברות". השדה form.csrf_token כלול כדי למנוע מתקפות זיוף בקריאה באמצעות אינטרנט (CSRF). הלולאות {% for %} משמשות להצגת שגיאות התקפה שעשויות להתרחש.

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

תוספות Flask

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

הנה חלק מהפופולריים ביותר:

• Flask-SQLAlchemy: מספק אינטגרציה עם כלי SQLAlchemy המקל על התקשרות עם מאגרי נתונים.
• Flask-Login: מספק אבטחת משתמש וניהול שיחות ל-Flask.
• Flask-Mail: מספק ממשק פשוט לשליחת הודעות דואר אלקטרוני מ-Flask.

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

בואו נראה דוגמה לשימוש ב-Flask-SQLAlchemy. קודם כל, אנו צריכים להתקין אותו:

pip install flask-sqlalchemy

לאחר מכן, עלינו להגדיר אותו. לדוגמה:

# sqlalchemy_example.py
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///example.db'
db = SQLAlchemy(app)

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

    def __repr__(self):
        return '<User %r>' % self.username

בדוגמה לעיל, יש לנו מודל User עם שדה username ושדה email. אנו גם מגדירים SQLALCHEMY_DATABASE_URI, מה שמעיד על כך שאנו משתמשים במסד נתונים SQLite הממוקם ב example.db. עם זה מוגדר, עכשיו יש לנו גישה לאובייקט db המאפשר לנו לתקשר עם מסד הנתונים. לדוגמה, יכולנו ליצור משתמש חדש ולהוסיף אותו למסד הנתונים, ככה:

#views.py 
from app import db, User

user = User(username='john', email='[email protected]')
db.session.add(user)
db.session.commit()

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

מסקנה

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

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

אם אתה מעוניין ללמוד עוד על Flask, הנה כמה מקורות נוספים:

• תיעוד Flask
• מדריך על Flask המגה, מאת מיגל גרינברג
• פיתוח רשת Flask, מאת מיגל גרינברג
• A simple Flask app tutorial
• הדרכות Flask של Real Python

אם אתה רוצה ללמוד עוד על Django ו-Flask ושימושיהם הטובים ביותר, תראה פיתוח אינטרנט ב-Python עם Django ו-Flask.

שאלות נפוצות על Flask, פריימוורק של Python