【Python】async/awaitの使い方!非同期処理の基本を解説

【Python】async/awaitの使い方!非同期処理の基本を解説

PR Amazonのアソシエイトとして、ITナレッジライフは適格販売により収入を得ています。

記事の文字数:5,138

Pythonのasync/awaitと標準ライブラリasyncioを使った非同期処理の使い方を徹底解説!コルーチンの基本構文から、asyncio.gatherやcreate_taskによる並行実行、タイムアウト制御、time.sleepを使わない注意点まで実機検証コード付きで紹介します。

Pythonユーザにお勧めの本 ↗

初心者向け

1週間でPythonの基礎が学べる本

難易度
実用性
読みやすさ

「絶対に挫折させない」という著者の強い意志を感じる、プログラミングの「最初の1冊」としておすすめできる良書です。

人気

スッキリわかるPython入門 第2版 スッキリわかるシリーズ

難易度
実用性
読みやすさ

対話形式でスラスラ読める。複雑な概念もキャラクターが分かりやすく解説してくれます。

独習Python

難易度
実用性
網羅性

言語仕様を深く解説。なんとなく書ける状態から、自信を持って書ける状態へ引き上げてくれます。

Python1年生 第2版 体験してわかる!会話でまなべる!プログラミングのしくみ

難易度
実用性
読みやすさ

イラスト中心で、プログラミングの楽しさを教えてくれる。ワクワクしながら学べる入門書です。

Web APIAPI [エーピーアイ]Application Programming Interface。異なるソフトウェア間の接続口から複数のデータを取得したり、データベースやファイルへの入出力(I/O)を繰り返したりするプログラムをPythonPython [パイソン]汎用プログラミング言語で書いていると、「1つずつの通信待ち時間が積み重なって全体の処理が遅くなる」という課題に直面することがあります。

Pythonでは、 async / await 構文 と標準ライブラリの asyncio モジュール を組み合わせることで、通信やI/Oの待ち時間を有効活用して複数のタスクを効率よく進める 非同期処理(コルーチン) をシンプルに実装できます。なお、通常の同期処理で単純に実行を一時停止したい場合は Pythonのtime.sleep関数の使い方 でも詳しく解説しています。

この記事では、async def と await の基本的な役割から、asyncio.gather() や asyncio.create_task() を使った並行実行の方法、タイムアウト処理の実装、さらに初心者がつまずきやすい注意点まで、実機で検証したコード例とともに分かりやすく解説します。

この記事でわかること

  • 非同期処理の仕組みと async / await・コルーチン・イベントループの関係
  • asyncio.run() と asyncio.sleep() を使った非同期関数の基本的な実行方法
  • asyncio.gather() で複数の非同期処理をまとめて並行実行し、処理時間を短縮する方法
  • asyncio.create_task() でバックグラウンドタスクをスケジュールする方法
  • asyncio.wait_for() によるタイムアウト制御と、非同期処理でやってはいけないアンチパターン

確認した環境

本記事で解説するコードおよび出力結果は、以下の環境で動作を確認しています。

※ Python 3.9は2025年10月31日にサポートが終了しています。本記事の環境は動作検証時のものです。新規開発では、サポート期間内のPythonバージョン(Python 3.12 / 3.13 等)の利用を推奨します。

Pythonのasync/await(非同期処理)とは?

Pythonにおける async / await とは、ネットワーク通信やディスク読み書きなどの 「待ち時間(I/O待ち)」が発生する処理を効率化する非同期プログラミングのための構文 です。

通常の同期処理(Synchronoussynchronous [シンクロナス]同期。処理の完了を待ってから次の処理を実行する方式)では、1つの処理が完了するまでプログラム全体が待機するため、1秒かかるAPI通信を3回行うと合計3秒かかります。一方、非同期処理(Asynchronousasynchronous [エイシンクロナス]非同期。処理の完了を待たずに次の処理を実行する方式)では、あるタスクが通信の応答を待っている間に別のタスクへ処理を切り替えることで、シングルスレッドのまま複数のI/O待ちを同時に進めることができます。

flowchart TD subgraph Sync["同期処理(直列実行:計3秒)"] direction LR S1["タスク1 (1秒)"] --> S2["タスク2 (2秒)"] end subgraph Async["非同期処理(並行実行:計2秒)"] direction TB A1["タスク1: 開始 ──(1秒待機)──> 完了"] A2["タスク2: 開始 ──────(2秒待機)──────> 完了"] end

押さえておくべき3つの基本用語

Pythonの非同期処理を理解するうえで、以下の3つの用語の役割を整理しておきましょう(参照: Python公式ドキュメント: asyncio — 非同期 I/O)。

用語記述方法・関数役割と仕組み
コルーチン(Coroutine)async def 関数名():処理の途中で一時停止・再開ができる特殊な関数。呼び出すと「コルーチンオブジェクト」を返す
await 式await <Awaitable>コルーチンやTaskなどの完了を待つキーワード。待機中はイベントループに制御を譲り、他のタスクを実行可能にする
イベントループ(Event Loop)asyncio.run()複数のコルーチンやタスクの実行順序を管理し、I/O待ちの切り替え(スケジューリング)を行うエンジン
スポンサーリンク

async defとawaitの基本的な使い方

もっとも基本的な非同期処理の書き方は、async def でコルーチン関数を定義し、内部の待機処理に await を付け、最後にエントリーポイントとして asyncio.run() で実行する流れです。

コルーチンを定義して実行する基本コード

以下の例では、1秒間の非同期待機(asyncio.sleep(1))を挟んでメッセージを返すコルーチン say_hello() を定義し、asyncio.run() で実行しています。

basic_async.py
import asyncio
async def say_hello(name: str) -> str:
print("処理を開始します...")
# 1秒間のI/O待ちをシミュレート(他のタスクに制御を譲る)
await asyncio.sleep(1)
print("処理が完了しました!")
return f"Hello, {name}!"
# イベントループを起動してコルーチンを実行
result = asyncio.run(say_hello("Alice"))
print(f"戻り値: {result}")

実行結果:

処理を開始します...
処理が完了しました!
戻り値: Hello, Alice!

コルーチンは直接呼び出すだけでは実行されない

通常のPython関数(関数とメソッドの違いは Pythonの関数とメソッドの違い を参照)とは異なり、async def で定義した関数を say_hello("Alice") のように呼び出しただけでは、中身の処理は実行されず コルーチンオブジェクト が生成されるだけです。

コルーチンを実際に動かすには、必ず以下のいずれかの方法をとる必要があります。

  • プログラムの最上位(通常の同期コード側)から asyncio.run(コルーチン) に渡して実行する
  • 別の async def 関数の内部で await コルーチン として呼び出す

[!WARNING] await は async def の外側では使えない await キーワードは async def で定義されたコルーチン関数の内部でのみ使用できます。通常の関数(def)内で await を記述すると SyntaxError: 'await' outside async function、関数外のトップレベルで記述すると SyntaxError: 'await' outside function が発生するため注意してください。

複数の非同期処理を並行実行する方法

1つのコルーチンの中で await を順番に書くだけでは、1つずつ完了を待つため実行時間は短縮されません。複数の非同期タスクを 並行(Concurrent) に走らせるには、 asyncio.gather() または asyncio.create_task() を使用します。

1. asyncio.gather()で複数タスクをまとめて並行実行する

複数のコルーチンを同時に開始し、すべての完了を待って結果をリスト(リストの基本操作は Pythonリストの使い方 を参照)として受け取りたい場合は、asyncio.gather() が便利です。

まずは、await を単純に2回並べた場合(直列実行)と、asyncio.gather() を使った場合(並行実行)で経過時間がどう変わるかを比較してみましょう。

compare_gather.py
import asyncio
import time
async def fetch_data(task_id: int, delay: int) -> str:
print(f"[タスク{task_id}] 取得開始 ({delay}秒待機)")
await asyncio.sleep(delay)
print(f"[タスク{task_id}] 取得完了")
return f"Data-{task_id}"
async def run_sequential():
print("=== 1. awaitを順番に実行(直列) ===")
start = time.perf_counter()
r1 = await fetch_data(1, 1)
r2 = await fetch_data(2, 2)
elapsed = time.perf_counter() - start
print(f"結果: {[r1, r2]}, 経過時間: {elapsed:.2f}秒\n")
async def run_concurrent():
print("=== 2. asyncio.gatherで実行(並行) ===")
start = time.perf_counter()
results = await asyncio.gather(
fetch_data(1, 1),
fetch_data(2, 2),
)
elapsed = time.perf_counter() - start
print(f"結果: {results}, 経過時間: {elapsed:.2f}秒")
asyncio.run(run_sequential())
asyncio.run(run_concurrent())

実行結果:

=== 1. awaitを順番に実行(直列) ===
[タスク1] 取得開始 (1秒待機)
[タスク1] 取得完了
[タスク2] 取得開始 (2秒待機)
[タスク2] 取得完了
結果: ['Data-1', 'Data-2'], 経過時間: 3.00秒
=== 2. asyncio.gatherで実行(並行) ===
[タスク1] 取得開始 (1秒待機)
[タスク2] 取得開始 (2秒待機)
[タスク1] 取得完了
[タスク2] 取得完了
結果: ['Data-1', 'Data-2'], 経過時間: 2.00秒

直列実行では「1秒 + 2秒 = 3.00秒」かかっているのに対し、asyncio.gather() を使った並行実行ではタスク1の完了を待たずにタスク2が開始されるため、もっとも時間がかかるタスク2に合わせた 2.00秒 で全処理が完了しています。

また、asyncio.gather() の戻り値のリストは、完了した順ではなく 引数に渡した順番 (['Data-1', 'Data-2'])が維持される点も実務で扱いやすい特徴です。

2. asyncio.create_task()でタスクを個別にスケジュールする

「非同期タスクをバックグラウンドで開始しておき、その間に別の処理を進め、必要なタイミングで結果を受け取る」といった柔軟な制御を行いたい場合は、 asyncio.create_task() を使用します。

create_task_demo.py
import asyncio
async def background_job(name: str, delay: int) -> str:
print(f"[{name}] バックグラウンド処理開始")
await asyncio.sleep(delay)
print(f"[{name}] バックグラウンド処理完了")
return f"{name}: OK"
async def main():
# コルーチンをTaskとしてイベントループに登録(即座にスケジュールされる)
task1 = asyncio.create_task(background_job("Job-A", 1))
task2 = asyncio.create_task(background_job("Job-B", 1))
print("タスクをスケジュールしました。別の処理を実行中...")
await asyncio.sleep(0.5)
# タスクの完了を待って結果を取得
res1 = await task1
res2 = await task2
print(f"完了結果: {res1}, {res2}")
asyncio.run(main())

実行結果:

タスクをスケジュールしました。別の処理を実行中...
[Job-A] バックグラウンド処理開始
[Job-B] バックグラウンド処理開始
[Job-A] バックグラウンド処理完了
[Job-B] バックグラウンド処理完了
完了結果: Job-A: OK, Job-B: OK

asyncio.create_task() を呼び出した時点でタスクがイベントループに登録され、次の await(上記の例では await asyncio.sleep(0.5))に到達したタイミングでバックグラウンド処理が並行して走り始めます。

[!TIP] Python 3.11以降なら asyncio.TaskGroup も選択肢に Python 3.11以降では、コンテキストマネージャ(async with asyncio.TaskGroup() as tg:)を使ってより安全にタスク群を管理できる TaskGroup が導入されました。ブロックを抜ける際に自動で全タスクの完了を待機し、いずれかのタスクで例外が発生した場合は残りのタスクを自動キャンセルしてくれるため、Python 3.11以降の環境では TaskGroup の利用も推奨されています。

スポンサーリンク

実務で役立つタイムアウト制御と例外処理

外部APIとの通信などでは、相手サーバーの応答が返ってこない場合に備えてタイムアウトを設定したり、複数タスクの一部が失敗した際の挙動を制御したりする必要があります。

1. asyncio.wait_for()でタイムアウトを設定する

コルーチンの実行時間に上限を設けたい場合は、 asyncio.wait_for(コルーチン, timeout=秒数) を使用します。指定した秒数以内に完了しない場合、自動的にタスクがキャンセルされ asyncio.TimeoutError(Python 3.11以降は組み込みの TimeoutError と同一)が発生します。

timeout_demo.py
import asyncio
async def slow_operation() -> str:
await asyncio.sleep(3)
return "完了"
async def main():
try:
# 上限を1.0秒に設定して実行
await asyncio.wait_for(slow_operation(), timeout=1.0)
except asyncio.TimeoutError:
print("エラー: 処理がタイムアウトしました (1.0秒経過)")
asyncio.run(main())

実行結果:

エラー: 処理がタイムアウトしました (1.0秒経過)

2. asyncio.gather()での例外の扱い(return_exceptions)

asyncio.gather() で複数のタスクを並行実行しているとき、デフォルト(return_exceptions=False)では1つのタスクで例外が発生すると即座に呼び出し元へその例外が送出されます。

一部のタスクが失敗しても他のタスクの結果を最後まで受け取りたい場合は、引数に return_exceptions=True を指定します。これにより、発生した例外オブジェクトも通常の戻り値と同じように結果リストの中に格納されて返されます。

非同期処理(async/await)を使う際の注意点

最後に、Pythonで非同期処理を実装する際によくある落とし穴を2つ確認しておきましょう。

1. コルーチン内でブロッキング関数(time.sleepなど)を使わない

もっとも陥りやすいミスは、async def の中で標準の time.sleep() や同期通信ライブラリの requests.get() などを直接呼び出してしまうことです。

これらのブロッキング関数はイベントループに制御を返さず、スレッド全体を停止させてしまうため、他のコルーチンもすべて止まり非同期処理のメリットが失われます。

2. CPU負荷の高い計算処理(CPUバウンド)は高速化されない

asyncio の非同期処理は、基本的に 1つのスレッド内でI/Oの待ち時間をやりくりする仕組み です。

そのため、画像処理や大量の数値計算など、待ち時間がなくCPUCPU [シーピーユー]Central Processing Unit。コンピュータの頭脳となる中央演算処理装置をフルに使い続ける処理(CPUバウンドな処理)を async / await で書いても並列化されず、処理速度は向上しません。CPUバウンドな処理を複数のCPUコアで並列実行したい場合は、asyncio ではなく標準ライブラリの concurrent.futures.ProcessPoolExecutor や multiprocessing モジュールを選択してください。

スポンサーリンク

まとめ

この記事では、Pythonの async / await 構文と asyncio モジュールを使った非同期処理の基本から実践的な並行実行の方法までを解説しました。

押さえておきたい要点

  • async def でコルーチンを定義し、await で待機ポイントを作ることでI/O待ちの間も別タスクを進められる
  • 通常の同期コードからコルーチンを実行する際は asyncio.run() を使用する
  • 複数のコルーチンをまとめて並行実行し結果リストを得るには asyncio.gather() を使う
  • バックグラウンドでタスクを走らせて柔軟に制御するには asyncio.create_task() を使う
  • コルーチン内では time.sleep() などのブロッキング処理を避け、await asyncio.sleep() や非同期対応ライブラリを使用する

Webスクレイピングや外部API連携、FastAPIなどの非同期Webフレームワークを扱ううえで、async / await の理解は欠かせません。ぜひ本記事のコード例をベースに、効率的な非同期処理を実装してみてください。

あわせて読みたい

Pythonの待機処理やテスト、関数の基礎についてさらに理解を深めたい方は、以下の記事もあわせてご覧ください。

Python sleep関数の使い方!秒・ミリ秒の一時停止や非同期処理
ITナレッジライフ

Python sleep関数の使い方!秒・ミリ秒の一時停止や非同期処理

Pythonのtime.sleep関数を使って処理を一時停止(待機)させる方法を初心者向けに解説します。秒単位・ミリ秒(小数)単位の指定方法から、for文やwhile文を使ったループ処理での活用例、APIリクエスト時の待機、さらに非同期処理(asyncio.sleep)との違いまで実務で役立つ使い方を紹介します。

【Python】関数とメソッドの違いを徹底解説!
ITナレッジライフ

【Python】関数とメソッドの違いを徹底解説!

Pythonの「関数」と「メソッド」の違いを初心者にもわかりやすく解説します。本記事では、両者の定義や使い方、そしてどのように使い分ければよいのかを具体例と共に丁寧に紹介します。オブジェクト指向との関連や実務での活用にも触れ、Pythonの理解を一段深める内容となっています。

【Python】pytest fixtureの使い方!前処理・後処理を解説
ITナレッジライフ

【Python】pytest fixtureの使い方!前処理・後処理を解説

Pythonのテストフレームワークpytestにおけるfixture(フィクスチャ)の使い方を徹底解説!基本構文からyieldを使った前処理・後処理、実行単位を制御するscope設定、conftest.pyによるファイル間の共通化、組み込みfixtureの活用法まで実機検証コード付きで紹介します。

【Python】デコレータ徹底解説|基礎からわかりやすく解説!
ITナレッジライフ

【Python】デコレータ徹底解説|基礎からわかりやすく解説!

Pythonのデコレータは、関数やクラスの振る舞いを柔軟に拡張できる便利な機能です。本記事では、初心者でも理解しやすいコード例と実行結果を交えて、デコレータの基本的な仕組みから、実践的な応用例まで詳しく解説します。Pythonの開発を効率化し、可読性の高いコードを書けるようになりましょう!


以上で本記事の解説を終わります。
よいITライフを!
スポンサーリンク
ITナレッジライフ 運営者
この記事を書いた人

Z (ITナレッジライフ)

現役のITエンジニア。Linux、プログラミング、IT用語など、日々の業務で得た「痒いところに手が届く」技術情報を発信しています。

プロフィールと編集ポリシーを見る →
スポンサーリンク

Pythonユーザにお勧めの本 ↗

初心者向け

1週間でPythonの基礎が学べる本

難易度
実用性
読みやすさ

「絶対に挫折させない」という著者の強い意志を感じる、プログラミングの「最初の1冊」としておすすめできる良書です。

スポンサーリンク

人気記事


記事を評価

Thanks!
目次
Scroll to Top