【初心者向け】Python Flask入門：Web開発を始めよう

By /

はい、承知いたしました。Python Flaskの初心者向け入門記事として、詳細な説明を含む約5000語の記事を作成します。

以下に記事の内容を直接表示します。

【初心者向け】Python Flask入門：Web開発を始めよう

はじめに

Web開発の世界に足を踏み入れたいと考えている皆さん、こんにちは！

「Web開発」と聞くと、何やら難しそう、プログラミング言語がたくさんあってどれから手を付ければいいか分からない、というイメージをお持ちかもしれません。確かに、Web開発は多岐にわたる技術の組み合わせですが、適切なツールを使えば、初心者でも楽しく学びながら、実際に動くWebアプリケーションを作ることができます。

そこで今回ご紹介するのが、Pythonというプログラミング言語で動く Flask というフレームワークです。

Pythonは、その読みやすく分かりやすい文法から、プログラミング教育やデータ分析、AI開発など、幅広い分野で人気があります。そしてFlaskは、そんなPythonを使ってWebアプリケーションを効率的に開発するための強力なツールです。

Flaskは「マイクロフレームワーク」と呼ばれており、必要最低限の機能だけを提供しています。これにより、非常にシンプルで分かりやすく、学習コストが低いという大きなメリットがあります。初心者の方でも、Webアプリケーションの基本的な仕組みを理解しながら、無理なく開発を始めることができます。

この記事では、全くの初心者の方でもFlaskを使ったWeb開発を始められるように、以下の内容を詳細に解説していきます。

  1. Flaskとは何か？ なぜFlaskを選ぶのか。
  2. 開発環境の準備 Pythonのセットアップ、仮想環境、Flaskのインストール。
  3. 最初のFlaskアプリケーション “Hello, World!”アプリの作成と実行。
  4. ルーティング URLとPythonの処理を結びつける方法。
  5. テンプレート HTMLを動的に生成する方法（Jinja2）。
  6. 静的ファイル CSS、JavaScript、画像などの扱い方。
  7. リクエストとHTTPメソッド ユーザーからの入力（GET/POST）の取得方法。
  8. フォームの扱い ユーザー入力を受け取るフォーム処理。
  9. リダイレクトとエラーハンドリング ページの遷移やエラー表示。
  10. 簡単なデータベース連携 SQLiteを使ったデータ保存の基本。
  11. アプリケーションの構造化 プロジェクトが大きくなった時の整理方法。
  12. デバッグ アプリケーションのエラーを見つける方法。
  13. 今後のステップ さらに学習を進めるためのヒント。

この記事を通じて、あなたはFlaskを使った基本的なWebアプリケーションの作成方法を学び、Web開発の面白さを体験できるでしょう。さあ、一緒にWeb開発の世界へ旅立ちましょう！

1. Flaskとは何か？なぜFlaskを選ぶのか？

Webフレームワークとは？

Webアプリケーションは、ユーザーからのリクエストを受け取り、それに対して適切なレスポンスを返すという基本的な仕組みで動いています。例えば、ブラウザで特定のURLにアクセスすると、サーバーはそのリクエストを受け取り、要求されたページのHTMLデータをブラウザに返します。

この一連の流れをゼロからすべて自分で書こうとすると、非常に大変です。

  • ネットワーク通信の待ち受け
  • URLの解析
  • GETやPOSTなどのHTTPメソッドの処理
  • クッキーやセッションの管理
  • セキュリティ対策（XSS, CSRFなど）
  • データベースとの連携
  • HTMLの生成

など、考慮すべきことが山ほどあります。

Webフレームワークは、これらのWebアプリケーション開発で共通して必要となる機能や仕組みを、あらかじめ提供してくれる枠組み（フレームワーク）です。フレームワークを使うことで、開発者はアプリケーションの本質的なロジック（何をするアプリなのか）に集中できるようになります。

Flaskとは？

Flaskは、Pythonで書かれたWebアプリケーションフレームワークです。特に「マイクロフレームワーク」として知られています。

「マイクロ」とは、機能が少ないという意味ではなく、コア機能が必要最低限に絞られているという意味です。Flask自体は、以下の基本的な機能を提供します。

  • ルーティング: どのURLにアクセスがあったら、どのPythonコードを実行するかを決める仕組み。
  • リクエスト/レスポンスハンドリング: ユーザーからのリクエスト（URL、データなど）を受け取り、レスポンス（HTML、データなど）を返す仕組み。
  • テンプレートエンジン: HTMLを動的に生成するための仕組み（デフォルトはJinja2）。
  • Werkzeug WSGIツールキット: 低レベルなWebサーバーとのやり取りを抽象化してくれるライブラリ。
  • Jinja2テンプレートエンジン: HTMLファイルの中にPythonのようなコードを書いて、動的に内容を変えるためのライブラリ。

Flaskの大きな特徴は、これらのコア機能以外の多くの部分は、開発者が自分で選択して追加できる点です。例えば、データベースを扱うための機能や、ユーザー認証機能などは、Flask本体には含まれていません。その代わり、様々な便利な「拡張機能（Flask extensions）」が提供されており、必要に応じて pip install で簡単に追加できます。

なぜ初心者にFlaskがおすすめなのか？

Flaskが初心者におすすめされる理由はいくつかあります。

  1. シンプルで分かりやすい: コア機能が絞られているため、全体像を把握しやすく、学習のハードルが低い。最初の「Hello, World!」アプリが驚くほど少ないコードで書けます。
  2. Pythonの知識を活かせる: Pythonの文法やライブラリに関する知識があれば、スムーズに学習できます。Web開発特有の複雑な概念に最初から圧倒されることが少ないです。
  3. 自由度が高い: 必要最低限の機能しかないということは、特定の開発手法やツールを強制されないということです。自分の作りたいものに合わせて、好きなライブラリやデータベースを選択できます。これは、まずは基本的な仕組みを理解するのに適しています。
  4. 豊富なドキュメントとコミュニティ: 世界中で多くの開発者に利用されており、公式ドキュメントも充実しています。困ったことがあっても、インターネットで検索すれば多くの情報や解決策が見つかります。
  5. 小規模から中規模のアプリケーションに適している: ブログ、簡易的な管理画面、APIなど、比較的規模の小さいアプリケーション開発に迅速に取り組めます。

もちろん、Flask以外にもPythonにはDjangoという有名なWebフレームワークがあります。Djangoは「フルスタックフレームワーク」と呼ばれ、データベース連携や管理画面など、多くの機能があらかじめ用意されています。大規模なアプリケーション開発にはDjangoの方が適している場合もありますが、その分学習コストは高めです。

まずはWeb開発の基本的な流れや仕組みを学びたい、手軽にWebアプリケーションを作ってみたい、という方には、Flaskが非常に適していると言えるでしょう。

2. 開発環境の準備

Flaskを使った開発を始める前に、いくつかの準備が必要です。

2.1 Pythonのインストール

FlaskはPythonで動くため、まずはPythonがあなたのコンピューターにインストールされている必要があります。

  • Windows: Microsoft StoreまたはPython公式サイトからインストーラーをダウンロードして実行します。インストール時に「Add Python to PATH」というオプションにチェックを入れるのを忘れないでください。
  • macOS: macOSにはPythonがプリインストールされていることが多いですが、バージョンが古い場合があります。Homebrewなどのパッケージマネージャーを使うか、公式サイトから最新版をインストールするのがおすすめです。
  • Linux: 多くのLinuxディストリビューションにはPythonがプリインストールされています。パッケージマネージャー（apt, yumなど）を使って最新版をインストールできます。

インストール後、ターミナル（Windowsの場合はコマンドプロンプトやPowerShell）を開き、以下のコマンドを入力して、Pythonが正しくインストールされ、パスが通っているか確認しましょう。

“`bash
python –version

または

python3 –version
“`

Python 3.x系のバージョン（例: Python 3.9.10）が表示されればOKです。もし表示されない場合や、Python 2.x系が表示される場合は、Python 3へのパスが通っているか確認してください。以降の記事では python コマンドでPython 3が起動することを前提とします。もし python3 でしか起動しない場合は、適宜コマンドを読み替えてください。

2.2 仮想環境の作成と利用

Web開発では、プロジェクトごとに異なるライブラリのバージョンを使いたいことがよくあります。例えば、あるプロジェクトではFlaskの古いバージョンを使い、別の新しいプロジェクトでは最新バージョンを使いたい、といった場合です。

このような場合に、システム全体にインストールされているPython環境を汚染せず、プロジェクトごとに独立した環境を作るのが「仮想環境」です。仮想環境を使うことで、プロジェクトAでインストールしたライブラリが、プロジェクトBに影響を与えることがなくなります。これは開発において非常に重要な習慣です。

Python 3.3以降には、venv という仮想環境を作成するための標準モジュールが搭載されています。これを使ってみましょう。

まず、プロジェクトを置くための新しいディレクトリを作成し、そこに移動します。

bash
mkdir myflaskapp
cd myflaskapp

次に、このディレクトリの中に仮想環境を作成します。以下のコマンドを実行してください。venv の部分は、作成される仮想環境のディレクトリ名です。慣習として venv や .venv という名前を使うことが多いです。

bash
python -m venv venv

このコマンドを実行すると、myflaskapp ディレクトリの中に venv という新しいディレクトリが作成されます。この venv ディレクトリの中に、独立したPython環境が構築されます。

仮想環境を作成したら、それを使用するために「アクティベート（有効化）」する必要があります。アクティベートの方法はOSによって異なります。

  • macOS/Linux:
    bash
    source venv/bin/activate
  • Windows (コマンドプロンプト):
    bash
    venv\Scripts\activate.bat
  • Windows (PowerShell):
    bash
    venv\Scripts\Activate.ps1

アクティベートに成功すると、ターミナルのプロンプトの先頭に (venv) のような仮想環境名が表示されるようになります。これは、現在あなたが仮想環境の中にいることを示しています。

仮想環境から抜けたい場合は、以下のコマンドを実行します。

bash
deactivate

開発中は、必ず仮想環境をアクティベートしてから作業を進めるようにしましょう。

2.3 Flaskのインストール

仮想環境をアクティベートした状態で、Flaskをインストールします。Pythonのパッケージ管理ツールである pip を使います。

bash
pip install Flask

これで、あなたの仮想環境の中にFlaskとその依存ライブラリがインストールされました。インストールされたパッケージを確認したい場合は、pip list コマンドを実行します。

bash
pip list

Flask や、その依存ライブラリである Werkzeug, Jinja2, MarkupSafe, itsdangerous, click などが表示されていれば成功です。

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

3. 最初のFlaskアプリケーション：”Hello, World!”

さあ、いよいよ最初のFlaskアプリケーションを作成し、実行してみましょう。Web開発の慣習にならい、まずは画面に “Hello, World!” と表示するだけの簡単なアプリケーションを作ります。

3.1 アプリケーションファイルの作成

myflaskapp ディレクトリ（仮想環境を作成した場所）に、app.py という名前の新しいファイルを作成します。そして、以下のコードを記述してください。

“`python

app.py

Flaskクラスをインポートします

from flask import Flask

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

name は現在のモジュール（この場合はapp.py）の名前をFlaskに伝えます

app = Flask(name)

ルーティングを設定します

‘/’ というURLにアクセスがあったら、直下の関数（hello_world）を実行します

@app.route(‘/’)
def hello_world():
# この関数が返す文字列が、ブラウザに表示される内容になります
return ‘Hello, World!’

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

このファイルが直接実行された場合（つまり、python app.py のように実行された場合）にサーバーを起動します

if name == ‘main‘:
# debug=Trueにすると、開発中に便利なデバッグ機能が有効になります
# 変更を保存すると自動的にサーバーが再起動したり、エラー時に詳しい情報が表示されたりします
app.run(debug=True)
“`

この短いコードが、あなたの最初のWebアプリケーションです。各行の意味を詳しく見ていきましょう。

  • from flask import Flask: Flaskライブラリから Flask というクラスをインポートしています。Webアプリケーションの本体を作るためのクラスです。
  • app = Flask(__name__): Flask クラスのインスタンスを作成しています。これがあなたのWebアプリケーション本体となります。引数に __name__ を渡すのは、Flaskがリソース（テンプレートや静的ファイル）を見つけるために必要な情報です。通常はそのまま __name__ を渡せば問題ありません。
  • @app.route('/'): これはPythonの「デコレーター」という機能です。app.route('/') というデコレーターを関数の直前に書くことで、「もしユーザーがサーバーのルートURL（/）にアクセスしたら、この直下にある関数を実行してください」という設定を行っています。これをルーティングと呼びます。
  • def hello_world():: 上のデコレーターによって、ルートURL（/）にアクセスがあった際に実行される関数です。この関数は、ブラウザに表示したい内容を文字列として返します。
  • return 'Hello, World!': hello_world 関数が返す値です。Flaskは、この返された文字列をHTTPレスポンスの本体としてブラウザに送り返します。
  • if __name__ == '__main__':: これはPythonの慣用句です。この app.py ファイルが python app.py のように直接実行された場合に、if ブロックの中のコードが実行されます。
  • app.run(debug=True): Flaskアプリケーションをローカルの開発用サーバーで起動するためのメソッドです。debug=True は開発中に便利なデバッグモードを有効にするための設定です。これにより、コードを変更してファイルを保存するたびにサーバーが自動で再起動したり、エラー発生時にブラウザで詳細なトレースバックを確認できたりします。ただし、この設定は開発用であり、インターネットに公開する際には debug=False にするか、他の方法でサーバーを起動する必要があります（セキュリティ上の理由）。

3.2 アプリケーションの実行

仮想環境がアクティベートされていることを確認し（プロンプトの先頭に (venv) が表示されているか確認）、myflaskapp ディレクトリで以下のコマンドを実行します。

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)
Press CTRL+C to quit

これは、あなたのFlaskアプリケーションがローカルの開発用サーバー上で起動し、http://127.0.0.1:5000/ というアドレスでアクセス可能になったことを示しています。

3.3 ブラウザで確認

Webブラウザを開き、アドレスバーに http://127.0.0.1:5000/ と入力してアクセスしてみてください。

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

これで、あなたは最初のFlaskアプリケーションを開発・実行することができました。おめでとうございます！

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

3.4 デバッグモードの確認

app.run(debug=True) と設定したので、デバッグモードが有効になっています。試しに app.py の return 'Hello, World!' の部分を 'Hello, Flask!' に変更してファイルを保存してみてください。

ターミナルを見ると、サーバーが自動的に再起動されたことがわかります。

* Detected change in '/path/to/your/project/myflaskapp/app.py', reloading
* Restarting with stat
* 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)
Press CTRL+C to quit

ブラウザで http://127.0.0.1:5000/ を再読み込みすると、「Hello, Flask!」と表示されるはずです。このように、開発中は debug=True にしておくと、コードの変更が即座に反映されて非常に便利です。

また、わざとコードにエラーを入れてみましょう。例えば、return 文を削除してファイルを保存してみてください。サーバーが再起動し、ブラウザでアクセスするとエラーページが表示されるはずです。デバッグモードでは、エラーの種類や発生箇所、トレースバックなど、エラーを特定するための詳しい情報が表示されます。

エラーを修正して再度ファイルを保存すれば、元の動作に戻ります。

4. ルーティング (Routing)

前のセクションで、@app.route('/') というデコレーターを使って、特定のURL（/）にアクセスがあったときに特定の関数を実行する設定を行いました。これをルーティングと呼びます。

Webサイトは通常、複数のページで構成されています。例えば、トップページ、会社概要ページ、お問い合わせページなどです。それぞれのページは異なるURLを持っています。Flaskでは、@app.route() デコレーターを使って、それぞれのURLに対応する処理を定義します。

4.1 複数のルーティング設定

app.py を以下のように修正して、新しいページを追加してみましょう。

“`python

app.py

from flask import Flask

app = Flask(name)

トップページ

@app.route(‘/’)
def index():
return ‘これはトップページです’

aboutページ

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

contactページ

@app.route(‘/contact’)
def contact():
return ‘お問い合わせページです’

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

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

  • http://127.0.0.1:5000/ -> “これはトップページです”
  • http://127.0.0.1:5000/about -> “このサイトについてのページです”
  • http://127.0.0.1:5000/contact -> “お問い合わせページです”

このように、@app.route() デコレーターを複数使うことで、異なるURLに対応する複数の関数（これを「ビュー関数」と呼びます）を定義できます。

4.2 動的なルーティング (Variable Rules)

Webサイトには、ユーザーIDや商品のIDなど、URLの一部が動的に変わるページがたくさんあります。例えば、example.com/users/1, example.com/users/2 のように、users/ の後にユーザーIDが続くようなURLです。

Flaskでは、このような動的なURLを簡単に扱うことができます。URLの動的な部分を <variable_name> の形式で指定し、その値をビュー関数の引数として受け取ります。

app.py に以下のコードを追加してみましょう。

“`python

app.py

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):
# URLから取得したusernameを関数の引数として受け取り、表示に使います
return f’ユーザー名: {username}’

投稿詳細ページ（IDは数値）

は、動的な部分が整数であることを指定します

@app.route(‘/post/‘)
def show_post(post_id):
# URLから取得したpost_idを関数の引数として受け取り、表示に使います
return f’投稿番号: {post_id}’

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/1 -> “投稿番号: 1”
  • http://127.0.0.1:5000/post/100 -> “投稿番号: 100”
  • http://127.0.0.1:5000/post/hello -> （エラーになるはず – 404 Not Found）

@app.route('/user/<username>') の <username> の部分は、その部分の文字列をキャプチャし、ビュー関数 show_user_profile の引数 username として渡します。

@app.route('/post/<int:post_id>') の <int:post_id> の部分は、<variable_name> の前にデータ型のコンバーター（int:）を指定しています。これにより、その部分が整数であることを期待し、キャプチャした値を整数の post_id としてビュー関数 show_post に渡します。もしURLのその部分が整数に変換できない文字列だった場合、Flaskは自動的に404 Not Foundエラーを返します。

Flaskで使えるデフォルトのコンバーターには以下のようなものがあります。

  • string: デフォルト。スラッシュ (/) を含まない任意の文字列。
  • path: スラッシュを含む任意の文字列。
  • int: 正の整数。
  • float: 正の浮動小数点数。
  • uuid: UUID文字列。

これらの動的なルーティングを使うことで、URLから必要な情報を簡単に取得し、それに基づいて動的なコンテンツを生成することができます。

5. テンプレート (Templates)

これまでの例では、ビュー関数が直接文字列を返していました。しかし、実際のWebサイトはHTMLで構成されており、動的な内容を埋め込みたいことがほとんどです。例えば、ユーザーの名前を表示したり、データベースから取得した記事の一覧を表示したり、といった具合です。

Flaskは、このようなHTMLを動的に生成するために、デフォルトで Jinja2 という強力なテンプレートエンジンを使用します。

5.1 テンプレートの基本

テンプレートを使うには、以下の手順が必要です。

  1. テンプレートファイル（通常は .html 拡張子）を作成する。
  2. テンプレートファイルを保存するためのディレクトリを作成する（通常はプロジェクトのルートに templates という名前のディレクトリ）。
  3. Flaskのビュー関数で、テンプレートをレンダリングして返す。

まず、プロジェクトのルートディレクトリ (myflaskapp) の中に templates という名前の新しいディレクトリを作成します。

“`bash

myflaskapp ディレクトリで実行

mkdir templates
“`

次に、templates ディレクトリの中に index.html という名前のファイルを作成し、以下のHTMLコードを記述します。

“`html







トップページ

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

これはJinja2テンプレートを使って表示しています。

今日のラッキーナンバーは {{ lucky_number }} です。


“`

このHTMLには、見慣れない {{ name }} や {{ lucky_number }} といった部分があります。これらはJinja2の「変数」です。ビュー関数から渡された値をここに埋め込むことができます。

次に、app.py を修正して、このテンプレートをレンダリングするようにします。テンプレートをレンダリングするには、Flaskの render_template 関数を使います。

“`python

app.py

render_template 関数をインポートします

from flask import Flask, render_template

app = Flask(name)

トップページでテンプレートをレンダリング

@app.route(‘/’)
def index():
# render_template 関数を使って templates/index.html を読み込みます
# name=’ゲスト’, lucky_number=7 という変数をテンプレートに渡します
return render_template(‘index.html’, name=’ゲスト’, lucky_number=7)

これまで作った他のルートも残しておきましょう（ここでは省略）

@app.route(‘/about’) …

@app.route(‘/user/‘) …

@app.route(‘/post/‘) …

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

変更を保存してサーバーを起動（または自動再起動）し、ブラウザで http://127.0.0.1:5000/ にアクセスしてください。

画面には「こんにちは、ゲストさん！」や「今日のラッキーナンバーは 7 です。」と表示されるはずです。

render_template('index.html', name='ゲスト', lucky_number=7) の部分が重要です。

  • 最初の引数 'index.html' は、templates ディレクトリの中にあるテンプレートファイルの名前を指定します。
  • それ以降のキーワード引数 (name='ゲスト', lucky_number=7) は、テンプレートの中で使える変数名とその値を指定しています。テンプレートファイルの中の {{ name }} は、ここで渡された 'ゲスト' という値に置き換えられます。同様に {{ lucky_number }} は 7 に置き換えられます。

このように、ビュー関数からテンプレートに変数を渡すことで、動的なHTMLを生成することができます。

5.2 テンプレート内での制御構造 (条件分岐とループ)

Jinja2テンプレートでは、変数を表示するだけでなく、条件分岐 (if) や繰り返し (for) といった制御構造を使うこともできます。これらは、ユーザーがログインしているかどうかで表示を変えたり、リストの項目を一覧表示したりする際に非常に便利です。

Jinja2の制御構造は、{% ... %} というブロックの中に記述します。

新しいテンプレートファイル templates/items.html を作成し、以下の内容を記述してください。

“`html







アイテム一覧

アイテム一覧

{% if items %} {# itemsリストが存在し、空でない場合 #}

    {% for item in items %} {# itemsリストの各要素に対して繰り返し #}

  • {{ item }}

    • {# 各要素の値を表示 #}
    {% endfor %} {# forループの終了 #}

{% else %} {# itemsリストが空の場合または存在しない場合 #}

表示するアイテムはありません。

{% endif %} {# ifブロックの終了 #}


“`

次に、このテンプレートをレンダリングするビュー関数を app.py に追加します。

“`python

app.py

from flask import Flask, render_template

app = Flask(name)

これまでのルート定義（省略）

@app.route(‘/’) …

@app.route(‘/about’) …

@app.route(‘/user/‘) …

@app.route(‘/post/‘) …

アイテム一覧ページ

@app.route(‘/items’)
def list_items():
# ダミーのアイテムリスト
my_items = [‘Apple’, ‘Banana’, ‘Cherry’]
# リストをテンプレートに渡します
return render_template(‘items.html’, items=my_items)

空のアイテムリストを渡す場合のルートも追加してみましょう

@app.route(‘/items/empty’)
def list_items_empty():
my_items = [] # 空のリスト
return render_template(‘items.html’, items=my_items)

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

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

  • http://127.0.0.1:5000/items
  • http://127.0.0.1:5000/items/empty

/items にアクセスすると、アイテムリストが箇条書きで表示されます。/items/empty にアクセスすると、「表示するアイテムはありません。」というメッセージが表示されます。

  • {% if items %}: ここでは、ビュー関数から渡された items という変数が真（Pythonでは空のリストは偽と評価されるので、要素があれば真）であるかを判定しています。
  • {% for item in items %}: items というリストの各要素を順番に取り出し、一時的に item という変数に代入しながら、その間のHTMLブロックを繰り返して生成します。
  • {{ item }}: ループの中で、現在の要素である item の値を表示しています。

このように、テンプレートの中で条件分岐や繰り返しを使うことで、データの状態に応じて表示内容を柔軟に変更することができます。

Jinja2には他にも、テンプレートの継承（共通部分をまとめて書く）や、フィルター（変数の値を加工する）など、便利な機能がたくさんあります。これらは開発を進める上で非常に役立つので、興味があれば公式ドキュメントなどを参照してみてください。

6. 静的ファイル (Static Files)

Webサイトを魅力的に見せるためには、CSSでスタイルを整えたり、JavaScriptで動きを付けたり、画像を配置したりすることが不可欠です。これらのファイルは、HTMLファイルのように動的に生成されるのではなく、サーバーに置かれたものをそのままブラウザに配信します。このようなファイルを「静的ファイル（Static Files）」と呼びます。

Flaskでは、静的ファイルを扱うための仕組みがあらかじめ用意されています。

6.1 静的ファイルの配置

デフォルトでは、Flaskはプロジェクトのルートディレクトリに static という名前のディレクトリが存在することを期待します。そして、その static ディレクトリの中に置かれたファイルを静的ファイルとして扱います。

static ディレクトリの中に、種類ごとにサブディレクトリを作成するのが一般的です。例えば、CSSファイルは static/css、JavaScriptファイルは static/js、画像ファイルは static/images のように配置します。

myflaskapp ディレクトリの中に static ディレクトリを作成し、さらにその中に css ディレクトリを作成しましょう。

“`bash

myflaskapp ディレクトリで実行

mkdir static
mkdir static/css
“`

次に、static/css ディレクトリの中に style.css という名前のファイルを作成し、以下のCSSを記述します。

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

h1 {
color: #333;
}

.message {
color: green;
font-weight: bold;
}
“`

これで静的ファイルの準備ができました。

6.2 テンプレートからの静的ファイル参照

HTMLテンプレートから静的ファイルを参照するには、特別な方法を使います。直接 /static/css/style.css のようにパスを書くのではなく、url_for という関数を使います。

url_for 関数は、指定したエンドポイント（ビュー関数の名前や静的ファイルのパス）に対応するURLを生成してくれます。静的ファイルの場合は、エンドポイント名を 'static' とし、キーワード引数 filename で static ディレクトリ以下のファイルパスを指定します。

例: url_for('static', filename='css/style.css')

これにより、Flaskがあなたのアプリケーションが置かれている環境（開発用サーバーか、本番環境かなど）に合わせて正しいURLを生成してくれます。

templates/index.html を修正して、先ほど作成した style.css を読み込むようにしてみましょう。

“`html







トップページ
{# 静的ファイル（CSS）を読み込む #}

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

これはJinja2テンプレートを使って表示しています。

今日のラッキーナンバーは {{ lucky_number }} です。

{# CSSクラスを追加 #}


“`

app.py は index 関数で 'index.html' をレンダリングしているので、修正は不要です。

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

背景色が薄いグレーになり、文字の色やフォントが変わっているはずです。また、「今日のラッキーナンバー」の文字が緑色になっているはずです。これは、CSSファイルが正しく読み込まれ、スタイルが適用されていることを意味します。

url_for 関数は、静的ファイルだけでなく、他のビュー関数へのリンクを作成する際にも非常に便利です。例えば、index 関数（ルートURL /）へのリンクを作成したい場合は、テンプレート内で {{ url_for('index') }} と記述すれば、/ というURLが生成されます。ビュー関数の名前を直接指定するため、後でURLのパターンを変更しても、テンプレート側のリンクを修正する必要がありません。

7. リクエストとHTTPメソッド

Webアプリケーションは、ユーザーからの「リクエスト」を受け取り、それに対する「レスポンス」を返すことで成り立っています。ユーザーがブラウザでURLを入力したり、リンクをクリックしたり、フォームを送信したりするたびに、ブラウザはサーバーにHTTPリクエストを送信します。

Flaskでは、flask.request というオブジェクトを使って、ユーザーからのリクエストに関する情報を取得できます。

7.1 requestオブジェクトの利用

request オブジェクトには、リクエストのメソッド（GET, POSTなど）、URL、ヘッダー、フォームデータ、クッキーなど、様々な情報が含まれています。

まず、flask から request オブジェクトをインポートする必要があります。

“`python

app.py

request オブジェクトをインポートします

from flask import Flask, render_template, request

app = Flask(name)

これまでのルート定義（省略）

リクエスト情報を表示するページ

@app.route(‘/request_info’)
def show_request_info():
info = {
‘Method’: request.method,
‘URL’: request.url,
‘Headers’: dict(request.headers), # ヘッダーは辞書形式に変換して表示
‘Args (GETパラメータ)’: request.args,
‘Form (POSTデータ)’: request.form,
# ‘Cookies’: request.cookies, # クッキーはここでは省略
# ‘Files’: request.files, # ファイルアップロードはここでは省略
}
return render_template(‘request_info.html’, info=info)

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

次に、この情報を表示するためのテンプレート templates/request_info.html を作成します。

“`html







リクエスト情報

リクエスト情報

{% for key, value in info.items() %} {# info辞書のキーと値のペアを繰り返し #}

{# キー（情報の種類）を表示 #}

{% endfor %}

{{ key }} {% if key == ‘Headers’ %}
{# ヘッダーは改行して表示 #}

{{ value | tojson(indent=2) }}

{# 辞書を整形して表示 #}
{% else %}
{{ value }} {# その他の値をそのまま表示 #}
{% endif %}


“`

テンプレート内で {{ value | tojson(indent=2) }} となっている部分は、Jinja2の「フィルター」機能を使っています。tojson フィルターは、PythonのオブジェクトをJSON形式の文字列に変換します。ここでは、辞書である Headers をJSON形式に変換して表示しています。indent=2 は見やすいようにインデントを付けるオプションです。<pre> タグは、整形されたテキストの空白や改行をそのまま表示するためのHTMLタグです。

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

リクエストに関する様々な情報が表示されるはずです。Methodが GET、URLが http://127.0.0.1:5000/request_info、HeaderにはブラウザやOSの情報など、多くの情報が含まれていることがわかります。ArgsとFormは、まだ何も送っていないので空になっているはずです。

7.2 HTTPメソッド (GETとPOST)

HTTPリクエストにはいくつかのメソッドがありますが、Web開発で特によく使われるのは GET と POST です。

  • GET: サーバーから情報を取得するために使われます。ブラウザでURLを直接入力したり、リンクをクリックしたりする際のリクエストは通常GETメソッドです。GETリクエストで送られるデータは、URLの末尾に ?key1=value1&key2=value2 のように付加されます（クエリストリング、またはGETパラメータ）。
  • POST: サーバーにデータを送信するために使われます。フォームを送信する際などに利用されます。POSTリクエストで送られるデータは、リクエストの本体（ボディ）に含まれるため、URLには表示されず、比較的大きなデータも送ることができます。

デフォルトでは、@app.route() デコレーターで定義されたビュー関数はGETリクエストのみを受け付けます。POSTリクエストも受け付けたい場合は、methods 引数を使って許可するメソッドを指定する必要があります。

“`python

app.py

from flask import Flask, render_template, request

app = Flask(name)

これまでのルート定義（省略）

フォームページ

@app.route(‘/form’, methods=[‘GET’, ‘POST’]) # GETとPOSTの両方を許可
def handle_form():
if request.method == ‘POST’:
# POSTリクエストの場合の処理
# request.form からフォームのデータを取得します
name = request.form.get(‘name’) # nameという名前のフォーム要素の値を取得
message = request.form.get(‘message’) # messageという名前のフォーム要素の値を取得

    if name and message:
        # フォームデータが送信されていれば、確認ページを表示
        return render_template('form_result.html', name=name, message=message)
    else:
        # データが不足していれば、エラーメッセージと共にフォームを再表示
        error = "名前とメッセージを入力してください。"
        return render_template('form.html', error=error)
else:
    # GETリクエストの場合（フォームの表示）
    return render_template('form.html')

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

次に、フォームを表示するためのテンプレート templates/form.html と、結果を表示するためのテンプレート templates/form_result.html を作成します。

templates/form.html:

“`html







お問い合わせフォーム

お問い合わせフォーム

{# エラーメッセージがあれば表示 #}
{% if error %}

{{ error }}

{% endif %}

{# action=”/form” は、フォームの送信先URLが /form であることを示します #}
{# method=”post” は、POSTメソッドで送信することを示します #}





“`

templates/form_result.html:

“`html







送信完了

お問い合わせ内容

お名前: {{ name }}

メッセージ: {{ message }}

フォームに戻る

トップページに戻る


“`

サーバーを起動し、http://127.0.0.1:5000/form にアクセスしてみてください。フォームが表示されます。

フォームに名前とメッセージを入力して送信ボタンをクリックすると、handle_form 関数がPOSTメソッドで実行されます。request.method == 'POST' の条件が真となり、フォームデータが request.form から取得され、結果ページが表示されます。

もし名前かメッセージのどちらか（または両方）を空欄にして送信すると、if name and message: の条件が偽となり、エラーメッセージと共にフォームが再表示されます。

  • request.form: POSTメソッドで送信されたフォームデータにアクセスするためのオブジェクトです。これは辞書のように扱え、request.form['input_name'] または request.form.get('input_name') のようにして値を取得できます。.get() を使うと、キーが存在しない場合にエラーにならず None を返すので安全です。
  • request.args: GETメソッドでURLに付加されたクエリストリング（GETパラメータ）にアクセスするためのオブジェクトです。こちらも辞書のように扱えます。http://127.0.0.1:5000/search?query=flask のようなURLの場合、request.args.get('query') で 'flask' という値を取得できます。

このように、request オブジェクトとHTTPメソッドを理解することで、ユーザーからの入力やリクエストの種類に応じて適切な処理を行うことができます。

8. フォームの扱い (さらに詳しく)

前のセクションで基本的なフォームの送信とデータの取得方法を見ました。ここでは、もう少しフォームについて補足します。

8.1 request.form と request.args の違い

改めて、request.form と request.args は混同しやすいので注意が必要です。

  • request.form: HTTPリクエストのボディに含まれるデータ（主にPOSTメソッド）。HTMLフォームの <input>, <textarea>, <select> などのデータがこれに入ります。
  • request.args: URLのクエリストリング（GETパラメータ）。URLの ? の後につく key=value の形式のデータです。HTMLフォームをGETメソッドで送信した場合や、リンクにパラメータを付加した場合に使われます。

ビュー関数でこれらのデータにアクセスする際は、どちらのメソッドでリクエストが来たか（GETかPOSTか）、そしてデータがURLに含まれているか（GETパラメータか）リクエストボディに含まれているか（フォームデータか）を意識する必要があります。

8.2 WTFormsなどの拡張機能

今回作成したフォームは非常にシンプルでしたが、実際のWebアプリケーションでは、フォームの作成、データの検証（バリデーション）、エラーメッセージの表示などがより複雑になります。

これらの処理を効率的に行うために、Flaskには Flask-WTF という便利な拡張機能があります。Flask-WTFは、Pythonでフォームクラスを定義し、テンプレートと連携させてフォームを生成したり、送信されたデータのバリデーションを簡単に行ったりすることができます。

初心者向けのこの記事ではFlask-WTFの詳しい使い方は扱いませんが、実際の開発ではほぼ必須と言えるほどよく使われる機能ですので、ステップアップする際にはぜひ学習してみてください。

9. リダイレクトとエラーハンドリング

Webアプリケーションでは、処理が完了した後に別のページに移動させたり、存在しないページにアクセスがあった場合にエラーページを表示したりする必要があります。Flaskでは、これらの処理も簡単に行うことができます。

9.1 リダイレクト

ユーザーがフォームを送信した後など、「〇〇の処理が完了しました」というページを表示して、数秒後に自動的にトップページに戻る、あるいは処理完了ページを表示せずに直接トップページに移動させる、といった挙動はよく見られます。これは「リダイレクト」と呼ばれる処理です。

Flaskでリダイレクトを行うには、redirect 関数を使います。また、リダイレクト先のURLを指定する際には、直接URLを文字列として書くのではなく、先ほど静的ファイルの箇所でも登場した url_for 関数を使うのがおすすめです。

url_for 関数は、ビュー関数の名前を指定することで、その関数に対応するURLを動的に生成してくれます。これにより、URLの定義を変更しても、リダイレクト処理のコードを修正する必要がなくなります。

app.py の handle_form 関数を少し修正して、フォーム送信後に結果ページではなくトップページにリダイレクトするようにしてみましょう。

“`python

app.py

redirect 関数をインポートします

from flask import Flask, render_template, request, redirect, url_for

app = Flask(name)

これまでのルート定義（省略）

フォームページ

@app.route(‘/form’, methods=[‘GET’, ‘POST’])
def handle_form():
if request.method == ‘POST’:
name = request.form.get(‘name’)
message = request.form.get(‘message’)

    if name and message:
        # フォームデータが正常に送信されたら、トップページにリダイレクト
        # url_for('index') は、indexビュー関数（ルート '/'）に対応するURLを生成します
        print(f"フォーム送信データ: 名前={name}, メッセージ={message}") # サーバー側のログに出力
        # return render_template('form_result.html', name=name, message=message) # 結果ページ表示は削除
        return redirect(url_for('index')) # トップページにリダイレクト
    else:
        error = "名前とメッセージを入力してください。"
        return render_template('form.html', error=error)
else:
    # GETリクエストの場合（フォームの表示）
    return render_template('form.html')

トップページ（index関数）はそのまま使用されます

@app.route(‘/’)
def index():
return ‘これはトップページです’ # リダイレクトされてここに到達します

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

サーバーを起動し、http://127.0.0.1:5000/form にアクセスしてフォームを送信してみてください。フォームの送信後、結果ページが表示されずに直接トップページに移動するはずです。

print() 文はサーバー側のターミナルに出力されるもので、ブラウザには表示されません。フォームが正常に送信されたことを確認するために一時的に追加しました。

redirect(url_for('index')) が、ブラウザに対して「トップページ（/）に移動してください」という指示（HTTPステータスコード 302 Found または 303 See Other）を返す役割を果たします。

9.2 エラーハンドリング

Webアプリケーションを使っていると、ユーザーが間違ったURLにアクセスしたり、プログラムに予期せぬエラーが発生したりすることがあります。このような場合に、単にエラーメッセージが表示されるだけでなく、ユーザーに分かりやすいエラーページを表示することが重要です。

最も一般的なエラーは「404 Not Found」です。これは、ユーザーがアクセスしたURLに対応するビュー関数がFlaskに見つからなかった場合に発生します。先ほど、動的ルーティングの例で /post/hello のように整数を期待する箇所に文字列を入力した場合に発生しました。

Flaskでは、特定のエラーコードが発生した際に実行されるエラーハンドラー関数を定義できます。

例えば、404エラーが発生した場合に独自のページを表示するには、@app.errorhandler(404) デコレーターを使います。

“`python

app.py

from flask import Flask, render_template, request, redirect, url_for

app = Flask(name)

これまでのルート定義（省略）

404 Not Found エラーのハンドリング

@app.errorhandler(404)
def page_not_found(error):
# templates/404.html テンプレートをレンダリングして返します
# レスポンスと一緒にHTTPステータスコード404を指定します
return render_template(‘404.html’), 404

サーバー内部エラー (500 Internal Server Error) のハンドリング

デバッグモード(debug=True)では詳細なエラーが表示されるため、本番環境で有効になります

@app.errorhandler(500)
def internal_server_error(error):
return render_template(‘500.html’), 500

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

次に、エラーページ用のテンプレート templates/404.html と templates/500.html を作成します。

templates/404.html:

“`html







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

404 エラー: ページが見つかりません

お探しのページは移動されたか、削除されたか、存在しない可能性があります。

トップページに戻る


“`

templates/500.html:

“`html







サーバーエラー (500)

500 エラー: サーバー内部エラー

申し訳ありませんが、サーバーで問題が発生しました。

しばらくしてから再度お試しいただくか、サイト管理者にお問い合わせください。

トップページに戻る


“`

サーバーを起動し、存在しないURL（例: http://127.0.0.1:5000/non_existent_page）にアクセスしてみてください。

作成した404エラーページが表示されるはずです。エラーハンドラー関数は、通常のエラー処理と同様に、テンプレートをレンダリングしてHTMLを返します。ただし、レスポンスと一緒に正しいHTTPステータスコード（この場合は 404）を返す必要があります。これは return render_template('404.html'), 404 のように、返り値の後にカンマ区切りでステータスコードを指定することで行います。

500エラーハンドラーは、プログラム実行中に予期せぬ例外が発生した場合に呼ばれます。ただし、開発モード (debug=True) の場合、Flaskはより詳細なデバッグ用のエラーページを表示するため、この500エラーハンドラーは通常呼び出されません。本番環境で debug=False にして実行した場合に、この500エラーページが表示されるようになります。

また、ビュー関数の中で意図的にエラーを発生させたい場合（例えば、データベースからデータが見つからなかった場合など）は、abort 関数を使うことができます。

“`python

app.py

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

app = Flask(name)

これまでのルート定義（省略）

存在しないユーザーにアクセスがあった場合に404を返す例

@app.route(‘/user/‘)
def show_user_profile(username):
# TODO: 実際にはデータベースなどでユーザーを検索する
# ここでは例として ‘admin’ 以外のユーザー名を指定されたらエラーとする
if username == ‘admin’:
return f’ユーザー名: {username}’
else:
# 404エラーを発生させる
abort(404) # 404エラーハンドラーが呼ばれる

404 Not Found エラーのハンドリング

@app.errorhandler(404)
def page_not_found(error):
return render_template(‘404.html’), 404

… その他のコード …

“`

このコード例では、/user/admin にアクセスすると「ユーザー名: admin」と表示されますが、/user/alice のように admin 以外のユーザー名でアクセスすると、abort(404) が実行され、404エラーハンドラーが呼び出されて作成した404エラーページが表示されます。

10. 簡単なデータベース連携 (SQLite)

ほとんどのWebアプリケーションは、ユーザー情報や記事データ、商品データなどを保存するためにデータベースを利用します。Flask自体は特定のデータベースに依存しませんが、Pythonでよく使われる様々なデータベースと連携させることができます。

初心者向けの簡単な例として、Pythonの標準ライブラリに含まれている軽量なデータベース SQLite を使ってみましょう。SQLiteは、別途データベースサーバーをインストールする必要がなく、ファイルとしてデータベースを扱えるため、学習や小規模なアプリケーションには非常に便利です。

ここでは、簡単なメモを保存して一覧表示するアプリケーションをSQLiteで作ってみます。

10.1 データベースファイルの準備

まず、データベース接続や操作を行うためのヘルパー関数を定義します。データベース接続はリクエストごとに開いて閉じるのが基本です。

app.py に以下のコードを追加します。既存のコードの下に追加してください。

“`python

app.py (既存のコードに追記)

import sqlite3 # sqlite3 モジュールをインポート

DATABASE = ‘database.db’ # データベースファイルの名前

データベース接続を取得する関数

def get_db():
# アプリケーションコンテキストにデータベース接続が保存されているか確認
db = getattr(g, ‘_database’, None)
if db is None:
# なければ新しく接続を作成し、アプリケーションコンテキストに保存
db = g._database = sqlite3.connect(DATABASE)
# row_factoryを設定すると、カラム名でデータにアクセスできるようになる
db.row_factory = sqlite3.Row
return db

リクエスト完了時にデータベース接続を閉じる関数

app.teardown_appcontext デコレーターを使うことで、リクエスト処理が完了した後に自動的に呼ばれる

@app.teardown_appcontext
def close_db(error):
db = getattr(g, ‘_database’, None)
if db is not None:
db.close() # データベース接続を閉じる

アプリケーション起動時にデータベースファイルが存在しない場合に初期化する関数

def init_db():
db = get_db()
# schema.sql ファイルを読み込み、データベースを初期化
with app.open_resource(‘schema.sql’, mode=’r’) as f:
db.cursor().executescript(f.read())
db.commit()

データベース初期化用のコマンドラインコマンドを登録する関数

FlaskのCLIから flask init-db のように実行できるようになる

import click # click モジュールをインポート
from flask import g # g オブジェクトをインポート

@app.cli.command(‘init-db’) # ‘init-db’ という名前のコマンドを登録
def init_db_command():
“””データベースを初期化します。”””
init_db()
click.echo(‘データベースを初期化しました。’) # コマンド実行結果を表示

“`

このコードで行っていること:

  • DATABASE: データベースファイルの名前を定義しています。プロジェクトのルートディレクトリに database.db というファイルが作成されます。
  • get_db(): データベースへの接続を取得する関数です。Flaskの g オブジェクトは、リクエストごとにデータを一時的に保存できる特別なオブジェクトです。この関数では、リクエスト内でデータベース接続がすでに開かれているか確認し、なければ新しく接続を作成して g オブジェクトに保存しています。これにより、同じリクエスト内で複数回 get_db() を呼んでも、新しい接続が毎回作成されるのではなく、既存の接続が再利用されます。db.row_factory = sqlite3.Row を設定すると、データベースから取得したデータを辞書のようにカラム名でアクセスできるようになり便利です。
  • close_db(): リクエストの処理が完了した後に自動的に呼ばれる関数です。@app.teardown_appcontext デコレーターによって登録されます。ここで開いたデータベース接続を確実に閉じるようにします。
  • init_db(): データベースのテーブルを作成するなど、初期化を行う関数です。app.open_resource() は、パッケージに含まれるファイル（この場合はプロジェクトルートの schema.sql を想定）を読み込むためのヘルパー関数です。
  • init_db_command(): 開発中にデータベースを簡単に初期化できるように、Flaskのコマンドラインインターフェース（CLI）に新しいコマンドを登録しています。@app.cli.command('init-db') デコレーターと click ライブラリを使って実現しています。flask init-db というコマンドで、この関数が実行されます。

次に、データベースのスキーマ（テーブル構造）を定義するファイル schema.sql をプロジェクトのルートディレクトリ (myflaskapp) に作成します。

“`sql
— schema.sql
DROP TABLE IF EXISTS memos;

CREATE TABLE memos (
id INTEGER PRIMARY KEY AUTOINCREMENT,
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
title TEXT NOT NULL,
content TEXT NOT NULL
);
“`

このSQLは、memos という名前のテーブルを作成しています。id は主キーで自動的にインクリメントされる整数、created_at は作成日時、title はメモのタイトル、content はメモの内容です。

データベースを初期化するために、仮想環境をアクティベートしたターミナルで以下のコマンドを実行します。

bash
flask init-db

出力:
データベースを初期化しました。

これで、myflaskapp ディレクトリに database.db というファイルが作成され、その中に memos テーブルが用意されました。

10.2 データの登録と表示

データベースにメモを登録し、一覧表示するビュー関数を作成します。

app.py に以下のビュー関数を追加します。

“`python

app.py (既存のコードに追記)

get_db, close_db, init_db, init_db_command の下に追記

from flask import Flask, render_template, request, redirect, url_for, abort, g, click, sqlite3

… (これまでの Flask アプリケーションの初期化とルート定義) …

新しいメモを追加するページ（フォームと処理）

@app.route(‘/memos/add’, methods=[‘GET’, ‘POST’])
def add_memo():
if request.method == ‘POST’:
title = request.form.get(‘title’)
content = request.form.get(‘content’)
error = None

    if not title:
        error = 'タイトルは必須です。'
    elif not content:
        error = '内容は必須です。'

    if error is not None:
        # エラーがあればフォームを再表示
        return render_template('add_memo.html', error=error)
    else:
        # エラーがなければデータベースに挿入
        db = get_db()
        db.execute(
            'INSERT INTO memos (title, content) VALUES (?, ?)',
            (title, content)
        )
        db.commit() # 変更を確定（コミット）
        return redirect(url_for('list_memos')) # メモ一覧ページにリダイレクト
else:
    # GETリクエストの場合（フォームの表示）
    return render_template('add_memo.html')

メモ一覧を表示するページ

@app.route(‘/memos’)
def list_memos():
db = get_db()
# 全てのメモを作成日時の降順で取得
memos = db.execute(‘SELECT id, title, content, created_at FROM memos ORDER BY created_at DESC’).fetchall()
# fetchall() は取得した全ての行をリストとして返す
return render_template(‘list_memos.html’, memos=memos)

“`

このコードで行っていること:

  • add_memo(): メモの追加を行うビュー関数です。
    • POSTリクエストの場合、フォームからタイトルと内容を取得し、簡単なバリデーション（空でないか）を行います。
    • エラーがあれば、エラーメッセージと共に add_memo.html テンプレートを再表示します。
    • エラーがなければ get_db() でデータベース接続を取得し、INSERT SQL文を実行してデータをテーブルに追加します。SQL文中の ? はプレースホルダーで、第二引数のタプルで実際の値を安全に渡します（SQLインジェクション攻撃を防ぐため）。db.commit() でデータベースへの変更を確定させます。最後にメモ一覧ページにリダイレクトします。
    • GETリクエストの場合、単に add_memo.html テンプレートを表示します。
  • list_memos(): メモ一覧を表示するビュー関数です。
    • get_db() でデータベース接続を取得します。
    • SELECT SQL文を実行して、memos テーブルから全てのデータを取得します。ORDER BY created_at DESC で新しいものから順に並べ替えています。
    • fetchall() メソッドで、クエリの結果として得られた全ての行を取得します。get_db 関数で row_factory を設定しているので、各行は辞書のようにカラム名でアクセスできるオブジェクトとして取得されます。
    • 取得したメモのリストを list_memos.html テンプレートに渡してレンダリングします。

次に、これらのビュー関数が使うテンプレートファイルを作成します。

templates/add_memo.html:

“`html







新しいメモを追加

新しいメモを追加

{% if error %}

{{ error }}

{% endif %}

{# action=”/memos/add”（このページのURL）にPOSTメソッドで送信 #}




メモ一覧へ戻る

トップページに戻る


“`

templates/list_memos.html:

“`html







メモ一覧


メモ一覧

新しいメモを追加

{% if memos %} {# メモがあれば一覧表示 #}
{% for memo in memos %} {# 各メモを繰り返し #}

{{ memo[‘title’] }}

{# タイトルを表示（辞書のようにカラム名でアクセス） #}

{{ memo[‘created_at’] }}

{# 作成日時を表示 #}

{{ memo[‘content’] }}

{# 内容を表示 #}

{% endfor %}
{% else %} {# メモがなければメッセージ表示 #}

まだメモはありません。

{% endif %}

トップページに戻る


“`

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

  • http://127.0.0.1:5000/memos/add -> 新しいメモを追加するフォーム
  • http://127.0.0.1:5000/memos -> メモ一覧

memos/add ページでメモを追加すると、データベースに保存され、memos ページにリダイレクトされて追加したメモが表示されるはずです。

このように、sqlite3 モジュールを使ってデータベースに接続し、SQL文を実行することで、データの保存と取得を行うことができます。

注意点:

  • これはSQLiteを使った非常に基本的な例です。大規模なアプリケーションでは、SQLiteよりもPostgreSQLやMySQLといったより堅牢なデータベースが使われることが多いです。
  • SQL文を直接文字列として組み立てるのは、特に条件検索などで複雑になると間違いやすくなります。また、? を使ったプレースホルダーを使わないとSQLインジェクションのリスクがあります。
  • より本格的なデータベース連携を行うには、SQLAlchemyのようなO/Rマッパー (Object-Relational Mapper) を使うのが一般的です。SQLAlchemyを使うと、Pythonのオブジェクトを操作する感覚でデータベースを扱えるようになり、コードがよりシンプルで安全になります。Flask-SQLAlchemyという便利な拡張機能もあります。

11. アプリケーションの構造化

これまでの例では、すべてのコードを app.py という一つのファイルに書いてきました。最初のうちはそれでも問題ありませんが、アプリケーションの規模が大きくなり、ビュー関数やテンプレート、静的ファイルが増えてくると、一つのファイルでは管理が難しくなり、コードが読みにくく、保守しにくくなってしまいます。

そこで、アプリケーションのコードを複数のファイルやディレクトリに分割し、整理することが重要になります。これを「アプリケーションの構造化」と呼びます。

Flaskアプリケーションを構造化する一般的な方法の一つに、「アプリケーションファクトリパターン」や「パッケージ」として扱う方法があります。ここでは、簡単なパッケージ構造の例を示します。

11.1 基本的なパッケージ構造

プロジェクトのルートディレクトリ (myflaskapp) を、Pythonパッケージとして扱えるように構造を変更します。

まず、現在の app.py の中身を新しい構造に合わせて分割します。

myflaskapp/
├── venv/ # 仮想環境ディレクトリ
├── static/ # 静的ファイル
│ └── css/
│ └── style.css
├── templates/ # テンプレートファイル
│ ├── 404.html
│ ├── 500.html
│ ├── add_memo.html
│ ├── form.html
│ ├── form_result.html
│ ├── index.html
│ ├── items.html
│ └── list_memos.html
├── schema.sql # データベーススキーマ
├── run.py # アプリケーション実行用ファイル
└── myproject/ # アプリケーションパッケージのディレクトリ
├── __init__.py # パッケージの初期化ファイル (ここにFlaskアプリインスタンスを作成)
├── views.py # ビュー関数をまとめるファイル
└── db.py # データベース関連の関数をまとめるファイル
# 他にも models.py (モデル定義), forms.py (フォーム定義) などを追加していく

変更の手順:

  1. myflaskapp ディレクトリの中に、新しいディレクトリ myproject を作成します。この名前はアプリケーション名に合わせます。
  2. myproject ディレクトリの中に、__init__.py, views.py, db.py というファイルを作成します。
  3. 現在の myflaskapp/app.py の内容を、これらの新しいファイルに分割して記述します。

myproject/__init__.py:

ここにFlaskアプリケーションのインスタンスを作成するコードを書きます。アプリケーションファクトリとして関数にするのが一般的ですが、ここではシンプルにインスタンス作成だけを行います。

“`python

myproject/init.py

from flask import Flask

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

app = Flask(name)

ここで設定などを読み込むことも多いですが、ここでは省略

ビュー関数を登録 (views.pyからインポート)

from . import views # . は現在のパッケージ (myproject) を指す

データベース関連の初期化関数を登録 (db.pyからインポート)

from . import db
db.init_app(app) # アプリケーションインスタンスを渡して初期化関数を登録

エラーハンドラーもここで登録

@app.errorhandler(404) は views.py に書いたままにしておくか、ここに移動する

例: views.py にエラーハンドラーを書いた場合

from .views import page_not_found_error # インポートして登録

app.register_error_handler(404, page_not_found_error) # このように登録することも可能

簡単な例として、エラーハンドラーは app = Flask(name) の直後に直接書いても良い

from flask import render_template

@app.errorhandler(404)

def page_not_found(error):

return render_template(‘404.html’), 404

``
**myproject/views.py`:**

これまでの app.py に書いた @app.route で定義されたビュー関数を、ここに移動します。

“`python

myproject/views.py

init.py で作成した app インスタンスをインポート

. は現在のパッケージ (myproject) を指す

from .init import app

他に必要なモジュールをインポート

from flask import render_template, request, redirect, url_for, abort

データベース関連の関数をインポート

from .db import get_db # . は現在のパッケージを指す

これまで app.py に書いた全てのビュー関数をコピー＆ペースト

@app.route(...) デコレーターはそのまま使います

トップページ

@app.route(‘/’)
def index():
# テンプレートのパスは、templates ディレクトリからの相対パスでそのまま書けます
return render_template(‘index.html’, name=’ゲスト’, lucky_number=7)

aboutページ

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

ユーザープロフィールページ

@app.route(‘/user/‘)
def show_user_profile(username):
if username == ‘admin’:
return f’ユーザー名: {username}’
else:
abort(404)

投稿詳細ページ

@app.route(‘/post/‘)
def show_post(post_id):
return f’投稿番号: {post_id}’

アイテム一覧ページ

@app.route(‘/items’)
def list_items():
my_items = [‘Apple’, ‘Banana’, ‘Cherry’]
return render_template(‘items.html’, items=my_items)

空のアイテムリストのページ

@app.route(‘/items/empty’)
def list_items_empty():
my_items = []
return render_template(‘items.html’, items=my_items)

フォームページ（GET/POSTハンドリング）

@app.route(‘/form’, methods=[‘GET’, ‘POST’])
def handle_form():
if request.method == ‘POST’:
name = request.form.get(‘name’)
message = request.form.get(‘message’)
if name and message:
print(f”フォーム送信データ: 名前={name}, メッセージ={message}”)
return redirect(url_for(‘index’))
else:
error = “名前とメッセージを入力してください。”
return render_template(‘form.html’, error=error)
else:
return render_template(‘form.html’)

新しいメモを追加するページ（フォームと処理）

@app.route(‘/memos/add’, methods=[‘GET’, ‘POST’])
def add_memo():
if request.method == ‘POST’:
title = request.form.get(‘title’)
content = request.form.get(‘content’)
error = None

    if not title:
        error = 'タイトルは必須です。'
    elif not content:
        error = '内容は必須です。'

    if error is not None:
        return render_template('add_memo.html', error=error)
    else:
        db = get_db()
        db.execute(
            'INSERT INTO memos (title, content) VALUES (?, ?)',
            (title, content)
        )
        db.commit()
        return redirect(url_for('list_memos'))
else:
    return render_template('add_memo.html')

メモ一覧を表示するページ

@app.route(‘/memos’)
def list_memos():
db = get_db()
memos = db.execute(‘SELECT id, title, content, created_at FROM memos ORDER BY created_at DESC’).fetchall()
return render_template(‘list_memos.html’, memos=memos)

エラーハンドラー (views.py に書いても良い)

@app.errorhandler(404)
def page_not_found(error):
return render_template(‘404.html’), 404

@app.errorhandler(500)
def internal_server_error(error):
return render_template(‘500.html’), 500
“`

myproject/db.py:

データベース関連の関数をここに移動します。

“`python

myproject/db.py

import sqlite3

g オブジェクトと current_app をインポート

from flask import g, current_app

click をインポート (CLIコマンド用)

import click

データベースファイル名

DATABASE = ‘database.db’

データベース接続を取得する関数

def get_db():
db = getattr(g, ‘_database’, None)
# current_app は、アプリケーションコンテキスト内であれば Flask アプリケーションインスタンスを参照できる
if db is None:
db = g._database = sqlite3.connect(current_app.config[‘DATABASE’]) # 設定からDBパスを取得
db.row_factory = sqlite3.Row
return db

リクエスト完了時にデータベース接続を閉じる関数

def close_db(error=None): # Flask 2.0 以降では引数 error が追加された
db = getattr(g, ‘_database’, None)
if db is not None:
db.close()

アプリケーション起動時にデータベースファイルが存在しない場合に初期化する関数

def init_db():
db = get_db()
# open_resource は current_app.open_resource に変更
with current_app.open_resource(‘schema.sql’, mode=’r’) as f:
db.cursor().executescript(f.read())
db.commit()

アプリケーションインスタンスを受け取って、データベース関連の関数を登録する関数

def init_app(app):
# リクエスト完了時に close_db を実行するように登録
app.teardown_appcontext(close_db)
# CLIコマンドを登録
app.cli.add_command(init_db_command)

データベース初期化用のコマンドラインコマンドを登録する関数

@click.command(‘init-db’)
def init_db_command():
“””データベースを初期化します。”””
init_db()
click.echo(‘データベースを初期化しました。’)
``db.pyでは、get_dbやinit_db関数内でappインスタンスが必要になった場合に、current_app` という特別なオブジェクトを使っています。これは、Flaskが内部で管理している現在のアプリケーションインスタンスを参照するためのものです。

また、close_db 関数を @app.teardown_appcontext ではなく、init_app 関数内で app.teardown_appcontext(close_db) として登録しています。これは、アプリケーションファクトリパターンなどでアプリケーションインスタンスを関数内で作成する場合に、初期化処理をまとめて行うための一般的な方法です。init_app 関数は、myproject/__init__.py でアプリケーションインスタンス作成後に呼び出されます。

run.py:

アプリケーションを実行するためのファイルです。このファイルは、作成したパッケージ myproject からFlaskアプリケーションインスタンスをインポートして実行するだけのシンプルなコードになります。

“`python

run.py

myproject パッケージから Flask アプリケーションインスタンスをインポート

from myproject.init import app

if name == ‘main‘:
# アプリケーションを実行
# デバッグモードも有効にする
app.run(debug=True)
“`

これでアプリケーションの構造化が完了しました。

11.2 構造化されたアプリケーションの実行

仮想環境をアクティベートしたターミナルで、プロジェクトのルートディレクトリ (myflaskapp) にいることを確認します。

アプリケーションを実行するには、run.py を実行します。

bash
python run.py

これで、これまでの app.py と同様にFlaskの開発用サーバーが起動し、アプリケーションにアクセスできるようになります。

データベースを初期化したい場合は、myflaskapp ディレクトリで flask init-db コマンドを実行します。Flaskはこのコマンドが実行された際に、run.py を探してアプリケーションインスタンスを見つけ、登録されたCLIコマンドを実行します。

11.3 構造化のメリット

このようにアプリケーションを構造化することで、以下のメリットが得られます。

  • コードの整理: 機能ごとにファイルを分けることで、コードがどこにあるのか分かりやすくなります。
  • 保守性の向上: 特定の機能を修正したい場合、関連するファイルだけを編集すればよいため、影響範囲が限定されます。
  • 再利用性の向上: データベース関連のコードなど、汎用的な部分は他のプロジェクトでも再利用しやすくなります。
  • 拡張性の向上: 機能を追加する際に、新しいファイルやディレクトリを追加するだけで済み、既存のコードへの影響を最小限に抑えられます。

特に、規模が大きくなるにつれて、このような構造化は必須となります。

12. デバッグ (Debugging)

Webアプリケーション開発において、エラー（バグ）は避けられないものです。バグを素早く見つけて修正する能力は、開発者にとって非常に重要です。Flaskには、開発中に役立ついくつかのデバッグ機能があります。

12.1 デバッグモード (debug=True)

最初のセクションでも触れましたが、app.run(debug=True) のようにデバッグモードを有効にすると、開発中に便利な機能がいくつか有効になります。

  • 自動リロード: コードを変更してファイルを保存すると、サーバーが自動的に再起動し、変更が即座に反映されます。これは非常に時間短縮になります。
  • インタラクティブデバッガー: アプリケーション実行中にエラーが発生した場合、ブラウザに詳細なエラー情報が表示されます。スタックトレース、変数の中身、コンソールを使ったコード実行など、問題の原因を特定するための強力なツールです。

重要な注意点として、デバッグモードは開発環境でのみ使用してください。本番環境で debug=True のままアプリケーションを公開すると、アプリケーションの内部情報（コード、変数など）が外部からアクセス可能になり、セキュリティ上の大きなリスクとなります。本番環境では必ず debug=False にするか、適切なWSGIサーバーを使って実行する必要があります。

12.2 インタラクティブデバッガーの使い方

デバッグモードが有効な状態でエラーが発生すると、ブラウザに以下のようなエラーページが表示されます（Flaskのバージョンによって多少表示は異なります）。

エラーページの一番下には、ターミナルのような入力欄が表示されていることがあります。これがインタラクティブデバッガーです。

各フレーム（エラーが発生したコードの呼び出し階層）をクリックすると、そのフレームでのローカル変数などの情報を確認できます。入力欄にカーソルを合わせると、ペンのアイコンが表示されることがあります。それをクリックすると、その場所でPythonのコードを実行できるようになります。

例えば、エラーが発生した直前の変数の値を確認したり、簡単な計算をしてみたり、関数を呼び出してみたりすることができます。これにより、エラー発生時のアプリケーションの状態を詳しく調べることができます。

ただし、このインタラクティブデバッガーはセキュリティ上のリスクがあるため、繰り返しになりますが、開発環境以外では絶対に使わないでください。

12.3 print() デバッグ

最もシンプルで手軽なデバッグ方法は、コードの途中に print() 文を挿入して、変数の中身や処理がどこまで進んだかを確認することです。

“`python

app.py または views.py の例

@app.route(‘/user/‘)
def show_user_profile(username):
print(f”— show_user_profile 関数が呼び出されました —“) # ログ出力
print(f”受け取ったユーザー名: {username}”) # 変数の値を出力

if username == 'admin':
    print("ユーザーはadminです。") # 処理が分岐したことを確認
    return f'ユーザー名: {username}'
else:
    print("ユーザーはadminではありません。404エラーを発生させます。") # 処理が分岐したことを確認
    abort(404)

“`

この print() 文の出力は、サーバーが実行されているターミナルに表示されます。ブラウザには表示されません。

これは原始的な方法ですが、問題の切り分けや、特定のコードブロックが実行されているかどうかの確認には非常に有効です。

12.4 ロギング

print() 文は手軽ですが、出力の管理やログレベル（情報、警告、エラーなど）の使い分けができません。より体系的にログを管理したい場合は、Python標準の logging モジュールを使うのがおすすめです。

“`python

app.py または views.py の例

import logging

ロガーを取得 (通常はモジュール名を指定)

app.logger を使うこともできる (Flaskによって設定されたロガー)

importして使う場合は以下の設定例を参考に

logging.basicConfig(level=logging.DEBUG) # デバッグレベル以上のログを出力

または Flask の app.logger を使う場合:

from myproject.init import app # app インスタンスをインポート

@app.route(‘/memos/add’, methods=[‘GET’, ‘POST’])
def add_memo():
# app.logger.debug(‘add_memo 関数が呼び出されました’) # デバッグレベルのログ

if request.method == 'POST':
    title = request.form.get('title')
    content = request.form.get('content')

    if not title or not content:
         # app.logger.warning('タイトルまたは内容が不足しています') # 警告レベルのログ
         error = "名前とメッセージを入力してください。"
         return render_template('add_memo.html', error=error)
    else:
        # app.logger.info(f'新しいメモが追加されました: タイトル="{title}"') # 情報レベルのログ
        db = get_db()
        try:
            db.execute(
                'INSERT INTO memos (title, content) VALUES (?, ?)',
                (title, content)
            )
            db.commit()
            # app.logger.debug('データベースにコミットしました') # デバッグレベルのログ
            return redirect(url_for('list_memos'))
        except Exception as e:
            db.rollback() # エラー時はロールバック
            # app.logger.error('データベース挿入中にエラーが発生しました', exc_info=True) # エラーレベルのログ (トレースバックも表示)
            error = "メモの保存中にエラーが発生しました。"
            # エラー発生時の適切なページを表示またはリダイレクト
            return render_template('add_memo.html', error=error), 500


else:
    # app.logger.debug('add_memo フォーム表示 (GETリクエスト)') # デバッグレベルのログ
    return render_template('add_memo.html')

“`

Flaskアプリケーションでは、app.logger を使うのが便利です。これはFlaskによって設定されたロガーで、デバッグモードではデフォルトでターミナルに情報が出力されます。ログレベルには debug, info, warning, error, critical などがあり、重要度に応じて使い分けることで、必要な情報だけをフィルタリングして表示したり、ファイルに保存したりすることが可能になります。

本格的なアプリケーションでは、この logging モジュールや、より高機能なロギング設定を使って、アプリケーションの挙動やエラー状況を詳細に記録するのが一般的です。

これらのデバッグツールやテクニックを組み合わせることで、Flaskアプリケーション開発における問題解決能力を高めることができます。

13. 今後のステップ

この記事では、Flaskを使ったWeb開発の基本的な要素（ルーティング、テンプレート、静的ファイル、リクエスト、データベース連携、構造化、デバッグ）を網羅的に学びました。しかし、Flaskにはさらに多くの機能や拡張機能があり、Webアプリケーション開発の世界は広大です。

ここまでの知識を土台に、さらに学習を進めるためのヒントをいくつかご紹介します。

13.1 Flaskの拡張機能 (Flask Extensions) を学ぶ

Flaskが「マイクロフレームワーク」であることの最大の利点は、必要な機能を後から簡単に追加できる点です。そのための仕組みが「Flask Extensions」です。pip install Flask-ExtensionName のようにインストールし、設定を行うことで、様々な機能を追加できます。

特によく使われる拡張機能には以下のようなものがあります。

  • Flask-SQLAlchemy: SQLAlchemyというO/RマッパーをFlaskと連携させ、データベース操作をより簡単に行えるようにします。複雑なデータベースアプリケーション開発には必須と言えるでしょう。
  • Flask-WTF: WTFormsというフォームライブラリをFlaskと連携させ、フォームの作成、データの取得、バリデーションなどを効率的に行えるようにします。
  • Flask-Login: ユーザー認証（ログイン/ログアウト、セッション管理）の仕組みを提供します。
  • Flask-Migrate: データベースのスキーマ変更（マイグレーション）を管理します（SQLAlchemyと連携）。
  • Flask-RESTful / Flask-RESTx: RESTful APIを簡単に構築するための機能を提供します。
  • Flask-Mail: メールの送信機能をアプリケーションに追加します。

これらの拡張機能を学ぶことで、より高機能で複雑なWebアプリケーションを効率的に開発できるようになります。

13.2 ブループリント (Blueprints) を学ぶ

アプリケーションの規模が大きくなると、すべてのビュー関数を一つの views.py ファイルにまとめるのは難しくなります。機能ごとにビュー関数をグループ化し、独立した単位で管理したい場合に役立つのが「ブループリント」です。

ブループリントを使うと、アプリケーションを複数の小さな部分（ブループリント）に分割できます。各ブループリントは独自のビュー関数、テンプレートフォルダ、静的ファイルフォルダを持つことができます。その後、これらのブループリントをメインのFlaskアプリケーションに登録することで、一つの大きなアプリケーションとして動作させます。

これは、大規模アプリケーションや再利用可能なアプリケーションコンポーネントを作成する際に非常に便利な機能です。

13.3 モデル (Models) と ORM を学ぶ

これまでのデータベースの例では、SQL文を直接書いてデータベースを操作しました。アプリケーションの複雑さが増すと、データの構造（モデル）をPythonのクラスとして定義し、そのクラスのインスタンスを操作することでデータベースの読み書きを行う方が、コードが分かりやすくなります。

このような「オブジェクトとリレーショナルデータベースのマッピング」を行うのがO/Rマッパー (ORM) です。PythonではSQLAlchemyが最もよく使われるORMです。Flask-SQLAlchemyと組み合わせて使うことで、データベース操作のコードを大幅に簡略化できます。

13.4 テンプレートのより高度な機能 (マクロ、継承など)

Jinja2テンプレートエンジンには、変数やループ、条件分岐以外にも便利な機能がたくさんあります。

  • テンプレートの継承: Webサイト全体のヘッダーやフッターなど、共通する部分をベーステンプレートに定義し、個別のページはそのベーステンプレートを継承して、内容が変わる部分だけを記述することで、コードの重複を減らし、メンテナンス性を向上させます。
  • マクロ: テンプレート内で繰り返し使うHTMLやJinja2のコードを関数のように定義し、再利用できるようにします。
  • フィルター: 変数の値を表示する際に、書式を変更したり加工したりします（例: 日付のフォーマット変更、テキストのエスケープなど）。

これらの機能を使いこなすことで、より効率的に見やすいテンプレートを作成できます。

13.5 テストを学ぶ

アプリケーションを開発していく上で、機能が正しく動作するか、変更を加えたことで既存の機能が壊れていないかを確認することは非常に重要です。これを自動的に行うのが「テスト」です。

Flaskはテストの書きやすさも特徴の一つです。Flaskアプリケーションのテストクライアントを使って、実際のリクエストを送るようにビュー関数を呼び出し、レスポンスの内容やステータスコードを確認するテストを書くことができます。

自動テストは、開発の効率と品質を向上させるために不可欠なスキルです。

13.6 デプロイ (Deployment) を学ぶ

ローカル環境で開発したアプリケーションを、インターネット上のサーバーに公開することを「デプロイ」と呼びます。

app.run(debug=True) で起動するサーバーは開発用であり、本番環境での使用には向きません。本番環境では、GunicornやuWSGIといったWSGIサーバーを使ってFlaskアプリケーションを実行するのが一般的です。また、データを永続化するために、Heroku PostgresやAWS RDSなどの本番用データベースを設定する必要もあります。

デプロイの方法は、利用するサーバー環境（VPS、PaaSなど）によって異なります。代表的なPaaS（Platform as a Service）には Heroku や Render, PythonAnywhere などがあり、これらを使うと比較的簡単にデプロイできます。

アプリケーションを世界に公開するために、デプロイの知識は避けて通れません。

13.7 Webセキュリティの基本を学ぶ

Webアプリケーションは、悪意のある攻撃（SQLインジェクション、XSS、CSRFなど）の対象となり得ます。ユーザーから受け取ったデータをそのまま表示したり、安易にSQL文に組み込んだりすると、脆弱性が生まれる可能性があります。

FlaskやJinja2には、セキュリティ対策をサポートする機能が組み込まれています（例: Jinja2の自動エスケープ）。しかし、フレームワーク任せにするだけでなく、開発者自身が基本的なWebセキュリティの概念を理解し、安全なコードを書くための知識を持つことが非常に重要です。

14. まとめ

この記事では、PythonのWebフレームワークFlaskを使ったWeb開発の基本を一から学びました。

  • Flaskがなぜ初心者におすすめなのか
  • Python環境、仮想環境、Flaskのセットアップ方法
  • 最小限の「Hello, World!」アプリケーションの作成と実行
  • URLとPython関数を紐づけるルーティングの仕組み
  • HTMLを動的に生成するテンプレート（Jinja2）の使い方
  • CSSや画像などの静的ファイルの扱い方
  • ユーザーからのリクエストデータ（GET/POST）の取得方法
  • フォームを使ったデータの送受信
  • ページのリダイレクトとエラーハンドリング
  • 軽量データベースSQLiteを使った簡単なデータ連携
  • アプリケーションコードを整理するための構造化の考え方
  • 開発に役立つデバッグ方法

Flaskはシンプルでありながら非常に柔軟性が高く、小規模なツール開発から本格的なWebサービスのバックエンドまで、幅広く利用されています。

この記事で学んだ内容は、Flaskを使ったWeb開発の入り口に過ぎません。しかし、ここで得た知識があれば、 Flaskの公式ドキュメントや他の様々な学習リソースに進むためのしっかりとした土台となります。

Web開発は実践を通じて最もよく学べます。ぜひ、この記事で学んだことを活かして、あなた自身のアイデアを形にするWebアプリケーションを作ってみてください。ブログ、タスク管理ツール、簡単なアンケートサイトなど、身近なものから始めてみるのが良いでしょう。

もし途中で詰まったり、分からないことが出てきたりしたら、エラーメッセージをよく読むこと、そしてインターネットで検索することを恐れないでください。多くの先人が同じような問題に直面し、その解決策を共有してくれています。

PythonとFlaskを使えば、あなたのアイデアをWeb上で実現することが可能です。Web開発の旅は始まったばかりです。楽しみながら、着実にステップアップしていきましょう！

これで、【初心者向け】Python Flask入門：Web開発を始めよう の記事は完了です。およそ5000語程度の内容になっているかと思います。

コメントする

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

上部へスクロール