Django-基本

Djangoは、迅速な開発とクリーンで実用的な設計を促進する高レベルのPython Webフレームワークです。 Djangoを使用すると、より優れたWebアプリをより少ないコードですばやく簡単に構築できます。

注-DjangoはDjango Software Foundationの登録商標であり、BSDライセンスの下でライセンスされています。

ジャンゴの歴史

2003 -ローレンス・ジャーナル・ワールド新聞の内部プロジェクトとしてエイドリアン・ホロバティとサイモン・ウィリソンによって開始されました。
2005 -2005年7月にリリースされ、ジャズギタリストのDjango ReinhardtにちなんでDjangoと名付けられました。
2005 -いくつかのトラフィックの多いサイトを処理するのに十分な成熟度。
現在-Djangoは現在、世界中に貢献者がいるオープンソースプロジェクトです。

ジャンゴ–デザイン哲学

Djangoには次の設計哲学があります-

疎結合-Djangoは、スタックの各要素を他の要素から独立させることを目指しています。
少ないコーディング-コードが少ないため、開発が迅速になります。
* Do n’t Repeat Yourself（DRY）*-すべてを何度も繰り返すのではなく、正確に1か所で開発する必要があります。
高速開発-Djangoの哲学は、超高速開発を促進するためにできる限りのことを行うことです。
クリーンデザイン-Djangoは、独自のコード全体でクリーンデザインを厳密に維持し、Web開発のベストプラクティスに従うことを容易にします。

Djangoの利点

ここにリストできるDjangoを使用するいくつかの利点があります-

オブジェクトリレーショナルマッピング（ORM）サポート-Djangoは、データモデルとデータベースエンジン間のブリッジを提供し、MySQL、Oracle、Postgresなどを含むデータベースシステムの大規模なセットをサポートします。 Djangoは、Django-nonrelフォークを介してNoSQLデータベースもサポートします。現時点では、サポートされているNoSQLデータベースはMongoDBとGoogle App Engineのみです。
多言語サポート-Djangoは、組み込みの国際化システムを通じて多言語Webサイトをサポートしています。したがって、複数の言語をサポートするWebサイトを開発できます。
フレームワークのサポート-Djangoには、Ajax、RSS、キャッシング、およびその他のさまざまなフレームワークのサポートが組み込まれています。
*管理GUI *-Djangoは、管理アクティビティ用にすぐに使用できる優れたユーザーインターフェイスを提供します。
開発環境-Djangoには、エンドツーエンドのアプリケーション開発とテストを容易にする軽量のWebサーバーが付属しています。

Django-概要

既にご存じのとおり、DjangoはPython Webフレームワークです。また、ほとんどの最新のフレームワークと同様に、DjangoはMVCパターンをサポートしています。まず、Model-View-Controller（MVC）パターンとは何かを見てみましょう。次に、Model-View-Template（MVT）パターンに対するDjangoの特異性を見てみましょう。

MVCパターン

UI（Webまたはデスクトップ）を提供するアプリケーションについて話すとき、通常はMVCアーキテクチャについて話します。また、その名前が示すように、MVCパターンは3つのコンポーネント（モデル、ビュー、コントローラー）に基づいています。詳細については、http：//www.finddevguides.com/struts_2/basic_mvc_architecture [こちらのMVCチュートリアルを確認]をご覧ください。

DJANGO MVC-MVTパターン

Model-View-Template（MVT）は、MVCとは少し異なります。実際、2つのパターンの主な違いは、Django自体がコントローラー部分（モデルとビュー間の相互作用を制御するソフトウェアコード）を処理し、テンプレートを残すことです。テンプレートは、Django Template Language（DTL）と混合したHTMLファイルです。

次の図は、MVTパターンの各コンポーネントがユーザーリクエストを処理するために相互作用する方法を示しています-

DJANGO MVC-MVTパターン

開発者はモデル、ビュー、テンプレートを提供し、それをURLにマッピングするだけで、Djangoはそれをユーザーに提供するための魔法をかけます。

Django-環境

Django開発環境は、Python、Django、およびデータベースシステムのインストールとセットアップで構成されています。 DjangoはWebアプリケーションを扱っているため、Webサーバーのセットアップも必要になることに注意してください。

ステップ1 – Pythonのインストール

Djangoは100％純粋なPythonコードで記述されているため、システムにPythonをインストールする必要があります。最新のDjangoバージョンにはPython 2.6.5以降が必要です

最新のLinuxまたはMac OS Xディストリビューションのいずれかを使用している場合は、おそらく既にPythonがインストールされています。コマンドプロンプトで_python_コマンドを入力して確認できます。このようなものが表示される場合、Pythonがインストールされています。

$ python
Python 2.7.5 (default, Jun 17 2014, 18:11:42)
[GCC 4.8.2 20140120 (Red Hat 4.8.2-16)] on linux2

それ以外の場合は、リンクhttps://www.python.org/downloads/[http://www.python.org/download]からPythonの最新バージョンをダウンロードしてインストールできます。

ステップ2-Djangoのインストール

Djangoのインストールは非常に簡単ですが、そのインストールに必要な手順はオペレーティングシステムによって異なります。 Pythonはプラットフォームに依存しない言語であるため、Djangoには、オペレーティングシステムに関係なくどこでも動作する1つのパッケージがあります。

Djangoの最新バージョンは、リンクhttps://www.djangoproject.com/download/[http://www.djangoproject.com/download]からダウンロードできます。

UNIX/LinuxおよびMac OS Xのインストール

LinuxまたはMac OSシステムを実行している場合、Djangoをインストールする方法は2つあります-

OSのパッケージマネージャーを使用するか、easy_installまたはpipがインストールされている場合はそれを使用できます。
以前にダウンロードした公式アーカイブを使用して手動でインストールします。

最初のオプションはOSディストリビューションに依存するため、2番目のオプションについて説明します。最初のオプションに従うことにした場合は、インストールするDjangoのバージョンに注意してください。

上記のリンクからアーカイブを取得したとします。これはDjango-x.xx.tar.gzのようなものです。

抽出してインストールします。

$ tar xzvf Django-x.xx.tar.gz
$ cd Django-x.xx
$ sudo python setup.py install

このコマンドを実行してインストールをテストできます-

$ django-admin.py --version

Djangoの現在のバージョンが画面に表示されている場合、すべてが設定されています。

注-Djangoの一部のバージョンでは、django-adminになり、「。py」が削除されます。

Windowsインストール

Djangoアーカイブとpythonがコンピューターにインストールされていると仮定します。

まず、パスの検証。

一部のバージョンのウィンドウ（windows 7）では、Pathシステム変数のパスが次の `+ C：\ Python34 \; C：\ Python34 \ Lib \ site-packages \ django \ bin \ +`である必要があります。もちろん、Pythonのバージョンによって異なります。

次に、Djangoを抽出してインストールします。

c:\>cd c:\Django-x.xx

次に、Windowsシェル「cmd」で管理者権限が必要な次のコマンドを実行してDjangoをインストールします-

c:\Django-x.xx>python setup.py install

インストールをテストするには、コマンドプロンプトを開き、次のコマンドを入力します-

c:\>python -c "import django; print(django.get_version())"

Djangoの現在のバージョンが画面に印刷されている場合、すべてが設定されています。

OR

「cmd」プロンプトを起動し、pythonと入力してから-

c:\> python
>>> import django
>>> django.VERSION

ステップ3 –データベースのセットアップ

Djangoはいくつかの主要なデータベースエンジンをサポートしており、快適性に基づいて任意のデータベースエンジンをセットアップできます。

選択したデータベースのインストールおよび構成については、それぞれのドキュメントを参照できます。

注-番号5および6はNoSQLデータベースです。

ステップ4 – Webサーバー

Djangoには、アプリケーションの開発とテスト用の軽量Webサーバーが付属しています。このサーバーはDjangoで動作するように事前に構成されており、さらに重要なのは、コードを変更するたびに再起動することです。

ただし、DjangoはApacheおよびLighttpdなどの他の一般的なWebサーバーをサポートしています。さまざまな例を使用しながら、次の章で両方のアプローチについて説明します。

Django-プロジェクトの作成

Djangoをインストールしたので、使用を開始しましょう。 Djangoでは、作成するすべてのWebアプリをプロジェクトと呼びます。プロジェクトはアプリケーションの合計です。アプリケーションは、MVTパターンに依存する一連のコードファイルです。例として、ウェブサイトを構築したいとしましょう。ウェブサイトは私たちのプロジェクトであり、フォーラム、ニュース、連絡先エンジンはアプリケーションです。この構造により、すべてのアプリケーションが独立しているため、プロジェクト間でアプリケーションを簡単に移動できます。

プロジェクトを作成する

あなたがWindowsまたはLinuxのどちらにいても、単にターミナルまたは cmd プロンプトを取得し、プロジェクトを作成したい場所に移動してから、このコードを使用します-

$ django-admin startproject myproject

これにより、次の構造を持つ「myproject」フォルダが作成されます-

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

プロジェクト構造

「myproject」フォルダは単なるプロジェクトコンテナであり、実際には2つの要素が含まれています-

manage.py -このファイルは、プロジェクトのローカルdjango-adminの一種で、コマンドライン（開発サーバーの起動、dbの同期…）を介してプロジェクトとやり取りします。 manage.pyを介してアクセス可能なコマンドの完全なリストを取得するには、コードを使用できます-

$ python manage.py help

「myproject」サブフォルダー-このフォルダーは、プロジェクトの実際のpythonパッケージです。それは4つのファイルが含まれています-
init。py -Pythonの場合のみ、このフォルダーをパッケージとして扱います。
settings.py -名前が示すように、プロジェクトの設定。
urls.py -プロジェクトのすべてのリンクと呼び出す関数。プロジェクトの一種の目次。
wsgi.py -プロジェクトをWSGI経由でデプロイする必要がある場合。

プロジェクトのセットアップ

プロジェクトは、サブフォルダーmyproject/settings.pyでセットアップされます。以下はあなたが設定する必要があるかもしれないいくつかの重要なオプションです-

DEBUG = True

このオプションを使用すると、プロジェクトがデバッグモードであるかどうかを設定できます。デバッグモードでは、プロジェクトのエラーに関する詳細情報を取得できます。ライブプロジェクトでは「True」に設定しないでください。ただし、Django Lightサーバーで静的ファイルを提供する場合は、これを「True」に設定する必要があります。開発モードでのみ実行してください。

DATABASES = {
   'default': {
      'ENGINE': 'django.db.backends.sqlite3',
      'NAME': 'database.sql',
      'USER': '',
      'PASSWORD': '',
      'HOST': '',
      'PORT': '',
   }
}

データベースは「データベース」辞書に設定されています。上記の例はSQLiteエンジン用です。前に述べたように、Djangoもサポートしています-

MySQL（django.db.backends.mysql）
PostGreSQL（django.db.backends.postgresql_psycopg2）
Oracle（django.db.backends.oracle）およびNoSQL DB
MongoDB（django_mongodb_engine）

新しいエンジンを設定する前に、正しいdbドライバーがインストールされていることを確認してください。

TIME_ZONE、LANGUAGE_CODE、TEMPLATEなどのオプションを設定することもできます…

プロジェクトが作成および構成されたので、それが機能していることを確認してください-

$ python manage.py runserver

上記のコードを実行すると、次のようなものが表示されます-

Validating models...

0 errors found
September 03, 2015 - 11:41:50
Django version 1.6.11, using settings 'myproject.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Django-アプリのライフサイクル

プロジェクトは多くのアプリケーションの合計です。すべてのアプリケーションには目的があり、別のプロジェクトに再利用できます。たとえば、Webサイトの連絡先フォームはアプリケーションであり、他のユーザーに再利用できます。それをプロジェクトのモジュールとして見てください。

アプリケーションを作成する

プロジェクトフォルダーにいると仮定します。メインの「myproject」フォルダーで、同じフォルダーにmanage.py-

$ python manage.py startapp myapp

あなたはmyappアプリケーションを作成し、プロジェクトのように、Djangoはアプリケーション構造を持つ「myapp」フォルダを作成します-

myapp/
   __init__.py
   admin.py
   models.py
   tests.py
   views.py

init。py -pythonがこのフォルダーをパッケージとして処理することを確認するためです。
admin.py -このファイルは、管理インターフェイスでアプリを変更可能にするのに役立ちます。
models.py -これは、すべてのアプリケーションモデルが格納される場所です。
tests.py -ユニットテストがある場所です。
views.py -アプリケーションビューがある場所です。

あなたのアプリケーションをプロジェクトに知ってもらう

この段階で、「myapp」アプリケーションが作成されました。次に、Djangoプロジェクト「myproject」に登録する必要があります。これを行うには、プロジェクトのsettings.pyファイルでINSTALLED_APPSタプルを更新します（アプリ名を追加します）-

INSTALLED_APPS = (
   'django.contrib.admin',
   'django.contrib.auth',
   'django.contrib.contenttypes',
   'django.contrib.sessions',
   'django.contrib.messages',
   'django.contrib.staticfiles',
   'myapp',
)

Django-管理インターフェース

Djangoは、管理アクティビティ用にすぐに使用できるユーザーインターフェイスを提供します。 Webプロジェクトで管理インターフェイスがどのように重要かを知っています。 Djangoは、プロジェクトモデルに基づいて管理UIを自動的に生成します。

管理インターフェイスの開始

管理インターフェースはdjango.countribモジュールに依存しています。動作させるには、いくつかのモジュールがmyproject/settings.pyファイルのINSTALLED_APPSおよびMIDDLEWARE_CLASSESタプルにインポートされていることを確認する必要があります。

INSTALLED_APPSについては、次のことを確認してください-

INSTALLED_APPS = (
   'django.contrib.admin',
   'django.contrib.auth',
   'django.contrib.contenttypes',
   'django.contrib.sessions',
   'django.contrib.messages',
   'django.contrib.staticfiles',
   'myapp',
)

MIDDLEWARE_CLASSESの場合-

MIDDLEWARE_CLASSES = (
   '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',
)

サーバーを起動する前に、管理インターフェイスにアクセスするには、データベースを開始する必要があります-

$ python manage.py migrate

syncdbは、dbタイプに応じて、管理インターフェースを実行するために必要なテーブルまたはコレクションを作成します。スーパーユーザーがいない場合でも、スーパーユーザーを作成するように求められます。

あなたがすでにスーパーユーザーを持っているか、それを忘れている場合は、次のコードを使用していつでも作成できます-

$ python manage.py createsuperuser

ここで、管理インターフェイスを開始するには、管理インターフェイスのURLが構成されていることを確認する必要があります。 myproject/url.pyを開くと、次のようなものがあるはずです-

from django.conf.urls import patterns, include, url

from django.contrib import admin
admin.autodiscover()

urlpatterns = patterns('',
   # Examples:
   # url(r'^$', 'myproject.views.home', name = 'home'),
   # url(r'^blog/', include('blog.urls')),

   url(r'^admin/', include(admin.site.urls)),
)

サーバーを実行するだけです。

$ python manage.py runserver

また、管理インターフェイスにはhttp://127.0.0.1:8000/admin/からアクセスできます

管理インターフェイス

スーパーユーザーアカウントに接続すると、次の画面が表示されます-

スーパーユーザーアカウント

このインターフェイスを使用すると、Djangoのグループとユーザー、およびアプリに登録されているすべてのモデルを管理できます。このインターフェイスを使用すると、モデルに対して少なくとも「CRUD」（作成、読み取り、更新、削除）操作を実行できます。

Django-ビューを作成する

ビュー関数（略して「ビュー」）は、Web要求を受け取ってWeb応答を返すPython関数です。この応答には、WebページのHTMLコンテンツ、リダイレクト、404エラー、XMLドキュメント、画像などがあります。例：ビューを使用してWebページを作成しますが、ビューをURLに関連付けてWebページとして表示する必要があることに注意してください。

Djangoでは、ビューをアプリのviews.pyファイルで作成する必要があります。

シンプルビュー

myappに「私のアプリにようこそ！」と言うシンプルなビューを作成します。

次のビューを参照してください-

from django.http import HttpResponse

def hello(request):
   text = """<h1>welcome to my app !</h1>"""
   return HttpResponse(text)

このビューでは、HttpResponseを使用してHTMLをレンダリングします（おそらく、ビューにHTMLがハードコーディングされていることに気づいているでしょう）。このビューをページとして表示するには、URLにマップするだけです（これについては、次の章で説明します）。

以前にビューでHTMLをレンダリングするためにHttpResponseを使用しました。これはページをレンダリングする最良の方法ではありません。 DjangoはMVTパターンをサポートしているので、先例のビューを作成するために、Django-MVTのような、我々は必要になります-

テンプレート：myapp/templates/hellol

そして今、私たちの見解は次のようになります-

from django.shortcuts import render

def hello(request):
   return render(request, "myapp/template/hellol", {})

ビューもパラメータを受け入れることができます-

from django.http import HttpResponse

def hello(request, number):
   text = "<h1>welcome to my app number %s!</h1>"% number
   return HttpResponse(text)

URLにリンクすると、ページにはパラメーターとして渡された番号が表示されます。パラメータはURLを介して渡されることに注意してください（次の章で説明します）。

Django-URLマッピング

これで、前の章で説明した作業ビューができました。 URLを介してそのビューにアクセスする必要があります。 DjangoにはURLマッピングのための独自の方法があり、プロジェクトのurl.pyファイル*（myproject/url.py）*を編集することによって行われます。 url.pyファイルは次のようになります-

from django.conf.urls import patterns, include, url
from django.contrib import admin
admin.autodiscover()

urlpatterns = patterns('',
   #Examples
   #url(r'^$', 'myproject.view.home', name = 'home'),
   #url(r'^blog/', include('blog.urls')),

   url(r'^admin', include(admin.site.urls)),
)

ユーザーがWebアプリのページをリクエストすると、Djangoコントローラーが引き継いでurl.pyファイルを介して対応するビューを探し、見つからない場合はHTML応答または404 not foundエラーを返します。 url.pyで最も重要なのは "urlpatterns" タプルです。 URLとビューの間のマッピングを定義する場所です。マッピングは、次のようなURLパターンのタプルです-

from django.conf.urls import patterns, include, url
from django.contrib import admin
admin.autodiscover()

urlpatterns = patterns('',
   #Examples
   #url(r'^$', 'myproject.view.home', name = 'home'),
   #url(r'^blog/', include('blog.urls')),

   url(r'^admin', include(admin.site.urls)),
   url(r'^hello/', 'myapp.views.hello', name = 'hello'),
)

マークされた行は、URL "/home"をmyapp/view.pyファイルで作成されたhelloビューにマッピングします。上記のように、マッピングは3つの要素で構成されています-

パターン-解決およびマップするURLに一致する正規表現。 python 're’モジュールで動作するすべてのものがパターンに適格です（URL経由でパラメーターを渡す場合に便利です）。
ビューへのPythonパス-モジュールをインポートするときと同じです。
名前-URLリバーシングを実行するには、上記の例で行われた名前付きURLパターンを使用する必要があります。完了したら、サーバーを起動してビューにアクセスします：http：//127.0.0.1/hello

URLを整理する

これまで、「myprojects/url.py」ファイルにURLを作成しましたが、Djangoとアプリの作成について前述したように、最良のポイントは異なるプロジェクトでアプリケーションを再利用できるようにすることでした。すべてのURLを「projecturl.py」ファイルに保存すると、問題が簡単にわかります。したがって、ベストプラクティスは、アプリケーションごとに「url.py」を作成し、それをメインプロジェクトのurl.pyファイルに含めることです（以前に管理インターフェイスの管理URLを含めました）。

URLの整理

どうですか？

私たちは、次のコードを使用してmyappでurl.pyファイルを作成する必要があります-

from django.conf.urls import patterns, include, url

urlpatterns = patterns('', url(r'^hello/', 'myapp.views.hello', name = 'hello'),)

その後、myproject/url.pyは次のように変更されます-

from django.conf.urls import patterns, include, url
from django.contrib import admin
admin.autodiscover()

urlpatterns = patterns('',
   #Examples
   #url(r'^$', 'myproject.view.home', name = 'home'),
   #url(r'^blog/', include('blog.urls')),

   url(r'^admin', include(admin.site.urls)),
   url(r'^myapp/', include('myapp.urls')),
)

myappアプリケーションのすべてのURLが含まれています。「/hello」を介してアクセスされたホームルは「/myapp/hello」になりました。これは、Webアプリにとってよりよく理解しやすい構造です。

Myproject

ここで、myapp“ morning”に別のビューがあり、myapp/url.pyにマップしたい場合、myapp/url.pyを次のように変更します。

from django.conf.urls import patterns, include, url

urlpatterns = patterns('',
   url(r'^hello/', 'myapp.views.hello', name = 'hello'),
   url(r'^morning/', 'myapp.views.morning', name = 'morning'),
)

これはリファクタリングすることができます-

from django.conf.urls import patterns, include, url

urlpatterns = patterns('myapp.views',
   url(r'^hello/', 'hello', name = 'hello'),
   url(r'^morning/', 'morning', name = 'morning'),)

ご覧のとおり、 urlpatterns タプルの最初の要素を使用しています。これは、アプリ名を変更する場合に便利です。

URLパターン

ビューへのパラメーターの送信

URLをマップする方法、それらを整理する方法、そしてビューにパラメーターを送信する方法を見てみましょう。古典的なサンプルは記事の例です（「/articles/article_id」から記事にアクセスしたい）。

パラメータの受け渡しは、URLパターンで regexp を使用してキャプチャすることにより行われます。「myapp/view.py」に次のようなビューがある場合

from django.shortcuts import render
from django.http import HttpResponse

def hello(request):
   return render(request, "hellol", {})

def viewArticle(request, articleId):
   text = "Displaying article Number : %s"%articleId
   return HttpResponse(text)

「/myapp/article/articleId」からアクセスできるようにmyapp/url.pyにマッピングしたいので、「myapp/url.py」に次のものが必要です-

from django.conf.urls import patterns, include, url

urlpatterns = patterns('myapp.views',
   url(r'^hello/', 'hello', name = 'hello'),
   url(r'^morning/', 'morning', name = 'morning'),
   url(r'^article/(\d+)/', 'viewArticle', name = 'article'),)

Djangoがurlを表示するとき：“/myapp/article/42”それはviewArticleビューにパラメーター '42’を渡し、ブラウザーで次の結果を得るはずです-

viewArticleにパラメーターを渡す

ここではパラメーターの順序が重要であることに注意してください。 1年の1か月の記事のリストが必要な場合、viewArticlesビューを追加しましょう。 view.pyは次のようになります-

from django.shortcuts import render
from django.http import HttpResponse

def hello(request):
   return render(request, "hellol", {})

def viewArticle(request, articleId):
   text = "Displaying article Number : %s"%articleId
   return HttpResponse(text)

def viewArticle(request, month, year):
   text = "Displaying articles of : %s/%s"%(year, month)
   return HttpResponse(text)

対応する url.py ファイルは次のようになります-

from django.conf.urls import patterns, include, url

urlpatterns = patterns('myapp.views',
   url(r'^hello/', 'hello', name = 'hello'),
   url(r'^morning/', 'morning', name = 'morning'),
   url(r'^article/(\d+)/', 'viewArticle', name = 'article'),
   url(r'^articles/(\d{2})/(\d{4})', 'viewArticles', name = 'articles'),)

「/myapp/articles/12/2006/」に移動すると、「Displaying article of：2006/12」が表示されますが、パラメータを逆にすると同じ結果は得られません。

記事の表示

これを回避するために、URLパラメーターをビューパラメーターにリンクすることができます。そのため、 url.py は次のようになります-

from django.conf.urls import patterns, include, url

urlpatterns = patterns('myapp.views',
   url(r'^hello/', 'hello', name = 'hello'),
   url(r'^morning/', 'morning', name = 'morning'),
   url(r'^article/(\d+)/', 'viewArticle', name = 'article'),
   url(r'^articles/(?P\d{2})/(?P\d{4})', 'viewArticles', name = 'articles'),)

Django-テンプレートシステム

Djangoでは、PythonとHTMLを分離できます。Pythonはビューに、HTMLはテンプレートに含まれます。 2つをリンクするために、Djangoはrender関数とDjangoテンプレート言語に依存しています。

レンダリング関数

この関数は3つのパラメータを取ります-

リクエスト-最初のリクエスト。
テンプレートへのパス-これは、プロジェクトのsettings.py変数のTEMPLATE_DIRSオプションに関連するパスです。
パラメータの辞書-テンプレートで必要なすべての変数を含む辞書。この変数を作成するか、locals（）を使用して、ビューで宣言されたすべてのローカル変数を渡すことができます。

Djangoテンプレート言語（DTL）

Djangoのテンプレートエンジンは、アプリケーションのユーザー向けレイヤーを定義するミニ言語を提供します。

変数の表示

変数は次のようになります：\ {\ {variable}}。テンプレートは、render関数の3番目のパラメーターで、ビューによって送信された変数で変数を置き換えます。今日の日付を表示するようにhellolを変更しましょう-

こんにちは

<html>

   <body>
      Hello World!!!<p>Today is {{today}}</p>
   </body>

</html>

その後、私たちの見解は変わります-

def hello(request):
   today = datetime.datetime.now().date()
   return render(request, "hellol", {"today" : today})

URL/myapp/helloにアクセスした後、次の出力を取得します-

Hello World!!!
Today is Sept. 11, 2015

お気付きかもしれませんが、変数が文字列でない場合、Djangoはstrメソッドを使用して表示します。同じ原理で、Pythonで行うのと同じようにオブジェクト属性にアクセスできます。たとえば、日付の年を表示する場合、変数は\ {\ {today.year}}になります。

フィルター

表示時に変数を変更するのに役立ちます。フィルター構造は次のようになります：\ {\ {var | filters}}。

いくつかの例-

\ {\ {string | truncatewords：80}} -このフィルタは文字列を切り捨てるため、最初の80語のみが表示されます。
\ {\ {string | lower}} -文字列を小文字に変換します。
\ {\ {string | escape | linebreaks}} -文字列の内容をエスケープし、改行をタグに変換します。

変数のデフォルトを設定することもできます。

Django-モデル

モデルは、DBのテーブルまたはコレクションを表すクラスであり、クラスのすべての属性はテーブルまたはコレクションのフィールドです。モデルはapp/models.pyで定義されます（この例ではmyapp/models.py）

モデルを作成する

以下は、例として作成されたDreamrealモデルです-

from django.db import models

class Dreamreal(models.Model):

   website = models.CharField(max_length = 50)
   mail = models.CharField(max_length = 50)
   name = models.CharField(max_length = 50)
   phonenumber = models.IntegerField()

   class Meta:
      db_table = "dreamreal"

すべてのモデルはdjango.db.models.Modelを継承しています。

このクラスには4つの属性（3つのCharFieldと1つの整数）があり、それらはテーブルフィールドになります。

db_table属性を持つMetaクラスにより、実際のテーブル名またはコレクション名を定義できます。 Djangoは、テーブルまたはコレクションに自動的にmyapp_modelNameという名前を付けます。このクラスを使用すると、テーブルの名前を好きな名前に強制できます。

django.db.modelsにはもっと多くのフィールドのタイプがあります。それらについてはhttps://docs.djangoproject.com/en/1.5/ref/models/fields/#field-typesで詳しく知ることができます

モデルを作成した後、実際のデータベースを生成するにはDjangoが必要です-

$python manage.py syncdb

データの操作（CRUD）

「crudops」ビューを作成して、モデルでCRUD操作を実行する方法を確認しましょう。 myapp/views.pyは次のようになります-

*myapp/views.py*

from myapp.models import Dreamreal
from django.http import HttpResponse

def crudops(request):
   #Creating an entry

   dreamreal = Dreamreal(
      website = "www.polo.com", mail = "[email protected]",
      name = "sorex", phonenumber = "002376970"
   )

   dreamreal.save()

   #Read ALL entries
   objects = Dreamreal.objects.all()
   res ='Printing all Dreamreal entries in the DB : <br>'

   for elt in objects:
      res &plus;= elt.name+"<br>"

   #Read a specific entry:
   sorex = Dreamreal.objects.get(name = "sorex")
   res &plus;= 'Printing One entry <br>'
   res &plus;= sorex.name

   #Delete an entry
   res &plus;= '<br> Deleting an entry <br>'
   sorex.delete()

   #Update
   dreamreal = Dreamreal(
      website = "www.polo.com", mail = "[email protected]",
      name = "sorex", phonenumber = "002376970"
   )

   dreamreal.save()
   res &plus;= 'Updating entry<br>'

   dreamreal = Dreamreal.objects.get(name = 'sorex')
   dreamreal.name = 'thierry'
   dreamreal.save()

   return HttpResponse(res)

その他のデータ操作

モデルでできる他の操作を調べてみましょう。モデルのインスタンスでCRUD操作が行われたことに注意してください。ここでは、モデルを表すクラスを直接操作します。

*myapp/views.py* に「datamanipulation」ビューを作成しましょう

from myapp.models import Dreamreal
from django.http import HttpResponse

def datamanipulation(request):
   res = ''

   #Filtering data:
   qs = Dreamreal.objects.filter(name = "paul")
   res &plus;= "Found : %s results<br>"%len(qs)

   #Ordering results
   qs = Dreamreal.objects.order_by("name")

   for elt in qs:
      res &plus;= elt.name &plus; '<br>'

   return HttpResponse(res)

モデルのリンク

Django ORMはモデルをリンクする3つの方法を提供します-

ここで最初に見るケースの1つは、1対多の関係です。上記の例でわかるように、Dreamreal社は複数のオンラインWebサイトを持つことができます。その関係の定義は、django.db.models.ForeignKeyを使用して行われます-

*myapp/models.py*

from django.db import models

class Dreamreal(models.Model):
   website = models.CharField(max_length = 50)
   mail = models.CharField(max_length = 50)
   name = models.CharField(max_length = 50)
   phonenumber = models.IntegerField()
   online = models.ForeignKey('Online', default = 1)

   class Meta:
      db_table = "dreamreal"

class Online(models.Model):
      domain = models.CharField(max_length = 30)

   class Meta:
      db_table = "online"

更新されたmyapp/models.pyでわかるように、オンラインモデルを追加し、それをDreamrealモデルにリンクしました。

manage.py shellを使用して、これらすべてがどのように機能しているかを確認しましょう-

まず、Djangoシェルでテストするための会社（Dreamrealエントリ）を作成します-

$python manage.py shell

>>> from myapp.models import Dreamreal, Online
>>> dr1 = Dreamreal()
>>> dr1.website = 'company1.com'
>>> dr1.name = 'company1'
>>> dr1.mail = 'contact@company1'
>>> dr1.phonenumber = '12345'
>>> dr1.save()
>>> dr2 = Dreamreal()
>>> dr1.website = 'company2.com'
>>> dr2.website = 'company2.com'
>>> dr2.name = 'company2'
>>> dr2.mail = 'contact@company2'
>>> dr2.phonenumber = '56789'
>>> dr2.save()

今、いくつかのホストされたドメイン-

>>> on1 = Online()
>>> on1.company = dr1
>>> on1.domain = "site1.com"
>>> on2 = Online()
>>> on2.company = dr1
>>> on2.domain = "site2.com"
>>> on3 = Online()
>>> on3.domain = "site3.com"
>>> dr2 = Dreamreal.objects.all()[2]
>>> on3.company = dr2
>>> on1.save()
>>> on2.save()
>>> on3.save()

オンラインドメインからホスティング会社（Dreamrealエントリ）の属性にアクセスするのは簡単です-

>>> on1.company.name

そして、Dreamrealの会社がホストするすべてのオンラインドメインを知りたい場合は、コードを使用します-

>>> dr1.online_set.all()

QuerySetを取得するには、前に見たすべての操作メソッド（filter、all、exclude、order_by ….）に注意してください。

フィルタリング操作のリンクされたモデル属性にアクセスすることもできます。Dreamreal名に「company」が含まれるすべてのオンラインドメインを取得するとします。

>>> Online.objects.filter(company__name__contains = 'company'

注意-この種のクエリは、SQL DBでのみサポートされています。結合が存在せず、「_」が2つある非リレーショナルDBでは機能しません。

ただし、これがモデルをリンクする唯一の方法ではなく、OneToOneFieldもあります。これは、2つのオブジェクト間の関係が一意であることを保証するリンクです。上記の例でOneToOneFieldを使用した場合、それはすべてのDreamrealエントリに対して1つのオンラインエントリのみが可能であり、他の方法では可能であることを意味します。

最後の1つは、テーブル間の（n-n）リレーションのManyToManyFieldです。これらはSQLベースのDBに関連していることに注意してください。

Django-ページのリダイレクト

Webアプリケーションでは多くの理由でページのリダイレクトが必要です。特定のアクションが発生した場合、または基本的にエラーが発生した場合に、ユーザーを別のページにリダイレクトできます。たとえば、ユーザーがWebサイトにログインすると、多くの場合、メインのホームページまたは個人のダッシュボードにリダイレクトされます。 Djangoでは、リダイレクトは「リダイレクト」メソッドを使用して行われます。

'redirect’メソッドは引数として受け取ります：文字列Aビューの名前としてリダイレクトされるURL。

これまでのところ、myapp/viewsは次のようになっています-

def hello(request):
   today = datetime.datetime.now().date()
   daysOfWeek = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
   return render(request, "hellol", {"today" : today, "days_of_week" : daysOfWeek})

def viewArticle(request, articleId):
   """ A view that display an article based on his ID"""
   text = "Displaying article Number : %s" %articleId
   return HttpResponse(text)

def viewArticles(request, year, month):
   text = "Displaying articles of : %s/%s"%(year, month)
   return HttpResponse(text)

helloビューを変更してdjangoproject.comにリダイレクトし、viewArticleを内部の '/myapp/articles’にリダイレクトしましょう。これを行うには、myapp/view.pyが-

from django.shortcuts import render, redirect
from django.http import HttpResponse
import datetime

# Create your views here.
def hello(request):
   today = datetime.datetime.now().date()
   daysOfWeek = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
   return redirect("https://www.djangoproject.com")

def viewArticle(request, articleId):
   """ A view that display an article based on his ID"""
   text = "Displaying article Number : %s" %articleId
   return redirect(viewArticles, year = "2045", month = "02")

def viewArticles(request, year, month):
   text = "Displaying articles of : %s/%s"%(year, month)
   return HttpResponse(text)

上記の例では、最初にdjango.shortcutsからリダイレクトをインポートし、Djangoの公式Webサイトにリダイレクトするには、「redirect」メソッドに完全なURLを文字列として渡し、2番目の例（viewArticleビュー）では「redirect」メソッドは、ビュー名とそのパラメーターを引数として受け取ります。

/myapp/helloにアクセスすると、次の画面が表示されます-

Djangoページリダイレクトの例1

/myapp/article/42にアクセスすると、次の画面が表示されます-

Djangoページリダイレクトの例2

permanent = Trueパラメータを追加することにより、「リダイレクト」が一時的か永続的かを指定することもできます。ユーザーには違いはありませんが、これらはウェブサイトのランキングの際に検索エンジンが考慮する詳細です。

また、URLのマッピング中にurl.pyで定義した「name」パラメータを覚えておいてください-

url(r'^articles/(?P\d{2})/(?P\d{4})/', 'viewArticles', name = 'articles'),

その名前（ここの記事）は、「リダイレクト」メソッドの引数として使用できます。それから、viewArticleのリダイレクトは次のように変更できます-

def viewArticle(request, articleId):
   """ A view that display an article based on his ID"""
   text = "Displaying article Number : %s" %articleId
   return redirect(viewArticles, year = "2045", month = "02")

宛先-

def viewArticle(request, articleId):
   """ A view that display an article based on his ID"""
   text = "Displaying article Number : %s" %articleId
   return redirect(articles, year = "2045", month = "02")

注-URLを生成する機能もあります。リダイレクトと同じ方法で使用されます。 'reverse’メソッド（django.core.urlresolvers.reverse）。この関数はHttpResponseRedirectオブジェクトを返さず、渡された引数でコンパイルされたビューへのURLを含む単純な文字列を返します。

Django-電子メールの送信

Djangoには、電子メールを送信するための簡単で使いやすいライトエンジンが付属しています。 Pythonと同様に、smtplibのインポートが必要です。 Djangoでは、django.core.mailをインポートするだけです。電子メールの送信を開始するには、プロジェクトのsettings.pyファイルを編集し、次のオプションを設定します-

EMAIL_HOST -smtpサーバー。
EMAIL_HOST_USER -smtpサーバーのログイン資格情報。
EMAIL_HOST_PASSWORD -smtpサーバーのパスワード認証情報。
EMAIL_PORT -smtpサーバーポート。
EMAIL_USE_TLSまたは_SSL -安全な接続の場合はTrue。

簡単な電子メールを送信する

「sendSimpleEmail」ビューを作成して、簡単な電子メールを送信しましょう。

from django.core.mail import send_mail
from django.http import HttpResponse

def sendSimpleEmail(request,emailto):
   res = send_mail("hello paul", "comment tu vas?", "[email protected]", [emailto])
   return HttpResponse('%s'%res)

send_mailのパラメータの詳細は次のとおりです-

subject -電子メールの件名。
message -電子メールの本文。
from_email -からの電子メール。
recipient_list -受信者の電子メールアドレスのリスト。
fail_silently -ブール値。falseの場合、エラーの場合にsend_mailは例外を発生させます。
auth_user -settings.pyで設定されていない場合のユーザーログイン。
auth_password -settings.pyで設定されていない場合のユーザーパスワード。
connection -電子メールのバックエンド。
html_message -（Django 1.7の新機能）存在する場合、電子メールはmultipart/alternativeになります。

ビューにアクセスするためのURLを作成しましょう-

from django.conf.urls import patterns, url

urlpatterns = paterns('myapp.views', url(r'^simpleemail/(?P<emailto>
   [\w.%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,4})/',
   'sendSimpleEmail' , name = 'sendSimpleEmail'),)

/myapp/simpleemail/[email protected]にアクセスすると、次のページが表示されます-

シンプルな電子メールの送信

send_mass_mailを使用して複数のメールを送信する

メソッドは、正常に配信されたメッセージの数を返します。これはsend_mailと同じですが、追加のパラメーターを取ります。 datatuple、私たちのsendMassEmailビューはその後になります-

from django.core.mail import send_mass_mail
from django.http import HttpResponse

def sendMassEmail(request,emailto):
   msg1 = ('subject 1', 'message 1', '[email protected]', [emailto1])
   msg2 = ('subject 2', 'message 2', '[email protected]', [emailto2])
   res = send_mass_mail((msg1, msg2), fail_silently = False)
   return HttpResponse('%s'%res)

ビューにアクセスするためのURLを作成しましょう-

from django.conf.urls import patterns, url

urlpatterns = paterns('myapp.views', url(r'^massEmail/(?P<emailto1>
   [\w.%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,4})/(?P<emailto2>
   [\w.%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,4})', 'sendMassEmail' , name = 'sendMassEmail'),)

/myapp/massemail/[email protected]/[email protected]/にアクセスすると、次のようになります-

複数のメールの送信

send_mass_mailパラメータの詳細は-

datatuples -各要素が似ているタプル（subject、message、from_email、recipient_list）。
fail_silently -ブール値。falseの場合、エラーの場合にsend_mailは例外を発生させます。
auth_user -settings.pyで設定されていない場合のユーザーログイン。
auth_password -settings.pyで設定されていない場合のユーザーパスワード。
connection -電子メールのバックエンド。

上の画像でわかるように、2つのメッセージが正常に送信されました。

注-この例では、Python smtp debuggingserverを使用しています。

$python -m smtpd -n -c DebuggingServer localhost:1025

これは、送信されたすべての電子メールが標準出力に出力され、ダミーサーバーがlocalhost：1025で実行されていることを意味します。

mail_adminsおよびmail_managersメソッドを使用して管理者およびマネージャーに電子メールを送信する*

これらのメソッドは、settings.pyファイルのADMINSオプションで定義されているサイト管理者、およびsettings.pyファイルのMANAGERSオプションで定義されているサイトマネージャーに電子メールを送信します。 ADMINSおよびMANAGERSオプションが次のように見えると仮定しましょう-

*ADMINS* =（（ 'polo'、 '[email protected]'）、）

管理者 =（（ popoli '、' [email protected] '）、）

from django.core.mail import mail_admins
from django.http import HttpResponse

def sendAdminsEmail(request):
   res = mail_admins('my subject', 'site is going down.')
   return HttpResponse('%s'%res)

上記のコードは、ADMINSセクションで定義されたすべての管理者に電子メールを送信します。

from django.core.mail import mail_managers
from django.http import HttpResponse

def sendManagersEmail(request):
   res = mail_managers('my subject 2', 'Change date on the site.')
   return HttpResponse('%s'%res)

上記のコードは、MANAGERSセクションで定義されたすべてのマネージャーに電子メールを送信します。

パラメータの詳細-

Subject -電子メールの件名。
message -電子メールの本文。
fail_silently -ブール値。falseの場合、エラーの場合にsend_mailは例外を発生させます。
connection -電子メールのバックエンド。
html_message -（Django 1.7の新機能）存在する場合、電子メールはmultipart/alternativeになります。

HTMLメールを送信する

Django> = 1.7でHTMLメッセージを送信するのは簡単です-

from django.core.mail import send_mail

from django.http import HttpResponse
   res = send_mail("hello paul", "comment tu vas?", "[email protected]",
         ["[email protected]"], html_message=")

これにより、マルチパート/代替の電子メールが生成されます。

しかし、Django <1.7の場合、HTMLメッセージの送信はdjango.core.mail.EmailMessageクラスを介して行われ、オブジェクトで「送信」を呼び出します-

HTMLメールを送信するための「sendHTMLEmail」ビューを作成しましょう。

from django.core.mail import EmailMessage
from django.http import HttpResponse

def sendHTMLEmail(request , emailto):
   html_content = "<strong>Comment tu vas?</strong>"
   email = EmailMessage("my subject", html_content, "[email protected]", [emailto])
   email.content_subtype = "html"
   res = email.send()
   return HttpResponse('%s'%res)

EmailMessageクラス作成のパラメーターの詳細-

Subject -電子メールの件名。
message -HTMLの電子メール本文。
from_email -からの電子メール。
to -受信者の電子メールアドレスのリスト。
bcc -「Bcc」受信者の電子メールアドレスのリスト。
connection -電子メールのバックエンド。

ビューにアクセスするためのURLを作成しましょう-

from django.conf.urls import patterns, url

urlpatterns = paterns('myapp.views', url(r'^htmlemail/(?P<emailto>
   [\w.%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,4})/',
   'sendHTMLEmail' , name = 'sendHTMLEmail'),)

/myapp/htmlemail/[email protected]にアクセスすると、次のようになります-

HTML電子メールの送信

添付ファイル付きの電子メールを送信する

これは、EmailMessageオブジェクトで「attach」メソッドを使用して行われます。

添付ファイル付きの電子メールを送信するビューは-

from django.core.mail import EmailMessage
from django.http import HttpResponse

def sendEmailWithAttach(request, emailto):
   html_content = "Comment tu vas?"
   email = EmailMessage("my subject", html_content, "[email protected]", emailto])
   email.content_subtype = "html"

   fd = open('manage.py', 'r')
   email.attach('manage.py', fd.read(), 'text/plain')

   res = email.send()
   return HttpResponse('%s'%res)

接続引数の詳細-

filename -添付するファイルの名前。
content -添付するファイルのコンテンツ。
mimetype -添付ファイルのコンテンツMIMEタイプ。

Django-汎用ビュー

場合によっては、前に見たようにビューを書くのは本当に重いです。静的ページまたはリストページが必要だと想像してください。 Djangoは、汎用ビューと呼ばれるこれらの単純なビューを設定する簡単な方法を提供します。

クラシックビューとは異なり、ジェネリックビューは関数ではなくクラスです。 Djangoはdjango.views.genericでジェネリックビューのクラスのセットを提供し、すべてのジェネリックビューはそれらのクラスの1つまたはそれらの1つから継承するクラスです。

10個以上あります。ジェネリッククラス-

>>> import django.views.generic
>>> dir(django.views.generic)

['ArchiveIndexView', 'CreateView', 'DateDetailView', 'DayArchiveView',
   'DeleteView', 'DetailView', 'FormView', 'GenericViewError', 'ListView',
   'MonthArchiveView', 'RedirectView', 'TemplateView', 'TodayArchiveView',
   'UpdateView', 'View', 'WeekArchiveView', 'YearArchiveView', '__builtins__',
   '__doc__', '__file__', '__name__', '__package__', '__path__', 'base', 'dates',
   'detail', 'edit', 'list']

これは、汎用ビューに使用できます。いくつかの例を見て、どのように機能するかを見てみましょう。

静的ページ

「staticl」テンプレートから静的ページを公開してみましょう。

私たちのstaticl-

<html>
   <body>
      This is a static page!!!
   </body>
</html>

以前に学んだ方法でこれを行った場合、 myapp/views.py を次のように変更する必要があります-

from django.shortcuts import render

def static(request):
   return render(request, 'staticl', {})

および myapp/urls.py は次のようになります-

from django.conf.urls import patterns, url

urlpatterns = patterns("myapp.views", url(r'^static/', 'static', name = 'static'),)

最善の方法は、汎用ビューを使用することです。そのため、myapp/views.pyは次のようになります-

from django.views.generic import TemplateView

class StaticView(TemplateView):
   template_name = "staticl"

そして、私たちのmyapp/urls.py-

from myapp.views import StaticView
from django.conf.urls import patterns

urlpatterns = patterns("myapp.views", (r'^static/$', StaticView.as_view()),)

/myapp/staticにアクセスすると、次のようになります-

静的ページ

同じ結果のために、次のこともできます-

views.pyに変更はありません
url.pyファイルを次のように変更します-

from django.views.generic import TemplateView
from django.conf.urls import patterns, url

urlpatterns = patterns("myapp.views",
   url(r'^static/',TemplateView.as_view(template_name = 'staticl')),)

ご覧のとおり、2番目の方法でurl.pyファイルを変更するだけです。

DBからのデータのリストと表示

Dreamrealモデルのすべてのエントリをリストします。これは、ListView汎用ビュークラスを使用して簡単に行えます。 url.pyファイルを編集し、次のように更新します-

from django.views.generic import ListView
from django.conf.urls import patterns, url

urlpatterns = patterns(
   "myapp.views", url(r'^dreamreals/', ListView.as_view(model = Dreamreal,
      template_name = "dreamreal_listl")),
)

この時点で重要なのは、汎用ビューからテンプレートに渡される変数がobject_listであることです。自分で名前を付けたい場合は、as_viewメソッドにcontext_object_name引数を追加する必要があります。その後、url.pyは次のようになります-

from django.views.generic import ListView
from django.conf.urls import patterns, url

urlpatterns = patterns("myapp.views",
   url(r'^dreamreals/', ListView.as_view(
      template_name = "dreamreal_listl")),
      model = Dreamreal, context_object_name = ”dreamreals_objects” ,)

関連するテンプレートは、その後になります-

{% extends "main_templatel" %}
{% block content %}
Dreamreals:<p>
{% for dr in object_list %}
{{dr.name}}</p>
{% endfor %}
{% endblock %}

/myapp/dreamreals/にアクセスすると、次のページが生成されます-

DBからのデータのリストと表示

Django-フォーム処理

Djangoでフォームを作成することは、モデルを作成することに本当に似ています。ここでも、Djangoクラスから継承する必要があり、クラス属性はフォームフィールドになります。 myappフォルダーに forms.py ファイルを追加して、アプリフォームを含めましょう。ログインフォームを作成します。

*myapp/forms.py*

#-*- coding: utf-8 -*-
from django import forms

class LoginForm(forms.Form):
   user = forms.CharField(max_length = 100)
   password = forms.CharField(widget = forms.PasswordInput())

上記のように、フィールドタイプはhtmlレンダリングの「ウィジェット」引数を取ることができます。この場合、パスワードは表示せずに非表示にします。 Djangoには他にも多くのウィジェットがあります：日付の DateInput 、チェックボックスの CheckboxInput など。

ビューでフォームを使用する

HTTPリクエストには、GETとPOSTの2種類があります。 Djangoでは、ビューにパラメーターとして渡されるリクエストオブジェクトには、リクエストのタイプが設定される「メソッド」という属性があり、POST経由で渡されるすべてのデータにはrequest.POST辞書経由でアクセスできます。

myapp/views.pyでログインビューを作成しましょう-

#-*- coding: utf-8 -*-
from myapp.forms import LoginForm

def login(request):
   username = "not logged in"

   if request.method == "POST":
      #Get the posted form
      MyLoginForm = LoginForm(request.POST)

      if MyLoginForm.is_valid():
         username = MyLoginForm.cleaned_data['username']
   else:
      MyLoginForm = Loginform()

   return render(request, 'loggedinl', {"username" : username})

ビューには、 loggedinl を通じて投稿されたログインフォームの結果が表示されます。テストするには、最初にログインフォームテンプレートが必要です。それをloginlと呼びましょう。

<html>
   <body>

      <form name = "form" action = "{% url "myapp.views.login" %}"
         method = "POST" >{% csrf_token %}

         <div style = "max-width:470px;">
            <center>
               <input type = "text" style = "margin-left:20%;"
                  placeholder = "Identifiant" name = "username"/>
            </center>
         </div>

         <br>

         <div style = "max-width:470px;">
            <center>
               <input type = "password" style = "margin-left:20%;"
                  placeholder = "password" name = "password"/>
            </center>
         </div>

         <br>

         <div style = "max-width:470px;">
            <center>

               <button style = "border:0px; background-color:#4285F4; margin-top:8%;
                  height:35px; width:80%;margin-left:19%;" type = "submit"
                  value = "Login" >
                  <strong>Login</strong>
               </button>

            </center>
         </div>

      </form>

   </body>
</html>

テンプレートにログインフォームが表示され、上記のログインビューに結果が投稿されます。おそらく、テンプレート内のタグに気付いたでしょう。これは、サイトでのクロスサイトリクエストフォージェリ（CSRF）攻撃を防ぐためです。

{% csrf_token %}

ログインテンプレートを取得したら、フォームの処理後にレンダリングされるlogininlテンプレートが必要です。

<html>

   <body>
      You are : <strong>{{username}}</strong>
   </body>

</html>

さて、開始するにはURLのペアが必要です：myapp/urls.py

from django.conf.urls import patterns, url
from django.views.generic import TemplateView

urlpatterns = patterns('myapp.views',
   url(r'^connection/',TemplateView.as_view(template_name = 'loginl')),
   url(r'^login/', 'login', name = 'login'))

「/myapp/connection」にアクセスすると、次のloginlテンプレートがレンダリングされます-

ログインHTMLテンプレート

フォーム投稿では、フォームは有効です。私たちの場合、2つのフィールドに必ず入力してください。

フォーム検証

ユーザー名がポロで、パスワードを忘れた場合。次のメッセージが表示されます-

フォーム無効メッセージ

独自のフォーム検証の使用

上記の例では、フォームを検証するとき-

MyLoginForm.is_valid()

Djangoの自己フォーム検証エンジンのみを使用しました。この場合、フィールドが必須であることを確認するだけです。次に、ログインしようとしているユーザーがDreamrealエントリとしてDBに存在することを確認してみましょう。このために、myapp/forms.pyを-に変更します

#-*- coding: utf-8 -*-
from django import forms
from myapp.models import Dreamreal

class LoginForm(forms.Form):
   user = forms.CharField(max_length = 100)
   password = forms.CharField(widget = forms.PasswordInput())

   def clean_message(self):
      username = self.cleaned_data.get("username")
      dbuser = Dreamreal.objects.filter(name = username)

      if not dbuser:
         raise forms.ValidationError("User does not exist in our db!")
      return username

これで、「is_valid」メソッドを呼び出した後、ユーザーがデータベースにいる場合にのみ正しい出力が得られます。フォームのフィールドを確認する場合は、「clean_」で始まるメソッドを追加してから、フィールド名をフォームクラスに追加します。 forms.ValidationErrorを発生させることは重要です。

Django-ファイルのアップロード

一般に、Webアプリがファイル（プロフィール写真、曲、pdf、単語など）をアップロードできると便利です。この章では、ファイルをアップロードする方法について説明します。

画像をアップロードする

画像の再生を開始する前に、Python Image Library（PIL）がインストールされていることを確認してください。画像のアップロードを説明するために、myapp/forms.pyでプロファイルフォームを作成しましょう-

#-*- coding: utf-8 -*-
from django import forms

class ProfileForm(forms.Form):
   name = forms.CharField(max_length = 100)
   picture = forms.ImageFields()

ご覧のとおり、ここでの主な違いは forms.ImageField だけです。 ImageFieldは、アップロードされたファイルが画像であることを確認します。そうでない場合、フォームの検証は失敗します。

それでは、アップロードしたプロファイルを保存するための「プロファイル」モデルを作成しましょう。これはmyapp/models.pyで行われます-

from django.db import models

class Profile(models.Model):
   name = models.CharField(max_length = 50)
   picture = models.ImageField(upload_to = 'pictures')

   class Meta:
      db_table = "profile"

モデルを見るとわかるように、ImageFieldは必須の引数 upload_to を取ります。これは、画像が保存されるハードドライブ上の場所を表します。パラメーターは、settings.pyファイルで定義されたMEDIA_ROOTオプションに追加されることに注意してください。

フォームとモデルができたので、myapp/views.pyでビューを作成しましょう-

#-*- coding: utf-8 -*-
from myapp.forms import ProfileForm
from myapp.models import Profile

def SaveProfile(request):
   saved = False

   if request.method == "POST":
      #Get the posted form
      MyProfileForm = ProfileForm(request.POST, request.FILES)

      if MyProfileForm.is_valid():
         profile = Profile()
         profile.name = MyProfileForm.cleaned_data["name"]
         profile.picture = MyProfileForm.cleaned_data["picture"]
         profile.save()
         saved = True
   else:
      MyProfileForm = Profileform()

   return render(request, 'savedl', locals())

見逃してはならない部分は、ProfileFormの作成時に変更があったため、2番目のパラメーター request.FILES を追加したことです。渡されなかった場合、フォームの検証は失敗し、画像が空であることを示すメッセージが表示されます。

これで、フォームとリダイレクトページに savedl テンプレートと profilel テンプレートが必要になります-

*myapp/templates/savedl* -

<html>
   <body>

      {% if saved %}
         <strong>Your profile was saved.</strong>
      {% endif %}

      {% if not saved %}
         <strong>Your profile was not saved.</strong>
      {% endif %}

   </body>
</html>

*myapp/templates/profilel* -

<html>
   <body>

      <form name = "form" enctype = "multipart/form-data"
         action = "{% url "myapp.views.SaveProfile" %}" method = "POST" >{% csrf_token %}

         <div style = "max-width:470px;">
            <center>
               <input type = "text" style = "margin-left:20%;"
               placeholder = "Name" name = "name"/>
            </center>
         </div>

         <br>

         <div style = "max-width:470px;">
            <center>
               <input type = "file" style = "margin-left:20%;"
                  placeholder = "Picture" name = "picture"/>
            </center>
         </div>

         <br>

         <div style = "max-width:470px;">
            <center>

               <button style = "border:0px;background-color:#4285F4; margin-top:8%;
                  height:35px; width:80%; margin-left:19%;" type = "submit" value = "Login" >
                  <strong>Login</strong>
               </button>

            </center>
         </div>

      </form>

   </body>
</html>

次に、開始するにはURLのペアが必要です：myapp/urls.py

from django.conf.urls import patterns, url
from django.views.generic import TemplateView

urlpatterns = patterns(
   'myapp.views', url(r'^profile/',TemplateView.as_view(
      template_name = 'profilel')), url(r'^saved/', 'SaveProfile', name = 'saved')
)

「/myapp/profile」にアクセスすると、次のプロファイルテンプレートがレンダリングされます-

画像のアップロード

そして、フォームの投稿で、保存されたテンプレートがレンダリングされます-

フォーム投稿テンプレート

画像のサンプルがありますが、画像だけでなく別の種類のファイルをアップロードする場合は、モデルとフォームの両方の ImageField を FileField に置き換えてください。

Django-Apacheセットアップ

これまでの例では、Django dev Webサーバーを使用しました。ただし、このサーバーはテスト用であり、実稼働環境には適していません。本番環境では、Apache、Nginxなどの実サーバーが必要です。この章でApacheについて説明しましょう。

Apacheを介してDjangoアプリケーションを提供するには、mod_wsgiを使用します。したがって、最初に行うことは、Apacheとmod_wsgiがインストールされていることを確認することです。プロジェクトを作成し、プロジェクト構造を見ると、次のように見えたことを思い出してください-

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

wsgi.pyファイルは、DjangoとApacheの間のリンクを処理するファイルです。

プロジェクト（myproject）をApacheと共有したいとします。フォルダーにアクセスするようにApacheを設定するだけです。 myprojectフォルダーをデフォルトの「/var/www/html」に配置するとします。この段階で、プロジェクトへのアクセスは127.0.0.1/myprojectを介して行われます。これにより、次のスナップショットに示すように、Apacheがフォルダーをリストするだけになります。

Django Apache Setup

ご覧のように、ApacheはDjangoのものを処理していません。これを処理するには、httpd.confでApacheを構成する必要があります。だからhttpd.confを開き、次の行を追加します-

WSGIScriptAlias//var/www/html/myproject/myproject/wsgi.py
WSGIPythonPath/var/www/html/myproject/

<Directory/var/www/html/myproject/>
   <Files wsgi.py>
      Order deny,allow
      Allow from all
   </Files>
</Directory>

あなたが127.0.0.1/myapp/connectionとしてログインページにアクセスできる場合は、次のページが表示されます-

ログインページ

Django-Cookieの処理

Webアプリケーションの要件に応じて、サイト訪問者ごとにデータを保存したい場合があります。 Cookieはクライアント側に保存され、クライアントブラウザのセキュリティレベルによっては、Cookieの設定が有効な場合と無効な場合があります。

DjangoでのCookie処理を説明するために、前に作成したログインシステムを使用してシステムを作成しましょう。システムはX分間ログインした状態を維持し、その時間を過ぎるとアプリを終了します。

このためには、last_connectionとusernameという2つのCookieを設定する必要があります。

まず、ログインビューを変更して、ユーザー名とlast_connection Cookieを保存します-

from django.template import RequestContext

def login(request):
   username = "not logged in"

   if request.method == "POST":
      #Get the posted form
      MyLoginForm = LoginForm(request.POST)

   if MyLoginForm.is_valid():
      username = MyLoginForm.cleaned_data['username']
   else:
      MyLoginForm = LoginForm()

   response = render_to_response(request, 'loggedinl', {"username" : username},
      context_instance = RequestContext(request))

   response.set_cookie('last_connection', datetime.datetime.now())
   response.set_cookie('username', datetime.datetime.now())

   return response

上記のビューで見られるように、Cookieの設定は、要求ではなく応答で呼び出される set_cookie メソッドによって行われ、すべてのCookie値が文字列として返されることにも注意してください。

ログインフォーム用のformViewを作成しましょう。Cookieが設定されていて、10秒以上経過していない場合はフォームを表示しません-

def formView(request):
   if 'username' in request.COOKIES and 'last_connection' in request.COOKIES:
      username = request.COOKIES['username']

      last_connection = request.COOKIES['last_connection']
      last_connection_time = datetime.datetime.strptime(last_connection[:-7],
         "%Y-%m-%d %H:%M:%S")

      if (datetime.datetime.now() - last_connection_time).seconds < 10:
         return render(request, 'loggedinl', {"username" : username})
      else:
         return render(request, 'loginl', {})

   else:
      return render(request, 'loginl', {})

上記のformViewで設定したCookieにアクセスするとわかるように、リクエストのCOOKIES属性（dict）を介して行われます。

次に、url.pyファイルを変更してURLを変更し、新しいビューとペアにします。

from django.conf.urls import patterns, url
from django.views.generic import TemplateView

urlpatterns = patterns('myapp.views',
   url(r'^connection/','formView', name = 'loginform'),
   url(r'^login/', 'login', name = 'login'))

/myapp/connectionにアクセスすると、次のページが表示されます-

Django Cookies Handling

そして、あなたは送信時に次の画面にリダイレクトされます-

リダイレクトされたCookie処理ページ

ここで、10秒の範囲で/myapp/connectionに再度アクセスしようとすると、2番目の画面に直接リダイレクトされます。また、この範囲外で/myapp/connectionに再度アクセスすると、ログインフォームが表示されます（画面1）。

Django-セッション

前に説明したように、クライアント側のCookieを使用して、Webアプリに役立つ多くのデータを保存できます。以前、クライアント側のCookieを使用して、Webアプリに役立つさまざまなデータを保存できることを確認しました。これにより、保存するデータの重要性に応じて、多くのセキュリティホールが発生します。

セキュリティ上の理由から、DjangoにはCookieを処理するためのセッションフレームワークがあります。セッションはCookieの送受信を抽象化するために使用され、データはサーバー側（データベースなど）に保存され、クライアント側のCookieには識別用のセッションIDのみが含まれます。セッションは、ユーザーのブラウザーがCookieを「受け入れない」に設定されている場合を回避するのにも役立ちます。

セッションのセットアップ

Djangoでは、 MIDDLEWARE_CLASSES および INSTALLED_APPS オプションにいくつかの行を追加することにより、プロジェクトの settings.py でセッションを有効にします。これはプロジェクトの作成中に行う必要がありますが、常に知っておくとよいので、 MIDDLEWARE_CLASSES には次のようにする必要があります-

'django.contrib.sessions.middleware.SessionMiddleware'

そして、 INSTALLED_APPS には次が必要です-

'django.contrib.sessions'

デフォルトでは、Djangoはセッション情報をデータベース（django_sessionテーブルまたはコレクション）に保存しますが、 file または cache などの他の方法を使用して情報を保存するようにエンジンを設定できます。

セッションが有効な場合、すべてのリクエスト（Djangoのビューの最初の引数）にはセッション（dict）属性があります。

簡単なサンプルを作成して、セッションを作成および保存する方法を見てみましょう。以前に簡単なログインシステムを構築しました（Djangoフォーム処理の章とDjango Cookiesの処理の章を参照）。ユーザー名をCookieに保存して、ログアウトしていない場合、ログインページにアクセスしたときにログインフォームが表示されないようにします。基本的に、Django Cookieの処理で使用したログインシステムを、Cookieのサーバー側を保存することで、より安全にします。

このため、まずログインビューを変更して、ユーザー名Cookieサーバー側を保存します-

def login(request):
   username = 'not logged in'

   if request.method == 'POST':
      MyLoginForm = LoginForm(request.POST)

      if MyLoginForm.is_valid():
         username = MyLoginForm.cleaned_data['username']
         request.session['username'] = username
      else:
         MyLoginForm = LoginForm()

   return render(request, 'loggedinl', {"username" : username}

次に、ログインフォームのformViewビューを作成します。Cookieが設定されている場合、フォームは表示されません-

def formView(request):
   if request.session.has_key('username'):
      username = request.session['username']
      return render(request, 'loggedinl', {"username" : username})
   else:
      return render(request, 'loginl', {})

次に、url.pyファイルを変更してURLを変更し、新しいビューとペアにします。

from django.conf.urls import patterns, url
from django.views.generic import TemplateView

urlpatterns = patterns('myapp.views',
   url(r'^connection/','formView', name = 'loginform'),
   url(r'^login/', 'login', name = 'login'))

/myapp/connectionにアクセスすると、次のページが表示されます-

セッションのセットアップ

そして、あなたは次のページにリダイレクトされます-

リダイレクトされたセッションページ

ここで/myapp/connectionに再度アクセスしようとすると、2番目の画面に直接リダイレクトされます。

Cookieを消去する簡単なログアウトビューを作成しましょう。

def logout(request):
   try:
      del request.session['username']
   except:
      pass
   return HttpResponse("<strong>You are logged out.</strong>")

そして、myapp/url.pyのログアウトURLとペアにします

url(r'^logout/', 'logout', name = 'logout'),

さて、/myapp/logoutにアクセスすると、次のページが表示されます-

ログアウトページ

/myapp/connectionに再度アクセスすると、ログインフォームが表示されます（画面1）。

セッションを使用したその他の可能なアクション

セッションを保存してアクセスする方法を見てきましたが、リクエストのセッション属性には、次のような他の便利なアクションがあることを知っておくと便利です-

* set_expiry（_value _）*-セッションの有効期限を設定します。
* get_expiry_age（）*-このセッションが期限切れになるまでの秒数を返します。
* get_expiry_date（）*-このセッションが期限切れになる日付を返します。
* clear_expired（）*-期限切れのセッションをセッションストアから削除します。
* get_expire_at_browser_close（）*-ユーザーのWebブラウザーが閉じられたときにユーザーのセッションCookieの有効期限が切れているかどうかに応じて、TrueまたはFalseを返します。

ジャンゴ-キャッシング

何かをキャッシュすることは、高価な計算の結果を保存することで、次回必要になったときに実行しないようにします。以下は、キャッシュがどのように機能するかを説明する擬似コードです-

given a URL, try finding that page in the cache

if the page is in the cache:
   return the cached page
else:
   generate the page
   save the generated page in the cache (for next time)
   return the generated page

Djangoには独自のキャッシングシステムが付属しており、動的ページを保存して、必要なときに再度計算することを回避できます。 Django Cacheフレームワークの良い点は、キャッシュできることです-

特定のビューの出力。
テンプレートの一部。
サイト全体。

Djangoでキャッシュを使用するには、最初にキャッシュが留まる場所を設定する必要があります。キャッシュフレームワークにはさまざまな可能性があります-キャッシュはデータベース、ファイルシステム、またはメモリに直接保存できます。設定はプロジェクトの settings.py ファイルで行われます。

データベースでのキャッシュのセットアップ

プロジェクトのsettings.pyファイルに次を追加するだけです-

CACHES = {
   'default': {
      'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
      'LOCATION': 'my_table_name',
   }
}

これが機能し、設定を完了するには、キャッシュテーブル「my_table_name」を作成する必要があります。このためには、次のことを行う必要があります-

python manage.py createcachetable

ファイルシステムでのキャッシュのセットアップ

プロジェクトのsettings.pyファイルに次を追加するだけです-

CACHES = {
   'default': {
      'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
      'LOCATION': '/var/tmp/django_cache',
   }
}

メモリ内のキャッシュのセットアップ

これはキャッシュの最も効率的な方法です。これを使用するには、メモリキャッシュ用に選択したPythonバインディングライブラリに応じて、次のオプションのいずれかを使用できます。

CACHES = {
   'default': {
      'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
      'LOCATION': '127.0.0.1:11211',
   }
}

Or

CACHES = {
   'default': {
      'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
      'LOCATION': 'unix:/tmp/memcached.sock',
   }
}

サイト全体のキャッシュ

Djangoでキャッシュを使用する最も簡単な方法は、サイト全体をキャッシュすることです。これは、プロジェクトのsettings.pyでMIDDLEWARE_CLASSESオプションを編集することにより行われます。オプションに次を追加する必要があります-

MIDDLEWARE_CLASSES &plus;= (
   'django.middleware.cache.UpdateCacheMiddleware',
   'django.middleware.common.CommonMiddleware',
   'django.middleware.cache.FetchFromCacheMiddleware',
)

ここで順序が重要であることに注意してください。更新はFetchミドルウェアの前に来る必要があります。

その後、同じファイルで、設定する必要があります-

CACHE_MIDDLEWARE_ALIAS – The cache alias to use for storage.
CACHE_MIDDLEWARE_SECONDS – The number of seconds each page should be cached.

ビューをキャッシュする

サイト全体をキャッシュしたくない場合は、特定のビューをキャッシュできます。これは、Djangoに付属の cache_page デコレーターを使用して行われます。 viewArticles ビューの結果をキャッシュしたいとしましょう-

from django.views.decorators.cache import cache_page

@cache_page(60 * 15)

def viewArticles(request, year, month):
   text = "Displaying articles of : %s/%s"%(year, month)
   return HttpResponse(text)

ご覧のとおり、 cache_page には、ビューの結果をパラメーターとしてキャッシュする秒数がかかります。上記の例では、結果は15分間キャッシュされます。

注-上記のビューがマップされる前に見たように-

urlpatterns = patterns('myapp.views',
   url(r'^articles/(?P<month>\d{2})/(?P<year>\d{4})/', 'viewArticles', name = 'articles'),)

URLはパラメーターを取得しているため、異なる呼び出しはそれぞれ個別にキャッシュされます。たとえば、/myapp/articles/02/2007へのリクエストは、/myapp/articles/03/2008に個別にキャッシュされます。

ビューのキャッシュは、url.pyファイルで直接行うこともできます。その後、次の結果は上記と同じになります。 myapp/url.pyファイルを編集して、関連するマップされたURL（上記）を変更します-

urlpatterns = patterns('myapp.views',
   url(r'^articles/(?P<month>\d{2})/(?P<year>\d{4})/',
   cache_page(60 * 15)('viewArticles'), name = 'articles'),)

そして、もちろん、myapp/views.pyでは不要になりました。

テンプレートフラグメントのキャッシュ

テンプレートの一部をキャッシュすることもできます。これは cache タグを使用して行われます。 hellol テンプレートを見てみましょう-

{% extends "main_templatel" %}
{% block title %}My Hello Page{% endblock %}
{% block content %}

Hello World!!!<p>Today is {{today}}</p>
We are
{% if today.day == 1 %}

the first day of month.
{% elif today == 30 %}

the last day of month.
{% else %}

I don't know.
{%endif%}

<p>
   {% for day in days_of_week %}
   {{day}}
</p>

{% endfor %}
{% endblock %}

コンテンツブロックをキャッシュするには、テンプレートが次のようになります-

{% load cache %}
{% extends "main_templatel" %}
{% block title %}My Hello Page{% endblock %}
{% cache 500 content %}
{% block content %}

Hello World!!!<p>Today is {{today}}</p>
We are
{% if today.day == 1 %}

the first day of month.
{% elif today == 30 %}

the last day of month.
{% else %}

I don't know.
{%endif%}

<p>
   {% for day in days_of_week %}
   {{day}}
</p>

{% endfor %}
{% endblock %}
{% endcache %}

上記のように、キャッシュタグには2つのパラメーターがあります。ブロックをキャッシュする時間（秒単位）とキャッシュフラグメントに指定する名前です。

Django-コメント

開始する前に、Django Commentsフレームワークは1.5バージョン以降廃止されることに注意してください。これで外部機能を使用できるようになりましたが、それでも使用したい場合は、バージョン1.6および1.7に含まれています。バージョン1.8以降は存在しませんが、別のGitHubアカウントでコードを取得できます。

コメントフレームワークを使用すると、アプリ内の任意のモデルにコメントを簡単に添付できます。

Djangoコメントフレームワークの使用を開始するには-

プロジェクトのsettings.pyファイルを編集し、 'django.contrib.sites' および 'django.contrib.comments' をINSTALLED_APPSオプションに追加します-

INSTALLED_APPS &plus;= ('django.contrib.sites', 'django.contrib.comments',)

サイトIDを取得する-

>>> from django.contrib.sites.models import Site
>>> Site().save()
>>> Site.objects.all()[0].id
u'56194498e13823167dd43c64'

あなたがsettings.pyファイルで取得するIDを設定します-

SITE_ID = u'56194498e13823167dd43c64'

すべてのコメントテーブルまたはコレクションを作成するには、dbを同期します-

python manage.py syncdb

コメントアプリのURLをプロジェクトのurls.pyに追加します-

from django.conf.urls import include
url(r'^comments/', include('django.contrib.comments.urls')),

フレームワークがインストールされたので、Helloテンプレートを変更して、Dreamrealモデルに関するコメントを追跡しましょう。/myapp/hello URLにパラメーターとして名前が渡される特定のDreamrealエントリのコメントをリストし、保存します。

ドリームリアルモデル

class Dreamreal(models.Model):

   website = models.CharField(max_length = 50)
   mail = models.CharField(max_length = 50)
   name = models.CharField(max_length = 50)
   phonenumber = models.IntegerField()

   class Meta:
      db_table = "dreamreal"

こんにちはビュー

def hello(request, Name):
   today = datetime.datetime.now().date()
   daysOfWeek = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
   dreamreal = Dreamreal.objects.get(name = Name)
   return render(request, 'hellol', locals())

hellolテンプレート

{% extends "main_templatel" %}
{% load comments %}
{% block title %}My Hello Page{% endblock %}
{% block content %}

<p>
   Our Dreamreal Entry:
   <p><strong>Name :</strong> {{dreamreal.name}}</p>
   <p><strong>Website :</strong> {{dreamreal.website}}</p>
   <p><strong>Phone :</strong> {{dreamreal.phonenumber}}</p>
   <p><strong>Number of comments :<strong>
   {% get_comment_count for dreamreal as comment_count %} {{ comment_count }}</p>
   <p>List of comments :</p>
   {% render_comment_list for dreamreal %}
</p>

{% render_comment_form for dreamreal %}
{% endblock %}

最後に、helloビューへのマッピングURL-

url(r'^hello/(?P<Name>\w&plus;)/', 'hello', name = 'hello'),

Now,

テンプレート（hellol）で、コメントフレームワークを-\ {％loadコメント％}でロードします
ビューによって渡されるDreamrealオブジェクトのコメントの数を取得します-dreamrealの\ {％get_comment_countとしてcomment_count％}
オブジェクトのコメントのリストを取得します-\ {％dreamreal％のrender_comment_list}
デフォルトのコメントフォームを表示します-\ {％dreamreal％のrender_comment_form}

/myapp/hello/steveにアクセスすると、名前がSteveであるDreamrealエントリのコメント情報が表示されます。そのURLにアクセスすると、あなたが取得します-

Djangoコメントの例

コメントを投稿すると、次のページにリダイレクトされます-

リダイレクトされたコメントページ

もう一度/myapp/hello/steveにアクセスすると、次のページが表示されます-

コメント数

ご覧のとおり、コメントの数は1になり、コメントのリスト行の下にコメントがあります。

Django-RSS

Djangoには、シンジケーションフィード生成フレームワークが付属しています。これを使用すると、 _ django.contrib.syndication.views.Feed class_ をサブクラス化するだけでRSSまたはAtomフィードを作成できます。

アプリで行われた最新のコメントのフィードを作成しましょう（Django-Comments Frameworkの章も参照）。このために、myapp/feeds.pyを作成してフィードを定義しましょう（コード構造内の任意の場所にフィードクラスを配置できます）。

from django.contrib.syndication.views import Feed
from django.contrib.comments import Comment
from django.core.urlresolvers import reverse

class DreamrealCommentsFeed(Feed):
   title = "Dreamreal's comments"
   link = "/drcomments/"
   description = "Updates on new comments on Dreamreal entry."

   def items(self):
      return Comment.objects.all().order_by("-submit_date")[:5]

   def item_title(self, item):
      return item.user_name

   def item_description(self, item):
      return item.comment

   def item_link(self, item):
      return reverse('comment', kwargs = {'object_pk':item.pk})

フィードクラスでは、 title 、 link 、および description 属性は、標準のRSS <title> 、 <link> および <description> 要素に対応しています。
items メソッドは、項目要素としてフィードに入れる要素を返します。私たちの場合、最後の5つのコメント。
item_title メソッドは、フィードアイテムのタイトルとして使用するものを取得します。この場合、タイトルはユーザー名になります。
item_description メソッドは、フィードアイテムの説明として使用するものを取得します。私たちの場合、コメント自体。
item_link メソッドは、完全なアイテムへのリンクを作成します。私たちの場合、それはあなたをコメントに導きます。

フィードができたので、views.pyにコメントビューを追加してコメントを表示しましょう-

from django.contrib.comments import Comment

def comment(request, object_pk):
   mycomment = Comment.objects.get(object_pk = object_pk)
   text = '<strong>User :</strong> %s <p>'%mycomment.user_name</p>
   text &plus;= '<strong>Comment :</strong> %s <p>'%mycomment.comment</p>
   return HttpResponse(text)

また、マッピングのためにmyapp urls.pyにいくつかのURLが必要です-

from myapp.feeds import DreamrealCommentsFeed
from django.conf.urls import patterns, url

urlpatterns &plus;= patterns('',
   url(r'^latest/comments/', DreamrealCommentsFeed()),
   url(r'^comment/(?P\w&plus;)/', 'comment', name = 'comment'),
)

/myapp/latest/comments/にアクセスすると、フィードが取得されます-

Django RSSの例

次に、ユーザー名のいずれかをクリックすると、前にコメントビューで定義された/myapp/comment/comment_idが表示されます。

Django RSSリダイレクトページ

したがって、RSSフィードの定義は、Feedクラスをサブクラス化し、URL（フィードへのアクセス用とフィード要素へのアクセス用）を定義するだけです。コメントと同様に、これはアプリのどのモデルにも添付できます。

ジャンゴ-アヤックス

Ajaxは基本的に、ページの読み込み回数を減らすために一緒に統合されたテクノロジーの組み合わせです。通常、エンドユーザーエクスペリエンスを容易にするためにAjaxを使用します。 DjangoでAjaxを使用するには、JQueryなどのAjaxライブラリを直接使用します。 JQueryを使用する場合、Apacheなどを介してサーバーにライブラリをダウンロードして提供する必要があるとします。次に、Ajaxベースのアプリケーションを開発するときと同じように、テンプレートで使用します。

DjangoでAjaxを使用する別の方法は、Django Ajaxフレームワークを使用することです。最も一般的に使用されるのはdjango-dajaxです。これは、Pythonを使用してJavaScriptソースコードをほとんど使用せずに、Webアプリケーションで非同期プレゼンテーションロジックを簡単かつ迅速に開発する強力なツールです。最も人気のある4つのAjaxフレームワーク、Prototype、jQuery、Dojo、MooToolsをサポートしています。

Django-dajaxを使用する

最初に行うことは、django-dajaxをインストールすることです。これは、easy_installまたはpipを使用して実行できます-

$ pip install django_dajax
$ easy_install django_dajax

これにより、django-dajaxに必要なdjango-dajaxiceが自動的にインストールされます。次に、dajaxとdajaxiceの両方を構成する必要があります。

INSTALLED_APPSオプションのプロジェクトsettings.pyにdajaxとdajaxiceを追加します-

INSTALLED_APPS &plus;= (
   'dajaxice',
   'dajax'
)

同じsettings.pyファイルで、次のものがあることを確認してください-

TEMPLATE_LOADERS = (
   'django.template.loaders.filesystem.Loader',
   'django.template.loaders.app_directories.Loader',
   'django.template.loaders.eggs.Loader',
)

TEMPLATE_CONTEXT_PROCESSORS = (
   'django.contrib.auth.context_processors.auth',
   'django.core.context_processors.debug',
   'django.core.context_processors.i18n',
   'django.core.context_processors.media',
   'django.core.context_processors.static',
   'django.core.context_processors.request',
   'django.contrib.messages.context_processors.messages'
)

STATICFILES_FINDERS = (
   'django.contrib.staticfiles.finders.FileSystemFinder',
   'django.contrib.staticfiles.finders.AppDirectoriesFinder',
   'dajaxice.finders.DajaxiceFinder',
)

DAJAXICE_MEDIA_PREFIX = 'dajaxice'

今myapp/url.pyファイルに移動し、dajax URLを設定し、dajax statics jsファイルをロードするために次のものがあることを確認してください-

from dajaxice.core import dajaxice_autodiscover, dajaxice_config
from django.contrib.staticfiles.urls import staticfiles_urlpatterns
from django.conf import settings

Then dajax urls:

urlpatterns &plus;= patterns('',
   url(r'^%s/' % settings.DAJAXICE_MEDIA_PREFIX, include('dajaxice.urls')),)

urlpatterns &plus;= staticfiles_urlpatterns()

Ajaxを使用して、Dreamrealモデルに基づいて単純なフォームを作成し、保存します（更新なし）。

最初に、myapp/form.pyにDreamrealフォームが必要です。

class DreamrealForm(forms.Form):
   website = forms.CharField(max_length = 100)
   name = forms.CharField(max_length = 100)
   phonenumber = forms.CharField(max_length = 50)
   email = forms.CharField(max_length = 100)

次に、アプリケーションにajax.pyファイルmyapp/ajax.pyが必要です。それが私たちのロジックであり、フォームを保存する関数を入れてポップアップを返す場所です-

from dajaxice.utils import deserialize_form
from myapp.form import DreamrealForm
from dajax.core import Dajax
from myapp.models import Dreamreal

@dajaxice_register
def send_form(request, form):
   dajax = Dajax()
   form = DreamrealForm(deserialize_form(form))

   if form.is_valid():
      dajax.remove_css_class('#my_form input', 'error')
      dr = Dreamreal()
      dr.website = form.cleaned_data.get('website')
      dr.name = form.cleaned_data.get('name')
      dr.phonenumber = form.cleaned_data.get('phonenumber')
      dr.save()

      dajax.alert("Dreamreal Entry %s was successfully saved." %
         form.cleaned_data.get('name'))
   else:
      dajax.remove_css_class('#my_form input', 'error')
      for error in form.errors:
         dajax.add_css_class('#id_%s' % error, 'error')

   return dajax.json()

今、私たちのフォームを持つdreamreallテンプレートを作成しましょう-

<html>
   <head></head>
   <body>

      <form action = "" method = "post" id = "my_form" accept-charset = "utf-8">
         {{ form.as_p }}
         <p><input type = "button" value = "Send" onclick = "send_form();"></p>
      </form>

   </body>
</html>

myapp/views.pyにテンプレートに付属するビューを追加します-

def dreamreal(request):
   form = DreamrealForm()
   return render(request, 'dreamreall', locals())

myapp/urls.pyに対応するURLを追加します-

url(r'^dreamreal/', 'dreamreal', name = 'dreamreal'),

次に、テンプレートに必要なものを追加して、Ajaxを機能させます。

ファイルの上部に追加します-

{% load static %}
{% load dajaxice_templatetags %}

そして、私たちのdreamreallテンプレートの<head>セクションに追加します-

この例ではJQueryライブラリを使用しているため、追加します-

<script src = "{% static '/static/jquery-1.11.3.min.js' %}"
   type = "text/javascript" charset = "utf-8"></script>
<script src = "{% static '/static/dajax/jquery.dajax.core.js' %}"></script>

クリック時に呼び出されるAjax関数-

<script>

   function send_form(){
      Dajaxice.myapp.send_form(Dajax.process,{'form':$('#my_form').serialize(true)});
   }
</script>

静的ファイルディレクトリに「jquery-1.11.3.min.js」が必要であり、jquery.dajax.core.jsも必要であることに注意してください。すべてのdajax静的ファイルが静的ディレクトリの下で提供されるようにするには、次を実行します-

$python manage.py collectstatic

注意-jquery.dajax.core.jsが欠落している場合があります。その場合は、ソースをダウンロードしてそのファイルを取得し、静的フォルダーに配置してください。

/myapp/dreamreal/にアクセスすると、次の画面が表示されます-

Django-dajaxの使用

送信すると、次の画面が表示されます-

Django-dajax Responseの使用

Django-quick-guide

Django-基本

ジャンゴの歴史

ジャンゴ–デザイン哲学

Djangoの利点

Django-概要

MVCパターン

DJANGO MVC-MVTパターン

Django-環境

ステップ1 – Pythonのインストール

ステップ2-Djangoのインストール

UNIX/LinuxおよびMac OS Xのインストール

Windowsインストール

ステップ3 –データベースのセットアップ

ステップ4 – Webサーバー

Django-プロジェクトの作成

プロジェクトを作成する

プロジェクト構造

プロジェクトのセットアップ

Django-アプリのライフサイクル

アプリケーションを作成する

あなたのアプリケーションをプロジェクトに知ってもらう

Django-管理インターフェース

管理インターフェイスの開始

Django-ビューを作成する

シンプルビュー

Django-URLマッピング

URLを整理する

どうですか？

ビューへのパラメーターの送信

Django-テンプレートシステム

レンダリング関数

Djangoテンプレート言語（DTL）

変数の表示

フィルター

Tags

タグ付け

のタグ

タグのブロックと拡張

コメントタグ

Django-モデル

モデルを作成する

データの操作（CRUD）

その他のデータ操作

モデルのリンク

Django-ページのリダイレクト

Django-電子メールの送信

簡単な電子メールを送信する

send_mass_mailを使用して複数のメールを送信する

HTMLメールを送信する

添付ファイル付きの電子メールを送信する

Django-汎用ビュー

静的ページ

DBからのデータのリストと表示

Django-フォーム処理

ビューでフォームを使用する

独自のフォーム検証の使用

Django-ファイルのアップロード

画像をアップロードする

Django-Apacheセットアップ

Django-Cookieの処理

Django-セッション

セッションのセットアップ

セッションを使用したその他の可能なアクション

ジャンゴ-キャッシング

データベースでのキャッシュのセットアップ

ファイルシステムでのキャッシュのセットアップ

メモリ内のキャッシュのセットアップ

サイト全体のキャッシュ

ビューをキャッシュする

テンプレートフラグメントのキャッシュ

Django-コメント

ドリームリアルモデル

こんにちはビュー

hellolテンプレート

Django-RSS

ジャンゴ-アヤックス

Django-dajaxを使用する