Python | ビズドットオンライン https://it-biz.online Wed, 02 Aug 2023 03:01:52 +0000 ja hourly 1 https://wordpress.org/?v=6.9.4 https://it-biz.online/wp-content/uploads/2019/10/cropped-4a332f05ade4ac7bb3c46c472cb5eac8-32x32.png Python | ビズドットオンライン https://it-biz.online 32 32 【Django】テンプレートの仕組みと基本を３分で解説 https://it-biz.online/python/template/ Mon, 10 Jul 2023 09:31:57 +0000 https://it-biz.online/?p=8138 Djangoのテンプレート（template）は、Webアプリケーションで生成されるHTMLの骨格を作成し、その中に動的なデータを埋め込むための仕組みです。

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

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

このページで学べる内容
  • Djangoのテンプレートとは？
  • Djangoテンプレートの基本
  • Djangoテンプレートタグとフィルター
  • Djangoテンプレートでの静的ファイルの扱い
  • Djangoテンプレートの継承

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

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

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

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

Django テンプレート
図1：Django テンプレート

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

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

Djangoテンプレートの基本

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

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

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

テンプレートタグ説明使用例
{% for %}、{% endfor %}リストの各要素に対してループを行う。{% for item in item_list %}<li>{{ item }}</li>{% endfor %}
{% if %}、{% endif %}条件分岐を行う。{% if user.is_authenticated %}Hello, {{ user.username }}.{% endif %}
{% else %}if タグまたは for タグと一緒に使用して、条件が満たされなかった場合の動作を定義する。{% if user.is_authenticated %}Hello, {{ user.username }}.{% else %}Please log in.{% endif %}
{% elif %}if タグと一緒に使用して、複数の条件をチェックする。{% if user.is_admin %}Admin{% elif user.is_staff %}Staff{% else %}User{% endif %}
{% empty %}for タグと一緒に使用して、リストが空の場合の動作を定義する。{% for item in item_list %}<li>{{ item }}</li>{% empty %}<li>No items.</li>{% endfor %}
{% extends %}他のテンプレートを継承する。{% extends "base.html" %}
{% block %}、{% endblock %}extends タグで継承されたテンプレートで上書き可能な領域を定義する。{% block content %}This is the content.{% endblock %}
{% include %}他のテンプレートを現在の位置に挿入する。{% include "header.html" %}
{% static %}静的ファイルへのURLを生成する。<img src="{% static "images/logo.png" %}">
{% url %}DjangoのURLパターン名からURLを動的に生成する<a href="{% url 'homepage' %}">Home</a>
{% csrf_token %}CSRF保護のためのトークンを出力する。通常はPOSTフォーム内で使用する。<a href="{% url 'homepage' %}">Home</a>
{% load %}カスタムテンプレートタグやフィルタを読み込む。{% load custom_tags %}

次の章では、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）のまとめ

Djangoテンプレート

  1. DjangoのテンプレートはWebアプリケーションの画面（ビュー）の骨格を形成するHTMLファイル。
  2. データを動的に埋め込むことで、同じテンプレートから異なる画面を作成可能。
  3. HTMLとPythonコードを分離し、保守性と再利用性を向上させることが可能。

テンプレート変数

  1. テンプレート変数はPythonから受け取ったデータをHTMLに埋め込むためのプレースホルダ。
  2. テンプレート変数は {{ variable_name }} の形式で記述される。
  3. テンプレート変数はPythonの値（文字列、数値、リスト、オブジェクトなど）をその場所に表示。

テンプレートタグ

  1. テンプレートタグはHTMLテンプレートに制御構造を追加するための構文。
  2. テンプレートタグは {% tag %} の形式で記述される。
  3. ループ（for）、条件分岐（if）、テンプレートの継承やインクルード（extends、include）など、さまざまな制御構造を表現可能。
<!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>

参考　mainタグ

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

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

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

【無料】プログラミングスクールの探し方 >

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

]]> 【Django】テンプレートの継承（extends/block）を３分で解説 https://it-biz.online/python/template-inheritance/ Tue, 11 Jul 2023 06:51:05 +0000 https://it-biz.online/?p=8166 このページでは、Djangoのテンプレートシステムにおける１つの核心的な概念「テンプレートの継承」について詳しく説明します。

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

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

テンプレートの継承
図1：テンプレートの継承

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

このページで学べる内容
  • テンプレートの継承とは
  • テンプレートの継承の使い方
  • テンプレートの継承の実践的な例
  • テンプレートの継承と再利用のベストプラクティス

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

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

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

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

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

Django テンプレートのイメージ
図2：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タグ（段落タグ）

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

図3：ベーステンプレートからの継承
テンプレートの継承の実践的な例

ここでは、ブログアプリを開発する場合の例を用いて、具体的にテンプレートの継承がどのように活用されるか？をご紹介します。

ステップ１　基底テンプレートの作成

ブログの全てのページで共有される要素（例えばナビゲーションバー、フッター、ヘッダー画像等）を含む基底テンプレート(base.html)を作成します。

<!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>

ステップ２　ブログ投稿ページのテンプレート作成

次に、基底テンプレートから継承したブログ投稿ページのテンプレート(post_detail.html)を作成します。このテンプレートでは、基底テンプレートのcontentブロックをオーバーライドします。

{% extends "base.html" %}

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

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

上記のようにして、すべてのページで共有される基本的なHTML構造を維持しつつ、個々のページで異なる内容を表示できます。これにより、コードの重複を避け、保守性と可読性を向上させることができます。

継承する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のまとめ

テンプレートの継承とは

  1. テンプレートの継承とは、１つのテンプレート（ベーステンプレート）の構造を他のテンプレート（子テンプレート）が継承することを指す。
    • HTMLやテンプレートコードの重複を避け、テンプレートの再利用性と保守性を向上させるための重要な手法。
  2. Djangoでは{% extends %}タグを使用してテンプレートの継承を行う。
  3. ベーステンプレート内で、{% 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でMySQLを利用する方法を３分で解説 https://it-biz.online/python/django-mysql/ Fri, 30 Jun 2023 07:52:34 +0000 https://it-biz.online/?p=8000 DjangoでMySQLを利用するためのステップバイステップの手順を解説します。

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

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

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

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

DjangoでMySQLを利用する方法
  • ステップ1　MySQLのインストール
  • ステップ2　MySQLデータベースの作成
  • ステップ3　MySQLユーザーの作成と権限の付与
  • ステップ4　DjangoでMySQLを使うための設定
  • ステップ5　データベースのマイグレーション

この解説は、既に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。正常に起動していることが確認できます。

MySQL active
図1:MySQL active
● 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】モデル（models.py）：初心者向けに３ステップで解説 https://it-biz.online/python/models/ Mon, 03 Jul 2023 12:15:01 +0000 https://it-biz.online/?p=8006 Web開発の世界では、データの管理と操作が非常に重要な役割を果たします。PythonのWebフレームワークであるDjangoは、このデータ管理を効率的に行うための強力なツールをモデル（models.py）として提供しています。

参考　Djangoとは？

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

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

このページで学べる内容
  • Djangoモデルの基本
  • Djangoモデルの作成方法
  • 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は多くの種類のフィールドを提供しています。これにより、様々な種類のデータをデータベースに保存することができます。以下に、いくつかの主要なフィールドを示します。

フィールドタイプ用途
CharField短い文字列
max_length（最大長を指定する必要があります）
TextField長い文字列
DateTimeField日付と時間
IntegerField整数
BooleanField真偽値（True/False）
FloatField浮動小数点数
EmailFieldメールアドレス

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

これらは一部の例であり、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）のまとめ

  1. Djangoモデルとは
    • Djangoモデルは、データベースのテーブルをPythonのクラスとして表現したものです。
    • モデルはデータの構造（フィールド）とそのデータに対する操作（メソッド）を定義します。
  2. モデルの定義
    • モデルはmodels.pyファイル内に定義します。
    • モデルクラスはdjango.db.models.Modelを継承します。
    • モデルのフィールドはクラス変数として定義します。
  3. フィールドの種類
    • Djangoは様々な種類のフィールドを提供しています（例：CharField, TextField, DateTimeFieldなど）。
    • 各フィールドは特定のデータ型を表し、データベースの列（カラム）を定義します。
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入門：学習カリキュラム　←こちらから！

]]> 【Django】プロジェクトの作成と基本構造を初心者向けに１から解説 https://it-biz.online/python/project/ Wed, 12 Jul 2023 11:48:48 +0000 https://it-biz.online/?p=8183

Web開発において、１つのWebサイトやアプリケーション全体を指し示す用語として「プロジェクト」という言葉が使用されます。

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

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

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

このページでは、Djangoプロジェクトの各コンポーネントとその機能を一つ一つ解説し、どのように相互に関連し合っているかを説明します。初めて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プロジェクトの基本構造です。ここでは、それぞれのファイルとディレクトリが何を表しているのかは↓の通り。

ファイル/ディレクトリ説明
manage.pyDjangoの道具箱です。サーバーを立ち上げたり、データベースの操作を行ったりするのに使います。
myproject/__init__.pyこのファイルがあることでPythonはmyprojectをパッケージ（関連するPythonファイルのまとまり）と認識します。普通は何も書かなくてOK。
myproject/settings.pyプロジェクト全体の設定が書かれています。例えば、使うデータベースの種類や、アプリケーションのリストなどです。
myproject/urls.pyここでは、ユーザーがアクセスするURLとそれに対応するコード（ビュー）を結びつけます。目次のようなものです。
myproject/asgi.py and myproject/wsgi.pyこれらのファイルは、Webサーバーと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のリスト

設定説明
DEBUGエラーが起きたときに詳細なエラー情報を表示するかどうかの設定。
INSTALLED_APPSDjangoプロジェクトで使用するアプリケーションのリスト。自分で作成したアプリケーションやDjangoが用意しているアプリケーションなどをここで指定する。
MIDDLEWAREリクエストとレスポンスを処理する際に、特定の処理を挟むためのミドルウェアのリスト。セキュリティ関連の処理やセッション管理などに使われる。
ROOT_URLCONFプロジェクトのルートURL設定を行うファイルを指定。通常は<プロジェクト名>.urlsが指定される。
TEMPLATESテンプレートエンジンの設定。DjangoではデフォルトでDjangoテンプレートエンジンが使われるが、必要に応じて他のエンジンを使用することも可能。
DATABASES使用するデータベースの設定。DjangoはデフォルトでSQLiteを使用するが、PostgreSQLやMySQLなど他のデータベースを使用することも可能。（関連　MySQLをDBとして利用する方法）
STATIC_URL and STATIC_ROOT静的ファイル（CSSやJavaScriptなど）の設定。STATIC_URLは静的ファイルへのURLのプレフィックスを、STATIC_ROOTはcollectstaticコマンドで静的ファイルが集められる場所を指定。

このように、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管理、ニュース配信、レポート機能）を実装するための部品のようなもの。

図1：プロジェクトとアプリケーション

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

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

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

$ python manage.py startapp myapp

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

ファイル名説明
models.pyデータベースのスキーマ（テーブルとそのフィールド）を定義します。これらの定義はDjangoのORM（Object-Relational Mapping）によりPythonのクラスとして扱われます。
views.pyユーザーに表示するページ（ビュー）を制御するためのロジックを記述します。ビューはユーザーのリクエストに対するレスポンスを決定します。
urls.pyアプリケーションのURLルーティングを定義します。特定のURLパスがどのビューに対応するのかをマッピングします。
admin.pyDjangoの管理者ページでこのアプリケーションのモデルをどのように表示するかを定義します。
apps.pyアプリケーションの設定情報が格納されています。通常は自動生成され、特別な設定が必要ない限り変更する必要はありません。
tests.pyアプリケーションのテストコードを記述します。Djangoは組み込みのテストフレームワークを提供しているため、ここにテストを書くことで自動テストが可能です。
migrations/データベースのスキーマの変更を追跡するためのディレクトリです。models.pyの変更に応じてマイグレーションファイルが生成され、これによりデータベースのバージョン管理が可能になります。

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

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

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

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

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

# settings.py

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

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

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

ポイント１　Djangoプロジェクトとは、１つのWebアプリケーション全体を指す。

ポイント２　Djangoプロジェクトの主要なディレクトリ構造は以下のようになる。

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

ポイント３　Djangoアプリケーションはプロジェクト内の個々の機能を表すモジュールで、以下のディレクトリ構造を持つ。

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

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

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

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

【無料】プログラミングスクールの探し方 >

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

]]> 【Django】urls.py の仕組み・使い方のコツを３分で解説 https://it-biz.online/python/urls-py/ Thu, 06 Jul 2023 03:45:19 +0000 https://it-biz.online/?p=8024 Djangoの中心的な要素であるurls.pyは、ユーザがアクセスしたURLを適切なビュー関数に接続する役割を担います。

Django urls.py
図1：URLパターン

参考　Django：ビュー関数（views.py）とは？

この記事では、urls.pyの設定方法と、DjangoのURLルーティングがどのように動作するかを詳しく解説。Djangoアプリケーションを利用し、適切なURL設計を行うための知識を深めていきましょう。

このページで学べる内容
  • Django URLパターン: 基本概念
    • urls.pyとは何か？
    • URLパターンの基本的な書き方
  • 動的URLパターン
  • 名前付きURLパターン
  • URL名前空間
  • 最適なURL設計とベストプラクティス

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

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

Django：URLパターンの基本

DjangoにおけるURLパターンの設定は、Webアプリケーションがユーザーのリクエストにどのように応答するかを定義する重要な設定です。このセクションでは、urls.pyファイルの役割と、基本的なURLパターンの作り方を解説します。

URLパターンとは？

URLパターンとは、Djangoがどのビュー関数を呼び出すかを判断するために使用するURLのルールまたはテンプレートのことを指します。

URLパターンは、Djangoのurls.pyファイル内で定義され、アプリケーションがブラウザからのリクエストをどのビューにルーティングするかを定義します。

例えば、あなたがブログ投稿アプリを開発しているとします。

ユーザーが個々のブログ記事を読むためには、それぞれの記事に対応するURLにアクセスする必要があります。URLパターンは、このとき、どのURLがどのビュー（つまり、どの記事）にマッチするかをDjangoに伝える役割を果たすようなイメージ。

Django urls.py
図1：URLパターン

上記の例で言うと、/AAA というURLをクリックされたら、View A を呼び出すような設定を行っているということ。

この章では上記URLパターンの定義（urls.py）の利用方法・基本を解説します。

Django urls.py とは

Djangoにおけるurls.pyファイルは、ユーザーのブラウザからのリクエスト（URL）を適切なビュー関数にルーティングするための"地図"の役割を果たします。

簡単に言うと、urls.pyはDjangoがユーザーのリクエストをどのように処理すべきかを指示するためのファイルです。

Django urls.py
図2：Django urls.py

urls.pyファイルはPythonのリスト　urlpatterns　を含んでいます。その中にpath()関数を使ったURLパターンが列挙されています。

参考　Python：リストとは？ / 関数とは？

以下が基本的なurls.pyファイルのサンプルコード。

from django.urls import path
from . import views

urlpatterns = [
    path('', views.home, name='home'),
]

参考　import文

上記のコードでは、URLがhttp://yourwebsite.com/（空のパス）であった場合、views.homeというビュー関数が呼び出されるように指示しています。

上記のコードを完全に理解するためには、path関数の使い方をマスターしている必要があります。ここで、path関数の使い方をご説明します。

path関数

path関数の基本的な利用方法は以下の通り。

path(route, view, kwargs=None, name=None)

path関数の引数

  • route：URLパターンを表す文字列。このパターンがユーザーからのリクエストと一致した場合、指定されたビューが呼び出される。
  • view：上記のrouteがマッチしたときに呼び出されるビュー関数。ビュー関数はユーザーのリクエストを処理し、レスポンスを生成する。
  • kwargs：任意のキーワード引数をビューに辞書として渡す（必須ではありません）。
  • name：URLパターンに名前をつけるためのもので、テンプレート内などから参照できます（必須ではありません）。

上記を踏まえて、再度サンプルコードを見てみましょう。

from django.urls import path
from . import views

urlpatterns = [
    path('articles/', views.article_list, name='article_list'),
    path('articles/<int:article_id>/', views.article_detail, name='article_detail'),
]

↑のサンプルコードでは、２つのpath関数が使われています。

1つ目のpath関数は、'articles/'というURLパターンがマッチした場合にviews.article_listというビュー関数を呼び出します。

2つ目のpath関数は、'articles/<int:article_id>/'というURLパターンがマッチした場合にviews.article_detailというビュー関数を呼び出します。このURLパターンは、特定の記事の詳細を表示するためのもので、<int:article_id>という部分は動的な部分（パスコンバータと呼ばれます）で、この部分には記事のIDが入ります。

動的URLについては後ほど詳しく解説します。ここでは、path関数の使い方とその役割が理解できればOK。

re_path関数

path()関数は非常に直感的にURLパターンを記述することが可能です。しかし、複雑なURLパターンを記述する必要がある場合に備えて、Djangoはより強力なツールre_path()関数を提供しています。

この関数はPythonの正規表現を用いてURLパターンを記述することを可能にします。

re_path()関数の基本的な利用方法は以下の通り。

re_path(route, view, kwargs=None, name=None)

この引数はpath()関数のものと同じですが、この際「route」は正規表現を使用した文字列となります。

from django.urls import re_path
from . import views

urlpatterns = [
    re_path(r'^articles/$', views.article_list, name='article_list'),
]

re_path()関数は、'^articles/$'というURLパターンがマッチした場合にviews.article_listというビュー関数を呼び出します。ここで^は文字列の先頭、$は文字列の末尾を意味し、このパターンはarticles/というURLにのみマッチします。

正規表現はうまく利用することで非常に便利なツールとなりますが、その分複雑で覚えることがたくさんあります。しかし、DjangoのURLディスパッチャで正規表現を理解しておくと、より複雑なURLマッチングを柔軟に行うことが可能になるので、この点も頭に入れておくと便利です。

Django：動的URLパターン

Djangoの強力な特性の1つ。それが、URLパターンを動的に生成できることです。これにより、一定のルールに基づいて可変的なURLを作成でき、各URLが特定のビューと一致するようにすることができます。

例えば、ブログ記事の個々のページを表示するためのURLを生成する必要があるとします。記事が何千もある場合、それぞれの記事に対して固定のURLパターンを作成するのは非現実的です。ここで動的URLパターンの利点が生きてきます。

具体的には、URL内の特定の部分をプレースホルダとして扱い、それをビューに渡す引数として利用します。

path('articles/<int:article_id>/', views.article_detail, name='article_detail'),

ここでは、<int:article_id>　の部分が動的URLパターンに該当します。

このパターンは、"articles/"に続く整数をarticle_idとして取り扱います。そしてこのarticle_idがarticle_detailビューに引数として渡され、そのビュー関数内で特定の記事の詳細を取得するのに使用されるという仕組み。

このように動的URLパターンを使用することで、一つのURLパターンとビューが、任意の数の記事詳細ページを処理できるようになります。

ビュー関数で動的URLパターンを受け取る方法

先ほどのpath関数を、ビュー関数で受け取るには以下のように記述します。

def article_detail(request, article_id):
    # ...

article_detailビュー関数は2つの引数を受け取ります。１つ目のrequestはDjangoから自動的に渡されるHttpRequestオブジェクトで、２つ目のarticle_idはURLから渡されるパラメーターです。

このarticle_idを使うことで、例えばデータベースから特定の記事を取得することができます。

from django.shortcuts import get_object_or_404
from .models import Article

def article_detail(request, article_id):
    article = get_object_or_404(Article, id=article_id)
    # ...

# ここではget_object_or_404関数を使用して
# IDに基づいてArticleオブジェクトを取得。

名前付きURLパターン

Djangoのurls.pyでは、個々のURLパターンに名前をつけることができます。

名前をつけると、プロジェクト全体でそのURLを一意に参照することができ、テンプレートやビュー、あるいはリダイレクトの中でその名前を利用してURLを逆引きすることが可能になります。

path('articles/<int:article_id>/', views.article_detail, name='article_detail'),

この例では、name='article_detail'としてURLパターンに名前をつけています。これにより、他の場所から'article_detail'という名前でこのURLパターンを参照できます。

たとえば、ビュー内でredirect関数を使用してリダイレクトを行う場合、URLの名前を使用することができます。

from django.shortcuts import redirect

def create_article(request):
    # ...
    return redirect('article_detail', article_id=new_article.id)

上記は、新規記事を作成した後その記事の詳細ページにリダイレクトさせるサンプルコードです。

ここでは、redirect関数にURLパターンの名前と、必要なパラメーター（この場合はarticle_id）を渡すことで、狙ったURLにリダイレクトさせています。

URL名前空間

大規模なDjangoプロジェクトでは、アプリケーションごとにURL設定を分けることが一般的。

このとき、異なるアプリケーション間でURLの名前が衝突しないようにするために、URL名前空間を利用します。URL名前空間は、アプリケーションごとにURLの名前を分ける概念であり、それぞれのアプリケーションが独自の"スペース"を持つことを可能にします。

具体的にURL名前空間を利用するには、各アプリケーションのurls.pyでapp_nameという変数を設定します。

app_name = 'blog'
urlpatterns = [
    path('articles/<int:article_id>/', views.article_detail, name='article_detail'),
    # ...
]

ここでは、app_nameに'blog'という名前を設定しました。これにより、このurls.pyで定義されるURLパターンは全て'blog'という名前空間に所属します。

この'blog'という名前空間に属したURLの逆引きを行う際には、'namespace:name'という形式でURLの名前を指定します。

return redirect('blog:article_detail', article_id=new_article.id)

この例では、redirect関数に'blog:article_detail'という名前を渡しています。この名前は、'blog'という名前空間の'article_detail'というURLを指しています。

このようにURL名前空間を使用することで、複数のアプリケーション間でURLの名前が衝突することなく、各アプリケーションが独立してURL設定を行うことができます。これにより、大規模なプロジェクトでもURLの管理が容易になります。

Django urls.py のまとめ

  1. Django URLパターン Djangoでは、URLパターンを用いて特定のURLがどのビュー関数にマッピングされるかを定義。path関数を利用したシンプルな文字列マッチングか、re_path関数を利用した正規表現マッチングを利用可能。
  2. 動的URLパターン パスコンバータを用いてURLから特定のパラメータを抽出し、それをビュー関数に渡すことが可能。
  3. 名前付きURLパターン 各URLパターンに名前を付けることで、そのURLをプロジェクト全体で一意に参照することが可能。これにより、URLの変更があったときにも、その名前を使っているすべての場所で自動的に新しいURLに更新される。
  4. URL名前空間 名前空間を設定することで、複数のアプリケーション間でURLの名前が衝突することを避け、各アプリケーションが独立してURL設定を行うことが可能。
## urls.py
from django.urls import path
from . import views

app_name = 'blog'
urlpatterns = [
    path('articles/<int:article_id>/', views.article_detail, name='article_detail'),
]

## views.py
from django.shortcuts import render, get_object_or_404
from .models import Article

def article_detail(request, article_id):
    article = get_object_or_404(Article, id=article_id)
    return render(request, 'blog/article_detail.html', {'article': article})

関連　Djangoテンプレート / render関数

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

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

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

【無料】プログラミングスクールの探し方 >

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

]]> 【Django】render関数の使い方をわかりやすく３分で解説 https://it-biz.online/python/render/ Mon, 10 Jul 2023 11:30:08 +0000 https://it-biz.online/?p=8152 Djangoのrender関数とは、HTTPリクエストを受け取り、指定されたテンプレートとデータを使用してHTML形式のHTTPレスポンスを生成する役割を担います。

参考　HTTPリクエスト/レスポンス

簡単に言えば、render関数はクライアントからのリクエストに対して動的にHTMLを生成し、それをレスポンスとして返すための関数。

このページではrender関数の使い方を初心者向けに１からわかりやすくサンプルコード付きでご説明します。

このページで学べる内容
  • render関数の使い方・構文ルール
    • Djangoのビュー（views.py）
    • Djangoのテンプレート
  • render関数を利用する際の注意点

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

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

Django：render関数とは？

Djangoのrender関数は、HTTPリクエストを処理して、テンプレートを使ってHTTPレスポンスを作成するのに使用されます。render関数はDjangoのテンプレートシステムと強力に統合されており、テンプレートを使ってHTMLを生成することができます。

render関数を理解するためには、Djangoの「テンプレート」の基本知識を有している必要があります。テンプレートって何？という方は以下の記事をご覧ください。

【Django】テンプレートの仕組みと基本を３分で解説
【初心者向け】Djangoテンプレートの基本を３分で理解するためのガイド。テンプレートの概念、テンプレート変数とテンプレートタグの使用方法について簡潔に説明します。手に取るように理解できる具体的なコード例も提供。DjangoでのWeb開発に必要な知識を素早く身につけましょう。
it-biz.online
2023.08.02

render関数の構文ルール

render(request, template_name, context)

参考　Python関数の使い方・基本

  1. request：ビュー関数に渡すHTTPリクエストオブジェクト
  2. template_name：描画するテンプレートの名前
  3. context：テンプレートに渡すデータを含む辞書（キーと値のペア）

基本的な構文ルールは上記の通り。実際のサンプルコードを見ていきながら、それぞれの引数の役割、Djangoにおけるrender関数の使い方を確認していきましょう。

render関数の使い方とコツ

Djangoのrender関数は主にviews.pyの中で利用されます。

Djangoのビュー（views.py）の基本は以下の記事を参照してください。

【Django】ビュー（views.py）：初心者向けに５ステップで解説
Djangoのビューについての基本的な概念から詳細な手順までを網羅的に解説します。関数ベースビュー、クラスベースビュー、汎用ビュー、ビューのテストについて学びます。
it-biz.online
2023.07.10

ビュー関数（クラスベースのビューのメソッド）はHTTPリクエストを受け取り、HTTPレスポンスを返す役割を担います。

図1：Djangoのビュー

↑を実現するためにviews.py中で利用されるのが、render関数。render関数は、テンプレートをレンダリングし、その結果をHTTPレスポンスとして返します。

# myapp/views.py

from django.shortcuts import render

def some_view(request):
    context = {"key": "value"}  # テンプレートに渡すためのデータ
    return render(request, "template_name.html", context)
  1. request：HTTPリクエスト
  2. テンプレート名：描画するテンプレートの名前。ここではtemplate_name.htmlとしています。Djangoは設定で指定されたテンプレートディレクトリを検索し、この名前のテンプレートを探します。
  3. context：テンプレートに渡す辞書。テンプレート内でこれらの値を変数として使用することができます。

参考　import文 / def文

上記の例では、まずdjango.shortcutsからrender関数をインポート。続いて、some_viewというビュー関数を定義しています。そして、render関数はテンプレートとcontextを使ってHTMLを生成し、そのHTMLを含むHTTPレスポンスオブジェクトを返します。

ざっくり図解するとrender関数の役割は以下のようなイメージ。

指定されたビューが呼び出されると事前に定義したrender関数が、画面を描画するための情報を整理しレスポンスするような形です。

Django render関数
図2：Django render関数

render関数を利用する際の注意点

Django初心者が躓きやすいrender関数の注意点を以下に整理します。

上記の通りにコーディングしても、Djangoでうまく画面表示ができない・・・という方は以下のポイントをチェックしましょう！

  1. テンプレートの場所: Djangoは設定ファイル（settings.py）で指定されたディレクトリからテンプレートとなるHTMLファイルを探します。そのため、テンプレートを適切な場所に配置していないと、Djangoはそれを見つけられずにエラーとなります。
  2. テンプレート変数の名前: コンテキストの辞書のキーは、テンプレート内での変数名として使用されます。これらの名前はテンプレート内で衝突しないように、適切に選ぶことが重要。
  3. 存在しない変数の扱い: Djangoテンプレートでは、存在しない変数にアクセスした場合にはデフォルトで何も表示されず、エラーも出ません。これは意図しない結果をもたらす可能性があるので注意が必要。
  4. リクエストオブジェクトの引き渡し: render関数の最初の引数は、現在処理中のHTTPリクエストオブジェクトでなければなりません。これを忘れると、Djangoはエラーを返します。
  5. エスケープと安全性: Djangoテンプレートシステムは、デフォルトで変数の内容をHTMLエスケープします。これはセキュリティ対策として重要な機能ですが、エスケープしたくない場合にはsafeフィルタを使うなどの対策が必要です。

以上のような点に注意しながらrender関数を使用することで、エラーを防ぎ、期待通りの動作を得ることができるでしょう。

Django：render関数のまとめ

以下のサンプルコードは、シンプルなDjangoのWebアプリケーションの一部として、render関数の使い方を示しています。

urls.py（ディレクトリ/urls.pyというパスに配置）

from django.urls import path
from . import views  # 同じディレクトリのviews.pyをインポート

urlpatterns = [
    path('', views.home, name='home'),  # ルートURL（http://yourdomain/）へのアクセスをviews.home関数にマッピング
]

参考　urls.pyの役割

views.py（ディレクトリ/views.pyというパスに配置）

from django.shortcuts import render

def home(request):
    # 'home.html'というテンプレートを描画し、コンテキストとして空の辞書を渡す
    return render(request, 'home.html', {})

参考　views.pyの役割

home.html（ディレクトリ/templates/home.htmlというパスに配置）

<!DOCTYPE html>
<html>
<head>
    <title>ホームページ</title>
</head>
<body>
    <h1>ようこそ、Djangoのホームページへ！</h1>
</body>
</html>

この例では、ユーザがルートURL（例えばhttp://localhost:8000/）にアクセスすると、homeビュー関数が呼び出されます。この関数では、render関数を使用してhome.htmlテンプレートを描画し、その結果をHTTPレスポンスとして返します。

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

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

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

【無料】プログラミングスクールの探し方 >

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

]]> Djangoとは？：Pythonの人気Webフレームワークを初心者向けに解説 https://it-biz.online/python/django/ Fri, 30 Jun 2023 05:41:39 +0000 https://it-biz.online/?p=7986 Django（ジャンゴ）とは、Pythonで書かれた無料＆オープンソースのWebフレームワークのこと。

豊富な機能と簡単な拡張性により、開発者が迅速にメンテナンス性の高いWebアプリケーションを作成できるように設計されている点が特徴。

Pythonという言葉を聞いたことがあるかもしれませんが、Python自体は一種のプログラミング言語で、その上で動作するDjangoはその能力を最大限に引き出すためのツールです。

この記事では、「Djangoって何？」「何のためにどうやって使われているの？」という疑問を解消すべく、IT初心者向けにDjangoの魅力とその基本的な使い方を分かりやすく解説します。一緒にDjangoの世界を探求していきましょう！

このページで学べる内容
  • Webフレームワークの役割
  • Djangoの特徴/利点/使用例
  • Djangoのインストール方法
  • Djangoでの基本的なWebアプリケーションの作り方
    • Djangoプロジェクトの作成
    • Djangoアプリケーションの作成
    • データベースの設定
    • View、URL、テンプレートの基本的な作り方

Pythonエンジニアであれば、知っておいて損はない基本知識の１つ。是非最後までご覧ください。

Webフレームワークとは？

はじめに、Webフレームワークとは何か、なぜそれが重要なのか？についてご説明します。

Webフレームワークは、一言で表すと「WebサイトやWebアプリケーションを作るための道具箱」です。

Webフレームワークがあることで、プログラマーは難解なコードを１から書く必要なく、複雑なWebアプリケーションを効率的に開発することができます。

例えば、Webフレームワークには以下のような役割があります。

Webフレームワークの主な役割
  • ルーティング
  • データベースとのインターフェース
  • テンプレートエンジン

これらの機能をフレームワークが提供してくれることで、開発者は複雑なWebアプリケーションも効率よく作成することができます。１から自分ですべてを作る必要がないので、必要な機能の開発にコストをかけることが可能。

その一つがPythonで作られたDjangoです。

Djangoはこのような一般的なフレームワークの機能に加え、セキュリティ対策や管理画面など、より高度な機能を初めから備えており、世界中の様々なWebサイトがDjangoをベースに構築されています。

Webサイト概要
Instagram世界で最も人気のある写真共有サービスの一つ。
ユーザーは写真をアップロードしそれを他のユーザーと共有することが可能。
MozillaFirefoxの開発者であるMozilla Foundationの公式Webサイト。
Pinterestユーザーがイメージを「ピン」として保存し、
それらをテーマ別に分類することができるプラットフォーム。
The Washington Post米国の主要な日刊新聞のWebサイト。
ニュース記事やコラム、ブログを提供しています。
Djangoで構築された主なWebサイト

それでは、なぜDjangoが多くのWebサイトで利用されているのか？次の章ではDjangoの特徴や利点をわかりやすく解説します。

「ライブラリ」「パッケージ」「フレームワーク」

Pythonを勉強している方は、ライブラリやパッケージといった単語を聞いたことがある方も多いかもしれません。ここでは、それらの関連性を整理しておきます。

参考　モジュール/パッケージ/ライブラリの違いを３分で解説

  1. ライブラリ：これはプログラミングにおいて、特定の機能を提供するコードの集まりのことを指します。例えば、数学的な計算を行うライブラリ、データをグラフとして描画するライブラリなどがあります。これらはプログラマーが自分で一からコードを書く手間を省くために存在します。
  2. パッケージ：パッケージは複数のライブラリやモジュールをひとまとめにしたものです。これらは特定の目的を達成するために、関連するライブラリやモジュールを一緒に管理し、利用しやすくするためのものです。
  3. フレームワーク：フレームワークはある種の"設計図"や"骨組み"のようなもので、開発者がアプリケーションを効率的に構築するための基盤を提供します。一般的には、特定のアーキテクチャやデザインパターンに基づいて設計されており、開発プロセスを標準化し、品質を向上させる役割を果たします。

これらの関連性について説明すると、フレームワークは特定の目的を達成するための一連のパッケージやライブラリを組み合わせ、それらを一つの統一された構造の中に組み込んだものと言えます。

つまり、フレームワークは複数のパッケージやライブラリを利用して、それらを一つの全体として働くように組み合わせたものです。

具体的にDjangoに置き換えて考えてみると、DjangoはWebアプリケーションを開発するためのフレームワークで、その内部にはWebページを作るためのテンプレートシステム、データベースを操作するためのORM、ウェブリクエストを処理するためのルーティングシステムなど、様々なライブラリやパッケージが組み込まれているものと考えられます。

これらを効率的に活用することで、ウェブアプリケーションの開発を効率化し、品質を高めることが可能になります。

Django（ジャンゴ）の特徴

Djangoの主な特徴は以下の通り。

Djangoの特徴
  • DRY原則による効率的な開発
  • セキュリティ対策
  • 高度な管理画面
  • 柔軟なデータベース設計

それぞれの内容について少しだけ深掘りしながら説明します。徐々にDjangoが何者であるか？がわかってくることと思います。

Djangoの特徴１：DRY原則による効率的な開発

DjangoではDRY（Don't Repeat Yourself）という原則が重視されています。これは「同じコードを何度も書かない」という意味です。

例えば、あなたが手紙を書くとき、同じ内容の手紙を5人に送るとします。それぞれの手紙を一から書くのは時間がかかりますよね。でも、一度書いた手紙のコピーを作れば、それほど時間はかかりません。

これがDRYの原則です。これにより、コードは整理され、保守も容易になります。

Djangoの特徴２：セキュリティ対策

Djangoはセキュリティを最初から考慮に入れて設計されています。

通常、セキュリティは設計・開発を行いながら、徐々にその精度や強度を高めていくものですが、Djangoを利用すれば最初からそれらのセキュリティのセットが組み込まれているので、効率的かつ安心に利用することができます。

Djangoを使用すれば、SQLインジェクションやクロスサイトスクリプティングなど、Web開発における一般的なセキュリティの脅威から保護されます。

家を建ててから、鍵や防犯カメラを設置するのではなく、最初から鍵や防犯カメラが設置されている家を改築・増築していくようなイメージに近いかもしれません。

Djangoの特徴３：高度な管理画面

Djangoは初めから使える高機能な管理画面を提供しています。

これは、あなたが新しいスマートフォンを手に入れたときに、最初から便利なアプリがインストールされているのと同じ。これにより、ユーザー管理やコンテンツの管理が容易になります。

通常、0からWebアプリケーションを開発する際には、当たり前ですが管理画面も存在しないため、必要であれば自分で管理画面を作成します。その手間が省けるというのがDjangoを利用するメリットの１つ。

Djangoの特徴４：柔軟なデータベース設計

Djangoではデータベース設計が非常に柔軟に行えます。

Djangoのオブジェクトリレーショナルマッピング（ORM）という機能を用いると、データベースの操作がPythonのコードで直感的に書けるようになります。

Python自体でデータベース設計を行うことも可能ですが、Pythonだけでデータベースを操作するためには、SQL（Structured Query Language）というデータベースを操作するための言語を学び、直接SQLを書く必要があります。

対して、Djangoを利用すればORMが利用できるので、Pythonのコードだけでデータベース操作が可能となります。これにより、SQLの詳細な知識がなくても、直感的にデータベース操作が行えるという点が特徴。

さらにDjangoでは、データベースのスキーマ（構造）を定義するためのモデルという概念が提供されています。これを用いることで、Pythonのクラス定義だけでデータベースのスキーマを定義することができ、コードの見通しが良くなります。このような機能があるため、Djangoを用いるとPythonだけでデータベース設計を行うよりも手間が大幅に削減できます。

PythonとDjangoのインストール手順

Djangoを利用するためには、まずPythonとDjangoを自身のコンピューターにインストールする必要があります。

その詳細な手順は別記事にて詳しく解説していますが、概要を以下に説明します。

ステップ１

Pythonのインストール：Pythonは多くのオペレーティングシステムで使用可能です。公式ウェブサイトからダウンロードし、インストールします。

【Windows版】Pythonのインストール方法をわかりやすく３分で解説
【初心者向け】Pythonを１から学習しようとしている方のために、最初の第１歩となるPythonのインストール方法から、プログラムの実行まで画像付きでまとめました。初心者でも分かりやすいように、完全図解（コマンドはコピペ可）で説明します。本ページを読み切れば、自分のパソコンでPythonを実行することができるようになります。
it-biz.online
2023.06.14

ステップ２

Djangoのインストール：Pythonをインストールした後、Pythonのパッケージ管理システム（pip）を使用してDjangoをインストールします。

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

↑こちらの記事ではVPS上にPythonの実行環境を構築する手順を解説しています。

Djangoでの基本的なWebアプリケーションの作り方

Djangoを用いてWebアプリケーションを作る流れを簡単に説明します。

まずは、新たなDjangoプロジェクトを作成するところから始めましょう。

Djangoプロジェクトの作成

DjangoでWebアプリケーションを作るためには、まずDjangoプロジェクトを作成する必要があります。

Djangoプロジェクトとは、あなたのWebアプリケーション全体を指す「コンテナ」「箱」「入れ物」のようなもので、アプリケーションの設定やデータベースの設定など、アプリケーション全体に関わる情報を管理するもの。

Djangoプロジェクトの作成は非常に簡単で、以下のコマンド一つで新たなプロジェクトを作成できます。

django-admin startproject myproject

このコマンドを実行すると、「myproject」（名前は任意で変更可能）という名前の新たなDjangoプロジェクトが作成されます。プロジェクト内部には、最初から基本的な設定が行われた設定ファイルやURLのルーティングを管理するファイルなどが含まれています。

Djangoプロジェクト
図1：Djangoプロジェクト（１）
Djangoプロジェクト
図2：Djangoプロジェクト（２）
ファイル
ディレクトリ		説明
myproject/プロジェクトのルートディレクトリ。
このディレクトリ名は、startprojectコマンドで指定したプロジェクト名。
├── myproject/Djangoプロジェクトの設定ディレクトリ。
このディレクトリ名も、startprojectコマンドで指定したプロジェクト名。
│ ├── init.pyPythonのパッケージを表すための空ファイル。
│ ├── settings.pyプロジェクトの設定ファイル。
データベースの設定、インストールされたアプリケーションのリスト、
テンプレートの設定、ミドルウェアの設定など。
プロジェクト全体に関わる設定がここに記述されます。
│ ├── urls.pyプロジェクトのURL設定ファイル。
URLとビューを結びつけるためのルーティング設定がここに記述されます。
│ └── wsgi.pyプロジェクトを配信するためのWSGIアプリケーションのエントリポイント。
WebサーバとDjangoアプリケーションをつなげる役割を果たします。
└── manage.pyDjangoプロジェクトを管理するためのコマンドラインユーティリティ。
Djangoアプリケーションの作成、開発用サーバの起動など。
Djangoに関連する様々なタスクをこのスクリプトを通じて行います。

上記はDjangoプロジェクトを新規に作成したときの最初のディレクトリ構成。

この中に新たなDjangoアプリケーションを作成したり、追加の設定を行ったりすることで、Webアプリケーションを作り上げていきます。

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

Djangoプロジェクトを作成した後、次に行うのがDjangoアプリケーションの作成です。Djangoアプリケーションは、特定の機能を持つ一つのモジュールを指します。

例えば、ブログ機能、ユーザー管理機能、商品管理機能などはそれぞれ機能ごとに別のアプリケーションとして作成していきます。

Djangoアプリケーションの作成もコマンド一つで行うことができます。以下のコマンドで新たなアプリケーションを作成します。

python manage.py startapp myapp

上記のコマンドを実行すると、「myapp」という新たなDjangoアプリケーションが作成されます。

アプリケーション内部には、モデル（データベースの構造を定義）、ビュー（アプリケーションの「見た目」を制御）、URLの設定などを行うための基本的なファイル群が自動的に作成されます。

Djangoアプリケーション
図3：Djangoアプリケーション
ファイル名内容
__init__.pyパッケージの初期化を担当する特殊なPythonファイル。
このファイルがあることで、
Djangoはこのディレクトリをパッケージとして扱う。
admin.pyDjangoの管理インターフェースでモデルを操作する設定を行う。
apps.pyアプリケーションの設定を行うためのファイル。
アプリケーションの名前や設定などを記述します。
migrations/このディレクトリはデータベーススキーマの
マイグレーション（変更）履歴を管理するために使われます。
models.pyアプリケーションで使用するデータベースのテーブルを
Pythonのクラスとして定義する。
tests.pyテストを書くためのファイルです。
Djangoはテスト駆動開発を強く推奨しており、
新しい機能を開発する前にまずそのテストを書くことを推奨している。
views.pyユーザーがブラウザでアクセスしたときに
表示されるページ内容を決めるためのファイル。
各ページにどのようなデータを表示するのか、
どのテンプレートを使用するのかなどを定義します。

このように、Djangoではプロジェクトとアプリケーションの概念をうまく分離して管理することで、１つの大きなWebアプリケーションを小さな部品（アプリケーション）の集合体として扱うことができます。

プロジェクトとアプリケーションの関係をわかりやすく・・・

Djangoのプロジェクトとアプリケーションの関係は、街（プロジェクト）とその中の建物（アプリケーション）という関係性に似ています。

例えば、街（プロジェクト）を考えてみましょう。

街全体の設計図（設定ファイル）があり、それにより街の全体像が定まります。その設計図に基づいて、道路が作られ、街の全体的なレイアウトが決定します。

そして、街にはさまざまな建物（アプリケーション）が存在します。例えば、レストラン、図書館、ショッピングモールなどがそれに当たります。これらの建物はそれぞれ特別な目的を持っています。レストランでは食事を提供し、図書館では書籍を提供し、ショッピングモールではさまざまな商品を提供。

このように、Djangoのプロジェクト（街）は全体的な構造や設定を定義し、アプリケーション（建物）はその中で特定の機能（レストランの食事、図書館の書籍など）を提供します。そしてこれらが組み合わさることで、一つの完全なWebサイトが構築されるわけです。

データベースの設定

Djangoは多種多様なデータベースエンジンとの連携が可能で、その設定方法は非常にシンプルです。

ここではその設定方法について、初心者の方でも理解できるよう詳しく説明します。

まず、Djangoでのデータベースの設定は、settings.pyというファイルに書かれます。具体的には、settings.py内にあるDATABASESという部分にデータベースの設定を書きます。この設定はPythonの辞書型という形式で記述されます。

Django データベースの設定
図4：Django データベースの設定

デフォルトの設定では、DjangoはSQLiteというDBMSを使用します。これは小規模なアプリケーションには適していますが、大規模なアプリケーションの場合はPostgreSQLやMySQLといったデータベースエンジンを使うことが多いです。

MySQLを利用する場合、settings.py内のDATABASESセクションは以下のように書き換えます。

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '3306',
    }
}
  • ENGINE: 使用するDBMS。MySQLの場合はdjango.db.backends.mysqlとなります。
  • NAME: 使用するデータベースの名前。あらかじめMySQLで作成しておく必要があります。
  • USER: データベースのユーザー名。該当のデータベースにアクセス可能なユーザーを指定します。
  • PASSWORD: データベースのユーザーのパスワード。
  • HOST: データベースサーバーのホスト名またはIPアドレス。同一マシン内で動作させる場合はlocalhostを指定。
  • PORT: データベースサーバーのポート番号。MySQLのデフォルトは3306です。

以上の設定を行うことで、DjangoからMySQLデータベースにアクセスできるようになります。

ただし、DjangoがMySQLと通信するためには、PythonのMySQLクライアントが必要で、mysqlclientやPyMySQLなどが一般的に利用されます。これらは追加でインストールする必要があります。

View/URL/テンプレートの基本的な作り方

Djangoの魅力の一つは、View、URL、テンプレートという3つの要素が連携してWebアプリケーションを構築するアーキテクチャ――MTV (Model Template View) と呼ばれるアーキテクチャを採用しています。

それぞれの要素の役割と、その基本的な作り方を見ていきましょう。

Viewの作り方

Viewは、ユーザーからのリクエストを受け取り、適切なレスポンスを生成する役割を果たします。基本的にはPythonの関数またはクラスとして定義します。

from django.http import HttpResponse

def hello(request):
    return HttpResponse("Hello, world!")

参考　import文 / print関数

上記のhello関数は、リクエストを受け取り、文字列 "Hello, world!" をレスポンスとして返します。

URLの設定

URL設定は、ユーザーがブラウザでURLを入力したとき、そのリクエストをどのViewに送るべきかを決定します。urls.pyにパスと対応するViewを指定することで、URLの設定を行います。

以下に、先程作成したhello関数を対応させるURLの設定例を示します。

from django.urls import path
from . import views

urlpatterns = [
    path('hello/', views.hello, name='hello'),
]

テンプレートの作り方

テンプレートは、HTMLを生成するためのファイル。

参考　HTMLとは？

テンプレートを利用することで動的なデータを簡単にHTMLに組み込むことができます。Djangoは、テンプレート言語を用いて、Pythonの変数や命令をHTML内に埋め込むことが可能です。以下に、シンプルなテンプレートの例を示します。

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

ここでは、{{ name }}がテンプレート変数で、この部分がViewから渡された値に置き換わります。

これら3つの要素――View、URL、テンプレート――がうまく連携することで、Djangoでは動的で豊富な機能を持つWebアプリケーションを簡単に作り上げることができます。

Python：Djangoのまとめ

  1. Djangoとは・・・
    • Pythonで作成されたWebフレームワーク
    • Webアプリケーション開発に必要なすべてを１つに集約
  2. Djangoの特長
    • レスポンシブな開発: PCやスマホなど様々なデバイスに対応したWebアプリケーションを短時間で作成可能
    • 高度な管理画面: データの管理を手軽に行える自動生成される管理サイトを提供
    • 柔軟なデータベース設計: ORM（Object-Relational Mapping）を利用したデータベース操作を可能にする
  3. Djangoプロジェクトとアプリケーション
    • プロジェクト: DjangoのWebアプリケーション全体を管理するためのコンテナ
    • アプリケーション: 一つの機能やウェブサイトの一部を実現する単位
  4. データベース設定
    • Djangoのsettings.pyでデータベースの設定を行う
    • 使うデータベースに応じて設定を変える（例: SQLite, PostgreSQL, MySQLなど）
  5. View、URL、テンプレートの基本的な作り方
    • View: ユーザーからのリクエストを受け取り、適切なレスポンスを生成
    • URL: リクエストをどのViewに送るべきかを決定
    • テンプレート: HTMLを生成するためのファイル、動的なデータを簡単にHTMLに組み込むことができる

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

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

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

【無料】プログラミングスクールの探し方 >

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

]]> 【Django】ビュー（views.py）：初心者向けに５ステップで解説 https://it-biz.online/python/views/ Tue, 04 Jul 2023 04:27:12 +0000 https://it-biz.online/?p=8011 Djangoにおけるビュー（views.py）は、ユーザーからのリクエストを受け取り、それに基づいたレスポンスを生成するコンポーネントです。言い換えると、ユーザーとアプリケーションの間のインターフェースの役割を果たすのがビューです。

この記事では、Djangoのビュー（views.py）について、初心者でも理解できるように詳しく解説します。

具体的には、ビューの基本的な作成方法から、より高度なリストビューやフォームビューの活用方法までを、5つのステップに分けて学んでいきます。

このページで学べる内容
  • ステップ1：ビューとは
  • ステップ2：関数ベースビューの作成
  • ステップ3：クラスベースビューの作成
  • ステップ4：汎用ビューの活用
    • リストビュー
    • ディテールビュー
    • フォームビュー
  • ステップ5：ビューのテスト方法

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

Djangoのビュー（view）とは？

Djangoにおけるビューは、ユーザーからのリクエストを受け取り、それに基づいたレスポンスを生成するコンポーネントです。つまり、ユーザーとアプリケーションの間のインターフェースの役割を果たします。

ビューはDjangoアプリケーションの中心的な部分であり、その動作を理解することは、Djangoでの開発スキルを向上させるために重要です。

ビューは基本的にPythonの関数またはクラスとして定義されます。その役割はユーザーからのHTTPリクエストを受け取り、HTTPレスポンスを返すことです。

Djangoのビュー
図1：Djangoのビュー

参考　HTTPリクエスト/HTTPレスポンスとは？

このレスポンスは通常、HTML形式のWebページですが、JSON形式のデータや、リダイレクト、404エラーなど、他の任意の形式のレスポンスも可能です。

ビューはviews.pyという名前のPythonファイルに定義されます。このファイルはDjangoアプリケーションを作成した際に自動的にディレクトリ内に保存されます。

Django view.py
図2：Django view.py

ビューの基本的な作成方法は2つ。１つは関数ベースのビュー、もう１つはクラスベースのビューです。

以下に、関数ベースのビューとクラスベースのビューの特徴と違いを表形式で整理しました。

関数ベースビュークラスベースビュー
定義方法Pythonの関数として定義Pythonのクラスとして定義
適用範囲小規模なアプリケーションや単純なビュー大規模なアプリケーションや複雑なビュー
特徴シンプルで直感的な構造再利用性と拡張性が高い
メソッドHTTPメソッド（GET, POSTなど）ごとに条件分岐が必要HTTPメソッドごとに異なるメソッド（get(), post()など）を定義できる
ミックスイン使用不可使用可能（複数のビヘイビアを組み合わせることが可能）
例def hello_world(request): return HttpResponse("Hello, World!")class HelloWorldView(TemplateView): template_name = "hello_world.html"

関数ベースのビューはそのシンプルさから理解しやすく、小規模なアプリケーションや単純なビューの作成に適しています。一方、クラスベースのビューは再利用性と拡張性が高く、大規模なアプリケーションや複雑なビューの作成に適しているのが特徴。

それぞれの作成方法について次の章で解説していきます。Djangoのビューについてさらに深掘りしていきましょう。

関数ベースビューの作成

関数ベースのビューは、Pythonの関数として定義され、１つのHTTPリクエストに対して１つのHTTPレスポンスを返します。

この関数は、リクエストを引数として受け取り、レスポンスを戻り値として返します。

早速、具体的なコードを見てみましょう。以下は、最も基本的な関数ベースのビューの例です。

from django.http import HttpResponse

def hello_world(request):
    return HttpResponse("Hello, World!")

参考　import文 / def文

このコードは、hello_worldという名前のビューを定義。このビューは、HTTPリクエストを受け取り、"Hello, World!"というテキストを含むHTTPレスポンスを返します。

関数ベースのビューは、そのシンプルさから、小規模なアプリケーションや単純なビューの作成に適しています。しかし、大規模なアプリケーションや複雑なビューを作成する場合には、クラスベースのビューを使用することが推奨されます。

先ほどのビューをDjangoアプリケーションで使用するには、URLconf（URL設定）にこのビューを追加する必要があります。

URLconfは、URLとビューをマッピングするための設定で、urls.pyという名前のPythonファイルに定義されます。以下は、先ほど定義したhello_worldビューをURLconfに追加する例です。

from django.urls import path
from .views import hello_world

urlpatterns = [
    path('hello/', hello_world),
]

例えば、あなたがローカル環境でDjangoアプリケーションを実行しているとします。通常、ローカル環境でDjangoアプリケーションを実行すると、http://127.0.0.1:8000/またはhttp://localhost:8000/というURLでアクセスできます。

このとき、hello_worldビューを/hello/というURLにマッピングした場合、http://127.0.0.1:8000/hello/またはhttp://localhost:8000/hello/というURLにアクセスすると、"Hello, World!"というテキストが表示されます。

クラスベースビューの作成

関数ベースのビューがシンプルで直感的な一方で、クラスベースのビューはその再利用性と拡張性から、より大規模なアプリケーションや複雑なビューの作成に適しています。

クラスベースのビューはPythonのクラスとして定義され、Djangoが提供するビューの親クラスを継承して作成します。

早速、こちらも具体的なコードを見てみましょう。以下は、最も基本的なクラスベースのビューの例です。

from django.views.generic import TemplateView

class HelloWorldView(TemplateView):
    template_name = "hello_world.html"

参考　class文 / 変数の基本

このコードは、HelloWorldViewという名前のビューを定義。このビューは、TemplateViewというDjangoが提供するビューの親クラスを継承しており、hello_world.htmlというテンプレートを使用してHTTPレスポンスを生成します。

このビューをDjangoアプリケーションで使用するには、関数ベースのビューと同様に、URLconfにこのビューを追加する必要があります。

ただし、クラスベースのビューをURLconfに追加するときには、ビューのクラス名にas_view()メソッドを追加する必要があります。以下は、先ほど定義したHelloWorldViewビューをURLconfに追加する例です。

from django.urls import path
from .views import HelloWorldView

urlpatterns = [
    path('hello/', HelloWorldView.as_view()),
]

このコードは、/hello/というURLがリクエストされたときに、HelloWorldViewビューが呼び出されるように設定しています。つまり、ユーザーがhttp://127.0.0.1:8000/hello/またはhttp://localhost:8000/hello/というURLにアクセスすると、hello_world.htmlというテンプレートが表示されます。

関数ベースビュークラスベースビュー
定義方法Pythonの関数として定義Pythonのクラスとして定義
適用範囲小規模なアプリケーションや単純なビュー大規模なアプリケーションや複雑なビュー
特徴シンプルで直感的な構造再利用性と拡張性が高い
メソッドHTTPメソッド（GET, POSTなど）ごとに条件分岐が必要HTTPメソッドごとに異なるメソッド（get(), post()など）を定義できる
ミックスイン使用不可使用可能（複数のビヘイビアを組み合わせることが可能）
例def hello_world(request): return HttpResponse("Hello, World!")class HelloWorldView(TemplateView): template_name = "hello_world.html"

以上が、クラスベースのビューの基本的な作成方法とその使用方法です。次の章では、クラスベースのビューをさらに拡張する方法について解説します。

クラスベースビューの拡張（汎用ビューの活用）

クラスベースのビューは、その再利用性と拡張性から、より大規模なアプリケーションや複雑なビューの作成に適しています。

Djangoの汎用ビュー（Generic Views）は、一般的なWeb開発タスクを簡単に行うための、多くの組み込みビューを提供しています。これらのビューは、クラスベースのビューを拡張して作成されています。汎用ビューを使用すると、特定のタスクを実行するためのコードを大幅に減らすことができます。

たとえば、Djangoには、データベースからオブジェクトを取得して表示するためのListView、新しいオブジェクトを作成するためのCreateView、既存のオブジェクトを更新するためのUpdateView、オブジェクトを削除するためのDeleteViewなど、多くの汎用ビューがあります。

Django：ListView

ListViewは、あるモデルのオブジェクトのリストを表示するためのビューです。デフォルトでは、これは全てのオブジェクトを取得しますが、get_querysetメソッドをオーバーライドすることでカスタマイズできます。

from django.views.generic import ListView
from .models import Book

class BookListView(ListView):
    model = Book
    template_name = 'books/book_list.html'  # <app>/<model>_<viewtype>.html

このビューは、Bookモデルの全インスタンスをリストで表示するビューです。template_nameで指定されたテンプレートを用いて表示します。ここでは books/book_list.html と指定しています。

参考　Djangoのモデル

Django：DetailView

DetailViewは、単一のオブジェクトの詳細を表示するためのビューです。

from django.views.generic import DetailView
from .models import Book

class BookDetailView(DetailView):
    model = Book
    template_name = 'books/book_detail.html'  # <app>/<model>_<viewtype>.html

このビューは、Bookモデルの単一のインスタンス（＝レコード）の詳細を表示するビューです。具体的なインスタンスはURLから取得されます（一般的にはプライマリキー）。

Django：CreateView

CreateViewは、新たなオブジェクトを作成するためのビューです。

from django.views.generic.edit import CreateView
from .models import Book

class BookCreateView(CreateView):
    model = Book
    fields = ['name', 'author', 'price']  # ここにモデルのフィールドを記述
    template_name = 'books/book_form.html'  # <app>/<model>_<viewtype>.html

このビューは、新しいBookインスタンスを作成するためのフォームを表示し、そのフォームの送信を処理するビューです。ここでfieldsはフォームに表示するフィールドを指定します。

Django：UpdateView

UpdateViewは、既存のオブジェクトを更新するためのビューです。

from django.views.generic.edit import UpdateView
from .models import Book

class BookUpdateView(UpdateView):
    model = Book
    fields = ['name', 'author', 'price']
    template_name = 'books/book_form.html'  # <app>/<model>_<viewtype>.html

このビューは、既存のBookインスタンスを更新するためのフォームを表示し、そのフォームの送信を処理します。編集するインスタンスはURLから取得されます。

Django：DeleteView

DeleteViewは、既存のオブジェクトを削除するためのビューです。

from django.views.generic.edit import DeleteView
from .models import Book

class BookDeleteView(DeleteView):
    model = Book
    template_name = 'books/book_confirm_delete.html'  # <app>/<model>_<viewtype>.html
    success_url = '/'  # 削除後にリダイレクトするURL

このビューは、既存のBookインスタンスを削除するための確認ページを表示し、その削除を処理します。削除するインスタンスはURLから取得されます。削除が成功した後はsuccess_urlで指定したURLにリダイレクトされます。

以上が、Djangoの汎用ビューの基本的な活用方法とその使用方法です。このように、汎用ビューを使用すると、一般的なWeb開発タスクを簡単に行うことができます。

ビューのテスト

最後に、作成したビューを簡単にテストする方法をご紹介します。

Djangoビューのテストは、アプリケーションの品質を確保するために重要なステップです。テストを行うことで、ビューが期待通りに動作することを確認し、エラーやバグを早期に発見することが可能に。

Djangoはビューのテストを支援するための強力なツールを提供しており、それはdjango.testモジュールのTestCaseクラスという形で用意されています。

我々はこのクラスをうまく使用することで、簡単にビューのテストを行うことができます。

以下に、ビューのテストの基本的な手順を示します。

ステップ1：テストケースの作成

まず、django.test.TestCaseを継承したクラスを作成します。このクラス内にテストメソッドを定義します。

from django.test import TestCase

class MyViewTest(TestCase):
    ...

ステップ2：テストメソッドの定義

次に、テストケースクラス内にテストメソッドを定義します。テストメソッドの名前はtest_で始まる必要があります。

def test_my_view(self):
    ...

ステップ3：ビューのテスト

最後に、TestCaseクラスのclient属性を使用して、ビューにリクエストを送信し、レスポンスを検証します。

response = self.client.get('/my-view-url/')
self.assertEqual(response.status_code, 200)

このコードは、/my-view-url/にGETリクエストを送信し、レスポンスのステータスコードが200（成功）であることを確認しています。

以上が、Djangoのビューのテストの基本的な手順です。このように、Djangoのテストフレームワークを使用すると、ビューのテストを簡単に行うことができます。

Django：ビュー（views.py）のまとめ

  1. ビューの基本: Djangoのビューは、ユーザーからのリクエストを受け取り、レスポンスを生成する役割を果たします。ビューは関数またはクラスとして定義されます。
  2. 関数ベースビュー: 関数ベースビューは、シンプルで直感的なビューの作成方法です。一つの関数が一つのビューを表します。
  3. クラスベースビュー: クラスベースビューは、より複雑なビューの作成やコードの再利用を可能にします。ビューの振る舞いをカスタマイズするために、クラスの継承やミックスインを利用できます。
  4. 汎用ビュー: Djangoは、一般的なウェブ開発タスクを簡単に行うための汎用ビューを提供しています。これらは、リストビュー、ディティールビュー、フォームビューなど、特定の用途に最適化されたクラスベースビューです。
  5. ビューのテスト: Djangoのテストフレームワークを使用して、ビューの動作を確認するテストを作成できます。これにより、コードの品質を保証し、バグを早期に発見できます。

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

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

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

【無料】プログラミングスクールの探し方 >

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

]]> 【Python】for文の使い方とコツを３分でわかりやすく解説 https://it-biz.online/python/for-range/ Tue, 01 Sep 2020 00:00:00 +0000 https://it-biz.online/?p=3759 Pythonのfor文は、指定された操作をリストや文字列などのデータの各要素に対して繰り返し実行するための構文です。

参考　Pythonとは？（特徴とできること）

for文をうまく利用することで、一連の同じ操作を効率よく行うことができます。

numbers = [1, 2, 3, 4, 5]  # 数字のリストを作成

for num in numbers:  # リストnumbersの各要素に対して以下の処理を行う
    print(num)  # numを表示

# 実行結果：
# 1
# 2
# 3
# 4
# 5

このページではPython初心者の方向けに、for文の使い方を１からわかりやすくサンプルコード付きで解説します。

このページで学べる内容
  • 【前提】繰り返し処理とは？
  • for文の使い方
  • for文を利用する際の注意点

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

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

前提：繰り返し処理とは？

「繰り返し実行」とは、特定のプログラムのコードブロック（つまり、命令の集まり）を何度も実行することを指します。この概念はプログラミングの基本的な要素の1つで、特定のタスクを指定した回数だけ、または特定の条件が満たされるまで実行するために使用されます。

繰り返し実行は主に2つの形式で現れます：「カウント制御ループ」と「条件制御ループ」です。

カウント制御ループ（for文で実現）

カウント制御ループは「指定された回数だけ何かを行う」というタスクに対応します。

例えば、「5回"こんにちは"と言ってください」と言われた場合、それを実行するには、"こんにちは"と言う行為を5回繰り返す必要があります。

Pythonのfor文を使ったプログラムでは、以下のように表現します。

for i in range(5):
    print("こんにちは")

# 実行結果：
# こんにちは
# こんにちは
# こんにちは
# こんにちは
# こんにちは

参考　print関数の使い方

このコードでは、"こんにちは"という文字列を5回表示します。range(5)は0から4までの数値を生成するので、for文はこの5回分の数字（つまり5回）を使ってループ（繰り返し）を作ります。

for文の使い方については後ほど詳しく解説します。

条件制御ループ（while文で実現）

条件制御ループは、特定の条件が満たされるまで何かを行うというタスクに対応します。

例えば、「お腹が空くまでリンゴを食べ続けてください」と言われた場合、お腹が空くという条件が満たされるまでリンゴを食べ続ける必要があります。

Pythonのwhile文を使ったプログラムでは、以下のように表現します。

stomach = 0  # お腹の状態を0とする（0は空腹を、10は満腹を表すとします）

while stomach < 10:  # お腹がまだ満腹でない場合
    print("リンゴを食べる")
    stomach += 1  # リンゴを1個食べるとお腹の状態を1だけ増やす

参考　while文の使い方 / 代入演算子（+=）

このコードでは、お腹が満腹になるまで（つまりstomachが10になるまで）"リンゴを食べる"と表示し続けます。

これらのループは、特定のタスクを指定した回数だけ実行するか、特定の条件が満たされるまで続けるかといった繰り返しの操作をコード化するための非常に重要なツールです。

前提をしっかり押さえたところで、カウント制御ループであるfor文の使い方について詳しく見ていきましょう。

Python：for文

Pythonのfor文は、指定された操作をリストや文字列などのデータの各要素に対して繰り返し実行するための構文です。

構文ルールは以下の通り。

for 変数 in シーケンス:
    # シーケンスの各要素（変数）を使った処理

ここで「シーケンス」はリストや文字列などの反復可能なデータを指し、「変数」はそのシーケンスの各要素を一つずつ受け取るためのものです。

参考　リストとは？ / 変数とは？

文字だけでは分からない部分もあると思うので、早速サンプルコードを見ていきましょう。

numbers = [1, 2, 3, 4, 5]  # 数字のリストを作成

for num in numbers:  # リストnumbersの各要素に対して以下の処理を行う
    print(num)  # numを表示

# 実行結果：
# 1
# 2
# 3
# 4
# 5

このプログラムは1から5までの各数字を順番に表示します。リストnumbersの各要素が一つずつnumに代入され、そのnumを使ってprint(num)という処理が行われます。結果、1~5の数字が出力されるという仕組み。

わかりやすく言うと「for文は指定したオブジェクトから要素を順番に取得し、その要素の数だけ処理を繰り返す」処理を行うということ。

リストだけでなく、他の集合・辞書・タプル、さらには文字列に対してもfor文を利用することが可能です。

サンプル　文字列に対するforループ

文字列は文字のシーケンスとみなすことができます。したがって、forループを使って文字列の各文字を順に処理することができます。

word = "Hello, World!"

for letter in word:
    print(letter)
# 実行結果：
# H
# e
# l
# l
# o
# ,
#  
# W
# o
# r
# l
# d
# !

サンプル　辞書に対するforループ

辞書はキーと値のペアの集合です。forループを使うと、辞書のキーまたは値、または両方に対して処理を行うことができます。

my_dict = {"apple": "red", "banana": "yellow", "grape": "purple"}

for key in my_dict:
    print(key)

# 実行結果：
# apple
# banana
# grape

for value in my_dict.values():
    print(value)

# 実行結果：
# red
# yellow
# purple

for key, value in my_dict.items():
    print(f"The {key} is {value}")

# 実行結果：
# The apple is red
# The banana is yellow
# The grape is purple

サンプル　タプルに対するforループ

タプルもリストと同じように要素のシーケンスですが、タプルの要素は変更できません。タプルに対するforループの使い方はリストと同じです。

my_tuple = ("apple", "banana", "grape")

for item in my_tuple:
    print(item)

# 実行結果：
# apple
# banana
# grape

サンプル　セットに対するforループ

セット（集合）は重複する要素を含まないアイテムの集合です。セットに対するforループの使い方もリストやタプルと同じです。

my_set = {"apple", "banana", "grape", "apple"}

for item in my_set:
    print(item)
# 実行結果（セットの順序は保証されない）：
# apple
# banana
# grape

以上のように、forループはPythonの様々なデータ構造に対して利用することができ、それぞれの要素に対して同じ操作を繰り返すために非常に便利です。

リストやタプルといった基本知識に不安がある方はこの機会に以下のページで復習しておきましょう！

【Python】データ構造（リスト・タプル・辞書・集合）の基本を３分でわかりやすく解説
【初心者向け】Pythonの４つのデータ構造を初心者向けに整理しています。リスト・タプル・辞書・集合のデータ構造の違いを説明できるでしょうか？このページでは、実際のPythonのサンプルコードを用いてそれぞれの違いを丁寧に解説しています。
it-biz.online
2023.06.28

Python：for文の注意点

for文は使いこなせると便利な構文でもありますが、いくつか注意点も存在します。

最後に、for文を利用する際の注意点についてご説明します。

Python：for文　注意点①：繰り返し処理中のシーケンスの変更

forループ中にシーケンス（リストやタプル、文字列など）を変更すると、結果が予測しきれなくなる可能性があります。これはループが要素をどの順番で処理するかが変わってしまうためです。

繰り返し処理の中でシーケンスを変更する必要がある場合は、通常、シーケンスのコピーを作ってからループを行います。

# NGな例 - 繰り返し処理中にシーケンスを変更する
numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num == 3:
        numbers.remove(num)
print(numbers)  # 結果は予期しないものになるかもしれません

# OKな例 - 繰り返し処理のためにシーケンスのコピーを作成する
numbers = [1, 2, 3, 4, 5]
for num in numbers.copy():
    if num == 3:
        numbers.remove(num)
print(numbers)  # 予期した結果が得られます

Python：for文　注意点②：変数のスコープ

forループ内で宣言された変数は、ループの外でも使用することが可能。しかし、一般的にはループの外でループ内部の変数を使用するのは避けた方が良いです。

ループ内部で生成された変数の値はループが終了した時点での最後の値となるため、プログラムが複雑になると予期しない結果を生じる可能性があります。

for i in range(5):
    temp = i * 2
print(temp)  # この時点でtempは最後のループの値、つまり8になる

Python：for文　注意点③：breakとcontinueの使用

breakはループを完全に終了させ、continueは現在のループをスキップして次のループに進むための命令です。

参考　breakとcontinueの違い

これらは制御フローをより細かく制御するのに便利ですが、使いすぎるとプログラムが複雑になり、読みにくくなる可能性があるため、注意して使用する必要があります。

for i in range(5):
    if i == 2:
        continue  # iが2のときのみ処理をスキップ
    print(i)
# 実行結果：
# 0
# 1
# 3
# 4

Python：for文　注意点④：無限ループの回避

理論的にはforループでは無限ループは発生しませんが、例えばリスト内包表記でリストを生成しながらそのリストをループするような場合などは注意が必要です。

無限ループが発生するとプログラムは止まらず、コンピュータのリソースを過剰に消費する可能性があります。

これらを意識しながらforループを使用すると、より効果的かつ安全にコードを書くことができます。

Python：for文のまとめ

Python：for文のまとめ
  • 基本：Pythonのfor文は、指定したシーケンス（リスト、タプル、文字列など）やイテラブル（反復可能なオブジェクト）の各要素に対して繰り返し処理を行うために使用されます。
  • 構文ルール：
    1. for <変数> in <シーケンス>:
    2. forの後には変数名が来ます。この変数には、シーケンスの各要素が一つずつ代入されます。
    3. inの後には繰り返し処理を行いたいシーケンスやイテラブルを指定します。
    4. :の後には繰り返し実行したいコードブロック（インデントされた部分）を記述します。
  • 注意点：
    • forループ中にシーケンスを変更しない。必要な場合はシーケンスのコピーを作ってからループを行う。
    • ループ内で宣言された変数はループの外でも使用できるが、基本的にはループの外で使わない。
    • breakやcontinueは制御フローを細かく制御するのに便利だが、使いすぎるとコードが読みにくくなるので注意する。
    • 無限ループを避ける。例えば、リスト内包表記でリストを生成しながらそのリストをループするといった場合には特に注意が必要。
# 最初の2つの数
num1, num2 = 0, 1
# 数列を表示するためのリスト
fibonacci_sequence = [num1, num2]

# 次の8つの数を生成
for _ in range(8):
    num1, num2 = num2, num1 + num2
    fibonacci_sequence.append(num2)

# 数列を表示
for number in fibonacci_sequence:
    print(number)

このコードを実行すると、最初の10個のFibonacci数（0, 1, 1, 2, 3, 5, 8, 13, 21, 34）が表示されます。

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

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

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

【無料】プログラミングスクールの探し方 >

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

]]>