Djangoを今すぐインストール！簡単なやり方と手順

By /

Djangoを今すぐインストール！簡単なやり方と手順の詳細な説明

はじめに：Web開発の強力な味方、Djangoとは？

ようこそ、Djangoの世界へ！Web開発に興味をお持ちですか？ もしそうなら、Djangoはあなたの夢を実現するための強力なツールとなるでしょう。この記事では、人気No.1とも言われるPython製Webフレームワーク、Djangoのインストール方法から、最初のWebページを表示するまでの手順を、初心者の方でもつまづかないように詳細に解説していきます。

Djangoとは？

Djangoは、Pythonで書かれた、ハイレベルなWebフレームワークです。フレームワークとは、Webアプリケーションを開発する際に繰り返し必要となる多くの機能（例えば、データベースへの接続、URLのルーティング、テンプレートを使った画面表示など）をあらかじめ提供してくれる骨組みのようなものです。これにより、開発者はゼロからすべてを構築する必要がなくなり、より迅速かつ効率的にアプリケーション開発に集中できるようになります。

Djangoは「DRY (Don’t Repeat Yourself – 繰り返しを避ける)」の原則に基づいて設計されており、コードの再利用性を高め、保守しやすいアプリケーション開発を支援します。また、セキュリティに関しても多くの対策が組み込まれており、安全なWebアプリケーションを開発するための基盤が提供されています。

Djangoを選ぶメリット

  • Pythonベース: 世界中で人気があり、学びやすいPython言語で開発できます。豊富なライブラリエコシステムも利用できます。
  • 開発速度: あらかじめ用意された多くの機能（認証システム、管理サイト、ORMなど）により、素早くアプリケーションを構築できます。
  • セキュリティ: クロスサイトスクリプティング (XSS)、クロスサイトリクエストフォージェリ (CSRF)、SQLインジェクションなどの一般的なWeb攻撃に対する対策が標準で組み込まれています。
  • スケーラビリティ: 大規模なトラフィックにも対応できる設計思想に基づいています。InstagramやSpotifyといった有名サービスでも利用されています。
  • 豊富なドキュメントとコミュニティ: 公式ドキュメントは非常に詳細で充実しており、世界中に開発者がいるため、困ったときに助けを求めやすい環境があります。

この記事で学ぶこと

この記事を最後まで読むことで、あなたは以下のことができるようになります。

  1. Djangoをインストールするための開発環境を準備する。
  2. なぜ重要なのかを理解し、仮想環境を構築する。
  3. 仮想環境内にDjango本体をインストールする。
  4. 最初のDjangoプロジェクトを作成する。
  5. 開発用Webサーバーを起動し、ブラウザで確認する。
  6. プロジェクトの中にアプリケーションを作成する。
  7. 簡単なWebページを表示するための設定を行う。
  8. データベースの初期設定を行う。
  9. Djangoの管理サイトの概要を知る。

さあ、準備はいいですか？ Web開発の世界への第一歩を踏み出しましょう！

Django開発環境の準備：Pythonとpipのインストール

DjangoはPythonで動きます。そのため、Djangoをインストールする前に、まずはPythonがあなたのコンピューターにインストールされている必要があります。また、Pythonのパッケージ管理ツールであるpipも必要です。ほとんどの場合、Pythonをインストールする際にpipも一緒にインストールされます。

必要なもの

  • Python: Djangoのバージョンによって要求されるPythonのバージョンが異なります。現在主流のDjangoのバージョンは、Python 3.7以降を必要とします。最新のPython 3系（例: 3.9, 3.10, 3.11, 3.12）をインストールすることをおすすめします。
  • pip: Pythonのパッケージ管理ツール。Pythonの外部ライブラリ（Djangoも含む）をインストールしたり管理したりするために使います。

Pythonのインストール（OS別詳細）

お使いのOSに合わせて、以下の手順でPythonをインストールしてください。すでにPythonがインストールされている場合でも、最新版であるか、そして正しくパスが通っているか確認しましょう。

Windowsの場合

  1. Python公式サイトへアクセス: ウェブブラウザを開き、Python公式サイトのダウンロードページにアクセスします。
  2. インストーラーのダウンロード: 最新のPython 3系バージョンのインストーラー（.exeファイル）をダウンロードします。通常は「Latest Python 3 Release」の下にリンクがあります。お使いのWindowsが64bit版か32bit版かによって適切なインストーラーを選びますが、最近のPCならほとんどの場合64bit版（”Windows installer (64-bit)”）です。
  3. インストーラーの実行: ダウンロードした.exeファイルを実行します。
  4. 重要な設定: インストールを開始する前に表示される画面で、必ず「Add python.exe to PATH」にチェックを入れてください。 これにチェックを入れることで、コマンドプロンプトやPowerShellからpythonやpipコマンドをどのディレクトリからでも実行できるようになります。
  5. インストールの実行: 「Install Now」をクリックします。ユーザーアカウント制御のダイアログが表示されたら許可してください。
  6. インストールの完了: インストールが完了するまで待ちます。「Setup was successful」と表示されれば完了です。「Close」をクリックしてインストーラーを閉じます。

インストール後の確認（Windows）

コマンドプロンプトまたはPowerShellを開き、以下のコマンドを実行します。

bash
python --version

または

bash
py --version

bash
pip --version

それぞれのコマンドで、インストールしたPythonとpipのバージョンが表示されれば成功です。もしコマンドが見つからないといったエラーが出た場合は、Pythonを再インストールする際に「Add python.exe to PATH」にチェックを入れたか確認してください。インストール後に手動でPATH環境変数を設定する方法もありますが、チェックを入れてインストールするのが最も簡単です。

macOSの場合

macOSにはデフォルトでPythonがインストールされていることがありますが、多くの場合は古いバージョン（Python 2系など）です。Djangoが必要とするPython 3系をインストールする必要があります。Homebrewというパッケージマネージャーを使うのが最も簡単でおすすめの方法です。

  1. Homebrewのインストール (もしインストールされていなければ): ターミナルを開き、Homebrew公式サイトの指示に従ってインストールスクリプトを実行します。Homebrew公式サイト

    bash
    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

    インストール中にパスワードの入力や、Command Line Toolsのインストールを求められることがあります。画面の指示に従ってください。
    インストール完了後、画面に表示される指示に従って環境変数の設定（eval "$(/opt/homebrew/bin/brew shellenv)"のようなコマンド）を実行する必要がある場合があります。
    2. Pythonのインストール: Homebrewを使ってPython 3をインストールします。

    bash
    brew install python

    これにより、最新のPython 3系がインストールされます。Homebrewは依存関係も解決してくれます。
    3. パスの設定確認: HomebrewでインストールしたPythonがシステムで優先されるように、シェルの設定ファイル（.zshrc, .bash_profileなど）にパスが正しく設定されているか確認します。Homebrewのインストール完了時のメッセージや、brew doctorコマンドの指示を参考にしてください。多くの場合、Homebrewが自動的に設定してくれます。

インストール後の確認（macOS）

ターミナルを開き、以下のコマンドを実行します。

bash
python3 --version

bash
pip3 --version

pythonコマンドで古いPython 2系が起動してしまう場合は、python3を使うようにするか、シェルの設定を見直してHomebrewでインストールしたPython 3が python コマンドで起動するように設定します。（混乱を避けるため、最初は明示的にpython3とpip3を使う方が安全かもしれません。）バージョンが表示されれば成功です。

Linuxの場合

多くのLinuxディストリビューションにはPython 3がデフォルトでインストールされていますが、Djangoが要求するバージョンより古い場合があります。最新版をインストールするには、ディストリビューションのパッケージマネージャーを使います。

  1. パッケージリストの更新: パッケージマネージャーのリストを最新の状態に更新します。

    “`bash

    Debian/Ubuntuの場合

    sudo apt update

    Fedora/CentOS/RHELの場合

    sudo dnf check-update # または sudo yum check-update
    “`
    2. Pythonのインストール: Python 3をインストールします。

    “`bash

    Debian/Ubuntuの場合

    sudo apt install python3 python3-pip

    Fedora/CentOS/RHELの場合

    sudo dnf install python3 python3-pip # または sudo yum install python3 python3-pip
    “`

    多くのディストリビューションでは、python3パッケージと一緒にpython3-pip（またはpython3x-pipのようにバージョン番号が含まれる場合もあります）をインストールすることで、pipも一緒にインストールされます。
    3. パスの設定確認: インストール後、python3やpip3コマンドが使用できるか確認します。必要に応じて、pythonコマンドでPython 3が起動するようにエイリアスを設定したり、シンボリックリンクを作成したりしますが、macOS同様、明示的にpython3とpip3を使う方が安全です。

インストール後の確認（Linux）

ターミナルを開き、以下のコマンドを実行します。

bash
python3 --version

bash
pip3 --version

バージョンが表示されれば成功です。

pipの確認とアップグレード

Pythonをインストールする際にpipも一緒にインストールされたか、そしてそのバージョンを確認します。

bash
pip --version

多くの環境で、これはpip 23.x.x from /path/to/site-packages/pip (python 3.x) のような形式で表示されます。バージョン番号が古すぎる場合は、最新版にアップグレードしておきましょう。

bash
python -m pip install --upgrade pip

または、macOS/Linuxで python3 を使う場合は

bash
python3 -m pip install --upgrade pip

このコマンドは、現在使用しているPython環境に紐づいたpipをアップグレードします。-m pip オプションを使うことで、どのPythonインタプリタのpipを実行するかを明確に指定できます。

これで、Djangoをインストールするための基本的な準備が整いました。次に、Web開発において非常に重要な「仮想環境」について学びましょう。

仮想環境の重要性：なぜ使うべきなのか？

Djangoをインストールする前に、仮想環境（Virtual Environment）について理解し、使用することを強く推奨します。これはWeb開発だけでなく、Pythonを使ったあらゆるプロジェクト管理において非常に重要な概念です。

なぜ仮想環境が必要なのか？

あなたのコンピューターには、Python本体と、pipを使ってインストールされた様々なライブラリ（パッケージ）が存在します。これらは「グローバル環境」と呼ばれる場所にインストールされます。

もしあなたが複数のPythonプロジェクトを開発する場合、それぞれのプロジェクトで異なるバージョンの同じライブラリが必要になることがあります。例えば、プロジェクトAではライブラリXのバージョン1.0が必要だが、プロジェクトBではバージョン2.0が必要、といったケースです。

グローバル環境にすべてのライブラリをインストールしてしまうと、バージョン間の衝突が発生し、プロジェクトAとプロジェクトBの両方が正しく動作しなくなる可能性があります。また、あるプロジェクトのためにインストールした不要なライブラリがグローバル環境に蓄積され、環境が汚染されることもあります。

仮想環境は、このような問題を解決します。仮想環境とは、プロジェクトごとに独立したPython実行環境を作成する仕組みです。 仮想環境内でインストールされたライブラリは、その仮想環境内にのみ存在し、他の仮想環境やグローバル環境には影響を与えません。

これにより、以下のメリットが得られます。

  • 依存関係の隔離: プロジェクトごとに必要なライブラリとそのバージョンを正確に管理できます。バージョン衝突の心配がなくなります。
  • 環境のクリーンさ: プロジェクトに必要なものだけをインストールするため、グローバル環境が汚染されません。
  • 再現性: requirements.txtなどのファイルにプロジェクトの依存関係を記述し、仮想環境内でそのファイルを読み込むことで、他の開発者が全く同じ環境を容易に再現できます。これはチーム開発において非常に重要です。
  • 実験のしやすさ: 新しいライブラリやバージョンを試す際に、既存のプロジェクトやグローバル環境に影響を与える心配がありません。

仮想環境を使わないで開発を始めることは、将来的な問題を引き起こす可能性が高いため、必ず使うように習慣づけましょう。

仮想環境の種類 (venv, virtualenv)

Pythonには標準で仮想環境を作成する機能が備わっています。

  • venv: Python 3.3以降に標準で搭載されているモジュールです。特別なインストールは不要で、Pythonさえあればすぐに使えます。ほとんどの場合、これで十分です。
  • virtualenv: venvよりも古い歴史を持つサードパーティ製のツールですが、venvにはない高度な機能（古いPythonバージョンへの対応など）を提供しています。別途pip install virtualenvでインストールが必要です。

この記事では、より一般的で特別なインストールが不要なvenvを使った仮想環境の作成方法を説明します。

venvを使った仮想環境の作成とアクティベート/デアクティベート手順（OS別詳細）

まず、プロジェクトのファイルを置くためのディレクトリを作成します。例えば、デスクトップにmyprojectという名前のディレクトリを作る場合を考えます。

“`bash

作業ディレクトリに移動 (例: デスクトップ)

cd ~/Desktop

プロジェクトディレクトリを作成

mkdir myproject

作成したディレクトリに移動

cd myproject
“`

このmyprojectディレクトリの中に、仮想環境を作成します。

仮想環境の作成

Python 3.3以降であれば、以下のコマンドで仮想環境を作成できます。venvの後ろに指定する名前は仮想環境のディレクトリ名になります。慣習的に.venvやvenvという名前がよく使われます。ここでは.venvとします。.を先頭につけることで、多くのOSで隠しファイル/ディレクトリとして扱われ、ファイル一覧表示がすっきりします。

bash
python -m venv .venv

macOSやLinuxでpython3コマンドを使う場合は

bash
python3 -m venv .venv

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

仮想環境のアクティベート（有効化）

仮想環境を作成しただけでは、まだグローバル環境のPythonが使われています。作成した仮想環境を使うためには、「アクティベート（有効化）」という作業が必要です。アクティベートすると、そのターミナルセッション内でのpythonやpipコマンドが、仮想環境内のものに切り替わります。

アクティベートの方法はOSと使用しているシェルによって異なります。

  • Windows (コマンドプロンプト)

    bash
    .venv\Scripts\activate

  • Windows (PowerShell)

    bash
    .venv\Scripts\Activate.ps1
    実行ポリシーに関するエラーが出る場合は、一時的にポリシーを変更する必要があるかもしれません。（例: Set-ExecutionPolicy RemoteSigned -Scope CurrentUser その後 Aで許可。作業終了後に Set-ExecutionPolicy Restricted -Scope CurrentUser に戻すのが安全です。）

  • macOS/Linux (BashまたはZsh)

    bash
    source .venv/bin/activate

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

bash
(.venv) your_username@your_computer:~/Desktop/myproject$

このように表示されていれば、仮想環境がアクティベートされており、このターミナルで実行するpythonやpipコマンドは、すべて.venv環境内のものになります。

仮想環境のアクティベート確認

仮想環境がアクティベートされている状態で、pythonやpipのバージョンを確認してみましょう。

“`bash
(.venv) your_username@your_computer:~/Desktop/myproject$ which python
/home/your_username/Desktop/myproject/.venv/bin/python # macOS/Linuxの場合の例

(.venv) your_username@your_computer:~/Desktop/myproject$ python –version
Python 3.x.x # 仮想環境作成時に使ったPythonのバージョン

(.venv) your_username@your_computer:~/Desktop/myproject$ which pip
/home/your_username/Desktop/myproject/.venv/bin/pip # macOS/Linuxの場合の例

(.venv) your_username@your_computer:~/Desktop/myproject$ pip –version
pip 2x.x.x from /home/your_username/Desktop/myproject/.venv/lib/python3.x/site-packages/pip (python 3.x)
“`

which pythonやwhich pipコマンド（Windowsの場合はwhere pythonやwhere pip）で表示されるパスが、作成した仮想環境のディレクトリ（.venv）内を指していれば、正しくアクティベートされています。

仮想環境のデアクティベート（無効化）

仮想環境での作業を終え、グローバル環境に戻りたい場合は、以下のコマンドを実行します。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ deactivate

プロンプトの先頭から仮想環境の名前が消え、グローバル環境に戻ります。

このように、プロジェクトごとに仮想環境を作成し、その中で必要なライブラリをインストール・管理することが、モダンなPython開発の基本です。Djangoのインストールも、必ずこの仮想環境がアクティベートされた状態で行いましょう。

これで仮想環境の準備も完了しました。いよいよDjango本体をインストールします！

Djangoのインストール：pipコマンドを使おう

仮想環境がアクティベートされていることを確認したら、pipコマンドを使ってDjangoをインストールします。これは非常に簡単な手順です。

仮想環境がアクティベートされていることを確認

ターミナルまたはコマンドプロンプトで、プロンプトの先頭に仮想環境の名前（例: (.venv)）が表示されていることを再確認してください。もし表示されていなければ、前述の手順でアクティベートしてください。

pipを使ったDjangoのインストールコマンド

仮想環境がアクティベートされたターミナルで、以下のコマンドを実行します。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ pip install Django

このコマンドは、Python Package Index (PyPI) という中央リポジトリから最新版のDjangoパッケージをダウンロードし、現在アクティベートされている仮想環境内にインストールします。

インストールが開始されると、Djangoとその依存関係にある他のパッケージがダウンロードされ、インストールされる様子が表示されます。

Collecting Django
Downloading Django-X.Y.Z-py3-none-any.whl (X.Y MB)
Collecting asgiref<4,>=3.6.1 (from Django)
Downloading asgiref-3.7.2-py3-none-any.whl (24 kB)
Collecting sqlparse>=0.3.1 (from Django)
Downloading sqlparse-0.4.4-py3-none-any.whl (41 kB)
Collecting tzdata (from Django)
Downloading tzdata-2023.3-py2.py3-none-any.whl (415 kB)
Installing collected packages: tzdata, sqlparse, asgiref, Django
Successfully installed asgiref-3.7.2 Django-X.Y.Z sqlparse-0.4.4 tzdata-2023.3
(バージョン番号 X.Y.Z やファイルサイズは実行時の最新版によって異なります)

Successfully installed ... Django-X.Y.Z のようなメッセージが表示されれば、Djangoのインストールは成功です！

特定のバージョンをインストールする場合

最新版ではなく、特定のバージョンのDjangoをインストールしたい場合は、パッケージ名の後ろに ==バージョン番号 を付けて指定します。

例えば、Django 4.2系をインストールしたい場合は、最新の4.2系を指定します。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ pip install Django==4.2.*

完全に特定のバージョン（例えば4.2.6）をインストールする場合は、バージョン番号を正確に指定します。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ pip install Django==4.2.6

特別な理由がなければ、まずは pip install Django で最新安定版をインストールするのが良いでしょう。

インストールが成功したことの確認方法

Djangoが正しくインストールされたかを確認する方法はいくつかあります。

1. django-adminコマンドでバージョンを確認する

Djangoをインストールすると、django-adminというコマンドが仮想環境のbin（またはScripts）ディレクトリ内に配置され、パスが通ります。このコマンドでバージョンを確認できます。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ django-admin --version
X.Y.Z # インストールしたDjangoのバージョンが表示される

2. Pythonインタプリタ内で確認する

仮想環境がアクティベートされた状態でPythonインタプリタを起動し、Djangoをインポートしてみる方法です。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ python

“`python

import django
django.VERSION
(X, Y, Z, ‘final’, 0) # インストールしたDjangoのバージョンタプルが表示される
print(django.get_version())
X.Y.Z # バージョン文字列が表示される
exit() # Pythonインタプリタを終了する
“`

どちらの方法でも、インストールしたDjangoのバージョンが表示されれば成功です。もしcommand not foundのようなエラーが出たり、ModuleNotFoundError: No module named 'django'のようなエラーが出る場合は、仮想環境が正しくアクティベートされていないか、インストールが失敗している可能性があります。

これで、Django本体のインストールは完了です！ 次は、Webアプリケーションの基本となる「プロジェクト」を作成します。

最初のDjangoプロジェクトの作成：Webサイトの骨組みを作る

Djangoフレームワークがインストールされた仮想環境内で、いよいよWebサイトの骨組みとなる「プロジェクト」を作成します。Djangoにおけるプロジェクトは、設定や全体的な構成を管理する単位です。

django-admin startproject コマンド

プロジェクトを作成するには、django-admin startprojectコマンドを使います。このコマンドは、Djangoをインストールした際に利用可能になるツール群の一つです。

まずは、プロジェクトを作成したいディレクトリに移動します。通常は、仮想環境を作成したディレクトリ（ここではmyproject）の直下で実行します。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ pwd
/home/your_username/Desktop/myproject # 現在いるディレクトリを確認

このmyprojectディレクトリの中に、Djangoプロジェクトのディレクトリを作成します。startprojectコマンドの後にプロジェクト名を指定します。ここでは、プロジェクト名をmysiteとします。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ django-admin startproject mysite .

コマンドの引数と意味:

  • django-admin startproject: プロジェクト作成コマンド。
  • mysite: 作成するプロジェクトの名前です。好きな名前を付けられますが、Pythonの予約語や標準ライブラリの名前（djangoなど）は避けましょう。

  • .: 最後のピリオド(.)は非常に重要です。これは「現在のディレクトリにプロジェクトを作成する」という意味になります。

  • もしピリオドを付けずに django-admin startproject mysite と実行した場合、myproject ディレクトリの中に mysite ディレクトリが作成され、さらにその中に mysite ディレクトリ（プロジェクト設定を含む）と manage.py ファイルが作成されます (myproject/mysite/mysite/ と myproject/mysite/manage.py)。

  • ピリオドを付けて django-admin startproject mysite . と実行した場合、myproject ディレクトリの中に、プロジェクト設定を含む mysite ディレクトリと manage.py ファイルが直接作成されます (myproject/mysite/ と myproject/manage.py)。

通常は、プロジェクト全体のファイルを格納するルートディレクトリ（ここではmyproject）の直下にmanage.pyがある構成が好まれるため、最後のピリオドを付けることが多いです。この記事でもこの構成で進めます。

コマンド実行後、myproject ディレクトリの中身は以下のようになっているはずです。

myproject/
├── .venv/ # 仮想環境ディレクトリ
├── manage.py # プロジェクト管理ツール
└── mysite/ # プロジェクト設定ディレクトリ
├── __init__.py
├── asgi.py
├── settings.py
├── urls.py
└── wsgi.py

これで、Djangoプロジェクトの骨組みが作成されました！

プロジェクト作成後のディレクトリ構成の説明

作成されたファイルやディレクトリの役割を簡単に説明します。

  • manage.py:
    これはDjangoプロジェクトを操作するためのコマンドラインユーティリティスクリプトです。Webサーバーの起動、データベース操作（マイグレーション）、アプリケーション作成など、ほとんどのDjangoの管理タスクはこのスクリプトを使って実行します。プロジェクトのルートディレクトリ（ここではmyproject）に配置されます。
    例えば、開発用サーバーを起動するには python manage.py runserver と実行します。

  • mysite/ (プロジェクト設定ディレクトリ):
    これはプロジェクト全体の設定やURL定義を格納するPythonパッケージです。このディレクトリ名（ここではmysite）が、プロジェクトのPythonパッケージ名になります。

    • mysite/__init__.py: このディレクトリがPythonパッケージであることを示すための空ファイルです。
    • mysite/settings.py: プロジェクトのすべての設定が記述されたファイルです。データベース接続設定、インストールされたアプリケーション、静的ファイルの設定、タイムゾーン、言語設定など、プロジェクトの挙動に関する重要な設定がここに集約されています。
    • mysite/urls.py: プロジェクト全体のURL定義を記述するファイルです。どのURLパターン（例: /about/, /products/）が、どのビュー関数（ユーザーに返すコンテンツを生成するPython関数）に対応するかをここで設定します。
    • mysite/wsgi.py: Web Server Gateway Interface (WSGI) を使用して、DjangoアプリケーションをWebサーバーにデプロイするための設定ファイルです。本番環境で必要になります。
    • mysite/asgi.py: Asynchronous Server Gateway Interface (ASGI) を使用して、DjangoアプリケーションをWebサーバーにデプロイするための設定ファイルです。リアルタイム通信（WebSocketなど）を扱う場合に必要になります。Django 3.0以降で追加されました。

settings.py の基本的な設定項目（簡単な紹介）

mysite/settings.py ファイルを開いてみましょう。多くの設定がすでに記述されています。現時点ですべてを理解する必要はありませんが、特に重要な項目をいくつか紹介します。

  • SECRET_KEY: 秘密鍵です。セキュリティ上非常に重要なので、この値は誰にも知られないようにし、本番環境では安全な方法で管理する必要があります。
  • DEBUG: デバッグモードを有効にするか無効にするかの真偽値 (TrueまたはFalse)。開発中はTrueにしておくと、エラー発生時に詳細なデバッグ情報が表示されます。本番環境では必ずFalseにする必要があります。
  • ALLOWED_HOSTS: このDjangoサイトが応答を許可するホスト名（ドメイン名）のリストです。DEBUG=True の場合は ['*'] としておくと開発しやすいですが、本番環境では必ずサイトのドメイン名を正確に指定する必要があります。
  • INSTALLED_APPS: このDjangoプロジェクトで使用するアプリケーション（組み込みアプリや自分で作成するアプリ、サードパーティ製アプリなど）をリスト形式で指定します。初期状態ですでにDjangoが提供する基本的な機能（認証、管理サイトなど）が登録されています。
  • MIDDLEWARE: リクエスト/レスポンス処理の間に挟まるミドルウェアのリストです。セキュリティ、セッション、CORSなどの処理を行います。
  • ROOT_URLCONF: プロジェクト全体のURL定義が記述されたファイルのパスを指定します。デフォルトでは 'mysite.urls' となっており、mysite/urls.py ファイルを指しています。
  • TEMPLATES: テンプレートエンジンの設定です。HTMLファイルなどを表示する際に使用します。
  • DATABASES: データベース接続設定です。デフォルトではSQLiteという軽量なデータベースが設定されています。
  • TIME_ZONE: プロジェクトで使用するタイムゾーンです。デフォルトは 'UTC' ですが、例えば 'Asia/Tokyo' に変更することもできます。
  • LANGUAGE_CODE: プロジェクトで使用する言語コードです。デフォルトは 'en-us' ですが、例えば 'ja' に変更することもできます。
  • STATIC_URL: 静的ファイル（CSS, JavaScript, 画像など）にアクセスするためのURLパスです。デフォルトは '/static/' です。

これらの設定は、プロジェクトの要件に応じて後から変更していくことになります。

開発用サーバーの起動：最初のWebページを見てみよう

Djangoプロジェクトを作成したら、すぐにそれが動くか試してみましょう。Djangoには、開発中に便利な軽量のWebサーバーが組み込まれています。これを使って、作成したばかりのサイトにアクセスしてみます。

manage.py runserver コマンド

プロジェクトのルートディレクトリ（manage.pyファイルがあるディレクトリ）にいることを確認してください。そして、仮想環境がアクティベートされている状態で、以下のコマンドを実行します。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ python manage.py runserver

コマンド実行例:

“`
Watching for file changes with StatReloader
Performing system checks…

System check identified no issues (0 silenced).

You have 20 unapplied migration(s). Your project may not work properly until you apply the migrations for apps: admin, auth, contenttypes, sessions.
Run ‘python manage.py migrate’ to apply them.

November 14, 2023 – 10:00:00
Django version 4.2.7, using settings ‘mysite.settings’
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.
“`
(日時、バージョン番号、マイグレーションの数は環境によって異なります)

コマンド実行後の説明:

  • Performing system checks... System check identified no issues: Djangoがプロジェクトの設定などをチェックし、問題がないことを示しています。
  • You have X unapplied migration(s)... Run 'python manage.py migrate' to apply them.: これは、Djangoが提供する組み込みアプリケーション（認証システム、管理サイトなど）がデータベースに必要とするテーブルがまだ作成されていないことを示すメッセージです。後でmigrateコマンドを実行してデータベースを初期化します。現時点では無視して問題ありません。
  • Starting development server at http://127.0.0.1:8000/: これが重要です。 Djangoの開発用サーバーが起動し、ローカルマシンのIPアドレス 127.0.0.1 (または localhost) のポート番号 8000 で待ち受けを開始したことを示しています。

サーバーが起動したことの確認（ブラウザでのアクセス）

ウェブブラウザを開き、アドレスバーに以下のURLを入力してアクセスします。

http://127.0.0.1:8000/

または

http://localhost:8000/

すべてがうまくいっていれば、Djangoのデフォルトのランディングページが表示されるはずです。「The install worked successfully! Congratulations!」といったメッセージと、ロケットが飛び立つアニメーションが表示されるページです。

このページが表示されれば、Djangoプロジェクトが正しく作成され、開発用サーバーが正常に起動していることが確認できます。おめでとうございます！Web開発の世界への第一歩を踏み出しました！

補足: ポート番号の変更

runserverコマンドはデフォルトでポート8000を使用します。もしポート8000がすでに他のアプリケーションで使用されている場合や、別のポートを使いたい場合は、コマンド実行時にポート番号を指定できます。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ python manage.py runserver 8001

この場合、ブラウザでは http://127.0.0.1:8001/ にアクセスします。IPアドレスも指定できます。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ python manage.py runserver 0.0.0.0:8000

0.0.0.0 を指定すると、ローカルネットワーク上の他のコンピューターからもアクセス可能になります（開発 purposes only!）。ファイアウォールの設定などが必要な場合があります。

サーバー停止方法

開発用サーバーを停止するには、サーバーを起動したターミナルで Control + C (Windows/macOS/Linux共通) を押します。

bash
^CQuit the server with CONTROL-C.

これにより、サーバーが安全に停止されます。

ALLOWED_HOSTS と runserver の関係

settings.py の ALLOWED_HOSTS 設定は、そのDjangoサイトがどのホスト名（ドメイン名）でのアクセスを許可するかを制御します。開発用サーバー (runserver) は通常 DEBUG=True の状態で実行されるため、デフォルトでは ALLOWED_HOSTS の設定に関わらず localhost (127.0.0.1) および 127.0.0.1 が許可されます。

しかし、runserver コマンドで 0.0.0.0 や特定のローカルIPアドレスを指定して外部からアクセス可能にする場合、ALLOWED_HOSTS にそのIPアドレスやホスト名を追加しないとエラーになることがあります（特に DEBUG=False の場合）。開発中は通常 DEBUG=True で ALLOWED_HOSTS = ['*'] としておくと便利ですが、本番環境ではセキュリティのため必要なドメインのみを指定することが必須です。

最初のアプリケーションの作成：Webサイトの機能を開発する単位

Djangoプロジェクトは、Webサイト全体の骨組みや共通設定を管理するものです。一方、実際の機能（ブログ機能、お問い合わせフォーム、ショッピングカートなど）は「アプリケーション（App）」として開発します。Djangoの設計思想では、プロジェクトは複数の再利用可能なアプリケーションの集合体であると考えます。

例えば、ブログサイトを開発する場合、認証機能を提供するアプリケーション、記事投稿機能を提供するアプリケーション、コメント機能を提供するアプリケーション、といった具合に機能を分割して開発するのが一般的です。これにより、特定のアプリケーション（例: コメント機能）を別のDjangoプロジェクトで再利用することが容易になります。

プロジェクトとアプリケーションの関係

  • プロジェクト: Webサイト全体の設定、URLのトップレベルルーティング、インストールされているアプリケーションのリストなどを管理します。通常は1つのWebサイトに対して1つのプロジェクトを作成します。
  • アプリケーション: 特定の機能（ブログ記事管理、ユーザー認証など）を提供します。モデル（データ構造）、ビュー（ロジック）、URL定義などを持ちます。1つのプロジェクト内に複数のアプリケーションを含めることができます。

manage.py startapp コマンド

新しいアプリケーションを作成するには、プロジェクトのルートディレクトリ（manage.pyがある場所）で、仮想環境がアクティベートされた状態で manage.py startapp コマンドを実行します。コマンドの後に作成するアプリケーションの名前を指定します。ここでは、簡単なWebページを表示するためのアプリケーションとして myapp という名前で作成します。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ python manage.py startapp myapp

コマンド実行後、myprojectディレクトリの中身は以下のようになっているはずです。

myproject/
├── .venv/
├── manage.py
├── myapp/ # ★新しく作成されたアプリケーションディレクトリ
│ ├── migrations/
│ │ └── __init__.py
│ ├── __init__.py
│ ├── admin.py
│ ├── apps.py
│ ├── models.py
│ ├── tests.py
│ └── views.py
└── mysite/
├── __init__.py
├── asgi.py
├── settings.py
├── urls.py
└── wsgi.py

myappという新しいディレクトリが作成され、その中にアプリケーション開発に必要な基本的なファイルが生成されました。

アプリ作成後のディレクトリ構成の説明

作成されたmyappディレクトリ内のファイルやディレクトリの役割を簡単に説明します。

  • myapp/migrations/:
    データベースのスキーマ（テーブル構造など）の変更履歴を管理するディレクトリです。後述するマイグレーションシステムが使用します。
  • myapp/__init__.py:
    このディレクトリがPythonパッケージであることを示すための空ファイルです。
  • myapp/admin.py:
    Djangoの管理サイトに、このアプリケーションのモデル（データ）を表示・編集するための設定を記述するファイルです。
  • myapp/apps.py:
    このアプリケーションの設定（名前、シグナルハンドラなど）を定義するファイルです。
  • myapp/models.py:
    アプリケーションで使用するデータの構造（データベースのテーブル定義） を記述するファイルです。DjangoのORM (Object-Relational Mapper) を使用して、Pythonのクラスとして定義します。
  • myapp/tests.py:
    このアプリケーションのテストコードを記述するファイルです。
  • myapp/views.py:
    Webリクエストを処理し、HTTPレスポンスを生成するロジック を記述するファイルです。ユーザーが見るWebページの内容を生成するコア部分です。

作成したアプリをプロジェクトに登録 (settings.py の INSTALLED_APPS)

アプリケーションを作成しただけでは、プロジェクトはまだそのアプリケーションの存在を知りません。作成したアプリケーションをプロジェクトに認識させるためには、プロジェクトのsettings.pyファイルにそのアプリケーションを登録する必要があります。

myproject/mysite/settings.pyファイルを開き、INSTALLED_APPSリストに 'myapp' を追加します。

“`python

myproject/mysite/settings.py の一部

INSTALLED_APPS = [
‘django.contrib.admin’,
‘django.contrib.auth’,
‘django.contrib.contenttypes’,
‘django.contrib.sessions’,
‘django.contrib.messages’,
‘django.contrib.staticfiles’,
# ★ 作成したアプリケーションをここに追加します
‘myapp’,
]

… その他の設定

“`

これで、プロジェクトがmyappアプリケーションを使用できるようになりました。Djangoが提供する組み込みアプリケーション（django.contrib.adminなど）と一緒に、あなたが作成したmyappもプロジェクトの一部として認識されるようになります。

簡単なビューとURLマッピング：Webページを表示するロジックと経路

Webリクエストを受け取ったDjangoは、どのコードを実行してレスポンスを生成するかを判断する必要があります。この処理の流れは、主に「URLマッピング（ルーティング）」と「ビュー」によって制御されます。

  • URLマッピング: ユーザーがブラウザでアクセスしたURL（例: /hello/）と、そのリクエストを処理するPythonコード（ビュー関数やクラス）を結びつける設定です。プロジェクトのurls.pyと、各アプリケーションのurls.pyで定義します。
  • ビュー: Webリクエストを受け取り、必要なデータ処理を行い、最終的にHTTPレスポンス（WebページのHTML、JSONデータ、リダイレクトなど）を生成するPython関数またはクラスです。通常はアプリケーションのviews.pyファイルに記述します。

このセクションでは、「Hello, world!」と表示するだけのシンプルなビューを作成し、そのビューにアクセスするためのURLを設定します。

views.py でシンプルなビュー関数を作成

myproject/myapp/views.pyファイルを開き、既存の内容を以下のコードで置き換えるか、追記します。

“`python

myproject/myapp/views.py

from django.http import HttpResponse

def hello(request):
“””
簡単な「Hello, world!」を表示するビュー。
“””
return HttpResponse(“Hello, world!”)

“`

コードの説明:

  • from django.http import HttpResponse: Webレスポンスを生成するために必要なHttpResponseクラスをインポートしています。
  • def hello(request):: helloという名前のPython関数を定義しています。これはDjangoのビュー関数として機能します。ビュー関数は、通常第一引数としてrequestオブジェクトを受け取ります。このrequestオブジェクトには、ユーザーからのリクエストに関する情報（GET/POSTデータ、ヘッダーなど）が含まれています。
  • return HttpResponse("Hello, world!"): HttpResponseオブジェクトを生成して返しています。HttpResponseオブジェクトは、Webブラウザに返す内容（ここでは"Hello, world!"という文字列）と、それがHTTPレスポンスであることをDjangoに伝えます。この文字列がそのままブラウザに表示されます。

これで、Webリクエストを処理するためのビュー関数が作成されました。

URLマッピングの設定

次に、作成したhelloビュー関数にアクセスするためのURLを設定します。URL設定は、プロジェクトのurls.pyとアプリケーションのurls.pyの連携によって行われます。

  1. アプリ内の urls.py を作成・編集

    まず、myappディレクトリの中にurls.pyという新しいファイルを作成します。

    myproject/myapp/urls.py

    “`python

    myproject/myapp/urls.py

    from django.urls import path
    from . import views

    urlpatterns = [
    path(‘hello/’, views.hello, name=’hello’),
    ]
    “`

    コードの説明:

    • from django.urls import path: URLマッピングを定義するために必要なpath関数をインポートします。
    • from . import views: 同じディレクトリ（.）にあるviews.pyモジュールをインポートし、viewsという名前で使用できるようにします。
    • urlpatterns = [...]: このリストに、URLパターンとそのパターンに対応するビュー関数のペアを定義していきます。Djangoはurlpatternsという名前のリストを検索します。
    • path('hello/', views.hello, name='hello'): これがURLマッピングの定義です。
      • 第一引数 'hello/': マッチさせたいURLパターンです。プロジェクト全体のURL設定からの相対パスで指定します。ここでは、後述するプロジェクト側の設定と組み合わせることで /myapp/hello/ というURLにマッチするようになります。パスの末尾にスラッシュ/を付けるのがDjangoの慣習です。
      • 第二引数 views.hello: このパターンにマッチした場合に実行されるビュー関数（またはクラス）です。ここでは、先ほどmyapp/views.pyで定義したhello関数を指定しています。
      • 第三引数 name='hello' (オプション): このURLパターンに名前を付けることができます。テンプレートやビューの中で、ハードコーディングせずにURLを逆引き（名前からURLを生成）する際に便利です。ここでは 'hello' という名前を付けています。

  2. プロジェクトの urls.py からアプリの urls.py をインクルード

    次に、プロジェクト全体のURL設定ファイルであるmyproject/mysite/urls.pyを開き、先ほど作成したアプリケーションのURL設定を読み込む（インクルードする）ように設定します。

    myproject/mysite/urls.pyを開き、以下の変更を行います。

    “`python

    myproject/mysite/urls.py

    from django.contrib import admin
    from django.urls import path, include # ★ include関数をインポート

    urlpatterns = [
    path(‘admin/’, admin.site.urls),
    # ★ myappアプリケーションのURL設定をインクルード
    path(‘myapp/’, include(‘myapp.urls’)),
    ]
    “`

    変更の説明:

    • from django.urls import path, include: include関数を追加でインポートします。この関数は、他のURL設定モジュールを読み込むために使用します。
    • path('myapp/', include('myapp.urls')): これがアプリケーションのURL設定をインクルードする設定です。
      • 第一引数 'myapp/': このパターンにマッチした場合、以降のURLパスをinclude関数で指定されたURL設定モジュールに引き渡します。つまり、/myapp/ で始まるURLは、myappアプリケーションのURL設定（myapp/urls.py）で定義されたパターンと比較されるようになります。
      • 第二引数 include('myapp.urls'): myappディレクトリ内のurls.pyモジュールを読み込むことをDjangoに伝えます。'myapp.urls'という文字列は、Pythonのモジュールパスを示しています。

この設定により、ユーザーが http://127.0.0.1:8000/myapp/hello/ のようなURLにアクセスした場合、以下の流れで処理されます。

  1. DjangoがリクエストURL /myapp/hello/ を受け取る。
  2. プロジェクトのurls.py (myproject/mysite/urls.py) を見る。
  3. urlpatternsリスト内の path('myapp/', include('myapp.urls')) にマッチすることを確認する（/myapp/ の部分にマッチ）。
  4. マッチした部分 (/myapp/) を取り除いた残りのパス /hello/ を、myapp.urls で定義されたURL設定に引き渡す。
  5. myapp/urls.py を見る。
  6. urlpatternsリスト内の path('hello/', views.hello, name='hello') にマッチすることを確認する（/hello/ の部分にマッチ）。
  7. このパターンに対応するビュー関数 views.hello を実行する。
  8. views.hello 関数が HttpResponse("Hello, world!") を返す。
  9. Djangoがそのレスポンスをユーザーのブラウザに返す。

開発用サーバーを再起動して変更を確認

設定ファイルを変更した場合は、通常、開発用サーバーを再起動する必要があります。（StatReloaderが有効な場合は自動でリロードされることもありますが、確実を期すため再起動するのが良いでしょう。）

サーバーを停止 (Control + C) してから、再度起動します。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ python manage.py runserver

サーバー起動後、ブラウザで以下のURLにアクセスします。

http://127.0.0.1:8000/myapp/hello/

ブラウザに「Hello, world!」と表示されれば成功です！ これで、あなたが書いたコードがWebブラウザに表示される最初のステップを完了しました。

もしエラーが表示される場合は、ターミナルに表示されたエラーメッセージを確認してください。スペルミス、ファイルのパスの指定ミス、settings.pyにアプリを登録し忘れている、などがよくある原因です。

データベースの設定とマイグレーション：データを扱う準備

Webアプリケーションの多くは、データを保存し、取得し、操作する必要があります。DjangoはObject-Relational Mapper (ORM) と呼ばれる仕組みを提供しており、Pythonコードを使ってデータベースとやり取りできます。データベースを使い始める前に、いくつかの初期設定と準備が必要です。

DjangoのORM (Object-Relational Mapper) について

ORMとは、データベースのテーブルとPythonのクラス（オブジェクト）を対応づける仕組みです。開発者はSQLクエリを直接書く代わりに、Pythonのオブジェクトやメソッドを使ってデータベース操作を行うことができます。これにより、データベースの種類（SQLite, PostgreSQL, MySQLなど）を意識せずにコードを書くことができ、開発効率が向上します。DjangoのORMは非常に強力で、多くの一般的なデータベース操作を抽象化してくれます。

デフォルトのデータベース (SQLite)

Djangoプロジェクトを作成した際、settings.pyのDATABASES設定には、デフォルトでSQLiteというデータベースが設定されています。

“`python

myproject/mysite/settings.py の一部

DATABASES = {
‘default’: {
‘ENGINE’: ‘django.db.backends.sqlite3’,
‘NAME’: BASE_DIR / ‘db.sqlite3’,
}
}
“`

SQLiteは、軽量でセットアップが不要なファイルベースのデータベースです。開発 purposes onlyに適しており、別途データベースサーバーをインストール・設定する必要がないため、手軽に開発を始められます。プロジェクトのルートディレクトリにdb.sqlite3という名前のファイルとして作成されます。本番環境では、通常PostgreSQLやMySQLなどのより堅牢で高性能なデータベースを使用します。

マイグレーションとは何か？

Djangoの「マイグレーション」システムは、データベースのスキーマ（テーブルやカラムなどの構造）の変更を追跡し、それらの変更をデータベースに適用するための仕組みです。

あなたはmodels.pyファイルでPythonのクラスとしてデータの構造を定義します。マイグレーションシステムは、これらのモデル定義の変更を検知し、データベース側でその構造を実現するための変更手順（マイグレーションファイル）を自動的に生成します。そして、そのマイグレーションファイルをデータベースに適用することで、実際にデータベースのテーブルが作成されたり変更されたりします。

マイグレーションを使うことで、データベーススキーマの変更をバージョン管理し、複数の開発者間での共有や、開発環境から本番環境への反映を効率的に行うことができます。

プロジェクト作成時に表示された「You have X unapplied migration(s)…」というメッセージは、Djangoの組み込みアプリケーション（認証、管理サイトなど）が使用するデータベーステーブルを作成するための初期マイグレーションが、まだデータベースに適用されていないことを意味しています。

manage.py makemigrations コマンド

このコマンドは、models.pyファイル（または他の場所で定義されたモデル）に対する変更を検知し、その変更をデータベースに適用するためのマイグレーションファイルを生成します。まだモデルを定義していませんが、プロジェクト作成時にすでにいくつかの組み込みアプリのモデルが存在するため、初期マイグレーションが保留状態になっています。

まず、このコマンドを実行してみましょう。プロジェクトのルートディレクトリで実行します。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ python manage.py makemigrations

コマンド実行例:

No changes detected

(まだ自分でモデルを定義していないため、「変更なし」となるはずです)

初期状態では、すでにプロジェクト作成時に組み込みアプリのマイグレーションファイルは生成されているため、このコマンドを再度実行しても「No changes detected」となります。今後、models.pyを編集して新しいモデルを追加したり、既存のモデルを変更したりした場合に、このコマンドを実行すると、変更を反映するためのマイグレーションファイルがmyapp/migrations/ディレクトリなどに生成されます。

manage.py migrate コマンド

このコマンドは、保留状態になっているマイグレーション（makemigrationsで生成されたファイル群）をデータベースに適用します。これにより、データベースのスキーマがマイグレーションファイルの状態に更新されます。

プロジェクト作成時に表示された組み込みアプリのマイグレーションをデータベースに適用するために、このコマンドを実行します。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ python manage.py migrate

コマンド実行例:

Operations to perform:
Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
Applying contenttypes.0001_initial... OK
Applying auth.0001_initial... OK
Applying admin.0001_initial... OK
Applying admin.0002_logentry_remove_auto_add... OK
Applying admin.0003_logentry_add_action_flag_choices... OK
Applying contenttypes.0002_remove_content_type_name... OK
Applying auth.0002_alter_permission_name_max_length... OK
Applying auth.0003_alter_user_permissions_alter_user_with_groups... OK
Applying auth.0004_alter_user_username_opts... OK
Applying auth.0005_alter_user_last_login_null... OK
Applying auth.0006_require_contenttypes_0002... OK
Applying auth.0007_alter_validators_add_error_messages... OK
Applying auth.0008_alter_user_username_max_length... OK
Applying auth.0009_alter_user_last_name_max_length... OK
Applying auth.0010_alter_group_name_max_length... OK
Applying auth.0011_update_proxy_permissions... OK
Applying auth.0012_alter_user_first_name_max_length... OK
Applying sessions.0001_initial... OK

(表示されるマイグレーション名や数はDjangoのバージョンによって異なります)

OKと表示されていれば、各マイグレーションが正常にデータベースに適用されたことを意味します。これにより、認証システムや管理サイトなどが使用するデータベーステーブルが、myproject/db.sqlite3ファイル内に作成されました。

migrateコマンドは、まだ適用されていないマイグレーションのみを自動的に判断して実行します。複数回実行しても、すでに適用済みのマイグレーションはスキップされるため安全です。

データベースブラウザを使った確認方法（任意）

SQLiteデータベースの内容を確認したい場合は、DB Browser for SQLiteなどのGUIツールを使うと便利です。myproject/db.sqlite3ファイルをこれらのツールで開くと、作成されたテーブル（例: auth_user, django_admin_log, django_sessionなど）を確認できます。

これで、あなたのDjangoプロジェクトはデータを保存するための準備が整いました。

管理サイト：Djangoの便利な機能を使ってみよう

Djangoには、プロジェクトに組み込まれたアプリケーションのデータ（データベースの内容）を管理するための、強力で自動生成される管理サイト機能が標準で含まれています。これは、開発者や管理者が簡単にデータを閲覧、追加、編集、削除できる非常に便利なツールです。

manage.py migrateコマンドを実行したことで、管理サイトに必要なデータベーステーブルも作成済みです。管理サイトを使うには、まず管理ユーザーを作成する必要があります。

スーパーユーザーの作成 (manage.py createsuperuser)

管理サイトにログインするには、権限を持つユーザーが必要です。特に、すべての権限を持つ「スーパーユーザー」を作成するのが一般的です。

プロジェクトのルートディレクトリで、仮想環境がアクティベートされた状態で、以下のコマンドを実行します。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ python manage.py createsuperuser

コマンド実行例:

Username: (Leave blank to use 'your_username') # ユーザー名を入力 (省略可)
Email address: # メールアドレスを入力 (省略可)
Password: # パスワードを入力 (入力内容は表示されない)
Password (again): # パスワードを再入力
Superuser created successfully.

画面の指示に従って、ユーザー名、メールアドレス、パスワードを入力します。パスワード入力時にはセキュリティのために文字が表示されませんが、そのまま入力してEnterキーを押してください。確認のため、パスワードを再度入力する必要があります。

「Superuser created successfully.」と表示されれば、スーパーユーザーの作成は成功です。入力したユーザー名とパスワードは、後で管理サイトにログインする際に必要になります。

管理サイトへのログイン

開発用サーバーが起動していることを確認してください。（起動していなければ python manage.py runserver で起動します。）

ブラウザを開き、管理サイトのURLにアクセスします。デフォルトでは settings.py の ROOT_URLCONF で設定されたURLの /admin/ パスにマッピングされています。

http://127.0.0.1:8000/admin/

アクセスすると、ログイン画面が表示されます。

ここで、先ほど createsuperuser コマンドで作成したスーパーユーザーのユーザー名とパスワードを入力してログインします。

ログインに成功すると、Djangoの管理サイトのダッシュボードが表示されます。ここには、認証と認可に関するグループやユーザーの管理画面が表示されているはずです。これらは、プロジェクト作成時にデフォルトで含まれている組み込みアプリケーションの機能です。

モデルを管理サイトに登録 (admin.py)

デフォルトの状態では、あなたが作成したmyappアプリケーションで定義したモデル（まだ定義していませんが）は、この管理サイトには表示されません。管理サイトで独自のデータを操作できるようにするには、各アプリケーションのadmin.pyファイルで、そのアプリケーションのモデルを管理サイトに登録する必要があります。

例えば、myapp/models.pyでPostというモデルを作成した場合、myapp/admin.pyを編集して以下のように記述します。

“`python

myproject/myapp/admin.py

from django.contrib import admin
from .models import Post # ★ あなたが定義したモデルをインポート

★ モデルを管理サイトに登録

admin.site.register(Post)
“`

こうすることで、管理サイトのダッシュボードに「Post」という項目が表示され、そこからデータベースに保存されたPostデータを一覧表示したり、新しいPostを追加したり、既存のPostを編集・削除したりできるようになります。

これは非常に強力な機能で、データの入力や管理が必要な多くのアプリケーションにおいて、管理画面をゼロから開発する手間を大幅に省くことができます。Djangoのモデルを定義するだけで、すぐに動く管理インターフェースが手に入るのです。

現時点ではmyappにはモデルがないため、myapp/admin.pyは編集不要ですが、今後モデルを作成した際にはこの手順が必要になります。

テンプレートの使用：動的なHTMLページを生成する

先ほどはHttpResponseを使って「Hello, world!」という文字列を直接ブラウザに表示しました。しかし、実際のWebサイトは、ヘッダー、フッター、CSSでの装飾、動的に変わるコンテンツなどを持つ、複雑なHTML構造でできています。

Djangoは、このような動的なHTMLページを効率的に生成するために、テンプレートという仕組みを提供しています。テンプレートは、静的なHTML構造の中に、Pythonコードから渡されたデータを埋め込んだり、簡単なロジック（条件分岐、ループなど）を記述したりできるファイルです。

MTVパターンでいうところの「T (Template)」にあたる部分です。ビュー（V）はデータを取得し、そのデータをテンプレート（T）に渡し、テンプレートエンジンがデータを使って最終的なHTMLを生成し、それをビューがレスポンスとして返します。

HTMLファイルを返すビューの作成

myapp/views.py を編集し、HttpResponseではなく、テンプレートを使ってHTMLを返すように変更します。Djangoでは、テンプレートを読み込んでレンダリングするために render() 関数がよく使われます。

“`python

myproject/myapp/views.py

from django.shortcuts import render # ★ render関数をインポート

def hello(request):

return HttpResponse(“Hello, world!”) # これはコメントアウトするか削除

def hello_template(request):
“””
テンプレートを使って「Hello, Django!」を表示するビュー。
“””
# テンプレートに渡すデータを辞書形式で定義
context = {
‘message’: ‘Hello, Django!’,
‘title’: ‘Django Template Example’
}
# テンプレートファイルを指定し、コンテキストデータを渡してレンダリング
return render(request, ‘myapp/hello.html’, context)
“`

コードの説明:

  • from django.shortcuts import render: render関数をインポートします。この関数は、リクエストオブジェクト、テンプレートファイルのパス、テンプレートに渡したいコンテキストデータ（辞書）を受け取り、レンダリングされたHttpResponseオブジェクトを返します。
  • def hello_template(request):: 新しいビュー関数hello_templateを定義しました。
  • context = { ... }: テンプレートに渡したいデータをPythonの辞書として定義しています。辞書のキー（'message', 'title')が、テンプレート内で変数名として使用できるようになります。
  • return render(request, 'myapp/hello.html', context):
    • 第一引数 request: リクエストオブジェクト。
    • 第二引数 'myapp/hello.html': 使用するテンプレートファイルのパスです。Djangoは後述するテンプレートディレクトリの設定に基づいてこのファイルを検索します。慣習的に アプリ名/テンプレートファイル名 の形式で指定することが多いです。
    • 第三引数 context: テンプレートに渡すコンテキストデータ辞書です。省略可能です。

テンプレートディレクトリの設定 (settings.py の TEMPLATES)

Djangoは、どこにテンプレートファイルが置かれているかをどのように知るのでしょうか？ これは、settings.pyのTEMPLATES設定で定義されます。プロジェクト作成時に、すでに基本的な設定がされています。

“`python

myproject/mysite/settings.py の一部

TEMPLATES = [
{
‘BACKEND’: ‘django.template.backends.django.DjangoTemplates’,
‘DIRS’: [], # ★ ここにテンプレートディレクトリを追加することが多い
‘APP_DIRS’: True, # ★ これがTrueの場合、INSTALLED_APPS内の各アプリの’templates’サブディレクトリを自動で探す
‘OPTIONS’: {
‘context_processors’: [
‘django.template.context_processors.debug’,
‘django.template.context_processors.request’,
‘django.contrib.auth.context_processors.auth’,
‘django.contrib.messages.context_processors.messages’,
],
},
},
]
“`

重要なのは APP_DIRS: True の設定です。これがTrueになっていると、DjangoはINSTALLED_APPSに登録されている各アプリケーションディレクトリ内のtemplatesという名前のサブディレクトリを自動的に探し、その中にあるテンプレートファイルを使用します。

先ほどのビュー関数で 'myapp/hello.html' と指定したのは、myappアプリケーションディレクトリ直下のtemplatesディレクトリの中に、さらにmyappという名前のサブディレクトリを作成し、その中にhello.htmlを置くという慣習的な配置方法に基づいています。これは、複数のアプリケーションが同じ名前のテンプレートファイル（例: base.html）を持つ場合に、名前の衝突を防ぐための良い方法です。

テンプレートファイル（.html）の作成

myappディレクトリの中にtemplatesディレクトリを新しく作成し、さらにその中にmyappというディレクトリを作成します。そして、そのmyappディレクトリの中にhello.htmlファイルを作成します。

myproject/
├── .venv/
├── manage.py
├── myapp/
│ ├── migrations/
│ ├── templates/ # ★ 新しく作成
│ │ └── myapp/ # ★ 新しく作成 (アプリ名と同じにするのが慣習)
│ │ └── hello.html # ★ 新しく作成
│ ├── __init__.py
│ ├── admin.py
│ ├── apps.py
│ ├── models.py
│ ├── tests.py
│ └── views.py
└── mysite/
├── __init__.py
├── asgi.py
├── settings.py
├── urls.py
└── wsgi.py

myproject/myapp/templates/myapp/hello.html ファイルを以下の内容で作成します。

“`html




{{ title }} {# ★ コンテキストから渡された ‘title’ 変数を表示 #}

{{ message }}

{# ★ コンテキストから渡された ‘message’ 変数を表示 #}

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

{# テンプレートタグの例: for ループ #}
{% comment “これはコメントです。ブラウザには表示されません” %}{% endcomment %}
{# {% if some_condition %}

条件が真の場合

{% else %}

条件が偽の場合

{% endif %} #}

“`

テンプレートコードの説明:

  • {{ variable_name }}: これはDjangoテンプレートの変数タグです。ビューからrender()関数のcontext引数として渡された辞書内のキーに対応する値が表示されます。ここでは、context辞書の'title'と'message'の値が表示されます。
  • {% tag_name parameters %}: これはDjangoテンプレートのテンプレートタグです。表示ロジック（ループ、条件分岐、テンプレートの継承など）を実行するために使用されます。
    • {% comment ... %}: 複数行のコメントタグです。
    • 他の一般的なタグとして、{% for item in list %} (ループ)、{% if condition %} (条件分岐)、{% extends "base.html" %} (テンプレート継承)、{% load static %} (静的ファイルの読み込み) などがあります。

テンプレートエンジンは、このhello.htmlファイルを読み込み、{{ ... }}や{% ... %}の部分を処理して、最終的なHTML文字列を生成します。

URLマッピングの更新

最後に、myapp/urls.pyを編集して、URL /myapp/hello/ が新しいビュー関数 hello_template を呼び出すように変更します。

“`python

myproject/myapp/urls.py

from django.urls import path
from . import views

urlpatterns = [
# path(‘hello/’, views.hello, name=’hello’), # 古いビューはコメントアウトまたは削除
path(‘hello/’, views.hello_template, name=’hello_template’), # ★ 新しいビュー関数を指定
]
“`

これで、/myapp/hello/へのアクセスはhello_templateビューによって処理され、myapp/templates/myapp/hello.htmlテンプレートがレンダリングされて表示されるようになります。

開発用サーバーを再起動して変更を確認

サーバーを停止 (Control + C) してから、再度起動します。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ python manage.py runserver

サーバー起動後、ブラウザで以下のURLにアクセスします。

http://127.0.0.1:8000/myapp/hello/

今度は、hello.htmlの内容がレンダリングされたWebページが表示されるはずです。ブラウザのタブタイトルが「Django Template Example」となり、ページ本文に「Hello, Django!」という見出しと「これはDjangoテンプレートを使ったページです。」という段落が表示されていれば成功です！

これにより、Djangoで動的なWebページを表示する基本的な流れ（URL → ビュー → テンプレート → レスポンス）を体験しました。

静的ファイル：CSSや画像を扱う

ほとんどのWebサイトは、HTMLだけでなく、スタイルを定義するためのCSSファイル、インタラクティブな機能を追加するためのJavaScriptファイル、そして画像ファイルといった「静的ファイル」を使用します。Djangoはこれらの静的ファイルを扱うための仕組みも提供しています。

静的ファイルディレクトリの設定 (settings.py の STATIC_URL, STATICFILES_DIRS)

settings.pyには、静的ファイルに関する基本的な設定がデフォルトで含まれています。

“`python

myproject/mysite/settings.py の一部

STATIC_URL = ‘/static/’
“`

STATIC_URL = '/static/' は、静的ファイルにアクセスする際に使用するURLパスを定義します。例えば、style.cssという名前のCSSファイルを配置した場合、ブラウザからは /static/style.css というURLでアクセスできるようになります。

Djangoは、デフォルトで以下の場所を静的ファイルの置き場として探します。

  1. INSTALLED_APPS に登録されている各アプリケーションの直下にある static/ という名前のサブディレクトリ。
  2. settings.py の STATICFILES_DIRS リストで指定された追加のディレクトリ。

ここでは、プロジェクト全体で使用する静的ファイルを置くためのディレクトリを、プロジェクトのルートディレクトリ（manage.pyと同じ階層）に作成し、それを STATICFILES_DIRS に登録する方法を見てみましょう。

プロジェクトのルートディレクトリに static というディレクトリを作成します。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ mkdir static

次に、myproject/mysite/settings.pyを開き、STATICFILES_DIRSにこのディレクトリを追加します。

“`python

myproject/mysite/settings.py の一部

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

… (他の設定)

STATIC_URL = ‘/static/’

★ プロジェクト全体の静的ファイルを置くディレクトリを指定

STATICFILES_DIRS = [
BASE_DIR / ‘static’, # Python 3.4以降のpathlibを使う場合
# または OSモジュールを使う場合: os.path.join(BASE_DIR, ‘static’),
]

… (他の設定)

“`

BASE_DIR は、プロジェクトのルートディレクトリを指すようにsettings.pyの先頭付近で定義されています。BASE_DIR / 'static' は、myproject/static/ というパスを表現しています。

これで、myproject/static/ ディレクトリに置いたファイルが、/static/ というURLでアクセスできるようになります。

テンプレートでの静的ファイルの参照方法 ({% static %} タグ)

テンプレート内で静的ファイル（CSS、JS、画像など）へのリンクを記述する際は、ハードコーディングするのではなく、{% static %} テンプレートタグを使用することを強く推奨します。このタグは、settings.py の STATIC_URL 設定値を考慮して、適切な静的ファイルのURLを生成してくれます。これにより、将来 STATIC_URL を変更した場合でもテンプレートのコードを修正する必要がなくなります。

{% static %} タグを使用するには、テンプレートファイルの先頭で {% load static %} を宣言する必要があります。

先ほど作成した myproject/myapp/templates/myapp/hello.html ファイルを編集し、CSSファイルを読み込む例を追加してみましょう。まず、簡単なCSSファイルを作成します。

myproject/static/style.css ファイルを以下の内容で作成します。

“`css
/ myproject/static/style.css /

body {
font-family: sans-serif;
background-color: #f0f0f0;
margin: 20px;
}

h1 {
color: #333;
}
“`

次に、myproject/myapp/templates/myapp/hello.html ファイルを編集します。

“`html
{% load static %} {# ★ テンプレートタグをロード #}




{{ title }}
{# ★ CSSファイルを読み込む #}

{{ message }}

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


“`

変更の説明:

  • {% load static %}: staticテンプレートタグを使用可能にするための宣言です。
  • <link rel="stylesheet" href="{% static 'style.css' %}">: {% static 'style.css' %} タグは、settings.py の STATIC_URL (/static/) と引数 'style.css' を組み合わせて、/static/style.css というURLを生成します。これにより、ブラウザは作成したCSSファイルを読み込みに行きます。

開発中の静的ファイルの提供

開発用サーバー (python manage.py runserver) は、デフォルトでsettings.pyで設定された静的ファイルディレクトリから静的ファイルを自動的に提供します。そのため、上記の設定とファイル配置を行えば、すぐにブラウザから /static/style.css にアクセスできるようになり、テンプレートで読み込まれたCSSが適用されます。

開発用サーバーを再起動して変更を確認

サーバーを停止 (Control + C) してから、再度起動します。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ python manage.py runserver

サーバー起動後、ブラウザで以下のURLにアクセスします。

http://127.0.0.0.1:8000/myapp/hello/

ページが表示された際に、CSSが適用され、フォントや背景色が変わっていれば成功です。

本番環境での静的ファイルの扱い (manage.py collectstatic)

重要: 開発用サーバーが静的ファイルを提供するのは、あくまで開発を容易にするためです。本番環境では、開発用サーバーを使って静的ファイルを提供してはいけません。 本番環境では、より効率的で安全な方法（Webサーバー自身やCDNなど）で静的ファイルを提供します。

本番環境にデプロイする際は、manage.py collectstaticコマンドを実行します。このコマンドは、プロジェクトで使用されているすべての静的ファイル（各アプリケーションのstatic/ディレクトリやSTATICFILES_DIRSで指定したディレクトリ内のファイル）を、settings.pyのSTATIC_ROOTで指定された一つのディレクトリに収集します。

bash
(.venv) your_username@your_computer:~/Desktop/myproject$ python manage.py collectstatic

このSTATIC_ROOTディレクトリを、本番環境のWebサーバーが直接静的ファイルとして配信するように設定します。この詳細は本記事の範囲外ですが、Djangoアプリケーションを本番環境にデプロイする際には必須のステップとなります。

これで、Djangoで基本的なWebページを作成し、静的ファイルを使ってスタイルを適用する方法を学びました。

次に学ぶこと：Djangoの更なる世界へ

この記事では、Djangoのインストールから最初のプロジェクト・アプリケーション作成、簡単なWebページの表示、データベースの初期設定、管理サイトの概要、そして静的ファイルの扱いまでを駆け足で学びました。これらはDjangoを使ったWeb開発のほんの入り口に過ぎません。

Djangoには、Webアプリケーション開発で必要となる多くの機能があらかじめ用意されています。次に学ぶべき重要なトピックをいくつか紹介します。

  • モデルとORMの詳細: データベースのテーブル構造をPythonクラスで定義し、Pythonコードでデータを操作する方法をさらに深く学びます。リレーションシップ（ForeignKeyなど）やモデルメソッド、クエリセットの使い方などが含まれます。
  • フォーム: ユーザーからの入力を受け取るためのフォームを生成し、入力データのバリデーション（検証）、処理を行う方法です。セキュリティの高いフォームを簡単に作成できます。
  • 汎用ビュー (Class-based Views): 一般的なWeb開発のパターン（オブジェクトのリスト表示、詳細表示、フォームを使った作成・更新・削除など）をクラスベースで効率的に記述するための仕組みです。関数ベースビューよりもコード量を減らせることが多いです。
  • テンプレートの継承: 共通のレイアウトを持つ複数のページを作成する際に、重複するコードを減らすための仕組みです。ベーステンプレートを作成し、他のテンプレートがそれを継承して必要な部分だけを記述します。
  • 認証・認可システム: ユーザーの登録、ログイン、ログアウト、そして特定のユーザーだけがアクセスできるページを作成する方法です。Djangoには強力な認証システムが標準で組み込まれています。
  • テスト: 作成したコード（ビュー、モデル、フォームなど）が意図通りに動作するかを自動的に検証するためのテストコードを記述する方法です。アプリケーションの品質を保つために非常に重要です。
  • デプロイ: 開発したDjangoアプリケーションを、インターネット上で公開されたサーバーで動作させる方法です。Webサーバー（Nginx, Apacheなど）、WSGIサーバー（Gunicorn, uWSGIなど）、データベースサーバーの設定など、様々な要素が含まれます。
  • 公式ドキュメントの活用: Djangoの公式ドキュメントは非常に詳細で質の高い情報源です。何か新しいことを知りたいとき、困ったときに最初に参照すべき場所です。

これらのトピックを一つずつ学んでいくことで、より複雑で実用的なWebアプリケーションを開発できるようになります。

まとめ：Django開発の第一歩を踏み出しました！

この記事では、以下のステップを通じてDjangoのインストールと最初の簡単なWebアプリケーション構築を行いました。

  1. Pythonとpipがインストールされていることを確認・セットアップしました。
  2. プロジェクトの依存関係を分離するために仮想環境を作成し、アクティベートしました。
  3. 仮想環境内にpip install DjangoコマンドでDjango本体をインストールしました。
  4. django-admin startprojectコマンドで新しいDjangoプロジェクトを作成しました。
  5. python manage.py runserverコマンドで開発用サーバーを起動し、デフォルトページを確認しました。
  6. python manage.py startappコマンドでアプリケーションを作成し、プロジェクトに登録しました。
  7. シンプルなビュー関数を作成し、URL設定とテンプレートを使って「Hello, world!」ならぬ「Hello, Django!」ページを表示しました。
  8. python manage.py migrateコマンドを実行し、データベースの初期設定を行いました。
  9. python manage.py createsuperuserコマンドで管理ユーザーを作成し、管理サイトの存在を確認しました。
  10. 静的ファイルの設定を行い、CSSを適用しました。

これらの手順は、どんなDjangoプロジェクトを開始する上でも基礎となるものです。最初は難しく感じる部分もあったかもしれませんが、各ステップの意味を理解し、実際に手を動かすことで、確実にDjango開発の基礎が身についたはずです。

Djangoは学習コストが比較的高いフレームワークと言われることもありますが、一度基本を習得してしまえば、Webアプリケーション開発の多くの側面を効率的に、かつ堅牢に行える強力なツールであることを実感できるでしょう。

この最初の成功体験を活かして、ぜひ次のステップに進んでください。公式ドキュメントを読んだり、チュートリアルを進めたり、簡単なアプリケーションを自分で考えたりして、楽しみながらDjangoのスキルを磨いていきましょう。

あなたのWeb開発の旅が素晴らしいものになることを願っています！

コメントする

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

上部へスクロール