Django学习笔记2

Django第一个简易项目理解框架

在理解了Django框架的基本目录结构之后，为了更好的理解框架的流程，我们通过一个简易项目来实践一下，上面的目录可总结为：在templates文件夹中写前端页面，在settings中进行Django基本配置，在app下的models中写数据库相关，在url中写路径的对应关系，在views中写请求处理。

下面的项目就对这些文件一个个进行书写。

配置相关

首先是各种配置的书写，一下都是在setting文件中的配置

1、理解settings文件中的BASE_DIR

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

这句话是获取项目的根路径，后面会用到。

2、在最初的时候先禁用csrf相关

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    # 'django.middleware.csrf.CsrfViewMiddleware',  在此禁用，一般在setting中的47行左右
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

3、确认APP是否注册

如果是在pycharm中创建的APP，一般都会在setting文件中自动注册，格式如下，如果没有请手动添加

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'book_system.apps.BookSystemConfig',  # 这行是app的注册语句 book_system是app名

]

4、配置template文件夹的位置

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')]  # 在此处配置，该DIRS是一个列表，可以配置多个
        ,
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

5、配置静态文件存放的位置(本篇可不用此设置)

# 静态文件保存目录的别名
STATIC_URL = '/static/'

# 所有静态文件(css/js/图片)都放在我下面你配置的文件夹中，同样是列表，路径可以多个
STATICFILES_DIRS = [
os.path.join(BASE_DIR, "static"),
]

6、配置数据库相关

这里编者是用的mysql数据库，然后连接的数据库名字为'booksystem'，

第一步------在settings文件中写下如下配置，先将原DATABASE注释掉

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'booksystem',  # 数据库的名字
        'HOST': '127.0.0.1',
        'PORT': 3306,
        'USER': 'root',  # mysql数据库的用户名
        'PASSWORD': 'root',  # 密码
    }
}

第二步------告诉Django用pymysql代替默认的MySQLDB 连接MySQL数据库

在项目/__init__.py文件中,写下面两句:
    import pymysql
    # 告诉Django用pymysql来代替默认的MySQLdb
    pymysql.install_as_MySQLdb()

恭喜你，至此你的配置环节已经结束

数据库和models表的建立

1、自己动手创建数据库
create database booksystem;

2、在创建的APP目录下的models.py下写下如下类，可在创建的空数据库中创建一系列的表

from django.db import models


# Create your models here.


# 出版社类
class Publisher(models.Model):
    id = models.AutoField(primary_key=True)  # 自增的ID主键
    # 创建一个varchar（64）的唯一的不为空的字段
    name = models.CharField(max_length=64, null=False, unique=True)

    def __str__(self):
        return "<Author object>: {}".format(self.name)


# 书类
class Book(models.Model):
    id = models.AutoField(primary_key=True)
    # 创建一个varchar(64)的唯一的不为空的字段
    tittle = models.CharField(max_length=64, null=False, unique=True)
    # 和出版者关联的外键字段
    publisher = models.ForeignKey(to="Publisher")  # 设置书籍连接到出版者的外键
    # 数据库自动生成的外键会自动加上_id

    def __str__(self):
        return "<Author object>: {}".format(self.tittle)


# 作者类
class Author(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=16, null=False, unique=True)
    book = models.ManyToManyField(to="Book")  # 创建作者表和书籍表多对多的关系
    # 多对多的关系会在数据库中另创建一个新的对应关系表，只存放id的对应关系

    def __str__(self):
        return "<Author object>: {}".format(self.name)

3、使创建的表结构通过django命令映射到数据库

（1）. python manage.py makemigrations --> 把models.py里面的更改记录到小本本（相应APP的migrations文件夹下）
（2）. python manage.py migrate              --> 把更改翻译成SQL语句,去数据库执行、

如果在pycharm环境中可以选择Tools-->Run manage.py task，然后会在下方弹出如下界面

在后面输入makemigration [appname]和migrate [appname]可以达到和如上一样的结果，执行完毕会在对应的数据库下创建各种表

3、自动创建的数据表在数据库中的结构如下

四个主要的表结构如下所示

到这，数据库结构的创建已经结束，向表中填写数据即可使用

url的路径关系及处理函数

1、数据库构建完成后，我们着手于对访问地址的解析，写url的路径关系

"""bookdjango URL Configuration

The `urlpatterns` list routes URLs to views. For more information please see:
    https://docs.djangoproject.com/en/1.11/topics/http/urls/
Examples:
Function views
    1. Add an import:  from my_app import views
    2. Add a URL to urlpatterns:  url(r'^$', views.home, name='home')
Class-based views
    1. Add an import:  from other_app.views import Home
    2. Add a URL to urlpatterns:  url(r'^$', Home.as_view(), name='home')
Including another URLconf
    1. Import the include() function: from django.conf.urls import url, include
    2. Add a URL to urlpatterns:  url(r'^blog/', include('blog.urls'))
"""
from django.conf.urls import url
from django.contrib import admin
from book_system import views


urlpatterns = [
    url(r'^admin/', admin.site.urls),

    # 出版社的对应关系
    url(r'^publisher_list/', views.publisher_list),
    url(r'^add_publisher/', views.add_publisher),
    url(r'^delete_publisher/', views.delete_publisher),
    url(r'^edit_publisher/', views.edit_publisher),

    # 书的对应关系
    url(r'^book_list/', views.book_list),
    url(r'^add_book/', views.add_book),
    url(r'^delete_book/', views.delete_book),
    url(r'^edit_book/', views.edit_book),

    # 作者的对应关系
    url(r'^author_list/', views.author_list),
    url(r'^add_author/', views.add_author),
    url(r'^delete_author/', views.delete_author),
    url(r'^edit_author/', views.edit_author),

    url(r'^author_list1/', views.author_list1),

]

url函数的第一个参数为正则表达式，匹配接收的网址路径，匹配上了就交给后面第二个参数的函数处理

我们这里的函数写在了APP目录下的views模块里，也就是book_system中，根据需要把import那一行导入改成自己的APP

2、有了路径解析函数，下面写请求处理函数

在book_system下的views.py中写下路径处理函数

from django.shortcuts import render, redirect, HttpResponse
from book_system import models


# Create your views here.


def publisher_list(request):
    # 去数据库查出所有的出版社，填充到html中，给用户界面
    ret = models.Publisher.objects.all().order_by("id")
    return render(request, "publisher_list.html", {"publisher_list": ret})


def add_publisher(request):
    error_msg = ""
    if request.method == "POST":
        new_name = request.POST.get("publisher_name")
        if new_name:
            models.Publisher.objects.create(name=new_name)
            return redirect("/publisher_list/")
        else:
            error_msg = "出版社的名字不能为空"
    return render(request, "add_publisher.html", {"error": error_msg})


def delete_publisher(request):
    del_id = request.GET.get("id")

    if del_id:
        del_obj = models.Publisher.objects.get(id=del_id)  # 这里的id相当于where语句
        del_obj.delete()
        return redirect("/publisher_list/")
    else:
        return HttpResponse("您要删除的数据不存在")


def edit_publisher(request):
    if request.method == "POST":
        publisher_id = request.POST.get("id")
        publisher_name = request.POST.get("publisher_name")

        publisher = models.Publisher.objects.get(id=publisher_id)
        publisher.name = publisher_name
        publisher.save()

        return redirect("/publisher_list/")
    else:
        edit_id = request.GET.get("id")
        print(models.Publisher.objects)
        edit_obj = models.Publisher.objects.get(id=edit_id)
        return render(request, "edit_publisher.html", {"edit_obj": edit_obj})


# book的相关试图操作
def book_list(request):
    # 去数据库查出所有的书籍，填充到html中，给用户界面
    ret = models.Book.objects.all().order_by("id")
    return render(request, "book_list.html", {"book_list": ret})


def add_book(request):
    error_msg = ""
    ret = models.Publisher.objects.all()
    if request.method == "POST":
        new_name = request.POST.get("book_name")
        new_publisher_id = request.POST.get("publisher")
        if new_name:
            models.Book.objects.create(tittle=new_name, publisher_id=new_publisher_id)
            return redirect("/book_list/")
        else:
            error_msg = "书本的名字不能为空"
    return render(request, "add_book.html", {
        "error": error_msg,
        "publisher_list": ret
    })


def delete_book(request):
    del_id = request.GET.get("id")

    if del_id:
        del_obj = models.Book.objects.get(id=del_id)  # 这里的id相当于where语句
        del_obj.delete()
        return redirect("/book_list/")
    else:
        return HttpResponse("您要删除的数据不存在")


def edit_book(request):
    ret = models.Publisher.objects.all()
    if request.method == "POST":
        book_id = request.POST.get("id")
        book_tittle = request.POST.get("book_tittle")
        book_publisher_id = request.POST.get("publisher")

        book = models.Book.objects.get(id=book_id)
        book.tittle = book_tittle
        book.publisher_id = book_publisher_id
        book.save()

        return redirect("/book_list/")
    else:
        edit_id = request.GET.get("id")
        print(models.Book.objects)
        edit_obj = models.Book.objects.get(id=edit_id)
        return render(request, "edit_book.html", {
            "edit_obj": edit_obj,
            "publisher_list": ret
        })


def author_list(request):
    all_author = models.Author.objects.all()
    return render(request, "author_list.html", {"author_list": all_author})


def add_author(request):
    error_msg = ""
    ret = models.Book.objects.all()
    if request.method == "POST":
        new_name = request.POST.get("author_name")
        new_books_id = request.POST.getlist("books")
        if new_name:
            new_book_obj = models.Author.objects.create(name=new_name)
            new_book_obj.book.set(new_books_id)  # 自动保存，不用save
            return redirect("/author_list/")
        else:
            error_msg = "作者的名字不能为空"
    return render(request, "add_author.html", {
        "error": error_msg,
        "book_list": ret
    })


def delete_author(request):
    del_id = request.GET.get("id")

    if del_id:
        models.Author.objects.get(id=del_id).delete()  # 这里的id相当于where语句
        return redirect("/author_list/")
    else:
        return HttpResponse("您要删除的数据不存在")


def edit_author(request):
    if request.method == "POST":
        old_id = request.POST.get("author_id")
        old_obj = models.Author.objects.get(id=old_id)

        new_name = request.POST.get("author_name")
        new_books_id = request.POST.getlist("books")
        print(new_books_id)

        # 更新
        old_obj.name = new_name
        old_obj.book.set(new_books_id)  # 自动保存，不用save
        old_obj.save()
        return redirect("/author_list/")

    edit_author_id = request.GET.get("id")
    edit_author_obj = models.Author.objects.get(id=edit_author_id)

    ret = models.Book.objects.all()

    return render(request, "edit_author.html", {
        "author": edit_author_obj,
        "book_list": ret,
    })


def author_list1(request):
    return render(request, "author_list1.html")

有了路径处理函数还远远不够，还需要html文件来配合显示

3、一下文件再都存放在项目根目录下的templates目录下

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>添加作者</title>
</head>
<body>
<h1>添加作者信息</h1>
<form action="/add_author/" method="post">
    <p>
        姓名：<input type="text" name="author_name">
    </p>
    <p>
        著作：
        <select multiple name="books">
            {% for book in book_list %}
                <option value="{{ book.id }}">{{ book.tittle }}</option>
            {% endfor %}
        </select>
    </p>
    <input type="submit" value="提交">
    <p style="color: red;">{{ error }}</p>
</form>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>添加书籍</title>
</head>
<body>
<h1>添加书籍信息</h1>
<form action="/add_book/" method="post">
    <p>
        书名：<input type="text" name="book_name">
    </p>
    <p>
        <select name="publisher">
            {% for publisher in publisher_list %}
                <option value="{{ publisher.id }}">{{ publisher.name }}</option>
            {% endfor %}
        </select>
    </p>
    <input type="submit" value="提交">
    <p style="color: red;">{{ error }}</p>
</form>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>添加出版社</h1>
<form action="/add_publisher/" method="post">
    <input type="text" name="publisher_name">
    <input type="submit" value="提交">
    <p style="color: red;">{{ error }}</p>
</form>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>作者列表</title>
</head>
<body>
{# a标签指向的位置找的也是urls.py文件中的对应关系的key。并不是直接找同级目录下的文件#}
<a href="/add_author/">添加新的作者信息</a>
<table border="1">
    <thead>
    <tr>
        <th>ID</th>
        <th>姓名</th>
        <th>作品</th>
        <th>操作</th>
    </tr>
    </thead>
    <tbady>
        {% for author in author_list %}
            <tr>
                <td>{{ author.id }}</td>
                <td>{{ author.name }}</td>
                <td>
                    {% for book in author.book.all %}
                        {{ book.tittle }}&nbsp;
                    {% endfor %}
                </td>
                <td>
                    <a href="/delete_author/?id={{ author.id }}">删除</a>
                    <a href="/edit_author/?id={{ author.id }}">编辑</a>
                </td>
            </tr>
        {% endfor %}
    </tbady>
</table>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>书籍列表</title>
</head>
<body>
{# a标签指向的位置找的也是urls.py文件中的对应关系的key。并不是直接找同级目录下的文件#}
<a href="/add_book/">添加新的书籍信息</a>
<table border="1">
    <thead>
    <tr>
        <th>ID</th>
        <th>书名</th>
        <th>出版社名称</th>
        <th>操作</th>
    </tr>
    </thead>
    <tbady>
        {% for book in book_list %}
            <tr>
                <td>{{ book.id }}</td>
                <td>{{ book.tittle }}</td>
                <td>{{ book.publisher.name }}</td>
                <td>
                    <a href="/delete_book/?id={{ book.id }}">删除</a>
                    <a href="/edit_book/?id={{ book.id }}">编辑</a>
                </td>
            </tr>
        {% endfor %}
    </tbady>
</table>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>编辑作者</title>
</head>
<body>
<h1>编辑作者信息</h1>
<form action="/edit_author/" method="post">
    <input type="text" name="author_id" value="{{ author.id }}" style="display: none">
{{ author.id }}
    <p>
        姓名：<input type="text" name="author_name" value="{{ author.name }}">
    </p>
    <p>
        著作：
        <select multiple name="books">
            {% for book in book_list %}
                {% if book in author.book.all %}
                    <option selected value="{{ book.id }}">{{ book.tittle }}</option>
                {% else %}
                    <option value="{{ book.id }}">{{ book.tittle }}</option>
                {% endif %}
            {% endfor %}
        </select>
    </p>
    <input type="submit" value="提交">
    <p style="color: red;">{{ error }}</p>
</form>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>编辑书籍信息</title>
</head>
<body>
<h1>编辑书籍信息</h1>
<form action="/edit_book/" method="post">
    <input type="text" name="id" value="{{ edit_obj.id }}" style="display: none;">
    <p>
        <input type="text" name="book_tittle" value="{{ edit_obj.tittle }}">

    </p>
    {#    <input type="text" name="publisher_name" value="{{ edit_obj.name }}">#}
    <p>
        <select name="publisher">
            {% for publisher in publisher_list %}
                {% if edit_obj.publisher_id == publisher.id %}
                    <option selected value="{{ publisher.id }}">{{ publisher.name }}</option>
                {% else %}
                    <option value="{{ publisher.id }}">{{ publisher.name }}</option>
                {% endif %}
            {% endfor %}
        </select>
    </p>
    <input type="submit" value="提交">
    <p style="color: red;">{{ error }}</p>
</form>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>编辑出版社</title>
</head>
<body>
<h1>编辑出版社</h1>
<form action="/edit_publisher/" method="post">
    <input type="text" name="id" value="{{ edit_obj.id }}" style="display: none;">
    <input type="text" name="publisher_name" value="{{ edit_obj.name }}">
    <input type="submit" value="提交">
    <p style="color: red;">{{ error }}</p>
</form>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>出版社列表</title>
</head>
<body>
{# a标签指向的位置找的也是urls.py文件中的对应关系的key。并不是直接找同级目录下的文件#}
<a href="/add_publisher/">添加新的出版社</a>
<table border="1">
    <thead>
    <tr>
        <th>序号</th>
        <th>ID</th>
        <th>出版社名称</th>
        <th>操作</th>
    </tr>
    </thead>
    <tbady>
        {% for publisher in publisher_list %}
            <tr>
                <td>{{ forloop.counter }}</td>
                <td>{{ publisher.id }}</td>
                <td>{{ publisher.name }}</td>
                <td>
                    <a href="/delete_publisher/?id={{ publisher.id }}">删除</a>
                    <a href="/edit_publisher/?id={{ publisher.id }}">编辑</a>
                </td>
            </tr>
        {% endfor %}
    </tbady>
</table>
</body>
</html>

此时可以点运行，看看成果了，在8000后面加上下方数字后面的list即可操作书籍系统

Django中各种路径的寻址

1、网页地址栏

类似于在网页地址栏中输入127.0.0.1:8000/publisher_list/，寻找的是项目同名目录下的urls.py中的urlpatterns列表

urlpatterns = [
    url(r'^admin/', admin.site.urls),

    # 出版社的对应关系
    url(r'^publisher_list/', views.publisher_list),

    # 书的对应关系
    url(r'^book_list/', views.book_list),

    # 作者的对应关系
    url(r'^author_list/', views.author_list),
]

　　url函数的第一个参数为正则表达式，表示匹配127.0.0.1:8000/后面的路径，然后寻找相应的路径处理函数，这里有一个注意的地方就是在浏览器输入尾部带斜线和不带斜线的路径时，都能匹配到结果，例如：输入127.0.0.1:8000/publisher_list 和 127.0.0.1:8000/publisher_list/ 时都能匹配到url(r'^publisher_list/', views.publisher_list)，这不是因为浏览器会自动补全，是因为Django中默认配置会补全斜线如果在settings.py中加入APPEND_SLASH = False，这时，地址栏访问就不会自动补全斜线。

2、views.py里render返回时寻址

render(request, "publisher_list.html", {"publisher_list": ret})

render函数第二个参数为settings中TEMPLATES列表"DIRS"下面路劲的相对路径

3、views.py里render返回时寻址

redirect("/publisher_list/")

重定向函数，和第一点一样，寻找的是项目同名目录下的urls.py中的urlpatterns列表

4、html文件中form表单action寻址

和第一点一样，寻找的是项目同名目录下的urls.py中的urlpatterns列表

5、html文件中a标签寻址

和第一点一样，寻找的是项目同名目录下的urls.py中的urlpatterns列表

6、img和script下的src和link下的href

这两者一般都会带有静态文件的别名，一般去settings文件下STATIC_URL去寻找

Django配置文件settings详解

ADMINS

默认值：[ ]（空列表）

所有获得代码错误通知的人的邮件地址列表。当DEBUG=False，并且一个视图引发了异常时,Django将会给这个列表里的人发一封含有完整异常信息的电子邮件。列表中的每个项目都应该是（全名，电子邮件地址）的元组。例如：

[('John', 'john@example.com'), ('Mary', 'mary@example.com')]

ALLOWED_HOSTS

默认值：[ ]（空列表）

这是新手比较困惑的一个配置项。该配置项列表中包含的是Django站点可以为之提供服务的主机/域名。也就是哪些主机或IP能够访问Django服务器！列表里的所有元素是同级的，并存的

列表中的值可以是localhost、www.example.com或者.example.com形式的域名。

也可以是IP地址，比如：137.2.4.1、192.168.1.1、0.0.0.0、127.0.0.1

还可以是通配符’*’，表示所有外部主机都可以访问Django。但这种情况具有安全风险，在线上环境不要使用。

对于0.0.0.0，表示局域网内的主机都可以访问Django。

当DEBUG为True和ALLOWED_HOSTS为空时，默认相当于配置：[‘localhost’， ‘127.0.0.1’， ‘[:: 1]’]。--------------127.0.0.1（IPv4）和[::1]（IPv6）。

APPEND_SLASH

默认值：True

当设定为True时，如果请求的URL没有匹配到URLconf里面的任何一条URL路由设置，并且没有以/（斜杠）结束，该请求将重定向到以请求URL加/的URL地址。需要注意的是重定向有可能导致POST提交的数据丢失。

APPEND_SLASH设置只有在安装了CommonMiddleware中间件时才会启用。

DATABASES

# 数据库配置
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',  # 数据库驱动名
        'NAME': 'mydatabase',  # 数据库名称
        'USER': 'mydatabaseuser',  # 用户名
        'PASSWORD': 'mypassword',  # 密码
        'HOST': '127.0.0.1',  # 数据库所在的主机。
        'PORT': '3306',  # 端口号
    }
}

　　其中ENGINE指定使用的数据库后端。 内建的数据库后端名称有：

'django.db.backends.postgresql'
'django.db.backends.mysql'
'django.db.backends.sqlite3'
'django.db.backends.oracle'

　　Django默认使用sqlite数据库，以文件的形式存在。当使用sqlite为数据库时只需要配置上述NAME属性为数据库文件的完整路径。指定路径时，请始终使用前向的斜杠，即使在Windows 上（例如C:/homes/user/mysite/sqlite3.db）。

DEBUG

　　打开/关闭调试模式。最重要的设置之一！默认值是False，你没有看错！只是在settings.py中又帮我们设置为True了，打开了调试模式，方便开发者和测试者的！线上部署网站的时候务必设置为False。

调试模式下可以显示错误页面的细节。若你的应用产生了一个异常，Django会显示追溯细节，包括许多环境变量的元数据, 比如所有当前定义的Django设置。

DEFAULT_CHARSET

默认值：’utf-8’

HttpResponse响应对象的默认字符集。

DEFAULT_CONTENT_TYPE

默认值：’text/html’

HttpResponse对象的默认内容类型。

DEFAULT_FROM_EMAIL

默认值：’webmaster@localhost’

默认的电子邮件发送地址，即发送方。

INSTALLED_APPS

Django核心配置项！

当前Django项目中启用的app列表。 每个元素应该是一个Python的点分路径，字符串格式：

项目内每个启用的app，包括Django内置的contrib都必须在这个列表里注册，否则创建数据表、调用功能等等都无法进行。

一个典型的配置如下：

# app注册
INSTALLED_APPS = [
    'app1',  # 将自定义模块注册到项目中
    'app2',  # 将自定义模块注册到项目中
    'django.contrib.admin',  # admin站点
    'django.contrib.auth',  # 身份认证系统
    'django.contrib.contenttypes',  # 内容类型框架
    'django.contrib.sessions',  # 会话框架
    'django.contrib.messages',  # 消息框架
    'django.contrib.staticfiles',  # 静态文件管理框架
]

LANGUAGE_CODE

默认值：’en-us’

当前项目所使用的语言。默认为英语。汉语是zh-hans，千万不要写成别的，比如‘chinese’之类！

USE_I18N必须设置为True才能使LANGUAGE_CODE生效。

TIME_ZONE

默认：’America/Chicago’

时区设置。

注意，这个配置项的值不一定要和服务器的时区一致。例如，一个服务器可上可能有多个Django站点，每个站点都有一个单独的时区设置。

如果要设为中国时间，也就是北京时间，请赋值：TIME_ZONE = ‘Asia/Shanghai’。注意是上海，不是北京，囧！

当USE_TZ为False时，它将成为Django存储所有日期和时间数据时，使用的时区。 当USE_TZ为True 时，它是Django显示模板中的时间，解释表单中的日期，使用的时区。所以，通常我们都将USE_TZ同时设置为False！

注：在Windows 环境中，Django不能可靠地交替其它时区。如果你在Windows上运行Django，TIME_ZONE必须设置为与系统时区一致。

MEDIA_ROOT

默认值：”（空字符串）

用户上传的文件，所在目录的，文件系统绝对路径。也就是指示上传文件放到哪里。

例如： “/var/www/example.com/media/”

警告：MEDIA_ROOT和STATIC_ROOT必须设置为不同的值。

MEDIA_URL

默认值：”（空字符串）

MEDIA_URL指向MEDIA_ROOT所指定的media文件，用来管理保存的文件。该URL设置为非空值时，必须以斜杠“/”结束。

若你打算在模版中使用{{ MEDIA_URL }}，必须在TEMPLATES的context_processors设置中添加django.template.context_processors.media。

警告:MEDIA_URL和STATIC_URL必须设置为不同的值。

SECRET_KEY

当前Django项目实例的密钥。用于提供cryptographic签名，是一个唯一的并且不可预测的值。

TEMPLATES

Django模板系统相关的配置。列表中每一项都是一个字典类型数据（类似DATABASE配置），可以配置模板不同的功能。

示例如下

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],  # DIRS:定义了一个目录列表，模板引擎按列表顺序搜索这些目录以查找模板源文件。
        'APP_DIRS': True,  # APP_DIRS:告诉模板引擎是否应该进入每个已安装的应用中查找模板。通常请将该选项保持为True。
        # OPTIONS中包含了具体的后端设置。
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

BACKEND：要使用的模板后端。 内置模板后端有：

'django.template.backends.django.DjangoTemplates'
'django.template.backends.jinja2.Jinja2'

通过将BACKEND设置为完全限定路径（即’mypackage.whatever.Backend’），你可以使用第三方提供的模板后端。

OPTIONS中包含了具体的后端设置。

由于绝大多数引擎都是从文件加载模板的，所以每种模板引擎都包含两项通用设置：

• DIRS:定义了一个目录列表，模板引擎按列表顺序搜索这些目录以查找模板源文件。
• APP_DIRS:告诉模板引擎是否应该进入每个已安装的应用中查找模板。通常请将该选项保持为True。

每种模板引擎后端都定义了一个惯用的名称作为应用内部存放模板的子目录名称。（例如Django为它自己的模板引擎指定的是 ‘templates’，为jinja2指定的名字是‘jinja2’）。尤其是，django允许你有多个模板引擎后端实例，且每个实例有不同的配置选项。 在这种情况下你必须为每个配置指定一个唯一的NAME .

DTL引擎的OPTIONS配置项中接受以下参数:

• ‘autoescape’：一个布尔值，用于控制是否启用HTML自动转义功能。默认为True。
• context_processors：上下文处理器，以”.”为分隔符的Python调用路径的列表。默认是个空列表。
• ‘debug’：打开/关闭模板调试模式的布尔值。默认和setting中的DEBUG有相同的值。
• ‘loaders’：模板加载器类的虚拟Python路径列表，每个模板加载器知道如何从特定的源来导入模板。默认值取决于DIRS和APP_DIRS的值。
• string_if_invalid：非法变量时输出的字符串。默认为空字符串。
• file_charset：用于读取磁盘上的模板文件的字符集编码。默认为FILE_CHARSET的值。
• ‘libraries’：用于注册模板引擎。 这可以用于添加新的库或为现有库添加备用标签，标签库可以在{% load %}标记中传入相应的字典键值进行载入。
• ‘builtins’：将模板标签库加入内建库中，无需调用{% load %}就可使用。

  OPTIONS={
      'builtins': ['myapp.builtins'],
  }

USE_I18N

默认值：True

这是一个布尔值，指定Django的翻译系统是否开启。如果设置为False，Django会做一些优化，不去加载翻译机制。

USE_L10N

默认值：False

一个布尔值，用于决定是否开启数据本地化。如果此设置为True，例如Django将使用当前语言环境的格式显示数字和日期。

USE_TZ

默认值：False

一个布尔值,用来指定是否使用指定的时区(TIME_ZONE)的时间。若为True, 则Django会使用内建的时区的时间；否则, Django将会使用本地的时间。

如果我们将TIME_ZONE设置成了Asia/Shanghai， 那么务必同时将USE_TZ改成False！

SESSION_EXPIRE_AT_BROWSER_CLOSE

默认值：False

是否在用户关闭浏览器时过期会话。

STATIC_ROOT

默认值：None

在DEBUG设置为False时，也就是线上环境时，Django项目里的静态文件（js\css\plugins）会无法使用。这是，需要运行python manage.py collectstatic，将静态文件统一收集到一个目录下。STATIC_ROOT配置的就是该目录的绝对路径。

示例：”/var/www/example.com/static/”

这个目录，刚开始应该是一个空目录。

STATIC_URL

默认值：None

引用位于STATIC_ROOT中的静态文件时使用的网址。

示例：”/static/”或”http://static.example.com/”

该URL设置为非空值时，必须以斜杠“/”结束。

WSGI_APPLICATION

默认值：None

Django的内置服务器（例如runserver）将使用的WSGI应用程序对象的完整Python路径。

Django使用WSGI协议与外部进行通信。

由django-admin startproject xxx命令创建的Django项目，将自动创建一个简单的wsgi.py模块，里面有一个可调用的application变量，WSGI_APPLICATION配置项的值就指向这个application变量。

MIDDLEWARE

要使用的中间件列表。Django-admin命令创建的新项目中，settings.py文件里默认会为MIDDLEWARE配置项添加一系列Django内置的中间件，我们保持它不变就好了。

注释掉MIDDLEWARE 中的’django.middleware.csrf.CsrfViewMiddleware’,因为这句话会进行校验，容易产生403错误。

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',
]

添加自己的配置项

如果要添加自己的配置项，需遵循以下准则：

配置项名称必须全为大写。
不要使用一个已经存在的设置

 

---------------------

总目录https://www.cnblogs.com/wlx97e6/p/9143284.html