使用 admin 管理后台

使用 admin 管理后台
    1、基本管理
    2、高级管理
        1、在 admin.py 中创建自定义管理类，以便实现以下高级功能
            1、定义 EntryAdmin 类
                继承自 admin.ModelAdmin
                class EntryAdmin(admin.ModelAdin):
                    ... ...

                admin.site.register(Entry,EntryAdmin)

            2、允许增加的属性
                1、list_display
                    在响应的页面展示哪些字段
                    取值可以是由属性名称所组成的元组
                    ex:
                    list_display=('name','age','price')
                2、list_display_links
                    生成一个到具体页面的超链接，取值必须要出现在 list_display 中,也是一个元组
                    ex:
                    list_display_links=('name','age')
                3、list_editable
                    定义可以直接在外层进行修改的字段们
                    注意：list_editable的值不能出现在list_display_links，取值也是元组
                    ex:
                        list_editable=('price')
                4、search_fields
                    添加允许被搜索的字段，取值是一个元组
                    ex:
                        search_fields=('title','publication_date')
                5、list_filter
                    右边增加一个过滤器
                    取值是由属性名组成的元组
                    ex:
                        list_filter=('title','publication_date')
                6、date_hierarchy
                    顶部增加事件选择器，所以取值必须是DateField 的字符串
                    ex:
                        date_hierarchy='publication_date'
                7、fields
                    指定页面上显示哪些属性，并且按照什么样的顺序显示
                    ex:
                        fields=('name','country')
                8、fieldsets
                    对现有的显示属性进行分组
                    fieldsets=(
                        元组1 - ('分组名称',{'fields':(),'classes':('collapse')})
                        元组2 - ()
                    )

    1、一对一查询(1:1)
        1、什么是一对一
            A表中的一条记录，只能与B表中的一条记录进行匹配
            典型代表：一夫一妻制
            数据库的实现：
                A ：有主键
                B ：有主键，外加一列，该列的内容为A表的主键值，并且增加唯一约束
        2、语法
            models.OneToOneField(Entry)
        3、查询
            class Wife:
                ... ...
                #在 Wife 中添加了对Author的引用
                author = models.OneToOneField(Author)
            //正向查询 ：通过 wife 找 author
            w = Wife.objects.get(id=1)
            a = w.author

            //反向查询 ：通过 author 找 wife
            a = Author.objects.get(id=9)
            w = a.wife        
    2、一对多查询 / 多对一查询(1:M)
        1、什么是一对多的查询
            A表中的一条数据可以与B表中的任意多条记录匹配
            一对多在数据库中的体现：
                通过 ForeignKey 外键约束实现一对多效果
                Author 表，作为主表，包含主键
                Book 表，作为子表，包含一个外键，引用在Author的主键
        2、语法
            使用 外键(Foreign Key)
            name = models.ForeignKey(Entry)
        3、查询
            class Book(models.Model):
                ... ...
                author = models.ForeignKey(Author)
            
            正向查询 ：
                book = Book.objects.get(id=1)
                author = book.author;
            反向查询
                author = Author.objects.get(id=9)
                books=author.book_set.all()
                book_set : 外键对象_set

    3、多对多查询
        1、什么是多对多
            A表中的一条记录可以与B表中的任意多条记录向匹配，同时 B 表中的每一条记录也可以与A表中的任意多条记录相匹配

            数据库中：通过创建中间表的方式来完成M:N操作

        2、语法
            models.ManyToManyField()
            注意：任何一个实体类中，都可以
        3、查询
            class Author(models.Model):
                ....
                publish=models.ManyToManyField(Publish)
            
            1、正向查询 - 在 Author 中查询 Publish
                author=Author.objects.get(id=9)
                pub_list = author.publish.all()

                通过 关联属性.all()
            2、反向查询 - 在 Publish 中查询 Author
                pub = Publish.objects.get(id=1)
                au_list=pub.author_set.all()