# Django 跨域请求

同源策略首先基于安全的原因，浏览器是存在同源策略这个机制的，同源策略阻止从一个源加载的文档或脚本获取或设置另一个源加载的文档的属性。
而我们要跳过策略，也就是非要跨域请求，那么久需要通过JSONP或者CORS来实现



## 什么是JSONP？

首先提一下json这个概念，json是一种轻量级的数据传输格式，被广泛应用于当前web应用中。JSON格式数据的编码和解析基本在所有主流语言中都被实现，所以现在大部分前后端分离的架构都以JSON格式进行数据的传输。

	那么什么是JSONP呢？

	在ajax中，不允许请求非同源的URL就可以来，比如www.a.com下的一个页面，其中的ajax请求是不允许访问www.b.com/c.js这样一个页面的。
	
	JSONP就是用来解决跨域请求问题的，那么具体是怎么实现的？
**JSONP原理**

ajax请求受同源策略影响，不允许进行跨域请求，而script标签src属性中的链接却可以访问跨域的js脚本，利用这个特性，服务端不再返回JSON格式的数据，而是返回一段调用某个函数的js代码，在src中进行了调用，这样实现了跨域。JSONP的具体实现
127.0.0.1:8000中的index.html
```html
<!DOCTYPE html>
<html>
<head>
    <title>GoJSONP</title>
</head>
<body>
 $(".jsonp_test").click(function () {
    $.ajax({
        url:"http://127.0.0.1:8008/service/",
        type:"get",
        dataType:"jsonp",     // 伪造ajax  基于script
        jsonp: 'callbacks',
        //jsonpCallback:"alex",
        success:function (data) {
            console.log(data)
        }
    })
})
<button class='jsop_test'>测试</button>
</body> </html>
```
127.0.0.1:8080的views
```python
import json
def jsonp_test(request): 
    func=request.GET.get("callbacks") #获取请求的callbacks参数
    info={"name":"fuyong","age":18} #定义数据
    return HttpResponse(" ('%s')"%(func,json.dumps(info))) #传json对象总结
```
一句话就是利用script标签绕过同源策略，获得一个类似这样的数据。ajax里边的callback本质上是（伪装成scripy标签src属性发送请求的方式）发送一个回调方法，参数data就是想得到的json数据。
## corscors定义
**Cross-origin Resource Sharing(CORS)跨来源资源共享是一份浏览器技术的规范，提供了web服务从不同域传来沙盒脚本的方法，以避开浏览器的同源策略，是JSONP模式的现代版。与JSONP不同，CORS除了GET要求方法以外也支持其他的HTTP请求。用CORS可以让网页设计师用一般的XMLHttpRequest，这种方法的错误处理比JSONP要来的好。另一方面，JSONP可以在不支持CORS的老旧浏览器上运作，现代的浏览器都支持CORS。**
## cors和jsonp的对比
* JSONP只能实现GET请求，而CORS支持所有类型的HTTP请求
* 使用CORS，开发者可以使用普通的XMLHttpRequest发起请求和获得数据，比起JSONP有更好的错误处理
* JSONP主要被老的浏览器支持，它们往往不支持CORS，而绝大多数现代浏览器都已经支持了CORS。

## 简单请求和复杂请求
简单请求
1. http方法这三种方法之一：HEAD、GET、POST
2. HTTP头消息不超出以下字段：Accept、Accept-language、Content-Language、Last-Event-ID，且Content-Type只能为下列类型中的某一个:
	
	* application/x-www-from-urlencoded
	* multipart/form-data
	* text/plain.

任何不满足上述要求的请求，都会被认为是复杂请求。

复杂请求回先发出一个预请求—预检，OPTIONS请求。cors实现思路
cors背后的基本思想是使用自定义的http头部允许浏览器和服务器相互了解对方，从而决定请求或相应成功与否。

例如localhost:63343通过ajax请求http:192.16810.61:8080服务器资源时就会出现如下异常：

其实数据已经获取到了，但是由于同源策略的限制给禁止了，提示说header里没有access-Control-Allow-Origin，那么，我们在发送响应的时候只需要给header加上这个参数就可以了。通过中间件实现cors

第一步，准备中间件
```python
from django.utils.deprecation import MiddlewareMixin 
class MyCors(MiddlewareMixin): 
	def process_response(self, request, response): # 如下，等于'*'后，便可允许所有简单请求的跨域访问 response['Access-Control-Allow-Origin'] = '*' # 判断是否为复杂请求 if request.method == 'OPTIONS': response['Access-Control-Allow-Headers'] = 'Content-Type' response['Access-Control-Allow-Methods'] = 'PUT,PATCH,DELETE' return response
```
第二步 视图文件
```python
from django.http import HttpResponse from rest_framework.views import APIView 
class TestView(APIView): 
	def get(self, request): 
		return HttpResponse("这是GET请求的数据") 
	def post(self, request): 
		return HttpResponse("这是POST请求的数据") 
	def put(self, request): 
		return HttpResponse("这是PUT请求的数")
settings.py

MIDDLEWARE = [
   .....
 
    'xxx.cors.CORSMiddleware',  # xxx为cors.py所在包的目录
]
```

django的跨域请求

视图层的主要工作是衔接HTTP请求、Python程序、HTML模板
## 1. URL映射
URL分发映射配置可以被看做Django项目的入口配置，通过URL dispatcher可以指定用户的每一个访问的后台Python处理函数是什么



### 1.1 普通URL映射
每个Django项目都有一个urls.py文件用于维护URL dispatcher，例如:
```python
from django.conf.urls import url

urlpatterns = [
    url(r'^year/2015/$',views.moment_2015),
    url(r'^year/([0-9]{4})/$', views.year_moments),
    url(r'^month/([0-9]{4})/([0-9]{2})/$',views.month_moments),
    url(r'^single/([0-9]{4})/([0-9]{2})/([0-9]+)/',views.single),
]
```
解析：
* 只匹配year/2015.路径调用的是views.py中的moment_2015,moment_2015(request)
* 匹配year/XXXX，year_moments(request,xxxx)
* 匹配year/xxxx/xx  month_moments(request,xxxx,xx)
* 匹配single/xxxx/xx/zz single(request,xxxx,xx,zz)
### 1.2 正则表达式
正则表达式速查表

|  符号   | 描述  |示例 |
|  ----  | ----  |----  |
|\|将下一个字符标记为一个特殊字符|"\n" 匹配一个换行符，"\\"匹配"\"  "\("匹配"("|
|^|输入字符串的开始位置|"^abc"，以abc开头|
|$|输入字符串的结束位置|"abc$",以abc结束|
|*|前面的子表达式零次或多次|"2*"匹配 空 2 22 222|
|+|前面的子表达式一次或多次|"2+"匹配 2 22|
|?|前面的子表达式零次或一次|"2?"匹配 空或2|
|{n}|n是一个非负整数，只匹配确定的n次||
|{n,}|n是一个非负整数,至少匹配n次||
|{n,m}|m和n均是非负整数，其中n<=m||
|.|匹配除\n外的任意单个字符||
|x|y|匹配x或y||
|[xyz]|字符集合，匹配所包含的任意一字符||
|[^xyz]|负值字符集合，匹配未包含的任意字符||
|[-]|字符范围||
|[^-]|负值字符范围，匹配不在指定范围内的任意字符||


快捷正则表达式符号

|  符号   | 描述  |示例 |
|  ----  | ----  |----  |
|\b|一个单词边界|空格、TAB、换行等|
|\d|一个数字字符|等价[0-9]|
|\D|一个非数字字符|等价[^0-9]|
|\f|一个换页符||
|\n||换行符|
|\r|回车符||
|\s|任意空白字符||
|\S|任意非空白字符||
|\t|制表符||
|\v|垂直制表符||
|\w|包括下划线的任意单词字符||
|\W|任意非单词字符||

### 1.3 命名URL参数映射
定义方式是:""?P"


## 2. 视图函数
## 3. 模板语法

3. 视图层

## 1. 基本操作
### 1.1 模型类定义
```
from django.db import models

class ModelName(models.Model):
    field1 = models.xxField(……)
    field2 = models.xxField(……)
    
    class Meta:
        db_table = ……
        other_metas = ……
```



解析:
* 所有Django模型继承自django.db.Model类
* 通过其中的类属性定义模型字段，模型字段必须是某种models.XXField类型
* 通过模型类的Meta子类定义模型元数据，比如数据库表名、数据库默认排序方式等

**Meta类的属性**由Django预定义，常用的Meta类属性如下:

* abstract:  True or False  标识本类是否为[抽象基类](https://www.jb51.net/article/225624.htm)
* app_label:  定义本类所属的应用，比如app_lable='app'
* db_table:   映射的数据表名，比如db_table='moments'

    > 如果Meta中不提供db_table字段，则Django会为模型自动生成数据表名，生成的格式为"应用名_模型名"
  
* db_tablespace: 映射的表空间名称。表空间的概念只在某些数据库如Oracle中存在，不存在表空间概念的数据库将忽略本字段
* default_related_name:  定义本模型的反向关系引用名称，默认与模型名一致。
* get_latest_by:   定义按那个字段值进行排列以获得模型的开始或结束的记录，本属性通常指向一个日期或整型的模型字段
* managed:   True or False ，定义Django的manage.py 命令行工具是否管理本模型。本属性默认为True，如果将其设为False,则运行python manage.py migrate时不会在数据库中生成本模型的数据表，所以需要手工维护数据库的定义
* order_with_resect_to: 定义本模型可以按照某外检引用的关系排序
* ordering: 本模型记录的默认排序字段，可以设置多个字段，默认以升序排列，如果以降序排列则需要再字段名钱加"负号",比如
```python
class Meta:
    ordering=['user_name','-pub_date']

```

* default_permissions: 默认操作权限，默认为default_permisstions=('add','change','delete')
* proxy:  True or False , 本模型所有继承自本模型的子模型是否为代理模型
* required_db_features:   定义底层数据库有所必须具备的特性。比如require_db_features=['gis_enabled'],只将本数据模型生成在gis_enabled特性的数据库中
* required_db_vendor: 定义底层数据库的类型，比如SQLite、 PostgreSQL、 MySQL、Oracle，如果定义了本属性，则模型只能在其声明的数据库中被维护
* unique_together:   用来设置的不重复的字段组合，必须唯一（可以将多个字段做联合唯一）
```python
class Meta:
    unique_together = (("user_name","pub_date"))
# 上述意识是定义每个user_name在同一个pub_date中只能有一条数据表记录。
```
* index_together:  定义联合索引的字段，可以设置多个：
```
class Meta:
    index_together = [["pub_date","deadline"],]
    
```
* verbose_name: 知名一个易于理解和表述的单数形式的对象名称。如果这个值没有被设置，则Django将会使用该model的类名的粉刺形式作为对象的表述名
* Verbose_name_plural: 指明一个易于理解和表述的复数形式的对象名称

### 1.2 普通字段类型
普通字段是指模型类中除外键关系外的数据字段属性，所有数据字段的属性必须集成自抽象类django.db.models.Field，开发者可以定义自己的继承自该类的字段类型。

|  字段类型   | 说明  |
|  ----  | ----  |
| AutoField  | 一个自动递增的整型字段，添加记录时他会自动增长。通常只用于充当数据表的主键，如果没有，django会自动添加一个 |
| BigIntegreField  | 64位整型字段 |
| BinaryField  | 二进制数据字段，只能通过bytes对其进行赋值 |
| BooleanField  | 布尔字段，相对应的Html标签是<input type="checkbox"> |
| CharField  | 字符串字段，用于较短的字符串，相对应的Html标签是单行输入框 input type="text">" |
| TextField  | 大容量文本字段，相对应的HTML标签是多行编辑框  textarea>" |
| CommaSeparatedIntegerField  | 用于存放分号分割的整数值，相对于普通的CharField,它有特殊的表单数据验证要求 |
| DateField  | 日期字段，相对应的HTML标签是 input type="text">、一个JavaScript日历和一个"Today"快捷键。有以下额外的可选参数:auto_now,当对象被保存时，将该字段的指设置为当前时间:auto_now_add，当对象首次被创建时，将该字段的值设置为当前时间|
| DateTimeField  | 类似于DateField，同时支持时间的输入 |
| DurationField  | 存储时间周期，用python的timedelta类型构建 |
| EmailField  | 一个带有检查的Email合法性的CharField |
| FileField  | 一个文件上传字段。在定义本字段时必须传入参数upload_to,用户保存上载文件的服务器文件系统的路径。这个路径必须包含strftime formatting，该格式将被上载的文件date/time替换 |
| FilePathField  | 按目录限制规则选择文件，定义本字段时必须传入参数path |
| FloatFiled  | 浮点型字段，定义本字段时必须传入参数max_digits和decimal_places，用以定义总位数(不包括小数点和符号)和小整位数 |
| ImageField  | 类似FileField，同时验证上传对象是否是一个合法图片。他有两个可选参数，即height_field和width_field，如果提供这两个参数，则图片将按照提供的高度和宽度保存，该字段要求安装Python Imaging |
| IntegerField  | 用于保存一个整数 |
| IPAddressField  | 一个字符串形式的IP地址 |
| NullBooleanField  | 类似于BooleanField，但比其多一个None选项 |
| PhoneNumberField  | 带有美国风格的电话号码校验 |
| PositiveIntegerField  | 只能输入非负数的IntegerField |
| SlugField  | 只包含字母、数字、下划线和连字符的输入字段，它通常用于URL |
| SmallIntegerField  | 类似于IntegerField，但只具有较小的输入范围，具体范围依赖所使用的数据库 |
| TimeField  | 时间字段，类似于DateTimeField，但只能表达和输入时间 |
| URLField  | 用于保存URL |
| USSSateField  | 美国州的缩写字段 |

### 1.3 常用字段参数 
每个字段类型都有一些特定的HTML标签和表单验证参数，比如height_field、path等。但同时有一些每个字段都可以设置的公共参数，比如：
* primary_key:   通过primary_key参数可以设置一个模型的主键字段
* null:    定义是否允许相对应的数据库字段为Null，默认设置为False
* blank:   定义字段是否可以为空。读者需要区分blank与null的区别，null是一个数据库的中的非空约束；而blank用于字段的HTML表单验证，即判断用户是否可以不输入数据。
* choices: 定义字段的可选值。本字段的值是一个包含二维元素的元组。元组的每个元素中的第1个值是实际存储的值，第2个值是HTML页面页面中进行选择时显示的值。
```python
from django.db import models

LEVELS=(
    ('1','very good'),
    ('2','Good'),
    ('3','Normal'),
    ('4','Bad'),
)

class Comment(models.Model):
    id = models.AutoField(primary_key=True)
    level = models.CharField(max_length=1,choices=LEVELS)
```
* default:   设定默认值，例如default='please input here'
* help_text:   HTML页面中输入控件的帮助字符串
* unique:   是否为字段定义数据库的唯一约束     

> 除了这些有名称的字段参数，django中的所有Field数据类型还有一个无名参数，可以设置该字段在HTML页面中的人性化名称，比如:
```python
class Comment(models.Model):
    id = models.AutoField(primary_key=True)
    level = models.CharField("请为本条信息评级",max_length=1,choices=LEVELS)
```

### 1.4 基本查询
```python
from django.db import models

class Comment(models.Model):
    id = models.AutoField(primary_key=True)
    headline = models.CharField(max_length=255)
    body_text = models.TextField()
    pub_date = models.DateField()
    n_visits = models.IntegerField()

    def __str__(self):

        return self.headline
```
查询Comment模型的所有数据
``` 
Comment.objects.all()
```
获取单条记录；
```
Comment.objects.get(id_exact=1)
```
排序操作
```
Comment.objects.order_by('head_line')
```
Django两种过滤器用于筛选记录：
* filter(*kwargs)   返回符合筛选条件的数据集
* exclude(**kwargs)   返回不符合筛选条件的数据集

多个filter和exclude可以连接在一起查询
  
``` 
Comment.objects.filter(pub_date__year=2015)
```

> 其中的pub_date__year,它不是模型中定义的一个字段，而是Django的定义的一种独特的字段查询(field lookup)表达方式，本例中该查询的含义是"pub_date字段的year属性为2015".
 

field lookup基本的表现形式是 
> 字段名称__谓词

**常见的谓词有如下**

|  谓词   | 含义  |示例 |  等价的SQL语句   |
|  ----  | ----  |----  |----  |
| exact | 精确等于 |Comment.objects.filter(id__exact=14)  |select * from Comment where id=14  |
| iexact  | 大小写不敏感的等于 | Comment.objects.filter(headline__iexact='I like this') |select * from Comment where upper(headline)='I LIKE THIS'  |
| contains |模糊匹配  | Comment.objects.filter(headline__contains="good") |select * from Comment where headline like "%good%"  |
| in  | 包含 | Comment.objects.filter(id__in=[1,5,9]) |select * from Comment where id in (1,5,9)  |
| gt/gte/lt/lte |大于  | Comment.objects.filter(n_visits__gt=30) |select * from Comment where n_visits >30  |
|startswith  | 以……开头 | Comment.objects.filter(body_text__startwith="Hello") |select * from Comment where body_text like 'Hello%'  |
|endswith  |以……结尾  | Comment.objects.filter() |  |
|range  | 在……范围内 | Comment.objects.filter(pub_date__range=(start_date,end_date)) |  |
|year/month/day/week_day  | 年/月/日/星期几 | Comment.objects.filter(pub_date__year=2015) |  |
|isnull  | 是否为空 | Comment.objects.filter(pub_date__isnull=True) | select * from Comment where pub_date is NUll |


### 1.5 数据保存与删除
与传统SQL相比，Django的一个较大优势是定义了一个统一的方法save()，用于完成模型的Insert和Update模型。在执行模型实例的save()函数时，Django会根据模型的主键，判断记录是否存在，如果存在则执行Update操作，否则执行Delete操作。比如:
```shell
# 新增记录
newObj = Comment(headline="I like this",body_text="……",pub_date=datetime.datetime.now(),n_visits=0)
newObj.save()


# 打印新增对象的主键
print newObject.id

# 修改记录数据
newObj.body_text="This comment is just what I want"
newObj.save()

# 打印主键，与新增后的id相同
print newObj.id


# 删除所有2014的记录
Comment.objects.filter(pub_date__year=2014).delete()

# 删除id=3的单条记录
Comment.objects.get(id=3).delete()
```

## 2. 关系操作
利用数据表之间的关系进行数据建模和业务开发是关系数据库最主要的功能。
### 2.1 一对一关系
在SQL语言中，一对一关系通过在两个表之间定义相同的主键来完成。如下代码在模型Account和Contact之间定义了一对一关系 
```python
from django.db import models

class Account(models.Model):
    user_name = models.CharField(max_length=80)
    password = models.CharField(max_length=255)
    reg_date = models.DateField()

    def __unicode__(self):
        return "Account :%s"% self.user_name

class Contact(models.Model):
    account = models.OneToOneField(Account,on_delete=models.CASCADE,primary_key=True)
    zip_code = models.CharField(max_length=10)
    address = models.CharField(max_length=80)
    mobile = models.CharField(max_length=20)

    def __unicode__(self):
        return "%s, %s"%(self.account.user_name,self.mobile)
```
* on_delete参数定义当被关联模型的记录被删除时本模型的记录如何处理，models.CASCADE用于定义此时本记录(Contact)也被删除
* 每个模型的__unicode__()函数用于定义模型的显示字符串
```shell
>>> a1 = Account(user_name="david")
>>> a1.save()
>>> a2 = Account(user_name="Rose")
>>> a2.save()

# 用a1初始化Contact的account字段，并保存
>>> c1 = Contact(account=a1,mobile="13912345000")
>>> c1.save()
>>> print a1
<Account: david>
>>> print c1
<Contact: david,13912345000>
>>> print a1.contact
<Contact: david,13912345000>
>>> print c1.account
<Account: david>
```

### 2.2 一对多关系
在SQL语言中，1：N关系通过在"附表"中设置到"主表"的外键引用来完成，在Django模型层，可以用models.ForeignKey类型的字段定义外键
```python
from django.db import models

class Account(models.Model):
    user_name = models.CharField(max_length=80)
    password = models.CharField(max_length=255)
    reg_date = models.DateField()

    def __unicode__(self):
        return "Account :%s"% self.user_name

class Contact(models.Model):
    account = models.ForeignKey(Account,on_delete=models.CASCADE)
    zip_code = models.CharField(max_length=10)
    address = models.CharField(max_length=80)
    mobile = models.CharField(max_length=20)

    def __unicode__(self):
        return "%s, %s"%(self.account.user_name,self.mobile)
```
对模型的操作代码:
```shell
>>> a1 = Account(user_name="Rose")
>>> a1.save()
>>> c1 = Contact(account=a1,mobile="13912345001")
>>> c1.save()
>>> c2 = Contact(account=a1,mobile="13912345002")
>>> c2.save()

>>>print c1.account
<Account: Rose>
>>>print c2.account
<Account: Rose>
>>>print a1.contact_set
[<Contact: Rose, 13912345001>,<Contact: Rose, 13912345002>]
>>>print a1.contact_set.count()
2

```
在一对多关系中，每个主模型对象可以关联多个子对象，所以本例中从主模型Account对象中寻找附模型Contact的属性是contact_set，即通过一个集合返回结果
### 2.3 多对多关系
在SQL语言找那个，M:N关系通过建立一个中间关系表来完成，该中间表中定义了到两个主表的外键。在Django模型层中，可以选择用两个1:N关系来定义M：N关系。这种方式同样通过models.ForeignKey来实现
```python
from django.db import models

class Account(models.Model):
    user_name = models.CharField(max_length=80)
    password = models.CharField(max_length=255)
    reg_date = models.DateField()

    def __unicode__(self):
        return "Account :%s"% self.user_name

class Contact(models.Model):
    accounts = models.ManyToManyField(Account)
    zip_code = models.CharField(max_length=10)
    address = models.CharField(max_length=80)
    mobile = models.CharField(max_length=20)

    def __unicode__(self):
        return "%s, %s"%(self.account.user_name,self.mobile)
```
模型操作:
```shell
>>> a1 = Account(user_name="Leon")
>>> a1.save()
>>> c1 = Contact(mobile="13912345003")
>>> c1.save()
>>> c1.accounts.add(a1)
>>> a2 = Account(user_name="Terry")
>>> a2.save()
>>> c1.accounts.add(a2)
>>> a3 = Account(user_name="Leon")
>>> c1.accounts.add(a3) # 这时候就会报错，因为a3还有保存呢
>>> a1.contact_set.remove(c1)  # 取消单个对象关联
>>> a1.contact_set.clear()     # 取消a1与所有其他Contact对象的关联

```
## 3. 面向对象ORM
Django模型层ORM的一个强大之处是对模型继承的支持，该技术将Python面向对象的编程方法与数据库面向关系表的数据结构有机地结合。Django支持三种风格的模型继承：
* 抽象类继承：父类继承自models.Model，但不会在底层数据库中生成相应的数据表。父类的属性列存储在其子类的数据表中
* 多表继承： 多表继承的每个模型类都在底层数据库中生成响应的数据表管理数据
* 代理模型继承：父类用于在底层数据库中管理数据表；而自雷不定义数据列，只定义查询数据集的排序方式等元数据。

### 3.1 抽象类继承
抽象类继承的作用是在多个表有若干相同的字段时，可以使开发者将这些字段统一定义在抽象基类，免于重复定义这些字段。抽象基类的定义通过在模型的Meta中定义属性abstract=True来实现。代码如下:
```python
from django.db import models

class MessageBase(models.Model):
    id = models.AutoField()
    content = models.CharField(max_length=100)
    user_name = models.CharField(max_length=80)
    pub_date = models.DateField()

    class Meta:
        abstract=True # 定义本类为抽象基类

class Moment(MessageBase):
    headline = models.CharField(max_length=50)

LEVELS = (
  ('1','very good'),
  ('2','good'),
  ('3','normal'),
  ('4','bad'),
)

class Comment(MessageBase):
    level = models.CharField(max_length=1,choices=LEVELS)
```
此时，Moment和Comment的数据库，都是有了MessageBase的字段。在子类模型的编程中，可以直接引用父类定义的字段，比如有:
```shell
m1 = Moment(user_name="Terry",headline="hello world")  # 新建Moment对象
m1.content = "reference parent field in subclass"
m1.save()

```
### 3.2 多表继承
在多表继承技术中，无论是父表还是子表都会用数据库中相对应的数据表维护模型数据，父类中的字段不会重复地在多个子类的相关数据表中定义。从某种意义上来讲，多表继承才是真正面向对象的ORM技术

多表继承的定义不需要特殊的关键字
```python
from django.db import models

class MessageBase(models.Model):
    id = models.AutoField()
    content = models.CharField(max_length=100)
    user_name = models.CharField(max_length=80)
    pub_date = models.DateField()


class Moment(MessageBase):
    headline = models.CharField(max_length=50)

LEVELS = (
  ('1','very good'),
  ('2','good'),
  ('3','normal'),
  ('4','bad'),
)

class Comment(MessageBase):
    level = models.CharField(max_length=1,choices=LEVELS)
```
3个数据表：
* MessageBase 有id content user_name pub_date
* Moment   有id  headline
* Comment  有id  level

在对模型的编程过程中，子类仍然可以直接引用父类定义的字段；同时子类可以通过父类对象引用访问父类示例，比如:
```shell
>>>m1 = Moment(user_name="Terry",headline="hello world")  # 新建Moment对象
>>>m1.content = "reference parent field in subclass"
>>>m1.save()

>>>print m1.messagebase.content
reference parent field in subclass
# 在多表继承时，子类实例中通过小写的父类的名字可以引用父亲的实例
```

### 3.3 代理模型继承
在前联众继承模型中子类模型都有实际存储数据的作用；而代理模型中继承中子类只用于管理父类的数据，而不实际存储数据。代理模型继承通过在子类的Meta中定义proxy=True属性来实现.
```python
from django.db import models

class Moment(models.Model):
    id = models.AutoField()
    content = models.CharField(max_length=100)
    user_name = models.CharField(max_length=80)
    pub_date = models.DateField()
    head_line = models.CharField(max_length=50)
    
class OrderedMoment(Moment):
    class Meta:
        proxy = True
        ordering = ["-pub_date"]

```

2. django模型层

## 1. django的特点以及结构



特点：
* 完善的文档
* 集成数据访问组件:django的Model层自带数据库ORM组件，使开发者无须学习其他数据库访问技术
* 强大的URL映射技术:django使用正则表达式管理URL映射
* 后台管理系统自动生成: 开发者只需要通过简单的几行配置和代码就可以实现完整的后台数据管理Web控制台
* 错误信息非常文章:在开发调试中，如果出现运行异常，则django可以提供非常完整的错误信息帮助开发者定位问题，比如缺少xxx组件的配置应用等，这样可以使开发者马上改正错误



组成结构:
* 管理工具(Management):一套内置的创建站点、迁移数据、维护静态文件的命令工具
* 模型(Model): 提供数据访问接口和模板，包括数据字段、元数据、数据关系等的定义及操作
* 视图(View): Django的视图层封装了HTTP Request和Response的一系列操作和数据流，其主要功能包括URL映射机制、绑定模板等！
* 模板(Template): 是一套Django自己的页面渲染模板语言，用若干内置的tags和filters定义页面的生成方式
* 表单(Form)： 通过内置的数据类型和空间生成HTML表单
* 管理站(Admin): 通过声明需要管理的Model，快速生成后台数据库管理网站

## 2. 安装Django
```python
pip instal django
```

## 3. 建立项目
在进行Django开发之前需要先用django-admin建立django的项目，语法如下：
```python
django-admin startproject 站点名称  项目生成的路径(可以不加)
# 例如
django-admin startproject djangosite
```
该命令在当前目录中建立了一个子目录djangosite，并在其中生成了django开发的默认文件，djangosite的目录如下:
```
djangosite/ 
    manage.py
    djangosite/
        __init__.py
        settings.py
        urls.py
        wsgi.py 
```

对它们的解释如下:
> 1. manage.py  是django用于管理本项目的命令行工具，之后进行站点运行、数据库自动生成、静态文件收集等都要通过该文件完成
> 2. 内层 djangosite/目录 中包好了本项目的实际文件，同时因为其中包含了__init__.py的文件，所以该目录也是一个Python包
> 3. djangosite/__init__.py  告诉python该目录是一个Python包
> 4. djangosite/settings.py  django的项目配置文件，默认时，在其中定义了本项目引用的Django组件、Django项目名等。在之后的开发中，还需在其中配置数据库参数、导入的其他python包的等信息。
> 5. djangosite/urls.py    维护项目的URL路由映射等，即定义客户端访问的URL由哪一个Python模块解释并提供反馈，在默认的情况下，其中只定义了"/admin"即管理员站点的解释器。
> 6. djangosite/wsgi.py    定义WSGI的接口信息，用于与其他Web服务器集成，一般本文件在生成后无须改动


## 4. 建立应用
为了在项目中开发符合MVC架构的实际应用程序，我们需要再项目中建立Django应用，每个Django项目可以包含多个Django应用。语法如下:
```python
# python manage.py startapp 应用名称
python manage.py startapp app
```
命令完成后会在项目目录中建立如下目录及文件结构:
```
app/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    views.py
    
```
对其中的文件功能解析如下:
* __init___.py  使app成为一个Python包
* admin.py   管理站点模型的声明文件，默认为空
* apps.py    应用信息定义文件。在其中生成了类AppConfig， 该类用于定义应用名等Meta数据
* migrations包  用于爱之后定义引用迁移功能
* models.py  添加模型层数据类的文件
* tests.py  添加测试代码文件
* views.py  定义URL响应函数

## 5. 基本视图
1. 在djangosite/app/views.py 建立一个路由响应函数
```python
from django.http import HttpResponse

def welcome(request):
    return HttpResponse("<h1>Welcome to my tiny twitter!</h1>")
```

2. 通过URL映射将用户的HTTP访问与该函数绑定起来。在djangosite/app目录中新建一个urls.py,管理应用app中的所有URL映射，其文件内容为:
```python
from django.conf.urls import url

# 引入app下的views.py的模块
from . import views

urlpatterns=[
    url(r'',views.welcome)
]
```
urlpatterns是一个变量列表，保存所有由url函数生成的路由映射

3. 在项目URL文件djangosite/urls.py 中增加一项，声明对应用app中的urls.py文件的引用
```python
from django.conf.urls import url
from django.contrib import admin
from django.conf.urls import include

urlpatterns=[
    url(r'^app/', include('app.urls')),
    url(r'^admin/', admin.site.urls)
]
```
解释:
> 首先通过import 语句引入django.conf.urls.include()函数，之后在urlpatterns列表中添加一个路径app/，将其转接到app.urls的包，即djangosite/app/urls.py文件。这样，通过include函数就将两个urlpatterns连接起来了

## 6. 启动
```python
python manage.py runserver 0.0.0.0:8001
```
用这种方式启动的Web服务器是Django内置的Web服务器，由于性能原因，一般只用于开发人员测试。正式运行的网站应该使用WSGI的方式启动

## 7. 模型类
Model层的处理，即设计和开发信息发布的数据访问层，4个步骤：
1. 配置项目INSTALLED_APPS
在项目的djangosite/settings.py的文件，找到INSTALLED_APPS数组，添加app的Config类:
```python
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app.apps.AppConfig']
```
2. 模型定义
打开djangosite/app/models.py 在其中新建一个模型类Moment用来定义信息发布表
```python
from django.db import models

class Moment(models.Model):
    content = models.CharField(max_length=200)
    user_name = models.CharField(max_length=20)
    kind = models.CharField(max_length=20)
```
content为保存消息的内容，user_name为保存发布人的名称、kind保存信息的类型

3. 生成迁移文件

**生成数据移植文件**(makemigrations)是指将models.py中定义的数据表转换成数据库生成脚本的过程。
```python
python manage.py makemigrations app
```
然后，会在migrations中看到一个.py的文件，若此时更改user_name的最大长度为30，修改完models.py之后，再次生成迁移文件，你就会看到一些明显的字段，说user_name的max_length进行修改了。迁移文件内的代码不用深究

4. 移植到数据库
在模型的修改过程中可以随时调用makemigrations生成中间的移植文件。而当需要使移植文件生效、修改真实的数据库schema时，则需要通过manage.py的migrate命令来修改同步到数据库中
```python
python manage.py migrate
```
> 可以在每次修改models.py文件内容运行makemigrations命令，检查改动是否符合数据库的语法规则；在调试运行之前，运行一次migrate命令使改动生效

 
## 8. 表单视图
设计和开发信息录入页面，该页面的基本功能为提供输入界面，让用户输入名字，文本消息内容、选择消息类型，用户提交后网页自动设置该信息的时间并保存到数据库中
1. 定义表单类
建立表单类文件djangosite/app/forms.py  在其中定义表单类MomentForm，定义如下:
```python
from django.forms import ModelForm
from app.models import Moment

class MomentForm(ModelForm):
    class Meta:
        model=moment
        fields='__all__'  # 导入所有字段
```

解释:
* 引入django.forms.ModelForm类，该类是所有DJango表单类的基类
* 引入在本应用models.py 中定义的Moment类，以便在后面的表单类中管理Moment类。
* 定义表单类MomentForm,在其中定义子类Meta。在Meta中声明与本表单管理的模型类机器字段
* Fields字段可以设为__all__，也可以用列表形式声明所要导入的属性，比如:fileds=('content','user_name','kind')

2. 修改模型类
为了使用户能够以单选的方式设置消息类型，则需要再models.py文件中定义单选枚举值，并与模型类Moment相关联。修改djangosite/app/models.py:
   
```python
from __future__ import unicode_literals
from django.db import models

# 新增元组用户设置消息类型  枚举型
KIND_CHOICES=(
    ('python技术','python技术'),
    ('数据库技术','数据库技术'),
    ('经济学','经济学'),
    ('文体资讯','文体资讯'),
    ('个人心情','个人心情'),
)

class Moment(models.Model):
    content = models.CharField(max_length=200)
    user_name = models.CharField(max_length=20,default='匿名')
    kind = models.CharField(max_length=20,choices=KIND_CHOICES,default=KIND_CHOICES[0])
```
其中kind_choices是一个元组，其中('经济学','经济学'),第一个是存储到数据库的，第二个是对应的关系，item.types.code,item.types.value，分别输出第一个，第二个的值

3. 开发模板文件
建立目录djangosite/app/templates，在其中新建文件文件moments_input.html，文件的内容如下:

```html
<!DOCTYPE html>
<html>
<head>
    <title>消息录入页面</title>
</head>
<body>
 <form action="?" method="post">
     <fieldset>
         <legend>请输入并提交</legend>
         {{form.as_p}}

         <input type="submit" value="submit">
     </fieldset>
 </form>
</body>
</html>

```


4. 开发视图
视图函数使得表单类和页面模板衔接起来。djangosite/app/views.py文件:
   
```python
import os
from app.forms import MomentForm
from django.http import HttpResponseRedirect
from django.core.urlresolvers import reverse
from django.shortcuts import render

def moment_input(request):
    if request.method=="POST":
        form = MomentForm(request.POST)
        if form.is_valid():
            moment = form.save()
            moment.save()
            return HttpResponseRedirect(reverse("app.views.welcome"))
    else:
        form  = MomentForm()
    PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    return render(request,os.path.join(PROJECT_ROOT,'app/templates','moments_input.html'),{'form':form})
```

在代码中新增视图函数moments_input()，该函数定义了两种访问方式的不同处理

在app/uls.py 文件中增加该文件视图函数的路由映射，内如容下:
```python
urlpatterns=[
    url(r'moments_input',views.moments_input),
    url(r'',views.welcome)
]
```
## 9. 使用管理界面
Django管理界面是一种通过简单的配置就可以实现的数据模型后台的Web控制台。管理界面通常是给系统管理员使用的，以完成元数据的输入、删除、查询等工作

首先，将管理界面需要管理的模型类推按家到djangosite/app/admin.py 文件中:
```python
from django.contrib import admin
from .models import Moment
admin.site.register(Moment)
```

在第一次访问管理界面之前，需要通过manage.py工具的createsuperuser命令建立管理员用户

1. django综述

# 测试框架Unittest的用法

## 1.什么是单元测试？
单元测试是指，对软件中的最小可测试单元在与程序其他部分相隔离的情况下进行检查和验证的工作，这里的最小可测试单元通常是指函数或者类，一般是开发来做的，按照测试阶段来分，就是单元测试、集成测试、系统测试以及验证测试。
## 2.为什么要做单元测试？
* 单元测试之后，才是集成测试，单个的功能模块测试通过之后，才能把单个功能模块集成起来做成测试，为了从底层发现bug，单元测试时可以减少合成后出现的问题
* 越早发现bug越好，这样可以早点发现问题，不然问题累计到后面，很可能会因为一个做错了而导致整个模块甚至更大范围的推倒重来，对于时间和经费来说，是非常浪费的。
* 对于测试来说，单元测试就是为了执行用例，输入测试数据->输出测试结果





## 3. Unittest框架及原理
unittest框架最核心的4个概念：

	1. test case:
	就是我们的测试用例，unitest中提供了一个基本类TestCase，可以用来创建新的测试用例，一个Testcase的实例就是一个测试用例，unittest中测试用例方法都是以test开头的，且执行顺序会按照方法名的ASCII值排序。
	
	2. test fixure
	
	测试夹具，用于测试用例环境的搭建和销毁。即用例测试前准备环境的搭建(SetUp前置条件)，测试后环境的还原(TearDown后置条件)，比如测试前需要登录获取token等就是测试用例需要的环境，运行完后执行下一个用例前需要还原环境，以免影响下一条用例的测试结果。
	
	3. test suite
	测试套件，用来把需要一起执行的测试用例集中放到一起执行，相当于一个篮子。我们可以使用TestLoader来加载测试用例到测试套件中。
	
	4. test runner
	用来执行测试用例的，并返回测试用例的执行结果。它还可以用图形或者文本接口，把返回的测试结果更形象的展示出来，如：HTMLTestRunner.
	
## 4. unittest的断言
在python中assert的使用方法很简单，即assert表达式，提示信息，而unittest框架中也提供了一个自带的断言方式，主要有以下集中:

|方法|检查|
|:--|:--|
|assertEqual(a, b,msg=None)|a==b|
|assertNotEqual(a, b)|a !=b|
|assertTrue(x)|bool(x) is True|
|assertFalse(x)|Bool(x) is False|
|assertIs(a, b)|a is b|
|assertIsNot(a, b)|a is not b|
|assertIsNone(x)|x is None|
|assertIsNotNone(x)|x is not None|
|assertIn(a, b)|a in b|
|assertNotIn(a, b)|a not in b|
|assertIsInstance(a, b)|isinstance(a,b)|
|assertNotIsInstance(a, b)|not isinstance(a,b)|


如果断言失败即不通过就会抛出一个AssertionError断言错误，成功则标识为通过，以上几种方式都有一个共同点，就是都有一个msg参数（表中只列了一个，其实都用），默认是None，即msg=None，如果指定msg参数的值，则将该信息作为失败的错误信息返回。

## 5. TestCase测试用例
步骤如下：
* 导入unittest模块
* 创建一个测试类，并继承unittest.TestCase()
* 定义测试方法，方法名必须以test_开头
* 调用unittest.main()方法来运行测试用例，unittest.main()方法会搜索该模块下所有以test开头的测试用例方法，并自动执行。

下面以注册功能为例，整个register.py就是注册功能的代码，没有前端界面，功能比较简单，只是方便用于演示，直接导入就可以使用：
```python
# coding:utf-8
# register.py
users = [{'username': 'test', 'password': '123456'}]


def register(username, password1, password2):

    if not all([username, password1, password2]):
        return {"code": 0, "msg": "所有参数不能为空"}
    # 注册功能
    for user in users:
        if username == user['username']:
            return {"code": 0, "msg": "该用户名已存在！"}
    else:
        if password1 != password2:
            return {"code": 0, "msg": "两次密码输入不一致！"}
        else:
            if 6 <= len(username) >= 6 and 6 <= len(password1) <= 18:
                users.append({'username': username, 'password': password2})
                return {"code": 1, "msg": "注册成功"}
            else:
                return {"code": 0, "msg": "用户名和密码必须在6-18位之间"}
```


```python
# coding:utf-8
# test_register.py
import unittest
from register import register   # 导入被测试的代码


class TestRegister(unittest.TestCase):
    """注册接口测试用例类"""

    def test_register_success(self):
        """注册成功"""
        data = ("mikitest", "miki123", "miki123")   # 测试数据
        expected = {"code": 1, "msg": "注册成功"}   # 预期结果
        result = register(*data)    # 把测试数据传到被测的代码，接收实际结果
        self.assertEqual(expected, result)  # 断言，预期和实际是否一致，一致即用例通过

    def test_username_isnull(self):
        """注册失败-用户名为空"""
        data = ("", "miki123", "miki123")
        expected = {"code": 0, "msg": "所有参数不能为空"}
        result = register(*data)
        self.assertEqual(expected, result)

    def test_username_lt6(self):
        """注册失败-用户名大于18位"""
        data = ("mikitestmikitestmikitest", "miki123", "miki123")
        expected = {"code": 0, "msg": "用户名和密码必须在6-18位之间！"}
        result = register(*data)
        self.assertEqual(expected, result)	# 这条用例应该是不通过的，注册代码bug

    def test_pwd1_not_pwd2(self):
        """注册失败-两次密码不一致"""
        data = ("miki123", "test123", "test321")
        expected = {"code": 0, "msg": "两次密码输入不一致！"}
        result = register(*data)
        self.assertEqual(expected, result)


# 如果直接运行这个文件，需要使用unittest中的main函数来执行测试用例
if __name__ == '__main__':
    unittest.main()
```

测试用例，一共4条用例，其中通过3条，不通过1条，不通过的是本身注册代码的bug。

## 6. TestFixure测试夹具
unittest的测试夹具有两种使用方式。
* 一种是以测试方法为维度的setUp()和tearDown()，
* 一种是以测试类维度的setUpClass()和tearDownClass()。以注册功能为例。

```python
# test_register.py
import unittest
from register import register  # 导入被测试的代码


class TestRegister(unittest.TestCase):
    """注册接口测试用例类"""

    def setUp(self):
        # 每条用例执行之前都会执行
        print("用例{}开始执行--".format(self))

    def tearDown(self):
        # 每条用例执行之后都会执行
        print("用例{}执行结束--".format(self))

    @classmethod  # 指明这是个类方法以类为维度去执行的
    def setUpClass(cls):
        # 整个测试用例类中的用例执行之前，会先执行此方法
        print("-----setup---class-----")

    @classmethod
    def tearDownClass(cls):
        # 整个测试用例类中的用例执行完之后，会执行此方法
        print("-----teardown---class-----")

    def test_register_success(self):
        """注册成功"""
        data = ("mikitest", "miki123", "miki123")  # 测试数据
        expected = {"code": 1, "msg": "注册成功！"}  # 预期结果
        result = register(*data)  # 把测试数据传到被测的代码，接收实际结果
        self.assertEqual(expected, result)  # 断言，预期和实际是否一致，一致即用例通过

    def test_username_isnull(self):
        """注册失败-用户名为空"""
        data = ("", "miki123", "miki123")
        expected = {"code": 0, "msg": "所有参数不能为空！"}
        result = register(*data)
        self.assertEqual(expected, result)


# 如果直接运行这个文件，需要使用unittest中的main函数来执行测试用例
if __name__ == '__main__':
    unittest.main()
```


## 7. TestSuite测试套件
unittest.TestSuite()类来表示一个测试用例集，把需要执行的用例类或模块存到一起，常用的方法如下：
* unittest.TestSuite()
	
	1. addTest():添加单个测试用例方法
	2. addTest([...]): 添加多个测试用例方法，方法名存在一个列表
	
* unittest.TestLoader()
	
	1. loadTestsFromTestCase(测试类名)：添加一个测试类
	2. loadTestsFromModule(模块名):添加一个模块类
	3. discover(测试用例的所在目录):指定目录去加载，会自动寻找整个目录下所有符合命名规则的测试用例。
    
```python
# coding:utf-8
# run_test.py，与test_register.py、register.py同一目录下
import unittest
import test_register

# 第一步，创建一个测试套件
suite = unittest.TestSuite()

# 第二步：将测试用例，加载到测试套件中
# 方式1，添加单条测试用例
# case = test_register.TestRegister("test_register_success")	# 创建一个用例对象，注意：通过用例类去创建测试用例对象的时候，需要传入用例的方法名（字符串类型）
# suite.addTest(case)	# 添加用例到测试套件中

# 方式2，添加多条测试用例
# case1 = test_register.TestRegister("test_register_success")
# case2 = test_register.TestRegister("test_username_isnull")
# suite.addTest([case1, case2])	# 添加用例到测试套件中

# 方式3，添加一个测试用例类
# loader = unittest.TestLoader()	# 创建一个加载对象
# suite.addTest(loader.loadTestsFromTestCase(test_register.TestRegister))

# 方式4，添加一个模块
loader = unittest.TestLoader()	# 创建一个加载对象
suite.addTest(loader.loadTestsFromModule(test_register))

# 方式5，指定测试用例的所在的目录路径，进行加载
# loader = unittest.TestLoader()
# suite.addTest(loader.discover(r"d:\learn\python"))
```
## 8. TestRunner执行用例
test runner顾名思义就是用来执行测试用例的，并且可以生成相应的测试报告。测试报告有两种展示形式，一种是text文本，一种是html格式。

html格式就是HTMLTestRunner了，HTMLTestRunner是python标准库的unittest框架的一个扩展，它可以生成一个直观清晰的HTML测试报告。使用的前提就是要下载HTMLTestRunner.py,下载完后放在Python的安装目录下的lib目录下的site-packages即可。

text文本相对于html来说比较简陋，与控制台输出的没有什么区别，也几乎没有人使用，这里不作演示。现在演示一下如何生成Html格式的测试报告: