CRM中QueryDict和模型表知识补充

CRM中QueryDict和模型表知识补充

1.QueryDict的用法

request.GET的用法：
1.在页面上输入：http://127.0.0.1:8000/index/
print(request.GET,type(request.GET))
<QueryDict: {}> <class 'django.http.request.QueryDict'>
在收到GET请求后，Django会将后面的参数以字典的形式接收。如果无参数就显示空字典
2.在页面上输入：http://127.0.0.1:8000/index/?page=2
<QueryDict: {'page': ['2']}> <class 'django.http.request.QueryDict'>
3.request.GET["name"]="jerd"  #直接进行添加操作，操作失败
查看源码：

from django.http.request import QueryDict
  class QueryDict(MultiValueDict):
        _mutable = True
        _encoding = None
        def __init__(self, query_string=None, mutable=False, encoding=None):pass
    在调用时，mutable=False，因此要向对request.GET接收的值及逆行更改。需要手动设置 _mutable = True
request.GET._mutable = True
request.GET["name"] = "jerd"
print(request.GET, type(request.GET))
<QueryDict: {'page': ['2'], 'name': ['jerd']}>

4.urlencode 将request.GET中的值拼接到一起，组成新的字符串

from django.http.request import QueryDict
request.GET._mutable = True
request.GET["name"] = "jerd"
print(request.GET.urlencode())  #page=2&name=jerd  类型为字符串

5.deepcopy(request.GET)
在对GET来的数据处理时，一般都另复制一份进行操作，使用deepcopy
import copy
    params=copy.deepcopy(request.GET)
    params["name"]="zhao"
    print(params)   #<QueryDict: {'name': ['zhao']}>
    为什么能直接添加了呢？
    在request.GET中mutable默认为False，需要设置为True才能添加数据，而在拷贝的request.GET中却可以
    直接添加，原因是在拷贝之后，mutable值为True
    查看其源码：即不管是深拷贝还是浅拷贝，mutable值均为True

 def __copy__(self):
        result = self.__class__('', mutable=True, encoding=self.encoding)
        pass

    def __deepcopy__(self, memo):
        result = self.__class__('', mutable=True, encoding=self.encoding)
        memo[id(self)] = result
        pass
 print("params的mutable值为：",params._mutable)  #params的mutable值为： True

2.ORM模型表知识补充

1.在models中创建模型表

class Book(models.Model):
    nid = models.AutoField(primary_key=True)
    title = models.CharField( max_length=32,verbose_name="书名")
    publishDate=models.DateField(verbose_name="出版日期")
    price=models.DecimalField(max_digits=5,decimal_places=2,verbose_name="价格")
    publish=models.ForeignKey(to="Publish",to_field="nid",on_delete=models.CASCADE,verbose_name="出版社")
    authors=models.ManyToManyField(to='Author',verbose_name="作者")
    def __str__(self):
        return self.title

2.根据模型表的类名取出app名和字符串类型的表名：

如在views中操作：

from app01 import models
app_name=models.Book._meta.app_label
model_name=models.Book._meta.model_name
print("app名字是:%s表名是%s"%(app_name,model_name))
app名字是:app02表名是food

3.通过字符串类型的字段名找到相应字段对象

Book类中的title，price，publish都是字段对象，max_length，verbose_name均是他们的属性
可直接调用，如title.max_length
通过"title"找到title对象：
obj = models.Book.model._meta.get_field("title")
print(obj.verbose_name)  #书名

4.根据字段对象，找到其关联的表中的所有对象

related_data=publish.rel.to.objects.all()

3.Q查询补充

    from django.db.models import Avg,Count
        from app01.models import Book
      Book.objects.filter(title="go") #Out[3]: <QuerySet [<Book: go>]>
      #查询名称为go和价格为100的书籍
      Book.objects.filter(title="go",price=100) #Out[4]: <QuerySet []>
      ##使用Q查询
      from django.db.models import Q
      查询题目为go，价格不是100的书籍
      Book.objects.filter(Q(title="go")&~Q(price=100)) #~非
          <QuerySet [<Book: go>]>
      Book.objects.filter(Q(title="go")&Q(price=100))
        Out[7]: <QuerySet []>
      Book.objects.filter(Q(title="go")|Q(price=100))
      Out[8]: <QuerySet [<Book: go>]>

Q().children，通过字段字符串查询

q=Q()
        ##查询出title字段中值为go的对象
        q.children.append(("title","go"))
        Book.objects.filter(q)
        Out[11]: <QuerySet [<Book: go>]>
        ##查询出title字段中值含有g的对象
        q.children.append(("title__contains","g"))
        Book.objects.filter(q)
        Out[13]: <QuerySet [<Book: go>]>
        q=Q()  #不同的字段之间的关系默认为and
        q.children.append(("title__contains","g"))
        q.children.append(("price",100))
        Book.objects.filter(q)
        Out[17]: <QuerySet []>
        q=Q()
        q.connector="or"  #不同的字段之间的关系更改为or
        q.children.append(("title__contains","g"))
        q.children.append(("price",100))
        Book.objects.filter(q)
        Out[22]: <QuerySet [<Book: go>]>

4.HTML中模板

1.{% include xxx.html %} 获取指定页面的所有内容
2. {% extends 'base.html' %} 当前HTML文件继承base.html
3.在模板中写上，{% block xxxx %}{% endblock %},在当前页面中可自义其中的内容
{% block page-css %}
  pass
{% endblock %}
5.Xadmin页面的完整代码：
Xadmin/views.py

#根据ModelAdmin源码写
from django.conf.urls import url
from  django.shortcuts import render,HttpResponse,redirect
from django.forms import ModelForm
from django.urls import reverse
from django.utils.safestring import  mark_safe
from Xadmin.page import Pagination
from django.db.models import Q
class ShowList(object):
    def __init__(self,config,data_list,request):
        self.config=config  #config是Modelxadmin的对象
        self.data_list=data_list
        self.request=request
    ##配置分页设置：
        current_page = self.request.GET.get("page")
        pagination = Pagination(current_page, self.data_list.count(), "%s" % self.config.get_list_url(), self.request.GET,
                                per_page_num=3)
        self.pagination=pagination
        self.model_list = self.data_list[pagination.start:pagination.end]
    #批量处理
        self.actions=self.config.get_action()
        self.list_filter=self.config.list_filter
    #将函数名和描述值处理后在页面显示出来
    def new_actions(self):
        temp=[]
        for action in self.actions:
            temp.append({
                "name":action.__name__,
                "desc":action.short_description
            })
        return temp
    def get_header(self):
        # 处理表头 [check，'title', 'prcie',edit]
        # 1.需要判断传的列表中的内容是函数名还是字符串
        # 2.如果是字符串，判断是"__str__"还是其他的
        head = []
        # for field in self.list_display:
        for field in self.config.new_list_display():
            if isinstance(field, str):
                if field == "__str__":
                    val = self.config.model._meta.model_name.upper()  # 如果没定义样式类，表头就显示操作表的名字的大写
                else:
                    # class Book(models.Model):
                    #     title = models.CharField(max_length=32, verbose_name="书名")
                    #     price = models.DecimalField(max_digits=5, decimal_places=2, verbose_name="价格")
                    # 如果是字段字符串，让表头显示其定义的中文表头。title是字段对象，找到title后title.verbose_name 获取这个属性值
                    obj = self.config.model._meta.get_field(field)
                    val = obj.verbose_name
            else:
                val = field(self.config, is_header=True)
            head.append(val)
        return head
    def get_body(self):
        content = []
        for obj in self.model_list:
            temp = []
            # for field in self.list_display:#自定义的样式类中有可能放的是自定义的函数名[check，'title', 'prcie',edit]
            for field in self.config.new_list_display():
                # 需要判断传的列表中的内容是函数名还是字符串
                if isinstance(field, str):  # 判断数据类型
                    # 处理多对多的字段方法二：判断是不是ManytoMany类型
                    from django.db.models.fields.related import ManyToManyField
                    try:
                        # 如果是__str__ 走到这会报错，因此使用抛出异常处理
                        many_obj = self.config.model._meta.get_field(field)  # 取到字段对象
                        if isinstance(many_obj, ManyToManyField):
                            t = []
                            for i in getattr(obj, field).all():
                                t.append(i.name)
                            val = " | ".join(t)
                        else:
                            # val=getattr(obj,field)  #相当于obj.title,obj.price 其中obj.__str__会自动触发这个方法
                            # 判断改字段是否在list_display_link，如果在，就设置成标签形式，不再就正常显示
                            if field in self.config.list_display_link:
                                edit_url = self.config.get_change_url(obj)
                                val = mark_safe("<a href='%s'>%s</a>" % (edit_url, getattr(obj, field)))
                            else:
                                val = getattr(obj, field)
                    except Exception as e:
                        val = getattr(obj, field)
                else:
                    val = field(self.config, obj, )  # 定义的方法，obj为这个方法执行的哪条数据对象
                temp.append(val)
            content.append(temp)
        return content

    # def get_page(self):
    #     # data_list = self.config.model.objects.all()
    #     current_page = self.request.GET.get("page")
    #     content=self.get_body()
    #     pagination = Pagination(current_page,  self.data_list.count(), "%s" % self.config.get_list_url(), self.request.GET,
    #                             per_page_num=3)
    #     model_list = content[pagination.start:pagination.end]
    #     return pagination, model_list
    def get_filter_link_tags(self):
        # link_tags={"publish":["a","a"],"author":["a","a"]}
        link_tags={}
        from copy import deepcopy
        for filter_field in self.list_filter:
            # /Xadmin/app01/book/?page=2
            params = deepcopy(self.request.GET)#将后面的参数以字典的形式接收 {'page':2}
            current_id=self.request.GET.get(filter_field)
            filter_field_obj=self.config.model._meta.get_field(filter_field)
            #得到字段对象关联表的所有对象
            related_data_list=filter_field_obj.rel.to.objects.all()
            temp=[]
            for obj in related_data_list:
                params[filter_field]=obj.pk # {"authors":2}
                _url=params.urlencode()
                # _url="%s=%s"%(filter_field,obj.pk)
                if current_id==str(obj.pk):
                    s = "<a class='item' href='?%s'>%s</a>" % (_url, str(obj))
                else:  
                    s="<a href='?%s'>%s</a>"%(_url,str(obj))
                temp.append(mark_safe(s))
            link_tags[filter_field]=temp
        return link_tags
class Modelxadmin(object):
    model_form_class = None  # 不设定的如果样式类中无model_form_class会报错
    list_display_link = []
    search_fields = []
    actions=[]
    list_filter = []
    list_display=["__str__"] #设置Modelxadmin的静态属性，即当注册的对象没使用样式类时，使用Modelxadmin的样式属性
    def __init__(self,model,site):  #如果传的是book，model就是Book 传的是publish，model就是Publiah
        self.model=model
        self.site=site
        self.model_name = self.model._meta.model_name
        self.app_name = model._meta.app_label

    # 定义ModelForm组件。 由于每张表中的字段都不同，Modelxadmin的ModelForm组件不能显示错误信息
    #如果要显示出错误信息，就在自己样式类中自当义ModelForm组件
    def get_model_form_class(self):
        if  self.model_form_class:
            print(666)
            return self.model_form_class  #得到自定义BookModelForm类
        else:
            #自定义类中没设置MOdelform的将model_form_class=None
            from django.forms import ModelForm
            class DemoModelForm(ModelForm):
                class Meta:
                    model=self.model
                    fields="__all__"
            return DemoModelForm
    ##反向解析得到路径，如果在函数中使用 list_url="%s/%s/"%(self.app_name,self.model_name)
    ##相当于是在当前路径后拼接，会报错
    def get_add_url(self):
        url_name="{}/{}_add".format( self.app_name, self.model_name)
        _url=reverse(url_name)
        return _url
    def get_list_url(self):
        url_name = "{}/{}_list".format(self.app_name, self.model_name)
        _url = reverse(url_name)
        return _url
    def get_change_url(self,obj):
        url_name = "{}/{}_change".format(self.app_name, self.model_name)
        _url = reverse(url_name,args=(obj.pk,))
        return _url
    def get_del_url(self,obj):
        url_name = "{}/{}_del".format(self.app_name, self.model_name)
        _url = reverse(url_name,args=(obj.pk,))
        return _url
    # 选择按钮  编辑 删除
    def edit(self, obj=None, is_header=False):
        if is_header:  # 此时作表头处理
            return "操作"
        else:
            v=self.get_change_url(obj)
            return mark_safe("<a href='%s'>编辑</a>" %v)
    def delete(self, obj=None, is_header=False):
        if is_header:  # 此时作表头处理
            return "操作"
        v = self.get_del_url(obj)
        return mark_safe("<a href='%s'>删除</a>" %v)
    def check(self, obj=None, is_header=False):
        if is_header:  # 此时作表头处理
            return "选择"
        return mark_safe("<input type='checkbox' name='selected' value='%s'>"%obj.pk)
    #构建新的list_dispaly
    def new_list_display(self):
        temp=[]
        temp.append(Modelxadmin.check)
        temp.extend(self.list_display)
        #判断是否加编辑操作
        if not self.list_display_link:
            temp.append(Modelxadmin.edit)
        temp.append(Modelxadmin.delete)
        return temp
    ##搜索
    def get_search(self,request):
        search_condition=Q()
        search_condition.connector='or'
        search_value = request.GET.get("search_value")
        if search_value:
            for search_field in self.search_fields:
                search_condition.children.append((search_field+"__icontains", search_value))  #元祖
        return search_condition
    ##批处理：得到注册对象样式类中指定的操作，并为所有的注册对象添加上删除操作
    def all_delete(self,request,queryset):
        queryset.delete()
        list_url=self.get_list_url()
        return redirect("%s"%list_url)
    all_delete.short_description="批量删除"
    def get_action(self): #将批量删除和样式类中的actions合到一起
        temp=[]
        temp.append(self.all_delete)
        temp.extend(self.actions) #迭代添加
        return temp  #将得到的temp作为ShowList的一个属性
    def list_view(self, request): #self是Modelxadmin的实例对象，要么是自定义样式类的实例对象
        type=request.GET.get("name")
        if not type:type=""
        if request.method=='POST': #批量操作
            action=request.POST.get("action")  #哪种操作
            print("操作是",action)
            selected_pk=request.POST.getlist("selected") #操作的数据
            action_obj=self.model.objects.filter(pk__in=selected_pk)
            action=getattr(self,action)
            ret=action(request,action_obj)
            return ret
        #print(self.model)  #用户调用的哪张表，self.model就是哪张表  <class 'app02.models.Order'>
        search_condition=self.get_search(request)
        ##过滤查询：
        filter_condition=Q()
        for filter_field,val in request.GET.items():
            ##当选择分页时，页面上会把page=2传过来，仍走这一步，但是表中并没有这个字段，所以会报错
            if filter_field not in ['page',"search_value"]:
                filter_condition.children.append((filter_field,val))
        data_list = self.model.objects.filter(filter_condition).filter(search_condition) #search_condition有值，就按值搜索，无值就搜索全部
       #data_list = self.model.objects.all()  # 取出每一条数据的对象，data_list[0].字段名(title) 就能得到相应的数据
        show_list=ShowList(self,data_list,request)  #self是 Modelxadmin的实例对象

        # 获取增加页面的url 点击增加的时候，跳到增加页面。自动拼接add_url="add"
        return render(request,"list.html",{"show_list":show_list,"add_url":self.get_add_url()})
    def add_view(self, request):
        # list_url="%s/%s/"%(self.app_name,self.model_name)
        DemoModelForm=self.get_model_form_class() #得到定义的ModelForm组件类
        if request.method=='POST':
            form_obj=DemoModelForm(request.POST)
            if form_obj.is_valid():
                form_obj.save()
                # return redirect(list_url)  #不能用，相当于在当前路径后面拼接
                return redirect(self.get_list_url())
            else:
                return render(request,'add_view.html',locals())
        form_obj = DemoModelForm()
        return render(request, 'add_view.html', locals())
    def change_view(self, request, id):
        DemoModelForm = self.get_model_form_class()  # 得到定义的ModelForm组件类
        change_obj=self.model.objects.get(pk=id)
        if request.method == 'POST':
            form_obj = DemoModelForm(request.POST,instance=change_obj)
            if form_obj.is_valid():
                form_obj.save()
                # return redirect(list_url)  #不能用，相当于在当前路径后面拼接
                return redirect(self.get_list_url())
            else:
                return render(request, 'change_view.html', locals())
        form_obj = DemoModelForm(instance=change_obj)
        return render(request, 'change_view.html', locals())
    def del_view(self, request, id):
        if request.method=='POST':
            self.model.objects.get(pk=id).delete()
            return redirect(self.get_list_url())
        return render(request,"del_view.html",{"url":self.get_list_url()})

    def get_url_2(self):
        temp = []
        # print("=====",model_name )
        # temp.append(url(r"^$", self.list_view))
        temp.append(url(r"^$", self.list_view,name="{}/{}_list".format( self.app_name, self.model_name)))
        temp.append(url(r"^add/$", self.add_view,name="{}/{}_add".format( self.app_name, self.model_name)))
        # temp.append(url(r"^(d+)/change/$", self.change_view,))
        temp.append(url(r"^change/(d+)/$", self.change_view,name="{}/{}_change".format( self.app_name, self.model_name) ))
        temp.append(url(r"^del/(d+)/$", self.del_view,name="{}/{}_del".format( self.app_name, self.model_name)))
        return temp
    @property
    def urls2(self):
        return self.get_url_2(), None, None

class XadminSite(object):
    def __init__(self, name='admin'):
        self._registry = {}
    def register(self, model, admin_class=None, **options):
        if not admin_class:
            admin_class = Modelxadmin #根据AdminSite源码，定义夜歌admin_class类
        self._registry[model] = admin_class(model, self) # {Book:ModelAdmin(Book)} self.model=Book
    def get_urls(self):
        temp = []
        print(self._registry)
        for model, xadmin_class in self._registry.items(): #xadmin_class=admin_class(model, self)是注册的模型表对象 ModelAdmin(Book)
            app_name = model._meta.app_label  # 拿到app的名字
            model_name = model._meta.model_name  # 拿到字符串类型的表名
            print("表名是:",model_name)
            temp.append(url(r"^{}/{}/".format(app_name, model_name), xadmin_class.urls2,))
            '''
              url(r"app01/book",ModelXadmin(Book,site).urls2)
              url(r"app01/publish",ModelXadmin(Publish,site).urls2)
              url(r"app02/order",ModelXadmin(Order,site).urls2)

            '''
        return temp

    @property
    def urls(self): #self就是XadminSite单例出来的对象
        return self.get_urls(), None, None
site=XadminSite() #生成单例对象

app01/xadmin.py

print("Xadmin app01")
from Xadmin.service.Xadmin import site,Modelxadmin
from  django.shortcuts import render,HttpResponse,redirect
from app01 import models
from django.utils.safestring import  mark_safe
from django.urls import reverse
from django.forms import ModelForm
from django.forms import widgets as wid #因为重名，所以起个别名
class BookModelForm(ModelForm):
    class Meta:
        model=models.Book
        fields="__all__"
        error_messages={
            "title":{"required":"该字段不能为空！"}
        }
        widgets = {
            " publishDate": wid.TextInput(attrs={"type": "date"})
        }
##将操作封装到类中
'''
class Operation():
    def edit(self, obj,is_header):
        if is_header:  # 此时作表头处理
            return "操作"
        else:
            url_name = "{}/{}_change".format(self.app_name, self.model_name)  # BookConfig中没有self.app_name，就去Modelxadmin找
            v = reverse(url_name, args=(obj.pk,))
            return mark_safe("<a href='%s'>编辑</a>" % v)
    def delete(self, obj, is_header):
        if is_header:  # 此时作表头处理
            return "操作"
        return mark_safe("<a href='del/%s/'>删除</a>" % obj.pk)

    def check(self, obj, is_header):
        if is_header:  # 此时作表头处理
            return "选择"
        else:print(777)
        return mark_safe("<input type='checkbox'>")
'''
class BookConfig(Modelxadmin):
    #自定义方法,obj默认为None，即在处理表头时用不到，is_header默认为False，在处理表头时用得到，处理表单内容时用不到
    #href='%s/change/'自动拼接路径
    ##在每个对象中添加删除，编辑，选择按钮
    '''
     def edit(self, obj=None,  is_header=False):
        if is_header:  # 此时作表头处理
            return "操作"
        ##反向解析url
        url_name="{}/{}_change".format( self.app_name, self.model_name) #BookConfig中没有self.app_name，就去Modelxadmin找
        v = reverse(url_name, args=(obj.pk,))
        return mark_safe("<a href='%s'>编辑</a>" % v)
        #自动拼接路由
        # return mark_safe("<a href='change/%s/'>编辑</a>"%obj.pk) 
    
    def delete(self, obj=None, is_header=False):
        if is_header:  # 此时作表头处理
            return "删除"
        return mark_safe("<a href='del/%s/'>删除</a>" % obj.pk)

    def check(self, obj=None, is_header=False):
        if is_header:  # 此时作表头处理
            return "选择"
        return mark_safe("<input type='checkbox'>")
    '''
    ##处理多对多的字段方法一：
    '''
     def display_authors(self,obj=None, is_header=False):
        if is_header:
            return "作者名称"
        s=[]
        for author in obj.authors.all(): #必须使用all(),得到所有的作者对象
            s.append(author.name) #取出每个作者对象的name属性
        val=" | ".join(s)
        return mark_safe(val)

    list_display = [check, "title", "price", "publish", display_authors, edit, delete]
    '''
    ###将编辑，删除，批量操作封装到一个类中,但是需要在每个样式类中给设定
    '''
     def check(self,obj=None, is_header=False):return super().check(obj, is_header)
    def edit(self,obj=None, is_header=False):return super().edit(obj, is_header)
    def delete(self,obj=None,  is_header=False):return super().delete(obj, is_header)
    list_display=[check,"title","price","publish","authors",edit,delete]
    
    '''
    model_form_class = BookModelForm
    list_display = ["title", "price", "publish", "authors"]
    list_display_link=["title"]
    search_fields = ["title", "price"]
    #批量处理
    def all_update(self,request,queryset): #queryset为数据对象
        queryset.update(price=998)
        list_url = self.get_list_url()
        return redirect("%s" % list_url)
    all_update.short_description="批量初始化"
    actions=[all_update,]
    #设置过滤：
    list_filter=["publish","authors"]


site.register(models.Book,BookConfig)
class PublishConfig(Modelxadmin):
    list_display=["name","city","email"]
site.register(models.Publish,PublishConfig)
class AuthorConfig(Modelxadmin):
    list_display=["name","age"]
site.register(models.Author,AuthorConfig)

site.register(models.AuthorDetail)

app02/xadmin.py

print("Xadmin app02")
from Xadmin.service.Xadmin import site
from Xadmin.service.Xadmin import Modelxadmin
from app02 import models
class OrderConfig(Modelxadmin):
    list_display=["title","addr"]
site.register(models.Order)
# class FoodConfig(Modelxadmin):
#     list_display=["title","price"]
site.register(models.Food)
print(site._registry)

list.HTML

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Title</title>
     <link href="/static/bootstrap/css/bootstrap.min.css" rel="stylesheet">
     <link href="/static/dashboard.css" rel="stylesheet">
    <style>
        .item{
            background-color: #985f0d;
        }
    </style>
</head>
<body>
<div class="container-fluid">
    <div class="row">
        <div class="col-sm-3 col-md-2 sidebar">
            <ul class="nav nav-sidebar">
                <li class="display active"><a href="/Xadmin/app01/book/ ">图书列表页<span class="sr-only">(current)</span></a>
                </li>
                <li class="display active"><a href="/Xadmin/app01/publish/">出版社列表页</a></li>
                <li class="display active"><a href="/Xadmin/app01/author/">作者列表页</a></li>
                 <li class="display active"><a href="/Xadmin/app02/order/">订单列表页</a></li>
                 <li class="display active"><a href="/Xadmin/app02/food/">美食列表页</a></li>
            </ul>

        </div>
        <div class="col-sm-7 col-sm-offset-3 col-md-7 col-md-offset-2 main">
            <h1 class="page-header" STYLE="color: #dff0d8">管理</h1>

            <div class="panel panel-success">
                <!-- Default panel contents -->
                <div class="panel-heading">信息 <i class="fa fa-thumb-tack pull-right"></i></div>
                <div class="panel-body">
                        <div class="row" style="margin-bottom: 15px">
                            <div class="col-md-4">
                                {% if  show_list.config.search_fields %}
                                     <div class="input-group">
                                     <form action="" method="get">

                                        <span class="input-group-btn">
                                             <input type="text" name="search_value" class="form-control" placeholder="Search for..." style="display: inline-block">
                                            <button class="btn btn-default" >搜索</button>
                                        </span>
                                     </form>
                                </div><!-- /input-group -->
                                {% endif %}

                            </div><!-- /.col-md-4 -->
                            <div class="col-md-1 pull-right">
                                 <a class="btn btn-success" href="{{ add_url }}">新增</a>
                            </div>
                    </div><!-- /.row -->
                        <div class="row" style="margin-bottom: 15px">
                            <form action="" method="post">
                                {% csrf_token %}
                                <div class="col-md-3" style="margin-bottom: 15px">
                                     <div class="input-group">
                                        <span class="input-group-btn" >
                                            <select name="action" id="" class="form-control">
                                                <option value="">------------------</option>
                                                {% for foo in show_list.new_actions %}
                                                     <option value="{{ foo.name }}">{{foo.desc  }}</option>
                                                {% endfor %}
                                            </select>
                                            <button class="btn btn-default" >GO</button>
                                        </span>
                                     </div>
                                </div>
                               <table class="table table-bordered">
                                   <thead>
                            <tr>
                                 <th>序号</th>
                                {% for foo in show_list.get_header %}
                                    <th>{{ foo }}</th>
                                {% endfor %}
                            </tr>
                       </thead>
                                   <tbody>
                                {% for foo in show_list.get_body %}
                                   <tr>
                                      <td>{{  forloop.counter }}</td>
                                       {% for foo1 in foo %}
                                            <td>{{ foo1 }}</td>
                                       {% endfor %}

                                  </tr>
                              {% endfor %}
                        </tbody>
                               </table>

                            </form>
                        </div>
                    <ul  class="pull-right">
                        {{show_list.pagination.page_html|safe }}
                    </ul>

                </div>

            </div>

        </div>
        <div class="col-sm-2">
            {% for filter_filed,link_tag_list in show_list.get_filter_link_tags.items  %}
                <p>By {{ filter_filed.upper }}</p>
                {% for link_tag in link_tag_list  %}
                <p>{{ link_tag }}</p>
                {% endfor %}
            {% endfor %}

        </div>
    </div>
</div>

<script src="/static/jquery-3.3.1.js"></script>
<script src="/static/bootstrap/js/bootstrap.min.js"></script>





{#未使用样式#}

{#[{'title': '江南', 'addr': '北京'}, {'title': '醉赤壁', 'addr': '上海'}, {'title': '杀手', 'addr': '广州'}]#}
{#<p>#}
{#    <span>序号</span>#}
{#    {% for foo in head %}#}
{#        <span>{{ foo }}</span>#}
{#    {% endfor %}#}
{#</p>#}
{##}
{#{% for foo in content %}#}
{#    <P>#}
{#      <span>{{ forloop.counter }}</span>#}
{#      {% for foo1 in foo %}#}
{#       <span>{{ foo1 }}</span>#}
{#    {% endfor %}#}
{#    </P>#}
{#{% endfor %}#}

</body>
</html>

models.py

from django.db import models

# Create your models here.
class Author(models.Model):
    nid = models.AutoField(primary_key=True)
    name=models.CharField( max_length=32,verbose_name="作者")
    age=models.IntegerField(verbose_name="年龄")
    # 与AuthorDetail建立一对一的关系
    authorDetail=models.OneToOneField(to="AuthorDetail",on_delete=models.CASCADE)
    def __str__(self):
        return self.name
class AuthorDetail(models.Model):
    nid = models.AutoField(primary_key=True)
    birthday=models.DateField()
    telephone=models.BigIntegerField(verbose_name="手机号")
    addr=models.CharField( max_length=64,default="北京",verbose_name="地址")
    def __str__(self):
        return self.birthday
class Publish(models.Model):
    nid = models.AutoField(primary_key=True)
    name=models.CharField( max_length=32,verbose_name="出版社")
    city=models.CharField( max_length=32,verbose_name="地址")
    email=models.EmailField()
    def __str__(self):
        return self.name

class Book(models.Model):
    nid = models.AutoField(primary_key=True)
    title = models.CharField( max_length=32,verbose_name="书名")
    publishDate=models.DateField(verbose_name="出版日期")
    price=models.DecimalField(max_digits=5,decimal_places=2,verbose_name="价格")
    def __str__(self):
        return self.title

    # 与Publish建立一对多的关系,外键字段建立在多的一方
    publish=models.ForeignKey(to="Publish",to_field="nid",on_delete=models.CASCADE,verbose_name="出版社")
    # 与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个，自动创建第三张表
    authors=models.ManyToManyField(to='Author',verbose_name="作者")

    def __str__(self):
        return self.title