【Python之路】第二十二篇--Django【基础篇】

1 Django流程介绍

MTV模式      

著名的MVC模式：所谓MVC就是把web应用分为模型(M),控制器(C),视图(V)三层；他们之间以一种插件似的，松耦合的方式连接在一起。

模型负责业务对象与数据库的对象(ORM),视图负责与用户的交互(页面)，控制器(C)接受用户的输入调用模型和视图完成用户的请求。

Django的MTV模式本质上与MVC模式没有什么差别，也是各组件之间为了保持松耦合关系，只是定义上有些许不同，Django的MTV分别代表：

Model(模型)：负责业务对象与数据库的对象(ORM)

Template(模版)：负责如何把页面展示给用户

View(视图)：负责业务逻辑，并在适当的时候调用Model和Template

此外，Django还有一个url分发器，它的作用是将一个个URL的页面请求分发给不同的view处理，view再调用相应的Model和Template

2 开始Django

1、创建Django项目

django-admin startproject mysite

当前目录下会生成一个 mysite的工程，目录结构如下：

• manage.py ----- Django项目里面的工具，通过它可以调用django shell和数据库等。

• settings.py ---- 包含了项目的默认设置，包括数据库信息，调试标志以及其他一些工作的变量。

• urls.py ----- 负责把URL模式映射到应用程序。

2、在mysite目录下创建app应用

python manage.py startapp blog

3、启动django项目

python manage.py runserver 8899   # ip:端口,默认本地ip

当我们访问：http://127.0.0.1:8899/ 时就可以看到：

3 Setting文件配置

方法一：

　　静态文件在单独的app下：如 /app01/static/app01/JS/jquery-2.1.4.min.js　　（其中蓝色app01目录为必须，但可改其他名字，static文件夹也可改其他名字）

# index.html
{% load static %}
<script src="{% static 'app01/JS/jquery-2.1.4.min.js' %}"></script>

　　setting文件设置： （其中app01为项目名字，static为保存静态文件的文件夹。）

STATIC_URL = '/whattttt/'   # 前端使用前缀

STATICFILES_DIRS = (
    os.path.join(BASE_DIR,'app01','static'),
)

方法二： （同上述setting配置）

# index.html
<script src="/whattttt/app01/JS/jquery-2.1.4.min.js"></script>

方法三：  使用别名的形式

# index.html
{% load static %}
<script src="{% static 'biemin/JS/jquery-2.1.4.min.js' %}"></script>

<script src="/whattttt/biemin/JS/jquery-2.1.4.min.js"></script>

　　setting文件设置：

STATIC_URL = '/whattttt/'

STATICFILES_DIRS = (
    ('biemin',os.path.join(BASE_DIR,'app01','static','app01')),
)

补充：

　　如果不想每次在模版中加载静态文件都使用 {% load static%}

　　可以在settings.py中的 TEMPLATES/OPTIONS添加'builtins':['django.templatetags.static']

TEMPLATES = [
  {
    'BACKEND': 'django.template.backends.django.DjangoTemplates',
    'DIRS': [os.path.join(BASE_DIR, 'templates')]
    ,
    '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',
      ],
      #添加在这个位置
      'builtins' : [
        'django.templatetags.static'
      ],
    },
  },
]

　　

4 Django URL路由系统

　　它的本质是URL模式以及要为该URL模式调用的视图函数之间的映射表

urlpatterns = [
    url(正则表达式, view函数,参数,别名),
]

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^index/', views.index , {"a":''} , 'FFF'),
]

参数说明：

• 一个正则表达式字符串

• 一个可调用对象，通常为一个视图函数或一个指定视图函数路径的字符串

• 可选的要传递给视图函数的默认参数（字典形式）

• 一个可选的name参数 (别名)

from django.conf.urls import url
from app01 import views

urlpatterns = [
    url(r'^index/', views.index),
    url(r'^articles/([0-9]{4})/$', views.year_archive),
    url(r'^articles/([0-9]{4})/([0-9]{2})/$', views.month_archive),
    url(r'^articles/([0-9]{4})/([0-9]{2})/([0-9]+)/$', views.article_detail),
]

demo

无命名分组：

　　加了( )后，视图函数需要添加一个形参，都为字符串类型 ！

urlpatterns = [
    url(r'^articles/([0-9]{4})/$', views.year_archive),
]

# 视图函数:
def year_archive(request,y):
    pass

命名分组 ：

　　视图函数形参名为分组名 ！

urlpatterns = [
    url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),
]

# 视图函数:
def year_archive(request,year):
    pass

参数：

　　加上参数时，对应的视图函数，必须加上一个形参，形参名必须与参数名相同！

　　如果 参数名与正则分组名字相同时，后面覆盖前面！

urlpatterns = [
    url(r'^index/', views.index , {"a":''} , 'FFF'),
]

别名：

　　加载时，一行一行去查找 url 中 name = ‘new_login’ 的行 , 然后替换 !

urlpatterns = [
    url(r'^index/', views.login, name = 'new_login'),
]

用法:
<form action = {% url 'new_login' %} >

URL映射分发 :

　　每当Django 遇到 include()时，它会去掉URL 中匹配的部分并将剩下的字符串发送给包含的URLconf 做进一步处理。

from django.conf.urls import url,include

urlpatterns = [
    url(r'^hot/', include('app01.urls')),
]

　　例子中的正则表达式没有包含 $（字符串结束匹配符），但是包含一个末尾的斜杠。

from django.conf.urls import url,include
from app01 import views

urlpatterns = [
    url(r'^all/', views.allpage),
]

　　页面访问 http://127.0.0.1:8000/hot/all 时触发views.allpage

别名的应用：

urlpatterns = [
    url(r'^index',views.index,name='bieming'),
]
###################

def index(req):
    if req.method=='POST':
        username=req.POST.get('username')
        password=req.POST.get('password')
        if username=='alex' and password=='':
            return HttpResponse("登陆成功")
    return render(req,'index.html')

#####################

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
{#  <form action="/index/" method="post"> #}
     <form action="{% url 'bieming' %}" method="post">
         用户名:<input type="text" name="username">
         密码:<input type="password" name="password">
         <input type="submit" value="submit">
     </form>
</body>
</html>

#######################

settings 中注释掉: csrf该行进行测试demo
MIDDLEWARE = [
    # 'django.middleware.csrf.CsrfViewMiddleware',
]

5 Django Views（视图函数）

http请求中产生两个核心对象：

http请求：HttpRequest对象

http响应：HttpResponse对象

所在位置：django.http

视图函数接收的参数request就是HttpRequest    检测方法：isinstance(request,HttpRequest)

HttpRequest对象的属性：

# path：       请求页面的全路径，不包括域名
#
# method：     请求中使用的HTTP方法的字符串表示。全大写表示。例如
#
#                    if  req.method=="GET":
#
#                              do_something()
#
#                    elseif req.method=="POST":
#
#                              do_something_else()
#
# GET:         包含所有HTTP GET参数的类字典对象
#
# POST：       包含所有HTTP POST参数的类字典对象
#
#              服务器收到空的POST请求的情况也是可能发生的，也就是说，表单form通过
#              HTTP POST方法提交请求，但是表单中可能没有数据，因此不能使用
#              if req.POST来判断是否使用了HTTP POST 方法；应该使用  if req.method=="POST"
#
#
#
# COOKIES:     包含所有cookies的标准Python字典对象；keys和values都是字符串。
#
# FILES：      包含所有上传文件的类字典对象；FILES中的每一个Key都是<input type="file" name="" />标签中                     name属性的值，FILES中的每一个value同时也是一个标准的python字典对象，包含下面三个Keys：
#
#             filename：      上传文件名，用字符串表示
#             content_type:   上传文件的Content Type
#             content：       上传文件的原始内容
#
#
# user：       是一个django.contrib.auth.models.User对象，代表当前登陆的用户。如果访问用户当前
#              没有登陆，user将被初始化为django.contrib.auth.models.AnonymousUser的实例。你
#              可以通过user的is_authenticated()方法来辨别用户是否登陆：
#              if req.user.is_authenticated();只有激活Django中的AuthenticationMiddleware
#              时该属性才可用
#
# session：    唯一可读写的属性，代表当前会话的字典对象；自己有激活Django中的session支持时该属性才可用。

HttpRequest对象的方法：

　　get_full_path()   比如：http://127.0.0.1:8000/index33/?name=123 ,req.get_full_path()  得到的结果就是/index33/?name=123

HttpResponse对象：

　　对于HttpRequest对象来说，是由django自动创建的，但是，HttpResponse对象就必须我们自己创建。

　　每个view请求处理方法必须返回一个HttpResponse对象。

HttpResponse 类在 django.http.HttpResponse

在HttpResponse对象上扩展的常用方法：

• 页面渲染：render，render_to_response,

• 页面跳转：redirect

• locals()：  可以直接将函数中所有的变量传给模板

from django.shortcuts import render,HttpResponse,redirect,render_to_response
import time

def index(request):
    times = time.time()

    return render(request,'index.html',{"times":times})  # 页面渲染

    return render(request,'index.html',locals())         # 页面渲染 , HTML文件路径在Setting文件中做了拼接处理!

    return render_to_response('index.html',locals())     # 页面渲染 , 可以不用填写request

    return redirect('/login')           # 跳转

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>{{ times }}</h1>
</body>
</html>

Demo: index.html

6 Django Models

1. django默认支持sqlite，mysql, oracle,postgresql数据库。

<1> sqlite

　　django默认使用sqlite的数据库，默认自带sqlite的数据库驱动

　　引擎名称：django.db.backends.sqlite3

<2>mysql

　　引擎名称：django.db.backends.mysql

2. mysql驱动程序

　　MySQLdb(mysql python)

　　mysqlclient

　　MySQL

　　PyMySQL(纯python的mysql驱动程序)

3. 在django的项目中会默认使用sqlite数据库，在settings里有如下设置：

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

如果我们想要更改数据库为MYSQL，需要修改如下：

DATABASES = {
    'default': {
    'ENGINE': 'django.db.backends.mysql',
    'NAME':'dbname',
    'USER': 'root',
    'PASSWORD': 'xxx',
    'HOST': '',
    'PORT': '',
    }
}

注意：NAME即数据库的名字，在mysql连接前该数据库必须已经创建，而上面的sqlite数据库下的db.sqlite3则是项目自动创建

USER和PASSWORD分别是数据库的用户名和密码。

设置完后，再启动我们的Django项目前，我们需要激活我们的mysql。

然后，启动项目，会报错：no module named MySQLdb

这是因为django默认你导入的驱动是MySQLdb，可是MySQLdb对于py3有很大问题，所以我们需要的驱动是PyMySQL

所以，我们只需要找到项目名文件下的__init__,在里面写入：

import pymysql
pymysql.install_as_MySQLdb()

         问题就解决了！

         这时就可以正常启动了。

        但此时数据库内并没有内容，我们需要做数据库的同步：

数据库的同步：

python manage.py makemigrations
python manage.py migrate

添加日志记录：(显示每次执行的SQL语句)

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}

LOGGING

4.2  Django的ORM（关系对象映射）

4.2.1  模型类的定义（一）

用于实现面向对象编程语言里不同类型系统的数据之间的转换，换言之，就是用面向对象的方式去操作数据库的创建表以及增删改查等操作。

优点：1 ORM使得我们的通用数据库交互变得简单易行，而且完全不用考虑该死的SQL语句。快速开发，由此而来。

2 可以避免一些新手程序猿写sql语句带来的性能问题。

缺点：1 性能有所牺牲，不过现在的各种ORM框架都在尝试各种方法，比如缓存，延迟加载登来减轻这个问题。效果很显著。

2 对于个别复杂查询，ORM仍然力不从心，为了解决这个问题，ORM一般也支持写raw sql。

下面要开始学习Django ORM语法了，为了更好的理解，我们来做一个基本的 书籍/作者/出版商 数据库结构。 我们这样做是因为 这是一个众所周知的例子，很多SQL有关的书籍也常用这个举例。

实例：我们来假定下面这些概念，字段和关系

作者模型：

　　一个作者有姓名。

作者详细模型：

　　把作者的详情放到详情表，包含性别，email地址和出生日期，作者详情模型和作者模型之间是一对一的关系（one－to－one）（类似于每个人和他的身份证之间的关系），

　　在大多数情况下我们没有必要将他们拆分成两张表，这里只是引出一对一的概念。

出版商模型：

　　出版商有名称，地址，所在城市，省，国家和网站。

书籍模型：

　　书籍有书名和出版日期，一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍的关系就是多对多的关联关系（many－to－many），

　　一本书只应该由一个出版商出版，所以出版商和书籍是一对多关联关系（one－to－many），也被称作外键。

from django.db import models
class Publisher(models.Model):
    name = models.CharField(max_length=30, verbose_name="名称")
    address = models.CharField("地址", max_length=50)
    city = models.CharField('城市',max_length=60)
    state_province = models.CharField(max_length=30)
    country = models.CharField(max_length=50)
    website = models.URLField()

    class Meta:
        verbose_name = '出版商'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name

class Author(models.Model):
    name = models.CharField(max_length=30)
    def __str__(self):
        return self.name

class AuthorDetail(models.Model):
    sex = models.BooleanField(max_length=1, choices=((0, '男'),(1, '女'),))
    email = models.EmailField()
    address = models.CharField(max_length=50)
    birthday = models.DateField()
    author = models.OneToOneField(Author)

class Book(models.Model):
    title = models.CharField(max_length=100)
    authors = models.ManyToManyField(Author)
    publisher = models.ForeignKey(Publisher)
    publication_date = models.DateField()
    price=models.DecimalField(max_digits=5,decimal_places=2,default=10)
    def __str__(self):
        return self.title

表结构

默认情况下，Django 会给每个模型添加下面这个字段：

id = models.AutoField(primary_key=True)

完成后,记得在settings 里的INSTALLED_APPS中加入'app01',然后同步数据库：

INSTALLED_APPS = [
    ....
    'app01',
]

模型之间的三种关系：一对一，一对多，多对多。

一对一：实质就是在主外键（author_id就是foreign key）的关系基础上，给外键加了一个UNIQUE的属性；

一对多：就是主外键关系；

多对多： book类里定义了一个多对多的字段authors，但是并没在book表中，这是因为创建了一张新的表：

模型的常用字段类型以及参数：

# AutoField
# 一个 IntegerField, 添加记录时它会自动增长. 你通常不需要直接使用这个字段; 如果你不指定主键的话,系统会自动添加一个主键字段到你的 model.(参阅 _自动主键字段)

# BooleanField
# A true/false field. admin 用 checkbox 来表示此类字段.

# CharField
# 字符串字段, 用于较短的字符串.
#
# 如果要保存大量文本, 使用 TextField.
#
# admin 用一个 <input type="text"> 来表示此类字段 (单行输入).
#
# CharField 要求必须有一个参数 maxlength, 用于从数据库层和Django校验层限制该字段所允许的最大字符数.

# CommaSeparatedIntegerField
# 用于存放逗号分隔的整数值. 类似 CharField, 必须要有 maxlength 参数.

# DateField
# 一个日期字段. 共有下列额外的可选参数:
#
# Argument    描述
# auto_now    当对象被保存时,自动将该字段的值设置为当前时间.通常用于表示 "last-modified" 时间戳.
# auto_now_add    当对象首次被创建时,自动将该字段的值设置为当前时间.通常用于表示对象创建时间.
# admin 用一个文本框 <input type="text"> 来表示该字段数据(附带一个 JavaScript 日历和一个"Today"快键.

# DateTimeField
#  一个日期时间字段. 类似 DateField 支持同样的附加选项.
# admin 用两上文本框 <input type="text"> 表示该字段顺序(附带JavaScript shortcuts). 

# EmailField
# 一个带有检查 Email 合法性的 CharField,不接受 maxlength 参数.

# FileField
# 一个文件上传字段.
#
# 要求一个必须有的参数: upload_to, 一个用于保存上载文件的本地文件系统路径. 这个路径必须包含 strftime formatting, 该格式将被上载文件的 date/time 替换(so that uploaded files don't fill up the given directory).
#
# admin 用一个``<input type="file">``部件表示该字段保存的数据(一个文件上传部件) .
#
# 在一个 model 中使用 FileField 或 ImageField 需要以下步骤:
#
# 在你的 settings 文件中, 定义一个完整路径给 MEDIA_ROOT 以便让 Django在此处保存上传文件. (出于性能考虑,这些文件并不保存到数据库.) 定义 MEDIA_URL 作为该目录的公共 URL. 要确保该目录对 WEB 服务器用户帐号是可写的.
# 在你的 model 中添加 FileField 或 ImageField, 并确保定义了 upload_to 选项,以告诉 Django 使用 MEDIA_ROOT 的哪个子目录保存上传文件.
# 你的数据库中要保存的只是文件的路径(相对于 MEDIA_ROOT). 出于习惯你一定很想使用 Django 提供的 get_<fieldname>_url 函数.举例来说,如果你的 ImageField 叫作 mug_shot, 你就可以在模板中以 {{ object.get_mug_shot_url }} 这样的方式得到图像的绝对路径.
# FilePathField
# 可选项目为某个特定目录下的文件名. 支持三个特殊的参数, 其中第一个是必须提供的.
#
# 参数    描述
# path    必需参数. 一个目录的绝对文件系统路径. FilePathField 据此得到可选项目. Example: "/home/images".
# match    可选参数. 一个正则表达式, 作为一个字符串, FilePathField 将使用它过滤文件名. 注意这个正则表达式只会应用到 base filename 而不是路径全名. Example: "foo.*\.txt^", 将匹配文件 foo23.txt 却不匹配 bar.txt 或 foo23.gif.
# recursive    可选参数.要么 True 要么 False. 默认值是 False. 是否包括 path 下面的全部子目录.
# 这三个参数可以同时使用.
#
# 我已经告诉过你 match 仅应用于 base filename, 而不是路径全名. 那么,这个例子:
#
# FilePathField(path="/home/images", match="foo.*", recursive=True)
# ...会匹配 /home/images/foo.gif 而不匹配 /home/images/foo/bar.gif

# FloatField
# 一个浮点数. 必须 提供两个 参数:
#
# 参数    描述
# max_digits    总位数(不包括小数点和符号)
# decimal_places    小数位数
# 举例来说, 要保存最大值为 999 (小数点后保存2位),你要这样定义字段:
#
# models.FloatField(..., max_digits=5, decimal_places=2)
# 要保存最大值一百万(小数点后保存10位)的话,你要这样定义:
#
# models.FloatField(..., max_digits=19, decimal_places=10)
# admin 用一个文本框(<input type="text">)表示该字段保存的数据.

# ImageField
# 类似 FileField, 不过要校验上传对象是否是一个合法图片.它有两个可选参数:height_field 和 width_field,如果提供这两个参数,则图片将按提供的高度和宽度规格保存.
#
# 该字段要求 Python Imaging Library.

# IntegerField
# 用于保存一个整数.
#
# admin 用一个``<input type="text">``表示该字段保存的数据(一个单行编辑框)

# IPAddressField
# 一个字符串形式的 IP 地址, (i.e. "24.124.1.30").
#
# admin 用一个``<input type="text">``表示该字段保存的数据(一个单行编辑框)

# NullBooleanField
# 类似 BooleanField, 不过允许 NULL 作为其中一个选项. 推荐使用这个字段而不要用 BooleanField 加 null=True 选项.
#
# admin 用一个选择框 <select> (三个可选择的值: "Unknown", "Yes" 和 "No" ) 来表示这种字段数据.

# PhoneNumberField
# 一个带有合法美国风格电话号码校验的 CharField``(格式: ``XXX-XXX-XXXX).

# PositiveIntegerField
# 类似 IntegerField, 但取值范围为非负整数(这个字段应该是允许0值的....所以字段名字取得不太好,无符号整数就对了嘛).

# PositiveSmallIntegerField
# 类似 PositiveIntegerField, 取值范围较小(数据库相关)

# SlugField
# "Slug" 是一个报纸术语. slug 是某个东西的小小标记(短签), 只包含字母,数字,下划线和连字符.它们通常用于URLs.
#
# 若你使用 Django 开发版本,你可以指定 maxlength. 若 maxlength 未指定, Django 会使用默认长度: 50. 在以前的 Django 版本,没有任何办法改变 50 这个长度.
#
# 这暗示了 db_index=True.
#
# 它接受一个额外的参数: prepopulate_from, which is a list of fields from which to auto-populate the slug, via JavaScript, in the object's admin form:
#
# models.SlugField(prepopulate_from=("pre_name", "name"))
# prepopulate_from 不接受 DateTimeFields.
#
# admin 用一个``<input type="text">``表示 SlugField 字段数据(一个单行编辑框) 

# SmallIntegerField
# 类似 IntegerField, 不过只允许某个取值范围内的整数.(依赖数据库)

# TextField
# 一个容量很大的文本字段.
#
# admin 用一个 <textarea> (文本区域)表示该字段数据.(一个多行编辑框).

# TimeField
# A time. Accepts the same auto-population options as DateField 和 DateTimeField.
#
# admin 用一个 <input type="text"> 文本框表示该字段保存的数据(附加一些JavaScript shortcuts).

# URLField
# 用于保存 URL. 若 verify_exists 参数为 True (默认), 给定的 URL 会预先检查是否存在(即URL是否被有效装入且没有返回404响应).
#
# admin 用一个 <input type="text"> 文本框表示该字段保存的数据(一个单行编辑框)

# USStateField
# 一个两字母的美国州名缩写.
#
# admin 用一个 <input type="text"> 文本框表示该字段保存的数据(一个单行编辑框)

# XMLField
# 一个校验值是否为合法XML的 TextField,必须提供参数: schema_path, 它是一个用来校验文本的 RelaxNG schema 的文件系统路径.

4.2.1  模型类的定义（二）

4.2.1  模型类的定义（二）      

一  定义数据模型的扩展属性

通过内部类Meta给数据模型类增加扩展属性：

class Meta：

verbose_name='名称'      ＃表名由英文转换成中文了

verbose_name_plural='名称复数形式'

ordering＝'排序字段'

    创建超级用户后，登录admin发现我们定义的表并不在，我们需要对所创建的表（类）进行注册：

from django.contrib import admin

# Register your models here.

from app01.models import *

admin.site.register(Author)
admin.site.register(AuthorDetail)
admin.site.register(Publisher)
admin.site.register(Book)

这是因为：

二  定义模型方法

定义模型方法和定义普通python类方法没有太大的差别，定义模型方法可以将当前对应的数据组装成具体的业务逻辑。

示例：定义__str__()让对象有一个名字

def __str__(self):
    return self.name

#py2
def __unicode__(self):
    return self.name

当添加一个作者保存后：      

这里只显示生成了一个作者对象，可我们希望在这里出现的是作者的名字，所以：

刷新页面：

4.3 ORM常用操作

4.3.1 增加

create和save方法

实例：

Author.objects.create(name='abcd')
AuthorDetail.objects.create(sex=False, email='[e-mail]', address='bejing', birthday='1999-9-9',author_id=1)

********************************************
author= Author()
author.name = 'eve'
author.save()

注意：如果每次创建一个对象，想显示对应的raw sql，需要在settings加上日志记录部分：

LOGGING = {
#     'version': 1,
#     'disable_existing_loggers': False,
#     'handlers': {
#         'console':{
#             'level':'DEBUG',
#             'class':'logging.StreamHandler',
#         },
#     },
#     'loggers': {
#         'django.db.backends': {
#             'handlers': ['console'],
#             'propagate': True,
#             'level':'DEBUG',
#         },
#     }
# }

那么如何插入存在 外键 和 多对多关系 的一本书的信息呢？

pub = Publisher.objects.get(id=1)
Book.objects.create(title='php', publisher=pub, publication_date='2017-7-7')

author1=Author.objects.get(id=1)
book=Book.objects.get(id=1)
book.authors.add(author1)

总结：

1   objects：   model默认管理器。

2   插入主外键关系的时候，可以用对象的方式，也可以用关联id的方式。

3   插入多对多关系的时候要分步操作。

4   create是管理器objects的方法

save是model对象的方法

4.3.2 修改

update和save方法

实例：

author = Author.objects.get(id=2)
author.name = 'mnm'
author.save()

Publisher.objects.filter(id=1).update(name='American publisher')

注意：<1> update是QuerySet对象的方法，get返回的是一个model对象，它没有update方法，而filter返回的是一个QuerySet对象。

　　   <2> save()方法，这个方法会更新一行里的所有列。

　　   <3> update()方法对于任何结果集（QuerySet）均有效，这意味着你可以同时更新多条记录。

　　   <4> update()方法会返回一个整型数值，表示受影响的记录条数。

Publisher.objects.all().update(country='USA')

4.3.3  查询 

models.Tb1.objects.get(id=123)           # 获取单条数据，不存在则报错（不建议）
models.Tb1.objects.all()                 # 获取全部
models.Tb1.objects.filter(name='seven')  # 获取指定条件的数据

4.3.4  删除

models.Tb1.objects.filter(name='seven').delete()  # 删除指定条件的数据

我们表面上删除了一条信息，实际却删除了三条，因为我们删除的这本书在Book_authors表中有两条相关信息，这种删除方式就是django默认的级联删除。

Model 进阶操作

一、创建表

1、基本结构

from django.db import models

class userinfo(models.Model):
    name = models.CharField(max_length=30)
    email = models.EmailField()
    memo = models.TextField()

AutoField(Field)
        - int自增列，必须填入参数 primary_key=True

    BigAutoField(AutoField)
        - bigint自增列，必须填入参数 primary_key=True

        注：当model中如果没有自增列，则自动会创建一个列名为id的列
        from django.db import models

        class UserInfo(models.Model):
            # 自动创建一个列名为id的且为自增的整数列
            username = models.CharField(max_length=32)

        class Group(models.Model):
            # 自定义自增列
            nid = models.AutoField(primary_key=True)
            name = models.CharField(max_length=32)

    SmallIntegerField(IntegerField):
        - 小整数 -32768 ～ 32767

    PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正小整数 0 ～ 32767
    IntegerField(Field)
        - 整数列(有符号的) -2147483648 ～ 2147483647

    PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正整数 0 ～ 2147483647

    BigIntegerField(IntegerField):
        - 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807

    自定义无符号整数字段

        class UnsignedIntegerField(models.IntegerField):
            def db_type(self, connection):
                return 'integer UNSIGNED'

        PS: 返回值为字段在数据库中的属性，Django字段默认的值为：
            'AutoField': 'integer AUTO_INCREMENT',
            'BigAutoField': 'bigint AUTO_INCREMENT',
            'BinaryField': 'longblob',
            'BooleanField': 'bool',
            'CharField': 'varchar(%(max_length)s)',
            'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
            'DateField': 'date',
            'DateTimeField': 'datetime',
            'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
            'DurationField': 'bigint',
            'FileField': 'varchar(%(max_length)s)',
            'FilePathField': 'varchar(%(max_length)s)',
            'FloatField': 'double precision',
            'IntegerField': 'integer',
            'BigIntegerField': 'bigint',
            'IPAddressField': 'char(15)',
            'GenericIPAddressField': 'char(39)',
            'NullBooleanField': 'bool',
            'OneToOneField': 'integer',
            'PositiveIntegerField': 'integer UNSIGNED',
            'PositiveSmallIntegerField': 'smallint UNSIGNED',
            'SlugField': 'varchar(%(max_length)s)',
            'SmallIntegerField': 'smallint',
            'TextField': 'longtext',
            'TimeField': 'time',
            'UUIDField': 'char(32)',

    BooleanField(Field)
        - 布尔值类型

    NullBooleanField(Field):
        - 可以为空的布尔值

    CharField(Field)
        - 字符类型
        - 必须提供max_length参数， max_length表示字符长度

    TextField(Field)
        - 文本类型

    EmailField(CharField)：
        - 字符串类型，Django Admin以及ModelForm中提供验证机制

    IPAddressField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制

    GenericIPAddressField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
        - 参数：
            protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
            unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启刺功能，需要protocol="both"

    URLField(CharField)
        - 字符串类型，Django Admin以及ModelForm中提供验证 URL

    SlugField(CharField)
        - 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号）

    CommaSeparatedIntegerField(CharField)
        - 字符串类型，格式必须为逗号分割的数字

    UUIDField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证

    FilePathField(Field)
        - 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能
        - 参数：
                path,                      文件夹路径
                match=None,                正则匹配
                recursive=False,           递归下面的文件夹
                allow_files=True,          允许文件
                allow_folders=False,       允许文件夹

    FileField(Field)
        - 字符串，路径保存在数据库，文件上传到指定目录
        - 参数：
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件，默认django.core.files.storage.FileSystemStorage

    ImageField(FileField)
        - 字符串，路径保存在数据库，文件上传到指定目录
        - 参数：
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件，默认django.core.files.storage.FileSystemStorage
            width_field=None,   上传图片的高度保存的数据库字段名（字符串）
            height_field=None   上传图片的宽度保存的数据库字段名（字符串）

    DateTimeField(DateField)
        - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]

    DateField(DateTimeCheckMixin, Field)
        - 日期格式      YYYY-MM-DD

    TimeField(DateTimeCheckMixin, Field)
        - 时间格式      HH:MM[:ss[.uuuuuu]]

    DurationField(Field)
        - 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型

    FloatField(Field)
        - 浮点型

    DecimalField(Field)
        - 10进制小数
        - 参数：
            max_digits，小数总长度
            decimal_places，小数位长度

    BinaryField(Field)
        - 二进制类型

字段

字段

    null                数据库中字段是否可以为空
    db_column           数据库中字段的列名
    db_tablespace
    default             数据库中字段的默认值
    primary_key         数据库中字段是否为主键
    db_index            数据库中字段是否可以建立索引
    unique              数据库中字段是否可以建立唯一索引
    unique_for_date     数据库中字段【日期】部分是否可以建立唯一索引
    unique_for_month    数据库中字段【月】部分是否可以建立唯一索引
    unique_for_year     数据库中字段【年】部分是否可以建立唯一索引

    verbose_name        Admin中显示的字段名称
    blank               Admin中是否允许用户输入为空
    editable            Admin中是否可以编辑
    help_text           Admin中该字段的提示信息
    choices             Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
                        如：gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1)

    error_messages      自定义错误信息（字典类型），从而定制想要显示的错误信息；
                        字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date
                        如：{'null': "不能为空.", 'invalid': '格式错误'}

    validators          自定义错误验证（列表类型），从而定制想要的验证规则
                        from django.core.validators import RegexValidator
                        from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\
                        MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator
                        如：
                            test = models.CharField(
                                max_length=32,
                                error_messages={
                                    'c1': '优先错信息1',
                                    'c2': '优先错信息2',
                                    'c3': '优先错信息3',
                                },
                                validators=[
                                    RegexValidator(regex='root_\d+', message='错误了', code='c1'),
                                    RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'),
                                    EmailValidator(message='又错误了', code='c3'), ]
                            )

参数

    class UserInfo(models.Model):
        nid = models.AutoField(primary_key=True)
        username = models.CharField(max_length=32)
        class Meta:
            # 数据库中生成的表名称 默认 app名称 + 下划线 + 类名
            db_table = "table_name"

            # 联合索引
            index_together = [
                ("pub_date", "deadline"),
            ]

            # 联合唯一索引
            unique_together = (("driver", "restaurant"),)

            # admin中显示的表名称
            verbose_name

            # verbose_name加s
            verbose_name_plural

    更多：https://docs.djangoproject.com/en/1.10/ref/models/options/

元信息

    1.触发Model中的验证和错误提示有两种方式：
        a. Django Admin中的错误信息会优先根据Admiin内部的ModelForm错误信息提示，如果都成功，才来检查Model的字段并显示指定错误信息
        b. 调用Model对象的 clean_fields 方法，如：
            # models.py
            class UserInfo(models.Model):
                nid = models.AutoField(primary_key=True)
                username = models.CharField(max_length=32)

                email = models.EmailField(error_messages={'invalid': '格式错了.'})

            # views.py
            def index(request):
                obj = models.UserInfo(username='', email='uu')
                try:
                    print(obj.clean_fields())
                except Exception as e:
                    print(e)
                return HttpResponse('ok')

           # Model的clean方法是一个钩子，可用于定制操作，如：上述的异常处理。

    2.Admin中修改错误提示
        # admin.py
        from django.contrib import admin
        from model_club import models
        from django import forms

        class UserInfoForm(forms.ModelForm):
            username = forms.CharField(error_messages={'required': '用户名不能为空.'})
            email = forms.EmailField(error_messages={'invalid': '邮箱格式错误.'})
            age = forms.IntegerField(initial=1, error_messages={'required': '请输入数值.', 'invalid': '年龄必须为数值.'})

            class Meta:
                model = models.UserInfo
                # fields = ('username',)
                fields = "__all__"

        class UserInfoAdmin(admin.ModelAdmin):
            form = UserInfoForm

        admin.site.register(models.UserInfo, UserInfoAdmin)

扩展知识

2、连表结构

• 一对多：models.ForeignKey(其他表)

• 多对多：models.ManyToManyField(其他表)

• 一对一：models.OneToOneField(其他表)

    ForeignKey(ForeignObject) # ForeignObject(RelatedField)
        to,                         # 要进行关联的表名
        to_field=None,              # 要关联的表中的字段名称
        on_delete=None,             # 当删除关联表中的数据时，当前表与其关联的行的行为
                                        - models.CASCADE，删除关联数据，与之关联也删除
                                        - models.DO_NOTHING，删除关联数据，引发错误IntegrityError
                                        - models.PROTECT，删除关联数据，引发错误ProtectedError
                                        - models.SET_NULL，删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）
                                        - models.SET_DEFAULT，删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）
                                        - models.SET，删除关联数据，
                                                      a. 与之关联的值设置为指定值，设置：models.SET(值)
                                                      b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)

                                                        def func():
                                                            return 10

                                                        class MyModel(models.Model):
                                                            user = models.ForeignKey(
                                                                to="User",
                                                                to_field="id"
                                                                on_delete=models.SET(func),)
        related_name=None,          # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()
        related_query_name=None,    # 反向操作时，使用的连接前缀，用于替换【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
        limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时，提供的条件：
                                    # 如：
                                            - limit_choices_to={'nid__gt': 5}
                                            - limit_choices_to=lambda : {'nid__gt': 5}

                                            from django.db.models import Q
                                            - limit_choices_to=Q(nid__gt=10)
                                            - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
                                            - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
        db_constraint=True          # 是否在数据库中创建外键约束
        parent_link=False           # 在Admin中是否显示关联数据

    OneToOneField(ForeignKey)
        to,                         # 要进行关联的表名
        to_field=None               # 要关联的表中的字段名称
        on_delete=None,             # 当删除关联表中的数据时，当前表与其关联的行的行为

                                    ###### 对于一对一 ######
                                    # 1. 一对一其实就是 一对多 + 唯一索引
                                    # 2.当两个类之间有继承关系时，默认会创建一个一对一字段
                                    # 如下会在A表中额外增加一个c_ptr_id列且唯一：
                                            class C(models.Model):
                                                nid = models.AutoField(primary_key=True)
                                                part = models.CharField(max_length=12)

                                            class A(C):
                                                id = models.AutoField(primary_key=True)
                                                code = models.CharField(max_length=1)

    ManyToManyField(RelatedField)
        to,                         # 要进行关联的表名
        related_name=None,          # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()
        related_query_name=None,    # 反向操作时，使用的连接前缀，用于替换【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
        limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时，提供的条件：
                                    # 如：
                                            - limit_choices_to={'nid__gt': 5}
                                            - limit_choices_to=lambda : {'nid__gt': 5}

                                            from django.db.models import Q
                                            - limit_choices_to=Q(nid__gt=10)
                                            - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
                                            - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
        symmetrical=None,           # 仅用于多对多自关联时，symmetrical用于指定内部是否创建反向操作的字段
                                    # 做如下操作时，不同的symmetrical会有不同的可选字段
                                        models.BB.objects.filter(...)

                                        # 可选字段有：code, id, m1
                                            class BB(models.Model):

                                            code = models.CharField(max_length=12)
                                            m1 = models.ManyToManyField('self',symmetrical=True)

                                        # 可选字段有: bb, code, id, m1
                                            class BB(models.Model):

                                            code = models.CharField(max_length=12)
                                            m1 = models.ManyToManyField('self',symmetrical=False)

        through=None,               # 自定义第三张表时，使用字段用于指定关系表
        through_fields=None,        # 自定义第三张表时，使用字段用于指定关系表中那些字段做多对多关系表
                                        from django.db import models

                                        class Person(models.Model):
                                            name = models.CharField(max_length=50)

                                        class Group(models.Model):
                                            name = models.CharField(max_length=128)
                                            members = models.ManyToManyField(
                                                Person,
                                                through='Membership',
                                                through_fields=('group', 'person'),
                                            )

                                        class Membership(models.Model):
                                            group = models.ForeignKey(Group, on_delete=models.CASCADE)
                                            person = models.ForeignKey(Person, on_delete=models.CASCADE)
                                            inviter = models.ForeignKey(
                                                Person,
                                                on_delete=models.CASCADE,
                                                related_name="membership_invites",
                                            )
                                            invite_reason = models.CharField(max_length=64)
        db_constraint=True,         # 是否在数据库中创建外键约束
        db_table=None,              # 默认创建第三张表时，数据库中表的名称

字段以及参数

创建表时,顺序问题:

class UserType(models.Model):
    nid = models.AutoField(primary_key=True)
    caption = models.CharField(max_length=16)

class UserInfo(models.Model):
    name = models.CharField(max_length=32)
    email = models.EmailField(max_length=32)
    pwd = models.CharField(max_length=64)
    user_type = models.ForeignKey(UserType)        # UserType已存在时

#*********************************************

class UserInfo(models.Model):
    name = models.CharField(max_length=32)
    email = models.EmailField(max_length=32)
    pwd = models.CharField(max_length=64)
    user_type = models.ForeignKey("UserType")     #UserType 不存在时 加上双引号

class UserType(models.Model):
    nid = models.AutoField(primary_key=True)
    caption = models.CharField(max_length=16)

二、操作表

1、基本操作

    # 增
    #
    # models.Tb1.objects.create(c1='xx', c2='oo')  增加一条数据，可以接受字典类型数据 **kwargs
    #
    # tb1_dict = {'a1':'123',...}
    # models.Tb1.objects.create(**tb1_dict)

    # obj = models.Tb1(c1='xx', c2='oo')
    # obj.save()

    # 查
    #
    # models.Tb1.objects.get(id=123)         # 获取单条数据，不存在则报错（不建议）
    # models.Tb1.objects.all()               # 获取全部
    # models.Tb1.objects.filter(name='seven') # 获取指定条件的数据

    # 删
    #
    # models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据

    # 改
    # models.Tb1.objects.filter(name='seven').update(gender='0')  # 将指定条件的数据更新，均支持 **kwargs
    # obj = models.Tb1.objects.get(id=1)
    # obj.c1 = '111'
    # obj.save()                                                 # 修改单条数据

2、进阶操作（了不起的双下划线）

利用双下划线将字段和对应的操作连接起来

        # 获取个数
        #
        # models.Tb1.objects.filter(name='seven').count()

        # 大于，小于
        #
        # models.Tb1.objects.filter(id__gt=1)              # 获取id大于1的值
        # models.Tb1.objects.filter(id__gte=1)              # 获取id大于等于1的值
        # models.Tb1.objects.filter(id__lt=10)             # 获取id小于10的值
        # models.Tb1.objects.filter(id__lte=10)             # 获取id小于10的值
        # models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值

        # in
        #
        # models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
        # models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in

        # isnull
        # Entry.objects.filter(pub_date__isnull=True)

        # contains
        #
        # models.Tb1.objects.filter(name__contains="ven")
        # models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
        # models.Tb1.objects.exclude(name__icontains="ven")

        # range
        #
        # models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and

        # 其他类似
        #
        # startswith，istartswith, endswith, iendswith,

        # order by
        #
        # models.Tb1.objects.filter(name='seven').order_by('id')    # asc
        # models.Tb1.objects.filter(name='seven').order_by('-id')   # desc

        # group by
        #
        # from django.db.models import Count, Min, Max, Sum
        # models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
        # SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"

        # limit 、offset
        #
        # models.Tb1.objects.all()[10:20]

        # regex正则匹配，iregex 不区分大小写
        #
        # Entry.objects.get(title__regex=r'^(An?|The) +')
        # Entry.objects.get(title__iregex=r'^(an?|the) +')

        # date
        #
        # Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
        # Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))

        # year
        #
        # Entry.objects.filter(pub_date__year=2005)
        # Entry.objects.filter(pub_date__year__gte=2005)

        # month
        #
        # Entry.objects.filter(pub_date__month=12)
        # Entry.objects.filter(pub_date__month__gte=6)

        # day
        #
        # Entry.objects.filter(pub_date__day=3)
        # Entry.objects.filter(pub_date__day__gte=3)

        # week_day
        #
        # Entry.objects.filter(pub_date__week_day=2)
        # Entry.objects.filter(pub_date__week_day__gte=2)

        # hour
        #
        # Event.objects.filter(timestamp__hour=23)
        # Event.objects.filter(time__hour=5)
        # Event.objects.filter(timestamp__hour__gte=12)

        # minute
        #
        # Event.objects.filter(timestamp__minute=29)
        # Event.objects.filter(time__minute=46)
        # Event.objects.filter(timestamp__minute__gte=29)

        # second
        #
        # Event.objects.filter(timestamp__second=31)
        # Event.objects.filter(time__second=2)
        # Event.objects.filter(timestamp__second__gte=31)

一对多,实例使用表结构:

class UserType(models.Model):
    nid = models.AutoField(primary_key=True)
    caption = models.CharField(max_length=16)

class UserInfo(models.Model):
    name = models.CharField(max_length=32)
    email = models.EmailField(max_length=32)
    pwd = models.CharField(max_length=64)
    user_type = models.ForeignKey(UserType)

查询:

ret = models.UserType.objects.all()
print(ret,type(ret))
# <QuerySet [<UserType: UserType object>, <UserType: UserType object>, ]> <class 'django.db.models.query.QuerySet'>
# [对象,...,...]   => 得到对象列表
for item in ret:
    print(item,item.nid,item.caption)

ret = models.UserType.objects.all().values('nid')# <QuerySet [{'nid': 1}, {'nid': 2}, {'nid': 3}]>
# [字典,...,...] 

ret = models.UserType.objects.all().values_list('nid')# <QuerySet [(1,), (2,), (3,)]>
# [元组,...,...] 

连表查询:

ret = models.UserInfo.objects.all()
for item in ret:
    print(item.name,item.user_type.caption)     #通过Userinfo表的外键user_type去查询了UserType表
# alex 管理员
# eric 普通用户

ret = models.UserInfo.objects.all().values('id','user_type__caption')
# <QuerySet [{'user_type__caption': '管理员', 'id': 1}, {'user_type__caption': '普通用户', 'id': 2}]>

# 正向查找:
ret = models.UserInfo.objects.filter(id=1)
ret = models.UserInfo.objects.filter(user_type__caption='管理员')
# 返回 [对象,...,...] 列表
# 可以通过 .来访问该对象的属性

ret = models.UserInfo.objects.filter(user_type__caption='管理员').values('name','user_type__caption')
# <QuerySet [{'name': 'alex', 'user_type__caption': '管理员'}]>
# 返回 [字典,...,...] 列表

反向查找:

ret = models.UserType.objects.filter(caption='管理员').first()
print(ret)
# UserType object 

obj = ret.userinfo_set.all()
obj = ret.userinfo_set.filter(id=1)
# <QuerySet [<UserInfo: UserInfo object>]>

for item in obj:
    print(item.name,item.email)

# 方法二:
ret = models.UserType.objects.all().values('nid','caption','userinfo__name')
# 以UserType表为主, 连接UserInfo表 , 不存在的为 None
# <QuerySet [{'caption': '管理员', 'userinfo__name': 'alex', 'nid': 1}, {'caption': '管理员', 'userinfo__name': 'eric', 'nid': 1}, {'caption': '普通用户', 'userinfo__name': None, 'nid': 2}, {'caption': '超级管理员', 'userinfo__name': None, 'nid': 3}]>

ret = models.UserType.objects.filter(nid=1,userinfo__name='alex')
# 返回 UserType对象列表
# <QuerySet [<UserType: UserType object>]>

多对多,实例使用表结构:

class Host(models.Model):
    hid = models.AutoField(primary_key=True)
    hostname = models.CharField(max_length=32)
    ip = models.CharField(max_length=32)
    #h2g = models.ManyToManyField(Group)

class Group(models.Model):
    gid = models.AutoField(primary_key=True)
    name = models.CharField(max_length=16)
    h2g = models.ManyToManyField(Host)

# ****************************************
# 填充数据:
models.Host.objects.create(hostname='alex1',ip='1.1.1.1')
models.Host.objects.create(hostname='alex2',ip='1.1.1.2')
models.Host.objects.create(hostname='alex3',ip='1.1.1.3')
models.Host.objects.create(hostname='alex4',ip='1.1.1.4')
models.Host.objects.create(hostname='alex5',ip='1.1.1.5')
models.Host.objects.create(hostname='alex6',ip='1.1.1.6')
models.Host.objects.create(hostname='alex7',ip='1.1.1.7')

models.Group.objects.create(name='运营部')
models.Group.objects.create(name='运维部')
models.Group.objects.create(name='人事部')
models.Group.objects.create(name='开发部')
models.Group.objects.create(name='后勤部')

情况一: 关系表(自动创建)

添加:

# 一个一个添加
h1 = models.Host.objects.get(hid=1)
g1 = models.Group.objects.get(gid=1)
g1.h2g.add(h1)

# 批量添加(多台机器分给一个组)
g1 = models.Group.objects.get(gid=1)
h = models.Host.objects.filter(hid__gt=3)
g1.h2g.add(*h)

# 一台机器分给多个组
h1 = models.Host.objects.get(hid=5)
g = models.Group.objects.filter(gid__gt=3)
h1.group_set.add(*g)

可以发现在 Host表中,隐含了一个 group_set

class Host(models.Model):
    hid = models.AutoField(primary_key=True)
    hostname = models.CharField(max_length=32)
    ip = models.CharField(max_length=32)
    group_set = ....

class Group(models.Model):
    gid = models.AutoField(primary_key=True)
    name = models.CharField(max_length=16)
    h2g = models.ManyToManyField(Host)    # 只生成3列

删除:

h = models.Host.objects.get(hid=1)
h.group_set.remove(*models.objects.filter(gid__gt=1))  # 关系表,删除 hid等于1 , gid 大于1的记录
h.group_set.all().delete()   # 关系表,group数据表的数据也删除了!!!

修改:

h = models.Host.objects.get(hid=1)
h.group_set.set(models.Group.objects.filter(gid=3))
# 关系表中, hid = 1 的所有行, 只剩下 , gid = 3   ,其余删除!
# 符合保留,不符合删除!. (仅限制在 符合hid=1 的关系表的数据行中!!)

h.group_set.get_or_create(name='技术部')
h.group_set.update_or_create(name='技术部')
# 在group添加新的记录,然后关系表也添加记录!

补充:

# 传对象
group= models.Group.objects.get(gid=1)
h1.group_set.add(group)

#　传值
h1.group_set.add(1)
h1.group_set.add(*[2,3])
#　可以直接添加id 

情况二: 关系表(自己创建) 需要自己添加唯一约束!

class HostToGroup(models.Model):
    hgid = models.AutoField(primary_key=True)
    host_id = models.ForeignKey("Host")
    group_id = models.ForeignKey("Group")
    status = models.IntegerField()
    class Meta:
        unique_together = [
            ("host_id", "group_id"),
        ]

class Host(models.Model):
    hid = models.AutoField(primary_key=True)
    hostname = models.CharField(max_length=32)
    ip = models.CharField(max_length=32)

class Group(models.Model):
    gid = models.AutoField(primary_key=True)
    name = models.CharField(max_length=16)

7 Django Template

　　模版的组成：HTML代码＋逻辑控制代码

模版的渲染：

>>> python manange.py shell  (进入该django项目的环境)
>>> from django.template import Context, Template
>>> t = Template('My name is {{ name }}.')
>>> c = Context({'name': 'Stephane'})
>>> t.render(c)
'My name is Stephane.'

逻辑控制代码：

1、变量

{{ item }}

2、句点号

# 后端数据 :
s = 'hello'
s1 = [1,2]
s2 = { 'user':'eriic' }
s3 = time.localtime()
s4 = Foo( 'eroiic' , 20 )

# 页面取值 :
{{ obj.1 }}       # 索引取值
{{ obj.user }}    # 根据字段key取值
{{ obj.year }}    # 根据属性取值
{{ obj.name }}    # 取类中字段

3、{% if %} 的使用

　　不允许同一标签里同时出现and和or，否则逻辑容易产生歧义

{% if num >= 100 and 8 %}

{% elif num < 100%}
    <p>num小于100</p>

{% else %}
    <p>num等于100</p>

{% endif %}

4、{% for %}的使用

{% for i in obj %}
# obj 为列表 , i 为值
    {{ forloop.counter }}    # 模拟索引 , 从1开始算
    {{ forloop.counter0 }}   # 模拟索引 , 从0开始算
    {{ forloop.revcounter }} # 反序索引 , 从最后开始算

# obj 为字典 , i 为key , 或者改为: obj.keys obj.values obj.items 进行循环

{% endfor %}

5、Filter（过滤器）

语法格式：      {{obj|filter:param}}

   # 1  add          ：   给变量加上相应的值
   #
   # 2  addslashes   :    给变量中的引号前加上斜线
   #
   # 3  capfirst     :    首字母大写
   #
   # 4  cut          ：   从字符串中移除指定的字符
   #
   # 5  date         ：   格式化日期字符串
   #
   # 6  default      ：   如果值是False,就替换成设置的默认值，否则就是用本来的值
   #
   # 7  default_if_none:  如果值是None，就替换成设置的默认值，否则就使用本来的值

#实例:

#value1="aBcDe"
{{ value1|upper }}

#value2=5
{{ value2|add:3 }}

#value3='he  llo wo r ld'
{{ value3|cut:' ' }}

#import datetime
#value4=datetime.datetime.now()
{{ value4|date:'Y-m-d' }}

#value5=[]
{{ value5|default:'空的' }}      # 设置默认值

#value6='<a href="#">跳转</a>'
{{ value6 }}                    # 字符串形式在页面显示

{% autoescape off %}            # 渲染成浏览器能解析的标签
  {{ value6 }}
{% endautoescape %}

{{ value6|safe }}               # 效果同上

{{ value6|striptags }}

#value7='1234'
{{ value7|filesizeformat }}     # obj 数据的大小 ~kb
{{ value7|first }}              # 取第一个值
{{ value7|length }}             #  得到长度
{{ value7|slice:":-1" }}        #  切片

#value8='http://www.baidu.com/?a=1&b=3'
{{ value8|urlencode }}          # 进行url编码

value9='hello I am eriic'
{{ value9|truncatechars:'' }}   # 按字符截断   总显示3个点, 占用3个位置!
{{ value9|truncatewords:'' }}   # 按单词截断

Demo

6、{%csrf_token%}：csrf_token标签 ， 放到form 表单里

7、{% with %}:用更简单的变量名替代复杂的变量名

{% with total=fhjsaldfhjsdfhlasdfhljsdal %}
{{ total }}
{% endwith %}

8、{% verbatim %}: 禁止变量被渲染

{% verbatim %}
    {{ hello }}              # 页面直接显示 {{ hello }}
{% endverbatim %}

9、{% load %}: 加载标签库

自定义filter和simple_tag：

0、现在setting中installed_apps 添加当前的app项目！

1、app项目下创建templatetags

2、创建任意文件 如 my_tags.py

3、引入类，自定义函数

from django import template
from django.utils.safestring import mark_safe

register = template.Library()   #register的名字是固定的,不可改变

@register.filter
def filter_multi(v1,v2):
    return  v1 * v2

@register.simple_tag
def simple_tag_multi(v1,v2):
    return  v1 * v2

@register.simple_tag
def my_input(id,arg):
    result = "<input type='text' id='%s' class='%s' />" %(id,arg,)
    return mark_safe(result)

4、HTML中使用

{% load my_tags %}    # 引入外部文件

使用:
{% my_add 100 101 %}      # simple_tag 可以传入多个参数 , 不能用于if语句
{{ obj | my_add:num2 }}   # filter 最多两个参数 , if 语句可以跟filter

模版继承：

include 模板标签  {% include %}

　　该标签允许在（模板中）包含其它的模板的内容。

　　标签的参数是所要包含的模板名称，可以是一个变量，也可以是用单/双引号硬编码的字符串。

　　每当在多个模板中出现相同的代码时，就应该考虑是否要使用 {% include %} 来减少重复。

extend(继承)模板标签

　　减少共用页面区域所引起的重复和冗余代码

　　方法一：解决该问题的传统做法是使用 服务器端的 includes ，你可以在 HTML 页面中使用该指令将一个网页嵌入到另一个中。

　　方法二：模板继承就是先构造一个基础框架模板，而后在其子模板中对它所包含站点公用部分和定义块进行重载。

#1 -- base.html     存放的是页面共有的代码 !
....
{% block content %}      # 非共有部分用 block代替 ,  block名字自定义
    ...
{% endblock %}

#2 -- order.html    只保留非共有部分的代码 !
{% extend 'base.html' %}   # 继承外部文件
{% block cotent %}         # 非共有部分的代码 ! , 会对base.html中的block进行替换 !!
    ....
{% endblock %}             # 没有对应上的block 会在base中原样显示!

# 如果需要同时显示父级的代码 和自己代码 可以嵌套使用
{{ block.super }}

更多见文档：https://docs.djangoproject.com/en/1.10/ref/templates/language/