به عنوان یک مهندس داده، بارها شده که بخواهیم کار خود را به اشتراک بگذاریم؛ تا هرکس دیگری در شرکت بتواند از فرآیندها یا مدل هایی که ما ایجاد کرده ایم استفاده کند. این زمانی است که API ها وارد عمل می شوند. ما در آموزش ساخت API با پایتون، قصد داریم ببینیم API چیست و چگونه می توانیم آن را در پایتون ایجاد کنیم.

 

پیش نیازها

برای تکمیل این آموزش می توانید از سیستم عامل های Windows، macOS یا Linux استفاده کنید؛ همچنین از پایتون 3، چارچوب وب Flask و یک مرورگر وب برای این آموزش مورد نیاز است.

تنها دانشی که به صراحت برای این درس در نظر گرفته شده است، توانایی استفاده از یک ویرایشگر متن، مانند BBEdit در macOS یا ++Notepad در ویندوز است. با این حال، دانش خط فرمان پایتون و مفاهیم وب مانند HTTP، این آموزش را آسان تر می کند. اگر در پایتون تازه کار هستید، سعی کنید آموزش ببینید و تمرین داشته باشید تا با مفاهیم اساسی در برنامه نویسی پایتون آشنا شوید.

 

نصب Python و Flask

ابتدا پایتون را دانلود کنید، Download Python 3.x.x را انتخاب کنید و سپس برای تأیید اینکه پایتون با موفقیت نصب شده است، ابتدا خط فرمان را باز کنید. در macOS، روی نماد spotlight در گوشه سمت راست بالای دسکتاپ خود (ذره بین) کلیک کنید و terminal را تایپ کنید. ترمینال باید اولین برنامه کاربردی باشد که ظاهر می شود. در ویندوز، روی نماد منوی Start کلیک کنید و cmd را در کادر جستجو تایپ کنید، سپس Enter را بزنید. هنگامی که خط فرمان شما باز شد، این دستورات را وارد کنید:

python --version
pip --version

 

اگر خروجی این دستورات شامل شماره نسخه باشد، پایتون نصب شده و از خط فرمان در دسترس است و می توانید به مرحله بعد بروید.

در مرحله بعد، باید Flask را نصب کنید. در خط فرمان تایپ کنید:

pip install flask

باید برخی از خروجی ها را ببینید که به اعلانی مبنی بر اینکه Flask با موفقیت نصب شده است ختم می شود.

به عنوان جایگزینی برای دستورالعمل های نصب بالا، می توانید نسخه Python 3 Anaconda را نصب کنید. Anaconda همراه با Flask است، بنابراین اگر این مسیر را دنبال کنید، نیازی به نصب Flask ندارید.

 

مبانی API

در برنامه نویسی، اصطلاح API، مخفف Application Programming Interface، به بخشی از یک برنامه کامپیوتری اشاره دارد که برای استفاده یا دستکاری توسط برنامه دیگری طراحی شده است، برخلاف رابطی که برای استفاده یا دستکاری انسان طراحی شده است. برنامه های رایانه ای اغلب نیاز به برقراری ارتباط بین خود یا با سیستم عامل اصلی دارند.

 

آموزش مرتبط : آموزش حلقه for در پایتون

 

یک API به دو سیستم کامپیوتری اجازه می دهد تا با یکدیگر تعامل داشته باشند. به عنوان مثال، اگر یک اتوماسیون ایجاد کنیم که یک گزارش تولید می کند و آن را از طریق ایمیل ارسال می کند، ارسال آن ایمیل به صورت دستی انجام نمی شود، خود اسکریپت این کار را انجام می دهد. برای انجام این کار، پایتون باید از جی‌میل بخواهد که آن ایمیل را همراه گزارش، به افراد خاصی بفرستد. در این مورد API Gmail مدنظر است.

یک وب API اجازه می دهد تا اطلاعات یا عملکرد توسط برنامه های دیگر از طریق اینترنت دستکاری شود. به عنوان مثال، با وب API توییتر، می‌توانید برنامه ای به زبانی مانند پایتون یا جاوا اسکریپت بنویسید که می تواند کارهایی مانند انتخاب توییت ها یا جمع‌آوری ابرداده ها را انجام دهد.

ایجاد یک API نیاز است اگر:

1. مجموعه داده‌های شما بزرگ است، و دانلود از طریق FTP سخت یا پرمخاطب است.
2. کاربران شما باید به داده های شما در زمان واقعی دسترسی داشته باشند، مانند نمایش در وب سایت دیگر یا به عنوان بخشی از یک برنامه.
3. داده های شما مرتباً تغییر می کند یا به روز می شود.
4. کاربران شما فقط نیاز به دسترسی به بخشی از داده ها در هر زمان دارند.
5. کاربران شما باید اقداماتی غیر از بازیابی داده ها انجام دهند، مانند مشارکت، به روزرسانی یا حذف داده ها.

اگر داده هایی دارید که می خواهید با جهان به اشتراک بگذارید، یک API یکی از راه هایی است که می توانید آن ها را در اختیار دیگران قرار دهید. با این حال، API ها همیشه بهترین راه برای اشتراک گذاری داده ها با کاربران نیستند. اگر اندازه داده هایی که ارائه می دهید نسبتاً کوچک است، می توانید به جای آن یک «داده خالی» در قالب یک فایل JSON، XML، CSV یا SQLite قابل دانلود ارائه دهید. بسته به منابع شما، این رویکرد می تواند تا حجم دانلود چند گیگا بایت قابل اجرا باشد.

به یاد داشته باشید که می توانید هم یک داده dump و هم یک API ارائه دهید، و کاربران می توانند روشی را پیدا کنند تا با موارد استفاده آن ها مطابقت داشته باشد. برای مثال Open Library، هم یک داده dump و هم یک API ارائه می‌کند، که هر کدام موارد استفاده متفاوتی را برای کاربران مختلف ارائه می کنند.

 

بخش های اصلی یک API چیست؟

1. “HTTP transfer protocol”راه اصلی ارتباط اطلاعات در وب است. روش های مختلفی وجود دارد که هر یک از آن ها برای مسائل مختلف استفاده می شود:

(GET) این روش امکان به دست آوردن اطلاعات از پایگاه داده یا از یک فرآیند را می دهد.

(POST) به شما امکان می دهد اطلاعات را ارسال کنید، مثلاً برای افزودن اطلاعات به پایگاه داده یا برای انتقال ورودی یک مدل یادگیری.

(PUT) اطلاعات را به روز می کند. معمولاً برای مدیریت اطلاعات در پایگاه داده استفاده می شود.

(DELETE) از این روش برای حذف اطلاعات از پایگاه داده استفاده می شود.

2. “URL”  آدرسی است که می توانیم API خود را در آن پیدا کنیم. اساسا این URL از سه بخش تشکیل شده است:

پروتکل(Protocol): مانند هر آدرسی، که می تواند :http// یا :https// باشد.

دامنه(Domain): آدرسی، که از پروتکل به انتهای com. ، یا هر انتهایی که url دارد. برای مثال در وب سایت ما دامنه academyit.net است.

نقطه پایانی(Endpoint): مانند یک وب سایت دارای چندین صفحه، یک API می تواند چندین نقطه را شامل شود و هر کدام کارهای متفاوتی انجام می دهند. هنگامی که API خود را در پایتون ایجاد می کنیم، نقاط پایانی را نشان می دهیم، بنابراین باید مطمئن شویم که هر endpoint  نماینده کاری است که API پشت آن انجام می دهد.

خوب، حالا که می دانیم API چیست و قسمت های اصلی آن چیست، بیایید ببینیم چگونه می توانیم یک API در پایتون ایجاد کنیم.

 

نحوه ایجاد API در پایتون

راه های مختلفی برای ایجاد یک API در پایتون وجود دارد که پرکاربردترین آن ها FastAPI و Flask هستند. بنابراین، نحوه کار هر دو را توضیح خواهم داد تا بتوانید از راهی که بیشتر دوست دارید استفاده کنید. بیایید با FastAPI شروع کنیم.

 

نحوه ایجاد API در پایتون با FastAPI

FastAPI راهی برای ایجاد API در پایتون است که در پایان سال 2018 منتشر شد. این روش بسیار سریع است، اگرچه فقط با Python +3.6 قابل استفاده است (به نظر من مشکل خاصی نیست، اما مهم است).
برای استفاده از آن، باید دو کتابخانه را نصب کنید: fastapi و uvicorn.

pip install fastapi
pip install uvicorn

 

اکنون که کتابخانه ها را نصب کرده ایم، به سادگی باید یک فایل در پایتون ایجاد کنیم که در آن API خود را تعریف کنیم. در این فایل، ما باید یک اپلیکیشن ایجاد کنیم که در آن API ها را به همراه نقاط پایانی، پارامترها و غیره در آن قرار دهیم.

هنگامی که برنامه را داریم، می توانیم اطلاعات مورد نیاز API را در آنجا تعریف کنیم: مانند نقطه پایانی، روش HTTP، آرگومان های ورودی و آنچه API پشت آن انجام خواهد داد.

from fastapi import FastAPI
app = FastAPI()
@app.get("/my-first-api")
def hello():
return {"Hello world!"}

 

با این کار، یک API بسیار ساده ایجاد می کنیم که به سادگی "Hello world!" را برمی گرداند. همانطور که خواهید دید، در چند خط تعریف کردیم: متد (get)، نقطه پایانی (“/”) و تابعی که این API باید اجرا کند.
حتی می توانیم آرگومان هایی را به API خود منتقل کنیم تا در عملکرد خود، از آن استفاده کند. هر زمان که آرگومان را به تابع خود منتقل می کنیم، باید نوع داده ای را که می خواهیم باشد (عدد، متن و غیره) مشخص کنیم.

FastAPI بررسی می کند تا نوع داده‌ای که در تماس به آن ارسال کرده ایم همان چیزی باشد که نشان دادیم. این بررسی برای اطمینان از اینکه API ما به درستی کار می کند ضروری است، لازم به ذکر است که روش ایجاد API (مانند Flask) شامل این کار نمی شود.

بیایید با یک مثال توضیح دهیم:

from fastapi import FastAPI
app =from fastapi import FastAPI
app = FastAPI()@app.get("/my-first-api")
def hello(name: str):
return {'Hello ' + name + '!'} 

 

حالا وقتی درخواستی را به این API می دهیم، باید پارامتر نام را به آن پاس دهیم تا کار کند. یعنی اگر قبلا کافی بود به http://127.0.0.1:8000/my-first-api برویم، حالا باید پارامتر نام را پاس دهیم. بنابراین درخواست به صورت زیر خواهد بود:

http://127.0.0.1:8000/my-first-api?name=Alireza 

.
همانطور که آرگومان نام را وارد کرده ایم، اگر در درخواست گنجانده نشود، کار نخواهد کرد. با این حال، ممکن است بخواهیم آرگومان های اختیاری را ارسال کنیم.

برای این کار، باید آرگومان را به صورت None نشان دهیم و FastAPI آن را به درستی تفسیر خواهد کرد. مثال: ما یک API ایجاد می کنیم که می توانید نام متغیر را به آن منتقل کنید یا نه. اگر آن را پاس دهید، “!Hello {name}” و اگر نه، خروجی ما به صورت  “!Hello” خواهد بود.

from fastapi import FastAPI
app = FastAPI()
@app.get("/my-first-api")
def hello(name = None):
if name is None:
text = 'Hello!'
else:
text = 'Hello ' + name + '!'
return text

 

در این صورت، اگر به http://127.0.0.1:8000/my-first-api برویم، API به درستی اجرا می شود و «!Hello» را بر می گرداند، در حالی که اگر پارامتر را پاس دهیم، مثلاً http: //127.0.0.1:8000/my-first-api?name=Alireza، از آن استفاده خواهد کرد و به درستی به کار خود ادامه می دهد و !Hello Alireza.

در اکثر مواقع یک API متن (داده و غیره) را برمی‌گرداند، اگرچه گاهی اوقات می تواند انواع دیگری از داده‌ها، مانند DataFrame یا یک تصویر را برگرداند.

وقتی صحبت از اشیاء "عادی" می شود، مانند DataFrame، FastAPI آن را مستقیماً به یک فایل JSON تبدیل می کند. مثال:

from fastapi import FastAPI
app = FastAPI()
@app.get("/get-iris")
def get_iris():
import pandas as pd
url ='https://gist.githubusercontent.com/curran/a08a1080b88344b0c8a7/raw/0e7a9b0a5d22642a06d3d5b9bcbad9890c8ee534/iris.csv'
iris = pd.read_csv(url)
return iris

 

اگر درخواستی به نقطه پایانی ارائه دهیم، پاسخ زیر را دریافت خواهیم کرد:

resp.text
'{"sepal_length":{"0":5.1,"1":4.9,"2":4.7,"3":4.6,"4":5.0,"5":5.4,"6":4.6,"7":5.0,"8":4.4,"9":4.9,"10":5.4,"11":4.8,"12":4.8,"13":4.3,"14":5.8,"15":5.7,"16":5.4,"17":5.1,"18":5.7,"19":5.1,"20":5.4,"21":5.1,"22":4.6,"23":5.1,"24":4.8,"25":5.0,"26":5.0,"27":5.2,"28":5.2,"29":4.7,"30":4.8,"31":5.4,"32":5.2,"33":5.5,"34":4.9,"35":5.0,"36":5.5,"37":4.9,"38":4.4,"39":5.1,"40":5.0,"41":4.5,"42":4.4,"43":5.0,"44":5.1,"45":4.8,"46":5.1,"47":4.6,"48":5.3,"49":5.0,"50":7.0,...

 

همانطور که می بینید Fast API به این شکل  Data Frameرا مستقیماً به یک شی JSON تبدیل می کند. با این حال، ممکن است سوالی مطرح شود که تصاویر یا ویدیوها چطور؟

FastAPI مبتنی بر starlette است، بنابراین برای پاسخگویی با تصاویر یا نمادها، می توانیم از StreamingResponse و FileResponse استفاده کنیم. در هر صورت نیاز به نصب aiofile داریم.

بنابراین، اگر بخواهیم تصویری را در API خود نمایش دهیم، برنامه FastAPI ما به شکل زیر خواهد بود:

@app.get("/plot-iris")
def plot_iris():
import pandas as pd
import matplotlib.pyplot as plt
url ='https://gist.githubusercontent.com/curran/a08a1080b88344b0c8a7/raw/0e7a9b0a5d22642a06d3d5b9bcbad9890c8ee534/iris.csv'
iris = pd.read_csv(url)
plt.scatter(iris['sepal_length'], iris['sepal_width'])
plt.savefig('iris.png')
file = open('iris.png', mode="rb")
return StreamingResponse(file, media_type="image/png")

 

همانطور که می بینیم، ایجاد یک API در پایتون با FastAPI بسیار ساده و بسیار متنوع است. اما چگونه می توانیم بررسی کنیم که API ما به درستی کار می کند؟

همانطور که در ابتدای این بخش گفتیم، برای ایجاد یک API در FastAPI باید کد خود را در یک فایل پایتون، ترجیحا main.py قرار دهیم. همچنین، ما باید Uvicorn را نصب کنیم. با در نظر گرفتن این موضوع، می توانیم API خود را به روشی بسیار ساده و با کد زیر اجرا کنیم:

uvicorn main:app --reload

 

این کد برنامه ما را اجرا می کند و ما می توانیم به API خود هم در سطح مرورگر و هم با برقراری تماس از رایانه خود دسترسی پیدا کنیم. API هنوز در جایی آپلود نشده است، بنابراین از لوکال هاست قابل دسترسی خواهد بود. شما می توانید هم در http://127.0.0.1/ و هم در http://localhost/ به لوکال هاست دسترسی داشته باشید، اگرچه باید این کار را در همان پورتی انجام دهید که API را اجرا می کند. برای فهمیدن، به نظر من، ساده ترین کار استفاده از لینکی است که uvicorn هنگام اجرای API به شما می دهد.

به عنوان مثال، ببینیم چگونه یک API درخواست کنیم که شامل تمام نقاط پایانی باشد که قبلاً توضیح داده ایم.

import requests
from PIL import Image
import io
resp = requests.get('http://127.0.0.1:8000/plot-iris')
file = io.BytesIO(resp.content)
im = Image.open(file)
im.show()

 

همانطور که می بینیم، API تصویر را به درستی به ما بر می گرداند. بیایید اولین نقطه پایانی را که ایجاد کرده ایم امتحان کنیم:

resp = requests.get('http://127.0.0.1:8000/my-first-api?name=Alireza')
resp.text

خروجی:

'"!Hello Alireza"'

 

علاوه بر این، FastAPI خود مستندات را به صورت swagger ایجاد می کند، که ما می توانیم از مسیر، Docs به آنها دسترسی داشته باشیم. همانطور که API در معرض نمایش است، می توانم به http://127.0.0.1:8000/docs دسترسی داشته باشیم.

علاوه بر این، روش دیگری نیز برای مستند سازی API وجود دارد، با OpenAPI، نیز نقطه پایانی /redoc قابل دسترسی است.

همانطور که می بینید، ایجاد یک API با FastAPI بسیار ساده و سریع است. با این حال، FastAPI تنها راه برای ایجاد یک API در پایتون نیست. راه دیگر برای انجام آن استفاده از Flask است. بیایید ببینیم چگونه کار می کند!

 

نحوه ایجاد یک API در پایتون با Flask

اول از همه، برای ایجاد یک API در پایتون با استفاده از Flask، باید بسته های flask و flask-restful را نصب کنیم. هنگامی که کتابخانه ها را نصب کردیم، باید سرور خود را ایجاد کنیم، همانطور که برای FastAPI انجام دادیم. با دستور زیر می توانیم این کار را انجام دهیم:

from flask import Flask
app = Flask()  

 

علاوه بر این، ما باید نشان دهیم که سرور به همراه پورتی که باید راه اندازی شود، راه اندازی می شود. برای انجام این کار، در انتهای برنامه ما باید کد زیر را وارد کنیم:

if __name__ == '__main__':
app.run(debug=True, port=8000)

 

هنگامی که سرور خود را ایجاد کردیم و مشخص کردیم که در کدام پورت باید اجرا شود، می توانیم شروع به ایجاد API های خود کنیم. برای ایجاد یک API در پایتون با Flask، باید این موارد را نشان دهیم: نقطه پایانی، متد و تابعی که باید در آن نقطه پایانی اجرا شود. بیایید مثالی با یک API ببینیم که به سادگی متن "!Hello world" را بر می گرداند.

from flask import Flask, jsonify, request,send_file
app = Flask()
@app.route('/my-first-api', method = ['GET'])
def hello():
return "Hello world!"

 

همانطور که می بینید، در این حالت زمانی که مسیر سرور را با app.route@ تعریف می کنیم، هم نقطه پایانی و هم متد را تعریف می کنیم. ما متد GET را تعریف کردیم؛ اگرچه لازم نیست، زیرا به طور پیش فرض، Flask از متد GET استفاده می کند. بنابراین تعریف متد فقط در صورتی الزامی است که بخواهیم از متدی غیر از GET استفاده کنیم، یعنی از POST، PUT یا DELETE استفاده کنیم.

 

نحوه ارسال پارامترها به API در Flask

بسیاری از اوقات، API های ما به پارامترهایی نیاز دارند. یک مثال واضح زمانی است که ما یک مدل را تولید می کنیم: هر ورودی مدل باید یک پارامتر از API ما باشد.

از این نظر، می توانیم هنگام درخواست، آرگومان هایی را به API خود در Flask ارسال کنیم. در این صورت، برای اینکه بتوانیم از آن ها در تابع استفاده کنیم، ابتدا باید آن ها را از درخواست استخراج کنیم که این کار را با request.args.get انجام خواهیم داد. این کار تا حدودی با نحوه انجام آن در FastAPI متفاوت است و به نظر می رسد در Flask دست و پا گیرتر از FastApi است.

به عنوان مثال، بیایید ببینیم که چگونه یک API ایجاد کنیم که پارامتر نام را دریافت کند و "!Hello {name}" را چاپ کند.

@app.route('/my-first-api', methods = ['GET'])
def hello():
name = request.args.get('name')
if name is None:
text = 'Hello!'
else:
text = 'Hello ' + name + '!'
return text

در این مورد، API ما با دو گزینه، پارامتر نام را از URL درخواست می کند:

اگر پارامتر name پاس نشده باشد، به عنوان مثال: http://127.0.0.1:8000/my-first-api، پارامتر نام None خواهد بود، بنابراین API Hello! را بر می گرداند.

اگر پارامتر name پاس شده باشد، به عنوان مثال http://127.0.0.1:8000/my-first-api?name=Alireza، API از پارامتری برای ایجاد پاسخ استفاده می کند که در این حالت Hello Alireza! خواهد بود.

نکته مهم: Flask پارامترهای درخواست را ارزیابی نمی کند، بنابراین باید خودمان ارزیابی را انجام دهیم، در غیر این صورت در تابع استفاده می شود. برای مثال، اگر URL را درخواست کنیم: http://127.0.0.1:8000/my-first-api?name=2، API Hello 2 را بر می گرداند، زیرا تأیید نکرده است که مقدار پارامتر باید یک رشته باشد و نه یک عدد یا هر نوع شیء دیگری.

همانطور که می بینیم، تا کنون رشته های متنی را بر گردانده ایم. با این حال، API ها معمولا داده ها را با فرمت JSON برمی گردانند. برای این کار باید از ماژول jsonify استفاده کنیم. بیایید نمونه ای از نحوه برگرداندن رشته قبلی را ببینیم، اما این بار در قالب JSON:

@app.route('/my-first-api', methods = ['GET'])
def hello():
name = request.args.get('name')
if name is None:
text = 'Hello!'
else:
text = 'Hello ' + name + '!'
return jsonify({"message": text})

 

به همین ترتیب، می توانیم نوع دیگری از شی مانند مجموعه داده را بر گردانیم. بیایید با یک مثال ببینیم که چگونه یک نقطه پایانی جدید ایجاد می کند و مجموعه داده را از طریق یک درخواست GET برمی گرداند:

@app.route("/get-iris")
def get_iris():
import pandas as pd
url ='https://gist.githubusercontent.com/curran/a08a1080b88344b0c8a7/raw/0e7a9b0a5d22642a06d3d5b9bcbad9890c8ee534/iris.csv'
iris = pd.read_csv(url)
return jsonify({
"message": "Iris Dataset",
"data": iris.to_dict()
})

 

برای ارسال یک DataFrame، ابتدا باید آن را به یک شی تبدیل کنیم که می تواند به JSON تبدیل شود، مانند دیکشنری. با این کار پاسخی مانند زیر خواهیم داشت:

resp.json()
{'data': {'petal_length': {'0': 1.4, '1': 1.4, '2': 1.3, '3': 1.5, '4': 1.4, '5': 1.7, '6': 1.4, '7': 1.5, '8': 1.4, '9': 1.5, '10': 1.5, '11': 1.6, '12': 1.4, '13': 1.1, '14': 1.2, '15': 1.5, '16': 1.3, '17': 1.4, '18': 1.7, '19': 1.5, '20': 1.7, '21': 1.5, '22': 1.0, '23': 1.7, '24': 1.9, '25': 1.6, '26': 1.6, '27': 1.5, '28': 1.4, '29': 1.6, '30': 1.6, '31': 1.5, '32': 1.5, '33': 1.4, '34': 1.5, '35': 1.2, '36': 1.3, '37': 1.5, '38': 1.3, '39': 1.5, '40': 1.3, '41': 1.3, '42': 1.3, '43': 1.6, '44': 1.9, '45': 1.4, '46': 1.6, '47': 1.4, '48': 1.5, '49': 1.4, '50': 4.7, ...

در نهایت، آیا می توانیم تصاویر را از طریق یک API در Python ساخته شده در Flask ارسال کنیم؟ در واقع، روش انجام آن بسیار شبیه FastAPI است، فقط در این صورت، باید محتوا را در خود Flask (یا هر دایرکتوری دیگری که هست) ذخیره کنیم و با استفاده از تابع send_file ارسال کنیم.

اکنون که می دانیم چگونه انواع مختلف محتوا را با یک API Python ایجاد شده با Flask ارسال کنیم، بیایید ببینیم چگونه بررسی کنیم که API ما درست کار می کند.

قبل از اجرای یک API Python ساخته شده در Flask، باید بررسی کنیم که آیا آن را در یک پورت در معرض نمایش قرار داده ایم. برای این کار باید کدی را که ذکر کرده ایم و در زیر قرار داده ایم وارد کنیم:

if __name__ == '__main__':
app.run(debug=True, port=8000)

 

بنابراین، برای اجرای برنامه فقط باید فایل پایتون خود را در جایی که API ایجاد کرده ایم اجرا کنیم:

python flask/main.py

 

همانطور که می بینید، API ما بر روی میزبان محلی ما، در پورتی که ما نشان داده ایم (پورت 8000) اجرا می شود.

بنابراین، برای آزمایش API، می توانیم به سادگی به مرورگر خود برویم و در نقاط پایانی مستقیماً درخواست هایی را از پایتون انجام دهیم:

resp.json()
{'message': 'Hello Alireza!'}

همانطور که می بینیم، API محتوا را به درستی بر می گرداند.

همچنین می توانیم اسناد Swagger و OpenApi را به API خود در Flask اضافه کنیم، اگرچه انجام این کار کمی خسته کننده تر از FastAPI است. 

 

نتیجه

همانطور که می بینید در آموزش ساخت API با پایتون، ایجاد API با هر دو روش FastApi و Flask بسیار ساده است، اگرچه تفاوت های خاصی با هم دارند:

Flask چارچوبی است که به شما امکان می دهد کل برنامه های وب را ایجاد کنید.

در FastAPI اعتبارسنجی انواع داده ها و همچنین کل فرآیند مستند سازی که انجام می دهیم، در مقایسه با Flask، بسیار سریع تر است.

بنابراین، توصیه من این است که اگر فقط می‌خواهید API ایجاد کنید، آن را در FastAPI انجام دهید، زیرا مطمئناً سریع تر خواهد بود. با این حال، اگر می خواهید یک رابط کاربری کامل (front and back) ایجاد کنید و API بخشی از اکوسیستم است، توصیه می کنم از Flask استفاده کنید، زیرا همه چیز تحت یک چهار چوب خواهد بود و برای شما بسیار راحت تر خواهد بود.