Django 模型

一.创建 django project

　　django-admin startproject django_model

二.新建App

　　python manage.py startapp app01

三. 更改settings配置，使用mysql数据库

　　1.更改django中__init.py__　

import pymysql
pymysql.install_as_MySQLdb()

　　2.settings设置，将DATABASE配置为mysql数据库

DATABASES = {
    'default': {
    'ENGINE': 'django.db.backends.mysql',
    'NAME':'db01',
    'USER': 'root',
    'PASSWORD': '123',
    'HOST': '192.168.11.100',
    'PORT': '3306',
    }
}

四. APP注册,在settings中配置

# Application definition

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app01',
]

五.表创建 

1.创建Model，之后可以根据Model来创建数据库表

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

1、models.AutoField　　自增列 = int(11)
　　如果没有的话，默认会生成一个名称为 id 的列，如果要显示的自定义一个自增列，必须将给列设置为主键 primary_key=True。
2、models.CharField　　字符串字段
　　必须 max_length 参数
3、models.BooleanField　　布尔类型=tinyint(1)
　　不能为空，Blank=True
4、models.ComaSeparatedIntegerField　　用逗号分割的数字=varchar
　　继承CharField，所以必须 max_lenght 参数
5、models.DateField　　日期类型 date
　　对于参数，auto_now = True 则每次更新都会更新这个时间；auto_now_add 则只是第一次创建添加，之后的更新不再改变。
6、models.DateTimeField　　日期类型 datetime
　　同DateField的参数
7、models.Decimal　　十进制小数类型 = decimal
　　必须指定整数位max_digits和小数位decimal_places
8、models.EmailField　　字符串类型（正则表达式邮箱） =varchar
　　对字符串进行正则表达式
9、models.FloatField　　浮点类型 = double
10、models.IntegerField　　整形
11、models.BigIntegerField　　长整形
　　integer_field_ranges = {
　　　　'SmallIntegerField': (-32768, 32767),
　　　　'IntegerField': (-2147483648, 2147483647),
　　　　'BigIntegerField': (-9223372036854775808, 9223372036854775807),
　　　　'PositiveSmallIntegerField': (0, 32767),
　　　　'PositiveIntegerField': (0, 2147483647),
　　}
12、models.IPAddressField　　字符串类型（ip4正则表达式）
13、models.GenericIPAddressField　　字符串类型（ip4和ip6是可选的）
　　参数protocol可以是：both、ipv4、ipv6
　　验证时，会根据设置报错
14、models.NullBooleanField　　允许为空的布尔类型
15、models.PositiveIntegerFiel　　正Integer
16、models.PositiveSmallIntegerField　　正smallInteger
17、models.SlugField　　减号、下划线、字母、数字
18、models.SmallIntegerField　　数字
　　数据库中的字段有：tinyint、smallint、int、bigint
19、models.TextField　　字符串=longtext
20、models.TimeField　　时间 HH:MM[:ss[.uuuuuu]]
21、models.URLField　　字符串，地址正则表达式
22、models.BinaryField　　二进制
23、models.ImageField   图片
24、models.FilePathField 文件

1、null=True
　　数据库中字段是否可以为空
2、blank=True
　　django的 Admin 中添加数据时是否可允许空值
3、primary_key = False
　　主键，对AutoField设置主键后，就会代替原来的自增 id 列
4、auto_now 和 auto_now_add
　　auto_now   自动创建---无论添加或修改，都是当前操作的时间
　　auto_now_add  自动创建---永远是创建时的时间
5、choices
GENDER_CHOICE = (
        (u'M', u'Male'),
        (u'F', u'Female'),
    )
gender = models.CharField(max_length=2,choices = GENDER_CHOICE)
6、max_length
7、default　　默认值
8、verbose_name　　Admin中字段的显示名称
9、name|db_column　　数据库中的字段名称
10、unique=True　　不允许重复
11、db_index = True　　数据库索引
12、editable=True　　在Admin里是否可编辑
13、error_messages=None　　错误提示
14、auto_created=False　　自动创建
15、help_text　　在Admin中提示帮助信息
16、validators=[]
17、upload-to

2、连表关系：

• 一对多，models.ForeignKey(ColorDic)
• 一对一，models.OneToOneField(OneModel)
• 多对多，authors = models.ManyToManyField(Author)

应用场景：

• 一对一：在某表中创建一行数据时，有一个单选的下拉框（下拉框中的内容被用过一次就消失了）。

  例如：原有含10列数据的一张表保存相关信息，经过一段时间之后，10列无法满足需求，需要为原来的表再添加5列数据。

• 一对多：当一张表中创建一行数据时，有一个单选的下拉框（可以被重复选择）。

  例如：创建用户信息时候，需要选择一个用户类型【普通用户】【金牌用户】【铂金用户】等。

• 多对多：在某表中创建一行数据是，有一个可以多选的下拉框。

  例如：创建用户信息，需要为用户指定多个爱好。

3、数据库操作

• 增加：创建实例，并调用save
• 更新：a.获取实例，再sava；b.update(指定列)
• 删除：a. filter().delete(); b.all().delete()
• 获取：a. 单个=get(id=1) ；b. 所有 = all()
• 过滤：filter(name='xxx');filter(name__contains='');(id__in = [1,2,3]) ;
  icontains(大小写无关的LIKE),startswith和endswith, 还有range(SQLBETWEEN查询）'gt', 'in', 'isnull', 'endswith', 'contains', 'lt', 'startswith', 'iendswith', 'icontains','range', 'istartswith'
• 排序：order_by("name") =asc ；order_by("-name")=desc
• 返回第n-m条：第n条[0]；前两条[0:2]
• 指定映射：values
• 数量：count()
• 聚合：from django.db.models import Min,Max,Sum objects.all().aggregate(Max('guest_id'))
• 原始SQL

cursor = connection.cursor()
cursor.execute('''SELECT DISTINCT first_name ROM people_person WHERE last_name = %s""", ['Lennon'])
row = cursor.fetchone()

上传文件实例：

class FileForm(forms.Form):
    ExcelFile = forms.FileField()

from django.db import models

class UploadFile(models.Model):
    userid = models.CharField(max_length = 30)
    file = models.FileField(upload_to = './upload/')
    date = models.DateTimeField(auto_now_add=True)

def UploadFile(request):
    uf = AssetForm.FileForm(request.POST,request.FILES)
    if uf.is_valid():
            upload = models.UploadFile()
            upload.userid = 1
            upload.file = uf.cleaned_data['ExcelFile']
            upload.save()
            
            print upload.file

五. 一对多表操作

5.2 创建表

from django.db import models
# Create your models here.
class UserType(models.Model):
    nid = models.AutoField(primary_key=True)
    caption = models.CharField(max_length=32)

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

终端运行创建表

python manage.py makemigrations
python manage.py migrate

5.3 表中新增数据

可以使用creat,或者add

from django.shortcuts import render,HttpResponse
from app01 import models

# Create your views here.
def Index(request):
    #Usertype表中插入数据
    models.UserType.objects.create(caption="普通用户")
    models.UserType.objects.create(caption="管理员")
    models.UserType.objects.create(caption="超级管理员")
    #UserInfo表中插入数据
    models.UserInfo.objects.create(user="Peter",pwd="123",email="peter@gmail.com",user_type_id=2)
    models.UserInfo.objects.create(user="Sam",pwd="123",email="Sam@gmail.com",user_type_id=2)
    user_info_dict ={
        'user': "Mary",
        "pwd": "123",
        "email": "Mary@gmail.com",
        "user_type_id": 1
    }
    models.UserInfo.objects.create(**user_info_dict)
    return HttpResponse("Ok")

5.4 数据查询　　

多表查询技巧：

       __:两个下划线可以生成连接查询，查询关联的字段信息

      _set:提供了对象访问相关联表数据的方法。但是这种方法只能是相关类访问定义了关系的类（主键类访问外键类）

def Index(request):
 
    #连表查询，filter条件过滤，__连表操作
    ret = models.UserInfo.objects.filter(user_type__caption="管理员").values("user","pwd")
    print(ret)
    #连表查询, 不加filter条件过滤查询所有
    ret = models.UserInfo.objects.values('user', 'pwd', 'user_type__caption')
    for item in ret:
        print(item)
    return HttpResponse("Ok")

 六. 多对多表操作

1.创建多对多关系表

from django.db import models

# Create your models here.
class Author(models.Model):
    """
    作者
    """
    name = models.CharField(max_length=100)
    age = models.IntegerField()

class BookType(models.Model):
    """
    图书类型
    """
    caption = models.CharField(max_length=64)

class Book(models.Model):
    """
    图书
    """
    name = models.CharField(max_length=64)
    pages = models.IntegerField()
    price = models.DecimalField(max_digits=10,decimal_places=2)
    pubdate = models.DateField()

    authors = models.ManyToManyField(Author)
    book_type = models.ForeignKey(BookType)

2.创建数据

#新增作者
    models.Author.objects.create(name="Peter",age=23)
    models.Author.objects.create(name="David",age=23)
    models.Author.objects.create(name="Jim",age=20)
    #booktype
    models.BookType.objects.create(caption="文学类")
    models.BookType.objects.create(caption="历史")
    models.BookType.objects.create(caption="自然")
    models.BookType.objects.create(caption="科学技术")
    #book
    models.Book.objects.create(name='向自由起飞',pages=260,price=45,pubdate='2016-11-20',book_type_id=1)
    models.Book.objects.create(name='华夏发展史',pages=1800,price=95,pubdate='2010-11-20',book_type_id=2)
    models.Book.objects.create(name='量子论',pages=800,price=75,pubdate='2014-11-20',book_type_id=4)
    book_info_dict = {
        'name': 'python入门',
        'pages': 600,
        'price': 89,
        'pubdate': '2013-10-11',
        "book_type_id": 4
    }
    models.Book.objects.create(**book_info_dict)

3.向关系表中加入数据 

 #将book_id3,4,5加入author_id为1的作者
    aut = models.Author.objects.get(id=1)
    aut.book_set.add(*models.Book.objects.filter(id__gt=2))

    aut = models.Author.objects.get(id=2)
    aut.book_set.add(models.Book.objects.get(id=1))

    #作者id 2-3 共同创作了book_id 为2的著作
    obj = models.Book.objects.get(id=2)
    q = models.Author.objects.filter(id__gt=1)
    obj.authors.add(*q)

    ret = models.BookType.objects.all()
    for item in ret:
        print(item.caption)

 4.查询

　　#1.查询所有图书类型为“文学”的所有书籍的名称，价格，发布时间，图书类型的两种方式
    result1_method1 = models.Book.objects.filter(book_type__caption="文学").values("name","price","pubdate","book_type__caption")
    print(result1_method1)
    result1_method2 = models.BookType.objects.filter(caption="文学").values("book__name","book__price","book__pubdate","caption")
    print(result1_method2)

    #2.查询作者为"Peter"参与编写的所有书籍的名称，价格，发布时间，图书类型，作者的两种方法
    result2_method1 = models.Book.objects.filter(authors__name="Peter").values
                    ("name","price","pubdate","authors__name")
    print(result2_method1)
    result2_method2 = models.Author.objects.filter(name="Peter").values("name","book__price","book__name","book__pubdate")
    print(result2_method2)
    return HttpResponse("ok")

多对多总结：

正向添加操作：通过表中有m2m操作：(*对象)。注：加*是因为后面获取到的是列表

反向添加操作：通过表中没有m2m操作：表名_set

实例：Q

先将文件进行配置

STATIC_URL = '/static/'
STATICFILES_DIRS = (
    os.path.join(BASE_DIR,"static"),
)

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

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

from django.db import models

# Create your models here.
class Author(models.Model):
    """
    作者
    """
    name = models.CharField(max_length=100)
    age = models.IntegerField()

class BookType(models.Model):
    """
    图书类型
    """
    caption = models.CharField(max_length=64)

class Book(models.Model):
    """
    图书
    """
    name = models.CharField(max_length=64)
    pages = models.IntegerField()
    price = models.DecimalField(max_digits=10,decimal_places=2)
    pubdate = models.DateField()

    authors = models.ManyToManyField(Author)
    book_type = models.ForeignKey(BookType)

    def __str__(self):
        return 'obj:%s-%s' %(self.name,self.price)

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^test', views.test),
    url(r'^index', views.index),
]

from django.shortcuts import render,HttpResponse
from app01 import models
# Create your views here.

# def test(request):
#     #数据库添加数据
#     models.BookType.objects.create(caption='技术')
#     models.BookType.objects.create(caption='文学')
#     models.BookType.objects.create(caption='动漫')
#     models.BookType.objects.create(caption='男人装')
#
#     models.Book.objects.create(name='文艺复兴',pages='100',price='40',pubdate='1992-11-2',book_type_id='1')
#     models.Book.objects.create(name='解密',pages='80',price='10', pubdate='2016-6-10',book_type_id='2')
#     models.Book.objects.create(name='刀锋',pages='50',price='3', pubdate='2014-02-16',book_type_id='2')
#     models.Book.objects.create(name='查令十字路84号',pages='260',price='40',pubdate='1999-10-12',book_type_id='3')
#     models.Book.objects.create(name='红楼',pages='1000',price='500', pubdate='1760-1-1',book_type_id='3')
#     models.Book.objects.create(name='将夜',pages='2000',price='300', pubdate='2010-3-3',book_type_id='1')
#     models.Book.objects.create(name='mysql从删库到跑路',pages='20',price='10',pubdate='1998-9-2',book_type_id='4')
#     models.Book.objects.create(name='马克思主义',pages='50',price='100',pubdate='1937-3-3',book_type_id='2')
#
#     return HttpResponse('ok')

import json
from datetime import date
from datetime import datetime
from decimal import Decimal
#序列化类
class JsonCustomEncoder(json.JSONEncoder):

    def default(self, field):

        if isinstance(field, datetime):
            return field.strftime('%Y-%m-%d %H:%M:%S')
        elif isinstance(field, date):
            return field.strftime('%Y-%m-%d')
        elif isinstance(field, Decimal):
            return str(field)
        else:
            return json.JSONEncoder.default(self, field)

def index(request):
    if request.method == 'POST':  #判断是否是post访问，接收post请求
        ret = {'status': False, 'message': '', 'data':None}
        try:
            post_data = request.POST.get('post_data',None)  #获取到前端发来的post_data，如果没有默认None
            post_data_dict = json.loads(post_data)  #将post_data反序列化成字典
            print(post_data_dict)
            # {'name': ['11', 'sdf']，'price': ['11', 'sdf']}
            # 构造搜索条件     去数据库进行搜索
            from django.db.models import Q
            con = Q()
            for k,v in post_data_dict.items():
                q = Q()
                q.connector = 'OR'  #创建或的关系
                for item in v:  #循环列表
                    q.children.append((k, item))  #循环出来的多个item是添加到或的关系
                con.add(q, 'AND')  #将或的关系添加到and的关系中
            """
            序列化
            ret = models.Book.objects.filter(con)
            print(ret) # ret是queryset,[对象]

            from django.core import serializers
            data = serializers.serialize("json", ret)
            print(type(data),data)  # 字符串
            """
            """
            #ret = models.Book.objects.filter(con).values('name','book_type__caption')
            ret = models.Book.objects.filter(con).values_list('name', 'book_type__caption')
            print(ret,type(ret))  #ret外面是queryset对象，里面是字典
            li = list(ret)  #转换成列表，里面是字典
            data = json.dumps(li)
            print(data,type(data))
            """
            result = models.Book.objects.filter(con).values('name','price','pubdate','book_type__caption')
            # result = models.Book.objects.filter(con)是queryset对象
            li = list(result)  #转换成列表，里面是字典，values_list内部元素的列表
            ret['status'] = True
            ret['data'] = li  #将列表信息添加到ret字典
        except Exception as e:
            ret['message'] = str(e)
        ret_str = json.dumps(ret, cls=JsonCustomEncoder)  #将queryset转换成字符串返回到前台
        print(ret_str)
        return HttpResponse(ret_str)  #返回字符串
    return render(request, 'index.html')

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        .left{
            float: left;
        }
        .clearfix:after{
            content: '.';
            clear: both;
            display: block;
            visibility: hidden;
            height: 0;
        }
    </style>
</head>
<body>
    <div class="condition">
        <div class="item clearfix">
            <div class="icon left" onclick="AddCondition(this);">+</div>
            <div class="left">
                <select onchange="ChangeName(this);">
                    <option value="name">书名</option>
                    <option value="book_type__caption">图书类型</option>
                    <option value="price">价格</option>
                    <option value="pages">页数</option>
                </select>
            </div>
            <div class="left"><input type="text" name="name" /></div>
        </div>
    </div>
    <div>
        <input type="button" onclick="Search();" value="搜索" />
    </div>
    <div class="container"></div>
    <script src="/static/jquery-1.12.4.js"></script>
    <script>
        function  AddCondition(ths) {
            var new_tag = $(ths).parent().clone();   //点加号时找到父级，克隆整个div
            new_tag.find('.icon').text('-');  //克隆的div将加号变成减号
            new_tag.find('.icon').attr('onclick', 'RemoveCondition(this);');  //将减号绑定事件

            $(ths).parent().parent().append(new_tag);  //将克隆的div添加到指定位置
        }
        function  RemoveCondition(ths) {  //减号绑定事件
            $(ths).parent().remove();  //点击减号将会移除div
        }
        function ChangeName(ths) {  //下拉框绑定事件
            var v = $(ths).val();  //获得当前框的值：可获得name，book_type__caption，price，pages
            $(ths).parent().next().find('input').attr('name',v);  //找到当前框对应的input标签的name属性和赋值，如：name=name，name=book_type__caption
        }
        function Search() {  //将获取的值提交后台
            var post_data_dict = {};

            // 获取所有input的内容，提交数据
            $('.condition input').each(function () {  //循环div里面所有的input
                // console.log($(this)[0])
                var n = $(this).attr('name');  //获取当前input的name
                var v = $(this).val();  //获取当前input标签里面输入的值
                var v_list = v.split('，');  //将输入的值用中文逗号进行分割
                post_data_dict[n] = v_list;  //将name和分割后的值添加到字典中
            });
{#            console.log(post_data_dict);#}
            var post_data_str = JSON.stringify(post_data_dict);  //将字典转换成字符串
            $.ajax({
                url:"/index/",  //index后面必须加/
                type:"POST",
                data:{"post_data":post_data_str},
                dataType:"json",
                success:function (arg) {
                     //arg返回的是json对象，写上dataType:"json"，就可以直接写arg.status。
                    if(arg.status){ //后端返回来的status为真
                        var table = document.createElement('table');  //创建table标签
                        table.setAttribute('border',1);  //设置table边框
                        // [{,name,pubdate,price,caption},]
                        $.each(arg.data, function(k,v){  //循环data列表，里面是字典
                            console.log(k);  //k是data索引
                            console.log(v);  //v是data里面的字典
                            //创建tr标签
                            var tr = document.createElement('tr');
                            //根据后台返回data里面的数组创建td
                            var td1 = document.createElement('td');
                            td1.innerText = v['name'];
                            var td2 = document.createElement('td');
                            td2.innerText = v['price'];
                            var td3 = document.createElement('td');
                            td3.innerText = v['book_type__caption'];
                            var td4 = document.createElement('td');
                            td4.innerText = v['pubdate'];
                            //将所有td添加到tr
                            tr.appendChild(td1);
                            tr.appendChild(td2);
                            tr.appendChild(td3);
                            tr.appendChild(td4);
                            //将tr添加到table
                            table.appendChild(tr);
                        });
                        $('.container').empty();  //显示table前将内容清空container
                        $('.container').append(table);  //将后台返回数据放在table里面添加到containerdiv显示在前端
                    }else{
                        alert(arg.message);
                    }
                }
            })
        }
    </script>
</body>
</html>

HTML之重点：

1、var new_tag = $(ths).parent().clone()获取的是通过jquery方法获得的对象。

dom对象和jquery对象之间的转换：

#dom对象：
document.getElementsById("i1")

#jquery对象：
$("i1")

#dom对象转换成jquery对象：
$(document.getElementsByTagName("div")[0])

#jquery对象转换成dom对象
$("div").first()[0]

1. option的value属性值要和创建表里面的字段一样，每次ChangeName时$(this).val()，可以获得当前选中标签的属性，再找到后面的input，将获取的属性值设置成input的name属性名。也就是option选图书类型时，value是book_type__caption，后面的input框的name属性就是book_type__caption。代码结合注释看会更加理解。
2. 发ajax时注意，不管urls.py路由配置有没有加/，发ajax请求时，url结尾都要加/，不加会出错：APPEND_SLASH 。
3. 403错误是需要注释settings里面的csrf。
4. data:{"post_data":post_data_str}里面的post_data_str必须传字符串，索引要转换成字符串格式：var post_data_str = JSON.stringify(post_data_dict)

views.py之重点：

1. json序列化时只能是python的数据结构：字典、列表等
2. filter()或者.all()得到的是queryset对象，用serializers.serialize实现序列化
3. JsonCustomEncoder是序列化类，字符串可以直接dumps，时间和小数（pubdate、price）不能dumps，有了序列化类就可以。