MENU
  1. ホーム
  2. Python
  3. PythonとFlaskで非同期処理を実装する方法を徹底解説

PythonとFlaskで非同期処理を実装する方法を徹底解説

Python

Pythonはシンプルで強力なプログラミング言語であり、多くのウェブアプリケーション開発で利用されています。その中でもFlaskは軽量なウェブフレームワークとして人気があります。この記事では、PythonとFlaskを用いて非同期処理を実装し、アプリケーションのパフォーマンスを向上させる方法を詳しく説明します。非同期処理の基本概念から具体的な実装手順、サンプルコード、応用例、最適化手法、エラーハンドリング、ベストプラクティスまでを包括的に解説します。

目次

非同期処理の基本概念

非同期処理は、プログラムが他のタスクを待たずに処理を進めることを可能にする手法です。これにより、ウェブアプリケーションのレスポンス速度が向上し、ユーザーエクスペリエンスが向上します。同期処理ではタスクが一つずつ順番に実行されますが、非同期処理では複数のタスクが同時に進行するため、処理待ち時間が短縮されます。以下のポイントが非同期処理の利点です。

利点

  • パフォーマンス向上：複数のタスクを同時に実行できるため、全体的な処理時間が短縮されます。
  • リソースの効率的な使用：CPUやメモリなどのリソースを効率的に使用することができます。
  • ユーザーエクスペリエンスの向上：非同期処理により、ユーザーが待たされる時間が短くなり、アプリケーションの応答性が向上します。

基本的な考え方

  • イベントループ：非同期処理はイベントループを用いて管理されます。イベントループは、タスクが完了するまで待ち、完了したら次のタスクに進みます。
  • コルーチン：Pythonでは、非同期処理のためにコルーチンを使用します。コルーチンは関数のように振る舞い、awaitキーワードを用いて非同期タスクの完了を待ちます。
  • 非同期関数：async defで定義された関数は非同期関数となり、他の非同期関数内でawaitを用いて呼び出されます。

非同期処理の理解は、Flaskでの実装に進む前に重要です。次に、Flaskで非同期処理をどのように実装するかを詳しく見ていきます。

Flaskで非同期処理を実装する方法

Flaskアプリケーションに非同期処理を実装するためには、いくつかのライブラリと手法を使用します。ここでは、Flaskで非同期処理を導入するための具体的な手順と必要なライブラリを紹介します。

必要なライブラリ

  • Flask：軽量なウェブフレームワーク
  • Asyncio：Python標準ライブラリの一部で、非同期I/Oをサポート
  • Quart：Flaskに似た非同期ウェブフレームワーク
pip install flask quart asyncio

FlaskとQuartの設定

Flask自体は同期的なフレームワークですが、Quartを使用することでFlaskと同様のAPIで非同期処理を実現できます。まず、FlaskアプリケーションをQuartに移行します。

from quart import Quart, request

app = Quart(__name__)

@app.route('/')
async def index():
    return 'Hello, world!'

if __name__ == '__main__':
    app.run()

非同期関数の実装

次に、非同期関数を実装します。非同期関数はasync defで定義され、内部でawaitを用いることができます。

import asyncio

async def fetch_data():
    await asyncio.sleep(2)  # 例として2秒間の待機
    return "Data fetched!"

@app.route('/data')
async def data():
    result = await fetch_data()
    return result

実装手順

  1. Flaskアプリケーションの作成：通常のFlaskアプリケーションを作成します。
  2. Quartの導入：FlaskをQuartに置き換え、非同期処理をサポートします。
  3. 非同期関数の定義：async defを用いて非同期関数を定義します。
  4. awaitの使用：非同期関数内でawaitを用いて他の非同期タスクを待機します。

注意点

  • 非同期関数のみで使用：awaitは非同期関数内でのみ使用できます。
  • 互換性：既存のFlask拡張機能がQuartと互換性があるかを確認してください。

これで、Flaskアプリケーションに非同期処理を導入する準備が整いました。次に、具体的なサンプルコードを用いてさらに詳細を説明します。

Flaskの非同期処理のサンプルコード

ここでは、実際にFlask（Quart）アプリケーションで非同期処理を実装するサンプルコードを紹介します。このサンプルでは、非同期でデータを取得する機能を実装します。

基本的な非同期処理の実装

まずは、シンプルな非同期処理を実装したサンプルコードを見てみましょう。

from quart import Quart
import asyncio

app = Quart(__name__)

@app.route('/')
async def index():
    return 'Hello, world!'

async def fetch_data():
    await asyncio.sleep(2)  # 非同期で2秒間待機
    return "Data fetched!"

@app.route('/data')
async def data():
    result = await fetch_data()
    return result

if __name__ == '__main__':
    app.run()

このコードでは、fetch_data関数が非同期で2秒間の待機を行い、データを返すようになっています。この非同期関数を/dataエンドポイントで呼び出し、その結果を返しています。

複数の非同期タスクの実行

次に、複数の非同期タスクを並行して実行するサンプルを紹介します。

async def fetch_data_1():
    await asyncio.sleep(1)
    return "Data 1 fetched!"

async def fetch_data_2():
    await asyncio.sleep(1)
    return "Data 2 fetched!"

@app.route('/multiple-data')
async def multiple_data():
    task1 = fetch_data_1()
    task2 = fetch_data_2()
    results = await asyncio.gather(task1, task2)
    return {'data1': results[0], 'data2': results[1]}

このサンプルでは、fetch_data_1とfetch_data_2という2つの非同期関数を定義し、それらを/multiple-dataエンドポイントで並行して実行しています。asyncio.gatherを使用することで、複数の非同期タスクを同時に実行し、それぞれの結果を収集しています。

非同期APIリクエスト

次に、外部APIから非同期でデータを取得するサンプルを紹介します。この例では、httpxライブラリを使用して非同期HTTPリクエストを行います。

import httpx

async def fetch_external_data():
    async with httpx.AsyncClient() as client:
        response = await client.get('https://jsonplaceholder.typicode.com/todos/1')
        return response.json()

@app.route('/external-data')
async def external_data():
    data = await fetch_external_data()
    return data

このサンプルでは、httpx.AsyncClientを使用して非同期HTTPリクエストを実行し、外部APIからデータを取得しています。取得したデータは/external-dataエンドポイントで返されます。

まとめ

これらのサンプルコードを通じて、Flask（Quart）アプリケーションでの非同期処理の実装方法を学びました。非同期処理を活用することで、アプリケーションのパフォーマンスを大幅に向上させることができます。次に、非同期処理の応用例について詳しく見ていきましょう。

非同期処理の応用例

非同期処理は、さまざまなアプリケーションで幅広く応用されています。ここでは、いくつかの実際のアプリケーションでの非同期処理の活用例を紹介します。

チャットアプリケーション

チャットアプリケーションでは、メッセージの送受信がリアルタイムで行われるため、非同期処理が非常に重要です。非同期処理を導入することで、サーバーは複数のメッセージを同時に処理し、ユーザーに迅速に応答することができます。

from quart import Quart, websocket

app = Quart(__name__)

@app.websocket('/ws')
async def ws():
    while True:
        message = await websocket.receive()
        await websocket.send(f"Message received: {message}")

if __name__ == '__main__':
    app.run()

この例では、WebSocketを使用してリアルタイムチャット機能を実装しています。サーバーは非同期でメッセージを受信し、即座に応答を返します。

リアルタイムデータ処理

金融市場やIoTデバイスなど、リアルタイムで大量のデータを処理する必要があるアプリケーションでは、非同期処理が不可欠です。以下の例では、リアルタイムで株価データを取得し、表示します。

import httpx
from quart import Quart, jsonify

app = Quart(__name__)

async def fetch_stock_data(symbol):
    async with httpx.AsyncClient() as client:
        response = await client.get(f'https://api.example.com/stocks/{symbol}')
        return response.json()

@app.route('/stock/<symbol>')
async def stock(symbol):
    data = await fetch_stock_data(symbol)
    return jsonify(data)

if __name__ == '__main__':
    app.run()

この例では、非同期HTTPリクエストを使用してリアルタイムの株価データを取得し、クライアントに返しています。

バックグラウンドタスクの実行

バックグラウンドタスク（例：メール送信、データベースのバックアップなど）を非同期に実行することで、ユーザーの操作を妨げることなく処理を行うことができます。

import asyncio
from quart import Quart, request

app = Quart(__name__)

async def send_email(to, subject, body):
    await asyncio.sleep(3)  # 実際のメール送信処理
    print(f"Email sent to {to}")

@app.route('/send-email', methods=['POST'])
async def handle_send_email():
    data = await request.json
    asyncio.create_task(send_email(data['to'], data['subject'], data['body']))
    return {"message": "Email is being sent"}, 202

if __name__ == '__main__':
    app.run()

この例では、メール送信を非同期タスクとしてバックグラウンドで実行し、即座に応答を返しています。

非同期バッチ処理

大量のデータを一括で処理するバッチ処理も、非同期処理を利用することで効率化できます。

async def process_batch(batch):
    await asyncio.sleep(2)  # バッチ処理の模擬
    print(f"Batch processed: {batch}")

@app.route('/process-batch', methods=['POST'])
async def handle_process_batch():
    data = await request.json
    tasks = [process_batch(batch) for batch in data['batches']]
    await asyncio.gather(*tasks)
    return {"message": "Batches are being processed"}, 202

if __name__ == '__main__':
    app.run()

この例では、複数のバッチを同時に処理することで、全体の処理時間を短縮しています。

まとめ

非同期処理は、チャットアプリケーション、リアルタイムデータ処理、バックグラウンドタスクの実行、バッチ処理など、さまざまな場面で有効に活用されています。次に、非同期処理によるパフォーマンス向上のための最適化手法について詳しく見ていきましょう。

パフォーマンス向上のための最適化手法

非同期処理を導入することで、アプリケーションのパフォーマンスを大幅に向上させることができます。ここでは、非同期処理を活用してパフォーマンスを最適化する具体的な手法を紹介します。

イベントループの効果的な利用

イベントループは非同期処理の中心となるメカニズムです。効果的に利用するためには、次の点に注意します。

  • タスクの適切な分割：大きなタスクを小さなタスクに分割し、イベントループが効率的に処理できるようにします。
  • 非同期I/Oの活用：I/O操作（ファイルアクセス、ネットワーク通信など）は非同期で行い、他の処理をブロックしないようにします。

非同期キューの導入

タスクを非同期キューに追加し、バックグラウンドで処理することで、メインスレッドの負荷を軽減できます。以下は、非同期キューの例です。

import asyncio
from quart import Quart, request

app = Quart(__name__)
task_queue = asyncio.Queue()

async def worker():
    while True:
        task = await task_queue.get()
        try:
            await task()
        finally:
            task_queue.task_done()

@app.before_serving
async def startup():
    app.add_background_task(worker)

@app.route('/enqueue-task', methods=['POST'])
async def enqueue_task():
    data = await request.json
    await task_queue.put(lambda: process_task(data))
    return {"message": "Task enqueued"}, 202

async def process_task(data):
    await asyncio.sleep(2)  # タスクの処理例
    print(f"Task processed: {data}")

if __name__ == '__main__':
    app.run()

非同期データベース操作

データベース操作は通常、I/O操作を含むため、非同期で実行することでアプリケーションの応答性を向上させることができます。以下は、非同期データベース操作の例です。

import asyncpg

async def fetch_user(user_id):
    conn = await asyncpg.connect('postgresql://user:password@localhost/dbname')
    try:
        result = await conn.fetchrow('SELECT * FROM users WHERE id=$1', user_id)
        return result
    finally:
        await conn.close()

@app.route('/user/<int:user_id>')
async def get_user(user_id):
    user = await fetch_user(user_id)
    return user

キャッシュの活用

頻繁にアクセスされるデータをキャッシュすることで、データベースや外部APIへのアクセス回数を減らし、パフォーマンスを向上させることができます。

import aiomcache

cache = aiomcache.Client("127.0.0.1", 11211)

async def get_user(user_id):
    cached_user = await cache.get(f"user:{user_id}")
    if cached_user:
        return cached_user
    user = await fetch_user_from_db(user_id)
    await cache.set(f"user:{user_id}", user, exptime=60)
    return user

@app.route('/user/<int:user_id>')
async def user(user_id):
    user = await get_user(user_id)
    return user

非同期タスクの並列実行

複数の非同期タスクを並列に実行することで、処理時間を短縮できます。asyncio.gatherやasyncio.waitを活用します。

async def process_data(data):
    tasks = [asyncio.create_task(process_item(item)) for item in data]
    await asyncio.gather(*tasks)

@app.route('/process-data', methods=['POST'])
async def handle_process_data():
    data = await request.json
    await process_data(data['items'])
    return {"message": "Data processed"}, 202

まとめ

非同期処理を効果的に活用することで、アプリケーションのパフォーマンスを大幅に向上させることができます。イベントループの効果的な利用、非同期キューの導入、非同期データベース操作、キャッシュの活用、非同期タスクの並列実行など、様々な手法を組み合わせて最適化を図りましょう。次に、非同期処理におけるエラーハンドリングについて詳しく見ていきます。

非同期処理におけるエラーハンドリング

非同期処理を導入する際には、エラーハンドリングが重要な課題となります。非同期タスクが失敗した場合、適切にエラーハンドリングを行わないと、アプリケーション全体の信頼性が損なわれる可能性があります。ここでは、非同期処理におけるエラーハンドリングの方法とその注意点を解説します。

基本的なエラーハンドリング

非同期関数内でエラーハンドリングを行う基本的な方法は、try/exceptブロックを使用することです。

async def fetch_data():
    try:
        await asyncio.sleep(2)  # 非同期で2秒間待機
        raise ValueError("データの取得に失敗しました")
    except ValueError as e:
        print(f"エラーが発生しました: {e}")
        return None

@app.route('/data')
async def data():
    result = await fetch_data()
    if result is None:
        return {"error": "データの取得に失敗しました"}, 500
    return result

この例では、fetch_data関数内で発生する可能性のあるエラーをキャッチし、適切に処理しています。

非同期タスクのエラーハンドリング

非同期タスクをバックグラウンドで実行する場合、エラーが発生してもその場では捕捉されないことがあります。そのため、タスク完了時にエラーを確認する必要があります。

import asyncio

async def faulty_task():
    await asyncio.sleep(1)
    raise RuntimeError("タスクでエラーが発生しました")

async def monitor_task(task):
    try:
        await task
    except Exception as e:
        print(f"タスクでエラーが発生しました: {e}")

@app.route('/start-task')
async def start_task():
    task = asyncio.create_task(faulty_task())
    asyncio.create_task(monitor_task(task))
    return {"message": "タスクが開始されました"}, 202

この例では、monitor_task関数を使用してバックグラウンドタスクのエラーを監視し、エラーが発生した場合に適切に処理しています。

ロギングの導入

エラーが発生した際には、詳細な情報をログに記録することが重要です。Pythonのloggingモジュールを使用して、エラー情報をログに残すことができます。

import logging

logging.basicConfig(level=logging.INFO)

async def fetch_data():
    try:
        await asyncio.sleep(2)
        raise ValueError("データの取得に失敗しました")
    except ValueError as e:
        logging.error(f"エラーが発生しました: {e}")
        return None

@app.route('/data')
async def data():
    result = await fetch_data()
    if result is None:
        return {"error": "データの取得に失敗しました"}, 500
    return result

この例では、エラーが発生した際にlogging.errorを使用してエラー情報をログに記録しています。

リトライ機能の実装

一時的なエラーが発生した場合に、タスクを再試行するリトライ機能を実装することも有効です。

async def fetch_data_with_retry(retries=3):
    for attempt in range(retries):
        try:
            await asyncio.sleep(2)
            if attempt < 2:  # テストのために最初の2回は失敗させる
                raise ValueError("一時的なエラーが発生しました")
            return "Data fetched!"
        except ValueError as e:
            logging.warning(f"リトライ {attempt + 1}/{retries} 回目: {e}")
            await asyncio.sleep(1)
    logging.error("データの取得に失敗しました")
    return None

@app.route('/retry-data')
async def retry_data():
    result = await fetch_data_with_retry()
    if result is None:
        return {"error": "データの取得に失敗しました"}, 500
    return result

この例では、fetch_data_with_retry関数でリトライ機能を実装し、指定された回数だけタスクを再試行します。

まとめ

非同期処理におけるエラーハンドリングは、アプリケーションの信頼性を確保するために非常に重要です。基本的なエラーハンドリング、非同期タスクのエラーハンドリング、ロギング、リトライ機能の実装など、適切な方法を組み合わせてエラーに対処しましょう。次に、非同期処理のベストプラクティスについて詳しく見ていきます。

非同期処理のベストプラクティス

非同期処理を効果的に実装するためには、いくつかのベストプラクティスを遵守することが重要です。ここでは、非同期処理の実装における最適な方法と実践的なヒントを紹介します。

非同期コードの設計

非同期コードを設計する際には、以下のポイントに注意することが重要です。

  • シンプルなインターフェース：非同期関数はできるだけシンプルなインターフェースを持たせ、複雑なロジックを分割します。
  • 明確なエラーハンドリング：各非同期関数で適切なエラーハンドリングを行い、エラーが発生してもシステム全体に影響が及ばないようにします。

非同期ライブラリの選定

非同期処理を行う際には、信頼性が高く、広く使用されているライブラリを選定します。例えば、HTTPリクエストにはhttpx、データベース操作にはasyncpgなどがあります。

import httpx
import asyncpg

async def fetch_data_from_api():
    async with httpx.AsyncClient() as client:
        response = await client.get('https://api.example.com/data')
        return response.json()

async def fetch_data_from_db(query):
    conn = await asyncpg.connect('postgresql://user:password@localhost/dbname')
    try:
        result = await conn.fetch(query)
        return result
    finally:
        await conn.close()

リソースの効率的な使用

非同期処理では、リソースの効率的な使用が重要です。リソースの競合を避け、スレッドプールやコネクションプールを適切に管理します。

from concurrent.futures import ThreadPoolExecutor
import asyncio

executor = ThreadPoolExecutor(max_workers=5)

async def run_blocking_task():
    loop = asyncio.get_running_loop()
    result = await loop.run_in_executor(executor, blocking_task)
    return result

タイムアウトの設定

非同期処理では、タイムアウトを設定して処理が長時間ブロックされないようにします。これにより、システムの応答性を維持できます。

import asyncio

async def fetch_data_with_timeout():
    try:
        result = await asyncio.wait_for(fetch_data(), timeout=5.0)
        return result
    except asyncio.TimeoutError:
        print("タイムアウトが発生しました")
        return None

テストとデバッグ

非同期コードは同期コードと同様にテストとデバッグが重要です。pytestやunittestなどのテストフレームワークを使用して非同期関数をテストします。

import pytest
import asyncio

@pytest.mark.asyncio
async def test_fetch_data():
    result = await fetch_data()
    assert result is not None

適切なロギングの導入

非同期処理におけるロギングは、エラーのトラブルシューティングに役立ちます。loggingモジュールを使用して、適切なログレベルでメッセージを記録します。

import logging

logging.basicConfig(level=logging.INFO)

async def fetch_data():
    try:
        await asyncio.sleep(2)
        return "Data fetched!"
    except Exception as e:
        logging.error(f"エラーが発生しました: {e}")
        return None

まとめ

非同期処理のベストプラクティスを遵守することで、効率的で信頼性の高いアプリケーションを構築できます。シンプルなインターフェース設計、適切なライブラリの選定、リソースの効率的な使用、タイムアウトの設定、テストとデバッグ、適切なロギングの導入などを実践しましょう。次に、Flaskで非同期処理を実装する際の注意点について詳しく見ていきます。

Flaskで非同期処理を実装する際の注意点

Flaskで非同期処理を実装する際には、いくつかの注意点を押さえておく必要があります。これにより、アプリケーションのパフォーマンスと信頼性を確保し、トラブルを未然に防ぐことができます。

FlaskとQuartの互換性

Flaskは同期的なフレームワークであるため、非同期処理を行うにはQuartに移行する必要があります。QuartはFlaskと互換性が高いですが、すべてのFlask拡張機能がQuartで動作するわけではないため、事前に互換性を確認しましょう。

非同期タスクの管理

非同期タスクを適切に管理することは重要です。バックグラウンドタスクを適切に監視し、リソースの過剰な消費を防ぐためにキューやワーカーを利用することを検討してください。

import asyncio

task_queue = asyncio.Queue()

async def worker():
    while True:
        task = await task_queue.get()
        try:
            await task()
        finally:
            task_queue.task_done()

@app.before_serving
async def startup():
    app.add_background_task(worker)

データベース接続の管理

非同期処理では、データベース接続の管理が特に重要です。接続プールを使用して接続を効率的に管理し、必要以上の接続を開かないようにします。

import asyncpg

async def init_db():
    return await asyncpg.create_pool(dsn='postgresql://user:password@localhost/dbname')

@app.before_serving
async def setup_db():
    app.db_pool = await init_db()

@app.after_serving
async def close_db():
    await app.db_pool.close()

タイムアウトとキャンセル

非同期タスクにはタイムアウトとキャンセル機能を実装し、長時間ブロックされることを防ぎます。asyncio.wait_forを使用して、指定された時間内にタスクが完了しない場合はキャンセルします。

async def fetch_data_with_timeout():
    try:
        result = await asyncio.wait_for(fetch_data(), timeout=5.0)
        return result
    except asyncio.TimeoutError:
        logging.warning("タイムアウトが発生しました")
        return None

エラーハンドリングの徹底

非同期処理では、エラーハンドリングが非常に重要です。各非同期関数で適切にエラーハンドリングを行い、エラーが発生した場合にログを記録し、必要に応じてリトライを行います。

async def fetch_data():
    try:
        await asyncio.sleep(2)
        return "Data fetched!"
    except Exception as e:
        logging.error(f"エラーが発生しました: {e}")
        return None

セキュリティの考慮

非同期処理を実装する際には、セキュリティにも注意が必要です。データの保護、認証と認可の適切な実装、外部サービスとの安全な通信など、基本的なセキュリティ対策を徹底しましょう。

依存関係の管理

FlaskとQuartの依存関係を適切に管理し、バージョンの互換性を確認します。requirements.txtやpoetry、pipenvなどを使用して依存関係を管理すると良いでしょう。

# requirements.txt
quart==0.14.1
asyncpg==0.23.0
httpx==0.21.1

パフォーマンスのモニタリング

非同期処理のパフォーマンスを定期的にモニタリングし、ボトルネックを特定して最適化します。ツールとしては、PrometheusやGrafanaなどの監視ツールを使用することが推奨されます。

まとめ

Flaskで非同期処理を実装する際には、互換性の確認、タスクとデータベース接続の管理、タイムアウトとキャンセル、エラーハンドリング、セキュリティ、依存関係の管理、パフォーマンスのモニタリングなど、多くの注意点を考慮する必要があります。これらのポイントを押さえて、信頼性と効率性を兼ね備えたアプリケーションを構築しましょう。次に、この記事のまとめと重要なポイントの復習を行います。

まとめ

この記事では、PythonとFlaskを用いて非同期処理を実装する方法について詳しく解説しました。非同期処理の基本概念から始まり、具体的な実装手順、サンプルコード、応用例、パフォーマンス最適化手法、エラーハンドリング、ベストプラクティス、実装時の注意点までを包括的に紹介しました。

以下に、重要なポイントを再度まとめます。

  • 非同期処理の基本概念：非同期処理は、タスクの並行実行により処理待ち時間を短縮し、アプリケーションのパフォーマンスを向上させる手法です。
  • Flaskでの実装方法：FlaskとQuartを組み合わせることで、非同期処理をサポートしたアプリケーションを構築できます。
  • サンプルコード：実際の非同期処理の実装例として、データ取得、複数タスクの並行実行、外部APIリクエスト、バックグラウンドタスクの例を紹介しました。
  • 応用例：チャットアプリケーション、リアルタイムデータ処理、バックグラウンドタスク実行、非同期バッチ処理など、実際のアプリケーションでの非同期処理の活用例を説明しました。
  • パフォーマンス最適化：イベントループの効果的な利用、非同期キューの導入、非同期データベース操作、キャッシュの活用、非同期タスクの並列実行などの最適化手法を紹介しました。
  • エラーハンドリング：基本的なエラーハンドリング、非同期タスクのエラーハンドリング、ロギング、リトライ機能の実装など、エラーハンドリングの方法を解説しました。
  • ベストプラクティス：非同期コードの設計、ライブラリの選定、リソースの効率的な使用、タイムアウトの設定、テストとデバッグ、適切なロギングの導入など、効果的な非同期処理の実装方法を紹介しました。
  • 注意点：FlaskとQuartの互換性、タスクとデータベース接続の管理、タイムアウトとキャンセル、エラーハンドリング、セキュリティ、依存関係の管理、パフォーマンスのモニタリングなどの注意点を説明しました。

これらのポイントを踏まえ、Flaskアプリケーションに非同期処理を導入することで、パフォーマンスと信頼性を兼ね備えたアプリケーションを構築することができます。この記事が、非同期処理の実装に役立つことを願っています。

Python
初心者向け 非同期処理 Flask Web開発

コメント

コメントする

目次