Python初心者向け：FlaskとFastAPIの基本とメリットを紹介

By /

はい、Python初心者向けにFlaskとFastAPIの基本、メリット、そしてどちらを選ぶべきかについて詳細に解説する記事を作成します。約5000語を目指し、コード例を交えながら丁寧に説明します。

Python初心者向け：FlaskとFastAPIの基本とメリットを紹介

はじめに：なぜPythonでWeb開発？ Webフレームワークとは？

Pythonを学び始めた皆さん、次のステップとして「Webアプリケーション開発」に興味を持つ方も多いのではないでしょうか。Pythonはデータ分析、機械学習、自動化など非常に多岐にわたる分野で活用されていますが、Web開発もその強力な得意分野の一つです。

PythonがWeb開発に適している理由は何でしょうか？
1. 読みやすく書きやすい構文: Pythonの直感的でクリーンな構文は、特に初心者にとって学習コストが低く、開発効率が高いです。
2. 豊富なライブラリとフレームワーク: Web開発に必要な機能（データベース連携、認証、テンプレート処理など）を提供するライブラリやフレームワークが豊富に存在します。
3. 大規模なコミュニティ: 困ったときに助けを求められる活発なコミュニティがあります。多くの情報やチュートリアルがオンラインで見つかります。

さて、Web開発において「フレームワーク」という言葉をよく耳にすると思います。フレームワークとは、Webアプリケーションを効率的に開発するための「骨組み」や「ひな形」のことです。Webアプリケーションには共通する機能（例えば、ユーザーからのリクエストを受け取る、適切な処理を実行する、結果を返す、データベースと連携するなど）が多くあります。フレームワークはこれらの共通機能をあらかじめ提供したり、開発のルールや構造を定めたりすることで、開発者がアプリケーション独自のビジネスロジックに集中できるように支援してくれます。

フレームワークを使わないでゼロからWebアプリケーションを作ることも可能ですが、それは非常に手間がかかり、セキュリティやパフォーマンスの問題を自分で全て解決しなければなりません。フレームワークを利用することで、これらの問題をある程度解決済みのアプローチで迅速に開発を進めることができるのです。

Pythonで人気のあるWebフレームワークはいくつかありますが、特に初心者にとって学習しやすいものとして Flask と FastAPI が挙げられます。どちらもPythonでWebアプリケーションやAPIを構築するために広く使われています。

この記事では、Pythonを学び始めたばかりの方々に向けて、FlaskとFastAPIの基本的な使い方、それぞれの特徴、メリット・デメリット、そして「結局、どちらから学ぶのが良いの？」という疑問に答えることを目指します。それぞれのフレームワークの考え方を理解し、自分に合ったフレームワークを選択できるようになるための手助けとなれば幸いです。

さあ、PythonでのWeb開発の世界へ、最初の一歩を踏み出しましょう！

パート1：マイクロフレームワークの代表格 – Flask

Flaskとは？ その特徴

Flaskは、Armin Ronacherによって開発されたPythonのマイクロフレームワークです。「マイクロ」とは、必要最小限のコア機能（リクエスト処理、ルーティングなど）のみを提供するという意味です。データベース操作、フォームバリデーション、ユーザー認証などの高度な機能は、Flask自体には組み込まれていません。これらの機能が必要な場合は、拡張機能（Extensions）と呼ばれる外部ライブラリを組み合わせて利用します。

Flaskの哲学はシンプルさと柔軟性です。開発者は必要なコンポーネントを自由に選択し、組み合わせて使用できます。この柔軟性が、Flaskが小規模なアプリケーションやAPI開発、あるいはフレームワークの仕組みを学ぶための教材として非常に人気がある理由です。

Flaskの基本的な使い方

まずは、Flaskの基本的な使い方を見ていきましょう。「Hello, World!」を表示する簡単なWebアプリケーションを作成します。

1. Flaskのインストール

Pythonのパッケージ管理ツールであるpipを使ってFlaskをインストールします。仮想環境を使うことを強く推奨します。

“`bash

仮想環境の作成 (任意)

python -m venv venv
source venv/bin/activate # macOS/Linux

または venv\Scripts\activate # Windows

Flaskのインストール

pip install Flask
“`

2. 簡単なアプリケーションの作成

app.pyという名前でファイルを作成し、以下のコードを書きます。

“`python

app.py

from flask import Flask

Flaskアプリケーションのインスタンスを作成

__name__は、実行中のモジュール名です。

Flaskはこれを使って、リソース（テンプレートなど）を探します。

app = Flask(name)

ルーティング（URLと実行する関数を結びつける）

デコレータを使って、ルート(‘/’)へのアクセスがあったときに

下のindex関数を実行するように指定します。

@app.route(‘/’)
def index():
# ブラウザに返す文字列
return ‘Hello, World!’

アプリケーションを実行

デバッグモードを有効にすると、コードを変更した際に自動で再読み込みされたり、

エラー発生時にブラウザで詳細なデバッグ情報が表示されたりします。

if name == ‘main‘:
app.run(debug=True)
“`

3. アプリケーションの実行

ターミナルを開き、app.pyがあるディレクトリで以下のコマンドを実行します。

bash
python app.py

ターミナルに以下のような出力が表示されます。

* Serving Flask app 'app'
* Debug mode: on
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

ブラウザを開き、「http://127.0.0.1:5000/」にアクセスしてみてください。「Hello, World!」と表示されるはずです。

これがFlaskアプリケーションの最も基本的な形です。Flask(__name__)でアプリケーションのインスタンスを作成し、@app.route('/')デコレータでURLパス（/）と、そのパスへのリクエストがあったときに実行される関数（index）を関連付けています。関数が返した文字列が、そのままブラウザに表示される内容になります。

Flaskの主要な機能

上記の例は非常にシンプルですが、実際のWebアプリケーションではもっと複雑な処理が必要です。Flaskの基本的な機能として、以下のものがあります。

1. ルーティングとURL変数

複数のページやAPIエンドポイントを作るには、複数のルートを定義します。URLの一部を変数として受け取ることも可能です。

“`python
from flask import Flask

app = Flask(name)

@app.route(‘/’)
def index():
return ‘ホームページです！’

@app.route(‘/about’)
def about():
return ‘このサイトについて’

の部分が変数として関数に渡される

@app.route(‘/user/‘)
def show_user_profile(username):
# 変数usernameは文字列として渡される
return f’ユーザー名：{username}’

のように型を指定することもできる

@app.route(‘/post/‘)
def show_post(post_id):
# post_idは整数として渡される
return f’投稿ID：{post_id}’

if name == ‘main‘:
app.run(debug=True)
“`

このコードを実行して、/, /about, /user/alice, /post/123といったURLにアクセスしてみてください。それぞれのURLに対応した関数が実行され、結果が表示されることがわかります。

2. テンプレートエンジン（Jinja2）

動的なHTMLページを生成するために、FlaskはデフォルトでJinja2というテンプレートエンジンを使用します。テンプレートエンジンを使うと、PythonコードとHTMLを分離し、HTMLの中に変数や制御構造（if文、for文など）を埋め込むことができます。

まず、プロジェクトディレクトリ内にtemplatesというフォルダを作成します。その中にHTMLファイル（例: index.html）を作成します。

“`html





{{ title }}

こんにちは、{{ name }}さん！

これはFlaskのテンプレートを使ったページです。

好きなフルーツリスト

    {% for fruit in fruits %}

  • {{ fruit }}

    • {% endfor %}

{% if show_message %}

メッセージを表示しています。

{% endif %}

“`

次に、Flaskアプリケーションのコードを修正し、このテンプレートをレンダリングするようにします。render_template関数を使います。

“`python

app.py

from flask import Flask, render_template

app = Flask(name)

@app.route(‘/’)
def index():
page_title = ‘はじめてのFlaskテンプレート’
user_name = ‘ゲスト’
fruit_list = [‘りんご’, ‘バナナ’, ‘オレンジ’]
show_info = True

# templates/index.htmlをレンダリングし、変数を渡す
return render_template(
    'index.html',
    title=page_title,
    name=user_name,
    fruits=fruit_list,
    show_message=show_info
)

if name == ‘main‘:
app.run(debug=True)
“`

これで/にアクセスすると、templates/index.htmlが読み込まれ、Pythonコードから渡された変数（page_title, user_name, fruit_list, show_info）の値が埋め込まれてHTMLが生成され、ブラウザに表示されます。

Jinja2の構文はシンプルです。
* {{ variable }}: Pythonコードから渡された変数の値を表示します。
* {% ... %}: if文やfor文などの制御構造を記述します。
* {# ... #}: コメントです。

3. リクエストとレスポンス

ユーザーからのリクエストデータ（フォームデータ、クエリパラメータなど）を取得したり、様々な形式のレスポンス（HTML、JSONなど）を返したりすることもできます。flaskモジュールからrequestオブジェクトをインポートして利用します。

“`python
from flask import Flask, request, jsonify, render_template

app = Flask(name)

@app.route(‘/’)
def index():
return render_template(‘form.html’) # 後述のフォーム用HTMLをレンダリング

GETリクエストでクエリパラメータを受け取る例

/greet?name=Taro にアクセス

@app.route(‘/greet’, methods=[‘GET’])
def greet():
# request.args でクエリパラメータを取得
name = request.args.get(‘name’, ‘名無し’) # ‘name’がない場合は’名無し’をデフォルトとする
return f’こんにちは、{name}さん！ (GETリクエスト)’

POSTリクエストでフォームデータを受け取る例

@app.route(‘/submit’, methods=[‘POST’])
def submit():
# request.form でフォームデータを取得
user_name = request.form.get(‘username’)
password = request.form.get(‘password’)

if user_name and password:
    return f'フォーム送信成功！ ユーザー名: {user_name}, パスワード: {password} (POSTリクエスト)'
else:
    return 'フォーム送信失敗！ユーザー名とパスワードを入力してください。'

JSONを返すAPIエンドポイントの例

@app.route(‘/api/data’)
def api_data():
data = {
‘id’: 1,
‘name’: ‘サンプルアイテム’,
‘value’: 100
}
# jsonifyを使うと、Pythonの辞書やリストをJSON形式に変換して返す
return jsonify(data)

if name == ‘main‘:
app.run(debug=True)
“`

上記の例で使っているフォーム用HTML (templates/form.html) は以下のようになります。

“`html





フォーム例

ユーザー情報入力フォーム (POST)




挨拶ページへのリンク (GET クエリパラメータ)

太郎さんへ挨拶 (GETリクエスト)


“`

/にアクセスしてフォームを試したり、/greet?name=Hanakoや/api/dataにアクセスしたりして動作を確認してみてください。

Flaskのメリット（初心者向け）

  • シンプルで理解しやすい: Flaskのコアは非常に小さく、学習すべき基本概念（ルーティング、テンプレート、リクエスト/レスポンス）が少ないため、初心者でも比較的早くWebアプリケーションの基礎を学ぶことができます。
  • マイクロフレームワークの哲学: 必要な機能だけを選んで追加できるため、「どうやって動いているんだろう？」という内部の仕組みを追いかけやすく、学習教材として優れています。
  • 豊富な拡張機能: 多くの開発者によって様々な拡張機能（データベース連携、ユーザー認証、フォーム処理など）が開発されています。これらを組み合わせることで、様々な要件に対応できます。
  • ドキュメントとコミュニティ: 歴史が長く、ドキュメントが充実しており、活発なコミュニティがあります。困ったときに情報を探しやすく、質問しやすい環境です。

Flaskのデメリット（初心者向け）

  • 機能が少ないゆえの手間: 高度な機能が必要な場合、自分で適切な拡張機能を探してインストール・設定する必要があります。これは、特に初心者にとっては少し敷 footpath になる可能性があります。
  • 非同期処理の扱い: Flaskは基本的に同期処理を前提としています。Webアプリケーションが多くのI/O待ち（データベースアクセス、外部API呼び出しなど）を含む場合、非同期処理を効率的に行うための組み込みサポートは限定的です。大規模な高負荷アプリケーションでは、パフォーマンスボトルネックになる可能性があります。（最近のFlaskは非同期処理にも対応し始めていますが、FastAPIほどネイティブではありません。）
  • API開発に特化していない: Webページ表示（HTMLテンプレート）とAPI（JSONレスポンス）の両方を柔軟に作れますが、特にAPI開発に求められるデータバリデーションやドキュメンテーションなどの機能は、自分で実装するか拡張機能で補う必要があります。

Flaskはどんな人におすすめ？

  • Webフレームワークの基本概念（ルーティング、HTTPメソッド、テンプレートなど）をじっくり学びたい人。
  • 小規模なWebアプリケーションやシンプルなAPIを素早く作りたい人。
  • フレームワークの内部の仕組みに興味があり、自分でコンポーネントを組み合わせてみたい人。
  • 既にPythonの他のライブラリ（例: SQLAlchemy for ORM）に慣れており、それらをWebフレームワークと組み合わせて使いたい人。

Flaskは、Web開発の「なぜ」や「どのように」を理解する上で非常に良い出発点となります。シンプルな構造が故に、その上に何を構築するかを自分で考え、選ぶ楽しさがあります。

パート2：モダンで高速なAPIフレームワーク – FastAPI

FastAPIとは？ その特徴

FastAPIは、Sebastian Ramírez氏によって開発された比較的新しいPythonのWebフレームワークです。その名の通り、API（特にREST API）を素早く（Fast）構築することに特化しています。Flaskがマイクロフレームワークであるのに対し、FastAPIはAPI開発に必要な多くの機能を組み込みで提供します。

FastAPIの最大の特徴は以下の点です。
* 高性能: Starlette（ASGIフレームワーク）とPydantic（データ検証ライブラリ）の上に構築されており、非常に高いパフォーマンスを発揮します。非同期処理（async/await）をネイティブにサポートしています。
* 自動生成ドキュメント: コードから自動的に対話型のAPIドキュメント（Swagger UIやReDoc）を生成します。
* データ検証とシリアライズ: Pydanticモデルを使うことで、リクエストデータの自動検証、PythonオブジェクトからJSONへの変換、JSONからPythonオブジェクトへの変換を簡単に行えます。
* 型ヒントの活用: Pythonの型ヒントを積極的に活用しており、コード補完やエラーチェックが強力です。

FastAPIの基本的な使い方

FastAPIの基本的な使い方を見ていきましょう。こちらも「Hello, World!」から始めます。

1. FastAPIとASGIサーバーのインストール

FastAPIは非同期で動作するため、非同期サーバー（ASGIサーバー）が必要です。最も一般的なのはUvicornです。

“`bash

仮想環境の作成 (任意)

python -m venv venv
source venv/bin/activate # macOS/Linux

または venv\Scripts\activate # Windows

FastAPIとUvicornのインストール

pip install fastapi uvicorn[standard]
``uvicorn[standard]`は、Uvicornとその推奨される依存関係（例えば、ホットリロードに必要なwatchfilesなど）をインストールします。

2. 簡単なアプリケーションの作成

main.pyという名前でファイルを作成し、以下のコードを書きます。

“`python

main.py

from fastapi import FastAPI

FastAPIアプリケーションのインスタンスを作成

app = FastAPI()

ルーティング（パスオペレーションと呼ばれる）

@app.[httpメソッド]を使って、特定のパスへのリクエストがあったときに

下のread_root関数を実行するように指定します。

@app.get(“/”)
async def read_root():
# 辞書を返すと、自動的にJSON形式に変換される
return {“Hello”: “World”}

非同期関数として定義する

@app.get(“/items/{item_id}”)
async def read_item(item_id: int, q: str | None = None):
# item_idは型ヒントにより整数として渡される
# qは型ヒントにより文字列またはNoneとして渡される（クエリパラメータ）
return {“item_id”: item_id, “q”: q}

``
FastAPIでは、ルート関数をasync def`で定義することが多いです。これは非同期処理に対応するためです。関数が辞書やリストを返すと、FastAPIは自動的にそれをJSON形式に変換してレスポンスとして返します。

3. アプリケーションの実行

ターミナルを開き、main.pyがあるディレクトリで以下のコマンドを実行します。

bash
uvicorn main:app --reload

  • main:app: main.pyファイルの中のappという名前のFastAPIインスタンスを実行することを指定しています。
  • --reload: コードを変更した際に自動でサーバーが再起動されるホットリロード機能を有効にします。

ターミナルに以下のような出力が表示されます。

INFO: Will watch for changes in these directories: ['/path/to/your/project']
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO: Started reloader process [xxxxx] using WatchFiles
INFO: Started server running on http://127.0.0.1:8000

ブラウザを開き、「http://127.0.0.1:8000/」にアクセスしてみてください。{"Hello":"World"}というJSONが表示されるはずです。また、「http://127.0.0.1:8000/items/5?q=somequery」にアクセスすると、{"item_id": 5, "q": "somequery"}というJSONが表示されます。

これがFastAPIアプリケーションの最も基本的な形です。FastAPI()でインスタンスを作成し、@app.get("/")などのデコレータでURLパスとHTTPメソッド（GET）を指定しています。パスオペレーション関数（この場合はread_rootやread_item）はasync defで定義され、Pythonの型ヒントを活用しています。

FastAPIの主要な機能

FastAPIがAPI開発において強力な理由となる主要な機能を見ていきましょう。

1. パスオペレーションとHTTPメソッド

FastAPIでは、特定のURLパスとHTTPメソッド（GET, POST, PUT, DELETEなど）の組み合わせを「パスオペレーション」と呼びます。それぞれのHTTPメソッドに対応するデコレータ（@app.get(), @app.post(), @app.put(), @app.delete()など）が用意されています。

“`python
from fastapi import FastAPI

app = FastAPI()

GETリクエスト

@app.get(“/items/”)
async def read_items():
return [{“item_id”: “Foo”}, {“item_id”: “Bar”}]

POSTリクエスト

POSTmanやcurlなどでテスト可能

@app.post(“/items/”)
async def create_item(item: dict): # リクエストボディを辞書として受け取る例
return {“message”: “Item created”, “item”: item}

PUTリクエスト

@app.put(“/items/{item_id}”)
async def update_item(item_id: int, item: dict):
return {“item_name”: item.get(“name”, “unknown”), “item_id”: item_id}
“`

これらのエンドポイントに異なるHTTPメソッドでアクセスしてみてください（ブラウザのURLバーは基本的にGETリクエストです。POST, PUT, DELETEなどはPOSTmanやInsomniaといったAPIテストツール、またはcurlコマンドなどを使う必要があります）。

2. Pydanticによるデータ検証とシリアライズ

FastAPIの最も強力な機能の一つが、Pydanticとの連携による自動的なデータ検証とシリアライズです。Pydanticモデルを定義することで、リクエストボディやレスポンスデータの構造と型を明確に指定できます。

まず、PydanticのBaseModelを継承したモデルを定義します。

“`python

models.py (別のファイルに分けるのが一般的ですが、ここでは同じファイルに書きます)

from pydantic import BaseModel, Field
from typing import List, Optional

Itemモデルを定義

各フィールドに型ヒントを指定する

class Item(BaseModel):
name: str = Field(…, example=”Awesome Item”) # exampleはドキュメント用
price: float = Field(…, gt=0, example=10.5) # priceは0より大きい必要あり (gt=greater than)
is_offer: Optional[bool] = Field(None, example=True) # OptionalはNoneも許可

ユーザーモデルの例

class User(BaseModel):
username: str = Field(…, example=”johndoe”)
email: str = Field(…, example=”[email protected]”)
full_name: Optional[str] = Field(None, example=”John Doe”)

複数のアイテムを含むことができるモデル

class ItemsList(BaseModel):
items: List[Item]
“`

次に、これらのPydanticモデルをパスオペレーション関数で型ヒントとして使用します。

“`python

main.py (上記のmodels.pyの内容も含むかインポート)

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
from typing import List, Optional

Pydantic モデルの定義（省略、上記を参照）

class Item(BaseModel):
name: str = Field(…, example=”Awesome Item”)
price: float = Field(…, gt=0, example=10.5)
is_offer: Optional[bool] = Field(None, example=True)

class User(BaseModel):
username: str = Field(…, example=”johndoe”)
email: str = Field(…, example=”[email protected]”)
full_name: Optional[str] = Field(None, example=”John Doe”)

app = FastAPI()

POSTリクエストでItemモデルを受け取る

@app.post(“/items/”)
async def create_item(item: Item): # Item型のオブジェクトとしてリクエストボディを受け取る
# FastAPIとPydanticが自動で以下の処理を行う：
# 1. リクエストボディのJSONをパースする
# 2. Itemモデルのスキーマに従ってデータを検証する
# 3. 検証が失敗した場合、自動的に422 Unprocessable Entityエラーを返す
# 4. 検証が成功した場合、PythonのItemオブジェクトを作成し、item変数に渡す
return item # Itemオブジェクトを返すと、自動的にJSONにシリアライズされる

レスポンスモデルを指定する例

@app.get(“/users/{user_id}”, response_model=User)
async def read_user(user_id: int):
# データベースなどからユーザー情報を取得する想定
dummy_db = {
1: User(username=”alice”, email=”[email protected]”, full_name=”Alice Smith”),
2: User(username=”bob”, email=”[email protected]”),
}
user = dummy_db.get(user_id)
if user is None:
raise HTTPException(status_code=404, detail=”User not found”)
return user # PydanticモデルのUserオブジェクトを返すと、response_modelで指定された形式でJSONにシリアライズされる
“`

このコードを実行し、/docsまたは/redocにアクセスしてみてください（後述）。自動生成されたドキュメントで/items/ (POST) エンドポイントを試すことができます。無効なデータを送ると、FastAPIが自動的にバリデーションエラーを返します。/users/1や/users/2、/users/3にアクセスして、response_modelの動作とエラーハンドリングを確認してください。

Pydanticを使うことで、以下の大きなメリットが得られます。
* 開発効率向上: リクエストデータのパースと検証コードを書く手間が大幅に省けます。
* 堅牢性: 定義したスキーマに従わない不正なデータを受け付けなくなるため、バグを防ぎやすくなります。
* 明確なAPI仕様: Pydanticモデルの定義そのものが、APIがどのようなデータを受け付け、どのようなデータを返すかの明確な仕様となります。
* 自動ドキュメンテーション: Pydanticモデルの情報がドキュメント生成に利用されます。

3. クエリパラメータ、パスパラメータ、リクエストボディ

Flaskと同様に、URLの一部を変数として受け取ったり（パスパラメータ）、URLの?key=value形式の部分を受け取ったり（クエリパラメータ）できます。FastAPIではこれらも型ヒントで扱います。

“`python
from fastapi import FastAPI, Query, Path, Body
from typing import Optional

app = FastAPI()

クエリパラメータとパスパラメータ

@app.get(“/items/{item_id}”)
async def read_item(
item_id: int = Path(…, title=”The ID of the item to get”, gt=0), # パスパラメータ。Path()でメタ情報を追加
q: Optional[str] = Query(None, alias=”item-query”), # クエリパラメータ。aliasで別の名前を指定
short: bool = False # 型ヒントだけでデフォルト値も指定可能
):
results = {“item_id”: item_id}
if q:
results.update({“q”: q})
if not short:
results.update({“description”: “This is an amazing item”})
return results

リクエストボディを複数の引数で受け取る

POST /items/body

{ “item”: { “name”: “Item A”, “price”: 10 }, “user”: { “username”: “user1”, “email”: “[email protected]” } }

@app.post(“/items/body”)
async def create_multiple_items(item: Item, user: User, importance: int = Body(default=0)):
return {“item”: item, “user”: user, “importance”: importance}
``Query(),Path(),Body()`といったファクトリ関数を使うことで、デフォルト値やバリデーション、ドキュメンテーション用の情報などを追加できます。

4. 依存性注入（Dependency Injection）

FastAPIの非常に強力な機能として「依存性注入（DI）」があります。これは、ある関数が必要とする「依存関係」（例えば、データベース接続、認証されたユーザー情報、設定値など）を、その関数自身が生成するのではなく、フレームワークが外部から提供する仕組みです。

DIを使うことで、コードの再利用性が高まり、テストが容易になります。FastAPIでは、パスオペレーション関数の引数に関数やクラスを指定することで、その関数やクラスが返す値を依存関係として注入できます。

“`python
from fastapi import FastAPI, Depends, HTTPException, status
from typing import Annotated

app = FastAPI()

ダミーの認証関数

async def verify_token(token: str):
# ここで実際の認証処理（トークンの検証など）を行う
if token != “fake-super-secret-token”:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=”Invalid token”)
return {“token”: token}

ダミーの現在のユーザーを取得する関数 (認証に依存)

async def get_current_user(token_info: Annotated[dict, Depends(verify_token)]):
# トークン情報を使ってユーザーを取得する想定
return {“username”: “authorized_user”, “token”: token_info.get(“token”)}

@app.get(“/users/me/”)
async def read_users_me(current_user: Annotated[dict, Depends(get_current_user)]):
# get_current_user 関数が実行され、その戻り値が current_user に注入される
# get_current_user は verify_token に依存しているため、verify_token も自動的に実行される
return current_user

@app.get(“/items/”)
async def read_items(token: Annotated[dict, Depends(verify_token)]):
# このエンドポイントにアクセスするには、verify_token が成功する必要がある
return [{“item”: “Foo”, “owner”: token.get(“token”)}]

``
この例では、get_current_user関数はverify_token関数に依存しています。read_users_meの引数にDepends(get_current_user)を指定することで、FastAPIはリクエストが来るたびにget_current_userを実行し、その結果をcurrent_user引数に渡します。さらに、get_current_userがverify_tokenに依存しているため、verify_token`も自動的に実行されます。

この仕組みは、認証、データベースセッション管理、設定値の取得など、様々な場面で非常に役立ちます。

5. 自動生成ドキュメント

FastAPIを起動すると、自動的に対話型のAPIドキュメントが生成されます。
* Swagger UI: http://127.0.0.1:8000/docs にアクセスすると表示されます。APIエンドポイントの一覧、それぞれの詳細（パス、メソッド、パラメータ、レスポンスモデル）、そしてブラウザ上でのAPI呼び出しテスト機能が提供されます。
* ReDoc: http://127.0.0.0.1:8000/redoc にアクセスすると表示されます。よりシンプルな形式のドキュメントです。

これらのドキュメントは、パスオペレーションの定義、型ヒント、Pydanticモデルなどから自動生成されます。開発者だけでなく、APIを利用するクライアント側の開発者にとっても非常に有用です。APIの仕様書を手動で作成・更新する手間が省けます。

FastAPIのメリット（初心者向け）

  • 高パフォーマンス: 非同期処理とStarletteのおかげで、特にI/Oバウンドな処理（データベースアクセス、外部API呼び出しなど）が多いAPIにおいて、Flaskよりも高いパフォーマンスを発揮する傾向があります。
  • 自動データ検証とシリアライズ: Pydanticを使うことで、リクエストデータの検証やレスポンスデータの整形が非常に簡単に、かつ安全に行えます。手作業によるバリデーションコードが不要になり、バグを減らせます。
  • 自動APIドキュメント: Swagger UI/ReDocが自動生成されるため、API仕様書の作成とメンテナンスの手間が劇的に減ります。これはAPI開発において非常に大きなメリットです。
  • 型ヒントの活用: Pythonの型ヒントを積極的に使うため、コードの可読性が向上し、エディタでの補完や静的解析ツールによるエラー検出が強力になります。
  • 依存性注入システム: シンプルながら強力なDIシステムが組み込まれており、コードの構造化やテストがしやすくなります。
  • API開発に特化: APIを構築するために必要な機能が多く組み込まれており、開発効率が高いです。

FastAPIのデメリット（初心者向け）

  • 非同期処理の学習コスト: async defやawaitといったPythonの非同期プログラミングの概念を理解する必要があります。これは同期処理に慣れている初心者にとっては、最初のハードルとなる可能性があります。
  • エコシステムの成熟度: Flaskと比較すると歴史が浅いため、利用可能な拡張機能やライブラリの種類、情報量はまだ少ないかもしれません（ただし、急速にエコシステムは成長しています）。
  • Webサイト（HTMLレンダリング）用途にはやや不向き: FastAPIはAPI開発に特化しているため、サーバー側でHTMLを動的に生成して返すような（伝統的なWebサイトの）用途には、FlaskやDjangoの方がテンプレートエンジンの統合などの点で使いやすい場合があります（FastAPIでもHTMLを返すことは可能ですが、テンプレート機能は組み込みではなくStarletteの機能を利用するなど、少し手順が必要です）。

FastAPIはどんな人におすすめ？

  • 主にAPI（REST API）を開発したい人。
  • モダンなPythonの機能（非同期処理、型ヒント）を学びたい人。
  • データ検証や自動ドキュメンテーションといったAPI開発に必須の機能を効率的に利用したい人。
  • 高いパフォーマンスが求められるアプリケーションを開発したい人。
  • フロントエンドフレームワーク（React, Vue, Angularなど）と組み合わせて、バックエンドAPIとして利用したい人。

FastAPIは、特に「バックエンドAPIを効率的に、堅牢に、そしてモダンな方法で構築したい」というニーズに強く応えるフレームワークです。Pydanticと自動ドキュメントの恩恵は計り知れません。

パート3：Flask vs FastAPI – 直接比較

さて、FlaskとFastAPIそれぞれの基本と特徴を見てきました。ここでは、いくつかの観点から両者を比較し、それぞれの違いをより明確にしてみましょう。

比較項目 Flask FastAPI 初心者にとっての違い
フレームワークの種類 マイクロフレームワーク フルスタックに近いAPIフレームワーク Flaskはシンプルで学ぶことが少ない。FastAPIは機能が豊富だが、学ぶ概念（Pydantic, asyncなど）が多い。
得意な用途 小規模Webアプリ、シンプルなAPI、学習 API開発（特にREST API）、高性能なバックエンド シンプルなWebサイトならFlaskが直感的。API中心ならFastAPIが効率的。
性能 同期処理が基本（非同期も一部可） 非同期処理がネイティブ、高パフォーマンス 同期I/Oが多い処理（DBアクセスなど）ではFastAPIが有利。単純な処理では差が小さいことも。初心者はまず同期/非同期の違いを理解する必要がある。
データ検証/シリアライズ 組み込み機能なし、拡張機能を使用（例: Pydantic, Marshmallow） Pydanticが組み込み、自動で行われる Flaskでは自分でライブラリを選び、コードを書く必要がある。FastAPIではPydanticモデルを定義するだけで済む。これはFastAPIの大きな強み。
APIドキュメント 組み込み機能なし、拡張機能を使用（例: Flask-Swagger） OpenAPI/JSON Schemaに基づき自動生成（Swagger UI, ReDoc） Flaskでは自分で設定が必要。FastAPIではサーバー起動と同時に利用できる。API利用者に非常に便利。
依存性注入 組み込み機能なし、拡張機能や独自実装 組み込み機能あり、型ヒントとDependsで利用 FlaskではDIの概念を別途学ぶか、手動で依存関係を管理する必要がある。FastAPIでは組み込み機能として自然に利用できる（概念理解は必要）。
型ヒントの活用 任意（推奨はされる） 積極的に活用（必須に近い） Flaskでは型ヒントがなくても動くが、FastAPIでは型ヒントがフレームワークの機能と密接に関わっているため重要。型ヒントの習得が必須。
学習曲線 基本部分は浅いが、高度な機能は拡張機能の学習が必要 基本概念（async, Pydantic, DI）の理解が必要だが、理解すれば開発がスムーズ Flaskは最初の一歩が簡単。FastAPIは最初にある程度の概念を学ぶ必要があるが、その後は生産性が上がりやすい。
エコシステム 成熟しており拡張機能が豊富 比較的新しいが急速に成長中、モダンなライブラリとの連携が多い Flaskの方が長年の蓄積がある。FastAPIは新しい技術との親和性が高い。
設定 シンプル、最小限の構成 設定項目は多いが、多くのデフォルトでカバー可能 Flaskは設定が少ない。FastAPIも多くはデフォルトでOKだが、細かい設定も可能。
テンプレート 組み込み（Jinja2） 組み込みではない（Starletteの機能などを利用） Webページ表示が主ならFlaskが便利。APIが主でHTMLはほとんど返さないならFastAPIでも問題ない。

性能について補足

FastAPIが高いパフォーマンスを発揮するのは、主に非同期処理とASGI（Asynchronous Server Gateway Interface）に基づいているためです。

  • 同期処理 (WSGI – Flaskなど): リクエストが来ると、その処理が終わるまで他のリクエストを待たせてしまう可能性があります。特にデータベースへの問い合わせや外部API呼び出しなど、応答待ちの時間（I/O待ち）が長い処理がある場合、その待ち時間中はサーバーのリソースが有効に使われず、大量のリクエストを同時に捌ききれません。
  • 非同期処理 (ASGI – FastAPIなど): I/O待ちが発生する処理を実行している間、他のリクエストの処理に切り替えることができます。これにより、サーバーのリソース（CPUなど）をより効率的に使い、大量の同時接続やI/Oバウンドなタスクをより高速に処理できます。

ただし、これはあくまで「I/Oバウンドな処理が多い場合」に顕著な差が出ます。CPUがボトルネックになるような計算量の多い処理がメインの場合、同期/非同期による性能差は小さくなる可能性があります。また、小規模なアプリケーションやアクセスが少ないアプリケーションでは、どちらを使っても体感できるほどの性能差は出ないことが多いでしょう。

初心者にとっては、まず「非同期処理がなぜ必要なのか」「asyncとawaitは何をしているのか」という基本的な理解が、FastAPIを効果的に使う上で重要になります。

パート4：Python初心者は結局どちらを選ぶべきか？

FlaskとFastAPI、どちらも素晴らしいフレームワークであり、それぞれに強みがあります。初心者にとっては、「どちらから学ぶべきか」「自分の目的に合っているのはどちらか」が気になる点でしょう。

決定を下すための考慮事項と、それぞれのフレームワークが特に向いている初心者のタイプをまとめてみましょう。

Flaskがおすすめの初心者

  • Webアプリケーション開発の基礎をじっくり学びたい人: HTTPの仕組み、ルーティング、テンプレート、リクエスト/レスポンスといったWeb開発の基本的な概念を、最小限の機能で構成されたフレームワークを通して理解したい場合に適しています。Flaskのシンプルな構造は、これらの概念を追いかけるのに役立ちます。
  • Webサイト（サーバー側でHTMLを生成する）を主に作りたい人: ブログ、簡単な情報サイトなど、ユーザーにHTMLページを見せるタイプのアプリケーション開発が中心であれば、Flaskの組み込みテンプレートエンジン（Jinja2）が非常に便利です。
  • マイクロフレームワークの柔軟性に魅力を感じる人: 必要な機能だけを自分で選び、カスタマイズしていくプロセスを楽しみたい人に向いています。拡張機能を組み込むことで、徐々に複雑なアプリケーションを構築するステップを学ぶことができます。
  • 非同期処理の概念は後回しにしたい人: まずは同期的な処理フローでWebアプリケーションの全体像を掴みたい場合に、Flaskはシンプルです。

FastAPIがおすすめの初心者

  • API開発（特にREST API）を学びたい人: スマートフォンアプリのバックエンド、JavaScriptフレームワーク（React/Vue/Angular）のバックエンドAPI、外部連携用のAPIなど、JSONデータのやり取りがメインのアプリケーション開発が目的なら、FastAPIは強力な味方になります。
  • Pydanticによるデータ検証と自動ドキュメントに魅力を感じる人: APIの品質と保守性を高める上で非常に有用なこれらの機能が、少ない手間で利用できることに価値を感じる人におすすめです。
  • モダンなPythonの機能（型ヒント、非同期処理）を積極的に学びたい人: FastAPIはPython3.6以降の機能をフル活用しています。これらの新しい機能を実践的に学びたい場合に良いでしょう。
  • 将来的に高性能なアプリケーション開発を目指したい人: 非同期処理に慣れておくことは、大量アクセスやI/O待ちが多いアプリケーションでパフォーマンスを最適化するために役立ちます。

どちらから学んでも大丈夫

重要なのは、「どちらか片方しか選べない」わけではないということです。PythonのWebフレームワークの基本的な概念（ルーティング、HTTP、リクエスト/レスポンスなど）は、どのフレームワークでも共通しています。

  • もしFlaskでWeb開発の基礎を学べば、HTTPの仕組みやサーバー側で何が起きているのかを理解しやすくなります。その後FastAPIを学ぶ際、Pydanticや非同期処理といったFastAPI特有の機能に集中して学習できます。
  • もしFastAPIでAPI開発を学べば、データ検証やDIといったモダンな開発手法に早く触れることができます。その後Flaskを学ぶ際、テンプレートや拡張機能による機能追加の考え方を学ぶことができます。

どちらを選んでも、次に別のフレームワークを学ぶときの助けになります。まずは興味を持った方、あるいは「作りたいもの」にとってより適していそうな方を選んで、実際に手を動かしてみることが一番重要です。

もし迷うなら、以下のように考えてみてください。

  • まずはWebサイト全体を作りたい（HTML主体）： Flaskから始めるのが少しスムーズかもしれません。
  • API機能を最初に作りたい（JSON主体）： FastAPIから始めるのが効率的でしょう。

あるいは、両方の「Hello, World」や簡単なサンプルコードを実際に書いてみて、より自分に合っていると感じた方の構文や考え方で進めてみるのも良い方法です。

まとめ：学習の旅を楽しもう

この記事では、Python初心者向けにFlaskとFastAPIという二つの人気Webフレームワークを紹介しました。

  • Flask は、シンプルで拡張性に富んだマイクロフレームワークです。Web開発の基本的な概念を学ぶのに適しており、小規模なWebサイトやAPI開発でその手軽さが活かされます。拡張機能を使って機能を積み上げていくスタイルです。
  • FastAPI は、高パフォーマンスなAPI開発に特化したモダンなフレームワークです。Pydanticによるデータ検証、自動ドキュメンテーション、強力な依存性注入といった便利な機能が組み込みで提供されます。非同期処理や型ヒントといったモダンなPythonの機能を活用します。

どちらのフレームワークも、PythonでWebアプリケーションやAPIを作る上で非常に有用なツールです。どちらから学ぶにしても、大切なのは以下のステップです。

  1. 基本を理解する: ドキュメントやチュートリアルを参考に、フレームワークの基本的な概念（ルーティング、リクエスト/レスポンス、データの扱い方など）をしっかり理解しましょう。
  2. 実際にコードを書く: 簡単なサンプルから始め、少しずつ複雑なアプリケーションに挑戦してください。「Hello, World」だけでなく、ユーザー入力の受け付け、データの表示、簡単なCRUD（作成、読み取り、更新、削除）操作などを含むアプリケーションを作ってみましょう。
  3. エラーを恐れない: 開発中にエラーはつきものです。エラーメッセージをよく読み、インターネットで検索して解決方法を探るスキルは非常に重要です。
  4. コミュニティを活用する: 公式ドキュメント、Stack Overflow、Qiita、Qiita、各種技術ブログなど、オンラインには多くの情報があります。また、困ったときは質問してみることも有効です。

FlaskもFastAPIも、それぞれ独自の思想と強みを持っています。どちらを学ぶにしても、Web開発の楽しさと奥深さをきっと感じられるはずです。

PythonでのWeb開発は、あなたのプログラミングスキルを次のレベルに引き上げる素晴らしいステップです。焦らず、楽しみながら学習を進めていってください。

この長い記事が、皆さんのPython Web開発の学習の第一歩を踏み出す手助けとなれば幸いです。頑張ってください！

コメントする

メールアドレスが公開されることはありません。 ※ が付いている欄は必須項目です

上部へスクロール