البدء بـ Flask، إطار عمل ميكرو للبايثون

في هذا المقال، سنقدم Flask، إطار عمل ميكرو مشهور للبرمجة بلغة Python، وهو بديل عن عملاق Django.

تم تصميم Flask ليكون خفيف الوزن ومرن، مما يسمح للمطورين بإنشاء تطبيقات الويب بسرور وبسهولة. في هذا المقال، سنغطي ما هو Flask، ميزاته الرئيسية، مزايا APIه البسيطة، مرونته في دعم الامتدادات الثالثة، الامتدادات الشائعة في Flask، ومتى هو ومتى لا يكون الوقت المناسب لاستخدام Flask.

المشاهدات الرئيسية

ما هو Flask؟

Flask هو إطار عمل ويب ميكرو مكتوب بلغة Python يستخدم لتطوير تطبيقات الويب. يقوم على مبدأ بساطة وخفة الوزن، مما يمنح المطورين الأدوات الأساسية اللازمة لبناء تطبيقات الويب دون تعقيد غير ضروري.

يقوم على ركيزة Werkzeug WSGI التي توفر وظائف الخادم الويب اللازمة لمعالجة الطلبات والاستجابات، ومحرك Jinja2 لقالب العرض، مما يمنح Flask القدرة على معالجة قوالب HTML، مما يسمح للمطورين بإنشاء تطبيقات ويب ديناميكية.

فيما يلي بعض الميزات الرئيسية لـ Flask التي تجعله إطارًا عمل رائعًا للعمل معه:

• يحتوي على منهج API بسيط لإنشاء المسارات الويب ومعالجة الطلبات.
• محرك Jinja للقوالب يوفر الدعم لقوالب HTML، مما يسمح للمطورين بإنشاء صفحات الويب بسهولة.
• إنه قابل للتمديد بشكل كبير، بفضل دعمه للإضافات الثالثة، لذا يمكن للمطور تثبيت الإضافات حسب احتياجات مشروعه.
• يأتي معه خادم تطوير يجعل من السهل اختبار وتصحيح التطبيقات.

الإجماليّا، يوفر Flask إطارًا قويًا ومرنًا ولكنه بسيط لبناء تطبيقات الويب. إنه خيار جيد لكل من المبتدئين والمطورين الخبراء في مجال تطوير الويب، وهو واحد من أكثر إطارات الويب شهرة في بيئة تطوير Python.

المزايا الخاصة بـ Flask

دعونا الآن نلقي نظرة مفصلة على بعض مزايا استخدام Flask في التطوير.

البساطة. تركز فلسفة تصميم Flask على البساطة، مما يجعلها سهلة الفهم والاستخدام للمطورين على أي مستوى. هذا يعني أيضًا أن لدى المطورين منحنى تعلم أقل بكثير، حيث يحتاجون فقط لتعلم بعض المفاهيم وواجهات برمجة التطبيقات لبدء بناء تطبيقات الويب.

المرونة. طبيعة الميكرو لـ Flask – التي توفر فقط الميزات الأساسية لإطار الويب – تمنح المطورين القوة لتخصيصها وتمديدها لتناسب متطلباتهم باستخدام إضافات Flask أو مكتبات ثالثة.

الوثائق. وثائق Flask شاملة جدًا، مع تغطية جيدة للموضوعات من الأساسية إلى المتقدمة، مما يجعل من السهل جدًا على المطورين تعلم كيفية استخدام الإطار.

توافق. يتوافق Flask مع مجموعة واسعة من إصدارات Python، مما يجعل من السهل استخدامه مع قواعد كود Python القائمة. كما يتمتع بدعم لخمسة عدة خوادم الويب، مما يجعل من السهل نشره على مجموعة متنوعة من منصات الاستضافة.

التطوير السريع. بساطة ومرونة Flask تقلل من الكود الإضافي اللازم لإعداد التطبيق، مما يسمح للمطورين بالبدء بسرور.

في الإنترنت، يتم استخدام Flask بطرق مثيرة للاهتمام كثيرة. أمثلة قليلة ملحوظة:

• PgAdmin. واجهة إدارة Postgres تعمل على مثيل Flask، مما يمنح المطورين واجهة حيث يمكنهم إدارة قواعد بيانات Postgres الخاصة بهم.
• Twilio. هذه منصة تواصل تستخدم Flask في عدة من APIsها.
• Pinterest. تطبيق مشاركة الصور هذا يستخدم Flask في مكونات تطوير الويب، مما يسمح لفريقه بإنشاء بعض الميزات والتكاملات المخصصة بسهولة.

متى ينبغي استخدام Flask

بساطة وسهولة استخدام Flask تجعله خيارًا ممتازًا لمجموعة واسعة من مشاريع الويب:

• النماذج النمطية. سهولة ومرونته تجعله خيارًا ممتازًا لإنشاء نماذج نمطية بسرور، مما يسمح للمطورين ببناء واختبار ميزات جديدة بسرعة.
• إنشاء APIs RESTful. بساطته الخاصة ب API تجعل من السهل إنشاء والتعامل مع طلبات HTTP.
• تطبيقات التجارة الإلكترونية. يعمل بشكل جيد في بناء الأسواق ومنصات التجارة الإلكترونية على الإنترنت.
• التمويل. إنه مفيد لبناء تطبيقات مالية، مع إدارة الحسابات، معالجة المعاملات، وتتبع الاستثمارات.
• الذكاء الاصطناعي. يوفر طريقة مفيدة وبسيطة لبناء ونشر نماذج تدريب الذكاء الاصطناعي.

عندما لا يكون من المناسب استخدام Flask

على الرغم من أن 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

على ويندوز، استخدم هذا الأمر:

. myenv\Scripts\activate

بمجرد تنشيط بيئتنا الافتراضية، ستظهر اسم البيئة الافتراضية على محرر الأوامر، تشبه الإخراج التالي:

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

في بيئتنا الافتراضية المنشطة، يمكننا المضي قدمًا وتثبيت Flask، باستخدام الأمر التالي:

pip install Flask

بمجرد اكتمال تثبيت Flask، دعونا ننشئ تطبيقًا أدنى. سننشئ وحدة تستوعب تطبيق Flask الخاص بنا. من أجل البساطة، دعونا نسميها hello.py. على لينكس أو ماك أو اس يمكننا استخدام الأمر التالي لإنشاء الملف في دليلنا 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() ستحدث عندما يزور شخص ما الطريقة الجذرية لتطبيقنا بمجرد تشغيله.

هناك طرق مختلفة يمكننا من خلالها تشغيل التطبيق، لذا دعونا نلقي نظرة على بعضها. الطريقة الأولى هي تزويد الأمر 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، هذا الربط يعرف باسم التوجيه – عملية ربط أو تعيين URLs إلى وظائف العرض. ربط URLs بوظائف العرض يسمح للتطبيق بمعالجة انواع مختلفة من الطلبات، مثل GET، POST، PUT، DELETE، وأكثر من ذلك. كما يمكّن التطبيق من معالجة طلبات متعددة من عملاء مختلفين.

لإعداد الطرق في Flask، نستخدم route() ملحق التنكر. ملحق التنكر يربط 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 URL، يتصل Flask بوظيفة about()، التي تعيد السلسلة “هذه هي صفحة الحوار”.

حتى الآن، على الرغم من أن هذه الأمثلة تعيد صفحات مختلفة، إلا أنها تستخدم كلها فقط طلب GET HTTP. من أجل التمكن من معالجة أي طلب محدد، يمكننا تحديد طريقة HTTP كوسيطة اختيارية لملحق route() التنكر.

دعونا نرى مثالاً على طلب 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 بالقدرة على التعامل مع أنواع مختلفة من الطلبات ويسمح لتطبيقنا بالتعامل مع البيانات والتصرف بها بشكل مختلف، حسب الرابط الذي يزوره المستخدم.

أشكال 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>

القالب المذكور أعلاه سيعرض حقول البريد الإلكتروني وكلمة المرور، جنبا إلى جنب مع علاماتهما، وزر إرسال مع النص “تسجيل الدخول”. تم تضمين حقل form.csrf_token لمنع هجوم التزوير بطلبات المواقع المتعددة (CSRF). تستخدم حلقات {% for %} لعرض أي أخطاء التحقق من الشروط التي قد تحدث.

باستخدام أشكال Flask، لدينا طريقة قوية للتعامل مع مدخلات المستخدم، وسنتمكن من تحقق من البيانات التي يدخلونها.

ملحقات 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، إطار عمل ويب خفيف الوزن ومرن لبايثون. ناقشنا مزايا استخدام Flask في تطوير الويب، بما في ذلك بساطته، مرونته، وسهولة استخدامه. كما تغطينا كيفية إعداد بيئة التطوير، إنشاء الطرق، استخدام القوالب، التعامل مع النماذج، واستخدام الامتدادات مثل Flask-SQLAlchemy.

لتلخيص، Flask هو خيار رائع لبناء تطبيقات الويب بأي حجم، من المشاريع الشخصية الصغيرة إلى التطبيقات التجارية الكبيرة. إنه سهل في التعلم والاستخدام، ولكنه يوفر أيضًا ميزات متقدمة عبر العديد من امتداداته.

إذا كنت مهتمًا بتعلم المزيد عن Flask، هنا بعض الموارد الإضافية:

• وثائق Flask
• برنامج تعليمي كبير في Flask، من قبل ميغيل غرينبرغ
• تطوير الويب باستخدام Flask، من قبل ميغيل غرينبرغ
• A simple Flask app tutorial
• برامج تعليمية Flask الحقيقية في Python

إذا كنت ترغب في معرفة المزيد عن Django و Flask وأفضل الاستخدامات لهما، تحقق من تطوير الويب باستخدام Python مع Django و Flask.

الأسئلة الشائعة حول Flask، إطار Python