age >= 20のような条件が1つだけなら読みやすいですが、実際のコードでは『20歳以上かつ会員』『管理者または本人』『空でないとき』のように複数条件がよく出てきます。

andは『全部』、orは『どれか』、notは『反対』。最初はこの3つの日本語に置き換えると読みやすくなります。

この記事では、and・or・notの基本、if文での使い方、True/Falseの考え方、初心者がつまずきやすい条件式を順番に整理します。

まず結論：andは全部、orはどれか、notは反対

Python公式ドキュメントでは、任意のオブジェクトは真偽値として判定でき、and・or・notはその真偽値を使う演算として説明されています。初心者の段階では、まず条件式を『TrueかFalseになる問い』として読みます。

andの使い方

andは、左右の条件がどちらも成り立つときにTrueとして扱います。

age = 25
has_ticket = True

if age >= 20 and has_ticket:
    print("入場できます")

この例では、age >= 20とhas_ticketの両方がTrueなので、if文の中が実行されます。比較演算子の基本が不安な場合は、Pythonの比較演算子も確認してください。

orの使い方

orは、左右の条件のどちらか一方でも成り立てばTrueとして扱います。

is_admin = False
is_owner = True

if is_admin or is_owner:
    print("編集できます")

この例では、管理者ではなくても本人であれば編集できます。条件を日本語で『管理者または本人なら』と読めると、コードの意味を追いやすくなります。

notの使い方

notは、条件の結果を反転します。TrueならFalse、FalseならTrueとして扱います。

name = ""

if not name:
    print("名前を入力してください")

空文字列は条件式の中でFalseとして扱われます。そのため、not nameは『名前が空なら』という意味で読めます。

True/Falseだけでなく空文字や空リストも関係する

Pythonでは、TrueやFalseだけでなく、空文字列、空リスト、0、Noneなども条件式の中でFalseとして扱われます。

この考え方は、while文やリスト処理でもよく出てきます。繰り返し条件の読み方はPythonのwhile文と合わせて理解するとつながります。

複数条件は括弧で読みやすくする

andとorが混ざると、どこまでが1つの条件なのか分かりにくくなります。初心者のうちは、必要に応じて括弧を使い、読む単位を明確にするのがおすすめです。

age = 18
has_parent_permission = True
has_ticket = True

if (age >= 20 or has_parent_permission) and has_ticket:
    print("入場できます")

この条件は『20歳以上または保護者の許可があり、かつチケットがある』と読みます。括弧があると、先に読むまとまりが見えます。

短絡評価をざっくり理解する

Pythonのandやorは、結果が決まった時点で残りの評価を省略することがあります。これを短絡評価と呼びます。

user = None

if user is not None and user.is_active:
    print("有効なユーザーです")

この例では、user is not NoneがFalseなら、右側のuser.is_activeは評価されません。Noneの値や型判定が曖昧な場合は、type関数とisinstance関数の記事も参考になります。

初心者がつまずきやすいポイント

条件を変数に分けると読みやすい

複雑な条件は、無理に1行で書くより、意味のある変数名に分けると読みやすくなります。

age = 22
has_ticket = True
is_member = False

is_adult = age >= 20
can_enter = is_adult and has_ticket
can_discount = is_member or age < 18

if can_enter:
    print("入場できます")

is_adultやcan_enterのような名前を付けると、条件式を日本語に近い形で読めます。特にandとorが混ざる場合は、変数に分けるだけで読み間違いを減らせます。

よくある書き間違い

初心者がよく書いてしまうのが、1つの変数に対して複数の値を比べるときの書き方です。

# 意図が伝わりにくい例
if answer == "yes" or "y":
    print("続けます")

# それぞれ比較する
if answer == "yes" or answer == "y":
    print("続けます")

# または in を使う
if answer in ["yes", "y"]:
    print("続けます")

orの左右には、それぞれ条件式を書きます。単に文字列だけを書くと、その文字列自体がTrueとして扱われるため、意図しない結果になりやすいです。

notを使いすぎない

notは便利ですが、否定が重なると読みにくくなります。

is_empty = len(items) == 0

if is_empty:
    print("データがありません")

if not is_empty:
    print("データがあります")

否定が読みにくいと感じたら、変数名を変えるのも手です。not is_emptyよりhas_itemsの方が自然に読める場面もあります。条件式は、短さよりも読み間違いにくさを優先しましょう。

練習するときの見方

and・or・notは、表を書いて確認すると身につきやすいです。左右の条件がTrueかFalseかを変えながら、最終結果がどう変わるかを見ます。

• andは4パターンのうち両方TrueのときだけTrue
• orは4パターンのうち少なくとも1つTrueならTrue
• notはTrueをFalseへ、FalseをTrueへ反転する
• 複雑な条件は小さい条件に名前を付けて確認する

実務コードで意識したいこと

条件式は、コンピュータが読めるだけでなく、人が後から読んでも意図が分かることが大切です。特に権限、料金、在庫、入力チェックのように間違えると影響が大きい条件では、andやorを詰め込まず、意味のある変数名や関数名に分ける方が安全です。

たとえばif user and user.is_active and user.has_paid:のような条件は短く書けますが、重要な判定ならcan_use_serviceのような名前に分けると、後から仕様を確認しやすくなります。

公式情報と関連して読みたい記事

• Python公式ドキュメント: Truth Value Testing
• Python公式ドキュメント: Boolean Operations
• Pythonのif文
• Pythonの比較演算子
• Pythonのwhile文

まとめ

and・or・notは、条件式を組み立てるための基本です。

• andは左右の条件が両方TrueならTrue
• orはどちらか一方でもTrueならTrue
• notは条件の結果を反転する
• 複雑な条件は括弧や変数名で読みやすくする

論理演算子を読めるようになると、if文やwhile文の条件がかなり追いやすくなります。

画面に文字を出すだけならprintで十分ですが、ユーザーが入力した名前、年齢、点数などを使って処理を変えたい場合はinput()を使います。

最初は『inputは文字列で受け取る』だけ覚えてください。数字を入力しても、受け取った直後は文字列です。

この記事では、input()の基本、入力メッセージの出し方、数値へ変換する方法、入力チェックでつまずきやすい点を順番に解説します。

次の図では、キーボードから入った文字がinput()を通り、まず文字列として変数へ入る流れを見てください。

次の図では、受け取った文字列をそのまま使う道と、int()で数値へ変換して計算に使う道を分けて見てください。

まず結論：input()は入力を文字列として受け取る

Python公式ドキュメントでは、input()は必要に応じてプロンプトを表示し、標準入力から1行を読み込む組み込み関数として説明されています。初心者向けには、まず『入力された1行を受け取り、文字列として返す関数』と理解すれば十分です。

input関数の基本形

一番シンプルな使い方は、入力された値を変数に入れる形です。

name = input()
print(name)

このコードを実行すると、ユーザーが入力した文字がnameに入り、その後printで表示されます。printの基本が曖昧な場合は、先にPythonのprint関数を確認すると読みやすくなります。

入力メッセージを表示する

input()の丸括弧の中に文字列を書くと、入力前にメッセージを表示できます。これをプロンプトとして使います。

name = input("名前を入力してください: ")
print("こんにちは、" + name + "さん")

プロンプトを入れると、何を入力すればよいかが分かりやすくなります。練習用のプログラムでも、入力待ちで止まって見える不安を減らせます。

数字を入力しても最初は文字列

inputで特に大事なのは、数字を入力しても戻り値は文字列だという点です。

age = input("年齢を入力してください: ")
print(age + 1)  # TypeError になる

この例では、ageは数値ではなく文字列です。そのため、1を足そうとするとエラーになります。

数値として計算したい場合は、int()やfloat()で型変換します。型変換の基本はint() float() str()の記事でも整理しています。

age_text = input("年齢を入力してください: ")
age = int(age_text)
print(age + 1)

if文と組み合わせる

inputで受け取った値は、条件分岐にもよく使います。

answer = input("続けますか？ yes/no: ")

if answer == "yes":
    print("続けます")
else:
    print("終了します")

このように、入力値によって処理を変えると小さな対話式プログラムになります。条件分岐の読み方はPythonのif文と合わせて押さえると理解しやすいです。

入力ミスに備える

int(input())は便利ですが、数字以外が入力されるとValueErrorになります。ユーザー入力は間違える前提で考えるのが基本です。

try:
    score = int(input("点数を入力してください: "))
    print(score >= 60)
except ValueError:
    print("数字を入力してください")

ここでは、数値に変換できない入力をtry-exceptで受け止めています。例外処理が初めてなら、Pythonのtry-exceptを先に読んでおくと安心です。

初心者がつまずきやすいポイント

小さな対話式プログラムで見る

inputは、単体で覚えるよりも、print、型変換、if文と組み合わせて小さなプログラムにすると理解しやすくなります。

name = input("名前: ")
age_text = input("年齢: ")
age = int(age_text)

if age >= 20:
    print(f"{name}さんは成人です")
else:
    print(f"{name}さんは未成年です")

この例では、名前はそのまま文字列として使い、年齢だけをintへ変換しています。すべての入力を数値に変換するのではなく、『何に使う値か』を見て変換するか決めるのがポイントです。

inputを読むときの順番

コードを読むときは、まずinputがどの変数へ入っているかを見ます。次に、その変数が文字列のまま使われているのか、intやfloatで変換されているのかを確認します。最後に、変換後の値がif文や計算に使われているかを追います。

練習するときのおすすめ手順

最初から長いプログラムを書く必要はありません。まずは1つの入力を受け取り、そのまま表示するところから始めます。次に、数値へ変換して計算し、最後にif文で処理を分けると段階的に理解できます。

• 名前を入力して挨拶を表示する
• 年齢を入力して来年の年齢を表示する
• 点数を入力して合格か不合格を表示する
• 数字以外が入力されたときのエラーをtry-exceptで受ける

入力を扱えるようになると、練習問題の幅が一気に広がります。画面に固定値を出すだけでなく、ユーザーが入れた値によって結果が変わるプログラムを作れるからです。

よくある疑問

inputで入力した文字の最後に改行は入る？

input()は、ユーザーがEnterキーを押すまでの1行を読み込みます。戻り値には、通常そのEnterによる改行文字は含まれません。そのため、入力された文字列をそのまま比較できます。

空のままEnterされたらどうなる？

何も入力せずにEnterを押すと、空文字列""が返ります。必須入力にしたい場合は、空文字列かどうかをif文で確認します。

name = input("名前: ")

if name == "":
    print("名前は必須です")
else:
    print(f"こんにちは、{name}さん")

inputはWebフォームでも使う？

input()は、主にターミナルで動く小さなプログラムや学習用コードで使います。Webアプリでは、HTMLフォームやフレームワーク側の仕組みで入力を受け取るため、同じ名前の入力欄とは役割が違います。

そのため、DjangoなどのWebフレームワークへ進む前の段階では、inputで『外から値が入ってくる感覚』を作っておくと役立ちます。後でフォーム処理を学ぶときも、入力値を受け取り、検証し、型を整えて使うという流れは共通しています。学習初期の小さな練習として、かなり効果が高い題材です。

公式情報と関連して読みたい記事

• Python公式ドキュメント: input()
• Pythonのprint関数
• int() float() str() データ型変換
• Pythonのif文
• Pythonのtry-except

まとめ

input()は、ユーザーから入力を受け取るための組み込み関数です。

• 入力値はまず文字列として受け取る
• プロンプトを入れると入力内容が分かりやすい
• 計算に使うならint()やfloat()で変換する
• 入力ミスに備えて条件分岐や例外処理を使う

inputを理解すると、printだけのプログラムから、ユーザーの入力に反応するプログラムへ進めます。

Pythonをインストールした直後は、標準ライブラリだけで学習できます。しかし、Excel操作、Webアプリ、データ分析などへ進むと、外部パッケージを入れる場面が出てきます。

venvは『場所を分ける』、pipは『必要なものを入れる』。この2つを分けて考えると理解しやすくなります。

この記事では、venvとpipの役割、仮想環境を作る理由、基本コマンド、requirements.txtの考え方、初心者が避けたい失敗を整理します。

次の図では、venvをプロジェクトごとに分かれた専用の部屋として見てください。

次の図では、pip installで外部パッケージがどこへ入り、コードからどう使われるかを確認してください。

まず結論：venvは環境、pipはインストール担当

Python公式ドキュメントでは、venvは仮想環境を作成する標準ライブラリとして説明されています。Python Packaging User Guideでは、pipはパッケージの推奨インストーラとして紹介されています。

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

仮想環境を使う理由は、プロジェクトごとに必要なライブラリやバージョンが違うからです。

たとえば、ある学習用プロジェクトでは古いライブラリを使い、別のWebアプリでは新しいライブラリを使うことがあります。すべてを同じ場所へ入れると、片方の更新がもう片方を壊すことがあります。

venvを使うと、プロジェクト専用のPython環境を作り、その中にだけパッケージを入れられます。

venvで仮想環境を作る

プロジェクトのフォルダで、次のように仮想環境を作ります。

# macOS / Linux
python3 -m venv .venv
source .venv/bin/activate

# Windows PowerShell
py -m venv .venv
.venv\Scripts\Activate.ps1

.venvは仮想環境のフォルダ名です。名前は変えられますが、初心者のうちはプロジェクト内に.venvとして作ると見通しがよくなります。Python本体のインストールがまだの場合は、Windows版Pythonのインストール方法から確認してください。

pipでパッケージを入れる

仮想環境を有効にしたら、pipで必要なパッケージを入れます。

python -m pip install requests
python -m pip install openpyxl

pip installと書く例も多いですが、初心者のうちはpython -m pipを使うと、今使っているPythonとpipの対応を揃えやすくなります。

入れたパッケージは、コード内でimportして使います。import文の基本はPythonのimport文、モジュールとパッケージの違いはモジュール/パッケージ/ライブラリの違いで整理しています。

パッケージを確認する

現在の環境に入っているパッケージを確認したい場合は、次のコマンドを使います。

python -m pip list

仮想環境を切り替えると、表示されるパッケージも変わります。ここで『プロジェクトごとに中身が分かれている』ことを確認できます。

requirements.txtで共有する

別のPCや本番環境で同じパッケージを入れたい場合は、requirements.txtを使うことがあります。

python -m pip freeze > requirements.txt
python -m pip install -r requirements.txt

1行目は現在の環境に入っているパッケージ一覧を書き出します。2行目は、その一覧をもとにパッケージをまとめてインストールします。

Excel操作やDjangoへ進むと必要になる

外部パッケージを使う記事では、venvとpipの理解が前提になりやすいです。

• PythonでExcelを操作する方法では、openpyxlのような外部パッケージを使う
• Djangoとは？では、Webフレームワークをインストールして使う
• 学習用の小さなコードでも、環境を分けておくと後で整理しやすい

初心者がつまずきやすいポイント

よくある疑問

仮想環境フォルダはGitに入れる？

通常、.venvのような仮想環境フォルダそのものはGitへ入れません。代わりに、必要なパッケージを再現するためのrequirements.txtなどを共有します。

pipとimportは同じ？

同じではありません。pipはパッケージを環境へインストールするコマンドで、importはPythonコードの中でモジュールを読み込む文です。先にpipで入れ、コード内でimportして使う、という順番で考えると整理できます。

コマンドを実行する場所を分けて考える

venvやpipでつまずく原因の多くは、Pythonコードの中で実行するものと、ターミナルで実行するものが混ざることです。

Pythonの対話モードでpython -m pip install ...を入力すると、Pythonの文として解釈されてエラーになります。コマンドはターミナル、importはPythonコード、と分けて考えましょう。

仮想環境は作り直せる

仮想環境は、壊したら終わりというものではありません。必要なパッケージを再現できる情報があれば、削除して作り直せます。

# 例: 作り直しの流れ
# 1. .venv フォルダを削除
# 2. 仮想環境を作成
python -m venv .venv

# 3. 有効化後にパッケージを再インストール
python -m pip install -r requirements.txt

そのため、仮想環境フォルダそのものを大事に保管するより、必要なパッケージの一覧を残すことが重要です。

pip installで入るものとimport名が違うことがある

パッケージ名とimport名は、いつも同じとは限りません。たとえば、インストール時の名前とコード内で読み込む名前が違うライブラリもあります。

python -m pip install beautifulsoup4

# Pythonコード側
from bs4 import BeautifulSoup

エラーが出たときは、pipで入れた名前だけでなく、公式ドキュメントやパッケージのREADMEに書かれているimport例を確認します。

練習用プロジェクトの流れ

最初の練習では、次の順番で1つの小さなフォルダを作ると流れをつかみやすいです。

• プロジェクト用フォルダを作る
• python -m venv .venvで仮想環境を作る
• 仮想環境を有効化する
• python -m pip install openpyxlなどで必要なパッケージを入れる
• Pythonファイルでimportして動かす
• python -m pip freeze > requirements.txtで一覧を残す

この流れを1回経験しておくと、DjangoやExcel操作の記事に進んだときも、環境作成とコードの実行を分けて理解できます。

公式情報と関連して読みたい記事

• Python公式ドキュメント: venv
• Python Packaging User Guide: Installing Packages
• Pythonのインストール方法
• Pythonのimport文
• モジュール/パッケージ/ライブラリの違い

まとめ

venvとpipは、Pythonで外部ライブラリを使うための土台です。

• venvはプロジェクト専用の仮想環境を作る
• pipはパッケージをインストールする
• python -m pipを使うとPythonとpipの対応を揃えやすい
• requirements.txtで必要パッケージを再現しやすくする

この2つを押さえると、Excel操作、Django、API利用など、外部ライブラリを使う記事へ進みやすくなります。

たとえば、数値の一覧から2倍した一覧を作る、条件に合う値だけを取り出す、といった処理を1行で表せます。

最初は『短く書けるfor文』ではなく、『新しいリストを作る構文』として読むと混乱しにくくなります。

この記事では、for文でappendする書き方との違い、基本形、if条件の付け方、読みやすく使うための判断を解説します。

次の図では、リスト内包表記を元のリストから要素を流し、条件ゲートと加工ゲートを通して新しいリストを作るラインとして見てください。

次の図では、通常のfor文で行っていた『取り出す・加工する・入れる』が、リスト内包表記の1行へまとまるイメージを見てください。

まず結論：新しいリストを作るための構文

Python公式チュートリアルでは、リスト内包表記はリストを作る簡潔な方法として紹介され、別の並びから各要素を加工したリストや条件に合う部分リストを作る用途が説明されています。

for文で書く場合

まずは通常のfor文で、新しいリストを作る例を見ます。

numbers = [1, 2, 3, 4]
squares = []

for number in numbers:
    squares.append(number * number)

print(squares)  # [1, 4, 9, 16]

このコードでは、元のリストから1件ずつ取り出し、計算結果をappendで新しいリストへ追加しています。リストの基本が曖昧な場合は、Pythonのリストを先に確認してください。

リスト内包表記で書く場合

同じ処理をリスト内包表記で書くと、次のようになります。

numbers = [1, 2, 3, 4]
squares = [number * number for number in numbers]

print(squares)  # [1, 4, 9, 16]

読み方は、for number in numbersで1件ずつ取り出し、左側のnumber * numberを新しいリストへ入れる、です。

基本形を分けて読む

リスト内包表記の基本形は、次のように分けると読みやすくなります。

[作る値 for 要素 in 元の並び]

for文そのものの読み方はPythonのfor文、連番を作る処理はrange関数と合わせて押さえると整理できます。

ifで条件を付ける

条件に合う要素だけを使いたい場合は、最後にifを付けます。

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = [number for number in numbers if number % 2 == 0]

print(even_numbers)  # [2, 4, 6]

この例では、number % 2 == 0を満たす偶数だけを新しいリストに入れています。

加工と絞り込みを同時に行う

リスト内包表記では、値を加工しながら条件で絞ることもできます。

names = ["sato", "suzuki", "tanaka"]
upper_s_names = [name.upper() for name in names if name.startswith("s")]

print(upper_s_names)  # ['SATO', 'SUZUKI']

ここでは、sで始まる名前だけを取り出し、upper()で大文字に変換しています。

for文とどちらを使うべきか

短ければ常に良いわけではありません。読んだ人がすぐ意味を追える範囲で使うのが大切です。

lambdaやmapとの関係

Pythonでは、mapやlambdaを使って似た処理を書くこともあります。

numbers = [1, 2, 3]
result = list(map(lambda x: x * 2, numbers))

ただし、初心者がまず覚えるなら、リスト内包表記の方が『何を取り出して、何を作るか』を読み取りやすい場面が多いです。lambdaの基本はPythonのラムダ関数で扱っています。

初心者がつまずきやすいポイント

読み方は右から左へ確認する

リスト内包表記は、見た目は左から始まりますが、読むときはforの部分から確認すると分かりやすくなります。

result = [name.upper() for name in names if len(name) >= 5]

この例は、まずfor name in namesで名前を1件ずつ取り出し、次にif len(name) >= 5で5文字以上に絞り、最後にname.upper()を新しいリストへ入れる、と読みます。

ネストした内包表記は最初は避ける

リスト内包表記は入れ子にもできますが、初心者のうちは無理に使わない方が読みやすいです。

# 読みにくくなりやすい例
pairs = [(x, y) for x in range(3) for y in range(3)]

# 最初はfor文で展開して理解する
pairs = []
for x in range(3):
    for y in range(3):
        pairs.append((x, y))

短いコードでも、読む人がすぐに処理の順番を追えなければメリットが薄くなります。二重ループや複雑な条件が出てきたら、通常のfor文へ戻す判断も大切です。

元のリストは基本的に変えない

リスト内包表記は、新しいリストを作るための構文です。元のリストの中身を書き換える処理ではありません。

numbers = [1, 2, 3]
doubled = [number * 2 for number in numbers]

print(numbers)  # [1, 2, 3]
print(doubled)  # [2, 4, 6]

元の値を残したまま、加工後の一覧を別に持てるのは大きな利点です。元のリストも変えたい場合は、代入やスライス、通常のfor文など、別の書き方を検討します。

練習するときの題材

リスト内包表記は、単純な変換と絞り込みから練習すると理解しやすいです。

• 数値リストを2倍した新しいリストを作る
• 文字列リストから3文字以上だけを取り出す
• 名前の一覧をすべて大文字にする
• 1から10までの偶数だけをリストにする

いきなり複雑な処理に使うより、for文で書ける処理をリスト内包表記へ置き換える練習をすると、構文の対応関係が見えやすくなります。

実務コードでの使いどころ

リスト内包表記は、データの一覧を画面表示用に加工したり、APIから受け取ったリストの一部だけを取り出したり、ファイル名の一覧を整形したりする場面でよく使われます。どれも共通しているのは、『元の並びから新しいリストを作る』という目的がはっきりしていることです。

逆に、途中でログを出す、複数の変数を更新する、例外処理を細かく入れる、といった処理は通常のfor文の方が向いています。リスト内包表記は、処理の目的が1つに絞れるときに使うと読みやすくなります。

公式情報と関連して読みたい記事

• Python公式チュートリアル: List Comprehensions
• Pythonのリスト
• Pythonのfor文
• range関数
• Pythonのラムダ関数

まとめ

リスト内包表記は、for文で処理した結果から新しいリストを作るための構文です。

• 基本形は[作る値 for 要素 in 元の並び]
• 条件で絞るなら最後にif 条件を付ける
• 複雑な処理は通常のfor文の方が読みやすい
• 元のリストを直接変えるのではなく、新しいリストを作る

リスト内包表記を読めるようになると、Pythonらしいリスト処理のコードがかなり追いやすくなります。

文字列を+でつなぐよりも、何を表示したいのかを自然な順番で書けます。printで結果を見せる練習や、ログ、メッセージ作成でよく使います。

f-stringは『fを付けた文字列の中で、{} の中だけPythonの式として読む』と考えると整理しやすいです。

この記事では、f-stringの基本、変数や式の埋め込み、小数点の表示、formatとの違い、初心者がつまずきやすい点を解説します。

次の図では、f-stringを文章テンプレートの穴へ変数を差し込むイメージとして見てください。

次の図では、数値がf-stringの書式指定を通って、画面に出すための読みやすい文字列へ整う流れを見てください。

まず結論：f"...{変数}..."で値を埋め込む

Python公式チュートリアルでは、f-stringは文字列の前にfまたはFを付け、波括弧の中にPython式を書ける文字列リテラルとして説明されています。

f-stringの基本形

基本形は、文字列の前にfを付け、埋め込みたい変数を{}で囲みます。

name = "Sato"
age = 25

message = f"{name}さんは{age}歳です"
print(message)

このコードでは、{name}がSatoに、{age}が25に置き換わります。文字列そのものの基本はPythonの文字列操作も参考になります。

文字列連結より読みやすい

同じ内容を+でつなぐと、型変換や記号が増えて読みにくくなりがちです。

name = "Sato"
age = 25

print(name + "さんは" + str(age) + "歳です")
print(f"{name}さんは{age}歳です")

f-stringでは、数値のageも表示用の文字列として自然に埋め込めます。型変換の考え方はint() float() str()の記事で詳しく扱っています。

式も書ける

波括弧の中には、変数だけでなく簡単な式も書けます。

price = 1200
count = 3

print(f"合計は{price * count}円です")

ただし、長い計算や複雑な条件をf-stringの中に詰め込みすぎると読みにくくなります。複雑な処理は先に変数へ入れてから埋め込む方が安全です。

小数点や桁区切りを指定する

f-stringでは、:の後に書式指定を書くことで、小数点や桁区切りを調整できます。

rate = 0.12345
amount = 1234567

print(f"割合: {rate:.2%}")
print(f"金額: {amount:,}円")

{rate:.2%}は百分率で小数第2位まで、{amount:,}は3桁区切りで表示します。より細かい書式は、formatメソッドと同じ考え方で理解できます。

formatメソッドとの違い

新しく書くコードでは、単純な埋め込みならf-stringが読みやすい場面が多いです。既存コードではformatも出てくるため、どちらも読めるようにしておくと安心です。

デバッグ表示にも使える

変数名と値を一緒に見たいときにもf-stringは便利です。

score = 82
print(f"score={score}")

練習中は、処理の途中で変数がどう変わったかをprintで確認する場面が多くあります。print関数とf-stringを組み合わせると、確認用の表示が読みやすくなります。

初心者がつまずきやすいポイント

辞書やリストの値も埋め込める

f-stringの{}の中には式を書けるため、辞書やリストから取り出した値も埋め込めます。

user = {"name": "Sato", "score": 82}

print(f"{user['name']}さんの点数は{user['score']}点です")

ただし、引用符が増えると読みにくくなります。複雑に見える場合は、先に変数へ取り出してからf-stringに入れると安全です。

name = user["name"]
score = user["score"]

print(f"{name}さんの点数は{score}点です")

複数行の文字列で使う

長いメッセージを作るときは、複数行のf-stringを使うこともあります。

name = "Sato"
score = 82

message = f"""
{name}さん
点数: {score}
判定: {'合格' if score >= 60 else '不合格'}
"""

print(message)

ただし、条件式まで入れると読みにくくなることがあります。表示用の文章を作るだけなら便利ですが、処理の本体をf-stringの中へ押し込まないようにしましょう。

format指定は少しずつ覚える

f-stringの書式指定は便利ですが、最初からすべて覚える必要はありません。まずは小数点、桁区切り、幅の指定をよく使います。

練習するときのおすすめ例

f-stringは、変数の値を見やすく表示する練習に向いています。計算そのものより、読みやすい出力を作る意識で試すと身につきます。

• 名前と年齢を1文で表示する
• 税込価格を計算して小数なしで表示する
• 点数と合否をメッセージにする
• 金額を3桁区切りで表示する

よくある疑問

f-stringはprint専用？

print専用ではありません。f-stringは文字列を作る書き方なので、変数に入れる、ファイルへ書く、ログに渡す、関数の戻り値にするなど、文字列が必要な場所で使えます。

def build_message(name, score):
    return f"{name}さんの点数は{score}点です"

波括弧そのものを表示したいときは？

f-stringで波括弧そのものを表示したい場合は、波括弧を二重にします。{{と}}を書くと、表示結果では1つの波括弧になります。

name = "Sato"
print(f"{{name}} の値は {name} です")

古いformatは覚えなくてよい？

新しく短いコードを書くならf-stringで十分な場面が多いです。ただし、既存コードや教材ではformatもまだ出てきます。完全に置き換えるというより、f-stringを中心にしつつ、formatも読める状態にしておくのが現実的です。

特にチーム開発では、既存コードの書き方に合わせることもあります。f-stringを使えるようになったうえで、formatや文字列連結を見ても意味が分かる状態にしておくと、古いコードと新しいコードの両方を読みやすくなります。検索して見つけたサンプルコードの理解にも役立ちます。

公式情報と関連して読みたい記事

• Python公式チュートリアル: Formatted String Literals
• Pythonの文字列操作
• Pythonのprint関数
• Pythonのformatメソッド
• int() float() str() データ型変換

まとめ

f-stringは、文字列の中に変数や式を埋め込むための読みやすい書き方です。

• 文字列の前にfを付ける
• {}の中に変数や式を書く
• 小数点や桁区切りも指定できる
• 複雑な処理は先に変数へ入れる

f-stringを使えるようになると、出力やメッセージ作成のコードがかなりすっきりします。

このテンプレートシステムを理解することで、PythonのコードとHTMLの間でデータを効率よくやり取りし、見栄えの良いウェブページを容易に作成することが可能となります。

このページでは、Djangoのテンプレートについて、初心者向けに１からわかりやすく整理して解説します。

Djangoを用いたWeb開発を行いたい人であれば、知らないと恥ずかしい超・基本知識の１つです。是非最後までご覧ください。

参考　Pythonの基本的な書き方・構文ルール

Django「テンプレート」とは何か？

Djangoのテンプレートとは、Webアプリケーションの画面の骨格を表すHTMLファイルのことを指します。Djangoでは、このテンプレートファイルにPythonのコードから動的に値を受け渡すことで、さまざまな画面を表示させることができます。

テンプレートを使用することで、Webページの見た目（HTML）とロジック（Pythonコード）を明確に分けることができ、コードの整理整頓、保守、再利用を容易にし、チームでの開発をスムーズにすることができます。

それでは、早速テンプレートの基本的な作成方法と、その利用方法を解説していきます。

Djangoテンプレートの基本

DjangoのテンプレートはHTMLファイルの形で保存され、主に2つの部分から成り立ちます。

1. HTML
2. テンプレートタグ or テンプレート変数

参考　HTMLファイルの書き方・作り方

骨格となるHTMLファイルに、変数を埋め込んでおき、その変数にPythonから値を渡して１つの画面を作成するようなイメージ。

このようにテンプレートを利用して、各場面に応じて修正が必要な部分だけをPythonから渡してあげることで、様々な画面を作成できる仕組みがテンプレートです。

Djangoのテンプレート変数とテンプレートタグの使い方を解説します。

Django：テンプレート変数

テンプレート変数は {{ variable_name }} の形でHTMLファイル内に記述します。ここには、Pythonから受け取った値（文字列、数値、リスト、オブジェクトなど）が挿入されます。

<p>Hello, {{ name }}!</p>

参考　HTML：pタグ

ここでの name はテンプレート変数です。ここに Python コードから値が渡されれば、その値が表示さる仕組み。

例えば、name に "John" という文字列が渡されれば、生成されるHTMLは以下のようになります。

<p>Hello, John!</p>

Django：テンプレートタグ

一方、テンプレートタグは {% tag %} の形でテンプレートに記述され、より複雑なロジックや制御フローをHTMLに組み込むことができます。

テンプレートタグにはさまざまな種類があり、条件分岐（{% if %}、{% else %}）、ループ（{% for %}）、テンプレートの継承やインクルード（{% extends %}、{% include %}）など、多くの操作を行うことができます。

例えば、以下のコードでは、item_list の各要素に対してループを行い、リストの要素をHTMLに挿入しています。

<ul>
{% for item in item_list %}
    <li>{{ item }}</li>
{% endfor %}
</ul>

参考　liタグ / Pythonのリスト

item_list はPythonから渡されたリストで、その各要素が item としてHTMLに埋め込まれます。

例えば、item_list に ["Apple", "Banana", "Cherry"] というリストが渡された場合、生成されるHTMLは以下のようになります。

<ul>
    <li>Apple</li>
    <li>Banana</li>
    <li>Cherry</li>
</ul>

このように、Djangoテンプレートタグを使うと、HTMLの生成をPythonのコードで制御することができます。

Djangoのテンプレートタグは多種多様。ここで、最も一般的に使用されるタグをいくつか取り上げ、その機能と使い方を表形式で整理しておきます。

次の章では、Djangoテンプレートの作成方法について詳しく解説します。

Djangoテンプレートの作成と使用方法

上記の基本知識を踏まえ、早速Djangoテンプレートの作成と使用方法を実際に見ていきましょう。

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

テンプレートは基本的にはHTMLファイルであり、Djangoプロジェクト内のアプリケーションフォルダにあるtemplatesディレクトリに保存されます。

例えば、myappという名前のアプリケーションがある場合、テンプレートはmyapp/templates/ディレクトリに配置します。

↓のような簡単なテンプレートを作成してみます。

<!-- myapp/templates/hello.html -->

<!DOCTYPE html>
<html>
<head>
    <title>Hello Django</title>
</head>
<body>
    <h1>Hello, {{ name }}!</h1>
</body>
</html>

このテンプレートでは、{{ name }}というテンプレート変数を使用しており、この部分は後でPythonコードから受け取った値に置き換えられます。

テンプレートの使用

Djangoのビューでテンプレートを使用するには、render関数を使います。この関数は、指定したテンプレートを使用してHTTPレスポンスを生成します。

参考　Pythonの関数とは？

次のコードは、上記のテンプレートを使って"Hello, Django!"と表示するビューの例です。

# myapp/views.py

from django.shortcuts import render

def hello(request):
    return render(request, 'hello.html', {'name': 'Django'})

参考　import文 / views.py（ビューとは？）

このビューでは、render関数を使ってhello.htmlテンプレートをレンダリングしています。3つ目の引数{'name': 'Django'}は、テンプレートに渡すコンテキストとなり、この例ではテンプレート変数{{ name }}が'Django'に置き換えられます。

render関数の詳しい使い方や利用する際の注意点は以下の記事をご覧ください。

【Django】render関数の使い方をわかりやすく３分で解説

【初心者向け】Djangoのrender関数の使い方を、基本的な概念から具体的なコード例までわかりやすく解説。初心者でも理解できるよう、用途や構文、利用時の注意点についても３分間で効率的にご説明。

it-biz.online

2023.07.10

以上がDjangoテンプレートの基本的な作成と使用方法です。

Django：テンプレート（template）のまとめ

<!DOCTYPE html>
<html>
<head>
    <title>{{ title }}</title>
    <link rel="stylesheet" href="{% static 'styles.css' %}">
</head>
<body>
    <header>
        <h1>{{ header }}</h1>
    </header>
    
    <main>
        <h2>Welcome, {{ username }}!</h2>
        <p>Here are some of your favorite fruits:</p>
        <ul>
        {% for fruit in favorite_fruits %}
            <li>{{ fruit }}</li>
        {% empty %}
            <li>No favorite fruits found.</li>
        {% endfor %}
        </ul>
    </main>
    
    <footer>
        {% include 'footer.html' %}
    </footer>
</body>
</html>

初めてPython/Djangoを勉強するのは結構難しいですよね。

でもその悩みを抱えているのは一人じゃありません。全てのPython使いが同じ道を進んできました。

Pythonをはじめとするプログラミングスキルを武器に、時間と場所に捉われない自由な生き方を目指してみませんか？今すぐ行動したい方は以下の記事をチェック！

読者料典　Python入門：学習カリキュラム　←こちらから！

参考　Djangoのテンプレートとは？

テンプレートの継承とは、一言で言うと、既存のテンプレート（通常はベースとなるテンプレート）から特定の部分を再利用し、その上で新たな要素を追加したり、既存の要素をオーバーライド（上書き）したりすることを可能にする機能です。

このページでは、テンプレートの継承とは何か？そのメリットと使用方法、さらには実践的な例とベストプラクティスを含む具体的な応用例を紹介します。

Djangoを用いたWeb開発を行いたい人であれば、知らないと恥ずかしい超・基本知識の１つです。是非最後までご覧ください。

参考　Pythonの基本的な書き方・構文ルール

Django：テンプレートの継承とは

テンプレートの継承とは、あるテンプレート（一般的にはベーステンプレートと呼ばれます）が持つ一部または全部の構造や要素を再利用し、新たなテンプレートを作る方法を指します。

例えば、画面のヘッダーやフッターを定義するベーステンプレートを用意しておいて、そのテンプレートをもとに、ヘッダーやフッターだけを編集した別のテンプレートを作るようなイメージ。

これは、DjangoがDRY（Don't Repeat Yourself）というコーディング原則を反映したもので、同じコードを何度も書く必要を減らし、保守性と効率性を向上させるための機能の１つ。

テンプレートの継承を理解するために、以下の２点について学習していきます。

1. 基底テンプレートの作成： Djangoのテンプレートシステムでは、ベースとなるテンプレートを作成し、その中に再利用したいHTMLの構造や要素を定義。ナビゲーションバー、フッター、スタイルシートのリンク、スクリプトのリンクなど、複数のページで共有される要素を含みます。
2. ブロックの定義とオーバーライド： ベーステンプレートには、子テンプレートでオーバーライド（上書き）または追加できるブロックを定義します。これらのブロックは、ページタイトル、メインコンテンツ、追加のスタイルシートなど、ページによって異なる可能性のある部分を占めます。

上記２点についてステップバイステップで解説していきます。

ベーステンプレートの作成

まず、ベース（親）テンプレートを作成します。このベーステンプレートには、すべてのテンプレートから共有される「共通のHTML構造」を定義します。

参考　HTMLとは？

以下がベーステンプレート（base.html）の例です。

<!DOCTYPE html>
<html lang="ja">
<head>
    <meta charset="UTF-8">
    <title>{% block title %}デフォルトタイトル{% endblock title %}</title>
    <!-- その他のメタ情報、スタイルシートのリンクなど -->
</head>
<body>
    <header>
        <!-- ヘッダーの内容 -->
    </header>

    <main>
        {% block content %}
        <!-- この部分は子テンプレートでオーバーライドされます -->
        {% endblock content %}
    </main>

    <footer>
        <!-- フッターの内容 -->
    </footer>

    <!-- その他のスクリプトなど -->
</body>
</html>

参考　HTMLの基本構造・書き方 / <header>タグ /<main>タグ

ここでは{% block title %}と{% block content %}の2つのブロックを定義しています。これらは子テンプレートでオーバーライドすることができます。

ここで、blockタグについて詳細を補足します。

Django：blockタグ

block はテンプレート内で再利用可能なセクションを定義するためのタグです。ベーステンプレートでは block を使用して子テンプレートで上書き（オーバーライド）できるセクションを定義します。

{% block blockname %}
    Default content...
{% endblock %}

blockname はブロックの名前（任意の名前）で、Default content... はブロックのデフォルトコンテンツ（子テンプレートでオーバーライドされない場合に表示される部分）です。

このblockタグを利用した部分は、次に解説する子テンプレートで上書きをすることが可能になるということです。

子テンプレートの作成とベーステンプレートからの継承

次に、ベーステンプレートから継承する子テンプレートを作成します。

子テンプレートでは、{% extends "base.html" %}を使用して基底テンプレートから継承を行い、{% block %}タグを使用して基底テンプレートのブロックをオーバーライドします。

{% extends "base.html" %}

{% block title %}マイページ{% endblock title %}

{% block content %}
    <h1>ようこそ、マイページへ！</h1>
    <!-- その他のコンテンツ -->
{% endblock content %}

参考　hタグ

この子テンプレートでは、基底テンプレートのtitleブロックとcontentブロックをオーバーライドしています。

分かりやすく言うと、１行目のextendsタグで「base.html」をテンプレートにするよ！と宣言。
そして、blockタグで「この部分はこの内容で上書きするよ！」という処理を書いています。

具体的なサンプルコードを見てみましょう。

例えば、以下のようなベーステンプレートがあるとします。

<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}デフォルトタイトル{% endblock %}</title>
</head>
<body>
    <header>
        <nav>
            <!-- ナビゲーションメニュー -->
        </nav>
    </header>

    <main>
        {% block content %}
        <!-- デフォルトコンテンツ:子テンプレートでオーバーライド予定 -->
        {% endblock %}
    </main>

    <footer>
        <!-- フッター情報 -->
    </footer>
</body>
</html>

参考　navタグ

このテンプレートをもとに、{% block %}タグを使ってベーステンプレートのブロックをオーバーライド↓。

{% extends "base.html" %}

{% block title %}
マイページ
{% endblock %}

{% block content %}
<h1>ようこそ、マイページへ！</h1>
<p>ここは、ユーザーのマイページです。</p>
{% endblock %}

参考　pタグ（段落タグ）

こうすることで、ベーステンプレートをもとにして、必要な部分だけを上書きした画面が出来上がるというわけです。

<!DOCTYPE html>
<html lang="ja">
<head>
    <meta charset="UTF-8">
    <title>{% block title %}My Blog{% endblock title %}</title>
    <!-- その他のメタ情報、スタイルシートのリンクなど -->
</head>
<body>
    <header>
        <!-- ヘッダーの内容 -->
    </header>

    <nav>
        <!-- ナビゲーションバーの内容 -->
    </nav>

    <main>
        {% block content %}
        <!-- この部分は子テンプレートでオーバーライドされます -->
        {% endblock content %}
    </main>

    <footer>
        <!-- フッターの内容 -->
    </footer>

    <!-- その他のスクリプトなど -->
</body>
</html>

{% extends "base.html" %}

{% block title %}
{{ post.title }} - My Blog
{% endblock title %}

{% block content %}
    <h1>{{ post.title }}</h1>
    <p>{{ post.content }}</p>
{% endblock content %}

継承するHTMLファイルの指定

Djangoではextendsタグを使って他のテンプレートを継承する際、テンプレートファイルの位置はTEMPLATES設定のDIRSオプションに指定されたディレクトリが検索対象となります。

つまり、extendsで指定するテンプレートファイルは同じフォルダに存在する必要はありません。

通常、Djangoプロジェクトはプロジェクト全体のテンプレートを配置するためのtemplatesディレクトリを持ち、各アプリケーションディレクトリの下にも各々templatesディレクトリを持つ構造になっています。

myproject/
├── manage.py
├── myproject/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   ├── wsgi.py
├── templates/
│   ├── base.html
└── todo/
    ├── __init__.py
    ├── admin.py
    ├── apps.py
    ├── migrations/
    ├── models.py
    ├── templates/
    │   ├── todo/
    │   │   ├── index.html
    │   │   ├── task_form.html
    │   │   └── delete_confirm.html
    ├── tests.py
    ├── urls.py
    └── views.py

ここで、各アプリケーションディレクトリ（↑の例言えば「todo」）の下にあるtemplatesディレクトリには、そのアプリケーション専用のテンプレートを配置。

プロジェクト全体で共有するテンプレート（↑の例で言えば「base.html」）はプロジェクトレベルのtemplatesディレクトリに配置します。

settings.pyのTEMPLATES設定ではDIRSオプションにプロジェクトレベルのtemplatesディレクトリのパスを含めます。

# settings.py
TEMPLATES = [
    {
        ...
        'DIRS': [BASE_DIR / 'templates'],  # BASE_DIRはプロジェクトのルートディレクトリを表す
        ...
    },
]

このようにすることで、base.htmlのようなプロジェクト全体で共有するテンプレートを各アプリケーションから参照することが可能になります。

したがって、todoアプリケーションのindex.htmlからbase.htmlを継承するには、以下のように記述すればOKということ。

{% extends 'base.html' %}
...

extendsタグで指定するテンプレートファイルの位置は、TEMPLATES設定のDIRSオプションで指定されたディレクトリの下であればどこでもかまいません。

Django：extends/blockのまとめ

<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}デフォルトタイトル{% endblock %}</title>
</head>
<body>
    {% block content %}
    <!-- この部分は子テンプレートでオーバーライド予定 -->
    {% endblock %}
</body>
</html>

{% extends "base.html" %}

{% block title %}
ページタイトル
{% endblock %}

{% block content %}
<h1>ページタイトル</h1>
<p>ここは、ページのコンテンツです。</p>
{% endblock %}

初めてPythonを勉強するのは結構難しいですよね。

でもその悩みを抱えているのは一人じゃありません。全てのPython使いが同じ道を進んできました。

Pythonをはじめとするプログラミングスキルを武器に、時間と場所に捉われない自由な生き方を目指してみませんか？今すぐ行動したい方は以下の記事をチェック！

読者料典　Python入門：学習カリキュラム　←こちらから！

DjangoはデフォルトのDBMSとしてSQLiteが設定されていますが、大規模なデータを扱うようなアプリケーションや、複数のプロセスから同時にアクセスするような状況では、パフォーマンスやデータ整合性の問題が生じる可能性があります。

一方、MySQLは大量のデータを扱うことができ、複数のユーザーからの同時アクセスに対応することができ、トランザクションをサポートしているため、データの整合性を保つことが可能。そのため、Djangoの開発では、SQLiteをそのまま利用するのではなくMySQLなどのデータベースを利用するのが一般的。

参考　トランザクションとは？

このページでは、以上のような背景を踏まえ、DjangoでMySQLを利用する方法を５つのステップに分けてわかりやすく解説します。

この解説は、既にVPS（CentOS）上にDjangoがインストールされている状況を想定しています。１から自分だけでDjango開発を行ってPythonの勉強をしたい方は以下の記事をご覧ください。

【簡単９ステップ】VPS上にPythonの実行環境を構築する方法

この記事では、VPS上にPythonの実行環境を構築する手順をわずか5分で学べます。シンプルかつ詳細なガイドラインに従って、プログラミングスキルを新たなレベルに引き上げましょう。初心者でも安心のステップバイステップの方法を提供します。

it-biz.online

2023.06.30

ステップ１：MySQLのインストール

それでは早速DjangoでMySQLを利用する方法を解説していきます。

まずはMySQLサーバをインストールします。以下のコマンドを実行。

sudo yum install mysql-server

このコマンドを実行すると、以下のような結果が返って来ますので「y」を入力。

ダウンロードサイズの合計: 21 M
インストール後のサイズ: 179 M
これでよろしいですか? [y/N]: 

次に、MySQLサーバを起動します。

sudo systemctl start mysqld

MySQLが正常に起動したか確認するには、以下のコマンドを実行します。

sudo systemctl status mysqld

以下のような結果が返ってくればOK。正常に起動していることが確認できます。

● mysqld.service - MySQL 8.0 database server
     Loaded: loaded (/usr/lib/systemd/system/mysqld.service; disabled; preset: disabled)
     Active: active (running) since Fri 2023-06-30 15:15:27 JST; 18s ago
    Process: 357658 ExecStartPre=/usr/libexec/mysql-check-socket (code=exited, status=0/SUCCESS)
    Process: 357680 ExecStartPre=/usr/libexec/mysql-prepare-db-dir mysqld.service (code=exited, status=0/SUCCESS)
   Main PID: 357756 (mysqld)
     Status: "Server is operational"
      Tasks: 39 (limit: 11106)
     Memory: 449.0M
        CPU: 3.592s
     CGroup: /system.slice/mysqld.service
             mq357756 /usr/libexec/mysqld --basedir=/usr

ステップ２：MySQLデータベースの作成

次に、Djangoで使用するためのデータベースを作成します。まず、MySQLのシェルにログインします。

mysql -u root -p

パスワードの入力が求められますが、今はまだパスワードを設定していないのでそのままEnterボタンを押下。

# mysql -u root -p
Enter password:
→このままEnterボタンを実行でログインできます。

ログインが完了すると以下のような結果が返って来ます。

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 8
Server version: 8.0.32 Source distribution

Copyright (c) 2000, 2023, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

ログインしたら以下のコマンドを実行してデータベースを作成します。your_database_nameは、作成したいデータベース名に置き換えてください。

CREATE DATABASE your_database_name CHARACTER SET UTF8;

---結果---
mysql> CREATE DATABASE your_database_name CHARACTER SET UTF8;
Query OK, 1 row affected, 1 warning (0.02 sec)

ユーザのパスワード設定方法

MySQLユーザのパスワードの設定方法は以下のような流れで行われます。

まずは、以下のコマンドを実行してください。

sudo mysql_secure_installation

このコマンドを実行すると、セキュリティ設定を行うための対話型のスクリプトが起動します。スクリプトは以下の手順で進行します。

1. パスワードの設定をするかどうかを尋ねられます。"Y"を入力してEnterキーを押します。
2. 新しいパスワードを入力してください。適切なパスワードを入力し、Enterキーを押します。
3. パスワードの強度を確認するために再度パスワードを入力します。同じパスワードを再入力し、Enterキーを押します。
4. パスワードが正しく設定されたか確認されます。
5. f匿名ユーザの削除、rootユーザのリモートログインの禁止、テストデータベースの削除を選択します。詳細は環境に合わせて選択してください。

上記の手順を実行すると、MySQLのパスワードが設定されます。再度ログインする際には、設定したパスワードを使用してログインしてください。

# sudo mysql_secure_installation

Securing the MySQL server deployment.

Connecting to MySQL using a blank password.

VALIDATE PASSWORD COMPONENT can be used to test passwords
and improve security. It checks the strength of password
and allows the users to set only those passwords which are
secure enough. Would you like to setup VALIDATE PASSWORD component?

Press y|Y for Yes, any other key for No: y

There are three levels of password validation policy:

LOW    Length >= 8
MEDIUM Length >= 8, numeric, mixed case, and special characters
STRONG Length >= 8, numeric, mixed case, special characters and dictionary                  file

Please enter 0 = LOW, 1 = MEDIUM and 2 = STRONG: 0
Please set the password for root here.

New password:

Re-enter new password:

Estimated strength of the password: 50
Do you wish to continue with the password provided?(Press y|Y for Yes, any other key for No) : y
By default, a MySQL installation has an anonymous user,
allowing anyone to log into MySQL without having to have
a user account created for them. This is intended only for
testing, and to make the installation go a bit smoother.
You should remove them before moving into a production
environment.

Remove anonymous users? (Press y|Y for Yes, any other key for No) : n

 ... skipping.


Normally, root should only be allowed to connect from
'localhost'. This ensures that someone cannot guess at
the root password from the network.

Disallow root login remotely? (Press y|Y for Yes, any other key for No) : n

 ... skipping.
By default, MySQL comes with a database named 'test' that
anyone can access. This is also intended only for testing,
and should be removed before moving into a production
environment.


Remove test database and access to it? (Press y|Y for Yes, any other key for No) : n

 ... skipping.
Reloading the privilege tables will ensure that all changes
made so far will take effect immediately.

Reload privilege tables now? (Press y|Y for Yes, any other key for No) : n

 ... skipping.
All done!

ステップ３：MySQLユーザーの作成と権限の付与

MySQLへのログインが成功したら、Djangoからデータベースにアクセスするためのユーザーを作成し、権限を付与します。

以下のコマンドを実行してください。your_usernameとyour_passwordは、作成したいユーザー名とパスワードに置き換えてください。

CREATE USER 'your_username'@'localhost' IDENTIFIED BY 'your_password';

-----
Query OK, 0 rows affected (0.01 sec)

作成したユーザーに対して、先ほど作成したデータベースへの全権限を付与します。

GRANT ALL PRIVILEGES ON your_database_name.* TO 'your_username'@'localhost';

-----
Query OK, 0 rows affected (0.01 sec)

変更を有効にするために、最後に以下のコマンドを実行します。

FLUSH PRIVILEGES;

これでMySQLの設定は完了です。MySQLのシェルを終了します。

exit;

ステップ４：DjangoでMySQLを使うための設定

Django側でMySQLを使えるように設定します。まず、DjangoがMySQLを使うために必要なパッケージをインストールします。以下のコマンドを実行してください。

pip install mysqlclient

次に、Djangoの設定ファイルであるsettings.pyを開き、データベースの設定を以下のように変更します。適切なデータベース名、ユーザー名、パスワードに置き換えてください。

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'your_database_name',
        'USER': 'your_username',
        'PASSWORD': 'your_password',
        'HOST': 'localhost',
        'PORT': '3306',
    }
}

以上で、DjangoとMySQLの設定は完了です。

ステップ５：データベースのマイグレーション

最後に、Djangoのマイグレーションを実行して、データベースのセットアップを完了します。以下のコマンドを実行してください。

python manage.py migrate

このコマンドにより、DjangoのデータベーススキーマがMySQLに適用されます。

以上で、DjangoでMySQLを利用する設定が完了しました。これにより、Djangoで作成したWebアプリケーションでMySQLデータベースを利用することができます。

参考　Djangoとは？

Djangoのモデルは、データベースの構造を定義するためのPythonのクラスで、テーブルのカラムやリレーションを定義します。これにより、データベースとのやり取りが容易になり、データの整合性を保つことが可能となります。

このページでは、Djangoのモデルについて、その基本的な概念から具体的な使用方法まで、初心者向けにわかりやすく解説します。5つのステップを通じて、Djangoのモデルを理解し、効果的に使用する方法を学んでいきましょう。

Pythonエンジニア/Djangoを利用したWeb開発者を目指す方であれば知らないと恥ずかしい超・基本知識の１つ。是非最後までご覧ください。

参考　Pythonの基本的な書き方・構文ルール

ステップ1：Djangoモデル（models.py）の基本

Djangoのモデル（models.py）は、アプリケーションのデータを構造化し、Pythonのクラスとして定義します。これにより、データベースとのやり取りが容易になり、データの整合性を保つことが可能になります。

参考　Pythonのクラスの基本

と説明されても、なかなかピンと来ない方も多いはずなので、この章では実際のサンプルコードを見つつ、Djangoモデルの基本的な要素とその役割について深めていきましょう。

モデルの定義（models.py の定義）

Djangoモデルは、Pythonのクラスとして定義。このクラスはdjango.db.models.Modelを継承します。モデルクラスの各フィールドは、モデルフィールドクラスのインスタンスとして定義され、これがデータベースの各項目を表します。

例えば、ブログ投稿を表すモデルを作成する場合、以下のように定義することができます。

from django.db import models

class BlogPost(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    pub_date = models.DateTimeField('date published')

参考　import文

モデルクラスの名前は、通常表現したいオブジェクトを表す名詞の単数形を使用。例えば、ブログ投稿を表すモデルを作成する場合、BlogPostという名前を使用します。

モデルクラス内のフィールドは、データベースの各列（カラム）を表します。フィールドの名前はPythonの変数として有効なものであれば何でも構いません。フィールドの型は、そのフィールドがどのようなデータを保存するかをDjangoに伝えます。

フィールド（項目）の種類

Djangoは多くの種類のフィールドを提供しています。これにより、様々な種類のデータをデータベースに保存することができます。以下に、いくつかの主要なフィールドを示します。

参考　プログラミング言語におけるデータ型

これらは一部の例であり、Djangoはこれら以外にも多くのフィールドタイプを提供しています。例えば、ImageFieldやFileFieldはファイルのアップロードを扱い、ForeignKeyやManyToManyFieldはモデル間のリレーションシップを表現します。

モデルのマイグレーション

モデルを定義したら、それをデータベースに反映する必要があります。これを行うために、Djangoはマイグレーションという機能を提供しています。マイグレーションは、モデルの変更をデータベーススキーマに適用する方法です。

マイグレーションを作成するには、以下のコマンドを実行します。

python manage.py makemigrations

# Migrations for 'todo':
#   todo/migrations/0003_blogpost.py
#     - Create model BlogPost

このコマンドを実行すると、Djangoはモデルの変更を追跡し、それらの変更をマイグレーションファイルに記録します。次に、以下のコマンドを実行して、これらのマイグレーションをデータベースに適用するという流れ。

python manage.py migrate

# Operations to perform:
#   Apply all migrations: admin, auth, contenttypes, sessions, todo
# Running migrations:
#   Applying todo.0003_blogpost... OK

これにより、モデルの変更がデータベーススキーマに反映されます。

例えば、利用しているDBMSがMySQLの場合、スキーマ反映後は以下のようにきちんとテーブルが作成されていることが分かります。

mysql> desc todo_blogpost;
+----------+--------------+------+-----+---------+----------------+
| Field    | Type         | Null | Key | Default | Extra          |
+----------+--------------+------+-----+---------+----------------+
| id       | bigint       | NO   | PRI | NULL    | auto_increment |
| title    | varchar(200) | NO   |     | NULL    |                |
| content  | longtext     | NO   |     | NULL    |                |
| pub_date | datetime(6)  | NO   |     | NULL    |                |
+----------+--------------+------+-----+---------+----------------+

【簡単５ステップ】DjangoでMySQLを利用する方法を３分で解説

DjangoでMySQLを利用するための設定方法を５つのステップに分けて解説します。

it-biz.online

2023.08.01

以上が、Djangoモデルの基本的な概念とその使用方法です。次のステップでは、具体的なモデルの作成方法について詳しく見ていきましょう。

ステップ2：Djangoモデルの作成方法

前章ではDjangoモデルの基本的な概念を学びました。今回はその知識を活かし、具体的なモデルの作成方法について見ていきましょう。

Djangoモデルを作成するためには、まず新しいアプリケーションを作成。以下のコマンドを実行して新しいアプリケーションを作成します。

python manage.py startapp your_app_name

このコマンドを実行すると、新しいアプリケーションディレクトリが作成され、その中にはmodels.pyというファイルが作成されます。

このmodels.pyファイルが、モデルを定義する場所です。

ブログ投稿を表すモデルを作成する場合、このmodels.pyにモデルを編集することで先ほどのようなテーブルを作成することができます。

from django.db import models

class BlogPost(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    pub_date = models.DateTimeField('date published')

あとは、マイグレーション。マイグレーションを実行する際には、特定のアプリケーションを指定することもできます。

python manage.py makemigrations your_app_name

このコマンドを実行すると、Djangoはyour_app_nameアプリケーションのモデルの変更を追跡し、それらの変更をマイグレーションファイルに記録します。

ステップ3：Djangoモデルの操作方法

ここまでで、モデル（models.py）を作成し、データベースに反映する方法を学びました。

次はモデルを使ってデータベースの操作を行う方法について解説します。具体的には、データの作成、取得、更新、削除（CRUD操作）について説明します。

データの作成

Djangoモデルを使って新しいデータを作成するには、モデルクラスのインスタンスを作成し、それを保存。以下に、BlogPostモデルを使って新しいブログ投稿を作成する例を示します。

from django.utils import timezone
from .models import BlogPost

post = BlogPost(title='My first post', content='This is my first post.', pub_date=timezone.now())
post.save()

この例では、まずBlogPostクラスのインスタンスpostを作成しています。BlogPostの括弧内には、各フィールドの初期値を指定。

ここでは、titleには'My first post'、contentには'This is my first post.'、pub_dateには現在の日時（timezone.now()）を設定しています。

最後に、save()メソッドを呼び出すことで、このインスタンスをデータベースに保存しています。この操作により、新しいブログ投稿がデータベースに作成されるという仕組みです。

データの取得

データベースからデータを取得するには、モデルクラスのobjects属性を使用します。objects属性は、モデルクラスに対するデータベースクエリを表すマネージャオブジェクトです。

以下に、すべてのブログ投稿を取得する例を示します。

posts = BlogPost.objects.all()

この例では、BlogPost.objects.all()がすべてのBlogPostオブジェクトを返します。この結果はPythonのリスト。つまり、forループを使って各ブログ投稿を順に処理することができる仕組みです。

参考　リストとは？ / forループとは？

条件を指定してデータを取得する

モデルクラスのobjects属性には、条件を指定してデータを取得するためのメソッドが用意されています。

例えば、filter()メソッドを使用すると、指定した条件に一致するすべてのオブジェクトを取得することができます。以下に、タイトルが'My first post'であるすべてのブログ投稿を取得する例を示します。

posts = BlogPost.objects.filter(title='My first post')

この例では、filter(title='My first post')がタイトルが'My first post'であるすべてのBlogPostオブジェクトを返します。この結果はPythonのリストと同様に扱うことができます。

また、get()メソッドを使用すると、指定した条件に一致する一つのオブジェクトを取得することができます。ただし、get()メソッドは一致するオブジェクトが一つだけであることを期待しています。一致するオブジェクトがない場合や、複数存在する場合にはエラーが発生します。

以上のように、Djangoではデータを取得する際に様々な条件を指定することが可能です。これにより、必要なデータだけを効率的に取得することができます。

データの更新

データを更新するには、①データを取得し、②その属性を変更し、③再度保存します。以下に、最初のブログ投稿のタイトルを更新する例を示します。

post = BlogPost.objects.get(pk=1)
post.title = 'Updated title'
post.save()

この例では、まずget()メソッドを使用して最初のブログ投稿を取得しています。get()メソッドは、指定した条件に一致するオブジェクトをデータベースから取得します。ここでは、主キー（pk）が1のブログ投稿を取得しています。

参考　主キー（primary key）とは？

次に、取得したブログ投稿のtitle属性を更新し、save()メソッドを呼び出して変更をデータベースに保存しています。

この操作により、ブログ投稿のタイトルが更新されます。

データの削除

データを削除するには、削除したいオブジェクトを取得し、そのdelete()メソッドを呼び出します。以下に、最初のブログ投稿を削除する例を示します。

post = BlogPost.objects.get(pk=1)
post.delete()

この例では、まずget()メソッドを使用して最初のブログ投稿を取得。次に、delete()メソッドを呼び出してこのブログ投稿をデータベースから削除しています。この操作により、指定したブログ投稿がデータベースから削除されるという流れです。

以上が、Djangoモデルを使ったデータベースの基本的な操作方法です。これらの操作を理解し、適切に使い分けることで、Pythonコードからデータベースを効率的に操作することができるようになります。

Djangoモデル（models.py）のまとめ

from django.db import models

class BlogPost(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    pub_date = models.DateTimeField('date published')

始めてPythonを勉強するのは結構難しいですよね。

でもその悩みを抱えているのは一人じゃありません。全てのPython使いが同じ道を進んできました。

Pythonをはじめとするプログラミングスキルを武器に、時間と場所に捉われない自由な生き方を目指してみませんか？今すぐ行動したい方は以下の記事をチェック！

読者料典　Python入門：学習カリキュラム　←こちらから！

プロジェクトは、全てのアプリケーション、データベース設定、サードパーティライブラリ、静的ファイルなど、Webサイトやアプリケーションを構成する全ての要素を含む箱のようなもの。

Djangoのプロジェクト構造は、非常に組織化されていて、特定の規則によって構成されています。これにより、異なる開発者やチーム間で効率的なコーディングが可能になります。

しかし、最初に見たとき、その構造は少々複雑に見えるかもしれません。それぞれのコンポーネントが何をするのか、どうやって連携するのかを理解することは、Djangoで効率的に開発を行うためには不可欠。

このページでは、Djangoプロジェクトの各コンポーネントとその機能を一つ一つ解説し、どのように相互に関連し合っているかを説明します。初めてDjangoプロジェクトに取り組む方や、既に始めてみて「このファイルは何をするの？」と思っている方向けにわかりやすくご説明します。

Djangoを用いたWeb開発を行いたい人であれば知らないと恥ずかしい超・基本知識の１つです。是非最後までご覧ください。

参考　Pythonの基本的な書き方・構文ルール

Djangoプロジェクトの作成

はじめに、Djangoプロジェクトの作成方法を解説します。

Djangoプロジェクトの作成は驚くほど簡単です。適切なディレクトリに移動したら、次のコマンドを実行するだけ。

django-admin startproject myproject

これで「myproject」という名前の新しいDjangoプロジェクトが作成されます。プロジェクトの名前は任意なので、目的とするWebサイトやWebアプリ用のプロジェクトであることがわかるようにしましょう。

上記のプロジェクト作成を行うと、以下のようなディレクトリが構築されます。

myproject/
    manage.py
    myproject/
        __init__.py
        settings.py
        urls.py
        asgi.py
        wsgi.py

この最初に作成されるファイルとディレクトリが、Djangoプロジェクトの基本構造です。ここでは、それぞれのファイルとディレクトリが何を表しているのかは↓の通り。

ここでは、特に大事な「settings.py」「urls.py」について詳しくご説明します。

これを理解することで、Djangoの「プロジェクト」の概念やイメージがより深まるはずです。

settings.py

Djangoプロジェクトの心臓部とも言えるのがsettings.pyファイルです。ここにはプロジェクト全体に関わる様々な設定が記述されています。

# settings.py

DEBUG = True  # デバッグモードを有効にします。

INSTALLED_APPS = [  # 使用するアプリケーションのリスト
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'myapp',  # 自作のアプリケーションもここで指定します。
]

MIDDLEWARE = [  # ミドルウェアのリスト
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

ROOT_URLCONF = 'myproject.urls'  # ルートURL設定ファイルの指定

TEMPLATES = [  # テンプレートエンジンの設定
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')],
        'APP_DIRS': True,
    },
]

DATABASES = {  # データベースの設定
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

STATIC_URL = '/static/'  # 静的ファイルへのURLのプレフィックス
STATIC_ROOT = os.path.join(BASE_DIR, 'static')  # 静的ファイルが集められる場所

参考　import文 / Pythonのリスト

このように、settings.pyファイルには様々な設定項目が存在し、それぞれの設定がDjangoプロジェクトの挙動を決定します。

urls.py

Djangoでは、ユーザーが指定したURLをクリックした際にどの画面に遷移させるか？（※どのビューを呼び出すか？）を設定します。その設定を行うのがurls.pyです。

これをURLルーティングとも呼びます。

# urls.py

from django.urls import path
from . import views  # このプロジェクトのビューをインポート

urlpatterns = [
    path('', views.home, name='home'),  # ホームページ
    path('about/', views.about, name='about'),  # "about" ページ
    path('contact/', views.contact, name='contact'),  # "contact" ページ
]

このコードのurlpatternsというリストには、それぞれのURLパターンとそれに対応するビューが設定されています。

たとえば、path('about/', views.about, name='about')という行では、ユーザーがWebサイトの"/about"というURLにアクセスしたときにviews.aboutというビューを表示するよう指定しています。

urls.py の基本や設定方法の詳細は以下の記事で解説しております。この機会に詳しく学習しておきたい方は以下をご覧ください。

【Django】urls.py の仕組み・使い方のコツを３分で解説

【初心者向け】Djangoのurls.pyの基本的な概念・実践的な使い方を、シンプルで実用的なサンプルコードと共に分かりやすく解説します。DjangoのURLパターン、動的URLパターン、名前付きURLパターン、そしてURL名前空間の意味と役割を把握し、コーディングの効率を向上させましょう。

it-biz.online

2023.07.12

Djangoアプリケーション

Djangoプロジェクトは、その全体を構成する複数のアプリケーションから成り立っています。

アプリケーションとは、Webサイトの特定の機能（例えばToDo管理、ニュース配信、レポート機能）を実装するための部品のようなもの。

アプリケーションはそれぞれが特定の機能を提供し、複数のアプリケーションが組み合わさることで、大きなWebサイトを構成。これにより、Djangoは非常にスケーラブル（拡張可能）なフレームワークとなっています。

Djangoアプリケーションの作成

Djangoでは、新しいアプリケーションを作成するためにstartappコマンドを使用します。

$ python manage.py startapp myapp

このコマンドを実行すると、myappという名前の新しいDjangoアプリケーションが作成されます。そして、その中には以下のような一連のファイルが自動的に生成されます。

これらの各ファイルはアプリケーションの特定の機能を担当し、それらがうまく連携することでアプリケーション全体が機能する仕組み。

それぞれの詳細はリンクから内容を確認してください。

プロジェクトとアプリケーションの統合

新しいアプリケーションを作成したら、それをプロジェクトに統合する必要があります。

具体的には、プロジェクトのsettings.pyファイル内のINSTALLED_APPS設定に新しく作成したアプリケーションの名前を追加することで行います。

# settings.py

INSTALLED_APPS = [
    # ...
    'myapp',  # 新しく作成したアプリケーションを追加
]

以上がDjangoのアプリケーションについての基本的な知識です。各アプリケーションが提供する機能を組み合わせることで、大きなDjangoプロジェクトを作り上げることが可能になります。

Django：プロジェクトのまとめ

- manage.py
- プロジェクト名/
  - __init__.py
  - settings.py
  - urls.py
  - asgi.py or wsgi.py

- アプリケーション名/
  - __init__.py
  - models.py
  - views.py
  - urls.py
  - admin.py
  - apps.py
  - tests.py
  - migrations/

初めてPythonを勉強するのは結構難しいですよね。

でもその悩みを抱えているのは一人じゃありません。全てのPython使いが同じ道を進んできました。

Pythonをはじめとするプログラミングスキルを武器に、時間と場所に捉われない自由な生き方を目指してみませんか？今すぐ行動したい方は以下の記事をチェック！

読者料典　Python入門：学習カリキュラム　←こちらから！