Django之Model

到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞:

  • 创建数据库,设计表结构和字段
  • 使用 MySQLdb 来连接数据库,并编写数据访问层代码
  • 业务逻辑层去调用数据访问层执行数据库操作
import MySQLdb
 
def GetList(sql):
    db = MySQLdb.connect(user='root', db='wupeiqidb', passwd='1234', host='localhost')
    cursor = db.cursor()
    cursor.execute(sql)
    data = cursor.fetchall()
    db.close()
    return data
 
def GetSingle(sql):
    db = MySQLdb.connect(user='root', db='wupeiqidb', passwd='1234', host='localhost')
    cursor = db.cursor()
    cursor.execute(sql)
    data = cursor.fetchone()
    db.close()
    return data
View Code

django为使用一种新的方式,即:关系对象映射(Object Relational Mapping,简称ORM)。

  PHP:activerecord

  Java:Hibernate 

    C#:Entity Framework

django中遵循 Code Frist 的原则,即:根据代码中定义的类来自动生成数据库表。

使用Django连接数据库,首先要在文件中进行相关配置:

pymysql配置:

Django之Model_第1张图片

import pymysql
pymysql.install_as_MySQLdb()
__init__.py

 

路由映射配置:

Django之Model_第2张图片

from django.conf.urls import url
from django.contrib import admin
from app01 import views
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^index', views.index),
]
urls.py

 

一、创建表

 1、基本结构

from django.db import models

# Create your models here.

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

class UserType(models.Model):
    nid = models.AutoField(primary_key=True)
    caption = models.CharField(max_length=16)
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(其他表)
  • 多对多:models.ManyToManyField(其他表)
  • 一对一:models.OneToOneField(其他表)

应用场景:

  • 一对多:当一张表中创建一行数据时,有一个单选的下拉框(可以被重复选择)
    例如:创建用户信息时候,需要选择一个用户类型【普通用户】【金牌用户】【铂金用户】等。
  • 多对多:在某表中创建一行数据是,有一个可以多选的下拉框
    例如:创建用户信息,需要为用户指定多个爱好
  • 一对一:在某表中创建一行数据时,有一个单选的下拉框(下拉框中的内容被用过一次就消失了
    例如:原有含10列数据的一张表保存相关信息,经过一段时间之后,10列无法满足需求,需要为原来的表再添加5列数据

 

二、操作表

1、基本操作

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

    # 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()                                                 # 修改单条数据
基本操作

实例:增

def index(requeset):
    增、删、改、查
    return HttpResponse("ok")

 

    #save添加
    # obj = UserType(caption="管理员")
    # obj.save()

    # #create添加
    # UserType.objects.create(caption="普通用户")

    # #字典添加
    # user_dict = {"caption":"超级管理员"}
    # UserType.objects.create(**user_dict)

这里用到了字典添加,注意字典添加时要写**

注:

    # 添加字典方法一
    user_info_dict1 = {
        "user": "alex",
        "email": "[email protected]",
        "pwd": 123,
        "user_type":UserType.objects.get(nid=1)
    }
    UserInfo.objects.create(**user_info_dict1)

    # 添加字典方法二
    user_info_dict2 = {
        "user": "eric",
        "email": "[email protected]",
        "pwd": 123,
        "user_type_id": 1
    }
    UserInfo.objects.create(**user_info_dict2)

注:

user_type是我们自定义的列名,如果要添加,后面就要通过获取对象来添加。

user_type_id是自动帮我们创建之后生成的列名,所以可以直接写。

 

单标查询:结果都是queryset

all():列表里面是对象

    #单表查询,结果都是queryset
    ret = UserType.objects.all()
    print(type(ret),ret,ret.query)  
    #type(ret)是QuerySet。ret是列表里面封装每一条数据的对象。 ret.query查看SQL语句
    for item in ret:
        print(item,item.nid,item.caption)  #item是对象

如图:

Django之Model_第3张图片

 

all().values():列表里面是字典

    ret1 = UserType.objects.all().values("nid")  #获取UserType表中nid的值
    print(type(ret1),ret1,ret1.query)  #type(ret1)是QuerySet。ret1是列表里面有字典
    for item in ret1:
        print(item,type(item))  #item是字典
        print(item["nid"])  #获取nid的值

 如图:

Django之Model_第4张图片

 

 all().values_list():列表里面是元组

    ret = UserType.objects.all().values_list("nid")
    print(type(ret),ret)  #用values_list获取到的item是列表里有元组

 如图:

Django之Model_第5张图片

 

2、进阶操作(了不起的双下划线)

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

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

    # 大于,小于
    #
    # models.Tb1.objects.filter(id__gt=1)              # 获取id大于1的值
    # models.Tb1.objects.filter(id__lt=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

    # 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

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

    # 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"
进阶操作

 注:.values().annotate()相当于MSQL里面的group by

3、连表操作(了不起的双下划线)

利用双下划线和 _set 将表之间的操作连接起来

class UserProfile(models.Model):
    user_info = models.OneToOneField('UserInfo')
    username = models.CharField(max_length=64)
    password = models.CharField(max_length=64)

    def __unicode__(self):
        return self.username


class UserInfo(models.Model):
    user_type_choice = (
        (0, u'普通用户'),
        (1, u'高级用户'),
    )
    user_type = models.IntegerField(choices=user_type_choice)
    name = models.CharField(max_length=32)
    email = models.CharField(max_length=32)
    address = models.CharField(max_length=128)

    def __unicode__(self):
        return self.name


class UserGroup(models.Model):

    caption = models.CharField(max_length=64)

    user_info = models.ManyToManyField('UserInfo')

    def __unicode__(self):
        return self.caption


class Host(models.Model):
    hostname = models.CharField(max_length=64)
    ip = models.GenericIPAddressField()
    user_group = models.ForeignKey('UserGroup')

    def __unicode__(self):
        return self.hostname
表结构实例
user_info_obj = models.UserInfo.objects.filter(id=1).first()
print user_info_obj.user_type
print user_info_obj.get_user_type_display()
print user_info_obj.userprofile.password
 
user_info_obj = models.UserInfo.objects.filter(id=1).values('email', 'userprofile__username').first()
print user_info_obj.keys()
print user_info_obj.values()
一对一操作
类似一对一
1、搜索条件使用 __ 连接
2、获取值时使用 .    连接
一对多
user_info_obj = models.UserInfo.objects.get(name=u'武沛齐')
user_info_objs = models.UserInfo.objects.all()
 
group_obj = models.UserGroup.objects.get(caption='CEO')
group_objs = models.UserGroup.objects.all()
 
# 添加数据
#group_obj.user_info.add(user_info_obj)
#group_obj.user_info.add(*user_info_objs)
 
# 删除数据
#group_obj.user_info.remove(user_info_obj)
#group_obj.user_info.remove(*user_info_objs)
 
# 添加数据
#user_info_obj.usergroup_set.add(group_obj)
#user_info_obj.usergroup_set.add(*group_objs)
 
# 删除数据
#user_info_obj.usergroup_set.remove(group_obj)
#user_info_obj.usergroup_set.remove(*group_objs)
 
# 获取数据
#print group_obj.user_info.all()
#print group_obj.user_info.all().filter(id=1)
 
# 获取数据
#print user_info_obj.usergroup_set.all()
#print user_info_obj.usergroup_set.all().filter(caption='CEO')
#print user_info_obj.usergroup_set.all().filter(caption='DBA')
多对多操作

 

 

 

一对多:实例(表是创建表基本结构时候的UserInfo和UserType):

 通过查询UserInfo表所有user,关联UserType表中的caption,这里直接用双下划线进行连表操作:

user_type__caption
    ret = UserInfo.objects.all().values("user","user_type__caption")
    print(ret)
#结果:
    
    print(ret.query)
#结果:SELECT `app01_userinfo`.`user`, `app01_usertype`.`caption` FROM `app01_userinfo` INNER JOIN `app01_usertype` ON (`app01_userinfo`.`user_type_id` = `app01_usertype`.`nid`)

 

查找用户类型是管理员的所有用户

正向查找:

连表查找UserType表中caption=管理员,再取出user、user_type__caption

  ret = UserInfo.objects.filter(user_type__caption="管理员").values("user","user_type__caption")
    print(ret)
    #[{'user_type__caption': '管理员', 'user': 'alex'}, {'user_type__caption': '管理员', 'user': 'eric'}]

 反向查找:

    ret = UserType.objects.filter(caption="管理员").values("nid","userinfo__user")
    print(ret)
    #[{'nid': 1, 'userinfo__user': 'alex'}, {'nid': 1, 'userinfo__user': 'eric'}]

一对多总结:

外键查关联表的主键是正向:表中有Foreignkey找另一张关联表的primarykey

主键查关联表的外键是反向:表中有primarykey找另一张关联表的 Foreignkey

Django之Model_第6张图片

 

 

多对多实例:

创建表结构:

#方法一:
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)

    h2g = models.ManyToManyField(Host)

#方法二:
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()会自动生成第三张表

自定义第三张表:

Django之Model_第7张图片

 

#方法三
class HostToGroup(models.Model):
    hgid = models.AutoField(primary_key=True)
    host_id = models.ForeignKey("Host")
    group_id = models.ForeignKey("Group")
    status = models.IntegerField()  #自定义第三张表可以添加字段

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)

    h2g = models.ManyToManyField(Host,through="HostToGroup")

 

我们使用方法一创建并添加数据:

    # #Host插入数据
    Host.objects.create(hostname="c1",ip="1.1.1.1")
    Host.objects.create(hostname="c2",ip="1.1.1.2")
    Host.objects.create(hostname="c3",ip="1.1.1.3")
    Host.objects.create(hostname="c4",ip="1.1.1.4")
    Host.objects.create(hostname="c5",ip="1.1.1.5")

    #Group插入数据
    Group.objects.create(name="财务部")
    Group.objects.create(name="人事部")
    Group.objects.create(name="公关部")
    Group.objects.create(name="技术部")
    Group.objects.create(name="运营部")
    Group.objects.create(name="销售部")
    Group.objects.create(name="客服部")
插入数据

向关系表中添加数据: 

注:h2g在Group里面,通过Group可以查看第三张表数据

    obj = Group.objects.get(gid=1)
    ret = obj.h2g.all()  #第三张表的所有数据
    print(ret)
#因为现在第三张表中还没有插入数据,所以ret是空列表

正向操作:将多台机器分配给一组:财务组

    obj = Group.objects.get(gid=1)
    #方法一
    h1 = Host.objects.get(hid=1)
    obj.h2g.add(h1)
    #方法二
    h = Host.objects.filter(hid__gt=3)
    obj.h2g.add(*h)

反向操作:将一台机器,分给多个组:_set

    #方法一
    # h = Host.objects.get(hid=1)
    # obj = Group.objects.get(gid=1)
    # obj.h2g.add(h)

    #方法二:基于Host表中隐含有group_set
    # h = Host.objects.get(hid=1)
    # h.group_set.add(*Group.objects.filter(gid__gt=2))

补充:

    # Django默认创建第三张表时,添加方法补充
    h = Host.objects.get(hid=1)
    # h.group_set.add(Group.objects.get(gid=1))
    h.group_set.add(1)
    # h.group_set.add(*Group.objects.filter(gid__gt=1))
    h.group_set.add(*[2,3])

 

多对多总结:

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

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

 

remove:只删除关系表中的数据

    h = Host.objects.get(hid=1)
    h.group_set.remove(*Group.objects.filter(gid__gt=3))

delete:既删除关系表中的数据,也删除基础表(Group表)中的数据。注:all()是Queryset,里面有delete方法

    h = Host.objects.get(hid=1)
    h.group_set.all().delete()

 

注:Django自动帮我们在关系表中创建了联合唯一索引,所以改数据时,不能有重复,不然会报错

set:删除、添加。

注:如果关系表中有要设置的数据,保留设置数据,如果有其他数据,会将其他数据删除。

set设置filter数据列表,不用加*
    h = Host.objects.get(hid=1)
    g = Group.objects.filter(gid=10)
    h.group_set.set(g)
   #set设置filter数据列表,不用加*
    h = Host.objects.get(hid=1)
    g = Group.objects.filter(gid__gt=11)
    h.group_set.set(g)

 

get_or create 和 uptate_or create :如果关系表中有就不创建,基础表也不创建;如果关系表中没有就创建,基础表也创建。两者一样。

    h = Host.objects.get(hid=1)
    r = h.group_set.get_or_create(name="财务部")
    r = h.group_set.update_or_create(name="技术部")

 

通过方法三自定义创建关联表,自定义关系表不能使用add,set,create命令,或者通过直接赋值方式来创建关系,可以通过all,filter获取

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:
        # index_together = ("host_id","group_id")  #创建唯一索引
        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)

    h2g = models.ManyToManyField(Host,through='HostToGroup')
自定义关系表

注:联合索引

Django之Model_第8张图片

数据库:

 

总结:

直接使用M2M创建可以操作的:

获取值filter、all,add添加,remove删除,filter.delete()删除,set设置(删除、添加),get_or_create和update_or_create创建。

补充:

自定义第三张关系表:

获取值:filter、all

 

实例:Q

先将文件进行配置

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

 

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

 

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',
]
settings之csrf注销

 

import pymysql
pymysql.install_as_MySQLdb()
__init__.py

 

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)
models.py

 

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

 

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')
views.py

 


"en">

    "UTF-8">
    Title
    


    
class="condition">
class="item clearfix">
class="icon left" οnclick="AddCondition(this);">+
class="left">
class="left">"text" name="name" />
"button" οnclick="Search();" value="搜索" />
class="container">
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]

2、option的value属性值要和创建表里面的字段一样,每次ChangeName时$(this).val(),可以获得当前选中标签的属性,再找到后面的input,将获取的属性值设置成input的name属性名。也就是option选图书类型时,value是book_type__caption,后面的input框的name属性就是book_type__caption。代码结合注释看会更加理解。

3、发ajax时注意,不管urls.py路由配置有没有加/,发ajax请求时,url结尾都要加/,不加会出错:APPEND_SLASH 。

4、403错误是需要注释settings里面的csrf。

5、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,有了序列化类就可以。

 

转载于:https://www.cnblogs.com/0820-zq/p/5798130.html

你可能感兴趣的:(Django之Model)