Python Flask入門：Web開発の第一歩

By /

Python Flask入門：Web開発の第一歩

はじめに

現代のデジタル世界において、Webアプリケーションは私たちの生活に欠かせない存在となっています。SNS、オンラインショッピング、ブログ、業務システムなど、その種類は多岐にわたります。そして、これらのWebアプリケーションの多くは、サーバーサイドのプログラミング言語とWebフレームワークを使って開発されています。

Pythonは、その読みやすい構文と豊富なライブラリにより、プログラミング初心者から熟練の開発者まで幅広く愛されています。Web開発においてもPythonは非常に強力な選択肢であり、Flaskはその中でも特に人気のあるマイクロWebフレームワークです。

この記事では、Pythonを使ったWeb開発の第一歩として、Flaskの基礎を徹底的に解説します。Web開発の経験がない方でも理解できるように、概念から具体的なコード例、さらには少し進んだトピックまで、段階的に学んでいきます。さあ、Flaskを使ってあなた自身のWebアプリケーションを作り始める旅に出かけましょう！

1. Web開発の基本を知ろう

Flaskについて学ぶ前に、まずはWeb開発がどのように行われているのか、基本的な仕組みを理解しておきましょう。

Web開発は、主に「クライアント」と「サーバー」という二つの要素間のやり取りによって成り立っています。

  • クライアント: 通常、ユーザーが操作するWebブラウザ（Chrome, Firefox, Safariなど）のことです。
  • サーバー: Webサイトのデータやプログラムが置かれているコンピューターのことです。

ユーザーがブラウザでWebサイトのアドレス（URL）を入力すると、ブラウザは指定されたサーバーに対して「このページの情報をください」という「リクエスト（Request）」を送ります。

サーバーはリクエストを受け取ると、要求された情報（HTMLファイル、画像ファイル、データなど）を探し、それをブラウザに「レスポンス（Response）」として送り返します。

ブラウザはそのレスポンスを受け取り、HTMLを解釈してページを表示します。CSSを使って見た目を整え、JavaScriptを使って動的な要素を追加します。

この「リクエストとレスポンス」のやり取りが、Web開発の根幹をなす仕組みです。Webフレームワークは、このリクエストを受け取り、適切な処理を行い、レスポンスを返すまでの一連の流れを効率的に開発するためのツールです。

2. Webフレームワークとは？なぜFlaskを選ぶのか？

もしWebフレームワークを使わずにWebアプリケーションをゼロから開発するとしたらどうなるでしょうか？

  • リクエストの解析（どのURLにアクセスされたか、どんなデータが送られてきたかなど）
  • URLに応じた適切な処理の実行
  • データベースとの連携
  • ユーザー認証やセッション管理
  • セキュリティ対策
  • レスポンスの生成（HTMLの組み立て、データの整形など）

これらすべてを自力で実装しなければなりません。これは非常に大変で、時間もかかり、セキュリティ上のリスクも高まります。

そこで登場するのがWebフレームワークです。Webフレームワークは、これらの定型的な処理や共通の機能があらかじめ用意された骨組み（フレームワーク）を提供してくれます。開発者はアプリケーション固有のロジック（例えば「ユーザーが商品をカートに入れたときの処理」など）に集中できるようになります。

Pythonにはいくつかの有名なWebフレームワークがありますが、代表的なものにFlaskとDjangoがあります。

  • Django: 「フルスタックフレームワーク」と呼ばれ、Web開発に必要な多くの機能（ORMによるデータベース操作、管理画面、認証システムなど）が最初から「バッテリー同梱」のように含まれています。大規模なアプリケーション開発や、決まったレールに沿って開発を進めたい場合に適しています。
  • Flask: 「マイクロフレームワーク」と呼ばれます。これは、必要最低限のコア機能（リクエストハンドリング、ルーティング、テンプレートエンジンなど）だけを提供することを意味します。データベース操作や認証などの機能は含まれておらず、必要に応じて拡張機能（Extension）を組み合わせて使います。

なぜFlaskを選ぶのか？

特にWeb開発の初心者にとって、Flaskは優れた選択肢となり得ます。

  1. シンプルさ: コード量が少なく、基本的な概念を理解しやすいです。学習曲線が緩やかで、Web開発の基本的な流れを掴むのに最適です。
  2. 柔軟性: 必要最低限の機能しかないため、開発者が使いたいライブラリやツールを自由に選べます。特定の技術スタックに縛られたくない場合に有利です。
  3. 小〜中規模アプリケーション: 小規模なWebサイト、APIサービス、プロトタイプの開発に非常に向いています。
  4. 学習リソース: 多くのチュートリアルやドキュメントが公開されており、困ったときに情報を探しやすです。

もちろん、Djangoも素晴らしいフレームワークであり、大規模開発ではDjangoの「おまかせ」機能が役立つ場面も多いです。しかし、まずはWebアプリケーションがどのように動いているのか、その基本的な仕組みを理解し、手を動かしてみたいという方には、Flaskのシンプルさが大きなアドバンテージとなります。

この記事では、Flaskの基本的な使い方を通じて、Web開発のコアな部分を体験していきます。

3. 開発環境の準備

Flaskを使い始める前に、必要なものを準備しましょう。

3.1. Pythonのインストール

FlaskはPythonで動作するため、まずはPythonがコンピューターにインストールされている必要があります。多くのオペレーティングシステム（macOSや主要なLinuxディストリビューション）には最初からPythonがインストールされていますが、最新版を使うことをお勧めします。

Pythonの公式ウェブサイト（https://www.python.org/）からお使いのOSに合ったインストーラーをダウンロードしてインストールしてください。インストール中に「Add Python to PATH」（環境変数PATHにPythonを追加する）のようなオプションがあれば、チェックを入れておくことをお勧めします。

インストールが完了したら、ターミナル（またはコマンドプロンプト）を開き、以下のコマンドを実行してPythonが正しくインストールされているか確認します。

“`bash
python –version

または

python3 –version
“`

バージョン番号が表示されれば成功です。以降の記事では、python コマンドでPythonが実行できるものとします。もし python3 でしか実行できない場合は、適宜コマンドを読み替えてください。

3.2. 仮想環境の利用（推奨）

Web開発では、プロジェクトごとに異なるライブラリのバージョンを使用することがよくあります。例えば、あるプロジェクトではFlaskの古いバージョンが必要だが、別のプロジェクトでは最新バージョンを使いたい、といった場合です。このような問題を解決するために、「仮想環境（Virtual Environment）」を利用することが強く推奨されます。

仮想環境は、プロジェクトごとに独立したPythonの実行環境を作成するものです。仮想環境の中にインストールされたライブラリは、システム全体や他の仮想環境には影響しません。

Python 3.3以降には venv という仮想環境を作成・管理する標準ライブラリが付属しています。これを使ってみましょう。

まず、プロジェクトを作成したいディレクトリに移動します。

bash
mkdir myflaskapp
cd myflaskapp

次に、仮想環境を作成します。環境の名前は任意ですが、.venv や venv が一般的です。

bash
python -m venv .venv

これで、myflaskapp ディレクトリの中に .venv というディレクトリが作成されます。これがあなたの仮想環境です。

次に、この仮想環境を「アクティベート」（有効化）します。アクティベートすることで、そのターミナルセッションでは、仮想環境内のPythonやpipコマンドが使われるようになります。

  • macOS / Linux:
    bash
    source .venv/bin/activate
  • Windows (Command Prompt):
    cmd
    .venv\Scripts\activate.bat
  • Windows (PowerShell):
    powershell
    .venv\Scripts\Activate.ps1

仮想環境がアクティベートされると、ターミナルのプロンプトの先頭に仮想環境の名前（通常は .venv）が表示されるようになります。

bash
(.venv) $

これで仮想環境の準備は完了です。

仮想環境を使い終えたら、以下のコマンドでディアクティベート（無効化）できます。

bash
deactivate

3.3. Flaskのインストール

仮想環境をアクティベートした状態で、pipコマンドを使ってFlaskをインストールします。

bash
(.venv) $ pip install Flask

インストールが完了すると、Flaskとその依存ライブラリが .venv ディレクトリ内の site-packages にインストールされます。

インストールされたパッケージを確認するには、以下のコマンドを使います。

bash
(.venv) $ pip list

Flask がリストに含まれていれば成功です。

これでFlaskを使ったWeb開発を始める準備が整いました！

4. 最初のFlaskアプリケーション「Hello, World!」

いよいよ、Flaskを使って最初のWebアプリケーションを作成しましょう。目標は、ブラウザに「Hello, World!」と表示させる簡単なアプリケーションです。

仮想環境がアクティベートされたターミナルで、myflaskapp ディレクトリにいることを確認してください。

テキストエディタを開き、app.py という名前で以下のコードを記述して保存してください。

“`python

app.py

from flask import Flask

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

name は現在のモジュール（ファイル）の名前

Flaskはこれを使ってテンプレートや静的ファイルの場所を特定する

app = Flask(name)

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

アプリケーションのルートURL (‘/’) にアクセスがあった場合に

以下の hello() 関数が実行される

@app.route(‘/’)
def hello():
return ‘Hello, World!’

アプリケーションを実行する

デバッグモードを有効にすると、コード変更時に自動でサーバーが再起動されたり、

エラー発生時にブラウザで詳細なデバッグ情報が表示されたりする（開発時のみ推奨）

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

この短いコードが、あなたの最初のWebアプリケーションです。それぞれの行が何をしているのか見ていきましょう。

  • from flask import Flask: Flaskライブラリから Flask クラスをインポートしています。
  • app = Flask(__name__): Flask クラスのインスタンスを作成しています。このインスタンスがあなたのWebアプリケーションそのものになります。引数に渡している __name__ は、実行中のPythonスクリプトの名前です。Flaskはこの名前を使って、関連ファイル（テンプレートや静的ファイルなど）の場所を決定します。
  • @app.route('/'): これは「デコレーター」と呼ばれるPythonの構文です。このデコレーターは、直下にある関数（hello 関数）がどのURLパスに対するリクエストを処理するかを指定します。ここでは '/'、つまりWebサイトのルート（トップページ）にアクセスがあった場合に hello 関数が実行されるように設定しています。
  • def hello(): return 'Hello, World!': これが「ビュー関数（またはルートハンドラー）」と呼ばれるものです。指定されたURL（この場合は '/'）にアクセスがあったときに実行されるPython関数です。この関数が返す値（ここでは 'Hello, World!' という文字列）が、ブラウザに対するレスポンスとして送り返されます。デフォルトでは、文字列はHTMLとして扱われます。
  • if __name__ == '__main__': app.run(debug=True): この部分は、スクリプトが直接実行された場合にFlask開発サーバーを起動するための慣用的な記述です。app.run() がサーバーを起動するコマンドです。debug=True はデバッグモードを有効にする設定で、開発中に役立ちます。本番環境では debug=False にするか、このオプションを指定しません。

4.1. アプリケーションを実行する

app.py ファイルを保存したら、仮想環境がアクティベートされたターミナルで、app.py があるディレクトリに移動し、以下のコマンドを実行してください。

bash
(.venv) $ python app.py

サーバーが起動し、以下のような出力が表示されるはずです（正確な内容は環境によって異なる場合があります）。

(.venv) $ python app.py
* Serving Flask app 'app' (lazy loading)
* Environment: development
* Debug mode: on
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

これは、Flask開発サーバーが http://127.0.0.1:5000/ というアドレスで待ち受けを開始したことを示しています。127.0.0.1 はあなたのコンピューター自身を指す特別なIPアドレス（localhost）で、5000 はポート番号です。Flask開発サーバーはデフォルトでポート5000を使用します。

4.2. ブラウザで確認する

お使いのWebブラウザを開き、アドレスバーに http://127.0.0.1:5000/ と入力してEnterキーを押してください。

ブラウザの画面に「Hello, World!」と表示されれば成功です！

ターミナルに戻ると、あなたがブラウザでアクセスした際のリクエスト情報が表示されているはずです。

127.0.0.1 - - [Date and Time] "GET / HTTP/1.1" 200 -

GET / HTTP/1.1 は、ブラウザがルートURL（/）に対してGETリクエストを送信したことを示します。200 - は、サーバーがリクエストを正常に処理し、ステータスコード200 (OK) を返したことを示します。

サーバーを停止するには、ターミナルで Ctrl + C を押してください。

これで、Webブラウザからのリクエストを受け取り、Pythonコードを実行し、結果をブラウザに返すという、Webアプリケーションの基本的なサイクルを体験しました。

5. ルーティングとビュー関数

前述の例では、ルートURL（/）に対するリクエストだけを処理しました。しかし、実際のWebサイトには様々なページがあります（例: /about, /contact, /products）。Flaskでは、@app.route() デコレーターを使って、異なるURLパスにアクセスがあったときに実行する関数を複数定義できます。

5.1. 複数のルートを定義する

app.py を以下のように修正してみましょう。

“`python

app.py

from flask import Flask

app = Flask(name)

@app.route(‘/’)
def index():
return ‘

ようこそ！

これはトップページです。

‘

@app.route(‘/about’)
def about():
return ‘

このサイトについて

Flask入門の記事です。

‘

@app.route(‘/contact’)
def contact():
return ‘

お問い合わせ

連絡先はこちら。

‘

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

変更したら app.py を保存し、ターミナルで再度 python app.py を実行してサーバーを起動します。

ブラウザで以下のURLにアクセスしてみてください。

  • http://127.0.0.1:5000/ -> “ようこそ！” のページ
  • http://127.0.0.1:5000/about -> “このサイトについて” のページ
  • http://127.0.0.1:5000/contact -> “お問い合わせ” のページ

それぞれのURLに対して、対応するビュー関数が実行され、その戻り値が表示されることがわかります。戻り値としてHTMLタグを含む文字列を返すことで、簡単なHTMLページを表示できます。

5.2. URLに変数を含める（Variable Rules）

URLの一部を動的に変化させたい場合があります。例えば、ユーザーのプロフィールページを /users/<username> のように表現したい場合などです。Flaskでは、ルート定義の中で <変数名> の形式を使ってこれを実現できます。

修正した app.py です。

“`python

app.py

from flask import Flask

app = Flask(name)

@app.route(‘/’)
def index():
return ‘トップページ’

部分は動的に変わる変数として扱われる

@app.route(‘/user/‘)
def show_user_profile(username):
# 変数名（username）はビュー関数の引数として渡される
return f’ユーザー: {username}’

は post_id を整数として扱うことを指定

@app.route(‘/post/‘)
def show_post(post_id):
# post_id は整数型の引数として渡される
return f’ポストID: {post_id}’

はスラッシュを含むパス全体を変数として扱う

@app.route(‘/path/‘)
def show_subpath(subpath):
return f’サブパス: {subpath}’

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

サーバーを再起動して、以下のURLにアクセスしてみてください。

  • http://127.0.0.1:5000/user/alice -> “ユーザー: alice”
  • http://127.0.0.1:5000/user/bob -> “ユーザー: bob”
  • http://127.0.0.1:5000/post/123 -> “ポストID: 123”
  • http://127.0.0.1:5000/post/hello -> 404 Not Found (intコンバータによる型チェック)
  • http://127.0.0.1:5000/path/a/b/c -> “サブパス: a/b/c”

このように、<変数名> を使うことで動的なURLに対応できます。さらに、<型:変数名> の形式で、変数の型を指定することも可能です。Flaskには以下の標準コンバーターが用意されています。

  • string: デフォルト。スラッシュを含まない任意の文字列。
  • int: 正の整数。
  • float: 正の浮動小数点数。
  • path: スラッシュを含む任意の文字列（ファイルパスなどに便利）。
  • uuid: UUID文字列。

5.3. HTTPメソッドを指定する

Webブラウザからのリクエストには、GET, POST, PUT, DELETEなどのHTTPメソッドがあります。GETは情報取得、POSTはデータ送信（フォーム送信など）によく使われます。デフォルトでは、@app.route() はGETリクエストのみを受け付けます。methods 引数を使うことで、受け付けるHTTPメソッドを指定できます。

“`python

app.py

from flask import Flask, request # requestオブジェクトをインポート

app = Flask(name)

@app.route(‘/submit’, methods=[‘GET’, ‘POST’])
def submit():
if request.method == ‘POST’:
# POSTリクエストの場合はフォームデータを取得
name = request.form.get(‘name’) # の値を取得
return f’こんにちは、{name}さん！ (POST)’
else:
# GETリクエストの場合は入力フォームを表示（簡易版）
return ”’

名前を入力してください:

”’

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

サーバーを起動し、http://127.0.0.1:5000/submit にアクセスしてみてください。

最初はGETリクエストとして処理され、簡単なHTMLフォームが表示されます。フォームに名前を入力して送信すると、POSTリクエストが /submit に送られ、Flaskは request.method == 'POST' のブロックを実行します。

ここで登場するのが request オブジェクトです。

6. requestオブジェクト：クライアントからの情報を取得する

flask モジュールから request オブジェクトをインポートすることで、ブラウザから送られてきたリクエストに関する詳細な情報にアクセスできます。

“`python
from flask import Flask, request

app = Flask(name)

@app.route(‘/login’, methods=[‘GET’, ‘POST’])
def login():
if request.method == ‘POST’:
# フォームデータの取得
username = request.form.get(‘username’)
password = request.form.get(‘password’)
# 認証処理（ここでは省略）
if username == ‘admin’ and password == ‘secret’:
return ‘ログイン成功！’
else:
return ‘ユーザー名またはパスワードが間違っています。’
else:
# GETリクエストの場合はログインフォームを表示
return ”’

ユーザー名:

パスワード:

”’

@app.route(‘/search’)
def search():
# クエリパラメータの取得
# URLが /search?q=flask&category=web の場合
query = request.args.get(‘q’) # ‘flask’ を取得
category = request.args.get(‘category’) # ‘web’ を取得
if query:
return f’検索語: {query}, カテゴリ: {category}’
else:
return ‘検索語が指定されていません。’

@app.route(‘/headers’)
def show_headers():
# リクエストヘッダーの取得
user_agent = request.headers.get(‘User-Agent’)
return f’あなたのブラウザ情報: {user_agent}’

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

request オブジェクトの主な属性と使い方は以下の通りです。

  • request.method: リクエストのHTTPメソッド (‘GET’, ‘POST’ など) を取得します。
  • request.form: POSTリクエストで送信されたフォームデータ（キー-値ペア）にアクセスできます。request.form.get('キー名') のように使います。キーが存在しない場合は None を返します。request.form['キー名'] とすると、キーが存在しない場合にエラーが発生します。
  • request.args: GETリクエストのURLに含まれるクエリパラメータ（URLの ? 以降の キー=値 のペア）にアクセスできます。使い方は request.form と同様です。
  • request.values: request.form と request.args を両方含む辞書ライクなオブジェクトです。
  • request.json: リクエストボディがJSON形式の場合に、そのデータをPythonの辞書として取得します。API開発でよく使われます。
  • request.files: ファイルアップロードに関するデータにアクセスできます。
  • request.cookies: クライアントから送信されたクッキーにアクセスできます。
  • request.headers: リクエストヘッダーにアクセスできます。request.headers.get('Header-Name') のように使います。
  • request.remote_addr: クライアントのIPアドレスを取得します。

request オブジェクトを使うことで、ユーザーがどのような操作を行い、どのような情報を送信してきたかを、Pythonのコード内で取得・利用できます。

7. テンプレート：HTMLとPythonコードの分離

これまでの例では、ビュー関数から直接HTML文字列を返していました。短いHTMLであれば問題ありませんが、複雑なWebページを生成する場合、Pythonコードの中にHTMLタグを大量に書くのは非常に読みにくく、メンテナンスも困難になります。また、デザインとロジックが混ざってしまい、役割分担が難しくなります。

この問題を解決するのが「テンプレートエンジン」です。テンプレートエンジンを使うと、HTMLファイルの中にPythonの変数や制御構造（if文、for文など）を埋め込むことができ、Pythonコード側からそのテンプレートに変数を渡してHTMLを生成できます。

FlaskはデフォルトでJinja2という強力なテンプレートエンジンをサポートしています。

7.1. テンプレートフォルダの作成

Flaskは、テンプレートファイルを自動的に探す場所として、アプリケーションのルートディレクトリ（app.py がある場所）と同じ階層にある templates という名前のフォルダを見に行きます。

myflaskapp ディレクトリの中に templates という新しいフォルダを作成してください。

“`bash

myflaskapp ディレクトリにいることを確認

mkdir templates
“`

7.2. テンプレートファイルの作成

templates フォルダの中に、index.html という名前で以下のファイルを作成してください。

“`html






{{ title }}

{{ heading }}

{{ message }}

ユーザーリスト

    {% for user in users %}

  • {{ user }}

    • {% endfor %}

{% if show_extra %}

追加情報が表示されています。

{% endif %}

“`

これがJinja2テンプレートの例です。注目すべきは以下の構文です。

  • {{ 変数名 }}: Pythonコードから渡された変数の値を表示します。
  • {% 制御構造 %}: forループやif文などの制御構造を記述します。
  • {# コメント #}: テンプレート内のコメントです。出力されるHTMLには含まれません。

7.3. ビュー関数からテンプレートをレンダリングする

ビュー関数からこのテンプレートを使うには、Flaskから render_template 関数をインポートし、それを使います。

app.py を以下のように修正します。

“`python

app.py

from flask import Flask, render_template # render_template をインポート

app = Flask(name)

@app.route(‘/’)
def index():
# テンプレートに渡すデータをPythonの変数として準備
page_title = “私のFlaskアプリ”
page_heading = “Flaskへようこそ！”
greeting_message = “これはテンプレートを使って表示しています。”
user_list = [“Alice”, “Bob”, “Charlie”]
show_extra_info = True # if文の条件として使う真偽値

# render_template 関数でテンプレートをレンダリング
# 第一引数にテンプレートファイル名、
# その後のキーワード引数でテンプレートに渡す変数を指定
return render_template(
    'index.html',
    title=page_title,
    heading=page_heading,
    message=greeting_message,
    users=user_list,
    show_extra=show_extra_info
)

@app.route(‘/about’)
def about():
return render_template(
‘about.html’, # 存在しないテンプレートファイルも指定可能（エラーになる）
title=”サイトについて”
)

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

サーバーを起動し、http://127.0.0.1:5000/ にアクセスしてみてください。

templates/index.html が読み込まれ、Pythonコードから渡された変数 page_title, page_heading, greeting_message, user_list, show_extra_info の値が埋め込まれて表示されるはずです。{% for user in users %} ブロックでユーザーリストが、{% if show_extra %} ブロックで追加情報が表示されていることを確認してください。

このように、render_template を使うことで、PythonコードとHTMLの記述を分離し、より分かりやすくメンテナンスしやすいコード構造にできます。

/about ルートにアクセスすると、about.html というテンプレートファイルを探しますが、まだ作成していないためエラーが表示されるはずです。このように、render_template は指定されたファイルが見つからない場合はエラーになります。

7.4. テンプレートの継承 (Template Inheritance)

多くのWebサイトでは、ヘッダー、フッター、ナビゲーションバーなど、共通の要素を持つページが多数存在します。これらの共通部分をすべてのテンプレートファイルにコピー＆ペーストするのは非効率的です。Jinja2のテンプレート継承機能を使うと、共通のレイアウトを定義し、各ページ固有の内容だけを記述することで、コードの重複を防ぎ、効率的に開発できます。

まず、共通のレイアウトを定義するベーステンプレートを作成します。templates フォルダに base.html という名前でファイルを作成してください。

“`html






{% block title %}My Flask App{% endblock %}

My Awesome Website

{# このブロックを子テンプレートで上書きする #}
{% block content %}{% endblock %}

© 2023 My Flask App


“`

このテンプレートでは、{% block ブロック名 %}{% endblock %} という構文を使っています。これは「ブロック」と呼ばれる領域を定義し、子テンプレートでこのブロックの内容を上書きできることを示しています。

  • title ブロック: ページのタイトルを定義しています。デフォルト値として “My Flask App” が設定されています。
  • content ブロック: 各ページ固有の主要なコンテンツを記述する場所です。

また、<link> タグの中に {{ url_for('static', filename='style.css') }} という見慣れない記述がありますね。これは後述する url_for 関数と静的ファイルに関するものです。

次に、このベーステンプレートを継承する子テンプレートを作成します。先ほど作った templates/index.html の内容を以下のように書き換えてください。

“`html

{# base.html テンプレートを継承することを宣言 #}
{% extends ‘base.html’ %}

{# base.html の title ブロックの内容を上書き #}
{% block title %}ホーム – My Flask App{% endblock %}

{# base.html の content ブロックの内容を上書き #}
{% block content %}

トップページ

これはテンプレート継承を使ったトップページです。

<h2>ユーザーリスト</h2>
<ul>
    {% for user in users %}
        <li>{{ user }}</li>
    {% endfor %}
</ul>

{% if show_extra %}
    <p>追加情報が表示されています。</p>
{% endif %}

{% endblock %}
“`

{% extends 'base.html' %} で、このテンプレートが base.html を継承することを宣言しています。そして、{% block title %} と {% block content %} で、ベーステンプレートで定義された同名のブロックの内容を上書きしています。ベーステンプレートで定義されていない部分はそのまま利用されます（header, footer など）。

app.py の index 関数は、テンプレートファイル名を 'index.html' に指定するだけで、コードの変更は不要です。

“`python

app.py (一部抜粋)

from flask import Flask, render_template, url_for # url_for もインポート

app = Flask(name)

@app.route(‘/’)
def index():
page_heading = “Flaskへようこそ！” # この変数はindex.htmlで使われないが、例として残す
greeting_message = “これはテンプレートを使って表示しています。” # 同上
user_list = [“Alice”, “Bob”, “Charlie”, “David”] # ユーザーリストを増やしてみる
show_extra_info = True

return render_template(
    'index.html',
    heading=page_heading,
    message=greeting_message,
    users=user_list,
    show_extra=show_extra_info
)

@app.route(‘/about’)
def about():
# about.html を作成して継承を使ってみる
return render_template(
‘about.html’,
# title ブロックに渡す値はテンプレート内で直接定義してもOK
# ここではabout.htmlで定義する想定
)

if name == ‘main‘:
# debug=True の場合、コードやテンプレートファイルの変更を検知して自動で再起動してくれる
app.run(debug=True)

“`

ついでに /about 用の子テンプレート templates/about.html も作成しておきましょう。

“`html

{% extends ‘base.html’ %}

{% block title %}サイトについて – My Flask App{% endblock %}

{% block content %}

このサイトについて

このサイトは、Python Flask入門の記事のデモです。

テンプレート継承の仕組みを学ぶために作成されました。

{% endblock %}
“`

サーバーを起動し、http://127.0.0.1:5000/ と http://127.0.0.1:5000/about にアクセスしてみてください。

どちらのページも共通のヘッダー、ナビゲーション、フッターが表示され、中央のコンテンツ部分だけがそれぞれのテンプレートファイル (index.html, about.html) で定義した内容になっているはずです。このように、テンプレート継承はコードの再利用性を高め、開発効率を向上させます。

8. 静的ファイル：CSS, JavaScript, 画像

WebサイトはHTMLだけでなく、スタイルを定義するCSS、動的な要素を追加するJavaScript、そして画像ファイルなども必要とします。これらの、サーバー側で特別な処理をせずにそのままブラウザに送り返されるファイルを「静的ファイル（Static Files）」と呼びます。

Flaskは、静的ファイルを配信するための仕組みを内蔵しています。デフォルトでは、アプリケーションのルートディレクトリと同じ階層にある static という名前のフォルダ内のファイルを静的ファイルとして扱います。

8.1. staticフォルダの作成

myflaskapp ディレクトリの中に static という新しいフォルダを作成してください。

“`bash

myflaskapp ディレクトリにいることを確認

mkdir static
“`

8.2. 静的ファイルの配置

static フォルダの中に、さらに css フォルダを作成し、その中に style.css という名前でファイルを作成してみましょう。

“`bash

myflaskapp/static ディレクトリにいることを確認

mkdir css
“`

static/css/style.css ファイルを作成し、以下のCSSを記述します。

“`css
/ static/css/style.css /
body {
font-family: sans-serif;
margin: 0;
padding: 0;
background-color: #f4f4f4;
color: #333;
}

header {
background-color: #333;
color: #fff;
padding: 10px 0;
text-align: center;
}

nav a {
color: #fff;
margin: 0 10px;
text-decoration: none;
}

.content {
margin: 20px;
padding: 20px;
background-color: #fff;
border-radius: 8px;
box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
}

footer {
text-align: center;
padding: 10px;
margin-top: 20px;
color: #777;
font-size: 0.9em;
}
“`

8.3. テンプレートから静的ファイルを参照する

テンプレートファイル（base.html）からこのCSSファイルを参照するには、url_for 関数を使います。既に base.html に記述例がありましたね。

“`html



{% block title %}My Flask App{% endblock %}
{# 静的ファイルを参照 #}
“`

{{ url_for('static', filename='css/style.css') }} は、Flaskが static フォルダ内の css/style.css ファイルへの正しいURLを生成してくれるように指示しています。Flask開発サーバーの場合、これは通常 /static/css/style.css のようなURLになります。

サーバーを起動し、ブラウザでページにアクセスしてみてください。CSSが適用され、Webサイトのデザインが変わっているはずです。

static フォルダには、js フォルダを作成してJavaScriptファイルを置いたり、images フォルダを作成して画像ファイルを置いたりすることもできます。それらをテンプレートから参照する際も、同様に url_for('static', filename='...') を使います。

  • 画像の場合: <img src="{{ url_for('static', filename='images/logo.png') }}" alt="Logo">
  • JavaScriptの場合: <script src="{{ url_for('static', filename='js/script.js') }}"></script>

9. url_for：URL生成の強力な味方

前のセクションで静的ファイルのパスを生成するために url_for 関数を使いました。url_for は、静的ファイルだけでなく、アプリケーション内で定義したルートのURLを生成するためにも非常に役立ちます。

なぜurl_forを使うべきか？

URLを生成する際に、ハードコード（文字列として直接URLを記述すること）するのではなく、url_for を使うことにはいくつかの大きな利点があります。

  1. URLの変更に強い: 例えば /about というURLを /about-us に変更した場合、url_for('about') を使っている箇所はコードを変更する必要がありません。ルート定義 @app.route('/about-us') だけを変更すれば、url_for が自動的に新しいURLを生成してくれます。
  2. タイポ防止: 文字列でURLを記述する場合、タイポによってリンクが壊れる可能性があります。url_for はビュー関数の名前を指定するため、存在しない関数名を指定した場合はプログラム実行前にエラーが発生し、問題に気づきやすいです。
  3. 動的なURLの生成: URLに変数を含む場合 (/user/<username>)、url_for を使うと簡単に正しいURLを生成できます。

url_forの使い方

url_for 関数の第一引数には、対象となるビュー関数の名前（@app.route() デコレーターが付いた def 関数名: の部分の関数名）を指定します。

“`python

app.py (一部抜粋)

from flask import Flask, render_template, url_for

app = Flask(name)

@app.route(‘/’)
def index():
# ‘about’ という名前のビュー関数へのURLを生成
about_page_url = url_for(‘about’)
print(f”Generated URL for ‘about’: {about_page_url}”) # ターミナルに表示
return render_template(‘index.html’) # テンプレート内で使う例は以下

@app.route(‘/about’)
def about():
return render_template(‘about.html’)

変数を含むルート

@app.route(‘/user/‘)
def show_user_profile(username):
return f’ユーザー: {username}’

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

テンプレート内で url_for を使う場合は、{{ url_for(...) }} のように波括弧で囲みます。

“`html

    <nav>
        {# index 関数のURLを生成 #}
        <a href="{{ url_for('index') }}">ホーム</a>
        {# about 関数のURLを生成 #}
        <a href="{{ url_for('about') }}">サイトについて</a>
        {# show_user_profile 関数のURLを生成、username 変数に 'alice' を渡す #}
        <a href="{{ url_for('show_user_profile', username='alice') }}">Aliceのプロフィール</a>
    </nav>

“`

変数を含むルートのURLを生成する場合は、キーワード引数として変数名とその値を渡します。url_for('show_user_profile', username='alice') とすると、/user/alice というURLが生成されます。

url_for はFlask開発における必須の関数と言えます。リンクやリダイレクトなど、URLが必要な箇所では積極的に url_for を使うようにしましょう。

10. リダイレクトとエラー処理

Webアプリケーションでは、あるページから別のページへユーザーを移動させたり（リダイレクト）、存在しないページにアクセスがあった場合にエラーページを表示したりする機能が必要です。

10.1. リダイレクト (Redirect)

ユーザーを別のURLに移動させるには、Flaskの redirect 関数と url_for 関数を組み合わせて使います。

“`python

app.py (一部抜粋)

from flask import Flask, render_template, url_for, redirect # redirect をインポート

app = Flask(name)

@app.route(‘/’)
def index():
return ‘トップページ’

@app.route(‘/old-url’)
def old_url():
# /new-url にリダイレクト
return redirect(url_for(‘new_url’)) # url_for を使って新しいURLを生成

@app.route(‘/new-url’)
def new_url():
return ‘新しいページです！’

フォーム送信後に別のページにリダイレクトする例

@app.route(‘/submit-and-redirect’, methods=[‘POST’])
def submit_and_redirect():
# フォーム処理（ここでは省略）
print(“フォームが送信されました！”)
# 処理完了後、トップページにリダイレクト
return redirect(url_for(‘index’))

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

サーバーを起動し、http://127.0.0.1:5000/old-url にアクセスしてみてください。自動的に /new-url にリダイレクトされ、「新しいページです！」と表示されるはずです。

リダイレクトは、ページのURL変更、フォーム送信後のページ遷移、ログイン後のページ遷移など、様々な場面で利用されます。

10.2. エラー処理 (Error Handling)

存在しないページにアクセスした場合、Flaskはデフォルトで「404 Not Found」エラーページを表示します。また、サーバー内部で予期せぬエラーが発生した場合は「500 Internal Server Error」を表示します。これらのデフォルトのエラーページはシンプルですが、ユーザーフレンドリーではありません。Flaskでは、独自のエラーページをカスタマイズできます。

@app.errorhandler() デコレーターを使って、特定のHTTPエラーコードが発生した場合に実行される関数を定義します。

“`python

app.py (一部抜粋)

from flask import Flask, render_template, url_for, redirect, abort # abort をインポート

app = Flask(name)

カスタム404エラーページ

@app.errorhandler(404)
def page_not_found(error):
# error オブジェクトにはエラーの詳細が含まれている
# 404 エラー発生時に templates/404.html を表示する
# 第二引数でステータスコード 404 を明示的に指定する
return render_template(‘404.html’), 404

意図的に404エラーを発生させる例

@app.route(‘/make-error’)
def make_error():
# abort 関数を使うと、指定したHTTPステータスコードでリクエストを中断できる
abort(404)
# abort が実行されると、以降のコードは実行されない

カスタム500エラーページ (デバッグモード有効時は表示されないことがある)

@app.errorhandler(500)
def internal_server_error(error):
# 500 エラー発生時に templates/500.html を表示する
return render_template(‘500.html’), 500

意図的に500エラーを発生させる例

@app.route(‘/make-500’)
def make_500():
# 例外を発生させて500エラーにする
result = 1 / 0 # ZeroDivisionError を発生させる
return “この行は実行されません”

if name == ‘main‘:
# デバッグモード有効時は、エラー時に詳細な情報が表示される（開発用）
# 本番環境では debug=False にするか、設定しないのが基本
app.run(debug=True)
“`

カスタムエラーページ用のテンプレートファイルを作成します。

templates/404.html:

“`html

{% extends ‘base.html’ %}

{% block title %}ページが見つかりません – {{ super() }}{% endblock %} {# super() で親テンプレートのブロック内容を呼び出す #}

{% block content %}

404 – ページが見つかりません

お探しのページは見つかりませんでした。

ホームに戻る

{% endblock %}
“`

templates/500.html:

“`html

{% extends ‘base.html’ %}

{% block title %}サーバーエラー – {{ super() }}{% endblock %}

{% block content %}

500 – 内部サーバーエラー

申し訳ありません、サーバーで予期せぬエラーが発生しました。

ホームに戻る

{% endblock %}
“`

サーバーを再起動し、以下のURLにアクセスしてみてください。

  • http://127.0.0.1:5000/non-existent-page -> カスタム404ページが表示される
  • http://127.0.0.1:5000/make-error -> カスタム404ページが表示される
  • http://127.0.0.1:5000/make-500 -> debug=True の場合は詳細なエラーページ、debug=False の場合はカスタム500ページが表示される

abort(ステータスコード) 関数は、ビュー関数の実行を中断し、指定したステータスコードのエラーを発生させたい場合に便利です。例えば、ユーザーがアクセス権限を持っていない場合に abort(403)（Forbidden）を返す、といった使い方をします。

カスタムエラーページを用意することで、エラー発生時でもユーザーに分かりやすい情報を提供し、サイトの見た目を統一できます。

11. Blueprints：アプリケーションの分割と構造化

これまでの例では、すべてのルートとビュー関数を一つの app.py ファイルに記述してきました。小規模なアプリケーションであればこれで問題ありませんが、アプリケーションが大きくなるにつれて、コードが肥大化し、管理が難しくなってきます。

Flaskでは、「Blueprint（ブループリント）」という機能を使って、アプリケーションを複数のモジュール（部品）に分割し、整理することができます。各Blueprintは独立したルーティング、テンプレート、静的ファイルを持つことができ、それらを後からメインのFlaskアプリケーションに「登録」してまとめます。

例えば、ユーザー認証関連の機能（ログイン、ログアウト、登録）をまとめたBlueprintや、ブログ機能（記事一覧、詳細、作成）をまとめたBlueprintなどを作成することができます。

11.1. Blueprintの作成

まず、Blueprintを格納するためのディレクトリを作成します。例えば、auth という認証機能用のBlueprintを作成する場合、myflaskapp ディレクトリの中に auth というフォルダを作成し、その中に __init__.py と routes.py ファイルを作成します。

“`bash

myflaskapp ディレクトリにいることを確認

mkdir auth
touch auth/init.py auth/routes.py
“`

auth/routes.py に、認証関連のルートとビュー関数を定義します。ただし、ここでは app.route ではなく、Blueprintインスタンスに対してルートを定義します。

auth/__init__.py:

“`python

auth/init.py

from flask import Blueprint

Blueprintインスタンスを作成

‘auth’ はBlueprintの名前、name はモジュールの名前

auth_bp = Blueprint(‘auth’, name,
template_folder=’templates’, # このBlueprint専用のテンプレートフォルダを指定
static_folder=’static’) # このBlueprint専用の静的フォルダを指定

ルーティングを定義したファイルをインポート

これにより、auth_bp に定義されたルートが有効になる

from . import routes
“`

auth/routes.py:

“`python

auth/routes.py

from flask import render_template, redirect, url_for, request

同じディレクトリにある init.py から Blueprint インスタンスをインポート

from . import auth_bp # auth_bp をインポート

@auth_bp.route(‘/login’, methods=[‘GET’, ‘POST’])
def login():
if request.method == ‘POST’:
username = request.form.get(‘username’)
password = request.form.get(‘password’)
# 認証処理…
if username == ‘user’ and password == ‘pass’:
# 認証成功後の処理
# ここで session などを使ってログイン状態を保持するのが一般的（後述）
print(“ログイン成功！”)
return redirect(url_for(‘index’)) # メインアプリの index ルートへリダイレクト
else:
# 認証失敗
print(“ログイン失敗！”)
return render_template(‘auth/login.html’, error=”ユーザー名またはパスワードが間違っています。”)
# GETリクエストの場合
return render_template(‘auth/login.html’)

@auth_bp.route(‘/logout’)
def logout():
# ログアウト処理…
print(“ログアウトしました。”)
return redirect(url_for(‘index’)) # メインアプリの index ルートへリダイレクト

@auth_bp.route(‘/register’)
def register():
return “ユーザー登録ページ (未実装)”

“`

Blueprintにも独自のテンプレートや静的ファイルを関連付けることができます。デフォルトでは、Blueprintのディレクトリ内にある templates および static フォルダを見に行きます。Blueprint のインスタンスを作成する際に template_folder や static_folder を明示的に指定することも可能です。

templates フォルダの中に、auth フォルダを作成し、login.html を作成します。

“`bash

myflaskapp/templates ディレクトリにいることを確認

mkdir auth
“`

templates/auth/login.html:

“`html

{% extends ‘base.html’ %}

{% block title %}ログイン – {{ super() }}{% endblock %}

{% block content %}

ログイン

{% if error %}
    <p style="color: red;">{{ error }}</p>
{% endif %}

<form method="post">
    <p>ユーザー名: <input type="text" name="username"></p>
    <p>パスワード: <input type="password" name="password"></p>
    <p><input type="submit" value="ログイン"></p>
</form>

{% endblock %}
“`

11.2. Blueprintをメインアプリケーションに登録する

Blueprintを作成したら、それをメインのFlaskアプリケーションインスタンスに登録する必要があります。これは app.register_blueprint() メソッドで行います。

app.py を以下のように修正します。

“`python

app.py

from flask import Flask, render_template, url_for
from auth import auth_bp # auth Blueprintをインポート

app = Flask(name)

Blueprintをアプリケーションに登録

app.register_blueprint(auth_bp)

メインアプリのルート

@app.route(‘/’)
def index():
return render_template(‘index.html’, users=[“Alice”, “Bob”, “Charlie”]) # index.html に渡すデータは適宜修正

@app.route(‘/about’)
def about():
return render_template(‘about.html’)

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

“`

これで、auth_bp に定義されたルート (/login, /logout, /register) が、メインアプリケーションのルートとして有効になります。

11.3. Blueprint内のURL生成

Blueprint内で定義されたビュー関数へのURLを生成する場合、url_for 関数の第一引数に blueprint名.関数名 の形式で指定します。

  • url_for('auth.login') -> /login (auth Blueprint内のlogin関数)
  • url_for('auth.logout') -> /logout (auth Blueprint内のlogout関数)
  • url_for('index') -> / (メインアプリケーションのindex関数)

auth/routes.py の中で redirect(url_for('index')) としている箇所がその例です。メインアプリケーションのルートを参照しています。

Blueprintはアプリケーションをモジュール化するための強力な機能です。アプリケーションの規模が大きくなってきたら、機能ごとにBlueprintに分割することを検討しましょう。

12. セッション：ユーザーの状態を保持する

HTTPは本来ステートレスなプロトコルです。つまり、サーバーは個々のリクエストがお互いに無関係であると見なします。しかし、Webアプリケーションでは、ユーザーがログインしているか、ショッピングカートに何が入っているかなど、ユーザーの状態を複数のリクエスト間で保持する必要があります。

このために「セッション（Session）」が利用されます。Flaskのセッションは、ユーザーごとにサーバー側に情報を一時的に保存し、そのユーザーを識別するための小さな情報（セッションID）をブラウザのクッキーに保存する仕組みです。ユーザーからのリクエストがあるたびに、ブラウザはセッションIDを含むクッキーをサーバーに送信し、サーバーはそのIDを使って該当するセッションデータを取り出します。

Flaskでセッションを使うには、まずアプリケーションに「秘密鍵（Secret Key）」を設定する必要があります。これは、セッションデータを暗号化および署名するために使われる重要な鍵です。秘密鍵が設定されていないと、セッション機能は利用できません。

12.1. 秘密鍵の設定

秘密鍵は、推測されにくいランダムな文字列にする必要があります。開発中は簡単な文字列でも構いませんが、本番環境では強固な鍵を使い、外部に漏れないように厳重に管理する必要があります。

“`python

app.py (秘密鍵の設定を追加)

from flask import Flask, render_template, url_for, redirect, request, session # session をインポート
from auth import auth_bp

app = Flask(name)

強固な秘密鍵を設定する！開発中は簡単でもOK

app.config[‘SECRET_KEY’] = ‘your_very_secret_key_that_no_one_can_guess’

app.register_blueprint(auth_bp)

メインアプリのルート

@app.route(‘/’)
def index():
# セッションからユーザー名を取得
username = session.get(‘username’)
if username:
message = f'{username}さん、ようこそ！’
else:
message = ‘ゲストさん、ようこそ！ログインしてください。’

return render_template('index.html', message=message, users=["Alice", "Bob", "Charlie"]) # index.html に message 変数を渡すように修正

templates/index.html に message を表示する部分を追加

… の中にでも追加してください

{{ message }}

@app.route(‘/about’)
def about():
return render_template(‘about.html’)

認証Blueprint内の login 関数を修正してセッションを使う

auth/routes.py を以下のように修正

“`

12.2. セッションデータの操作

セッションデータは、Pythonの辞書のように session['キー'] = 値 や session.get('キー')、session.pop('キー', None) のように操作できます。

auth/routes.py を修正し、ログイン成功時にセッションにユーザー名を保存するようにします。

“`python

auth/routes.py

from flask import render_template, redirect, url_for, request, session # session をインポート
from . import auth_bp

@auth_bp.route(‘/login’, methods=[‘GET’, ‘POST’])
def login():
if request.method == ‘POST’:
username = request.form.get(‘username’)
password = request.form.get(‘password’)

    if username == 'user' and password == 'pass':
        # **ログイン成功**
        # セッションにユーザー名を保存
        session['username'] = username # 'username' というキーでセッションに保存
        print(f"{username} がログインしました！")
        return redirect(url_for('index')) # トップページにリダイレクト
    else:
        # 認証失敗
        error = "ユーザー名またはパスワードが間違っています。"
        print("ログイン失敗！")
        return render_template('auth/login.html', error=error)
# GETリクエストの場合
return render_template('auth/login.html')

@auth_bp.route(‘/logout’)
def logout():
# ログアウト処理
# セッションからユーザー名を削除
session.pop(‘username’, None) # ‘username’ というキーがあれば削除する
print(“ログアウトしました。”)
return redirect(url_for(‘index’)) # トップページにリダイレクト

@auth_bp.route(‘/register’)
def register():
return “ユーザー登録ページ (未実装)”

“`

templates/index.html にセッションから取得したメッセージを表示する部分を追加します（前のセクションで示唆した箇所）。

“`html

{% extends ‘base.html’ %}

{% block title %}ホーム – {{ super() }}{% endblock %}

{% block content %}

トップページ

{{ message }}

{# ここにセッションに基づいたメッセージが表示される #}

<h2>ユーザーリスト</h2>
<ul>
    {% for user in users %}
        <li>{{ user }}</li>
    {% endfor %}
</ul>

{% if show_extra %}
    <p>追加情報が表示されています。</p>
{% endif %}

{# ログイン/ログアウトリンクを追加 (base.html に含めても良い) #}
{% if session.get('username') %}
    <p><a href="{{ url_for('auth.logout') }}">ログアウト</a></p>
{% else %}
    <p><a href="{{ url_for('auth.login') }}">ログイン</a></p>
{% endif %}

{% endblock %}
“`

サーバーを再起動し、以下の手順で動作を確認してください。

  1. http://127.0.0.1:5000/ にアクセス -> 「ゲストさん、ようこそ！ログインしてください。」と表示される
  2. http://127.0.0.1:5000/login にアクセス
  3. ユーザー名に user、パスワードに pass を入力してログイン -> トップページにリダイレクトされ、「userさん、ようこそ！」と表示される。
  4. ブラウザを一度閉じて再度開いて http://127.0.0.1:5000/ にアクセス -> まだ「userさん、ようこそ！」と表示される（クッキーに保存されたセッションIDにより状態が維持されているため）
  5. 「ログアウト」リンクをクリック -> トップページにリダイレクトされ、「ゲストさん、ようこそ！ログインしてください。」と表示される。

このように、セッションを使うことでユーザーの状態を管理し、ログイン機能などを実装できます。Flaskのデフォルトセッションはクッキーにデータを保存しますが、これは署名されているため改ざんは困難です。ただし、クッキーに保存できるデータ量には制限があり、機密性の高いデータはセッションではなくデータベースに保存し、セッションにはそのデータを特定するためのIDだけを保存する、といった工夫が必要な場合もあります。

13. 次のステップへ

ここまでで、Flaskを使ったWebアプリケーション開発の基本的な要素（ルーティング、テンプレート、静的ファイル、リクエスト/レスポンス処理、セッション、Blueprint）を学びました。これらはFlaskアプリケーションを構築するための強固な基盤となります。

しかし、実際のWebアプリケーション開発では、さらに多くの機能が必要になります。次に学ぶべき重要なトピックをいくつか紹介します。

  1. データベース連携: ユーザーデータや投稿データなど、アプリケーションのデータを永続的に保存するにはデータベースが必要です。Flaskでは、SQLAlchemyのようなORM (Object-Relational Mapper) を使うのが一般的です。Flask-SQLAlchemy という拡張機能を利用すると、FlaskとSQLAlchemyを簡単に連携させることができます。
  2. フォーム処理: ユーザーからの入力を安全に受け付け、バリデーション（検証）を行うためには、フォームライブラリを使うのが効率的です。Flask-WTF は、PythonでWebフォームを扱うためのWTFormsライブラリをFlaskで使いやすくする拡張機能です。
  3. ユーザー認証と認可: ログイン機能は実装しましたが、ユーザー登録、パスワードのリセット、メールアドレスの確認、役割に基づいたアクセス制限（管理者だけが特定のページにアクセスできるなど）といった機能も必要になることが多いです。Flask-Login や Flask-Security-Too などの拡張機能が役立ちます。
  4. APIの構築: Webアプリケーションのバックエンドとして、モバイルアプリや別のサービスにデータを提供するRESTful APIを構築する場合も多くあります。FlaskはAPI開発にも向いており、JSONレスポンスを簡単に生成できます。
  5. テスト: アプリケーションが正しく動作するかを確認するために、自動テストを書くことは非常に重要です。Flaskはテストを書きやすいように設計されており、テストクライアントを使ってビュー関数へのリクエストをシミュレートできます。
  6. デバッグ: 開発中に発生した問題を効率的に見つけるためのデバッグ手法やツールを学ぶことは、生産性を上げる上で不可欠です。Flaskのデバッグモードはその第一歩です。
  7. デプロイ: 開発したアプリケーションをインターネット上に公開するには、サーバー（例: Gunicorn, uWSGI）を使ってアプリケーションを起動し、Webサーバー（例: Nginx, Apache）と連携させる必要があります。Heroku, AWS, Google Cloud Platform, PythonAnywhereなど、様々なデプロイ先があります。

これらのトピックは、Flaskの公式ドキュメントや、Flask-SQLAlchemy, Flask-WTF, Flask-Login といった拡張機能のドキュメント、あるいは関連するチュートリアルなどで学ぶことができます。Flaskの大きな特徴は、これらの機能がコアに含まれていない代わりに、豊富な拡張機能エコシステムが存在することです。

14. まとめ

この記事では、Python Flaskを使ったWeb開発の基本的な流れを、環境準備からルーティング、テンプレート、静的ファイル、セッション、Blueprintといった主要な概念を網羅して解説しました。

Flaskはシンプルながらも非常に柔軟で強力なフレームワークです。この記事で学んだ基礎があれば、あなたのアイデアをWebアプリケーションとして形にするための第一歩を踏み出せます。

Web開発は広大な分野であり、学ぶことはたくさんありますが、焦らず、一つずつ着実に理解していくことが大切です。まずはこの記事で作成したアプリケーションをベースに、学んだことを試したり、少しずつ機能を追加したりしてみてください。手を動かすことが、理解を深める一番の方法です。

さあ、Flaskを使ったあなたのWeb開発の旅を楽しんでください！

コメントする

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

上部へスクロール